@depup/typebox 1.3.27-depup.0 → 1.3.34-depup.0

package/build/system/settings/settings.mjs

@@ -1,8 +1,12 @@
 import { Guard } from '../../guard/index.mjs';
+// -------------------------------------------------------------------
+// State
+// -------------------------------------------------------------------
 // Internal mutable state
 const settings = {
     immutableTypes: false,
     maxErrors: 8,
+    maxParseErrors: 1,
     maxInstantiationCount: 128,
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
@@ -10,10 +14,14 @@ const settings = {
     correctiveParse: false,
     unionPrioritySort: true
 };
+// -------------------------------------------------------------------
+// Reset
+// -------------------------------------------------------------------
 /** Resets system settings to defaults */
 export function Reset() {
     settings.immutableTypes = false;
     settings.maxErrors = 8;
+    settings.maxParseErrors = 1;
     settings.maxInstantiationCount = 128;
     settings.useAcceleration = true;
     settings.exactOptionalPropertyTypes = false;
@@ -21,6 +29,9 @@ export function Reset() {
     settings.correctiveParse = false;
     settings.unionPrioritySort = true;
 }
+// -------------------------------------------------------------------
+// Set
+// -------------------------------------------------------------------
 /** Sets system settings */
 export function Set(options) {
     for (const key of Guard.Keys(options)) {
@@ -30,6 +41,9 @@ export function Set(options) {
         }
     }
 }
+// -------------------------------------------------------------------
+// Get
+// -------------------------------------------------------------------
 /** Gets current system settings */
 export function Get() {
     return settings;

package/build/type/extends/inference.d.mts

@@ -22,7 +22,7 @@ export declare function TryRestInferable<Type extends TSchema>(type: Type): TTry
 export type TTryInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TInfer<infer Name extends string, infer Type extends TSchema> ? TInferable<Name, Type> : undefined)> = Result;
 export declare function TryInferable<Type extends TSchema>(type: Type): TTryInferable<Type>;
 type TryInferResults<Rest extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Rest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<{}, Head, Right> extends Result.TExtendsTrueLike ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
-declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result?: TSchema[]): TryInferResults<Rest, Right>;
+declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right): TryInferResults<Rest, Right>;
 export type TInferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
     [_ in Name]: TTuple<Results>;
 }>> : Result.TExtendsFalse);

package/build/type/extends/inference.mjs

@@ -45,8 +45,21 @@ export function TryInferable(type) {
     return (IsInfer(type) ? Inferrable(type.name, type.extends) :
         undefined);
 }
-function TryInferResults(rest, right, result = []) {
-    return Guard.ShiftLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+// function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result: TSchema[] = []): TryInferResults<Rest, Right> {
+//   return Guard.ShiftLeft(rest, (head, tail) =>
+//     Result.Match(ExtendsLeft({}, head, right),
+//       () => TryInferResults(tail, right, [...result, head]), // Stack Overflow Here (Large Rest)
+//       () => undefined),
+//     () => result) as never
+// }
+function TryInferResults(rest, right) {
+    const result = [];
+    for (const head of rest) {
+        if (!Result.IsExtendsTrueLike(ExtendsLeft({}, head, right)))
+            return undefined;
+        result.push(head);
+    }
+    return result;
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/build/type/extends/tuple.d.mts

@@ -16,7 +16,8 @@ type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftR
 type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
 type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
-type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArrayReduce<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : TExtendsTupleToArrayReduce<Inferred, Left, Right>);
 export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
 export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
 export {};

package/build/type/extends/tuple.mjs

@@ -47,11 +47,31 @@ function ExtendsTupleToTuple(inferred, left, right) {
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
+// function ExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>
+//   (inferred: Inferred, left: [...Left], right: Right):
+//     TExtendsTupleToArrayReduce<Inferred, Left, Right> {
+//   return (
+//     Guard.ShiftLeft(left, (head, tail) =>
+//       Result.Match(ExtendsLeft(inferred, head, right), inferred =>
+//         ExtendsTupleToArrayReduce(inferred, tail, right), // Stack Overflow Here (Large Left)
+//         () => Result.ExtendsFalse()),
+//       () => Result.ExtendsTrue(inferred))
+//   ) as never
+// }
+function ExtendsTupleToArrayReduce(inferred, left, right) {
+    for (const head of left) {
+        const result = ExtendsLeft(inferred, head, right);
+        if (!Result.IsExtendsTrueLike(result))
+            return result;
+        inferred = result.inferred; // (review-assign-to-argument)
+    }
+    return Result.ExtendsTrue(inferred);
+}
 function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : ExtendsTupleToArrayReduce(inferred, left, right));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, State([], []), left);

