@openclaw/tavily-plugin 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/typebox/build/type/extends/extends_left.d.mts

@@ -1,20 +1,19 @@
 import { type TExtendsAny } from './any.mjs';
 import { type TExtendsArray } from './array.mjs';
-import { type TExtendsAsyncIterator } from './async_iterator.mjs';
 import { type TExtendsBigInt } from './bigint.mjs';
 import { type TExtendsBoolean } from './boolean.mjs';
 import { type TExtendsConstructor } from './constructor.mjs';
+import { type TExtendsDependent } from './dependent.mjs';
 import { type TExtendsEnum } from './enum.mjs';
 import { type TExtendsFunction } from './function.mjs';
 import { type TExtendsInteger } from './integer.mjs';
 import { type TExtendsIntersect } from './intersect.mjs';
-import { type TExtendsIterator } from './iterator.mjs';
 import { type TExtendsLiteral } from './literal.mjs';
 import { type TExtendsNever } from './never.mjs';
 import { type TExtendsNull } from './null.mjs';
 import { type TExtendsNumber } from './number.mjs';
 import { type TExtendsObject } from './object.mjs';
-import { type TExtendsPromise } from './promise.mjs';
+import { type TExtendsRecord } from './record.mjs';
 import { type TExtendsString } from './string.mjs';
 import { type TExtendsSymbol } from './symbol.mjs';
 import { type TExtendsTemplateLiteral } from './template_literal.mjs';
@@ -25,21 +24,20 @@ import { type TExtendsUnknown } from './unknown.mjs';
 import { type TExtendsVoid } from './void.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 TBigInt } from '../types/bigint.mjs';
 import { type TBoolean } from '../types/boolean.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
+import { type TDependent } from '../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../types/enum.mjs';
 import { type TFunction } from '../types/function.mjs';
 import { type TInteger } from '../types/integer.mjs';
 import { type TIntersect } from '../types/intersect.mjs';
-import { type TIterator } from '../types/iterator.mjs';
 import { type TLiteral } from '../types/literal.mjs';
 import { type TNever } from '../types/never.mjs';
 import { type TNull } from '../types/null.mjs';
 import { type TNumber } from '../types/number.mjs';
 import { type TObject } from '../types/object.mjs';
-import { type TPromise } from '../types/promise.mjs';
+import { type TRecord } from '../types/record.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TString } from '../types/string.mjs';
 import { type TSymbol } from '../types/symbol.mjs';
@@ -51,5 +49,5 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TVoid } from '../types/void.mjs';
 import * as Result from './result.mjs';
-export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, TEnum<Values>, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsDependent<Inferred, If, Then, Else, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, Values, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsRecord<Inferred, Pattern, Value, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
 export declare function ExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsLeft<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/extends_left.mjs

@@ -1,21 +1,20 @@
 // deno-fmt-ignore-file
 import { ExtendsAny } from './any.mjs';
 import { ExtendsArray } from './array.mjs';
-import { ExtendsAsyncIterator } from './async_iterator.mjs';
 import { ExtendsBigInt } from './bigint.mjs';
 import { ExtendsBoolean } from './boolean.mjs';
 import { ExtendsConstructor } from './constructor.mjs';
+import { ExtendsDependent } from './dependent.mjs';
 import { ExtendsEnum } from './enum.mjs';
 import { ExtendsFunction } from './function.mjs';
 import { ExtendsInteger } from './integer.mjs';
 import { ExtendsIntersect } from './intersect.mjs';
-import { ExtendsIterator } from './iterator.mjs';
 import { ExtendsLiteral } from './literal.mjs';
 import { ExtendsNever } from './never.mjs';
 import { ExtendsNull } from './null.mjs';
 import { ExtendsNumber } from './number.mjs';
 import { ExtendsObject } from './object.mjs';
-import { ExtendsPromise } from './promise.mjs';
+import { ExtendsRecord } from './record.mjs';
 import { ExtendsString } from './string.mjs';
 import { ExtendsSymbol } from './symbol.mjs';
 import { ExtendsTemplateLiteral } from './template_literal.mjs';
@@ -29,21 +28,20 @@ import { ExtendsVoid } from './void.mjs';
 // ----------------------------------------------------------------------------
 import { IsAny } from '../types/any.mjs';
 import { IsArray } from '../types/array.mjs';
