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

package/node_modules/typebox/build/type/engine/intrinsics/from_template_literal.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TMappingType, type TMappingFunc } from './mapping.mjs';
-import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
 import { type TFromType } from './from_type.mjs';
-export type TFromTemplateLiteral<Mapping extends TMappingType, Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TFromType<Mapping, Decoded>> = Result;
+import { type TEvaluateTemplateLiteral } from '../evaluate/index.mjs';
+export type TFromTemplateLiteral<Mapping extends TMappingType, Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends TSchema = TFromType<Mapping, Evaluated>> = Result;
 export declare function FromTemplateLiteral(mapping: TMappingFunc, pattern: string): TSchema;

package/node_modules/typebox/build/type/engine/intrinsics/from_template_literal.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 import { FromType } from './from_type.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/index.mjs';
 export function FromTemplateLiteral(mapping, pattern) {
-    const decoded = TemplateLiteralDecode(pattern);
-    const result = FromType(mapping, decoded);
+    const evaluated = EvaluateTemplateLiteral(pattern);
+    const result = FromType(mapping, evaluated);
     return result;
 }

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

@@ -1,13 +1,14 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TKeyOfDeferred } from '../../action/keyof.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
 import { type TFromType } from './from_type.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic ? TCollapseToObject<Type> : Type extends TDependent ? TCollapseToObject<Type> : Type extends TIntersect ? TCollapseToObject<Type> : Type extends TUnion ? TCollapseToObject<Type> : Type)> = Result;
 export type TKeyOfAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TNormalizeType<Type>> : TKeyOfDeferred<Type>> = Result;
 export declare function KeyOfAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TKeyOfAction<Type>;
 export type TKeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TKeyOfAction<InstantiatedType>;

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

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { KeyOfDeferred } from '../../action/keyof.mjs';
@@ -11,7 +12,10 @@ import { CollapseToObject } from '../object/index.mjs';
 // ------------------------------------------------------------------
 import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
-    const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) : type);
+    const result = (IsCyclic(type) ||
+        IsDependent(type) ||
+        IsIntersect(type) ||
+        IsUnion(type)) ? CollapseToObject(type) : type;
     return result;
 }
 export function KeyOfAction(type, options) {

package/node_modules/typebox/build/type/engine/mapped/mapped_operation.d.mts

@@ -5,11 +5,11 @@ import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TIdentifier } from '../../types/identifier.mjs';
 import { type TTemplateLiteral } from '../../types/template_literal.mjs';
-import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
-import { type TState, type TInstantiateType } from '../instantiate.mjs';
-import { type TEvaluateIntersect } from '../evaluate/index.mjs';
+import { type TInstantiateType, type TState } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 import { type TMappedVariants } from './mapped_variants.mjs';
-type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedAs> = Result;
+type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : InstantiatedAs> = Result;
 type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
     [_ in Identifier['name']]: Variant;
 }>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {

package/node_modules/typebox/build/type/engine/mapped/mapped_operation.mjs

@@ -4,13 +4,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
 import { Object } from '../../types/object.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
-import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-import { EvaluateIntersect } from '../evaluate/index.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 import { MappedVariants } from './mapped_variants.mjs';
 function CanonicalAs(instantiatedAs) {
     const result = IsTemplateLiteral(instantiatedAs)
-        ? TemplateLiteralDecode(instantiatedAs.pattern)
+        ? EvaluateTemplateLiteral(instantiatedAs.pattern)
         : instantiatedAs;
     return result;
 }

package/node_modules/typebox/build/type/engine/mapped/mapped_variants.d.mts

@@ -3,12 +3,13 @@ import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
-type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema[] = TFromType<Decoded>> = Result;
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+type TFromTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
 type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+type TFromEnum<Values extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Values>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
 type TFromLiteral<Value extends TLiteralValue, Result extends TSchema[] = Value extends number ? [TLiteral<`${Value}`>] : [TLiteral<Value>]> = Result;
-type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromUnion<TEnumValuesToVariants<Values>> : Type extends TLiteral<infer Value extends number> ? TFromLiteral<Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Type extends TLiteral<infer Value extends number> ? TFromLiteral<Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
     Type
 ])> = Result;
 export type TMappedVariants<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;

package/node_modules/typebox/build/type/engine/mapped/mapped_variants.mjs

