typebox 0.0.1 → 1.0.0-rc

package/build/type/engine/cyclic/dependencies.mjs

@@ -0,0 +1,53 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { IsAsyncIterator } from '../../types/async-iterator.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsIterator } from '../../types/iterator.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsPromise } from '../../types/promise.mjs';
+import { PropertyValues } from '../../types/properties.mjs';
+import { IsRecord, RecordValue } from '../../types/record.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { IsInterfaceDeferred } from '../../action/interface.mjs';
+function FromRef(context, ref, result) {
+    return (result.includes(ref)
+        ? result
+        : ref in context
+            ? FromType(context, context[ref], [...result, ref])
+            : Unreachable());
+}
+function FromProperties(context, properties, result) {
+    const types = PropertyValues(properties);
+    return FromTypes(context, types, result);
+}
+function FromTypes(context, types, result) {
+    return types.reduce((result, left) => {
+        return FromType(context, left, result);
+    }, result);
+}
+function FromType(context, type, result) {
+    return (IsRef(type) ? FromRef(context, type.$ref, result) :
+        IsArray(type) ? FromType(context, type.items, result) :
+            IsAsyncIterator(type) ? FromType(context, type.iteratorItems, result) :
+                IsConstructor(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
+                    IsFunction(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
+                        IsInterfaceDeferred(type) ? FromProperties(context, type.parameters[1], result) :
+                            IsIntersect(type) ? FromTypes(context, type.allOf, result) :
+                                IsIterator(type) ? FromType(context, type.iteratorItems, result) :
+                                    IsObject(type) ? FromProperties(context, type.properties, result) :
+                                        IsPromise(type) ? FromType(context, type.item, result) :
+                                            IsUnion(type) ? FromTypes(context, type.anyOf, result) :
+                                                IsTuple(type) ? FromTypes(context, type.items, result) :
+                                                    IsRecord(type) ? FromType(context, RecordValue(type), result) :
+                                                        result);
+}
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export function CyclicDependencies(context, key, type) {
+    const result = FromType(context, type, [key]);
+    return result;
+}

package/build/type/engine/cyclic/extends.d.mts

@@ -0,0 +1,31 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TAsyncIterator } from '../../types/async-iterator.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TIterator } from '../../types/iterator.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TPromise } from '../../types/promise.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TUnknown } from '../../types/unknown.mjs';
+type TFromRef<_Ref extends string> = (TAny);
+type TFromProperties<Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromType<Properties[Key]>;
+}> = {
+    [Key in keyof Result]: Result[Key];
+};
+type TFromTypes<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, [...Result, TFromType<Left>]> : Result;
+type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
+type TCyclicAnyFromParameters<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? TFromType<Defs[Ref]> : TUnknown);
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export type TCyclicExtends<Type extends TCyclic, Result extends TSchema = TCyclicAnyFromParameters<Type['$defs'], Type['$ref']>> = Result;
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export declare function CyclicExtends<Type extends TCyclic>(type: Type): TCyclicExtends<Type>;
+export {};

package/build/type/engine/cyclic/extends.mjs

@@ -0,0 +1,53 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Any } from '../../types/any.mjs';
+import { Array, IsArray, ArrayOptions } from '../../types/array.mjs';
+import { AsyncIterator, IsAsyncIterator } from '../../types/async-iterator.mjs';
+import { Constructor, IsConstructor } from '../../types/constructor.mjs';
+import { Function, IsFunction } from '../../types/function.mjs';
+import { Intersect, IsIntersect } from '../../types/intersect.mjs';
+import { Iterator, IsIterator } from '../../types/iterator.mjs';
+import { Object, IsObject } from '../../types/object.mjs';
+import { Promise, IsPromise } from '../../types/promise.mjs';
+import { IsRecord, Record, RecordKey, RecordValue } from '../../types/record.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { Tuple, IsTuple } from '../../types/tuple.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
+import { Unknown } from '../../types/unknown.mjs';
+function FromRef(_ref) {
+    return Any();
+}
+function FromProperties(properties) {
+    return Guard.Keys(properties).reduce((result, key) => {
+        return { ...result, [key]: FromType(properties[key]) };
+    }, {});
+}
+function FromTypes(types) {
+    return types.reduce((result, left) => {
+        return [...result, FromType(left)];
+    }, []);
+}
+function FromType(type) {
+    return (IsRef(type) ? FromRef(type.$ref) :
+        IsArray(type) ? Array(FromType(type.items), ArrayOptions(type)) :
+            IsAsyncIterator(type) ? AsyncIterator(FromType(type.iteratorItems)) :
+                IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
+                    IsFunction(type) ? Function(FromTypes(type.parameters), FromType(type.returnType)) :
+                        IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
+                            IsIterator(type) ? Iterator(FromType(type.iteratorItems)) :
+                                IsObject(type) ? Object(FromProperties(type.properties)) :
+                                    IsPromise(type) ? Promise(FromType(type.item)) :
+                                        IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
+                                            IsUnion(type) ? Union(FromTypes(type.anyOf)) :
+                                                IsTuple(type) ? Tuple(FromTypes(type.items)) :
+                                                    type);
+}
+function CyclicAnyFromParameters(defs, ref) {
+    return (ref in defs
+        ? FromType(defs[ref])
+        : Unknown());
+}
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export function CyclicExtends(type) {
+    return CyclicAnyFromParameters(type.$defs, type.$ref);
+}

