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

package/node_modules/typebox/build/type/engine/indexable/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/evaluate.mjs';
 export function FromTemplateLiteral(pattern) {
-    const decoded = TemplateLiteralDecode(pattern);
-    const result = FromType(decoded);
+    const evaluated = EvaluateTemplateLiteral(pattern);
+    const result = FromType(evaluated);
     return result;
 }

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

@@ -1,5 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
@@ -7,11 +8,12 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromEnum } from './from_enum.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromLiteral } from './from_literal.mjs';
 import { type TFromTemplateLiteral } from './from_template_literal.mjs';
 import { type TFromUnion } from './from_union.mjs';
-export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
 ])> = Result;
 export declare function FromType<Indexer extends TSchema>(type: Indexer): TFromType<Indexer>;

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

@@ -1,11 +1,13 @@
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsLiteral } from '../../types/literal.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromEnum } from './from_enum.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromLiteral } from './from_literal.mjs';
@@ -13,10 +15,11 @@ import { FromTemplateLiteral } from './from_template_literal.mjs';
 import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-        IsEnum(type) ? FromEnum(type.enum) :
-            IsIntersect(type) ? FromIntersect(type.allOf) :
-                IsLiteral(type) ? FromLiteral(type.const) :
-                    IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
-                        IsUnion(type) ? FromUnion(type.anyOf) :
-                            []);
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsEnum(type) ? FromEnum(type.enum) :
+                IsIntersect(type) ? FromIntersect(type.allOf) :
+                    IsLiteral(type) ? FromLiteral(type.const) :
+                        IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
+                            IsUnion(type) ? FromUnion(type.anyOf) :
+                                []);
 }

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

@@ -1,5 +1,6 @@
 import { type TSchema, type TSchemaOptions } 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 TUnion } from '../../types/union.mjs';
@@ -7,7 +8,7 @@ import { type TState, type TInstantiateType, type TCanInstantiate } from '../ins
 import { type TIndexDeferred } from '../../action/indexed.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 TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
 export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;
 export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;