@@ -4,11 +4,11 @@ import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 function FromTemplateLiteral(pattern) {
-    const decoded = TemplateLiteralDecode(pattern);
-    const result = FromType(decoded);
+    const evaluated = EvaluateTemplateLiteral(pattern);
+    const result = FromType(evaluated);
     return result;
 }
 function FromUnion(types) {
@@ -16,12 +16,17 @@ function FromUnion(types) {
         return [...result, ...FromType(left)];
     }, []);
 }
+function FromEnum(values) {
+    const evaluated = EvaluateEnum(values);
+    const result = FromType(evaluated);
+    return result;
+}
 function FromLiteral(value) {
     const result = Guard.IsNumber(value) ? [Literal(`${value}`)] : [Literal(value)];
     return result;
 }
 function FromType(type) {
-    const result = (IsEnum(type) ? FromUnion(EnumValuesToVariants(type.enum)) :
+    const result = (IsEnum(type) ? FromEnum(type.enum) :
         IsLiteral(type) ? FromLiteral(type.const) :
             IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
                 IsUnion(type) ? FromUnion(type.anyOf) :

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

@@ -5,17 +5,15 @@ import { type TState } from '../instantiate.mjs';
 import { type TCyclicCandidates } from '../cyclic/candidates.mjs';
 import { type TInstantiateCyclic } from '../cyclic/instantiate.mjs';
 import { type TInstantiateType } from '../instantiate.mjs';
-type TInstantiateCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
-    [Key in Extract<keyof Context, CyclicKeys[number]>]: TInstantiateCyclic<Context, Key, Context[Key]>;
+type TInstantiateCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Extract<keyof Declarations, CyclicKeys[number]>]: TInstantiateCyclic<DeclarationContext, Key, Declarations[Key]>;
 }> = Result;
-type TInstantiateNonCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
-    [Key in Exclude<keyof Context, CyclicKeys[number]>]: TInstantiateType<Context, {
-        callstack: [];
-    }, Context[Key]>;
+type TInstantiateNonCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Exclude<keyof Declarations, CyclicKeys[number]>]: TInstantiateType<DeclarationContext, TState<[], []>, Declarations[Key]>;
 }> = Result;
-type TInstantiateModule<Context extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Context>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
+type TInstantiateModule<Context extends TProperties, Declarations extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Declarations>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, Declarations, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, Declarations, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
     [Key in keyof InstantiatedModule]: InstantiatedModule[Key];
 } & {};
-export type TModuleInstantiate<Context extends TProperties, _State extends TState, Properties extends TProperties, ModuleContext extends TProperties = Memory.TAssign<Context, Properties>, InstantiatedModule extends TProperties = TInstantiateModule<ModuleContext>> = InstantiatedModule;
-export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, _state: State, properties: Properties, options: TSchemaOptions): TModuleInstantiate<Context, State, Properties>;
+export type TModuleInstantiate<Context extends TProperties, _State extends TState, Declarations extends TProperties, InstantiatedModule extends TProperties = TInstantiateModule<Context, Declarations>> = InstantiatedModule;
+export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Declarations extends TProperties>(context: Context, _state: State, declarations: Declarations, options: TSchemaOptions): TModuleInstantiate<Context, State, Declarations>;
 export {};

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

@@ -2,33 +2,35 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Memory } from '../../../system/memory/index.mjs';
+import { State } from '../instantiate.mjs';
 // ------------------------------------------------------------------
 // Module: Instantiation Infrastructure
 // ------------------------------------------------------------------
 import { CyclicCandidates } from '../cyclic/candidates.mjs';
 import { InstantiateCyclic } from '../cyclic/instantiate.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function InstantiateCyclics(context, cyclicKeys) {
