@depup/typebox 1.1.6-depup.0

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

@@ -0,0 +1,25 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.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 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, type TPropertyValues } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TInterfaceDeferred } from '../../action/interface.mjs';
+type TFromRef<Context extends TProperties, Ref extends string, Dependencies extends string[]> = Ref extends Dependencies[number] ? Dependencies : Ref extends keyof Context ? TFromType<Context, Context[Ref], [...Dependencies, Ref]> : TUnreachable;
+type TFromProperties<Context extends TProperties, Properties extends TProperties, Dependencies extends string[], Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Context, Types, Dependencies>;
+type TFromTypes<Context extends TProperties, Types extends TSchema[], Dependencies extends string[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Context, Right, TFromType<Context, Left, Dependencies>> : Dependencies;
+type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, 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 type TCyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema, Result extends string[] = TFromType<Context, Type, [Key]>> = Result;
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export declare function CyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema>(context: Context, key: Key, type: Type): TCyclicDependencies<Context, Key, Type>;
+export {};

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 as _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,8 @@
+import { type TEnumValue } from '../../types/enum.mjs';
+import { type TUnionToTuple } from '../helpers/union.mjs';
+export type TTypeScriptEnumLike = Record<PropertyKey, TEnumValue>;
+export declare function IsTypeScriptEnumLike(value: unknown): value is TTypeScriptEnumLike;
+type TReduceEnumValues<Keys extends string[], Type extends TTypeScriptEnumLike, Result extends TEnumValue[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TReduceEnumValues<Right, Type, [...Result, Type[Left]]> : Result);
+export type TTypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike, EnumKeys extends string[] = TUnionToTuple<Extract<keyof Type, string>>, Elements extends TEnumValue[] = TReduceEnumValues<EnumKeys, Type>> = Elements;
+export declare function TypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike>(type: Type): TTypeScriptEnumToEnumValues<Type>;
+export {};

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

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+export function IsTypeScriptEnumLike(value) {
+    return Guard.IsObjectNotArray(value);
+}
+export function TypeScriptEnumToEnumValues(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,27 @@
+import { type TSchema } from '../../types/schema.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 TIsObjectLike<Type extends TSchema> = Type extends TObject | TTuple ? true : false;
+type TIsUnionOperand<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
+type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, IsUnionOperand extends boolean = TIsUnionOperand<EvaluatedLeft, EvaluatedRight>, IsObjectLeft extends boolean = TIsObjectLike<EvaluatedLeft>, IsObjectRight extends boolean = TIsObjectLike<EvaluatedRight>, Result extends TSchema = ([
+    IsUnionOperand
+] extends [true] ? TEvaluateIntersect<[EvaluatedLeft, EvaluatedRight]> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, true] ? TComposite<EvaluatedLeft, EvaluatedRight> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, false] ? EvaluatedLeft : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [false, true] ? EvaluatedRight : TNarrow<EvaluatedLeft, EvaluatedRight>)> = 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 {};