-import { IsAsyncIterator } from '../types/async_iterator.mjs';
 import { IsBigInt } from '../types/bigint.mjs';
 import { IsBoolean } from '../types/boolean.mjs';
 import { IsConstructor } from '../types/constructor.mjs';
+import { IsDependent } from '../types/dependent.mjs';
 import { IsEnum } from '../types/enum.mjs';
 import { IsFunction } from '../types/function.mjs';
 import { IsInteger } from '../types/integer.mjs';
 import { IsIntersect } from '../types/intersect.mjs';
-import { IsIterator } from '../types/iterator.mjs';
 import { IsLiteral } from '../types/literal.mjs';
 import { IsNever } from '../types/never.mjs';
 import { IsNull } from '../types/null.mjs';
 import { IsNumber } from '../types/number.mjs';
 import { IsObject } from '../types/object.mjs';
-import { IsPromise } from '../types/promise.mjs';
+import { IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
 import { IsString } from '../types/string.mjs';
 import { IsSymbol } from '../types/symbol.mjs';
 import { IsTemplateLiteral } from '../types/template_literal.mjs';
@@ -56,28 +54,27 @@ import * as Result from './result.mjs';
 export function ExtendsLeft(inferred, left, right) {
     return (IsAny(left) ? ExtendsAny(inferred, left, right) :
         IsArray(left) ? ExtendsArray(inferred, left, left.items, right) :
-            IsAsyncIterator(left) ? ExtendsAsyncIterator(inferred, left.iteratorItems, right) :
-                IsBigInt(left) ? ExtendsBigInt(inferred, left, right) :
-                    IsBoolean(left) ? ExtendsBoolean(inferred, left, right) :
-                        IsConstructor(left) ? ExtendsConstructor(inferred, left.parameters, left.instanceType, right) :
-                            IsEnum(left) ? ExtendsEnum(inferred, left, right) :
+            IsBigInt(left) ? ExtendsBigInt(inferred, left, right) :
+                IsBoolean(left) ? ExtendsBoolean(inferred, left, right) :
+                    IsConstructor(left) ? ExtendsConstructor(inferred, left.parameters, left.instanceType, right) :
+                        IsDependent(left) ? ExtendsDependent(inferred, left.if, left.then, left.else, right) :
+                            IsEnum(left) ? ExtendsEnum(inferred, left.enum, right) :
                                 IsFunction(left) ? ExtendsFunction(inferred, left.parameters, left.returnType, right) :
                                     IsInteger(left) ? ExtendsInteger(inferred, left, right) :
                                         IsIntersect(left) ? ExtendsIntersect(inferred, left.allOf, right) :
-                                            IsIterator(left) ? ExtendsIterator(inferred, left.iteratorItems, right) :
-                                                IsLiteral(left) ? ExtendsLiteral(inferred, left, right) :
-                                                    IsNever(left) ? ExtendsNever(inferred, left, right) :
-                                                        IsNull(left) ? ExtendsNull(inferred, left, right) :
-                                                            IsNumber(left) ? ExtendsNumber(inferred, left, right) :
-                                                                IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
-                                                                    IsPromise(left) ? ExtendsPromise(inferred, left.item, right) :
-                                                                        IsString(left) ? ExtendsString(inferred, left, right) :
-                                                                            IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
-                                                                                IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
-                                                                                    IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
-                                                                                        IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
-                                                                                            IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
-                                                                                                IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
-                                                                                                    IsVoid(left) ? ExtendsVoid(inferred, left, right) :
-                                                                                                        Result.ExtendsFalse());
+                                            IsLiteral(left) ? ExtendsLiteral(inferred, left, right) :
+                                                IsNever(left) ? ExtendsNever(inferred, left, right) :
+                                                    IsNull(left) ? ExtendsNull(inferred, left, right) :
+                                                        IsNumber(left) ? ExtendsNumber(inferred, left, right) :
+                                                            IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
+                                                                IsRecord(left) ? ExtendsRecord(inferred, RecordPattern(left), RecordValue(left), right) :
+                                                                    IsString(left) ? ExtendsString(inferred, left, right) :
+                                                                        IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
+                                                                            IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
+                                                                                IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
+                                                                                    IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
+                                                                                        IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
+                                                                                            IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
+                                                                                                IsVoid(left) ? ExtendsVoid(inferred, left, right) :
+                                                                                                    Result.ExtendsFalse());
 }

