typebox 1.1.12 → 1.1.13

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 : Right extends TUnknown ? Result.TExtendsTrue : 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';
@@ -26,26 +25,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 : Right extends TUnknown ? Result.TExtendsTrue : 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';
@@ -12,25 +11,19 @@ function ParameterCompare(inferred, left, leftRest, right, rightRest) {
     const isRightOptional = IsOptional(right);
     const check = ExtendsLeft(inferred, checkLeft, checkRight);
     return (!isLeftOptional && isRightOptional
-        ? Result.ExtendsFalse()
+        ? Result.ExtendsFalse() // 'fail: left-required-but-right-is-optional'
         : Result.IsExtendsTrueLike(check)
             ? ExtendsParameters(check.inferred, leftRest, rightRest)
-            : Result.ExtendsFalse());
+            : 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

@@ -31,23 +31,16 @@ function ElementsCompare(inferred, reversed, left, leftRest, right, rightRest) {
 }
 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 +53,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.13",
   "keywords": [
     "typescript",
     "jsonschema"