package/build/value/parse/parse.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { Settings } from '../../system/system.mjs';
-import { Arguments } from '../../system/arguments/index.mjs';
+import { EnableParseErrors, DisableParseErrors } from '../../system/settings/internal.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -18,8 +18,11 @@ export class ParseError extends AssertError {
     }
 }
 function Assert(context, type, value) {
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
     if (!Check(context, type, value))
-        throw new ParseError(value, Errors(context, type, value));
+        throw new ParseError(value, errors);
     return value;
 }
 // ------------------------------------------------------------------
@@ -43,5 +46,8 @@ export function Parse(...args) {
         return value;
     if (Settings.Get().correctiveParse)
         return Parser(context, type, value);
-    throw new ParseError(value, Errors(context, type, value));
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
+    throw new ParseError(value, errors);
 }

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-09-06T01:04:01.845Z",
+  "timestamp": "2026-09-20T01:02:49.478Z",
   "totalUpdated": 0
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@depup/typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript (with updated dependencies)",
-  "version": "1.3.27-depup.0",
+  "version": "1.3.34-depup.0",
   "keywords": [
     "typebox",
     "depup",
@@ -94,8 +94,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "typebox",
-    "originalVersion": "1.3.27",
-    "processedAt": "2026-09-06T01:04:02.687Z",
+    "originalVersion": "1.3.34",
+    "processedAt": "2026-09-20T01:02:50.022Z",
     "smokeTest": "passed"
   }
 }

package/readme.md

@@ -30,12 +30,12 @@ import Type from 'typebox'
 
 const T = Type.Object({                     // const T = {
   x: Type.Number(),                         //   type: 'object',
-  y: Type.Number(),                         //   properties: {
-  z: Type.Number()                          //     x: { type: 'number' },
-})                                          //     y: { type: 'number' },
+  y: Type.Number(),                         //   required: ['x', 'y', 'z']
+  z: Type.Number()                          //   properties: {
+})                                          //     x: { type: 'number' },
+                                            //     y: { type: 'number' },
                                             //     z: { type: 'number' }
                                             //   },
-                                            //   required: ['x', 'y', 'z']
                                             // }
 
 type T = Type.Static<typeof T>              // type T = {
@@ -69,9 +69,9 @@ License: MIT
 
 ## Type
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFonmXW32POvueHb7kafo16ix4ic2oBjCADsAzvACqC1FDgBeREQB0AeWIArVNJgAKAN5wbtu-Yc26cWYpVqN2y5RvAAJgBcOmi6AMowUMByAObmAJQANI7JKfbONoRoQXgQxqYweAk+cHIAhiCoQYKoYRFRsYmpTQ7pcGDYaLDAqApB3jaoIKXAADZVeuGRMVaY0EMw2YPDI3hwAL5xya2+gXDWmZX4SlPRq2tFG81X11v0dmUVfXAH2cf1Z0U3X99w23BLoyexR+INSfwyRFedRihTgwNBCLSd3sGDmpQW+ABKzhiNxdj+a3heIRrUJxLxrSgqAAjgBXYBU3YAbSJ5J+fzw-lhrLZXw5D1Q3N5JORNjwWKowtBrQAujypc1nIThJJVWr1XxnOF0cBpCqNQbDZxqAc4Kp1FpgjVtTBdQAeA4QDBmjwAPmuzlN5s8e3lCqarX8QTeMU+-u+rQFweh0TD4ZurSx0ZOfvjjiVQA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgYwgDsBneAVUdSjgF5EiA6APLEAVqhowAFAG84sufIWLZAemVw6TVu048plWcAAmALl5o+AZRhRg9AOYSAlABolb9wtVzCaU3ggiYjB4zvpw9ACGIKimyOZWNvZOrh6pnmqyUKgAjgCuwFkmcADaYaggEcAANrH8CbYOMhjQFTB+5ZVVeHAAvo5uXvJ4RiFwlH1pk1MDGXJ4kdGjYdMrK4NzHdVUqztT6wC6obvHHutg2GiwwKiMpnonD4rrBkUyPjH4zIl23T1HjwC4M9wlEPm8iH4vg1fv9AQ9gZsanAZMs4cdgbJ3pDrNDXKi0TsMZgWhE2vhEd18QS1rNZD0qdS9rN6Yzdl56ZR3nA2BxuGZUJYYKTgDQADzvCAYbnaAB8TLgXJ5OmRDNZaXWRlMUPssLV03WCw+2rsur1k3WiK1OPsqrNM16QA)
 