package/node_modules/typebox/build/type/extends/extends_right.d.mts

@@ -2,6 +2,7 @@ import { Memory } from '../../system/memory/index.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TAny } from '../types/any.mjs';
+import { type TDependent } from '../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../types/enum.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TIntersect } from '../types/intersect.mjs';
@@ -10,16 +11,17 @@ import { type TUnion } from '../types/union.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
-import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
-import { type TEnumValuesToUnion } from '../engine/enum/index.mjs';
+import { type TEvaluateEnum } from '../engine/evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
 type TExtendsRightInfer<Inferred extends TProperties, Name extends string, Left extends TSchema, Right extends TSchema, Result extends Result.TResult = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Memory.TAssign<Inferred, CheckInferred>, {
     [_ in Name]: Left;
 }>> : Result.TExtendsFalse)> = Result;
 type TExtendsRightAny<Inferred extends TProperties, _Left extends TSchema, Result extends Result.TResult = Result.TExtendsTrue<Inferred>> = Result;
-type TExtendsRightEnum<Inferred extends TProperties, Left extends TSchema, Right extends TEnumValue[], Union extends TSchema = TEnumValuesToUnion<Right>> = TExtendsLeft<Inferred, Left, Union>;
+type TExtendsRightDependent<Inferred extends TProperties, Left extends TSchema, If extends TSchema, Then extends TSchema, Else extends TSchema, Result extends Result.TResult = TExtendsLeft<Inferred, Left, If> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? (TExtendsLeft<Inferred, Left, Then> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse) : (TExtendsLeft<Inferred, Left, Else> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse)> = Result;
+type TExtendsRightEnum<Inferred extends TProperties, Left extends TSchema, Right extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Right>> = TExtendsLeft<Inferred, Left, Evaluated>;
 type TExtendsRightIntersect<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRightIntersect<Inferred, Left, Tail> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
-type TExtendsRightTemplateLiteral<Inferred extends TProperties, Left extends TSchema, Right extends string, Decoded extends TSchema = TTemplateLiteralDecode<Right>> = TExtendsLeft<Inferred, Left, Decoded>;
+type TExtendsRightTemplateLiteral<Inferred extends TProperties, Left extends TSchema, Right extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Right>> = TExtendsLeft<Inferred, Left, Evaluated>;
 type TExtendsRightUnion<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : TExtendsRightUnion<Inferred, Left, Tail> : Result.TExtendsFalse);
-export type TExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAny ? TExtendsRightAny<Inferred, Left> : Right extends TEnum<infer Values extends TEnumValue[]> ? TExtendsRightEnum<Inferred, Left, Values> : Right extends TInfer<infer Name extends string, infer Type extends TSchema> ? TExtendsRightInfer<Inferred, Name, Left, Type> : Right extends TTemplateLiteral<infer Pattern extends string> ? TExtendsRightTemplateLiteral<Inferred, Left, Pattern> : Right extends TIntersect<infer Types extends TSchema[]> ? TExtendsRightIntersect<Inferred, Left, Types> : Right extends TUnion<infer Types extends TSchema[]> ? TExtendsRightUnion<Inferred, Left, Types> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+export type TExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAny ? TExtendsRightAny<Inferred, Left> : Right extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsRightDependent<Inferred, Left, If, Then, Else> : Right extends TEnum<infer Values extends TEnumValue[]> ? TExtendsRightEnum<Inferred, Left, Values> : Right extends TInfer<infer Name extends string, infer Type extends TSchema> ? TExtendsRightInfer<Inferred, Name, Left, Type> : Right extends TTemplateLiteral<infer Pattern extends string> ? TExtendsRightTemplateLiteral<Inferred, Left, Pattern> : Right extends TIntersect<infer Types extends TSchema[]> ? TExtendsRightIntersect<Inferred, Left, Types> : Right extends TUnion<infer Types extends TSchema[]> ? TExtendsRightUnion<Inferred, Left, Types> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 export declare function ExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsRight<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/extends_right.mjs