-    const keys = Guard.Keys(context).filter(key => cyclicKeys.includes(key));
-    return keys.reduce((result, key) => {
-        return { ...result, [key]: InstantiateCyclic(context, key, context[key]) };
+function InstantiateCyclics(context, declarations, cyclicKeys) {
+    const declarationContext = Memory.Assign(context, declarations);
+    const declarationKeys = Guard.Keys(declarations).filter(key => cyclicKeys.includes(key));
+    return declarationKeys.reduce((result, key) => {
+        return { ...result, [key]: InstantiateCyclic(declarationContext, key, declarations[key]) };
     }, {});
 }
-function InstantiateNonCyclics(context, cyclicKeys) {
-    const keys = Guard.Keys(context).filter(key => !cyclicKeys.includes(key));
-    return keys.reduce((result, key) => {
-        return { ...result, [key]: InstantiateType(context, { callstack: [] }, context[key]) };
+function InstantiateNonCyclics(context, declarations, cyclicKeys) {
+    const declarationContext = Memory.Assign(context, declarations);
+    const declarationKeys = Guard.Keys(declarations).filter(key => !cyclicKeys.includes(key));
+    return declarationKeys.reduce((result, key) => {
+        return { ...result, [key]: InstantiateType(declarationContext, State([], []), declarations[key]) };
     }, {});
 }
-function InstantiateModule(context, options) {
-    const cyclicCandidates = CyclicCandidates(context);
-    const instantiatedCyclics = InstantiateCyclics(context, cyclicCandidates);
-    const instantiatedNonCyclics = InstantiateNonCyclics(context, cyclicCandidates);
+function InstantiateModule(context, declarations, options) {
+    const cyclicCandidates = CyclicCandidates(declarations);
+    const instantiatedCyclics = InstantiateCyclics(context, declarations, cyclicCandidates);
+    const instantiatedNonCyclics = InstantiateNonCyclics(context, declarations, cyclicCandidates);
     const instantiatedModule = { ...instantiatedCyclics, ...instantiatedNonCyclics };
     return Memory.Update(instantiatedModule, {}, options);
 }
-export function ModuleInstantiate(context, _state, properties, options) {
-    const moduleContext = Memory.Assign(context, properties);
-    const instantiatedModule = InstantiateModule(moduleContext, options);
+export function ModuleInstantiate(context, _state, declarations, options) {
+    const instantiatedModule = InstantiateModule(context, declarations, options);
     return instantiatedModule;
 }

package/node_modules/typebox/build/type/engine/object/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/node_modules/typebox/build/type/engine/object/from_dependent.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

package/node_modules/typebox/build/type/engine/object/from_type.d.mts

@@ -1,14 +1,16 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromObject } from './from_object.mjs';
 import { type TFromTuple } from './from_tuple.mjs';
 import { type TFromUnion } from './from_union.mjs';
-export type TFromType<Type extends TSchema, Result extends TProperties = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
+export type TFromType<Type extends TSchema, Result extends TProperties = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

package/node_modules/typebox/build/type/engine/object/from_type.mjs

@@ -1,20 +1,23 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromObject } from './from_object.mjs';
 import { FromTuple } from './from_tuple.mjs';
 import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-        IsIntersect(type) ? FromIntersect(type.allOf) :
-            IsUnion(type) ? FromUnion(type.anyOf) :
-                IsTuple(type) ? FromTuple(type.items) :
-                    IsObject(type) ? FromObject(type.properties) :
-                        {});
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    IsTuple(type) ? FromTuple(type.items) :
+                        IsObject(type) ? FromObject(type.properties) :
+                            {});
 }

package/node_modules/typebox/build/type/engine/object/from_union.mjs

@@ -11,9 +11,9 @@ function CollapseUnionProperties(left, right) {
     return result;
 }
 function ReduceVariants(types, result) {
-    return Guard.TakeLeft(types, (left, right) => ReduceVariants(right, CollapseUnionProperties(result, FromType(left))), () => result);
+    return Guard.ShiftLeft(types, (left, right) => ReduceVariants(right, CollapseUnionProperties(result, FromType(left))), () => result);
 }
 export function FromUnion(types) {
-    return Guard.TakeLeft(types, (left, right) => ReduceVariants(right, FromType(left)), () => Unreachable());
+    return Guard.ShiftLeft(types, (left, right) => ReduceVariants(right, FromType(left)), () => Unreachable());
 }
 // deno-coverage-ignore-stop

package/node_modules/typebox/build/type/engine/optional/instantiate_add.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TOptional } from '../../types/_optional.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddOptionalOperation<Type extends TSchema, Result extends TSchema = `~optional` extends keyof Type ? Type : TOptional<Type>> = Result;
+export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = TAddOptionalOperation<Type>> = Result;
+export declare function AddOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddOptionalAction<Type>;
+export type TAddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddOptionalAction<InstantiateType>;
+export declare function AddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddOptionalInstantiate<Context, State, Type>;
+export {};

package/node_modules/typebox/build/type/engine/optional/instantiate_add.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+function AddOptionalOperation(type) {
+    return Memory.Update(type, { '~optional': true }, {});
+}
+export function AddOptionalAction(type, options) {
+    const result = Memory.Update(AddOptionalOperation(type), {}, options);
+    return result;
+}
+export function AddOptionalInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return AddOptionalAction(instantiatedType, options);
+}

