typebox 1.1.12 → 1.1.14

package/build/type/engine/call/distribute-arguments.d.mts

@@ -3,7 +3,7 @@ import { type TUnion } from '../../types/union.mjs';
 import { type TDeferred } from '../../types/deferred.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TParameter } from '../../types/parameter.mjs';
-type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef<infer Name extends string> ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Name]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Expression extends TDeferred<'Mapped', [infer _Identifier extends TSchema, infer Type extends TSchema, infer _As extends TSchema, infer _Property extends TSchema]> ? (Type extends TDeferred<'KeyOf', [infer Ref extends TRef]> ? [...Result, Ref['$ref']] : Result) : Result);
+type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Left['$ref']]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Expression extends TDeferred<'Mapped', [infer _Identifier extends TSchema, infer Type extends TSchema, infer _As extends TSchema, infer _Property extends TSchema]> ? (Type extends TDeferred<'KeyOf', [infer Ref extends TRef]> ? [...Result, Ref['$ref']] : Result) : Result);
 type TBuildDistributionArray<Parameters extends TParameter[], Names extends string[], Result extends boolean[] = []> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? Left['name'] extends Names[number] ? TBuildDistributionArray<Right, Names, [...Result, true]> : TBuildDistributionArray<Right, Names, [...Result, false]> : Result);
 type TZipDistributionArray<Arguments extends TSchema[], DistributionArray extends boolean[], Result extends [boolean, TSchema][] = []> = (Arguments extends [infer ArgumentLeft extends TSchema, ...infer ArgumentRight extends TSchema[]] ? DistributionArray extends [infer BooleanLeft extends boolean, ...infer BooleanRight extends boolean[]] ? TZipDistributionArray<ArgumentRight, BooleanRight, [...Result, [BooleanLeft, ArgumentLeft]]> : Result : Result);
 type TExpand<Type extends TSchema> = (Type extends TUnion<infer Types extends TSchema[]> ? [...Types] : [Type]);

package/build/type/engine/call/distribute-arguments.mjs

@@ -8,7 +8,7 @@ function CollectDistributionNames(expression, result = []) {
     // Conditional
     IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
         ? IsRef(expression.parameters[0])
-            ? CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], [...result, expression.parameters[0].$ref]))
+            ? CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], [...result, expression.parameters[0]['$ref']]))
             : CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], result))
         // Mapped
         : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')

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

@@ -1,8 +1,10 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
 import * as Result from './result.mjs';
 import { type TExtendsParameters } from './parameters.mjs';
 import { type TExtendsReturnType } from './return-type.mjs';
-export type TExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema> = (Right extends TConstructor<infer RightParamters extends TSchema[], infer RightInstanceType extends TSchema> ? TExtendsParameters<Inferred, Parameters, RightParamters> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, InstanceType, RightInstanceType> : Result.TExtendsFalse : Result.TExtendsFalse);
+export type TExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TConstructor ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, InstanceType, Right['instanceType']> : Result.TExtendsFalse : Result.TExtendsFalse);
 export declare function ExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: InstanceType, right: Right): TExtendsConstructor<Inferred, Parameters, InstanceType, Right>;

package/build/type/extends/constructor.mjs

@@ -1,5 +1,7 @@
 // deno-fmt-ignore-file
+import { IsAny } from '../types/any.mjs';
 import { IsConstructor } from '../types/constructor.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
 import * as Result from './result.mjs';
 // ------------------------------------------------------------------
 // Parameters | ReturnType
@@ -7,10 +9,9 @@ import * as Result from './result.mjs';
 import { ExtendsParameters } from './parameters.mjs';
 import { ExtendsReturnType } from './return-type.mjs';
 export function ExtendsConstructor(inferred, parameters, returnType, right) {
-    return (IsConstructor(right) ? (() => {
-        const check = ExtendsParameters(inferred, parameters, right.parameters);
-        return Result.IsExtendsTrueLike(check)
-            ? ExtendsReturnType(check.inferred, returnType, right.instanceType)
-            : Result.ExtendsFalse();
-    })() : Result.ExtendsFalse());
+    return (IsAny(right) ? Result.ExtendsTrue(inferred) :
+        IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+            IsConstructor(right) ? Result.Match(ExtendsParameters(inferred, parameters, right['parameters']), inferred => ExtendsReturnType(inferred, returnType, right['instanceType']), () => Result.ExtendsFalse()) // 'not-a-parameter-match'
+                : Result.ExtendsFalse() // 'not-a-constructor'
+    );
 }

package/build/type/extends/extends-right.mjs

@@ -1,6 +1,5 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
-import { IsSchema } from '../types/schema.mjs';
 import { IsAny } from '../types/any.mjs';
 import { IsEnum } from '../types/enum.mjs';
 import { IsInfer } from '../types/infer.mjs';