package/build/type/engine/cyclic/index.d.mts

@@ -0,0 +1,6 @@
+export * from './candidates.mjs';
+export * from './check.mjs';
+export * from './dependencies.mjs';
+export * from './extends.mjs';
+export * from './instantiate.mjs';
+export * from './target.mjs';

package/build/type/engine/cyclic/index.mjs

@@ -0,0 +1,6 @@
+export * from './candidates.mjs';
+export * from './check.mjs';
+export * from './dependencies.mjs';
+export * from './extends.mjs';
+export * from './instantiate.mjs';
+export * from './target.mjs';

package/build/type/engine/cyclic/instantiate.d.mts

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TCyclicDependencies } from '../cyclic/dependencies.mjs';
+import { type TInterfaceDeferred } from '../../action/index.mjs';
+import { type TInstantiateProperties } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
+    callstack: [];
+}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, {
+    callstack: [];
+}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+type TCyclicDefinitions<Context extends TProperties, Dependencies extends string[], Result extends TProperties = {
+    [Key in Extract<keyof Context, Dependencies[number]>]: Context[Key] extends TInterfaceDeferred<infer Heritage extends TSchema[], infer Properties extends TProperties> ? TCyclicInterface<Context, Heritage, Properties> : Context[Key];
+}> = Result;
+export type TInstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema, Dependencies extends string[] = TCyclicDependencies<Context, Ref, Type>, Definitions extends TProperties = TCyclicDefinitions<Context, Dependencies>, Result extends TSchema = TCyclic<Definitions, Ref>> = Result;
+export declare function InstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema>(context: Context, ref: Ref, type: Type): TInstantiateCyclic<Context, Ref, Type>;
+export {};

package/build/type/engine/cyclic/instantiate.mjs

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Cyclic } from '../../types/cyclic.mjs';
+import { Object } from '../../types/object.mjs';
+import { CyclicDependencies } from '../cyclic/dependencies.mjs';
+import { IsInterfaceDeferred } from '../../action/index.mjs';
+import { InstantiateProperties } from '../instantiate.mjs';
+import { InstantiateTypes } from '../instantiate.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+function CyclicInterface(context, heritage, properties) {
+    const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
+    const instantiatedProperties = InstantiateProperties({}, { callstack: [] }, properties);
+    const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object(instantiatedProperties)]);
+    return evaluatedInterface;
+}
+function CyclicDefinitions(context, dependencies) {
+    const keys = Guard.Keys(context).filter(key => dependencies.includes(key));
+    return keys.reduce((result, key) => {
+        const type = context[key];
+        const instantiatedType = IsInterfaceDeferred(type) ? CyclicInterface(context, type.parameters[0], type.parameters[1]) : type;
+        return { ...result, [key]: instantiatedType };
+    }, {});
+}
+export function InstantiateCyclic(context, ref, type) {
+    const dependencies = CyclicDependencies(context, ref, type);
+    const definitions = CyclicDefinitions(context, dependencies);
+    const result = Cyclic(definitions, ref);
+    return result;
+}