package/node_modules/typebox/build/type/engine/optional/instantiate_remove.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TOptional } from '../../types/_optional.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveOptionalOperation<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalOperation<Type> : Type> = Result;
+export type TRemoveOptionalAction<Type extends TSchema, Result extends TSchema = TRemoveOptionalOperation<Type>> = Result;
+export declare function RemoveOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveOptionalAction<Type>;
+export type TRemoveOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveOptionalAction<InstantiateType>;
+export declare function RemoveOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveOptionalInstantiate<Context, State, Type>;
+export {};

package/node_modules/typebox/build/type/engine/optional/instantiate_remove.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+function RemoveOptionalOperation(type) {
+    return Memory.Discard(type, ['~optional']);
+}
+export function RemoveOptionalAction(type, options) {
+    const result = Memory.Update(RemoveOptionalOperation(type), {}, options);
+    return result;
+}
+export function RemoveOptionalInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return RemoveOptionalAction(instantiatedType, options);
+}

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

@@ -3,11 +3,10 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TParametersDeferred } from '../../action/parameters.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TInstantiateElements } from '../instantiate.mjs';
-type TParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TFunction ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
-    callstack: [];
-}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+import { type TState } from '../instantiate.mjs';
+type TParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TFunction ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
 export type TParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TParametersOperation<Type> : TParametersDeferred<Type>> = Result;
 export declare function ParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TParametersAction<Type>;
 export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantiatedType>;

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

@@ -6,9 +6,10 @@ import { Tuple } from '../../types/tuple.mjs';
 import { ParametersDeferred } from '../../action/parameters.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { InstantiateElements } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
 function ParametersOperation(type) {
     const parameters = IsFunction(type) ? type['parameters'] : [];
-    const instantiatedParameters = InstantiateElements({}, { callstack: [] }, parameters);
+    const instantiatedParameters = InstantiateElements({}, State([], []), parameters);
     const result = Tuple(instantiatedParameters);
     return result;
 }

package/node_modules/typebox/build/type/engine/partial/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/node_modules/typebox/build/type/engine/partial/from_dependent.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

package/node_modules/typebox/build/type/engine/partial/from_intersect.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TFromType } from './from_type.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-export type TFromIntersect<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, [...Result, TFromType<Left>]> : TEvaluateIntersect<Result>);
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
 export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/node_modules/typebox/build/type/engine/partial/from_intersect.mjs

@@ -2,6 +2,7 @@
 import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 export function FromIntersect(types) {
-    const result = types.map(type => FromType(type));
-    return EvaluateIntersect(result);
+    const evaluated = EvaluateIntersect(types);
+    const result = FromType(evaluated);
+    return result;
 }

package/node_modules/typebox/build/type/engine/partial/from_object.d.mts

@@ -1,8 +1,8 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TOptionalAdd } from '../../types/_optional.mjs';
+import { type TAddOptional } from '../../action/_add_optional.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 export type TFromObject<Properties extends TProperties, Mapped extends TProperties = {
-    [Key in keyof Properties]: TOptionalAdd<Properties[Key]>;
+    [Key in keyof Properties]: TAddOptional<Properties[Key]>;
 }, Result extends TSchema = TObject<Mapped>> = Result;
 export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

package/node_modules/typebox/build/type/engine/partial/from_object.mjs

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Object } from '../../types/object.mjs';
-import { Optional } from '../../types/_optional.mjs';
+import { AddOptional } from '../../action/_add_optional.mjs';
 export function FromObject(properties) {
     const mapped = Guard.Keys(properties).reduce((result, left) => {
-        return { ...result, [left]: Optional(properties[left]) };
+        return { ...result, [left]: AddOptional(properties[left]) };
     }, {});
     const result = Object(mapped);
     return result;

package/node_modules/typebox/build/type/engine/partial/from_type.d.mts

@@ -1,12 +1,14 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromUnion } from './from_union.mjs';
 import { type TFromObject } from './from_object.mjs';