@@ -2,6 +2,7 @@
 import { Guard } from '../../guard/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { IsAny } from '../types/any.mjs';
+import { IsDependent } from '../types/dependent.mjs';
 import { IsEnum } from '../types/enum.mjs';
 import { IsInfer } from '../types/infer.mjs';
 import { IsIntersect } from '../types/intersect.mjs';
@@ -10,35 +11,39 @@ import { IsUnion } from '../types/union.mjs';
 import { IsUnknown } from '../types/unknown.mjs';
 import { ExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
-import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
-import { EnumValuesToUnion } from '../engine/enum/index.mjs';
+import { EvaluateEnum } from '../engine/evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
 function ExtendsRightInfer(inferred, name, left, right) {
     return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Result.ExtendsTrue(Memory.Assign(Memory.Assign(inferred, checkInferred), { [name]: left })), () => Result.ExtendsFalse());
 }
 function ExtendsRightAny(inferred, _left) {
     return Result.ExtendsTrue(inferred);
 }
+function ExtendsRightDependent(inferred, left, if_, then_, else_) {
+    return Result.Match(ExtendsLeft(inferred, left, if_), inferred => Result.Match(ExtendsLeft(inferred, left, then_), inferred => Result.ExtendsTrue(inferred), () => Result.ExtendsFalse()), () => Result.Match(ExtendsLeft(inferred, left, else_), inferred => Result.ExtendsTrue(inferred), () => Result.ExtendsFalse()));
+}
 function ExtendsRightEnum(inferred, left, right) {
-    const union = EnumValuesToUnion(right);
-    return ExtendsLeft(inferred, left, union);
+    const evaluated = EvaluateEnum(right);
+    return ExtendsLeft(inferred, left, evaluated);
 }
 function ExtendsRightIntersect(inferred, left, right) {
-    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+    return Guard.ShiftLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 function ExtendsRightTemplateLiteral(inferred, left, right) {
-    const decoded = TemplateLiteralDecode(right);
-    return ExtendsLeft(inferred, left, decoded);
+    const evaluated = EvaluateTemplateLiteral(right);
+    return ExtendsLeft(inferred, left, evaluated);
 }
 function ExtendsRightUnion(inferred, left, right) {
-    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
+    return Guard.ShiftLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
 }
 export function ExtendsRight(inferred, left, right) {
     return (IsAny(right) ? ExtendsRightAny(inferred, left) :
-        IsEnum(right) ? ExtendsRightEnum(inferred, left, right.enum) :
-            IsInfer(right) ? ExtendsRightInfer(inferred, right.name, left, right.extends) :
-                IsIntersect(right) ? ExtendsRightIntersect(inferred, left, right.allOf) :
-                    IsTemplateLiteral(right) ? ExtendsRightTemplateLiteral(inferred, left, right.pattern) :
-                        IsUnion(right) ? ExtendsRightUnion(inferred, left, right.anyOf) :
-                            IsUnknown(right) ? Result.ExtendsTrue(inferred) :
-                                Result.ExtendsFalse());
+        IsDependent(right) ? ExtendsRightDependent(inferred, left, right.if, right.then, right.else) :
+            IsEnum(right) ? ExtendsRightEnum(inferred, left, right.enum) :
+                IsInfer(right) ? ExtendsRightInfer(inferred, right.name, left, right.extends) :
+                    IsIntersect(right) ? ExtendsRightIntersect(inferred, left, right.allOf) :
+                        IsTemplateLiteral(right) ? ExtendsRightTemplateLiteral(inferred, left, right.pattern) :
+                            IsUnion(right) ? ExtendsRightUnion(inferred, left, right.anyOf) :
+                                IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+                                    Result.ExtendsFalse());
 }

package/node_modules/typebox/build/type/extends/inference.mjs

