@openclaw/slack 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/typebox/build/type/engine/cyclic/check.mjs

@@ -1,13 +1,10 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/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';
@@ -24,25 +21,22 @@ function FromProperties(stack, context, properties) {
     return FromTypes(stack, context, types);
 }
 function FromTypes(stack, context, types) {
-    return Guard.TakeLeft(types, (left, right) => FromType(stack, context, left)
+    return Guard.ShiftLeft(types, (left, right) => FromType(stack, context, left)
         ? true
         : FromTypes(stack, context, right), () => false);
 }
 function FromType(stack, context, type) {
     return (IsRef(type) ? FromRef(stack, context, type.$ref) :
         IsArray(type) ? FromType(stack, context, type.items) :
-            IsAsyncIterator(type) ? FromType(stack, context, type.iteratorItems) :
-                IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
-                    IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
-                        IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
-                            IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
-                                IsIterator(type) ? FromType(stack, context, type.iteratorItems) :
-                                    IsObject(type) ? FromProperties(stack, context, type.properties) :
-                                        IsPromise(type) ? FromType(stack, context, type.item) :
-                                            IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
-                                                IsTuple(type) ? FromTypes(stack, context, type.items) :
-                                                    IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
-                                                        false);
+            IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
+                IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
+                    IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
+                        IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
+                            IsObject(type) ? FromProperties(stack, context, type.properties) :
+                                IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
+                                    IsTuple(type) ? FromTypes(stack, context, type.items) :
+                                        IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
+                                            false);
 }
 /** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
 export function CyclicCheck(stack, context, type) {

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

@@ -1,13 +1,10 @@
 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';
@@ -17,7 +14,7 @@ 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);
+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 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 TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, 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. */

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

@@ -1,13 +1,10 @@
 // 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';
@@ -33,18 +30,15 @@ function FromTypes(context, types, 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);
+            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) :
+                            IsObject(type) ? FromProperties(context, type.properties, 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) {

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

@@ -1,14 +1,11 @@
 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';
@@ -22,7 +19,7 @@ type TFromProperties<Properties extends TProperties, Result extends TProperties
     [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 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 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 TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : 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;

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

@@ -2,13 +2,10 @@
 import { Guard } from '../../../guard/index.mjs';
 import { Any } from '../../types/any.mjs';
 import { Array as _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';
@@ -30,17 +27,14 @@ function FromTypes(types) {
 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);
+            IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
+                IsFunction(type) ? _Function_(FromTypes(type.parameters), FromType(type.returnType)) :
+                    IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
+                        IsObject(type) ? Object(FromProperties(type.properties)) :
+                            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

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

@@ -6,12 +6,9 @@ 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 TState } 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 TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, TState<[], []>, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, TState<[], []>, 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;

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

@@ -7,10 +7,11 @@ import { CyclicDependencies } from '../cyclic/dependencies.mjs';
 import { IsInterfaceDeferred } from '../../action/index.mjs';
 import { InstantiateProperties } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
+import { State } 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 instantiatedHeritage = InstantiateTypes(context, State([], []), heritage);
+    const instantiatedProperties = InstantiateProperties({}, State([], []), properties);
     const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object(instantiatedProperties)]);
     return evaluatedInterface;
 }

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

@@ -1,2 +1 @@
-export * from './enum_to_union.mjs';
 export * from './typescript_enum_to_enum_values.mjs';

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

@@ -1,2 +1 @@
-export * from './enum_to_union.mjs';
 export * from './typescript_enum_to_enum_values.mjs';

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

@@ -2,7 +2,6 @@ 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';
@@ -10,7 +9,7 @@ type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends
 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]> : Left extends TNever ? TBroadenTypes<Right, Result> : 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;