package/node_modules/typebox/build/type/engine/indexed/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 { InstantiateType, CanInstantiate } from '../instantiate.mjs';
@@ -8,8 +9,10 @@ import { IndexDeferred } from '../../action/indexed.mjs';
 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 IndexAction(type, indexer, options) {

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

@@ -1,27 +1,31 @@
-import { type TImmutable } from '../types/_immutable.mjs';
-import { type TOptional, type TOptionalAdd, type TOptionalRemove } from '../types/_optional.mjs';
-import { type TReadonly, type TReadonlyAdd, type TReadonlyRemove } from '../types/_readonly.mjs';
+import { type TAddImmutableAction } from './immutable/instantiate_add.mjs';
+import { type TAddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { type TAddOptionalAction } from './optional/instantiate_add.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 TDeferred } from '../types/deferred.mjs';
 import { type TFunction } from '../types/function.mjs';
 import { type TCall } from '../types/call.mjs';
 import { type TIdentifier } from '../types/identifier.mjs';
+import { type TDependent } from '../types/dependent.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 TTuple } from '../types/tuple.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TRef } from '../types/ref.mjs';
 import { type TRest } from '../types/rest.mjs';
-import { type TReadonlyAddAction, type TReadonlyRemoveAction } from '../action/_readonly.mjs';
-import { type TOptionalAddAction, type TOptionalRemoveAction } from '../action/_optional.mjs';
-import { type TAwaitedInstantiate } from './awaited/instantiate.mjs';
+import { type TAddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { type TRemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { type TAddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { type TRemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { type TAddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { type TRemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { type TOptional } from '../types/_optional.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
+import { type TReadonly } from '../types/_readonly.mjs';
 import { type TCallInstantiate } from './call/instantiate.mjs';
 import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TConditionalInstantiate } from './conditional/index.mjs';
@@ -38,7 +42,6 @@ import { type TMappedInstantiate } from './mapped/instantiate.mjs';
 import { type TModuleInstantiate } from './module/instantiate.mjs';
 import { type TNonNullableInstantiate } from './non_nullable/instantiate.mjs';
 import { type TOmitInstantiate } from './omit/instantiate.mjs';
-import { type TOptionsInstantiate } from './options/instantiate.mjs';
 import { type TParametersInstantiate } from './parameters/instantiate.mjs';
 import { type TPartialInstantiate } from './partial/instantiate.mjs';
 import { type TPickInstantiate } from './pick/instantiate.mjs';
@@ -50,20 +53,15 @@ import { type TReturnTypeInstantiate } from './return_type/instantiate.mjs';
 import { type TTemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
 import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TWithInstantiate } from './with/instantiate.mjs';
 import { type TRestSpread } from './rest/index.mjs';
-export interface TState {
-    callstack: string[];
+export interface TState<CallStack extends string[] = string[], Visited extends string[] = string[]> {
+    callstack: CallStack;
+    visited: Visited;
 }
+export declare function State<CallStack extends string[], Visited extends string[]>(callstack: CallStack, visited: Visited): TState<CallStack, Visited>;
 export type TCanInstantiate<Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef ? false : TCanInstantiate<Right> : true;
 export declare function CanInstantiate<Types extends TSchema[]>(types: [...Types]): TCanInstantiate<Types>;
-type ModifierAction = 'add' | 'remove' | 'none';
-type TModifierActions<Type extends TSchema, Readonly extends ModifierAction, Optional extends ModifierAction> = (Type extends TReadonlyRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, 'remove', Optional> : Type extends TOptionalRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'remove'> : Type extends TReadonlyAddAction<infer Type extends TSchema> ? TModifierActions<Type, 'add', Optional> : Type extends TOptionalAddAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'add'> : [
-    Type,
-    Readonly,
-    Optional
-]);
-type TApplyReadonly<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TReadonlyRemove<Type> : Action extends 'add' ? TReadonlyAdd<Type> : Type);
-type TApplyOptional<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TOptionalRemove<Type> : Action extends 'add' ? TOptionalAdd<Type> : Type);
 export type TInstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties, Result extends TProperties = {
     [Key in keyof Properties]: TInstantiateType<Context, State, Properties[Key]>;
 }> = Result;
@@ -72,10 +70,26 @@ export type TInstantiateElements<Context extends TProperties, State extends TSta
 export declare function InstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateElements<Context, State, Types>;
 export type TInstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInstantiateTypes<Context, State, Right, [...Result, TInstantiateType<Context, State, Left>]> : Result);
 export declare function InstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateTypes<Context, State, Types>;
+type TWithModifiers<Type extends TSchema, InstantiatedType extends TSchema, WithOptional extends TSchema = Type extends TOptional ? TAddOptionalAction<InstantiatedType> : InstantiatedType, WithReadonly extends TSchema = Type extends TReadonly ? TAddReadonlyAction<WithOptional> : WithOptional, WithImmutable extends TSchema = Type extends TImmutable ? TAddImmutableAction<WithReadonly> : WithReadonly> = WithImmutable;
 type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
     Action,
     Parameters
-] extends ['Awaited', [infer Type extends TSchema]] ? TAwaitedInstantiate<Context, State, Type> : [
+] extends ['AddImmutable', [infer Type extends TSchema]] ? TAddImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveImmutable', [infer Type extends TSchema]] ? TRemoveImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddReadonly', [infer Type extends TSchema]] ? TAddReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveReadonly', [infer Type extends TSchema]] ? TRemoveReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddOptional', [infer Type extends TSchema]] ? TAddOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveOptional', [infer Type extends TSchema]] ? TRemoveOptionalInstantiate<Context, State, Type> : [
     Action,
     Parameters
 ] extends ['Capitalize', [infer Type extends TSchema]] ? TCapitalizeInstantiate<Context, State, Type> : [
@@ -114,7 +128,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Mapped', [infer Name extends TIdentifier, infer Key extends TSchema, infer As extends TSchema, infer Property extends TSchema]] ? TMappedInstantiate<Context, State, Name, Key, As, Property> : [
     Action,
     Parameters
-] extends ['Module', [infer Properties extends TProperties]] ? TModuleInstantiate<Context, State, Properties> : [
+] extends ['Module', [infer Declarations extends TProperties]] ? TModuleInstantiate<Context, State, Declarations> : [
     Action,
     Parameters
 ] extends ['NonNullable', [infer Type extends TSchema]] ? TNonNullableInstantiate<Context, State, Type> : [
@@ -123,9 +137,6 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Pick', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TPickInstantiate<Context, State, Type, Indexer> : [
     Action,
     Parameters
-] extends ['Options', [infer Type extends TSchema, infer Options extends TSchema]] ? TOptionsInstantiate<Context, State, Type, Options> : [
-    Action,
-    Parameters
 ] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> : [
     Action,
     Parameters
@@ -153,13 +164,15 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Uncapitalize', [infer Type extends TSchema]] ? TUncapitalizeInstantiate<Context, State, Type> : [
     Action,
     Parameters
-] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : TDeferred<Action, Parameters>);
-export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, Immutable extends boolean = Input extends TImmutable ? true : false, Modifiers extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = Modifiers[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithImmutable extends TSchema = Immutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<Modifiers[1], TApplyOptional<Modifiers[2], WithImmutable>>> = WithModifiers;
-export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, input: Type): TInstantiateType<Context, State, Type>;
+] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['With', [infer Type extends TSchema, infer Options extends TSchema]] ? TWithInstantiate<Context, State, Type, Options> : TDeferred<Action, Parameters>);
+type TInstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithModifiers extends TSchema = TWithModifiers<Type, InstantiatedType>> = WithModifiers;
+export type TInstantiateType<Context extends TProperties, State extends TState, Type extends TSchema, Result extends TSchema = Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : TInstantiateImmediate<Context, State, Type>> = Result;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type): TInstantiateImmediate<Context, State, Type>;
 /** Instantiates computed schematics using the given context and type. */
