@openclaw/facetime 0.0.0 → 2026.9.7

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

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TDeferred } from '../../types/deferred.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Left['$ref']]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Expression extends TDeferred<'Mapped', [infer _Identifier extends TSchema, infer Type extends TSchema, infer _As extends TSchema, infer _Property extends TSchema]> ? (Type extends TDeferred<'KeyOf', [infer Ref extends TRef]> ? [...Result, Ref['$ref']] : Result) : Result);
+type TBuildDistributionArray<Parameters extends TParameter[], Names extends string[], Result extends boolean[] = []> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? Left['name'] extends Names[number] ? TBuildDistributionArray<Right, Names, [...Result, true]> : TBuildDistributionArray<Right, Names, [...Result, false]> : Result);
+type TZipDistributionArray<Arguments extends TSchema[], DistributionArray extends boolean[], Result extends [boolean, TSchema][] = []> = (Arguments extends [infer ArgumentLeft extends TSchema, ...infer ArgumentRight extends TSchema[]] ? DistributionArray extends [infer BooleanLeft extends boolean, ...infer BooleanRight extends boolean[]] ? TZipDistributionArray<ArgumentRight, BooleanRight, [...Result, [BooleanLeft, ArgumentLeft]]> : Result : Result);
+type TCanonicalArgument<Type extends TSchema> = (Type extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : Type extends TEnum<infer Values extends TEnumValue[]> ? TEvaluateEnum<Values> : Type);
+type TExpand<Argument extends TSchema, CanonicalArgument extends TSchema = TCanonicalArgument<Argument>> = (CanonicalArgument extends TUnion<infer Types extends TSchema[]> ? [...Types] : [CanonicalArgument]);
+type TAppend<Current extends TSchema[][], Type extends TSchema, Result extends TSchema[][] = []> = (Current extends [infer Left extends TSchema[], ...infer Right extends TSchema[][]] ? TAppend<Right, Type, [...Result, [...Left, Type]]> : Result);
+type TCross<Current extends TSchema[][], Variants extends TSchema[], Result extends TSchema[][] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCross<Current, Right, [...Result, ...TAppend<Current, Left>]> : Result);
+type TDistribute<ZippedArguments extends [boolean, TSchema][], Result extends TSchema[][] = [[]]> = (ZippedArguments extends [infer Left extends [boolean, TSchema], ...infer Right extends [boolean, TSchema][]] ? Left[0] extends true ? TDistribute<Right, TCross<Result, TExpand<Left[1]>>> : TDistribute<Right, TCross<Result, [Left[1]]>> : Result);
+export type TDistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema, DistributionNames extends string[] = TCollectDistributionNames<Expression>, DistributionArray extends boolean[] = TBuildDistributionArray<Parameters, DistributionNames>, ZippedArguments extends [boolean, TSchema][] = TZipDistributionArray<Arguments, DistributionArray>, Result extends TSchema[][] = (Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<ZippedArguments> : Expression extends TDeferred<'Mapped', TSchema[]> ? TDistribute<ZippedArguments> : [Arguments])> = Result;
+export declare function DistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema>(parameters: [...Parameters], arguments_: [...Arguments], expression: Expression): TDistributeArguments<Parameters, Arguments, Expression>;
+export {};

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

@@ -0,0 +1,66 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsDeferred } from '../../types/deferred.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { IsRef } from '../../types/ref.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
+function CollectDistributionNames(expression, result = []) {
+    return (
+    // Conditional
+    IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? IsRef(expression.parameters[0])
+            ? CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], [...result, expression.parameters[0]['$ref']]))
+            : CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], result))
+        // Mapped
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? (IsDeferred(expression.parameters[1]) && Guard.IsEqual(expression.parameters[1].action, 'KeyOf') && IsRef(expression.parameters[1].parameters[0]) ? [...result, expression.parameters[1].parameters[0]['$ref']] :
+                result) : result);
+}
+function BuildDistributionArray(parameters, names) {
+    return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
+}
+function ZipDistributionArray(arguments_, distributionArray, result = []) {
+    return Guard.ShiftLeft(arguments_, (argumentLeft, argumentRight) => Guard.ShiftLeft(distributionArray, (booleanLeft, booleanRight) => ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]]), () => result), () => result);
+}
+function CanonicalArgument(type) {
+    return (IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
+        IsEnum(type) ? EvaluateEnum(type.enum) :
+            type);
+}
+function Expand(type) {
+    const canonicalArgument = CanonicalArgument(type);
+    return (IsUnion(canonicalArgument)
+        ? [...canonicalArgument.anyOf]
+        : [canonicalArgument]);
+}
+function Append(current, type) {
+    return current.reduce((result, left) => [...result, [...left, type]], []);
+}
+function Cross(current, variants) {
+    return variants.reduce((result, left) => {
+        return [...result, ...Append(current, left)];
+    }, []);
+}
+function Distribute(zipped) {
+    return zipped.reduce((result, left) => {
+        return Guard.IsEqual(left[0], true)
+            ? Cross(result, Expand(left[1]))
+            : Cross(result, [left[1]]); // - no-expansion
+    }, [[]]);
+}
+export function DistributeArguments(parameters, arguments_, expression) {
+    const distributionNames = CollectDistributionNames(expression);
+    const distributionArray = BuildDistributionArray(parameters, distributionNames);
+    const zippedArguments = ZipDistributionArray(arguments_, distributionArray);
+    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? Distribute(zippedArguments)
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? Distribute(zippedArguments)
+            : [arguments_]);
+}

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