package/build/type/engine/cyclic/target.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TRef } from '../../types/ref.mjs';
+type TResolve<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? Defs[Ref] extends TRef<infer Ref extends string> ? TResolve<Defs, Ref> : Defs[Ref] : TNever);
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+export type TCyclicTarget<Defs extends TProperties, Ref extends string, Result extends TSchema = TResolve<Defs, Ref>> = Result;
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+export declare function CyclicTarget<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TCyclicTarget<Defs, Ref>;
+export {};

package/build/type/engine/cyclic/target.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Never } from '../../types/never.mjs';
+import { IsRef } from '../../types/ref.mjs';
+function Resolve(defs, ref) {
+    return (ref in defs
+        ? IsRef(defs[ref])
+            // @ts-ignore 5.0.4 - does not see $ref
+            ? Resolve(defs, defs[ref].$ref)
+            : defs[ref]
+        : Never());
+}
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+export function CyclicTarget(defs, ref) {
+    const result = Resolve(defs, ref);
+    return result;
+}

package/build/type/engine/enum/enum-to-union.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TNull } from '../../types/null.mjs';
+import { type TNever } from '../../types/never.mjs';
+type TFromEnumValue<Value extends TEnumValue, Result extends TSchema = Value extends string | number ? TLiteral<Value> : Value extends null ? TNull : TNever> = Result;
+export type TEnumValuesToVariants<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEnumValuesToVariants<Right, [...Result, TFromEnumValue<Left>]> : Result);
+export declare function EnumValuesToVariants<Values extends TEnumValue[]>(values: [...Values]): TEnumValuesToVariants<Values>;
+export type TEnumValuesToUnion<Values extends TEnumValue[], Variants extends TSchema[] = TEnumValuesToVariants<Values>, Results extends TSchema = TUnion<Variants>> = Results;
+export declare function EnumValuesToUnion<Values extends TEnumValue[]>(values: [...Values]): TEnumValuesToUnion<Values>;
+export type TEnumToUnion<Type extends TEnum, Result extends TSchema = TEnumValuesToUnion<Type['enum']>> = Result;
+export declare function EnumToUnion<Type extends TEnum>(type: Type): TEnumToUnion<Type>;
+export {};

package/build/type/engine/enum/enum-to-union.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Union } from '../../types/union.mjs';
+import { Literal } from '../../types/literal.mjs';
+import { Null } from '../../types/null.mjs';
+import { Never } from '../../types/never.mjs';
+function FromEnumValue(value) {
+    return (Guard.IsString(value) || Guard.IsNumber(value) ? Literal(value) :
+        Guard.IsNull(value) ? Null() :
+            Never());
+}
+export function EnumValuesToVariants(values) {
+    const result = values.map(value => FromEnumValue(value));
+    return result;
+}
+export function EnumValuesToUnion(values) {
+    const variants = EnumValuesToVariants(values);
+    const result = Union(variants);
+    return result;
+}
+export function EnumToUnion(type) {
+    const result = EnumValuesToUnion(type.enum);
+    return result;
+}

package/build/type/engine/enum/index.d.mts

@@ -0,0 +1,2 @@
+export * from './enum-to-union.mjs';
+export * from './typescript-enum-to-enum-values.mjs';

package/build/type/engine/enum/index.mjs

@@ -0,0 +1,2 @@
+export * from './enum-to-union.mjs';
+export * from './typescript-enum-to-enum-values.mjs';

package/build/type/engine/enum/typescript-enum-to-enum-values.d.mts

@@ -0,0 +1,7 @@
+import { type TEnumValue } from '../../types/enum.mjs';
+import { type TUnionToTuple } from '../helpers/union.mjs';
+export type TTSEnumLike = Record<PropertyKey, TEnumValue>;
+type TReduceEnumValues<Keys extends string[], Type extends TTSEnumLike, Result extends TEnumValue[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TReduceEnumValues<Right, Type, [...Result, Type[Left]]> : Result);
+export type TTSEnumToEnumValues<Type extends TTSEnumLike, EnumKeys extends string[] = TUnionToTuple<Extract<keyof Type, string>>, Elements extends TEnumValue[] = TReduceEnumValues<EnumKeys, Type>> = Elements;
+export declare function TSEnumToEnumValues<Type extends TTSEnumLike>(type: Type): TTSEnumToEnumValues<Type>;
+export {};

package/build/type/engine/enum/typescript-enum-to-enum-values.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+export function TSEnumToEnumValues(type) {
+    const keys = Guard.Keys(type).filter((key) => isNaN(key));
+    return keys.reduce((result, key) => [...result, type[key]], []);
+}

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

