@openclaw/voice-call 2026.5.20-beta.2 → 2026.5.22

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

@@ -0,0 +1,23 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TCallConstruct } from '../../types/call.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TGeneric } from '../../types/generic.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TEvaluateUnion } from '../evaluate/index.mjs';
+import { type TInstantiateType } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+import { type TDistributeArguments } from './distribute_arguments.mjs';
+import { type TResolveTarget } from './resolve_target.mjs';
+import { type TResolveArgumentsContext } from './resolve_arguments.mjs';
+type TPeek<State extends TState, Result extends string = State['callstack'] extends [...infer _ extends string[], infer Top extends string] ? Top : ''> = Result;
+type TIsTailCall<State extends TState, Name extends string, Result extends boolean = TPeek<State> extends Name ? true : false> = Result;
+type TCallDispatch<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, Arguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
+    callstack: [...State['callstack'], Target['$ref']];
+}, Expression>> = TInstantiateType<Context, State, ReturnType>;
+type TCallDistributed<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, DistributedArguments extends TSchema[][], Result extends TSchema[] = []> = (DistributedArguments extends [infer Arguments extends TSchema[], ...infer DistributedArguments extends TSchema[][]] ? TCallDispatch<Context, State, Target, Parameters, Expression, Arguments> extends infer ReturnType extends TSchema ? TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments, [...Result, ReturnType]> : never : Result);
+type TCallImmediate<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, InstantiatedArguments extends TSchema[], DistributedArguments extends TSchema[][] = TDistributeArguments<Parameters, InstantiatedArguments, Expression>, ReturnTypes extends TSchema[] = TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments>, Result extends TSchema = ReturnTypes['length'] extends 1 ? ReturnTypes[0] : TEvaluateUnion<ReturnTypes>> = Result;
+export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TIsTailCall<State, Name> extends true ? TCallConstruct<TRef<Name>, InstantiatedArguments> : TCallImmediate<Context, State, TRef<Name>, Parameters, Expression, InstantiatedArguments> : TCallConstruct<Target, InstantiatedArguments>)> = Result;
+export declare function CallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[]>(context: Context, state: State, target: Target, arguments_: [...Arguments]): TCallInstantiate<Context, State, Target, Arguments>;
+export {};

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

@@ -0,0 +1,48 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { CallConstruct } from '../../types/call.mjs';
+import { Ref } from '../../types/ref.mjs';
+import { IsGeneric } from '../../types/generic.mjs';
+import { EvaluateUnion } from '../evaluate/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+import { InstantiateTypes } from '../instantiate.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { DistributeArguments } from './distribute_arguments.mjs';
+import { ResolveTarget } from './resolve_target.mjs';
+import { ResolveArgumentsContext } from './resolve_arguments.mjs';
+function Peek(state) {
+    const result = Guard.IsGreaterThan(state.callstack.length, 0) ? state.callstack[state.callstack.length - 1] : '';
+    return result;
+}
+function IsTailCall(state, name) {
+    const result = Guard.IsEqual(Peek(state), name);
+    return result;
+}
+function CallDispatch(context, state, target, parameters, expression, arguments_) {
+    const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
+    const returnType = InstantiateType(argumentsContext, { callstack: [...state.callstack, target.$ref] }, expression);
+    return InstantiateType(context, state, returnType);
+}
+function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
+    return distributedArguments.reduce((result, arguments_) => [...result, CallDispatch(context, state, target, parameters, expression, arguments_)], []);
+}
+function CallImmediate(context, state, target, parameters, expression, arguments_) {
+    const distributedArguments = DistributeArguments(parameters, arguments_, expression);
+    const returnTypes = CallDistributed(context, state, target, parameters, expression, distributedArguments);
+    const result = Guard.IsEqual(returnTypes.length, 1) ? returnTypes[0] : EvaluateUnion(returnTypes);
+    return result;
+}
+export function CallInstantiate(context, state, target, arguments_) {
+    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
+    const resolved = ResolveTarget(context, target, arguments_);
+    const name = resolved[0];
+    const type = resolved[1];
+    const result = (IsGeneric(type)
+        ? IsTailCall(state, name)
+            ? CallConstruct(Ref(name), instantiatedArguments)
+            : CallImmediate(context, state, Ref(name), type.parameters, type.expression, instantiatedArguments)
+        : CallConstruct(target, instantiatedArguments));
+    return result;
+}

package/node_modules/typebox/build/type/engine/call/resolve_arguments.d.mts

