typebox 1.0.66 → 1.0.68

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/guard/emit.d.mts

@@ -34,7 +34,8 @@ export declare function IsGreaterThan(left: string, right: string): string;
 export declare function IsLessThan(left: string, right: string): string;
 export declare function IsLessEqualThan(left: string, right: string): string;
 export declare function IsGreaterEqualThan(left: string, right: string): string;
-export declare function StringGraphemeCount(value: string): string;
+export declare function IsMinLength(value: string, length: string): string;
+export declare function IsMaxLength(value: string, length: string): string;
 export declare function Every(value: string, offset: string, params: [value: string, index: string], expression: string): string;
 export declare function Entries(value: string): string;
 export declare function Keys(value: string): string;

package/build/guard/emit.mjs

@@ -104,8 +104,11 @@ export function IsGreaterEqualThan(left, right) {
 // --------------------------------------------------------------------------
 // String
 // --------------------------------------------------------------------------
-export function StringGraphemeCount(value) {
-    return `Guard.StringGraphemeCount(${value})`;
+export function IsMinLength(value, length) {
+    return `Guard.IsMinLength(${value}, ${length})`;
+}
+export function IsMaxLength(value, length) {
+    return `Guard.IsMaxLength(${value}, ${length})`;
 }
 // --------------------------------------------------------------------------
 // Array
@@ -181,7 +184,7 @@ export function ReduceOr(operands) {
     return G.IsEqual(operands.length, 0) ? 'false' : operands.reduce((left, right) => Or(left, right));
 }
 // --------------------------------------------------------------------------
-// Arithmatic
+// Arithmetic
 // --------------------------------------------------------------------------
 export function PrefixIncrement(expression) {
     return `++${expression}`;

package/build/guard/guard.d.mts

@@ -37,6 +37,12 @@ export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint
 /** Returns true if the value appears to be an instance of a class. */
 export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
+/** Returns the number of grapheme clusters in the string */
+export declare function GraphemeCount(value: string): number;
+/** Returns true if the string has at most the given number of graphemes */
+export declare function IsMaxLength(value: string, length: number): boolean;
+/** Returns true if the string has at least the given number of graphemes */
+export declare function IsMinLength(value: string, length: number): boolean;
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if this value has this property key */
@@ -55,5 +61,3 @@ export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
 export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
 /** Tests values for deep equality */
 export declare function IsDeepEqual(left: unknown, right: unknown): boolean;
-/** Returns the number of Unicode Grapheme Clusters */
-export declare function StringGraphemeCount(value: string): number;

package/build/guard/guard.mjs

@@ -1,3 +1,4 @@
+import * as String from './string.mjs';
 // --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
@@ -127,6 +128,21 @@ export function IsValueLike(value) {
         IsUndefined(value);
 }
 // --------------------------------------------------------------------------
+// String
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in the string */
+export function GraphemeCount(value) {
+    return String.GraphemeCount(value);
+}
+/** Returns true if the string has at most the given number of graphemes */
+export function IsMaxLength(value, length) {
+    return String.IsMaxLengthFast(value, length);
+}
+/** Returns true if the string has at least the given number of graphemes */
+export function IsMinLength(value, length) {
+    return String.IsMinLengthFast(value, length);
+}
+// --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
 export function Every(value, offset, callback) {
@@ -190,84 +206,3 @@ function DeepEqualArray(left, right) {
 export function IsDeepEqual(left, right) {
     return (IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right));
 }
-// --------------------------------------------------------------------------
-// StringGraphemeCountIntl - Intl.Segmenter Polyfill
-// --------------------------------------------------------------------------
-//
-// const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' })
-// function StringGraphemeCountIntl(value: string): number {
-//   const iterator = segmenter.segment(value)[Symbol.iterator]()
-//   let length = 0
-//   while (!iterator.next().done) length++
-//   return length
-// }
-//
-// --------------------------------------------------------------------------
-function IsRegionalIndicator(value) {
-    return value >= 0x1F1E6 && value <= 0x1F1FF;
-}
-function IsVariationSelector(value) {
-    return value >= 0xFE00 && value <= 0xFE0F;
-}
-function IsCombiningMark(value) {
-    return ((value >= 0x0300 && value <= 0x036F) ||
-        (value >= 0x1AB0 && value <= 0x1AFF) ||
-        (value >= 0x1DC0 && value <= 0x1DFF) ||
-        (value >= 0xFE20 && value <= 0xFE2F));
-}
-function CodePointLength(value) {
-    return value > 0xFFFF ? 2 : 1;
-}
-function StringGraphemeCountIntl(value) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        const start = value.codePointAt(index);
-        let clusterEnd = index + CodePointLength(start);
-        // Combining marks & variation selectors
-        while (clusterEnd < value.length) {
-            const next = value.codePointAt(clusterEnd);
-            if (IsCombiningMark(next) || IsVariationSelector(next)) {
-                clusterEnd += CodePointLength(next);
-            }
-            else {
-                break;
-            }
-        }
-        // ZWJ sequences
-        while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
-            const next = value.codePointAt(clusterEnd + 1);
-            clusterEnd += 1 + CodePointLength(next);
-        }
-        // Regional indicator pairs (flags)
-        const first = IsRegionalIndicator(start);
-        const second = clusterEnd < value.length && IsRegionalIndicator(value.codePointAt(clusterEnd));
-        if (first && second) {
-            const next = value.codePointAt(clusterEnd);
-            clusterEnd += CodePointLength(next);
-        }
-        count++;
-        index = clusterEnd;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
-// StringGraphemeCount
-// --------------------------------------------------------------------------
-function IsComplexGraphemeCodeUnit(value) {
-    return ((value >= 0xD800 && value <= 0xDBFF) || // High surrogate
-        (value >= 0x0300 && value <= 0x036F) || // Combining diacritical marks
-        (value === 0x200D) // Zero-width joiner
-    );
-}
-/** Returns the number of Unicode Grapheme Clusters */
-export function StringGraphemeCount(value) {
-    let count = 0;
-    for (let index = 0; index < value.length; index++) {
-        if (IsComplexGraphemeCodeUnit(value.charCodeAt(index))) {
-            return StringGraphemeCountIntl(value);
-        }
-        count++;
-    }
-    return count;
-}

package/build/guard/string.d.mts

@@ -0,0 +1,10 @@
+/** Returns the number of grapheme clusters in a string */
+export declare function GraphemeCount(value: string): number;
+/** Checks if a string has at least a minimum number of grapheme clusters */
+export declare function IsMinLength(value: string, minLength: number): boolean;
+/** Checks if a string has at most a maximum number of grapheme clusters */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Fast check for minimum grapheme length, falls back to full check if needed */
+export declare function IsMinLengthFast(value: string, minLength: number): boolean;
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export declare function IsMaxLengthFast(value: string, maxLength: number): boolean;

package/build/guard/string.mjs

@@ -0,0 +1,154 @@
+// --------------------------------------------------------------------------
+// IsBetween
+// --------------------------------------------------------------------------
+function IsBetween(value, min, max) {
+    return value >= min && value <= max;
+}
+// --------------------------------------------------------------------------
+// IsRegionalIndicator
+// --------------------------------------------------------------------------
+function IsRegionalIndicator(value) {
+    return IsBetween(value, 0x1F1E6, 0x1F1FF);
+}
+// --------------------------------------------------------------------------
+// IsVariationSelector
+// --------------------------------------------------------------------------
+function IsVariationSelector(value) {
+    return IsBetween(value, 0xFE00, 0xFE0F);
+}
+// --------------------------------------------------------------------------
+// IsCombiningMark
+// --------------------------------------------------------------------------
+function IsCombiningMark(value) {
+    return (IsBetween(value, 0x0300, 0x036F) ||
+        IsBetween(value, 0x1AB0, 0x1AFF) ||
+        IsBetween(value, 0x1DC0, 0x1DFF) ||
+        IsBetween(value, 0xFE20, 0xFE2F));
+}
+// --------------------------------------------------------------------------
+// CodePointLength
+// --------------------------------------------------------------------------
+function CodePointLength(value) {
+    return value > 0xFFFF ? 2 : 1;
+}
+// --------------------------------------------------------------------------
+// ConsumeModifiers (helper)
+// --------------------------------------------------------------------------
+function ConsumeModifiers(value, index) {
+    while (index < value.length) {
+        const point = value.codePointAt(index);
+        if (IsCombiningMark(point) || IsVariationSelector(point)) {
+            index += CodePointLength(point);
+        }
+        else {
+            break;
+        }
+    }
+    return index;
+}
+// --------------------------------------------------------------------------
+// NextGraphemeClusterIndex
+// --------------------------------------------------------------------------
+function NextGraphemeClusterIndex(value, clusterStart) {
+    const startCP = value.codePointAt(clusterStart);
+    let clusterEnd = clusterStart + CodePointLength(startCP);
+    // Consume combining marks & variation selectors
+    clusterEnd = ConsumeModifiers(value, clusterEnd);
+    // Handle multi-ZWJ sequences
+    while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
+        const nextCP = value.codePointAt(clusterEnd + 1);
+        clusterEnd += 1 + CodePointLength(nextCP);
+        clusterEnd = ConsumeModifiers(value, clusterEnd);
+    }
+    // Handle regional indicator pairs (flags)
+    if (IsRegionalIndicator(startCP) &&
+        clusterEnd < value.length &&
+        IsRegionalIndicator(value.codePointAt(clusterEnd))) {
+        clusterEnd += CodePointLength(value.codePointAt(clusterEnd));
+    }
+    return clusterEnd;
+}
+// --------------------------------------------------------------------------
+// IsGraphemeCodePoint
+// --------------------------------------------------------------------------
+function IsGraphemeCodePoint(value) {
+    return (IsBetween(value, 0xD800, 0xDBFF) || // High surrogate
+        IsBetween(value, 0x0300, 0x036F) || // Combining diacritical marks
+        (value === 0x200D) // Zero-width joiner
+    );
+}
+// --------------------------------------------------------------------------
+// GraphemeCount
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in a string */
+export function GraphemeCount(value) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+    }
+    return count;
+}
+// --------------------------------------------------------------------------
+// IsMinLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at least a minimum number of grapheme clusters */
+export function IsMinLength(value, minLength) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at most a maximum number of grapheme clusters */
+export function IsMaxLength(value, maxLength) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count > maxLength)
+            return false;
+    }
+    return true;
+}
+// --------------------------------------------------------------------------
+// IsMinLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for minimum grapheme length, falls back to full check if needed */
+export function IsMinLengthFast(value, minLength) {
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMinLength(value, minLength);
+        }
+        index++;
+        if (index >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export function IsMaxLengthFast(value, maxLength) {
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMaxLength(value, maxLength);
+        }
+        index++;
+        if (index > maxLength)
+            return false;
+    }
+    return true;
+}

package/build/schema/engine/maxLength.mjs

@@ -4,13 +4,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildMaxLength(stack, context, schema, value) {
-    return E.IsLessEqualThan(E.StringGraphemeCount(value), E.Constant(schema.maxLength));
+    return E.IsMaxLength(value, E.Constant(schema.maxLength));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckMaxLength(stack, context, schema, value) {
-    return G.IsLessEqualThan(G.StringGraphemeCount(value), schema.maxLength);
+    return G.IsMaxLength(value, schema.maxLength);
 }
 // ------------------------------------------------------------------
 // Error

package/build/schema/engine/minLength.mjs

@@ -4,13 +4,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildMinLength(stack, context, schema, value) {
-    return E.IsGreaterEqualThan(E.StringGraphemeCount(value), E.Constant(schema.minLength));
+    return E.IsMinLength(value, E.Constant(schema.minLength));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckMinLength(stack, context, schema, value) {
-    return G.IsGreaterEqualThan(G.StringGraphemeCount(value), schema.minLength);
+    return G.IsMinLength(value, schema.minLength);
 }
 // ------------------------------------------------------------------
 // Error

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "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.