@@ -46,7 +46,7 @@ export function TryInferable(type) {
         undefined);
 }
 function TryInferResults(rest, right, result = []) {
-    return Guard.TakeLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+    return Guard.ShiftLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/node_modules/typebox/build/type/extends/object.d.mts

@@ -6,6 +6,8 @@ import { type TOptional } from '../types/_optional.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TNever } from '../types/never.mjs';
 import { type TObject } from '../types/object.mjs';
+import { type TRecord } from '../types/record.mjs';
+import { type TUnion } from '../types/union.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
 import { type TExtendsRight } from './extends_right.mjs';
 import { type TUnionToTuple } from '../engine/helpers/union.mjs';
@@ -20,6 +22,11 @@ type TExtendsPropertiesComparer<Inferred extends TProperties, Left extends TProp
 }, Checked extends boolean = Properties[keyof Right] extends Result.TExtendsTrueLike ? true : false, Extracted extends TProperties = Checked extends true ? TExtractInferredProperties<TUnionToTuple<keyof Properties>, Properties> : {}> = (Checked extends true ? Result.TExtendsTrue<Extracted> : Result.TExtendsFalse);
 type TExtendsProperties<Inferred extends TProperties, Left extends TProperties, Right extends TProperties, Compared extends Result.TResult = TExtendsPropertiesComparer<Inferred, Left, Right>> = (Compared extends Result.TExtendsTrueLike<infer ComparedInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Inferred, ComparedInferred>> : Result.TExtendsFalse);
 type TExtendsObjectToObject<Inferred extends TProperties, Left extends TProperties, Right extends TProperties> = (TExtendsProperties<Inferred, Left, Right>);
-export type TExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema> = (Right extends TObject<infer Properties extends TProperties> ? TExtendsObjectToObject<Inferred, Left, Properties> : TExtendsRight<Inferred, TObject<Left>, Right>);
+type TRecordMergeInferred<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
+    [Key in keyof Right]: Key extends keyof Left ? Left[Key] extends TUnion<infer Types extends TSchema[]> ? TUnion<[...Types, Right[Key]]> : TUnion<[Left[Key], Right[Key]]> : Right[Key];
+}> = Result;
+type TExtendsRecordComparer<Properties extends TProperties, Keys extends (keyof Properties)[], Type extends TSchema, Result extends TProperties> = (Keys extends [infer Left extends (keyof Properties), ...infer Right extends (keyof Properties)[]] ? TExtendsLeft<{}, Properties[Left], Type> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRecordComparer<Properties, Right, Type, TRecordMergeInferred<Result, Inferred>> : Result.TExtendsFalse : Result.TExtendsTrue<Result>);
+type TExtendsObjectToRecord<Inferred extends TProperties, Properties extends TProperties, _Pattern extends string, Value extends TSchema, Keys extends (keyof Properties)[] = TUnionToTuple<keyof Properties>, Result extends Result.TResult = TExtendsRecordComparer<Properties, Keys, Value, Inferred>> = Result;
+export type TExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema> = (Right extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsObjectToRecord<Inferred, Left, Pattern, Value> : Right extends TObject<infer Properties extends TProperties> ? TExtendsObjectToObject<Inferred, Left, Properties> : TExtendsRight<Inferred, TObject<Left>, Right>);
 export declare function ExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsObject<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/object.mjs

@@ -7,6 +7,8 @@ import { IsOptional } from '../types/_optional.mjs';
 import { IsInfer } from '../types/infer.mjs';
 import { IsNever } from '../types/never.mjs';
 import { IsObject, Object } from '../types/object.mjs';