@@ -0,0 +1,13 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TBindArgument<Context extends TProperties, State extends TState, Name extends string, Extends extends TSchema, Type extends TSchema, InstantiatedArgument extends TSchema = TInstantiateType<Context, State, Type>> = Memory.TAssign<Context, {
+    [_ in Name]: InstantiatedArgument;
+}>;
+type TBindArguments<Context extends TProperties, State extends TState, ParameterLeft extends TParameter, ParameterRight extends TParameter[], Arguments extends TSchema[], InstantiatedExtends extends TSchema = TInstantiateType<Context, State, ParameterLeft['extends']>, InstantiatedEquals extends TSchema = TInstantiateType<Context, State, ParameterLeft['equals']>> = (Arguments extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, Left>, State, ParameterRight, Right> : TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, InstantiatedEquals>, State, ParameterRight, []>);
+type TBindParameters<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? TBindArguments<Context, State, Left, Right, Arguments> : Context);
+export type TResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[], Result extends TProperties = TBindParameters<Context, State, Parameters, Arguments>> = Result;
+export declare function ResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]>(context: Context, state: State, parameters: [...Parameters], arguments_: [...Arguments]): TResolveArgumentsContext<Context, State, Parameters, Arguments>;
+export {};

package/node_modules/typebox/build/type/engine/call/resolve_arguments.mjs

@@ -0,0 +1,33 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { IsInfer } from '../../types/infer.mjs';
+import { IsCall } from '../../types/call.mjs';
+// ------------------------------------------------------------------
+// AssertArgument
+// ------------------------------------------------------------------
+function AssertArgumentExtends(name, type, extends_) {
+    if (IsInfer(type) || IsCall(type) || ExtendsResult.IsExtendsTrueLike(Extends({}, type, extends_)))
+        return;
+    const cause = { parameter: name, expect: extends_, actual: type };
+    // @ts-ignore - no definition for { cause } options 
+    throw new Error(`Argument for parameter ${name} does not satisfy constraint`, { cause });
+}
+function BindArgument(context, state, name, extends_, type) {
+    const instantiatedArgument = InstantiateType(context, state, type);
+    AssertArgumentExtends(name, instantiatedArgument, extends_);
+    return Memory.Assign(context, { [name]: instantiatedArgument });
+}
+function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
+    const instantiatedExtends = InstantiateType(context, state, parameterLeft.extends);
+    const instantiatedEquals = InstantiateType(context, state, parameterLeft.equals);
+    return Guard.TakeLeft(arguments_, (left, right) => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right), () => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
+}
+function BindParameters(context, state, parameters, arguments_) {
+    return Guard.TakeLeft(parameters, (left, right) => BindArguments(context, state, left, right, arguments_), () => context);
+}
+export function ResolveArgumentsContext(context, state, parameters, arguments_) {
+    return BindParameters(context, state, parameters, arguments_);
+}

package/node_modules/typebox/build/type/engine/call/resolve_target.d.mts

@@ -0,0 +1,25 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TGeneric } from '../../types/generic.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TNever } from '../../types/never.mjs';
+type TFromNotResolvable = ([
+    '(not-resolvable)',
+    TNever
+]);
+type TFromNotGeneric = ([
+    '(not-generic)',
+    TNever
+]);
+type TFromGeneric<Name extends string, Parameters extends TParameter[], Expression extends TSchema> = ([
+    Name,
+    TGeneric<Parameters, Expression>
+]);
+type TFromRef<Context extends TProperties, Ref extends string, Arguments extends TSchema[]> = (Ref extends keyof Context ? TFromType<Context, Ref, Context[Ref], Arguments> : TFromNotResolvable);
+type TFromType<Context extends TProperties, Name extends string, Type extends TSchema, Arguments extends TSchema[]> = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TFromGeneric<Name, Parameters, Expression> : Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Arguments> : TFromNotGeneric);
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export type TResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[], Result extends [string, TSchema] = TFromType<Context, '(anonymous)', Target, Arguments>> = Result;
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export declare function ResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[]>(context: Context, target: Target, arguments_: [...Arguments]): TFromType<Context, '(anonymous)', Target, Arguments>;
+export {};