-export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, {
-    callstack: [];
-}, Type>);
+export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, TState<[], []>, Type>);
 /** Instantiates computed schematics using the given context and type. */
 export declare function Instantiate<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): TInstantiate<Context, Type>;
 export {};

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

@@ -4,37 +4,37 @@ import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Modifiers
 // ------------------------------------------------------------------
-import { IsImmutable, Immutable } from '../types/_immutable.mjs';
-import { IsOptional, OptionalAdd, OptionalRemove } from '../types/_optional.mjs';
-import { IsReadonly, ReadonlyAdd, ReadonlyRemove } from '../types/_readonly.mjs';
-// ------------------------------------------------------------------
-// Types
-// ------------------------------------------------------------------
-import { IsBase } from '../types/base.mjs';
+import { AddImmutableAction } from './immutable/instantiate_add.mjs';
+import { AddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { AddOptionalAction } from './optional/instantiate_add.mjs';
 import { _Array_, IsArray, ArrayOptions } from '../types/array.mjs';
-import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async_iterator.mjs';
 import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
 import { Deferred, IsDeferred } from '../types/deferred.mjs';
 import { _Function_, IsFunction, FunctionOptions } from '../types/function.mjs';
 import { IsCall } from '../types/call.mjs';
+import { Dependent, IsDependent, DependentOptions } from '../types/dependent.mjs';
 import { Intersect, IsIntersect, IntersectOptions } from '../types/intersect.mjs';
-import { Iterator, IsIterator, IteratorOptions } from '../types/iterator.mjs';
 import { Object, IsObject, ObjectOptions } from '../types/object.mjs';
-import { _Promise_, IsPromise, PromiseOptions } from '../types/promise.mjs';
 import { RecordFromPattern, IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
 import { Tuple, IsTuple, TupleOptions } from '../types/tuple.mjs';
 import { Union, IsUnion, UnionOptions } from '../types/union.mjs';
 import { IsRef } from '../types/ref.mjs';
 import { Rest, IsRest } from '../types/rest.mjs';
 // ------------------------------------------------------------------
-// Modifier Actions
+// Modifier Instantiate
 // ------------------------------------------------------------------
-import { IsReadonlyAddAction, IsReadonlyRemoveAction } from '../action/_readonly.mjs';
-import { IsOptionalAddAction, IsOptionalRemoveAction } from '../action/_optional.mjs';
+import { AddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { RemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { AddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { RemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { AddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { RemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { IsOptional } from '../types/_optional.mjs';
+import { IsImmutable } from '../types/_immutable.mjs';
+import { IsReadonly } from '../types/_readonly.mjs';
 // ------------------------------------------------------------------
 // Instantiate
 // ------------------------------------------------------------------
-import { AwaitedInstantiate } from './awaited/instantiate.mjs';
 import { CallInstantiate } from './call/instantiate.mjs';
 import { CapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { ConditionalInstantiate } from './conditional/index.mjs';
@@ -51,7 +51,6 @@ import { MappedInstantiate } from './mapped/instantiate.mjs';
 import { ModuleInstantiate } from './module/instantiate.mjs';
 import { NonNullableInstantiate } from './non_nullable/instantiate.mjs';
 import { OmitInstantiate } from './omit/instantiate.mjs';
-import { OptionsInstantiate } from './options/instantiate.mjs';
 import { ParametersInstantiate } from './parameters/instantiate.mjs';
 import { PartialInstantiate } from './partial/instantiate.mjs';
 import { PickInstantiate } from './pick/instantiate.mjs';
@@ -63,29 +62,16 @@ import { ReturnTypeInstantiate } from './return_type/instantiate.mjs';
 import { TemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
 import { UncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { UppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { WithInstantiate } from './with/instantiate.mjs';
 import { RestSpread } from './rest/index.mjs';
+export function State(callstack, visited) {
+    return { callstack, visited };
+}
 export function CanInstantiate(types) {
-    return Guard.TakeLeft(types, (left, right) => IsRef(left)
+    return Guard.ShiftLeft(types, (left, right) => IsRef(left)
         ? false
         : CanInstantiate(right), () => true);
 }
-function ModifierActions(type, readonly, optional) {
-    return (IsReadonlyRemoveAction(type) ? ModifierActions(type.type, 'remove', optional) :
-        IsOptionalRemoveAction(type) ? ModifierActions(type.type, readonly, 'remove') :
-            IsReadonlyAddAction(type) ? ModifierActions(type.type, 'add', optional) :
-                IsOptionalAddAction(type) ? ModifierActions(type.type, readonly, 'add') :
-                    [type, readonly, optional]);
-}
-function ApplyReadonly(action, type) {
-    return (Guard.IsEqual(action, 'remove') ? ReadonlyRemove(type) :
-        Guard.IsEqual(action, 'add') ? ReadonlyAdd(type) :
-            type);
-}
-function ApplyOptional(action, type) {
-    return (Guard.IsEqual(action, 'remove') ? OptionalRemove(type) :
-        Guard.IsEqual(action, 'add') ? OptionalAdd(type) :
-            type);
-}
 export function InstantiateProperties(context, state, properties) {
     return Guard.Keys(properties).reduce((result, key) => {
         return { ...result, [key]: InstantiateType(context, state, properties[key]) };
@@ -99,61 +85,74 @@ export function InstantiateElements(context, state, types) {
 export function InstantiateTypes(context, state, types) {
     return types.map(type => InstantiateType(context, state, type));
 }
+function WithModifiers(type, instantiatedType) {
+    const withOptional = IsOptional(type) ? AddOptionalAction(instantiatedType, {}) : instantiatedType;
+    const withReadonly = IsReadonly(type) ? AddReadonlyAction(withOptional, {}) : withOptional;
+    const withImmutable = IsImmutable(type) ? AddImmutableAction(withReadonly, {}) : withReadonly;
+    return withImmutable;
+}
 function InstantiateDeferred(context, state, action, parameters, options) {
-    return (Guard.IsEqual(action, 'Awaited') ? AwaitedInstantiate(context, state, parameters[0], options) :
-        Guard.IsEqual(action, 'Capitalize') ? CapitalizeInstantiate(context, state, parameters[0], options) :
-            Guard.IsEqual(action, 'Conditional') ? ConditionalInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
-                Guard.IsEqual(action, 'ConstructorParameters') ? ConstructorParametersInstantiate(context, state, parameters[0], options) :
-                    Guard.IsEqual(action, 'Evaluate') ? EvaluateInstantiate(context, state, parameters[0], options) :
-                        Guard.IsEqual(action, 'Exclude') ? ExcludeInstantiate(context, state, parameters[0], parameters[1], options) :
-                            Guard.IsEqual(action, 'Extract') ? ExtractInstantiate(context, state, parameters[0], parameters[1], options) :
-                                Guard.IsEqual(action, 'Index') ? IndexInstantiate(context, state, parameters[0], parameters[1], options) :
-                                    Guard.IsEqual(action, 'InstanceType') ? InstanceTypeInstantiate(context, state, parameters[0], options) :
-                                        Guard.IsEqual(action, 'Interface') ? InterfaceInstantiate(context, state, parameters[0], parameters[1], options) :
-                                            Guard.IsEqual(action, 'KeyOf') ? KeyOfInstantiate(context, state, parameters[0], options) :
-                                                Guard.IsEqual(action, 'Lowercase') ? LowercaseInstantiate(context, state, parameters[0], options) :
-                                                    Guard.IsEqual(action, 'Mapped') ? MappedInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
-                                                        Guard.IsEqual(action, 'Module') ? ModuleInstantiate(context, state, parameters[0], options) :
-                                                            Guard.IsEqual(action, 'NonNullable') ? NonNullableInstantiate(context, state, parameters[0], options) :
-                                                                Guard.IsEqual(action, 'Pick') ? PickInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                    Guard.IsEqual(action, 'Options') ? OptionsInstantiate(context, state, parameters[0], parameters[1]) :
-                                                                        Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
-                                                                            Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
-                                                                                Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                    Guard.IsEqual(action, 'ReadonlyObject') ? ReadonlyObjectInstantiate(context, state, parameters[0], options) :
-                                                                                        Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                            Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
-                                                                                                Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
-                                                                                                    Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
-                                                                                                        Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
-                                                                                                            Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
-                                                                                                                Deferred(action, parameters, options));
+    return (
+    // Modifiers
+    Guard.IsEqual(action, 'AddImmutable') ? AddImmutableInstantiate(context, state, parameters[0], options) :
+        Guard.IsEqual(action, 'RemoveImmutable') ? RemoveImmutableInstantiate(context, state, parameters[0], options) :
+            Guard.IsEqual(action, 'AddReadonly') ? AddReadonlyInstantiate(context, state, parameters[0], options) :
+                Guard.IsEqual(action, 'RemoveReadonly') ? RemoveReadonlyInstantiate(context, state, parameters[0], options) :
+                    Guard.IsEqual(action, 'AddOptional') ? AddOptionalInstantiate(context, state, parameters[0], options) :
+                        Guard.IsEqual(action, 'RemoveOptional') ? RemoveOptionalInstantiate(context, state, parameters[0], options) :
+                            // Actions
+                            Guard.IsEqual(action, 'Capitalize') ? CapitalizeInstantiate(context, state, parameters[0], options) :
+                                Guard.IsEqual(action, 'Conditional') ? ConditionalInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                    Guard.IsEqual(action, 'ConstructorParameters') ? ConstructorParametersInstantiate(context, state, parameters[0], options) :
+                                        Guard.IsEqual(action, 'Evaluate') ? EvaluateInstantiate(context, state, parameters[0], options) :
+                                            Guard.IsEqual(action, 'Exclude') ? ExcludeInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                Guard.IsEqual(action, 'Extract') ? ExtractInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                    Guard.IsEqual(action, 'Index') ? IndexInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                        Guard.IsEqual(action, 'InstanceType') ? InstanceTypeInstantiate(context, state, parameters[0], options) :
+                                                            Guard.IsEqual(action, 'Interface') ? InterfaceInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                Guard.IsEqual(action, 'KeyOf') ? KeyOfInstantiate(context, state, parameters[0], options) :
+                                                                    Guard.IsEqual(action, 'Lowercase') ? LowercaseInstantiate(context, state, parameters[0], options) :
+                                                                        Guard.IsEqual(action, 'Mapped') ? MappedInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                                                            Guard.IsEqual(action, 'Module') ? ModuleInstantiate(context, state, parameters[0], options) :
+                                                                                Guard.IsEqual(action, 'NonNullable') ? NonNullableInstantiate(context, state, parameters[0], options) :
+                                                                                    Guard.IsEqual(action, 'Pick') ? PickInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                        Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
+                                                                                            Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
+                                                                                                Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                                    Guard.IsEqual(action, 'ReadonlyObject') ? ReadonlyObjectInstantiate(context, state, parameters[0], options) :
+                                                                                                        Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                                            Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
+                                                                                                                Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
+                                                                                                                    Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
+                                                                                                                        Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
+                                                                                                                            Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
+                                                                                                                                Guard.IsEqual(action, 'With') ? WithInstantiate(context, state, parameters[0], parameters[1]) :
+                                                                                                                                    Deferred(action, parameters, options));
 }
-export function InstantiateType(context, state, input) {
-    const immutable = IsImmutable(input);
-    const modifiers = ModifierActions(input, IsReadonly(input) ? 'add' : 'none', IsOptional(input) ? 'add' : 'none');
-    const type = IsBase(modifiers[0]) ? modifiers[0].Clone() : modifiers[0];
-    const instantiated = (IsRef(type) ? RefInstantiate(context, state, type, type.$ref) :
+function InstantiateImmediate(context, state, type) {
+    const instantiatedType = (IsRef(type) ? RefInstantiate(context, state, type, type.$ref) :
         IsArray(type) ? _Array_(InstantiateType(context, state, type.items), ArrayOptions(type)) :
-            IsAsyncIterator(type) ? AsyncIterator(InstantiateType(context, state, type.iteratorItems), AsyncIteratorOptions(type)) :
-                IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) :
-                    IsConstructor(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) :
-                        IsDeferred(type) ? InstantiateDeferred(context, state, type.action, type.parameters, type.options) :
-                            IsFunction(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) :
-                                IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
-                                    IsIterator(type) ? Iterator(InstantiateType(context, state, type.iteratorItems), IteratorOptions(type)) :
-                                        IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :
-                                            IsPromise(type) ? _Promise_(InstantiateType(context, state, type.item), PromiseOptions(type)) :
-                                                IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) :
-                                                    IsRest(type) ? Rest(InstantiateType(context, state, type.items)) :
-                                                        IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
-                                                            IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
-                                                                type);
-    const withImmutable = immutable ? Immutable(instantiated) : instantiated;
-    const withModifiers = ApplyReadonly(modifiers[1], ApplyOptional(modifiers[2], withImmutable));
+            IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) :
+                IsConstructor(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) :
+                    IsFunction(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) :
+                        IsDependent(type) ? Dependent(InstantiateType(context, state, type.if), InstantiateType(context, state, type.then), InstantiateType(context, state, type.else), DependentOptions(type)) :
+                            IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
+                                IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :
+                                    IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) :
+                                        IsRest(type) ? Rest(InstantiateType(context, state, type.items)) :
+                                            IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
+                                                IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
+                                                    type);
+    const withModifiers = WithModifiers(type, instantiatedType);
     return withModifiers;
 }
+export function InstantiateType(context, state, type) {
+    const result = IsDeferred(type)
+        ? InstantiateDeferred(context, state, type.action, type.parameters, type.options)
+        : InstantiateImmediate(context, state, type);
+    return result;
+}
 /** Instantiates computed schematics using the given context and type. */
 export function Instantiate(context, type) {
-    return InstantiateType(context, { callstack: [] }, type);
+    return InstantiateType(context, State([], []), type);
 }

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

@@ -3,16 +3,13 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
 import { type TInterfaceDeferred } from '../../action/index.mjs';
-import { type TState, type TCanInstantiate } from '../instantiate.mjs';
+import { type TCanInstantiate } from '../instantiate.mjs';
 import { type TInstantiateProperties } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
 type TInterfaceOperation<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TEvaluateIntersect<[...Heritage, TObject<Properties>]>> = Result;
 export type TInterfaceAction<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TCanInstantiate<Heritage> extends true ? TInterfaceOperation<Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>> = Result;
 export declare function InterfaceAction<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceAction<Heritage, Properties>;
-export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
-    callstack: [];
-}, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, {
-    callstack: [];
-}, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, State, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, State, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
 export declare function InterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties>(context: Context, state: State, heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceInstantiate<Context, State, Heritage, Properties>;
 export {};

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> ? {