@@ -13,10 +12,7 @@ import * as Result from './result.mjs';
 import { TemplateLiteralDecode } from '../engine/template-literal/decode.mjs';
 import { EnumValuesToUnion } from '../engine/enum/index.mjs';
 function ExtendsRightInfer(inferred, name, left, right) {
-    const check = ExtendsLeft(inferred, left, right);
-    return (Result.IsExtendsTrueLike(check)
-        ? Result.ExtendsTrue(Memory.Assign(Memory.Assign(inferred, check.inferred), { [name]: left }))
-        : Result.ExtendsFalse());
+    return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Result.ExtendsTrue(Memory.Assign(Memory.Assign(inferred, checkInferred), { [name]: left })), () => Result.ExtendsFalse());
 }
 function ExtendsRightAny(inferred, left) {
     return Result.ExtendsTrue(inferred);
@@ -26,26 +22,14 @@ function ExtendsRightEnum(inferred, left, right) {
     return ExtendsLeft(inferred, left, union);
 }
 function ExtendsRightIntersect(inferred, left, right) {
-    const [head, ...tail] = right;
-    return (IsSchema(head) ? (() => {
-        const check = ExtendsLeft(inferred, left, head);
-        return Result.IsExtendsTrueLike(check)
-            ? ExtendsRightIntersect(check.inferred, left, tail)
-            : Result.ExtendsFalse();
-    })() : Result.ExtendsTrue(inferred));
+    return Result.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 function ExtendsRightTemplateLiteral(inferred, left, right) {
     const decoded = TemplateLiteralDecode(right);
     return ExtendsLeft(inferred, left, decoded);
 }
 function ExtendsRightUnion(inferred, left, right) {
-    const [head, ...tail] = right;
-    return (IsSchema(head) ? (() => {
-        const check = ExtendsLeft(inferred, left, head);
-        return Result.IsExtendsTrueLike(check)
-            ? Result.ExtendsTrue(check.inferred)
-            : ExtendsRightUnion(inferred, left, tail);
-    })() : Result.ExtendsFalse());
+    return Result.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
 }
 export function ExtendsRight(inferred, left, right) {
     return (IsAny(right) ? ExtendsRightAny(inferred, left) :

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

@@ -1,8 +1,10 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
 import { type TFunction } from '../types/function.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
 import * as Result from './result.mjs';
 import { type TExtendsParameters } from './parameters.mjs';
 import { type TExtendsReturnType } from './return-type.mjs';
-export type TExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema> = (Right extends TFunction<infer RightParamters extends TSchema[], infer RightReturnType extends TSchema> ? TExtendsParameters<Inferred, Parameters, RightParamters> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, ReturnType, RightReturnType> : Result.TExtendsFalse : Result.TExtendsFalse);
+export type TExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TFunction ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, ReturnType, Right['returnType']> : Result.TExtendsFalse : Result.TExtendsFalse);
 export declare function ExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: ReturnType, right: Right): TExtendsFunction<Inferred, Parameters, ReturnType, Right>;

package/build/type/extends/function.mjs

@@ -1,5 +1,7 @@
 // deno-fmt-ignore-file
+import { IsAny } from '../types/any.mjs';
 import { IsFunction } from '../types/function.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
 import * as Result from './result.mjs';
 // ------------------------------------------------------------------
 // Parameters | ReturnType
@@ -7,10 +9,9 @@ import * as Result from './result.mjs';
 import { ExtendsParameters } from './parameters.mjs';
 import { ExtendsReturnType } from './return-type.mjs';
 export function ExtendsFunction(inferred, parameters, returnType, right) {
-    return (IsFunction(right) ? (() => {
-        const check = ExtendsParameters(inferred, parameters, right.parameters);
-        return Result.IsExtendsTrueLike(check)
-            ? ExtendsReturnType(check.inferred, returnType, right.returnType)
-            : Result.ExtendsFalse();
-    })() : Result.ExtendsFalse());
+    return (IsAny(right) ? Result.ExtendsTrue(inferred) :
+        IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+            IsFunction(right) ? Result.Match(ExtendsParameters(inferred, parameters, right['parameters']), inferred => ExtendsReturnType(inferred, returnType, right['returnType']), () => Result.ExtendsFalse()) // 'not-a-parameter-match'
+                : Result.ExtendsFalse() // 'not-a-function'
+    );
 }

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

@@ -21,7 +21,7 @@ export type TTryRestInferable<Type extends TSchema, Result extends TInferable |
 export declare function TryRestInferable<Type extends TSchema>(type: Type): TTryRestInferable<Type>;
 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<TProperties> ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
+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>;
 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>;

package/build/type/extends/inference.mjs

@@ -2,10 +2,6 @@
 import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-// ----------------------------------------------------------------------------
-// Schematics
-// ----------------------------------------------------------------------------
-import { IsSchema } from '../types/schema.mjs';
 import { IsArray } from '../types/array.mjs';
 import { IsUnknown } from '../types/unknown.mjs';
 import { Tuple } from '../types/tuple.mjs';
@@ -49,14 +45,7 @@ export function TryInferable(type) {
         undefined);
 }
 function TryInferResults(rest, right, result = []) {
-    const [head, ...tail] = rest;
-    return (IsSchema(head)
-        ? (() => {
-            const check = ExtendsLeft({}, head, right);
-            return Result.IsExtendsTrueLike(check)
-                ? TryInferResults(tail, right, [...result, head])
-                : undefined;
-        })() : result);
+    return Result.TakeLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/build/type/extends/object.mjs

@@ -19,12 +19,9 @@ function ExtendsPropertyOptional(inferred, left, right) {
 function ExtendsProperty(inferred, left, right) {
     return (
     // Right TInfer<TNever> is TExtendsFalse
-    IsInfer(right) && IsNever(right.extends) ? Result.ExtendsFalse() : (() => {
-        const check = ExtendsLeft(inferred, left, right);
-        return (Result.IsExtendsTrueLike(check)
-            ? ExtendsPropertyOptional(check.inferred, left, right)
-            : Result.ExtendsFalse());
-    })());
+    (IsInfer(right) && IsNever(right.extends))
+        ? Result.ExtendsFalse()
+        : Result.Match(ExtendsLeft(inferred, left, right), inferred => ExtendsPropertyOptional(inferred, left, right), () => Result.ExtendsFalse()));
 }
 function ExtractInferredProperties(keys, properties) {
     return keys.reduce((result, key) => {

package/build/type/extends/parameters.mjs

@@ -1,6 +1,5 @@
 // deno-fmt-ignore-file
 import { IsInfer } from '../types/infer.mjs';
-import { IsSchema } from '../types/schema.mjs';
 import { IsOptional } from '../types/_optional.mjs';
 import { ExtendsLeft } from './extends-left.mjs';
 import * as Result from './result.mjs';
@@ -10,27 +9,18 @@ function ParameterCompare(inferred, left, leftRest, right, rightRest) {
     const checkRight = IsInfer(right) ? right : left;
     const isLeftOptional = IsOptional(left);
     const isRightOptional = IsOptional(right);
-    const check = ExtendsLeft(inferred, checkLeft, checkRight);
-    return (!isLeftOptional && isRightOptional
-        ? Result.ExtendsFalse()
-        : Result.IsExtendsTrueLike(check)
-            ? ExtendsParameters(check.inferred, leftRest, rightRest)
-            : Result.ExtendsFalse());
+    return ((!isLeftOptional && isRightOptional)
+        ? Result.ExtendsFalse() // 'fail: left-required-but-right-is-optional'
+        : Result.Match(ExtendsLeft(inferred, checkLeft, checkRight), inferred => ExtendsParameters(inferred, leftRest, rightRest), () => Result.ExtendsFalse()) // 'fail: left-and-right-did-not-match'
+    );
 }
 function ParameterRight(inferred, left, leftRest, rightRest) {
-    const [head, ...tail] = rightRest;
-    return (IsSchema(head)
-        ? ParameterCompare(inferred, left, leftRest, head, tail)
-        : IsOptional(left) // 'right-did-not-have-enough-elements'
-            ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
-            : Result.ExtendsFalse() // 'fail: left was required'
-    );
+    return Result.TakeLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
+        ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
+        : Result.ExtendsFalse()); // 'fail: left was required'
 }
 function ParametersLeft(inferred, left, rightRest) {
-    const [head, ...tail] = left;
-    return (IsSchema(head)
-        ? ParameterRight(inferred, head, tail, rightRest)
-        : Result.ExtendsTrue(inferred));
+    return Result.TakeLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
 }
 export function ExtendsParameters(inferred, left, right) {
     return ParametersLeft(inferred, left, right);

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

@@ -19,3 +19,9 @@ export declare function ExtendsFalse(): TExtendsFalse;
 export declare function IsExtendsFalse(value: unknown): value is TExtendsFalse;
 export type TExtendsTrueLike<Inferred extends TProperties = TProperties> = TExtendsUnion<Inferred> | TExtendsTrue<Inferred>;
 export declare function IsExtendsTrueLike(value: unknown): value is TExtendsTrueLike;
+export type MatchTrueLike = (inferred: TProperties) => unknown;
+export type MatchFalse = () => unknown;
+export declare function Match(result: TResult, true_: MatchTrueLike, false_: MatchFalse): unknown;
+export type TakeLeftTrue<T> = (left: T, right: T[]) => unknown;
+export type TakeLeftFalse = () => unknown;
+export declare function TakeLeft<T>(array: T[], true_: TakeLeftTrue<T>, false_: TakeLeftFalse): unknown;

package/build/type/extends/result.mjs

@@ -31,3 +31,9 @@ export function IsExtendsFalse(value) {
 export function IsExtendsTrueLike(value) {
     return IsExtendsUnion(value) || IsExtendsTrue(value);
 }
+export function Match(result, true_, false_) {
+    return IsExtendsTrueLike(result) ? true_(result.inferred) : false_();
+}
+export function TakeLeft(array, true_, false_) {
+    return Guard.IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1));
+}

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

@@ -11,13 +11,13 @@ type TReverse<Types extends TSchema[], Result extends TSchema[] = []> = (Types e
 type TApplyReverse<Types extends TSchema[], Reversed extends boolean> = Reversed extends true ? TReverse<Types> : Types;
 type TReversed<Types extends TSchema[], First extends TSchema | undefined = Types extends [infer Left extends TSchema, ...infer _ extends TSchema[]] ? Left : undefined, Inferable extends TSchema | undefined = First extends TSchema ? TTryRestInferable<First> : undefined, Result extends boolean = Inferable extends TSchema ? true : false> = Result;
 type TElementsCompare<Inferred extends TProperties, Reversed extends boolean, Left extends TSchema, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[]> = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? TElements<CheckInferred, Reversed, LeftRest, RightRest> : Result.TExtendsFalse);
-type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[], Inferable extends TInferable | undefined = TTryRestInferable<Right>> = (Inferable extends TInferable<infer Name extends string, infer Type extends TSchema> ? TInferTupleResult<Inferred, Name, TApplyReverse<LeftRest, Reversed>, Type> : LeftRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsCompare<Inferred, Reversed, Head, Tail, Right, RightRest> : Result.TExtendsFalse);
+type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[], Inferable extends TInferable | undefined = TTryRestInferable<Right>> = (Inferable extends TInferable ? TInferTupleResult<Inferred, Inferable['name'], TApplyReverse<LeftRest, Reversed>, Inferable['type']> : LeftRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsCompare<Inferred, Reversed, Head, Tail, Right, RightRest> : Result.TExtendsFalse);
 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, {
     callstack: [];
 }, 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<infer Name extends string, infer Type extends TSchema> ? TInferUnionResult<Inferred, Name, Left, 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 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>);
 export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, {
     callstack: [];
 }, 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>);

package/build/type/extends/tuple.mjs

@@ -23,31 +23,20 @@ function Reversed(types) {
     return IsSchema(inferrable);
 }
 function ElementsCompare(inferred, reversed, left, leftRest, right, rightRest) {
-    const check = ExtendsLeft(inferred, left, right);
-    return (Result.IsExtendsTrueLike(check)
-        ? Elements(check.inferred, reversed, leftRest, rightRest)
-        : Result.ExtendsFalse() // 'left-and-right-not-compared'
-    );
+    return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Elements(checkInferred, reversed, leftRest, rightRest), () => Result.ExtendsFalse()); // 'left-and-right-not-compared'
 }
 function ElementsLeft(inferred, reversed, leftRest, right, rightRest) {
     const inferable = TryRestInferable(right);
-    return (IsInferable(inferable)
-        ? InferTupleResult(inferred, inferable.name, ApplyReverse(leftRest, reversed), inferable.type)
-        : (() => {
-            const [head, ...tail] = leftRest;
-            return IsSchema(head)
-                ? ElementsCompare(inferred, reversed, head, tail, right, rightRest)
-                : Result.ExtendsFalse();
-        })());
+    return (
+    // Rest Inferrable Right Means we delegate to TInferTupleResult to Generate a Result
+    IsInferable(inferable)
+        ? InferTupleResult(inferred, inferable['name'], ApplyReverse(leftRest, reversed), inferable['type'])
+        : Result.TakeLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
 }
 function ElementsRight(inferred, reversed, leftRest, rightRest) {
-    const [head, ...tail] = rightRest;
-    return (IsSchema(head)
-        ? ElementsLeft(inferred, reversed, leftRest, head, tail)
-        : Guard.IsEqual(leftRest.length, 0)
-            ? Result.ExtendsTrue(inferred) // 'Ok: right-empty-and-left-empty'
-            : Result.ExtendsFalse() // 'Fail: right-empty-and-left-not-empty'
-    );
+    return Result.TakeLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
+        ? Result.ExtendsTrue(inferred) // 'Ok: right-empty-and-left-empty'
+        : Result.ExtendsFalse()); // 'Fail: right-empty-and-left-not-empty'
 }
 function Elements(inferred, reversed, leftRest, rightRest) {
     return ElementsRight(inferred, reversed, leftRest, rightRest);
@@ -60,19 +49,8 @@ function ExtendsTupleToTuple(inferred, left, right) {
 function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
-        // @ts-ignore 4.9.5 fails to see `type` property on inferrable
-        ? InferUnionResult(inferred, inferrable.name, left, inferrable.type)
-        : (() => {
-            const [head, ...tail] = left;
-            return IsSchema(head)
-                ? (() => {
-                    const check = ExtendsLeft(inferred, head, right);
-                    return Result.IsExtendsTrueLike(check)
-                        ? ExtendsTupleToArray(check.inferred, tail, right)
-                        : Result.ExtendsFalse();
-                })()
-                : Result.ExtendsTrue(inferred);
-        })());
+        ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
+        : Result.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, { callstack: [] }, left);

package/build/type/extends/union.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import { IsSchema } from '../types/schema.mjs';
 import { IsUnion } from '../types/union.mjs';
 import { ExtendsLeft } from './extends-left.mjs';
 import * as Result from './result.mjs';
@@ -8,22 +7,10 @@ import * as Result from './result.mjs';
 // ----------------------------------------------------------------------------
 import { IsInferable, TryInferable, InferUnionResult } from './inference.mjs';
 function ExtendsUnionSome(inferred, type, unionTypes) {
-    const [head, ...tail] = unionTypes;
-    return (IsSchema(head) ? (() => {
-        const check = ExtendsLeft(inferred, type, head);
-        return Result.IsExtendsTrueLike(check)
-            ? Result.ExtendsTrue(check.inferred)
-            : ExtendsUnionSome(inferred, type, tail);
-    })() : Result.ExtendsFalse());
+    return Result.TakeLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
 }
 function ExtendsUnionLeft(inferred, left, right) {
-    const [head, ...tail] = left;
-    return (IsSchema(head) ? (() => {
-        const check = ExtendsUnionSome(inferred, head, right);
-        return Result.IsExtendsTrueLike(check)
-            ? ExtendsUnionLeft(check.inferred, tail, right)
-            : Result.ExtendsFalse();
-    })() : Result.ExtendsTrue(inferred));
+    return Result.TakeLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 export function ExtendsUnion(inferred, left, right) {
     const inferrable = TryInferable(right);

package/build/type/script/mapping.d.mts

@@ -164,7 +164,7 @@ export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, u
 export declare function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | []): unknown;
 export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown> = (Input extends ['(', infer Type extends T.TSchema, ')'] ? Type : Input extends infer Type extends T.TSchema ? Type : never);
 export declare function BaseMapping(input: [unknown, unknown, unknown] | unknown): unknown;
-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] ? C.TIndexDeferred<TFactorIndexArray<Type, Left>, Indexer> : Right extends [] ? T.TArray<TFactorIndexArray<Type, Left>> : T.TNever) : Type);
+type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<C.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
 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] ? C.TConditionalDeferred<Type, Right, True, False> : Type);
 export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[]] ? KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend> : never);
 export declare function FactorMapping(input: [unknown, unknown, unknown, unknown]): unknown;