+export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>> = Flattened;
 /** 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/node_modules/typebox/build/type/engine/evaluate/broaden.mjs

@@ -1,9 +1,8 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { IsAny } from '../../types/any.mjs';
-import { Never, IsNever } from '../../types/never.mjs';
+import { IsNever } 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';
@@ -40,8 +39,5 @@ function BroadenTypes(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;
+    return flattened;
 }

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

@@ -1,25 +1,29 @@
 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 TReadonly } from '../../types/_readonly.mjs';
+import { type TOptional } 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 TAddReadonly } from '../../action/_add_readonly.mjs';
+import { type TAddOptional } from '../../action/_add_optional.mjs';
+import { type TRemoveReadonly } from '../../action/_remove_readonly.mjs';
+import { type TRemoveOptional } from '../../action/_remove_optional.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>>> = ([
+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 = TRemoveReadonly<TRemoveOptional<Evaluated>>> = ([
     IsReadonly,
     IsOptional
-] extends [true, true] ? TReadonlyAdd<TOptionalAdd<Property>> : [
+] extends [true, true] ? TAddReadonly<TAddOptional<Property>> : [
     IsReadonly,
     IsOptional
-] extends [true, false] ? TReadonlyAdd<Property> : [
+] extends [true, false] ? TAddReadonly<Property> : [
     IsReadonly,
     IsOptional
-] extends [false, true] ? TOptionalAdd<Property> : Property);
+] extends [false, true] ? TAddOptional<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>;

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

@@ -2,11 +2,15 @@
 // 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 { IsReadonly } from '../../types/_readonly.mjs';
+import { 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 { AddReadonly } from '../../action/_add_readonly.mjs';
+import { AddOptional } from '../../action/_add_optional.mjs';
+import { RemoveReadonly } from '../../action/_remove_readonly.mjs';
+import { RemoveOptional } from '../../action/_remove_optional.mjs';
 import { TupleElementsToProperties } from '../tuple/to_object.mjs';
 import { EvaluateIntersect } from './evaluate.mjs';
 function IsReadonlyProperty(left, right) {
@@ -20,10 +24,10 @@ function CompositeProperty(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) :
+    const property = RemoveReadonly(RemoveOptional(evaluated));
+    return (isReadonly && isOptional ? AddReadonly(AddOptional(property)) :
+        isReadonly && !isOptional ? AddReadonly(property) :
+            !isReadonly && isOptional ? AddOptional(property) :
                 property);
 }
 function CompositePropertyKey(left, right, key) {

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

@@ -1,4 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
@@ -6,7 +7,7 @@ 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 TIsObjectLike<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? 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

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

@@ -31,15 +31,15 @@ function DistributeOperation(left, right) {
     return result;
 }
 function DistributeType(type, types, result = []) {
-    return Guard.TakeLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(type, left)]), () => Guard.IsEqual(result.length, 0)
+    return Guard.ShiftLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(type, left)]), () => Guard.IsEqual(result.length, 0)
         ? [type]
         : result);
 }
 function DistributeUnion(types, distribution, result = []) {
-    return Guard.TakeLeft(types, (left, right) => DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]), () => result);
+    return Guard.ShiftLeft(types, (left, right) => DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]), () => result);
 }
 export function Distribute(types, result = []) {
-    return Guard.TakeLeft(types, (left, right) => IsUnion(left)
+    return Guard.ShiftLeft(types, (left, right) => IsUnion(left)
         ? Distribute(right, DistributeUnion(left.anyOf, result))
         : Distribute(right, DistributeType(left, result)), () => result);
 }

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

@@ -1,14 +1,26 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
 import { type TDistribute } from './distribute.mjs';
 import { type TBroaden } from './broaden.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TNever } from '../../types/never.mjs';
-export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Result extends TSchema = TBroaden<Distribution>> = Result;
+import { type TExcludeOperation } from '../exclude/operation.mjs';
+import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
+export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersect extends TSchema = TIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersect, Excluded]>> = Result;
+export declare function EvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TEvaluateDependent<If, Then, Else>;
+export type TEvaluateEnum<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEvaluateEnum<Right, [...Result, TLiteral<Left>]> : TEvaluateUnion<Result>);
+export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values]): TEvaluateEnum<Values>;
+export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Broadend extends TSchema[] = TBroaden<Distribution>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = 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 type TEvaluateTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TEvaluateType<Evaluated>> = Result;
+export declare function EvaluateTemplateLiteral<Pattern extends string>(pattern: Pattern): TEvaluateTemplateLiteral<Pattern>;
+export type TEvaluateUnion<Types extends TSchema[], Broadend extends TSchema[] = TBroaden<Types>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = 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 type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TEvaluateDependent<If, Then, Else> : Type extends TEnum<infer Values extends TEnumValue[]> ? TEvaluateEnum<Values> : Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
 export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;
 export type TEvaluateUnionFast<Types extends TSchema[], Result extends TSchema = (Types extends [infer Type extends TSchema] ? Type : Types extends [] ? TNever : TUnion<Types>)> = Result;
 export declare function EvaluateUnionFast<Types extends TSchema[]>(types: [...Types]): TEvaluateUnionFast<Types>;

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

@@ -1,23 +1,49 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsIntersect } from '../../types/intersect.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { Literal } from '../../types/literal.mjs';
+import { IsIntersect, Intersect } from '../../types/intersect.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
-import { Union, IsUnion } from '../../types/union.mjs';
-import { Never } from '../../types/never.mjs';
+import { ExcludeOperation } from '../exclude/operation.mjs';
+import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+export function EvaluateDependent(if_, then_, else_) {
+    const intersect = Intersect([if_, then_]);
+    const excluded = ExcludeOperation(else_, if_);
+    const result = EvaluateUnion([intersect, excluded]);
+    return result;
+}
+export function EvaluateEnum(values) {
+    const result = values.map(value => Literal(value));
+    return EvaluateUnion(result);
+}
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
-    const result = Broaden(distribution);
+    const broadend = Broaden(distribution);
+    const result = EvaluateUnionFast(broadend);
+    return result;
+}
+export function EvaluateTemplateLiteral(pattern) {
+    const evaluated = TemplateLiteralDecode(pattern);
+    const result = EvaluateType(evaluated);
     return result;
 }
 export function EvaluateUnion(types) {
-    const result = Broaden(types);
+    const broadend = Broaden(types);
+    const result = EvaluateUnionFast(broadend);
     return result;
 }
 export function EvaluateType(type) {
-    return (IsIntersect(type) ? EvaluateIntersect(type.allOf) :
-        IsUnion(type) ? EvaluateUnion(type.anyOf) :
-            type);
+    return (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
+        IsEnum(type) ? EvaluateEnum(type.enum) :
+            IsIntersect(type) ? EvaluateIntersect(type.allOf) :
+                IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
+                    IsUnion(type) ? EvaluateUnion(type.anyOf) :
+                        type);
 }
 export function EvaluateUnionFast(types) {
     const result = (Guard.IsEqual(types.length, 1) ? types[0] :

package/node_modules/typebox/build/type/engine/exclude/operation.d.mts

@@ -1,11 +1,10 @@
 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 TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
-type TExcludeUnionLeft<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnionLeft<Tail, Right, [...Result, ...TExcludeTypeLeft<Head, Right>]> : Result);
-type TExcludeTypeLeft<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [] : [Left]> = Result;
-export type TExcludeOperation<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExcludeUnionLeft<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExcludeUnionLeft<TFlatten<Types>, Right> : TExcludeTypeLeft<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [] : [Left]> = Result;
+type TExcludeUnion<Left extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
+export type TExcludeOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExcludeUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
 export declare function ExcludeOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExcludeOperation<Left, Right>;
 export {};

package/node_modules/typebox/build/type/engine/exclude/operation.mjs

@@ -1,24 +1,23 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
-import { IsEnum } from '../../types/enum.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
-function ExcludeUnionLeft(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExcludeTypeLeft(head, right)];
-    }, []);
-}
-function ExcludeTypeLeft(left, right) {
+import { EvaluateType } from '../evaluate/evaluate.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+function ExcludeType(left, right) {
     const check = Extends({}, left, right);
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
     return result;
 }
+function ExcludeUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExcludeType(head, right)];
+    }, []);
+}
 export function ExcludeOperation(left, right) {
-    const remaining = (IsEnum(left) ? ExcludeUnionLeft(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExcludeUnionLeft(Flatten(left.anyOf), right) :
-            ExcludeTypeLeft(left, right));
+    const evaluated = EvaluateType(left);
+    const canonical = IsUnion(evaluated) ? evaluated.anyOf : [evaluated];
+    const remaining = ExcludeUnion(canonical, right);
     const result = EvaluateUnion(remaining);
     return result;
 }

package/node_modules/typebox/build/type/engine/extract/operation.d.mts

@@ -1,11 +1,10 @@
 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 TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
-type TExtractUnionLeft<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnionLeft<Tail, Right, [...Result, ...TExtractTypeLeft<Head, Right>]> : Result);
-type TExtractTypeLeft<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [Left] : []> = Result;
-export type TExtractOperation<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExtractUnionLeft<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtractUnionLeft<TFlatten<Types>, Right> : TExtractTypeLeft<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [Left] : []> = Result;
+type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+export type TExtractOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExtractUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
 export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
 export {};

package/node_modules/typebox/build/type/engine/extract/operation.mjs

@@ -1,24 +1,23 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
-import { IsEnum } from '../../types/enum.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
-function ExtractUnionLeft(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExtractTypeLeft(head, right)];
-    }, []);
-}
-function ExtractTypeLeft(left, right) {
+import { EvaluateType } from '../evaluate/evaluate.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+function ExtractType(left, right) {
     const check = Extends({}, left, right);
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
     return result;
 }
+function ExtractUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExtractType(head, right)];
+    }, []);
+}
 export function ExtractOperation(left, right) {
-    const remaining = (IsEnum(left) ? ExtractUnionLeft(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExtractUnionLeft(Flatten(left.anyOf), right) :
-            ExtractTypeLeft(left, right));
+    const evaluated = EvaluateType(left);
+    const canonical = IsUnion(evaluated) ? evaluated.anyOf : [evaluated];
+    const remaining = ExtractUnion(canonical, right);
     const result = EvaluateUnion(remaining);
     return result;
 }