typebox 1.0.67 → 1.0.69

package/build/compile/index.d.mts

@@ -4,9 +4,5 @@ export * from './validator.mjs';
 import { Code } from './code.mjs';
 import { Compile } from './compile.mjs';
 import { Validator } from './validator.mjs';
-declare const _default: {
-    Code: typeof Code;
-    Compile: typeof Compile;
-    Validator: typeof Validator;
-};
-export default _default;
+export { Code, Compile, Validator };
+export default Compile;

package/build/compile/index.mjs

@@ -10,4 +10,5 @@ export * from './validator.mjs';
 import { Code } from './code.mjs';
 import { Compile } from './compile.mjs';
 import { Validator } from './validator.mjs';
-export default { Code, Compile, Validator };
+export { Code, Compile, Validator };
+export default Compile;

package/build/system/memory/discard.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Metrics } from "./metrics.mjs";
+import { Metrics } from './metrics.mjs';
 import { Clone } from './clone.mjs';
 /** Discards multiple property keys from the given object value */
 export function Discard(value, propertyKeys) {

package/build/system/memory/update.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Settings } from '../settings/index.mjs';
-import { Metrics } from "./metrics.mjs";
+import { Metrics } from './metrics.mjs';
 import { Clone } from './clone.mjs';
 /**
  * Updates a value with new properties while preserving property enumerability. Use this function to modify

package/build/type/engine/evaluate/distribute.d.mts

@@ -5,8 +5,8 @@ import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TComposite } from './composite.mjs';
 import { type TNarrow } from './narrow.mjs';
-import { type TEvaluateType } from "./evaluate.mjs";
-import { type TEvaluateIntersect } from "./evaluate.mjs";
+import { type TEvaluateType } from './evaluate.mjs';
+import { type TEvaluateIntersect } from './evaluate.mjs';
 type TCanDistribute<Type extends TSchema> = Type extends TObject | TTuple ? true : false;
 type TDistributeNormalize<Type extends TSchema> = Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type;
 type TDistributeOperation<Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TDistributeNormalize<Left>, NormalRight extends TSchema = TDistributeNormalize<Right>, IsObjectLeft extends boolean = TCanDistribute<NormalLeft>, IsObjectRight extends boolean = TCanDistribute<NormalRight>, Result extends TSchema = ([

package/build/type/engine/evaluate/distribute.mjs

@@ -8,8 +8,8 @@ import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
 import { Composite } from './composite.mjs';
 import { Narrow } from './narrow.mjs';
-import { EvaluateType } from "./evaluate.mjs";
-import { EvaluateIntersect } from "./evaluate.mjs";
+import { EvaluateType } from './evaluate.mjs';
+import { EvaluateIntersect } from './evaluate.mjs';
 function CanDistribute(type) {
     return IsObject(type) || IsTuple(type);
 }

package/build/type/engine/evaluate/evaluate.d.mts

@@ -1,11 +1,14 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TUnion } from '../../types/union.mjs';
 import { type TDistribute } from './distribute.mjs';
 import { type TBroaden } from './broaden.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TNever } from '../../types/never.mjs';
 export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Result extends TSchema = TBroaden<Distribution>> = Result;
 export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
 export type TEvaluateUnion<Types extends TSchema[], Result extends TSchema = TBroaden<Types>> = Result;
 export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
 export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
 export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;
+export type TEvaluateUnionFast<Types extends TSchema[], Result extends TSchema = (Types extends [infer Type extends TSchema] ? Type : Types extends [] ? TNever : TUnion<Types>)> = Result;
+export declare function EvaluateUnionFast<Types extends TSchema[]>(types: [...Types]): TEvaluateUnionFast<Types>;

package/build/type/engine/evaluate/evaluate.mjs

@@ -1,8 +1,10 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { IsUnion } from '../../types/union.mjs';
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
+import { Never } from '../../types/never.mjs';
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
     const result = Broaden(distribution);
@@ -17,3 +19,9 @@ export function EvaluateType(type) {
         IsUnion(type) ? EvaluateUnion(type.anyOf) :
             type);
 }
+export function EvaluateUnionFast(types) {
+    const result = (Guard.IsEqual(types.length, 1) ? types[0] :
+        Guard.IsEqual(types.length, 0) ? Never() :
+            Union(types));
+    return result;
+}

package/build/type/engine/evaluate/narrow.d.mts

@@ -1,5 +1,5 @@
 import { TSchema } from '../../types/schema.mjs';
-import { TNever } from "../../types/never.mjs";
-import { TCompare, TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from "./compare.mjs";
+import { TNever } from '../../types/never.mjs';
+import { TCompare, TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
 export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
 export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;

package/build/type/engine/evaluate/narrow.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Never } from "../../types/never.mjs";
-import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from "./compare.mjs";
+import { Never } from '../../types/never.mjs';
+import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
 export function Narrow(left, right) {
     const result = Compare(left, right);
     return (Guard.IsEqual(result, ResultLeftInside) ? left :

package/build/type/engine/indexed/from-tuple.d.mts

@@ -2,12 +2,12 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TLiteral } from '../../types/literal.mjs';
 import { type TNumber } from '../../types/number.mjs';
 import { type TInteger } from '../../types/integer.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
 import { type TFormatArrayIndexer } from './array-indexer.mjs';
 type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
-type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnion<Elements>> = Result;
-type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnion<Types>> = Result;
+type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnionFast<Elements>> = Result;
+type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnionFast<Types>> = Result;
 export type TFromTuple<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema = (Indexer extends TNumber | TInteger ? TFromTupleWithoutIndexer<Types> : TFromTupleWithIndexer<Types, Indexer>)> = Result;
 export declare function FromTuple<Types extends TSchema[], Indexer extends TSchema>(types: [...Types], indexer: Indexer): TFromTuple<Types, Indexer>;
 export {};

package/build/type/engine/indexed/from-tuple.mjs

@@ -2,7 +2,7 @@
 import { Literal } from '../../types/literal.mjs';
 import { IsNumber } from '../../types/number.mjs';
 import { IsInteger } from '../../types/integer.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { FormatArrayIndexer } from './array-indexer.mjs';
 function IndexElementsWithIndexer(types, indexer) {
@@ -16,10 +16,10 @@ function IndexElementsWithIndexer(types, indexer) {
 function FromTupleWithIndexer(types, indexer) {
     const formattedArrayIndexer = FormatArrayIndexer(indexer);
     const elements = IndexElementsWithIndexer(types, formattedArrayIndexer);
-    return EvaluateUnion(elements);
+    return EvaluateUnionFast(elements);
 }
 function FromTupleWithoutIndexer(types) {
-    return EvaluateUnion(types);
+    return EvaluateUnionFast(types);
 }
 export function FromTuple(types, indexer) {
     return (IsNumber(indexer) || IsInteger(indexer)

package/build/type/engine/keyof/from-object.d.mts

@@ -3,8 +3,8 @@ import { type TSchema } from '../../types/index.mjs';
 import { type TUnionToTuple } from '../helpers/index.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
 type TFromPropertyKeys<Keys extends PropertyKey[], Result extends TSchema[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Left extends TLiteralValue ? TFromPropertyKeys<Right, [...Result, TLiteral<Left>]> : TUnreachable : Result);
-export type TFromObject<Properties extends TProperties, PropertyKeys extends PropertyKey[] = TUnionToTuple<keyof Properties>, Variants extends TSchema[] = TFromPropertyKeys<PropertyKeys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export type TFromObject<Properties extends TProperties, PropertyKeys extends PropertyKey[] = TUnionToTuple<keyof Properties>, Variants extends TSchema[] = TFromPropertyKeys<PropertyKeys>, Result extends TSchema = TEvaluateUnionFast<Variants>> = Result;
 export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;
 export {};

package/build/type/engine/keyof/from-object.mjs

@@ -3,7 +3,7 @@ import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { Literal, IsLiteralValue } from '../../types/literal.mjs';
 import { ConvertToIntegerKey } from '../helpers/keys.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 function FromPropertyKeys(keys) {
     const result = keys.reduce((result, left) => {
         return IsLiteralValue(left)
@@ -15,6 +15,6 @@ function FromPropertyKeys(keys) {
 export function FromObject(properties) {
     const propertyKeys = Guard.Keys(properties);
     const variants = FromPropertyKeys(propertyKeys);
-    const result = EvaluateUnion(variants);
+    const result = EvaluateUnionFast(variants);
     return result;
 }

package/build/type/engine/keyof/from-tuple.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/index.mjs';
 import { type TLiteral } from '../../types/literal.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
-export type TFromTuple<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer _ extends TSchema] ? TFromTuple<Left, [TLiteral<Left['length']>, ...Result]> : TEvaluateUnion<Result>);
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+export type TFromTuple<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer _ extends TSchema] ? TFromTuple<Left, [TLiteral<Left['length']>, ...Result]> : TEvaluateUnionFast<Result>);
 export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

package/build/type/engine/keyof/from-tuple.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Literal } from '../../types/literal.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 export function FromTuple(types) {
     const result = types.map((_, index) => Literal(index));
-    return EvaluateUnion(result);
+    return EvaluateUnionFast(result);
 }

package/build/value/create/from-type.mjs

@@ -14,7 +14,7 @@ import { FromFunction } from './from-function.mjs';
 import { FromInteger } from './from-integer.mjs';
 import { FromIntersect } from './from-intersect.mjs';
 import { FromIterator } from './from-iterator.mjs';
-import { FromLiteral } from "./from-literal.mjs";
+import { FromLiteral } from './from-literal.mjs';
 import { FromNever } from './from-never.mjs';
 import { FromNull } from './from-null.mjs';
 import { FromNumber } from './from-number.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "keywords": [
     "typescript",
     "jsonschema"

package/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="typebox.png" />
 
@@ -25,12 +25,12 @@ $ npm install typebox
 
 ## Usage
 
-A TypeScript engine for Json Schema [Reference](https://tsplay.dev/wOyMRm)
+A TypeScript first validation engine for JSON Schema [Example](https://tsplay.dev/mZMOeN)
 
 ```typescript
 import Type from 'typebox'
 
-// Json Schema
+// JSON Schema
 
 const T = Type.Object({                             // const T = {
   x: Type.Number(),                                 //   type: 'object',
@@ -51,49 +51,39 @@ type T = Type.Static<typeof T>                      // type T = {
 // TypeScript
 
 const { S } = Type.Script({ T }, `
-  type RenameKey<K> = 
-    K extends 'x' ? 'a' :
-    K extends 'y' ? 'b' :
-    K extends 'z' ? 'c' :
-    K
-
   type S = {
-    readonly [K in keyof T as RenameKey<K>]: string
+    readonly [K in keyof T as Uppercase<K>]: string
   }
 `)
 
-type S = Type.Static<typeof S>                    // type S = {
-                                                  //   readonly a: string,
-                                                  //   readonly b: string,
-                                                  //   readonly c: string
-                                                  // }
+type S = Type.Static<typeof S>                      // type S = {
+                                                    //   readonly X: string,
+                                                    //   readonly Y: string,
+                                                    //   readonly Z: string
+                                                    // }
 ```
 
 ## Overview
 
 [Documentation](https://sinclairzx81.github.io/typebox/)
 
-TypeBox is a runtime type system 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 system that can be statically checked by TypeScript and validated at runtime using standard Json Schema.
+TypeBox is a runtime type system 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 system that can be statically checked by TypeScript and validated at runtime using standard JSON Schema.
 
-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.
+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
 
 ## Contents
 
-- [Upgrade](#Upgrade)
+
 - [Type](#Type)
 - [Value](#Value)
-- [Compile](#Compile)
 - [Script](#Script)
+- [Compile](#Compile)
 - [Schema](#Schema)
+- [Legacy](#Legacy)
 - [Contribute](#Contribute)
 
-## Upgrade
-
-If upgrading from `@sinclair/typebox` refer to the 1.0 migration guide at the following URL.
-
-[Migration Guide](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
 
 <a name="Type"></a>
 
@@ -101,11 +91,11 @@ If upgrading from `@sinclair/typebox` refer to the 1.0 migration guide at the fo
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://tsplay.dev/NaMoBN)
 
-TypeBox provides many functions to create Json Schema types. Each function returns a small Json Schema fragment that can be composed into more complex types. TypeBox includes a set of functions that are used to construct Json Schema compliant schematics as well as a set of extended functions that return schematics for constructs native to JavaScript.
+TypeBox provides many functions to create JSON Schema types. Each function returns a small JSON Schema fragment that can be composed into more complex types. TypeBox includes a set of functions that are used to construct JSON Schema compliant schematics as well as a set of extended functions that return schematics for constructs native to JavaScript.
 
 ## Example
 
-The following creates a Json Schema type and infers with Static.
+The following creates a JSON Schema type and infers with Static.
 
 ```typescript
 import Type from 'typebox'
@@ -130,17 +120,16 @@ type T = Type.Static<typeof T>                      // type T = {
 Schema options can be passed on the last argument of any given type.
 
 ```typescript
-const T = Type.String({                            // const T = {
-  format: 'email'                                  //   type: 'string',
-})                                                 //   format: 'email'
-                                                   // }
-
-const S = Type.Number({                            // const S = {
-  minimum: 0,                                      //   type: 'number',
-  maximum: 100                                     //   minimum: 0,
-})                                                 //   maximum: 100
-                                                   // }
+const T = Type.String({                             // const T = {
+  format: 'email'                                   //   type: 'string',
+})                                                  //   format: 'email'
+                                                    // }
 
+const S = Type.Number({                             // const S = {
+  minimum: 0,                                       //   type: 'number',
+  maximum: 100                                      //   minimum: 0,
+})                                                  //   maximum: 100
+                                                    // }
 ```
 
 <a name="Value"></a>
@@ -173,42 +162,11 @@ const A = Value.Parse(T, {                          // const A: {
 })                                                  // } = ...
 ```
 
-
-<a name="Compile"></a>
-
-## Compile
-
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://tsplay.dev/WyraZw)
-
-The Compile submodule is a high-performance Json Schema compliant JIT compiler that compiles schematics into efficient runtime validators. The compiler is optimized for fast compilation and validation and is known to be one of the fastest validation solutions available for JavaScript.
-
-```typescript
-import { Compile } from 'typebox/compile' 
-```
-
-### Example
-
-The following uses the compiler to Compile and Parse a value. 
-
-```typescript
-const C = Compile(Type.Object({                     // const C: Validator<{}, TObject<{
-  x: Type.Number(),                                 //   x: TNumber,
-  y: Type.Number(),                                 //   y: TNumber,
-  z: Type.Number()                                  //   z: TNumber
-}))                                                 // }>>
-
-const A = C.Parse({                                 // const A: {
-  x: 0,                                             //   x: number,
-  y: 1,                                             //   y: number,
-  z: 0                                              //   z: number
-})                                                  // } = ...
-```
-
 ## Script
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://tsplay.dev/Wk6L1m) | [Example 2](https://tsplay.dev/NnrJoN)
 
-TypeBox is a runtime TypeScript DSL engine that can create, transform, and compute Json Schema using native TypeScript syntax. The engine is implemented symmetrically at runtime and within the TypeScript type system, and is intended for use with the TypeScript 7 native compiler and above.
+TypeBox is a runtime TypeScript DSL engine that can create, transform, and compute JSON Schema using native TypeScript syntax. The engine is implemented symmetrically at runtime and within the TypeScript type system, and is intended for use with the TypeScript 7 native compiler and above.
 
 ```typescript
 // Scripted Type
@@ -223,7 +181,7 @@ const T = Type.Script(`{
                                                     //   z: TBoolean
                                                     // }>
 
-// Json Schema Introspection
+// JSON Schema Introspection
 
 T.type                                              // 'object'
 T.required                                          // ['x', 'y', 'z']
@@ -248,17 +206,47 @@ type S = Type.Static<typeof S>                      // type S = {
                                                     // }
 ```
 
+<a name="Compile"></a>
+
+## Compile
+
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://tsplay.dev/WyraZw)
+
+The Compile submodule is a high-performance JSON Schema compliant JIT compiler that compiles schematics into efficient runtime validators. The compiler is optimized for fast compilation and validation and is known to be one of the fastest validation solutions available for JavaScript.
+
+```typescript
+import Compile from 'typebox/compile' 
+```
+
+### Example
+
+The following uses the compiler to Compile and Parse a value. 
+
+```typescript
+const C = Compile(Type.Object({                     // const C: Validator<{}, TObject<{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber
+}))                                                 // }>>
+
+const A = C.Parse({                                 // const A: {
+  x: 0,                                             //   x: number,
+  y: 1,                                             //   y: number,
+  z: 0                                              //   z: number
+})                                                  // } = ...
+```
+
 <a name="Schema"></a>
 
 ## Schema
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://tsplay.dev/Wvrv3W) | [Example 2](https://tsplay.dev/m3g0ym)
 
-TypeBox is built upon a high-performance validation infrastructure that supports the direct compilation and inference of Json Schema schematics. TypeBox implements Draft 3 to 2020-12 and is compliance tested via the official Json Schema [Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite). It offers high-performance JIT compilation with automatic fallback to dynamic checking in JIT restricted environments.
+TypeBox is built upon a high-performance validation infrastructure that supports the direct compilation and inference of JSON Schema schematics. TypeBox implements Draft 3 to 2020-12 and is compliance tested via the official JSON Schema [Test Suite](https://github.com/JSON-schema-org/JSON-Schema-Test-Suite). It offers high-performance JIT compilation with automatic fallback to dynamic checking in JIT restricted environments.
 
 ### Example
 
-The following compiles Json Schema. Type inference is supported.
+The following compiles JSON Schema. Type inference is supported.
 
 ```typescript
 const C = Compile({
@@ -278,6 +266,60 @@ const A = C.Parse({                                 // const A: {
 })                                                  // } = ...
 ```
 
+## Legacy
+
+If upgrading from `@sinclair/typebox` 0.34.x refer to the 1.0 migration guide at the following URL.
+
+[Migration Guide](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
+
+Most types created with 0.34.x are compatible with V1, and it is possible to run both `typebox` and `@sinclair/typebox` packages side by side. 
+
+[Compatibility](https://tsplay.dev/Wzr2rW)
+
+```typescript
+import { Type } from '@sinclair/typebox'            // TB: 0.34.x
+import { Static } from 'typebox'                    // TB: 1.0.0
+
+// Legacy Types
+
+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 C = Type.Composite([A, B])
+
+// Modern Inference
+
+type C = Static<typeof C>                           // type C = {
+                                                    //   x: number;
+                                                    //   y: number;
+                                                    //   z: number;
+                                                    //   a: number;
+                                                    //   b: number;
+                                                    //   c: number;
+                                                    // }
+
+// Modern Compile
+
+import Compile from 'typebox/compile'
+
+const Result = Compile(C).Check({ ... })
+```
+
+Revision 0.34.x is actively maintained at the following URL.
+
+[TypeBox 0.34.x](https://github.com/sinclairzx81/typebox-legacy)
+
+Please submit non-1.0 issues to this repository.
+
 ## Contribute
 
 TypeBox is open to community contribution. Please ensure you submit an issue before submitting a pull request. The TypeBox project prefers open community discussion before accepting new features.