-TypeBox types are JSON Schema fragments that compose into more complex types. The library offers a set of types used to construct JSON Schema compliant schematics as well as a set of extended types used to model constructs native to the JavaScript language. The schematics produced by TypeBox can be passed directly to any JSON Schema compliant validator.
+TypeBox types are JSON Schema fragments that compose into more complex types. The library provides a core set of types for constructing JSON Schema compliant schematics, alongside extended types designed to model constructs native to JavaScript and TypeScript. The JSON Schema schematics produced by TypeBox can be passed directly to any compliant validator.
 
 ### Example
 
@@ -80,38 +80,33 @@ The following creates a User type and infers with Static.
 ```typescript
 import Type from 'typebox'
 
-// Type
-
 const User = Type.Object({                       // const User = {
   id: Type.String(),                             //   type: 'object',
-  name: Type.String(),                           //   properties: {
-  email: Type.String({ format: 'email' })        //     id: { type: 'string' },
-})                                               //     name: { type: 'string' },
+  name: Type.String(),                           //   required: [
+  email: Type.String({ format: 'email' })        //     'id', 
+})                                               //     'name', 
+                                                 //     'email'
+                                                 //   ],
+                                                 //   properties: {
+                                                 //     id: { type: 'string' },
+                                                 //     name: { type: 'string' },
                                                  //     email: { 
                                                  //       type: 'string', 
                                                  //       format: 'email' 
                                                  //     }
-                                                 //   },
-                                                 //   required: [
-                                                 //     'id', 
-                                                 //     'name', 
-                                                 //     'email'
-                                                 //   ]
+                                                 //   }
                                                  // }
 
-// Static
-
 type User = Type.Static<typeof User>              // type User = {
                                                   //   id: string,
                                                   //   name: string,
                                                   //   email: string
                                                   // }
-
 ```
 
 ## Script
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFkBDGAC0YgBMBXAG1WoBjCADsAzvGZs4AXkREAdAGVBUYGBgAKAAaU4cQmjgA1VIJjQALLLgBvOGQBccEdxDFUUADRwkz1+6ePgBe-m4e3nAA7mGBUHAAvnoGRCZmFlAAzDb2Ti7hQb6xESHFnonJhuim5tAATDkOZZF++XEV2gCU1HRwAOJQTGCswIJiHDz8QqIS-YPDo+NyyGjKqupaUqw+uvpVabCoZDnJ+pBiwDDAos41GZZepy7QIEy8t+nQmY-6+twAbh9alA6skkntUn1UDhUDAoEgTr84P9PFdBKgxB9DmQANoAXR+v2AIk4owxzXxYMqqSknmAb0RvyY7mAqBEMCB90J+lJGAw3DEqE5Vm5cDEaEEfCYUGFUEsVIhRgYGPYclsTwA5tCQLD4c4oTC4UhRa8YHS3s5aWo3lSutR9sqxKr5KslDAWKMADxVCAYOZDEZjHF4R2sPB4gB8+l6DpVjKRCcTSeTKZTvX0WsNerscAUecSotTReLJfTcFN5veObzCgqJfrDeTvQSQA) | [Example 2](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFkBDGAC0YgBMBXAG1WoBjCADsAzvABqqQTGgAWOAF5ERAHQB5YgCsZMABQBvOGQBcqtGoBy3EMVRR9ASgA0cJOeSWbdh87cAXp7qPvaOrnAA7sHetmHOcAC+TpTC4lJ60ADMyhaomjp6RiYx+aF+ER551nEVgaU1vuFJKWkScNKy0ABMuV75WrqyxWbV5eFuVf2N8U4t1HRwAOJQTGCswIJiHDz8QqLt0rCoZH3qg0WGlHBwkGLAMMCi5p1yUPIu13Ai0CBMvC9MlAsp8btwAG6ArpQbqUZKpA7wJaoHCoGBQJBnSwXYZXG7ghyPQSoMQNACCUFWSH0RxgJ1cX2AIk4mxJ5MpTGp03GzhS8La8GYdKgwH+WIGhVxXyYdmAqBEMChbw+XxZGAw3DEqCVClBcDEaEEfCYUB170+-MRjBJ7BU0xxBjxcAA5iiQGiMeZkaj0Ug9X9haKAYwWA4g3CUpRCGhrWJbdUAMowFibAA80ZRGFjrAAfDd8wXC4sM9nck7CxXK1XqzX84sbq6fZ64MY1G2knra13u1363AA2H-uZW+3El8exPJ3X6IkgA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgYwgDsBneAWQEMYALOAXkSIB0AZRpRgYGAAoABpThxCaOADVUNGNAAsvOAG84ZAFxx6AVxDFUUADRwkxsxau2AXg-OWbcAO7unUOABfOQUiFTUNKABmHX0jEw9nOz9PVxSrIJDFdFV1aAAmWIN0r3sE-0zpAEpqOiZ4AHEoNjBOYBpGHWQ0YVFxKXYuW1l5bPDYVDJYkPlIRmAYYAZjXMjNaxmTaBA2ABsViOgojfl5UwA3A7yofJDg0bCG1BxUGCgkadO4c6tFmlRGAcJmQANoAXROp2A9AAJu0ASVwXcsmFBlZgHtPqc2BZgKh6DArmtIfI4RgMKZGKgiVoSXBGGgaKZdmwoDSoJpkQ8lCwAdw+LpNgBzZ4gV7vYxPF5vJB0nYwdF7YxosR7ZHVahjXmMfn8HpCGAcdoAHmyEAwcCaLTaHRBeG1nDwYIAfPIAPRu0I8vlYr5+-0BwNBoMe04i6USvRwAQxoJ04MJxNJ0PyeWK-ZRmMCTJJ3N5wOhwJAA) | [Example 2](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFkBDGAC0YgBMBXAG1WoBjCADsAzvABqqQTGgAWOAF5ERAHQB5YgCsZMABQBvOGQBcqtGoBy3EMVRR9ASgA0cJOeSWbdh87cAXp7qPvaOrnAA7sHetmHOcAC+TpTC4lJ60ADMyhaomjp6RiYx+aF+ER551nEVgaU1vuFJKWkScNKy0ABMuV75WrqyxWbV5eFuVf2N8U4t1HRwAOJQTGCswIJiHDz8QqLt0rCoZH3qg0WGlHBwkGLAMMCi5p1yUPIu13Ai0CBMvC9MlAsp8btwAG6ArpQbqUZKpA7wJaoHCoGBQJBnSwXYZXG7ghyPQSoMQNACCUFWSH0RxgJ1cX2AIk4mxJ5MpTGp03GzhS8La8GYdKgwH+WIGhVxXyYdmAqBEMChbw+XxZGAw3DEqCVClBcDEaEEfCYUB170+-MRjBJ7BU0xxBjxcAA5iiQGiMeZkaj0Ug9X9haKAYwWA4g3CUpRCGhrWJbdUAMowFibAA80ZRGFjrAAfDd8wXC4sM9nck7CxXK1XqzX84sbq6fZ64MY1G2knra13u1363AA2H-uZW+3El8exPJ3X6IkgA)
 
 TypeBox includes a micro TypeScript engine that can transform TypeScript definitions to JSON Schema. The engine is fully type-safe and supports many programmable constructs including Conditional, Mapped, Indexed, Generics, Distributive Generics, and more.
 