@@ -0,0 +1,16 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TCompare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
+import { type TFlatten } from './flatten.mjs';
+import { type TEvaluateType } from './evaluate.mjs';
+type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultRightInside ? TBroadFilter<Type, Right, [...Result]> : TBroadFilter<Type, Right, [...Result, Left]> : Result);
+type TIsBroadestType<Type extends TSchema, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultLeftInside | typeof ResultEqual ? false : TIsBroadestType<Type, Right> : true);
+type TBroadenType<Type extends TSchema, Types extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>, Result extends TSchema[] = (Evaluated extends TAny ? [Evaluated] : TIsBroadestType<Evaluated, Types> extends true ? [...TBroadFilter<Evaluated, Types>, Evaluated] : Types)> = Result;
+type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : TBroadenTypes<Right, TBroadenType<Left, Result>> : Result);
+export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>, Result extends TSchema = (Flattened extends [] ? TNever : Flattened extends [infer Type extends TSchema] ? Type : TUnion<Flattened>)> = Result;
+/** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
+export declare function Broaden<Types extends TSchema[]>(types: [...Types]): TBroaden<Types>;
+export {};

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

@@ -0,0 +1,48 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsSchema } from '../../types/schema.mjs';
+import { IsAny } from '../../types/any.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { Union } from '../../types/union.mjs';
+import { Compare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
+import { Flatten } from './flatten.mjs';
+import { EvaluateType } from './evaluate.mjs';
+function BroadFilter(type, types) {
+    return types.filter(left => {
+        return Compare(type, left) === ResultRightInside
+            ? false
+            : true;
+    });
+}
+function IsBroadestType(type, types) {
+    const result = types.some(left => {
+        const result = Compare(type, left);
+        return Guard.IsEqual(result, ResultLeftInside) || Guard.IsEqual(result, ResultEqual);
+    });
+    return Guard.IsEqual(result, false);
+}
+function BroadenType(type, types) {
+    const evaluated = EvaluateType(type);
+    return (IsAny(evaluated) ? [evaluated] :
+        IsBroadestType(evaluated, types)
+            ? [...BroadFilter(evaluated, types), evaluated]
+            : types);
+}
+function BroadenTypes(types, result = []) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? IsObject(left)
+            ? BroadenTypes(right, [...result, left]) // special: push object type
+            : BroadenTypes(right, BroadenType(left, result))
+        : result);
+}
+/** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
+export function Broaden(types) {
+    const broadened = BroadenTypes(types);
+    const flattened = Flatten(broadened);
+    const result = (flattened.length === 0 ? Never() :
+        flattened.length === 1 ? flattened[0] :
+            Union(flattened));
+    return result;
+}

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

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TUnknown } from '../../types/unknown.mjs';
+import { type TExtends, ExtendsResult } from "../../extends/index.mjs";
+export declare const ResultEqual = "equal";
+export declare const ResultDisjoint = "disjoint";
+export declare const ResultLeftInside = "left-inside";
+export declare const ResultRightInside = "right-inside";
+export type TCompareResult = typeof ResultEqual | typeof ResultDisjoint | typeof ResultLeftInside | typeof ResultRightInside;
+/** Compares left and right types and determines their set relationship */
+export type TCompare<Left extends TSchema, Right extends TSchema, Extends extends [ExtendsResult.TResult, ExtendsResult.TResult] = [
+    Left extends TUnknown ? ExtendsResult.TExtendsFalse : TExtends<{}, Left, Right>,
+    Left extends TUnknown ? ExtendsResult.TExtendsTrue : TExtends<{}, Right, Left>
+]> = (Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsTrueLike] ? typeof ResultEqual : Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsFalse] ? typeof ResultLeftInside : Extends extends [ExtendsResult.TExtendsFalse, ExtendsResult.TExtendsTrueLike] ? typeof ResultRightInside : typeof ResultDisjoint);
+/** Compares left and right types and determines their set relationship. */
+export declare function Compare<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TCompare<Left, Right>;

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

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { IsUnknown } from '../../types/unknown.mjs';
+import { Extends, ExtendsResult } from "../../extends/index.mjs";
+// ------------------------------------------------------------------
+// TCompare
+// ------------------------------------------------------------------
+export const ResultEqual = 'equal';
+export const ResultDisjoint = 'disjoint';
+export const ResultLeftInside = 'left-inside';
+export const ResultRightInside = 'right-inside';
+/** Compares left and right types and determines their set relationship. */
+export function Compare(left, right) {
+    const extendsCheck = [
+        IsUnknown(left) ? ExtendsResult.ExtendsFalse() : Extends({}, left, right),
+        IsUnknown(left) ? ExtendsResult.ExtendsTrue({}) : Extends({}, right, left),
+    ];
+    return (ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? ResultEqual :
+        ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && ExtendsResult.IsExtendsFalse(extendsCheck[1]) ? ResultLeftInside :
+            ExtendsResult.IsExtendsFalse(extendsCheck[0]) && ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? ResultRightInside :
+                ResultDisjoint);
+}

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