package/node_modules/typebox/build/type/engine/call/resolve_target.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Generic, IsGeneric } from '../../types/generic.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { Never } from '../../types/never.mjs';
+function FromNotResolvable() {
+    return ['(not-resolvable)', Never()];
+}
+function FromNotGeneric() {
+    return ['(not-generic)', Never()];
+}
+function FromGeneric(name, parameters, expression) {
+    return [name, Generic(parameters, expression)];
+}
+function FromRef(context, ref, arguments_) {
+    return (ref in context
+        ? FromType(context, ref, context[ref], arguments_)
+        : FromNotResolvable());
+}
+function FromType(context, name, target, arguments_) {
+    return (IsGeneric(target) ? FromGeneric(name, target.parameters, target.expression) :
+        IsRef(target) ? FromRef(context, target.$ref, arguments_) :
+            FromNotGeneric());
+}
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export function ResolveTarget(context, target, arguments_) {
+    return FromType(context, '(anonymous)', target, arguments_);
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TConditionalDeferred } from '../../action/conditional.mjs';
+type TConditionalOperation<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, ExtendsResult extends ExtendsResult.TResult = TExtends<Context, Left, Right>> = (ExtendsResult extends ExtendsResult.TExtendsUnion<infer InferredContext extends TProperties> ? TUnion<[TInstantiateType<InferredContext, State, True>, TInstantiateType<Context, State, False>]> : ExtendsResult extends ExtendsResult.TExtendsTrue<infer InferredContext extends TProperties> ? TInstantiateType<InferredContext, State, True> : TInstantiateType<Context, State, False>);
+export type TConditionalAction<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TConditionalOperation<Context, State, Left, Right, True, False> : TConditionalDeferred<Left, Right, True, False>> = Result;
+export declare function ConditionalAction<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalAction<Context, State, Left, Right, True, False>;
+export type TConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, InstaniatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstaniatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TConditionalAction<Context, State, InstaniatedLeft, InstaniatedRight, True, False>;
+export declare function ConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalInstantiate<Context, State, Left, Right, True, False>;
+export {};

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

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Union } from '../../types/union.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { ConditionalDeferred } from '../../action/conditional.mjs';
+function ConditionalOperation(context, state, left, right, true_, false_) {
+    const extendsResult = Extends(context, left, right);
+    return (ExtendsResult.IsExtendsUnion(extendsResult) ? Union([InstantiateType(extendsResult.inferred, state, true_), InstantiateType(context, state, false_)]) :
+        ExtendsResult.IsExtendsTrue(extendsResult) ? InstantiateType(extendsResult.inferred, state, true_) :
+            InstantiateType(context, state, false_));
+}
+export function ConditionalAction(context, state, left, right, true_, false_, options) {
+    const result = CanInstantiate([left, right])
+        ? Memory.Update(ConditionalOperation(context, state, left, right, true_, false_), {}, options)
+        : ConditionalDeferred(left, right, true_, false_, options);
+    return result;
+}
+export function ConditionalInstantiate(context, state, left, right, true_, false_, options) {
+    const instantiatedLeft = InstantiateType(context, state, left);
+    const instantiatedRight = InstantiateType(context, state, right);
+    return ConditionalAction(context, state, instantiatedLeft, instantiatedRight, true_, false_, options);
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateElements } from '../instantiate.mjs';
+type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
+    callstack: [];
+}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+export type TConstructorParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TConstructorParametersOperation<Type> : TConstructorParametersDeferred<Type>> = Result;
+export declare function ConstructorParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TConstructorParametersAction<Type>;
+export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;
+export declare function ConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TConstructorParametersInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,24 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { Tuple } from '../../types/tuple.mjs';
+import { ConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { InstantiateElements } from '../instantiate.mjs';
+function ConstructorParametersOperation(type) {
+    const parameters = IsConstructor(type) ? type['parameters'] : [];
+    const instantiatedParameters = InstantiateElements({}, { callstack: [] }, parameters);
+    const result = Tuple(instantiatedParameters);
+    return result;
+}
+export function ConstructorParametersAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(ConstructorParametersOperation(type), {}, options)
+        : ConstructorParametersDeferred(type, options);
+    return result;
+}
+export function ConstructorParametersInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return ConstructorParametersAction(instantiatedType, options);
+}

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

@@ -0,0 +1,9 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TProperties, type TPropertyKeys } from '../../types/properties.mjs';
+import { type TCyclicCheck } from './check.mjs';
+type TResolveCandidateKeys<Context extends TProperties, Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Context ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : TUnreachable : Result);
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export type TCyclicCandidates<Context extends TProperties, Keys extends string[] = TPropertyKeys<Context>, Result extends string[] = TResolveCandidateKeys<Context, Keys>> = Result;
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export declare function CyclicCandidates<Context extends TProperties>(context: Context): TCyclicCandidates<Context>;
+export {};

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

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { PropertyKeys } from '../../types/properties.mjs';
+import { CyclicCheck } from './check.mjs';
+function ResolveCandidateKeys(context, keys) {
+    return keys.reduce((result, left) => {
+        return left in context
+            ? CyclicCheck([left], context, context[left])
+                ? [...result, left]
+                : result
+            : Unreachable();
+    }, []);
+}
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export function CyclicCandidates(context) {
+    const keys = PropertyKeys(context);
+    const result = ResolveCandidateKeys(context, keys);
+    return result;
+}

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