@@ -122,16 +117,12 @@ Syntax highlighting is available via the [Visual Studio Marketplace](https://mar
 ```typescript
 import Type from 'typebox'
 
-// Math Module
-
 const Math = Type.Script(`
   type Vector4 = { x: number, y: number, z: number, w: number }
   type Vector3 = { x: number, y: number, z: number }
   type Vector2 = { x: number, y: number }
 `)
 
-// Graphics Module
-
 const Graphics = Type.Script(Math, `
   type Vertex = {
     position: Vector4,
@@ -163,9 +154,9 @@ type Mesh = Type.Static<typeof Graphics['Mesh']>  // type Mesh = {
 
 ## Schema
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://www.typescriptlang.org/play/#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQbddcAtH-wMFDhI0WPESenbgGECYYABs003pPUbNW-hyQQAdg3gBVBmihwAvImZYAdHPBK0ACgDebOHDIUAXMQhKACs0JBgiABpPODB8ClhgNAZ-Dy8vYAATFO9yNH8iIyhgfQBzIjgAXyi0uH1MEDy4Nxy-YkLissrqtJYlbJ9Ggpgi0sjcaCwYfN7FcoroquioNABHAFdgZay4AG1oryJMsf3iOobjmqIZ9i8AXTYKgEoOLjVtd4+P1QAFTCgzVSfIHAyS6AxGOBrMwWaymcx2X7-VzNGqotHouCvPSGeBQ8wpaKZfIANgArDgAIyYABMlAAzEgACwZUloYk4ADsmAAHJQAJxIAAMGQpYwx6Ne6W27VK3TOgzxUDF4pVqq8ktq9UaMpK3Rm+UVAAEMgRMMU7HoQOU1SqNfq4DqHo8bS7XajXhUrHA7D6gA) | [Example 2](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQokscAKuWrnyES-ajXZs6dOAFo58hYqXKVqteo0zJ0gMIEwwADZptszeYuWr8tmyQQAdg3gBVBmihwAvImZYAdHrgRmgAFHwU-gDylABWaEgwoQDebHBwwAAmAFy8-P4IMFDADgDmoQCUADRpcA6YIGi5EWgFRSXl1bUsRs35hcVlKbjQWDC5RD2GRHAAvhVs8wum1qtr61pScAAKmFDuKxtHx6q29k7wAK7unj5uHv67+2HJ6W-vH5-vW+fOcNceXKpdJZCYANgArDgAIyYABMlAAzEgACyZCFoME4ADsmAAHJQAJxIAAMmWhRCqX2pcC2IJycGcg1KNXS9UaEwBUEpNN5fO+0jZDSajPaZVZcCmnJuAAFMgRMCV-PYQDN+by6ZKsL1RczFhV1YajR8trNvHB-JagA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQokscAKuWrnyES-ajXZs6dOAGECYYABs0bNkggA7BvABqaJDGhwAvImZYAdHPBK0ACj4ULyKMDAw7AAwDebOHBoALjgNAFcQSjQoPzhSYLCIqJiAL3jwyOiAX08AShzVKVl0JABrVXUteAA3TEVgABMTOD0DaCtikrtvAOCARgAaWOCABkHUuGG4TJz-OEKK7Tgauvrg6ghlTA0C6QAFTCgGFTVNRag0BlDFeFMWwygLfcP7bqC4AaGJsZGpmbnpBbwc6Xa7BbqzfwxCHQmGwuHwhGFfxvBIZKEIjGYrH+JGfVFJbGEokw3HjfHRYmUomFTJAA) | [Example 2](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQokscAKuWrnyES-ajXZs6dOAGECYYABs0bNkggA7BvABqaJDGhwAvImZYAdHPBK0ACj4ULAeUoArfTDsBvNnDg0AFy8-BYAcgCuIJRoUHYAlAA0fnCkwY5o4VExcUkpAF7poZHRsQlsAL7x8apSsuhIANaq6lrwAG6YisAAJiZwegbQVg2NPgHBAIyJqcEADDOFcHNwVf5wda3acJ3dPcHUEMqYGrXSAAqYUAwqaprbUGgMEYrwpoOGUBaX1-beE3BprNlot5qt4v5Nvd4I9nq9gv91v4UkjUWj0RjMVi6v4gnANNlYiisSTSWTIdJ-Gl8YSoMTyQzGRT1ksCaU6UzOYy6hUgA) | [Example 3](https://www.typescriptlang.org/play/#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQbddcAwgWMAA2aDkggA7BvABqaJDGhwAvImZYAdH3BC0ACgDebOHDIUAXMQiUAVnJhEANEbhQ0ARwCuwVwBMLAbSIaR2JSEKIALyIAXSdjMHwKWGA0BgtDY2MadJNyNAsicQ8QSjQoIjgAXzjM0hzTfOIikrKK6udjCPq8gubS8qrnSrZKgEoOLl50JABrUQkpOAA3TEFgH2U4WXloTWmZgzhsuABGBzg6uAAGc67rqtHMybFJeBW1vzhqCGFMcQnuAAFTBQBgiNgvRauBgeQTwFTbBRQdTA0F6fRHCxnC4WG5wO5XB7GZ4LeDQ2EwHKZYwdal0+kMxlMpmTLIWPplWnM7k83lwVk4uAcqBcvli8X87iddnFfqiiUK5mTSpAA)
 
-TypeBox includes a high-performance JIT compiler that supports JSON Schema Draft 3 through to 2020-12. It is designed to be a lightweight industry-grade alternative to Ajv and offers improved compilation and validation performance. It also provides automatic fallback to dynamic validation in JIT restricted environments such as Cloudflare Workers.
+TypeBox includes a high-performance JSON Schema JIT compiler that supports Draft 3 through to 2020-12. The compiler is designed to be a lightweight industry-grade alternative to Ajv and offers improved compilation and validation performance. It also offers automatic fallback to dynamic validation in JIT restricted environments such as Cloudflare Workers.
 
 The compiler is available via optional sub module import.
 
@@ -175,36 +166,10 @@ import Schema from 'typebox/schema'
 
 ### Compile
 
-The compiler accepts either TypeBox types or native JSON Schema.
-
-```typescript
-
-// Type
-
-const VectorA = Schema.Compile(Type.Object({       // const VectorA: Validator<TObject<{
-  x: Type.Number(),                                //   x: TNumber
-  y: Type.Number(),                                //   y: TNumber
-  z: Type.Number()                                 //   z: TNumber
-}))                                                // }>>
-
-// Schema
-
-const VectorB = Schema.Compile({                   // const VectorB: Validator<{
-  type: 'object',                                  //   type: "object";
-  required: ['x', 'y', 'z'],                       //   required: ["x", "y", "z"];
-  properties: {                                    //   properties: { ... };
-    x: { type: 'number' },                         // }, { ... }>
-    y: { type: 'number' },
-    z: { type: 'number' }
-  }
-})
-```
-
-### Validate
-
-Compiled validator instances provide functions to Check and Parse values.
+The compiler accepts TypeBox types as well as plain JSON Schema objects, and returns a Validator instance which can be used to check values. The following compiles a Vector type.
 
 ```typescript
+import Schema from 'typebox/schema'
 
 // Compile
 
@@ -227,11 +192,11 @@ const result = Vector.Parse({ x: 1, y: 0, z: 0 })  // const result: {
                                                    // }
 ```
 
-### Coverage
+### Compatibility
 
 [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) | [JSON Schema Compliance Suite](https://github.com/sinclairzx81/json-schema-compliance-suite)
 
-TypeBox supports all major JSON Schema draft versions and tracks compliance against the official JSON Schema Test Suite. It also maintains a separate JavaScript compliance suite to track ecosystem adoption as JSON Schema moves toward the V1 candidate. The following table shows TypeBox specification coverage.
+TypeBox supports all versions of JSON Schema and is heavily tested against the official JSON Schema Test Suite. It prioritizes compatibility with modern specifications while also maintaining broad support for legacy versions provided their semantics are not in conflict with modern specifications.
 
 | Spec | 3 | 4 | 6 | 7 | 2019-09 | 2020-12 | v1 |
 |:-----|:--|:--|:--|:--|:--|:--|:--|
@@ -254,7 +219,6 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 | enum | 16/18 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMaximum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMinimum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
-| format | ✅ | ✅ | ✅ | ✅ | ✅ | 114/133 | - |
 | if-then-else | - | - | - | ✅ | ✅ | ✅ | ✅ |
 | infinite-loop-detection | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | items | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -287,43 +251,47 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 
 ### Performance
 
-TypeBox tracks comparative performance against AJV8 as the de facto performance standard. For broader comparative benchmarks, refer to the community maintained projects below.
+TypeBox tracks performance against AJV8 only as the defacto performance standard. For broader comparative benchmarks, refer to the following community maintained projects.
 
 [Runtime Benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/) | [Schema Benchmarks](https://schemabenchmarks.dev/)
 
-The following table shows compilation performance for various JSON Schema structures. These benchmarks measure the time required to JIT compile schematics, with faster compilation resulting in faster application startup.
+### Compile
+
+The following table shows compile performance for various JSON Schema structures. These benchmarks measure the time required to build and runtime JIT schematics. Faster compilation results in faster application startup.
 
 ```python
 ┌──────────────────────┬──────────────┬──────────────┐
 │ Compile              │ TB1X         │ AJV8         │
 ├──────────────────────┼──────────────┼──────────────┤
-│ Boolean              │  50.4K ops/s │   7.1K ops/s │
-│ Number               │ 129.9K ops/s │   7.9K ops/s │
-│ String               │ 128.9K ops/s │   9.1K ops/s │
-│ Null                 │  91.3K ops/s │   8.4K ops/s │
-│ Literal_String       │  63.1K ops/s │   7.4K ops/s │
-│ Literal_Number       │  74.5K ops/s │   7.6K ops/s │
-│ Literal_Boolean      │ 143.3K ops/s │   7.7K ops/s │
-│ Pattern              │  94.2K ops/s │   6.4K ops/s │
-│ Object_Open          │  19.4K ops/s │   1.3K ops/s │
-│ Object_Close         │  17.6K ops/s │    991 ops/s │
-│ Object_Vector3       │  46.1K ops/s │   3.3K ops/s │
-│ Object_Basis3        │    16K ops/s │    848 ops/s │
-│ Intersect_And        │  41.3K ops/s │   4.2K ops/s │
-│ Intersect_Structural │  25.3K ops/s │   1.5K ops/s │
-│ Union_Or             │  58.6K ops/s │   2.4K ops/s │
-│ Union_Structural     │  31.5K ops/s │   1.8K ops/s │
-│ Tuple_Values         │  18.2K ops/s │   1.9K ops/s │
-│ Tuple_Objects        │   3.9K ops/s │    437 ops/s │
-│ Array_Numbers_4      │ 114.5K ops/s │   4.2K ops/s │
-│ Array_Numbers_8      │ 128.3K ops/s │   3.9K ops/s │
-│ Array_Numbers_16     │ 128.4K ops/s │     4K ops/s │
-│ Array_Objects_Open   │    22K ops/s │    780 ops/s │
-│ Array_Objects_Close  │    22K ops/s │     1K ops/s │
+│ Boolean              │  54.9K ops/s │     7K ops/s │
+│ Number               │ 154.2K ops/s │   7.8K ops/s │
+│ String               │ 161.4K ops/s │   9.7K ops/s │
+│ Null                 │ 111.9K ops/s │   8.9K ops/s │
+│ Literal_String       │  34.6K ops/s │   7.5K ops/s │
+│ Literal_Number       │  78.1K ops/s │   7.6K ops/s │
+│ Literal_Boolean      │  79.7K ops/s │   8.4K ops/s │
+│ Pattern              │  92.1K ops/s │   6.1K ops/s │
+│ Object_Open          │  18.6K ops/s │   1.3K ops/s │
+│ Object_Close         │    17K ops/s │    975 ops/s │
+│ Object_Vector3       │  33.3K ops/s │   3.4K ops/s │
+│ Object_Basis3        │  18.9K ops/s │    858 ops/s │
+│ Intersect_And        │  63.5K ops/s │   3.6K ops/s │
+│ Intersect_Structural │  25.7K ops/s │   1.7K ops/s │
+│ Union_Or             │  58.2K ops/s │   3.3K ops/s │
+│ Union_Structural     │  33.7K ops/s │     2K ops/s │
+│ Tuple_Values         │  19.5K ops/s │     2K ops/s │
+│ Tuple_Objects        │     4K ops/s │    388 ops/s │
+│ Array_Numbers_4      │  90.7K ops/s │   4.3K ops/s │
+│ Array_Numbers_8      │ 121.8K ops/s │   3.8K ops/s │
+│ Array_Numbers_16     │ 116.6K ops/s │   3.9K ops/s │
+│ Array_Objects_Open   │  22.6K ops/s │    802 ops/s │
+│ Array_Objects_Close  │  18.4K ops/s │    930 ops/s │
 └──────────────────────┴──────────────┴──────────────┘
 ```
 
-The following tables shows validation performance for various JSON Schema structures. These benchmarks measure overall validation throughput for JIT compiled schematics.
+### Validate
+
+The following table shows validation performance for various JSON Schema structures. These benchmarks measure overall validation throughput for compiled schematics.
 
 ```python
 ┌──────────────────────┬──────────────┬──────────────┐