+import { IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
+import { Union, IsUnion } from '../types/union.mjs';
 import { ExtendsLeft } from './extends_left.mjs';
 import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
@@ -80,8 +82,28 @@ function ExtendsProperties(inferred, left, right) {
 function ExtendsObjectToObject(inferred, left, right) {
     return ExtendsProperties(inferred, left, right);
 }
+function RecordMergeInferred(left, right) {
+    return Guard.Keys(right).reduce((result, key) => {
+        return {
+            ...result, [key]: Guard.HasPropertyKey(left, key)
+                ? IsUnion(result[key])
+                    // @ts-ignore 5.0.4 cannot see `.anyOf`
+                    ? Union([...result[key].anyOf, right[key]])
+                    : Union([left[key], right[key]])
+                : right[key]
+        };
+    }, left);
+}
+function ExtendsRecordComparer(properties, keys, type, result) {
+    return Guard.ShiftLeft(keys, (left, right) => Result.Match(ExtendsLeft({}, properties[left], type), inferred => ExtendsRecordComparer(properties, right, type, RecordMergeInferred(result, inferred)), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(result));
+}
+function ExtendsObjectToRecord(inferred, properties, _pattern, value) {
+    const keys = Guard.Keys(properties);
+    const result = ExtendsRecordComparer(properties, keys, value, inferred);
+    return result;
+}
 export function ExtendsObject(inferred, left, right) {
-    return (IsObject(right)
-        ? ExtendsObjectToObject(inferred, left, right.properties)
-        : ExtendsRight(inferred, Object(left), right));
+    return (IsRecord(right) ? ExtendsObjectToRecord(inferred, left, RecordPattern(right), RecordValue(right)) :
+        IsObject(right) ? ExtendsObjectToObject(inferred, left, right.properties) :
+            ExtendsRight(inferred, Object(left), right));
 }

package/node_modules/typebox/build/type/extends/parameters.mjs

@@ -16,12 +16,12 @@ function ParameterCompare(inferred, left, leftRest, right, rightRest) {
     );
 }
 function ParameterRight(inferred, left, leftRest, rightRest) {
-    return Guard.TakeLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
+    return Guard.ShiftLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
         ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
         : Result.ExtendsFalse()); // 'fail: left was required'
 }
 function ParametersLeft(inferred, left, rightRest) {
-    return Guard.TakeLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
+    return Guard.ShiftLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
 }
 export function ExtendsParameters(inferred, left, right) {
     return ParametersLeft(inferred, left, right);

package/node_modules/typebox/build/type/extends/record.d.mts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TRecordPatternToType, type TRecord } from '../types/record.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export type TFromObject<Inferred extends TProperties, Properties extends TProperties> = keyof Properties extends never ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse;
+type TFromRecord<Inferred extends TProperties, _LeftKey extends TSchema, LeftValue extends TSchema, _RightKey extends TSchema, RightValue extends TSchema> = (TExtendsLeft<Inferred, LeftValue, RightValue>);
+export type TExtendsRecord<Inferred extends TProperties, LeftPattern extends string, LeftValue extends TSchema, Right extends TSchema> = (Right extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TFromRecord<Inferred, TRecordPatternToType<LeftPattern>, LeftValue, TRecordPatternToType<Pattern>, Value> : Right extends TObject<infer Properties extends TProperties> ? TFromObject<Inferred, Properties> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+export declare function ExtendsRecord<Inferred extends TProperties, Pattern extends string, Value extends TSchema, Right extends TSchema>(inferred: Inferred, leftPattern: Pattern, leftValue: Value, right: Right): TExtendsRecord<Inferred, Pattern, Value, Right>;
+export {};

package/node_modules/typebox/build/type/extends/record.mjs

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsAny } from '../types/any.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import { IsObject } from '../types/object.mjs';
+import { IsRecord, RecordPatternToType, RecordPattern, RecordValue } from '../types/record.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+function FromObject(inferred, properties) {
+    return (Guard.IsEqual(Guard.Keys(properties).length, 0)
+        ? Result.ExtendsTrue(inferred)
+        : Result.ExtendsFalse());
+}
+function FromRecord(inferred, _leftKey, leftValue, _rightKey, rightValue) {
+    return ExtendsLeft(inferred, leftValue, rightValue);
+}
+export function ExtendsRecord(inferred, leftPattern, leftValue, right) {
+    return (IsRecord(right) ? FromRecord(inferred, RecordPatternToType(leftPattern), leftValue, RecordPatternToType(RecordPattern(right)), RecordValue(right)) :
+        IsObject(right) ? FromObject(inferred, right.properties) :
+            IsAny(right) ? Result.ExtendsTrue(inferred) :
+                IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+                    Result.ExtendsFalse());
+}