-export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
+export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

package/node_modules/typebox/build/type/engine/partial/from_type.mjs

@@ -1,17 +1,20 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromUnion } from './from_union.mjs';
 import { FromObject } from './from_object.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-        IsIntersect(type) ? FromIntersect(type.allOf) :
-            IsUnion(type) ? FromUnion(type.anyOf) :
-                IsObject(type) ? FromObject(type.properties) :
-                    Object({}));
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    IsObject(type) ? FromObject(type.properties) :
+                        Object({}));
 }

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

@@ -0,0 +1 @@
+export * from './priority.mjs';

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

@@ -0,0 +1 @@
+export * from './priority.mjs';

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

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCompare, type TCompareResult } from '../evaluate/compare.mjs';
+type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends 'right-inside' ? 1 : CompareResult extends 'disjoint' ? 1 : 0)> = Result;
+type TInsert<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TComparer<Type, Left> extends 1 ? TInsert<Type, Right, [...Result, Left]> : [...Result, Type, ...Types] : [...Result, Type]);
+type TSort<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TSort<Right, TInsert<Left, Result>> : Result);
+/**
+ * Priority sorts types in sequence of narrowest to broadest using an Insertion Sort
+ * algorithm. This function is typically used to sequence types for union variant
+ * checks to ensure that values are checked against the most narrow types before
+ * the broadest, which in turn helps ensure order-independent Union checking.
+ */
+export type TPriority<Types extends TSchema[], Result extends TSchema[] = TSort<Types>> = Result;
+/**
+ * Priority sorts types in sequence of narrowest to broadest using an Insertion Sort
+ * algorithm. This function is typically used to sequence types for union variant
+ * checks to ensure that values are checked against the most narrow types before
+ * the broadest, which in turn helps ensure order-independent Union checking.
+ */
+export declare function Priority<Types extends TSchema[]>(types: [...Types]): TPriority<Types>;
+export {};

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

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Compare } from '../evaluate/compare.mjs';
+function Comparer(left, right) {
+    const compareResult = Compare(left, right);
+    const result = (Guard.IsEqual(compareResult, 'right-inside') ? 1 :
+        Guard.IsEqual(compareResult, 'disjoint') ? 1 :
+            0);
+    return result;
+}
+function Insert(type, types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Guard.IsEqual(Comparer(type, left), 1)
+        ? Insert(type, right, [...result, left])
+        : [...result, type, ...types], () => [...result, type]);
+}
+function Sort(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Sort(right, Insert(left, result)), () => result);
+}
+/**
+ * Priority sorts types in sequence of narrowest to broadest using an Insertion Sort
+ * algorithm. This function is typically used to sequence types for union variant
+ * checks to ensure that values are checked against the most narrow types before
+ * the broadest, which in turn helps ensure order-independent Union checking.
+ */
+export function Priority(types) {
+    const result = Sort(types);
+    return result;
+}

package/node_modules/typebox/build/type/engine/readonly/instantiate_add.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TReadonly } from '../../types/_readonly.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddReadonlyOperation<Type extends TSchema, Result extends TSchema = `~readonly` extends keyof Type ? Type : TReadonly<Type>> = Result;
+export type TAddReadonlyAction<Type extends TSchema, Result extends TSchema = TAddReadonlyOperation<Type>> = Result;
+export declare function AddReadonlyAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddReadonlyAction<Type>;
+export type TAddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddReadonlyAction<InstantiateType>;
+export declare function AddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddReadonlyInstantiate<Context, State, Type>;
+export {};

package/node_modules/typebox/build/type/engine/readonly/instantiate_add.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+function AddReadonlyOperation(type) {
+    return Memory.Update(type, { '~readonly': true }, {});
+}
+export function AddReadonlyAction(type, options) {
+    const result = Memory.Update(AddReadonlyOperation(type), {}, options);
+    return result;
+}
+export function AddReadonlyInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return AddReadonlyAction(instantiatedType, options);
+}