@@ -0,0 +1,30 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TReadonly, type TReadonlyAdd, type TReadonlyRemove } from '../../types/_readonly.mjs';
+import { type TOptional, type TOptionalAdd, type TOptionalRemove } from '../../types/_optional.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TTupleElementsToProperties } from '../tuple/to-object.mjs';
+import { type TEvaluateIntersect } from './evaluate.mjs';
+type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
+type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
+type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TReadonlyRemove<TOptionalRemove<Evaluated>>> = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TReadonlyAdd<TOptionalAdd<Property>> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TReadonlyAdd<Property> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TOptionalAdd<Property> : Property);
+type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
+type TCompositeProperties<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
+    [Key in keyof (Right & Left)]: TCompositePropertyKey<Left, Right, Key>;
+}> = Result;
+type TGetProperties<Type extends TSchema, Result extends TProperties = (Type extends TObject<infer Properties extends TProperties> ? Properties : Type extends TTuple<infer Types extends TSchema[]> ? TTupleElementsToProperties<Types> : TUnreachable)> = Result;
+export type TComposite<Left extends TSchema, Right extends TSchema, LeftProperties extends TProperties = TGetProperties<Left>, RightProperties extends TProperties = TGetProperties<Right>, Properties extends TProperties = TCompositeProperties<LeftProperties, RightProperties>, Result extends TSchema = TObject<Properties>> = Result;
+export declare function Composite<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TComposite<Left, Right>;
+export {};

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

@@ -0,0 +1,63 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { ReadonlyAdd, ReadonlyRemove, IsReadonly } from '../../types/_readonly.mjs';
+import { OptionalAdd, OptionalRemove, IsOptional } from '../../types/_optional.mjs';
+import { Object, IsObject } from '../../types/object.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { TupleElementsToProperties } from '../tuple/to-object.mjs';
+import { EvaluateIntersect } from './evaluate.mjs';
+function IsReadonlyProperty(left, right) {
+    return (IsReadonly(left) ? IsReadonly(right) ? true : false : false);
+}
+function IsOptionalProperty(left, right) {
+    return (IsOptional(left) ? IsOptional(right) ? true : false : false);
+}
+function CompositeProperty(left, right) {
+    const isReadonly = IsReadonlyProperty(left, right);
+    const isOptional = IsOptionalProperty(left, right);
+    const evaluated = EvaluateIntersect([left, right]);
+    // Modifiers need to be discarded and re-applied
+    const property = ReadonlyRemove(OptionalRemove(evaluated));
+    return (isReadonly && isOptional ? ReadonlyAdd(OptionalAdd(property)) :
+        isReadonly && !isOptional ? ReadonlyAdd(property) :
+            !isReadonly && isOptional ? OptionalAdd(property) :
+                property);
+}
+function CompositePropertyKey(left, right, key) {
+    return (key in left
+        ? key in right
+            ? CompositeProperty(left[key], right[key])
+            : left[key]
+        : key in right
+            ? right[key]
+            : Never());
+}
+function CompositeProperties(left, right) {
+    const keys = new Set([...Guard.Keys(right), ...Guard.Keys(left)]);
+    return [...keys].reduce((result, key) => {
+        return { ...result, [key]: CompositePropertyKey(left, right, key) };
+    }, {});
+}
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - symmetric unreachable | internal
+//
+// Composite is called by Distribute which provisions the type as
+// either TObject ot TTuple. Fall-through unreachable.
+//
+// ------------------------------------------------------------------
+function GetProperties(type) {
+    const result = (IsObject(type) ? type.properties :
+        IsTuple(type) ? TupleElementsToProperties(type.items) :
+            Unreachable() // {}
+    );
+    return result;
+}
+export function Composite(left, right) {
+    const leftProperties = GetProperties(left);
+    const rightProperties = GetProperties(right);
+    const properties = CompositeProperties(leftProperties, rightProperties);
+    return Object(properties);
+}

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