@@ -0,0 +1,24 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TAsyncIterator } from '../../types/async_iterator.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TIterator } from '../../types/iterator.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TPromise } from '../../types/promise.mjs';
+import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TInterfaceDeferred } from '../../action/interface.mjs';
+type TFromRef<Stack extends string[], Context extends TProperties, Ref extends string> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
+type TFromProperties<Stack extends string[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
+type TFromTypes<Stack extends string[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
+type TFromType<Stack extends string[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export type TCyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export declare function CyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema>(stack: [...Stack], context: Context, type: Type): TCyclicCheck<Stack, Context, Type>;
+export {};

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

@@ -0,0 +1,51 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { IsAsyncIterator } from '../../types/async_iterator.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsIterator } from '../../types/iterator.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsPromise } from '../../types/promise.mjs';
+import { PropertyValues } from '../../types/properties.mjs';
+import { IsRecord, RecordValue } from '../../types/record.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { IsInterfaceDeferred } from '../../action/interface.mjs';
+function FromRef(stack, context, ref) {
+    return (stack.includes(ref)
+        ? true
+        : FromType([...stack, ref], context, context[ref]));
+}
+function FromProperties(stack, context, properties) {
+    const types = PropertyValues(properties);
+    return FromTypes(stack, context, types);
+}
+function FromTypes(stack, context, types) {
+    return Guard.TakeLeft(types, (left, right) => FromType(stack, context, left)
+        ? true
+        : FromTypes(stack, context, right), () => false);
+}
+function FromType(stack, context, type) {
+    return (IsRef(type) ? FromRef(stack, context, type.$ref) :
+        IsArray(type) ? FromType(stack, context, type.items) :
+            IsAsyncIterator(type) ? FromType(stack, context, type.iteratorItems) :
+                IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
+                    IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
+                        IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
+                            IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
+                                IsIterator(type) ? FromType(stack, context, type.iteratorItems) :
+                                    IsObject(type) ? FromProperties(stack, context, type.properties) :
+                                        IsPromise(type) ? FromType(stack, context, type.item) :
+                                            IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
+                                                IsTuple(type) ? FromTypes(stack, context, type.items) :
+                                                    IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
+                                                        false);
+}
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export function CyclicCheck(stack, context, type) {
+    const result = FromType(stack, context, type);
+    return result;
+}

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

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

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

@@ -0,0 +1,53 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { IsAsyncIterator } from '../../types/async_iterator.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsIterator } from '../../types/iterator.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsPromise } from '../../types/promise.mjs';
+import { PropertyValues } from '../../types/properties.mjs';
+import { IsRecord, RecordValue } from '../../types/record.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { IsInterfaceDeferred } from '../../action/interface.mjs';
+function FromRef(context, ref, result) {
+    return (result.includes(ref)
+        ? result
+        : ref in context
+            ? FromType(context, context[ref], [...result, ref])
+            : Unreachable());
+}
+function FromProperties(context, properties, result) {
+    const types = PropertyValues(properties);
+    return FromTypes(context, types, result);
+}
+function FromTypes(context, types, result) {
+    return types.reduce((result, left) => {
+        return FromType(context, left, result);
+    }, result);
+}
+function FromType(context, type, result) {
+    return (IsRef(type) ? FromRef(context, type.$ref, result) :
+        IsArray(type) ? FromType(context, type.items, result) :
+            IsAsyncIterator(type) ? FromType(context, type.iteratorItems, result) :
+                IsConstructor(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
+                    IsFunction(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
+                        IsInterfaceDeferred(type) ? FromProperties(context, type.parameters[1], result) :
+                            IsIntersect(type) ? FromTypes(context, type.allOf, result) :
+                                IsIterator(type) ? FromType(context, type.iteratorItems, result) :
+                                    IsObject(type) ? FromProperties(context, type.properties, result) :
+                                        IsPromise(type) ? FromType(context, type.item, result) :
+                                            IsUnion(type) ? FromTypes(context, type.anyOf, result) :
+                                                IsTuple(type) ? FromTypes(context, type.items, result) :
+                                                    IsRecord(type) ? FromType(context, RecordValue(type), result) :
+                                                        result);
+}
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export function CyclicDependencies(context, key, type) {
+    const result = FromType(context, type, [key]);
+    return result;
+}

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

@@ -0,0 +1,31 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TAsyncIterator } from '../../types/async_iterator.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TIterator } from '../../types/iterator.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TPromise } from '../../types/promise.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TUnknown } from '../../types/unknown.mjs';
+type TFromRef<_Ref extends string> = (TAny);
+type TFromProperties<Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromType<Properties[Key]>;
+}> = {
+    [Key in keyof Result]: Result[Key];
+};
+type TFromTypes<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, [...Result, TFromType<Left>]> : Result;
+type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
+type TCyclicAnyFromParameters<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? TFromType<Defs[Ref]> : TUnknown);
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export type TCyclicExtends<Type extends TCyclic, Result extends TSchema = TCyclicAnyFromParameters<Type['$defs'], Type['$ref']>> = Result;
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export declare function CyclicExtends<Type extends TCyclic>(type: Type): TCyclicExtends<Type>;
+export {};

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