package/build/type/script/mapping.mjs

@@ -188,10 +188,10 @@ export function BaseMapping(input) {
 // deno-coverage-ignore-start
 // ...
 const FactorIndexArray = (Type, indexArray) => {
-    return indexArray.reduceRight((result, right) => {
-        const _right = right;
-        return (Guard.IsEqual(_right.length, 1) ? C.IndexDeferred(result, _right[0]) :
-            Guard.IsEqual(_right.length, 0) ? T.Array(result) :
+    return indexArray.reduce((result, left) => {
+        const _left = left;
+        return (Guard.IsEqual(_left.length, 1) ? C.IndexDeferred(result, _left[0]) :
+            Guard.IsEqual(_left.length, 0) ? T.Array(result) :
                 Unreachable());
     }, Type);
 };

package/build/value/codec/from-ref.mjs

@@ -2,9 +2,30 @@
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from-type.mjs';
 import { Callback } from './callback.mjs';
-export function FromRef(direction, context, type, value) {
-    value = Guard.HasPropertyKey(context, type.$ref)
+// ------------------------------------------------------------------
+// ResolveRef
+// ------------------------------------------------------------------
+function ResolveRef(direction, context, type, value) {
+    return Guard.HasPropertyKey(context, type.$ref)
         ? FromType(direction, context, context[type.$ref], value)
         : value;
-    return Callback(direction, context, type, value);
+}
+// ------------------------------------------------------------------
+// FromRef
+//
+// Decode and Encode apply the Callback and the referenced type's
+// codec pipeline in opposite orders, since the two operations are
+// inverses of each other.
+//
+// Decode: referenced type resolves first, Callback runs after.
+//   wire value -> resolve $ref -> Callback -> decoded value
+//
+// Encode: Callback runs first, referenced type resolves after.
+//   encoded value -> Callback -> resolve $ref -> wire value
+//
+// ------------------------------------------------------------------
+export function FromRef(direction, context, type, value) {
+    return Guard.IsEqual(direction, 'Decode')
+        ? Callback(direction, context, type, ResolveRef(direction, context, type, value))
+        : ResolveRef(direction, context, type, Callback(direction, context, type, value));
 }

package/package.json

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

package/readme.md

@@ -28,21 +28,21 @@ $ npm install typebox
 ```typescript
 import Type from 'typebox'
 
-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 = Type.Static<typeof T>                      // type T = {
-                                                    //   x: number,
-                                                    //   y: number,
-                                                    //   z: number
-                                                    // }
+const T = Type.Object({                     // const T = {
+  x: Type.Number(),                         //   type: 'object',
+  y: Type.Number(),                         //   properties: {
+  z: Type.Number()                          //     x: { type: 'number' },
+})                                          //     y: { type: 'number' },
+                                            //     z: { type: 'number' }
+                                            //   },
+                                            //   required: ['x', 'y', 'z']
+                                            // }
+
+type T = Type.Static<typeof T>              // type T = {
+                                            //   x: number,
+                                            //   y: number,
+                                            //   z: number
+                                            // }
 ```
 
 ## Overview
@@ -58,7 +58,6 @@ License: MIT
 ## Contents
 
 - [Type](#Type)
-- [Value](#Value)
 - [Script](#Script)
 - [Schema](#Schema)
 - [Versions](#Versions)
@@ -69,157 +68,163 @@ License: MIT
 
 ## Type
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview)
+[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)
 
-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 types are JSON Schema fragments that can 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.
 
 ## Example
 
-The following creates a JSON Schema type and infers with Static.
+The following creates a User type and infers with Static.
 
 ```typescript
 import Type from 'typebox'
 
-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 = Type.Static<typeof T>                      // type T = {
-                                                    //   x: number,
-                                                    //   y: number,
-                                                    //   z: number
-                                                    // }
+// -------------------------------------------------------------------------------
+// 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' },
+                                                 //     email: { 
+                                                 //       type: 'string', 
+                                                 //       format: 'email' 
+                                                 //     }
+                                                 //   }
+                                                 //   required: [
+                                                 //     'id', 
+                                                 //     'name', 
+                                                 //     'email'
+                                                 //   ]
+                                                 // }
+
+// -------------------------------------------------------------------------------
+// Static
+// -------------------------------------------------------------------------------
+
+type User = Type.Static<typeof User>              // type User = {
+                                                  //   id: string,
+                                                  //   name: string,
+                                                  //   email: string
+                                                  // }
 ```
 
-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
-                                                    // }
-```
+## Script
 
-<a name="Value"></a>
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFonmXW32POvueHb6AygGMowMDH6Ne0mbLnNqQiADsAzvADecAKqrUUADQ69UbWAAmAQxjoAvnAC8iIgDpho8QAoABtTjBlGygMSyF0AFFA4EI4DUo4f3MALjh1UWUAc3jbPwCgkLDjfThUMhtlc1U4SJhopFi4eITlSxBUFLSAjKMmkpBLYAAbDph0jMa4HPjCNCLTC2t0J3CAN0tBgFdFgB5egAVgIQBrbd19IyPUJAgMaqjCAD44ADIJhL3LWGB17YB5EGipxMFyuNzutUeD3iUO8AEpqHQpPJkSiUZIAEqoDCDVBCCSI1GEom8RQqVQQHEuQYQDKeM5QWEJJnMlmstksxFxdncnm83mIhIzdr4CDEABWuJgeAMvT5cvlbIFcDA2DQX1QqhSXIVOt1SoSwGSDSFKTwnUyeEmMt1Nvl+rgLTaWrgJvw5oylts1ttPu59tQ-SGztdZtGXU9st9UYSSq9kejvqVUFQAEcNsBk0aANrxhO2+14Q3St55qMFx2oYu50s6gsBgaDKg1sv0BIAXWrzbliKmSjUFNQVJpdJMZisNkZec5na7-NbLqIptFErx0pns7985VEDVtQ1WvXG8V84NRq0Ifdnu9R4V9orwcXbrDFqth5vzP9geGxsfobGEffW95zjQC7XnZM0wzVBs0Lcw8A7UDu3oKYCWJND0IUREBBgaxDkkDCCOJaghTmRxnDQNwcNqIRtiFMF6SeJCF1mekyO1RC5yZQ0RjGa8OM3Jl71SZ9ujfRClXrINhLGMTQJ7YiiDmMdFjI5AKOw3CaLo256WUmxGMREjdIWGw2NkwClW46Suj4-jj0E1pUAAfh4mzzPfCSvxc6zMncm95KAA) | [Example 2](https://www.typescriptlang.org/play/#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFonmXW32POvnb7k1ejbsJGj21AMYQAdgGd4AUWkxghOAF5ERAHQB5YgCtUEmAAoA3pThxgAEwBcWtNoDKMKMGkBzUwEpKAL7+lFJy8ACqsqhQGk6o2gCSytEYAIYSqKYA2koqhAC6ADRwltbSqSCojvzxbh7efoVWcKggqcAANtU6dZ4+-kGSMvJwkdHhYLapMOiaNdoKAG6pHQCu05nzSTNQUSbZzfMACsASANamY1DF8wDSqEi6GKa5qki+vk3Wx6mwwCumea6ECqS5Ra5xbT3R7PV6ED7+fIfah0IRidEYzHcQQAJVQGA6xhggixpLJWKGcgghO0HQgPiuvmszJZrLZ7NZqNKHJ5vL5vNR1kIaEceAghiJeC+-Jlsp5grgYGwaD+qFkjm5cq1WoV1jsGrgwqq+Hk9S8eDgAWl2pt-N1cHKlQNRtFpr6FqtzVt3o59ta7S6JUNRFd7ndlq9PqjzIVnuj8esCqgqAAjqtgMmHHAspGE977Xg7FK4Lm8zaC47UMXS2WdfQWXh-Z0qLWfQr8jXWzLUQFKbJqfE6QzwRMpjMmQmuZ2u3yFS78OKjCYpdOZ-L64rldEVGqNau1+z7fqg-O8G7vB7rQfuxuyhVjeZgyKTWGL5ar9fZ7eWm1Os6Qy+Zoevun4xhucagXaG7JmmGaoFmWSFrYeAdpBUERiS5JYdhnCCG40ynJhOHEcR1BGqM4KxPM+EqBIAA8RoQBgFHRAAfLKqLkVcsSamh67Mse55eB+fFsgqlaOEJImiSyCpNoGQkgWhPZkUQLFQKOGxUT0MAEfRjHMVcmkzOxcCcWpRmTFpmi8TJnIboJr7CUpkHifeAD8klOdJdlmRu8meXAim+Ye9ABEAA)
 
-## Value
+TypeBox can transform TypeScript definitions into JSON Schema. The Script function provides an optional programmatic syntax to rapidly convert type definitions into JSON Schema, or serve more generally as an alternative to Type.* builders. The Script function is designed to handle a wide array of complex TypeScript type-level expressions.
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview)
+### Example
 
-The Value submodule provides functions for validation and other typed operations on JavaScript values. It includes functions such as Check, Parse, Clone, Encode, and Decode, as well as advanced functions for performing structural Diff and Patch operations on dynamic JavaScript values.
+The following uses the Script to parse interfaces into JSON Schema.
 
 ```typescript
-import Value from 'typebox/value'
-```
-
-### Example
+import Type from 'typebox'
 
-The following uses the Value module to Parse a value. 
+// -------------------------------------------------------------------------------
+// Script
+// -------------------------------------------------------------------------------
 
-```typescript
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-})
-
-const A = Value.Parse(T, {                          // const A: {
-  x: 1,                                             //   x: number,
-  y: 0,                                             //   y: number,
-  z: 0                                              //   z: number
-})                                                  // } = ...
-```
+const { User, UserUpdate } = Type.Script(`
 
-## Script
+ interface Entity {
+  id: string
+ }
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview)
+ interface User extends Entity { 
+   name: string, 
+   email: string 
+ }
 
-TypeBox includes a runtime TypeScript DSL engine that can transform TypeScript syntax into JSON Schema. The engine is implemented at runtime and within the TypeScript type system.
+ type UserUpdate = Evaluate<
+   Pick<User, keyof Entity> & 
+   Partial<Omit<User, keyof Entity>>
+ >
+`)
 
-```typescript
-// ----------------------------------------------------------
-// Script
-// ----------------------------------------------------------
-const T = Type.Script(`{ 
-  x: number, 
-  y: string, 
-  z: boolean 
-}`)
-
-// ----------------------------------------------------------
+// -------------------------------------------------------------------------------
 // Reflect
-// ----------------------------------------------------------
-T.type                                              // 'object'
-T.required                                          // ['x', 'y', 'z']
-T.properties                                        // { x: ..., y: ..., z: ... }
-
-// ----------------------------------------------------------
-// Computed
-// ----------------------------------------------------------
-const S = Type.Script({ T }, `{
-  [K in keyof T]: T[K] | null
-}`)
-
-// ----------------------------------------------------------
-// Inference
-// ----------------------------------------------------------
-type S = Type.Static<typeof S>                      // type S = {
-                                                    //   x: number | null,
-                                                    //   y: string | null,
-                                                    //   z: boolean | null
-                                                    // }
+// -------------------------------------------------------------------------------
+
+console.log(User)                                // {
+                                                 //   type: 'object',
+                                                 //   properties: {
+                                                 //     id: { type: 'string' },
+                                                 //     name: { type: 'string' },
+                                                 //     email: { type: 'string' }
+                                                 //   },
+                                                 //   required: [
+                                                 //     'id', 
+                                                 //     'name', 
+                                                 //     'email'
+                                                 //   ]
+                                                 // }
+
+console.log(UserUpdate)                          // {
+                                                 //   type: 'object',
+                                                 //   properties: {
+                                                 //     id: { type: 'string' },
+                                                 //     name: { type: 'string' },
+                                                 //     email: { type: 'string' }
+                                                 //   },
+                                                 //   required: ['id']
+                                                 // }
+
+// -------------------------------------------------------------------------------
+// Static
+// -------------------------------------------------------------------------------
+
+type User = Type.Static<typeof User>              // type User = {
+                                                  //   id: string,
+                                                  //   name: string,
+                                                  //   email: string
+                                                  // }
+
+type UserUpdate = Type.Static<typeof UserUpdate>  // type UserUpdate = {
+                                                  //   id: string,
+                                                  //   name?: string,
+                                                  //   email?: string
+                                                  // }
+
 ```
 
 <a name="Schema"></a>
 
 ## Schema
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQokscAKuWrnyES-ajXZs6dOAFo58hYqXKVqteo0zJ0gMIEwwADZptszeYuWr8tmyQQAdg3gBVBmihwAvImZYAdHrgRmgAFHwU-gDylABWaEgwoQDebHBwwAAmAFy8-P4IMFDADgDmoQCUADRpcA6YIGi5EWgFRSXl1bUsRs35hcVlKbjQWDC5RD2GRHAAvhVs8wum1qtr61pScAAKmFDuKxtHx6q29k7wAK7unj5uHv67+2HJ6W-vH5-vW+fOcNceXKpdJZCYANgArDgAIyYABMlAAzEgACyZCFoME4ADsmAAHJQAJxIAAMmWhRCqX2pcC2IJycGcg1KNXS9UaEwBUEpNN5fO+0jZDSajPaZVZcCmnJuAAFMgRMCV-PYQDN+by6ZKsL1RczFhV1YajR8trNvHB-JagA) | [Example 2](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQbddcAtH-wMFDhI0WPESenbgGECYYABs003pPUbNW-hyQQAdg3gBVBmihwAvImZYAdHPBK0ACgDebOHDIUAXMQhKACs0JBgiABpPODB8ClhgNAZ-Dy8vYAATFO9yNH8iIyhgfQBzIjgAXyi0uH1MEDy4Nxy-YkLissrqtJYlbJ9Ggpgi0vKK6KroqDQARwBXYGmsuABtaK8iTMi4deI6hu3dol7Fdi8AXTYKgEoOLjVtR6en1QAFTCgzVWef38ldAxGOBzMwWaymcx2d6fVzNGrwhGIuD3PSGeAg8wpaKZfIANgArDgAIyYABMlAAzEgACwZfFoXE4ADsmAAHJQAJxIAAMGSJ2yRiPu6WW7VK3X2gwxUAFgrl8q8wtq9UaYpK3RO+WlAAEMgRMMU7HoQOUFXKlZq4GqrtczXb7fD7hUrHA7G6gA)
 
-The Schema submodule is a low level JSON Schema spec compliant validation system that supports Drafts 3 through to 2020-12. This validation system is decoupled from both Type.* and Value.* submodules and is designed to be an ultra lightweight, high performance alternative to Ajv for compiling and validating with native JSON Schema.
-
-```typescript
-import Schema from 'typebox/schema'
-```
+TypeBox includes high performance validation compiler for JSON Schema Drafts 3 through to 2020-12. The compiler supports both TypeBox and JSON Schema, and will convert schematics into high performance validation routines. The compiler is designed to be a lightweight spec compliant alternative to Ajv for high-throughput applications.
 
 ### Example
 
-The following uses the Schema submodule to compile and parse from JSON Schema.
+The following uses the Schema submodule to compile a TypeBox type.
 
 ```typescript
-// ----------------------------------------------------------
+import Schema from 'typebox/schema'
+
+// -------------------------------------------------------------------------------
 // Compile
-// ----------------------------------------------------------
-const C = Schema.Compile({
-  type: 'object',
-  required: ['x', 'y', 'z'],
-  properties: {
-    x: { type: 'number' },
-    y: { type: 'number' },
-    z: { type: 'number' }
-  }
-})
-
-// ----------------------------------------------------------
+// -------------------------------------------------------------------------------
+
+const User = Schema.Compile(Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  email: Type.String({ format: 'email' })
+}))
+
+// -------------------------------------------------------------------------------
 // Parse
-// ----------------------------------------------------------
-const R = C.Parse({  x: 0, y: 0, z: 0 })            // const R: {
-                                                    //   x: number,
-                                                    //   y: number,
-                                                    //   z: number
-                                                    // } = ...
+// -------------------------------------------------------------------------------
+
+const user = User.Parse({                        // const user: {
+  id: '65f1a2b3c4d5e6f7a8b9c0d1',                //   id: string,
+  name: 'user',                                  //   name: string,
+  email: 'user@domain.com'                       //   email: string
+})                                               // } = ...
 ```
 
 <a name="Versions"></a>
@@ -228,25 +233,10 @@ const R = C.Parse({  x: 0, y: 0, z: 0 })            // const R: {
 
 TypeBox provides two distinct versions that span two generations of the TypeScript compiler.
 
-### Version 0.x
-
-```bash
-$ npm install @sinclair/typebox                     # 0.x - LTS    | TS 4-6
-```
-
-Developed against TypeScript 4-6 and maintained under Long Term Support (LTS) for existing infrastructure on the 0.x revision line. ESM and CJS compatible.
-
-### Version 1.x
-
-```bash
-$ npm install typebox                               # 1.x - Latest | TS 7 Native
-```
-
-Developed against the TypeScript 7 native compiler with advanced type inference and JSON Schema 2020-12 compliant validation, with backwards compatibility for `0.x` types. ESM only.
-
-### Additional
-
-The `1.x` version is recommended for most new projects and is the active development line that targets optimizations enabled by the TypeScript 7 native compiler. The `0.x` version is maintained under LTS for environments requiring CJS and ESM compatibility as well as support for older TypeScript compiler versions. For issues relating to `0.x` please submit them to the [TypeBox 0.x](https://github.com/sinclairzx81/sinclair-typebox) repository.
+| Version | TypeScript | Description |
+| :--- | :--- | :--- |
+| **1.x** | **6.0 - 7.0+** | **Latest.** Developed against the TypeScript 7 native compiler. Provides advanced type inference and native JSON Schema 2020-12 support. Includes backwards compatibility with `0.x` types. **ESM only.** |
+| **0.x** | **5.0 - 6.0** | **LTS.** Developed against older TypeScript versions and actively maintained under Long Term Support. Compatible with both **ESM and CJS**. Issues should be submitted to the [Sinclair TypeBox](https://github.com/sinclairzx81/sinclair-typebox) repository. |
 
 ## Contribute