@@ -0,0 +1,26 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TComposite } from './composite.mjs';
+import { type TNarrow } from './narrow.mjs';
+import { type TEvaluateType } from "./evaluate.mjs";
+import { type TEvaluateIntersect } from "./evaluate.mjs";
+type TCanDistribute<Type extends TSchema> = Type extends TObject | TTuple ? true : false;
+type TDistributeNormalize<Type extends TSchema> = Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type;
+type TDistributeOperation<Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TDistributeNormalize<Left>, NormalRight extends TSchema = TDistributeNormalize<Right>, IsObjectLeft extends boolean = TCanDistribute<NormalLeft>, IsObjectRight extends boolean = TCanDistribute<NormalRight>, Result extends TSchema = ([
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, true] ? TComposite<TEvaluateType<NormalLeft>, NormalRight> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, false] ? TEvaluateType<NormalLeft> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [false, true] ? NormalRight : TNarrow<TEvaluateType<NormalLeft>, NormalRight>)> = Result;
+type TDistributeType<Type extends TSchema, Distribution extends TSchema[], Result extends TSchema[] = []> = (Distribution extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeType<Type, Right, [...Result, TDistributeOperation<Type, Left>]> : Result extends [] ? [Type] : Result);
+type TDistributeUnion<Types extends TSchema[], Distribution extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeUnion<Right, Distribution, [...Result, ...TDistribute<[Left], Distribution>]> : Result);
+export type TDistribute<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TUnion<infer UnionTypes extends TSchema[]> ? TDistribute<Right, TDistributeUnion<UnionTypes, Result>> : TDistribute<Right, TDistributeType<Left, Result>> : Result);
+export declare function Distribute<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TDistribute<Types>;
+export {};

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

@@ -0,0 +1,53 @@
+// deno-fmt-ignore-file
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsSchema } from '../../types/schema.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { Composite } from './composite.mjs';
+import { Narrow } from './narrow.mjs';
+import { EvaluateType } from "./evaluate.mjs";
+import { EvaluateIntersect } from "./evaluate.mjs";
+function CanDistribute(type) {
+    return IsObject(type) || IsTuple(type);
+}
+function DistributeNormalize(type) {
+    return (IsIntersect(type)
+        ? EvaluateIntersect(type.allOf)
+        : type);
+}
+function DistributeOperation(left, right) {
+    const normalLeft = DistributeNormalize(left);
+    const normalRight = DistributeNormalize(right);
+    const isObjectLeft = CanDistribute(normalLeft);
+    const IsObjectRight = CanDistribute(normalRight);
+    const result = (isObjectLeft && IsObjectRight ? Composite(EvaluateType(normalLeft), normalRight) :
+        isObjectLeft && !IsObjectRight ? EvaluateType(normalLeft) :
+            !isObjectLeft && IsObjectRight ? normalRight :
+                Narrow(EvaluateType(normalLeft), normalRight));
+    return result;
+}
+function DistributeType(type, types, result = []) {
+    const [left, ...right] = types;
+    return (!Guard.IsUndefined(left) // TSchema[]
+        ? DistributeType(type, right, [...result, DistributeOperation(type, left)])
+        : result.length === 0
+            ? [type]
+            : result);
+}
+function DistributeUnion(types, distribution, result = []) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)])
+        : result);
+}
+export function Distribute(types, result = []) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? IsUnion(left)
+            ? Distribute(right, DistributeUnion(left.anyOf, result))
+            : Distribute(right, DistributeType(left, result))
+        : result);
+}

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

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

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

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { Distribute } from './distribute.mjs';
+import { Broaden } from './broaden.mjs';
+export function EvaluateIntersect(types) {
+    const distribution = Distribute(types);
+    const result = Broaden(distribution);
+    return result;
+}
+export function EvaluateUnion(types) {
+    const result = Broaden(types);
+    return result;
+}
+export function EvaluateType(type) {
+    return (IsIntersect(type) ? EvaluateIntersect(type.allOf) :
+        IsUnion(type) ? EvaluateUnion(type.anyOf) :
+            type);
+}