package/node_modules/typebox/build/type/extends/template_literal.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
-import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
-export type TExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema, Decoded extends TSchema = TTemplateLiteralDecode<Left>> = TExtendsLeft<Inferred, Decoded, Right>;
-export declare function ExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTemplateLiteral<Inferred, Left, Right>;
+import { type TEvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
+export type TExtendsTemplateLiteral<Inferred extends TProperties, Pattern extends string, Right extends TSchema, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsTemplateLiteral<Inferred extends TProperties, Pattern extends string, Right extends TSchema>(inferred: Inferred, left: Pattern, right: Right): TExtendsTemplateLiteral<Inferred, Pattern, Right>;

package/node_modules/typebox/build/type/extends/template_literal.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { ExtendsLeft } from './extends_left.mjs';
-import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
+import { EvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
 export function ExtendsTemplateLiteral(inferred, left, right) {
-    const decoded = TemplateLiteralDecode(left);
-    return ExtendsLeft(inferred, decoded, right);
+    const evaluated = EvaluateTemplateLiteral(left);
+    return ExtendsLeft(inferred, evaluated, right);
 }

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

@@ -6,6 +6,7 @@ import { type TExtendsLeft } from './extends_left.mjs';
 import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 import { type TInstantiateElements } from '../engine/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 import { type TTryRestInferable, type TTryInferable, type TInferable, type TInferTupleResult, type TInferUnionResult } from './inference.mjs';
 type TReverse<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReverse<Right, [Left, ...Result]> : Result);
 type TApplyReverse<Types extends TSchema[], Reversed extends boolean> = Reversed extends true ? TReverse<Types> : Types;
@@ -14,12 +15,8 @@ type TElementsCompare<Inferred extends TProperties, Reversed extends boolean, Le
 type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[], Inferable extends TInferable | undefined = TTryRestInferable<Right>> = (Inferable extends TInferable ? TInferTupleResult<Inferred, Inferable['name'], TApplyReverse<LeftRest, Reversed>, Inferable['type']> : LeftRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsCompare<Inferred, Reversed, Head, Tail, Right, RightRest> : Result.TExtendsFalse);
 type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
-type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, {
-    callstack: [];
-}, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
+type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
 type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
-export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, {
-    callstack: [];
-}, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
+export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
 export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/tuple.mjs

@@ -7,6 +7,7 @@ import { ExtendsLeft } from './extends_left.mjs';
 import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 import { InstantiateElements } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 // ----------------------------------------------------------------------------
 // Inference
 // ----------------------------------------------------------------------------
@@ -31,10 +32,10 @@ function ElementsLeft(inferred, reversed, leftRest, right, rightRest) {
     // Rest Inferrable Right Means we delegate to TInferTupleResult to Generate a Result
     IsInferable(inferable)
         ? InferTupleResult(inferred, inferable['name'], ApplyReverse(leftRest, reversed), inferable['type'])
-        : Guard.TakeLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
+        : Guard.ShiftLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
 }
 function ElementsRight(inferred, reversed, leftRest, rightRest) {
-    return Guard.TakeLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
+    return Guard.ShiftLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
         ? Result.ExtendsTrue(inferred) // 'Ok: right-empty-and-left-empty'
         : Result.ExtendsFalse()); // 'Fail: right-empty-and-left-not-empty'
 }
@@ -42,7 +43,7 @@ function Elements(inferred, reversed, leftRest, rightRest) {
     return ElementsRight(inferred, reversed, leftRest, rightRest);
 }
 function ExtendsTupleToTuple(inferred, left, right) {
-    const instantiatedRight = InstantiateElements(inferred, { callstack: [] }, right);
+    const instantiatedRight = InstantiateElements(inferred, State([], []), right);
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
@@ -50,10 +51,10 @@ function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
 }
 export function ExtendsTuple(inferred, left, right) {
-    const instantiatedLeft = InstantiateElements(inferred, { callstack: [] }, left);
+    const instantiatedLeft = InstantiateElements(inferred, State([], []), left);
     return (IsTuple(right) ? ExtendsTupleToTuple(inferred, instantiatedLeft, right.items) :
         IsArray(right) ? ExtendsTupleToArray(inferred, instantiatedLeft, right.items) :
             ExtendsRight(inferred, Tuple(instantiatedLeft), right));

package/node_modules/typebox/build/type/extends/union.mjs

@@ -8,10 +8,10 @@ import * as Result from './result.mjs';
 // ----------------------------------------------------------------------------
 import { IsInferable, TryInferable, InferUnionResult } from './inference.mjs';
 function ExtendsUnionSome(inferred, type, unionTypes) {
-    return Guard.TakeLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
+    return Guard.ShiftLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
 }
 function ExtendsUnionLeft(inferred, left, right) {
-    return Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+    return Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 export function ExtendsUnion(inferred, left, right) {
     const inferrable = TryInferable(right);