@@ -0,0 +1,53 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Any } from '../../types/any.mjs';
+import { Array as _Array_, IsArray, ArrayOptions } from '../../types/array.mjs';
+import { AsyncIterator, IsAsyncIterator } from '../../types/async_iterator.mjs';
+import { Constructor, IsConstructor } from '../../types/constructor.mjs';
+import { Function as _Function_, IsFunction } from '../../types/function.mjs';
+import { Intersect, IsIntersect } from '../../types/intersect.mjs';
+import { Iterator, IsIterator } from '../../types/iterator.mjs';
+import { Object, IsObject } from '../../types/object.mjs';
+import { Promise, IsPromise } from '../../types/promise.mjs';
+import { IsRecord, Record, RecordKey, RecordValue } from '../../types/record.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { Tuple, IsTuple } from '../../types/tuple.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
+import { Unknown } from '../../types/unknown.mjs';
+function FromRef(_ref) {
+    return Any();
+}
+function FromProperties(properties) {
+    return Guard.Keys(properties).reduce((result, key) => {
+        return { ...result, [key]: FromType(properties[key]) };
+    }, {});
+}
+function FromTypes(types) {
+    return types.reduce((result, left) => {
+        return [...result, FromType(left)];
+    }, []);
+}
+function FromType(type) {
+    return (IsRef(type) ? FromRef(type.$ref) :
+        IsArray(type) ? _Array_(FromType(type.items), ArrayOptions(type)) :
+            IsAsyncIterator(type) ? AsyncIterator(FromType(type.iteratorItems)) :
+                IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
+                    IsFunction(type) ? _Function_(FromTypes(type.parameters), FromType(type.returnType)) :
+                        IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
+                            IsIterator(type) ? Iterator(FromType(type.iteratorItems)) :
+                                IsObject(type) ? Object(FromProperties(type.properties)) :
+                                    IsPromise(type) ? Promise(FromType(type.item)) :
+                                        IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
+                                            IsUnion(type) ? Union(FromTypes(type.anyOf)) :
+                                                IsTuple(type) ? Tuple(FromTypes(type.items)) :
+                                                    type);
+}
+function CyclicAnyFromParameters(defs, ref) {
+    return (ref in defs
+        ? FromType(defs[ref])
+        : Unknown());
+}
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export function CyclicExtends(type) {
+    return CyclicAnyFromParameters(type.$defs, type.$ref);
+}

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

@@ -0,0 +1,6 @@
+export * from './candidates.mjs';
+export * from './check.mjs';
+export * from './dependencies.mjs';
+export * from './extends.mjs';
+export * from './instantiate.mjs';
+export * from './target.mjs';

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

@@ -0,0 +1,6 @@
+export * from './candidates.mjs';
+export * from './check.mjs';
+export * from './dependencies.mjs';
+export * from './extends.mjs';
+export * from './instantiate.mjs';
+export * from './target.mjs';

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

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TCyclicDependencies } from '../cyclic/dependencies.mjs';
+import { type TInterfaceDeferred } from '../../action/index.mjs';
+import { type TInstantiateProperties } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
+    callstack: [];
+}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, {
+    callstack: [];
+}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+type TCyclicDefinitions<Context extends TProperties, Dependencies extends string[], Result extends TProperties = {
+    [Key in Extract<keyof Context, Dependencies[number]>]: Context[Key] extends TInterfaceDeferred<infer Heritage extends TSchema[], infer Properties extends TProperties> ? TCyclicInterface<Context, Heritage, Properties> : Context[Key];
+}> = Result;
+export type TInstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema, Dependencies extends string[] = TCyclicDependencies<Context, Ref, Type>, Definitions extends TProperties = TCyclicDefinitions<Context, Dependencies>, Result extends TSchema = TCyclic<Definitions, Ref>> = Result;
+export declare function InstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema>(context: Context, ref: Ref, type: Type): TInstantiateCyclic<Context, Ref, Type>;
+export {};