@@ -0,0 +1,21 @@
+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, TState<[...State['callstack'], Target['$ref']], State['visited']>, Expression>> = TInstantiateType<ArgumentsContext, TState<[], []>, 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,79 @@
+// deno-fmt-ignore-file
+import { Settings } from '../../../system/settings/index.mjs';
+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';
+import { State } from '../instantiate.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { DistributeArguments } from './distribute_arguments.mjs';
+import { ResolveTarget } from './resolve_target.mjs';
+import { ResolveArgumentsContext } from './resolve_arguments.mjs';
+// ------------------------------------------------------------------
+// InstantiationGuard
+// ------------------------------------------------------------------
+let instantiationDepth = 0;
+let instantiationCount = 0;
+function InstantiationAssert() {
+    if (Guard.IsLessThan(instantiationCount, Settings.Get().maxInstantiationCount))
+        return;
+    throw Error('Type instantiation is excessively deep and possibly infinite');
+}
+function InstantiationIncrement() {
+    InstantiationAssert();
+    instantiationCount++;
+    instantiationDepth++;
+}
+function InstantiationDecrement() {
+    instantiationDepth--;
+    if (Guard.IsEqual(instantiationDepth, 0))
+        instantiationCount = 0;
+}
+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_) {
+    InstantiationIncrement();
+    try {
+        const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
+        const returnType = InstantiateType(argumentsContext, State([...state['callstack'], target['$ref']], state['visited']), expression);
+        return InstantiateType(argumentsContext, State([], []), returnType);
+    }
+    finally {
+        InstantiationDecrement();
+    }
+}
+function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
+    return distributedArguments.reduce((result, arguments_) => {
+        const returnType = CallDispatch(context, state, target, parameters, expression, arguments_);
+        return [...result, returnType];
+    }, []);
+}
+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.ShiftLeft(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.ShiftLeft(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,14 @@
+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 TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateElements } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, 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,25 @@
+// 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';
+import { State } from '../instantiate.mjs';
+function ConstructorParametersOperation(type) {
+    const parameters = IsConstructor(type) ? type['parameters'] : [];
+    const instantiatedParameters = InstantiateElements({}, State([], []), 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,8 @@
+import { type TProperties, type TPropertyKeys } from '../../types/properties.mjs';
+import { type TCyclicCheck } from './check.mjs';
+type TResolveCandidateKeys<Context extends TProperties, Keys extends (keyof Context)[], Result extends (keyof Context)[] = []> = (Keys extends [infer Left extends keyof Context, ...infer Right extends (keyof Context)[]] ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : Result);
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export type TCyclicCandidates<Context extends TProperties, Keys extends (keyof Context)[] = TPropertyKeys<Context>, Result extends (keyof Context)[] = 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,16 @@
+// deno-fmt-ignore-file
+import { PropertyKeys } from '../../types/properties.mjs';
+import { CyclicCheck } from './check.mjs';
+function ResolveCandidateKeys(context, keys) {
+    return keys.reduce((result, left) => {
+        return CyclicCheck([left], context, context[left])
+            ? [...result, left]
+            : result;
+    }, []);
+}
+/** 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,21 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.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 (keyof Context)[], Context extends TProperties, Ref extends (keyof Context)> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
+type TFromProperties<Stack extends (keyof Context)[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
+type TFromTypes<Stack extends (keyof Context)[], 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 (keyof Context)[], 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 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 TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : 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 (keyof Context)[], 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 (keyof Context)[], 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,45 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsObject } from '../../types/object.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.ShiftLeft(types, (left, right) => FromType(stack, context, left)
+        ? true
+        : FromTypes(stack, context, right), () => false);
+}
+function FromType(stack, context, type) {
+    return (IsRef(type) ? FromRef(stack, context, type.$ref) :
+        IsArray(type) ? FromType(stack, context, type.items) :
+            IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
+                IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
+                    IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
+                        IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
+                            IsObject(type) ? FromProperties(stack, context, type.properties) :
+                                IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
+                                    IsTuple(type) ? FromTypes(stack, context, type.items) :
+                                        IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
+                                            false);
+}
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export function CyclicCheck(stack, context, type) {
+    const result = FromType(stack, context, type);
+    return result;
+}

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

@@ -0,0 +1,22 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.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 TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export type TCyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema, Result extends string[] = TFromType<Context, Type, [Key]>> = Result;
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+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,47 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsObject } from '../../types/object.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) :
+            IsConstructor(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
+                IsFunction(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
+                    IsInterfaceDeferred(type) ? FromProperties(context, type.parameters[1], result) :
+                        IsIntersect(type) ? FromTypes(context, type.allOf, result) :
+                            IsObject(type) ? FromProperties(context, type.properties, result) :
+                                IsUnion(type) ? FromTypes(context, type.anyOf, result) :
+                                    IsTuple(type) ? FromTypes(context, type.items, result) :
+                                        IsRecord(type) ? FromType(context, RecordValue(type), result) :
+                                            result);
+}
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export function CyclicDependencies(context, key, type) {
+    const result = FromType(context, type, [key]);
+    return result;
+}

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

@@ -0,0 +1,28 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TArray } from '../../types/array.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 TObject } from '../../types/object.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 TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
+type TCyclicAnyFromParameters<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? TFromType<Defs[Ref]> : TUnknown);
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export type TCyclicExtends<Type extends TCyclic, Result extends TSchema = TCyclicAnyFromParameters<Type['$defs'], Type['$ref']>> = Result;
+/** 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 {};