@openclaw/matrix 2026.7.1-beta.2 → 2026.7.1-beta.5

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TReadonly } from '../../types/_readonly.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveReadonlyOperation<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? TRemoveReadonlyOperation<Type> : Type> = Result;
+export type TRemoveReadonlyAction<Type extends TSchema, Result extends TSchema = TRemoveReadonlyOperation<Type>> = Result;
+export declare function RemoveReadonlyAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveReadonlyAction<Type>;
+export type TRemoveReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveReadonlyAction<InstantiateType>;
+export declare function RemoveReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveReadonlyInstantiate<Context, State, Type>;
+export {};

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

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

package/node_modules/typebox/build/type/engine/readonly_object/from_array.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TImmutableAdd } from '../../types/_immutable.mjs';
-export type TFromArray<Type extends TSchema, Result extends TSchema = TImmutableAdd<TArray<Type>>> = Result;
+import { type TAddImmutable } from '../../action/_add_immutable.mjs';
+export type TFromArray<Type extends TSchema, Result extends TSchema = TAddImmutable<TArray<Type>>> = Result;
 export declare function FromArray<Type extends TSchema>(type: Type): TFromArray<Type>;

package/node_modules/typebox/build/type/engine/readonly_object/from_array.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Array } from '../../types/array.mjs';
-import { Immutable } from '../../types/_immutable.mjs';
+import { AddImmutable } from '../../action/_add_immutable.mjs';
 export function FromArray(type) {
-    const result = Immutable(Array(type));
+    const result = AddImmutable(Array(type));
     return result;
 }

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

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

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

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

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

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

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

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

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

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

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

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

package/node_modules/typebox/build/type/engine/readonly_object/from_tuple.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TImmutableAdd } from '../../types/_immutable.mjs';
-export type TFromTuple<Types extends TSchema[], Result extends TSchema = TImmutableAdd<TTuple<Types>>> = Result;
+import { type TAddImmutable } from '../../action/_add_immutable.mjs';
+export type TFromTuple<Types extends TSchema[], Result extends TSchema = TAddImmutable<TTuple<Types>>> = Result;
 export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

package/node_modules/typebox/build/type/engine/readonly_object/from_tuple.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Tuple } from '../../types/tuple.mjs';
-import { Immutable } from '../../types/_immutable.mjs';
+import { AddImmutable } from '../../action/_add_immutable.mjs';
 export function FromTuple(types) {
-    const result = Immutable(Tuple(types));
+    const result = AddImmutable(Tuple(types));
     return result;
 }

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

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

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

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

package/node_modules/typebox/build/type/engine/record/from_key_enum.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/index.mjs';
 import { type TEnumValue } from '../../types/enum.mjs';
-import { type TEnumValuesToUnion } from '../enum/enum_to_union.mjs';
 import { type TFromKey } from './from_key.mjs';
-export type TFromEnumKey<Values extends TEnumValue[], Value extends TSchema, UnionKey extends TSchema = TEnumValuesToUnion<Values>, Result extends TSchema = TFromKey<UnionKey, Value>> = Result;
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+export type TFromEnumKey<Values extends TEnumValue[], Value extends TSchema, UnionKey extends TSchema = TEvaluateEnum<Values>, Result extends TSchema = TFromKey<UnionKey, Value>> = Result;
 export declare function FromEnumKey<Values extends TEnumValue[], Value extends TSchema>(values: [...Values], value: Value): TFromEnumKey<Values, Value>;

package/node_modules/typebox/build/type/engine/record/from_key_enum.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { EnumValuesToUnion } from '../enum/enum_to_union.mjs';
 import { FromKey } from './from_key.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
 export function FromEnumKey(values, value) {
-    const unionKey = EnumValuesToUnion(values);
+    const unionKey = EvaluateEnum(values);
     const result = FromKey(unionKey, value);
     return result;
 }

package/node_modules/typebox/build/type/engine/record/from_key_template_literal.d.mts

@@ -3,6 +3,6 @@ import { type TRecord } from '../../types/record.mjs';
 import { type TFromKey } from './from_key.mjs';
 import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
 import { type TIsTemplateLiteralFinite } from '../template_literal/is_finite.mjs';
-import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
-export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TTemplateLiteralDecode<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TEvaluateTemplateLiteral<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
 export declare function FromTemplateKey<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TFromTemplateKey<Pattern, Value>;

package/node_modules/typebox/build/type/engine/record/from_key_template_literal.mjs

@@ -2,11 +2,11 @@
 import { FromKey } from './from_key.mjs';
 import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
 import { IsTemplateLiteralFinite } from '../template_literal/is_finite.mjs';
-import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 import { CreateRecord } from './record_create.mjs';
 export function FromTemplateKey(pattern, value) {
     const types = ParsePatternIntoTypes(pattern);
     const finite = IsTemplateLiteralFinite(types);
-    const result = finite ? FromKey(TemplateLiteralDecode(pattern), value) : CreateRecord(pattern, value);
+    const result = finite ? FromKey(EvaluateTemplateLiteral(pattern), value) : CreateRecord(pattern, value);
     return result;
 }

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

@@ -1,6 +1,6 @@
 import { type TProperties } from '../../types/properties.mjs';
-import { type TState, type TInstantiateType } from '../instantiate.mjs';
-import { type TCyclicCheck } from '../cyclic/check.mjs';
+import { type TInstantiateType } from '../instantiate.mjs';
 import { type TRef } from '../../types/ref.mjs';
-export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends keyof Context ? TCyclicCheck<[Ref], Context, Context[Ref]> extends true ? Type : TInstantiateType<Context, State, Context[Ref]> : Type);
+import { type TState } from '../instantiate.mjs';
+export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends State['visited'][number] ? Type : Ref extends keyof Context ? TInstantiateType<Context, TState<State['callstack'], [...State['visited'], Ref]>, Context[Ref]> : Type);
 export declare function RefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string>(context: Context, state: State, type: Type, ref: Ref): TRefInstantiate<Context, State, Type, Ref>;

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

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { InstantiateType } from '../instantiate.mjs';
-import { CyclicCheck } from '../cyclic/check.mjs';
+import { State } from '../instantiate.mjs';
 export function RefInstantiate(context, state, type, ref) {
-    return (ref in context
-        ? CyclicCheck([ref], context, context[ref])
-            ? type
-            : InstantiateType(context, state, context[ref])
-        : type);
+    return (state.visited.includes(ref)
+        ? type
+        : ref in context
+            ? InstantiateType(context, State(state['callstack'], [...state['visited'], ref]), context[ref])
+            : type);
 }

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

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

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

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

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

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

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

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

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

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

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

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