@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/typebox/build/system/memory/clone.mjs

@@ -1,28 +1,33 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
 // ------------------------------------------------------------------
-// Guard
+// ClassInstance
+//
+// TypeBox does not clone arbitrary class instances. Class instances
+// cannot be safely cloned without potentially breaking private
+// members of the instance.
+//
 // ------------------------------------------------------------------
-function IsGuard(value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~guard');
-}
-function FromGuard(value) {
-    return value; // non-clonable
+function FromClassInstance(value) {
+    return value; // atomic
 }
 // ------------------------------------------------------------------
-// Array
+// TypeObject
+//
+// Types have non-enumerable properties that MUST be preserved on Clone. 
+// The following is the optimal path for TypeBox types.
 // ------------------------------------------------------------------
-function FromArray(value) {
-    return value.map((value) => FromValue(value));
+function IsTypeObject(value) {
+    return (Guard.HasPropertyKey(value, '~kind') ||
+        Guard.HasPropertyKey(value, '~unsafe'));
 }
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-function FromObject(value) {
+function FromTypeObject(value) {
     const result = {};
     const descriptors = Object.getOwnPropertyDescriptors(value);
     for (const key of Object.keys(descriptors)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         const descriptor = descriptors[key];
         if (Guard.HasPropertyKey(descriptor, 'value')) {
             Object.defineProperty(result, key, { ...descriptor, value: FromValue(descriptor.value) });
@@ -31,31 +36,73 @@ function FromObject(value) {
     return result;
 }
 // ------------------------------------------------------------------
+// PlainObject
+// ------------------------------------------------------------------
+function FromPlainObject(value) {
+    const result = {};
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
+        result[key] = FromValue(value[key]);
+    }
+    for (const key of Guard.Symbols(value)) {
+        result[key] = FromValue(value[key]);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
+        IsTypeObject(value) ? FromTypeObject(value) :
+            FromPlainObject(value));
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    return value.map((element) => FromValue(element));
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypedArray(value) {
+    return value.slice();
+}
+// ------------------------------------------------------------------
 // RegExp
 // ------------------------------------------------------------------
 function FromRegExp(value) {
     return new RegExp(value.source, value.flags);
 }
 // ------------------------------------------------------------------
-// RegExp
+// Map
 // ------------------------------------------------------------------
-function FromUnknown(value) {
-    return value;
+function FromMap(value) {
+    return new Map(FromValue([...value.entries()]));
 }
 // ------------------------------------------------------------------
-// Value
+// Set
 // ------------------------------------------------------------------
+function FromSet(value) {
+    return new Set(FromValue([...value.values()]));
+}
 function FromValue(value) {
-    return (value instanceof RegExp ? FromRegExp(value) :
-        IsGuard(value) ? FromGuard(value) :
-            Guard.IsArray(value) ? FromArray(value) :
-                Guard.IsObject(value) ? FromObject(value) :
-                    FromUnknown(value));
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
+        GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+            GlobalsGuard.IsMap(value) ? FromMap(value) :
+                GlobalsGuard.IsSet(value) ? FromSet(value) :
+                    Guard.IsArray(value) ? FromArray(value) :
+                        Guard.IsObject(value) ? FromObject(value) :
+                            value);
 }
+// ------------------------------------------------------------------
+// Clone
+// ------------------------------------------------------------------
 /**
- * Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
- * properties from the source value. This is to ensure cloned types retain discriminable
- * hidden properties.
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
  */
 export function Clone(value) {
     Metrics.clone += 1;

package/node_modules/typebox/build/system/settings/settings.d.mts

@@ -3,6 +3,7 @@ export interface TSettings {
      * Determines whether types should be instantiated as immutable using `Object.freeze(...)`.
      * This helps prevent unintended schema mutation. Enabling this option introduces a slight
      * performance overhead during instantiation.
+     *
      * @default false
      */
     immutableTypes: boolean;
@@ -11,6 +12,7 @@ export interface TSettings {
      * performs exhaustive checks to gather diagnostics for invalid values, which can result in
      * excessive buffering for large or complex types. This setting limits the number of buffered
      * errors and acts as a safeguard against potential denial-of-service (DoS) attacks.
+     *
      * @default 8
      */
     maxErrors: number;
@@ -20,6 +22,7 @@ export interface TSettings {
      * generated code. If evaluation is not permitted, it falls back to dynamic checking. Setting
      * this to `false` disables evaluation entirely, which may be desirable in applications that
      * restrict runtime code evaluation, regardless of Content Security Policy (CSP).
+     *
      * @default true
      */
     useAcceleration: boolean;
@@ -30,11 +33,13 @@ export interface TSettings {
      * TypeScript semantics to remain consistent with the language. This option is provided to align
      * runtime check semantics with projects that configure 'exactOptionalPropertyTypes: true' in
      * tsconfig.json.
+     *
      * @default false
      */
     exactOptionalPropertyTypes: boolean;
     /**
      * Controls whether internal compositor properties (`~kind`, `~readonly`, `~optional`) are enumerable.
+     *
      * @default false
      */
     enumerableKind: boolean;
@@ -44,9 +49,19 @@ export interface TSettings {
      * the value, followed by a subsequent `Assert`. Enabling this option may incur significant performance
      * overhead for invalid values. It is recommended to keep this disabled in performance-sensitive
      * applications.
+     *
      * @default false
      */
     correctiveParse: boolean;
+    /**
+     * Controls whether TypeBox sorts Union variants by specificity (narrowest first) for operations
+     * that require deterministic value matching, such as Clean, Decode, and Encode. When enabled,
+     * more specific types (e.g. Literal) always take precedence over broader types (e.g. String),
+     * regardless of the order variants are declared.
+     *
+     * @default true
+     */
+    unionPrioritySort: boolean;
 }
 /** Resets system settings to defaults */
 export declare function Reset(): void;

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -6,7 +6,8 @@ const settings = {
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
     enumerableKind: false,
-    correctiveParse: false
+    correctiveParse: false,
+    unionPrioritySort: true
 };
 /** Resets system settings to defaults */
 export function Reset() {
@@ -16,6 +17,7 @@ export function Reset() {
     settings.exactOptionalPropertyTypes = false;
     settings.enumerableKind = false;
     settings.correctiveParse = false;
+    settings.unionPrioritySort = true;
 }
 /** Sets system settings */
 export function Set(options) {

package/node_modules/typebox/build/type/action/_add_immutable.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TAddImmutableAction } from '../engine/immutable/instantiate_add.mjs';
+/** Creates a deferred AddImmutable action. */
+export type TAddImmutableDeferred<Type extends TSchema> = (TDeferred<'AddImmutable', [Type]>);
+/** Creates a deferred AddImmutable action. */
+export declare function AddImmutableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddImmutableDeferred<Type>;
+/** Applies an AddImmutable action to a type. */
+export type TAddImmutable<Type extends TSchema> = (TAddImmutableAction<Type>);
+/** Applies an AddImmutable action to a type. */
+export declare function AddImmutable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddImmutable<Type>;

package/node_modules/typebox/build/type/action/_add_immutable.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { AddImmutableAction } from '../engine/immutable/instantiate_add.mjs';
+/** Creates a deferred AddImmutable action. */
+export function AddImmutableDeferred(type, options = {}) {
+    return Deferred('AddImmutable', [type], options);
+}
+/** Applies an AddImmutable action to a type. */
+export function AddImmutable(type, options = {}) {
+    return AddImmutableAction(type, options);
+}

package/node_modules/typebox/build/type/action/_add_optional.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TAddOptionalAction } from '../engine/optional/instantiate_add.mjs';
+/** Creates a deferred AddOptional action. */
+export type TAddOptionalDeferred<Type extends TSchema> = (TDeferred<'AddOptional', [Type]>);
+/** Creates a deferred AddOptional action. */
+export declare function AddOptionalDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddOptionalDeferred<Type>;
+/** Applies an AddOptional action to a type. */
+export type TAddOptional<Type extends TSchema> = (TAddOptionalAction<Type>);
+/** Applies an AddOptional action to a type. */
+export declare function AddOptional<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddOptional<Type>;

package/node_modules/typebox/build/type/action/_add_optional.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { AddOptionalAction } from '../engine/optional/instantiate_add.mjs';
+/** Creates a deferred AddOptional action. */
+export function AddOptionalDeferred(type, options = {}) {
+    return Deferred('AddOptional', [type], options);
+}
+/** Applies an AddOptional action to a type. */
+export function AddOptional(type, options = {}) {
+    return AddOptionalAction(type, options);
+}

package/node_modules/typebox/build/type/action/_add_readonly.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TAddReadonlyAction } from '../engine/readonly/instantiate_add.mjs';
+/** Creates a deferred AddReadonly action. */
+export type TAddReadonlyDeferred<Type extends TSchema> = (TDeferred<'AddReadonly', [Type]>);
+/** Creates a deferred AddReadonly action. */
+export declare function AddReadonlyDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddReadonlyDeferred<Type>;
+/** Applies an AddReadonly action to a type. */
+export type TAddReadonly<Type extends TSchema> = (TAddReadonlyAction<Type>);
+/** Applies an AddReadonly action to a type. */
+export declare function AddReadonly<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddReadonly<Type>;

package/node_modules/typebox/build/type/action/_add_readonly.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { AddReadonlyAction } from '../engine/readonly/instantiate_add.mjs';
+/** Creates a deferred AddReadonly action. */
+export function AddReadonlyDeferred(type, options = {}) {
+    return Deferred('AddReadonly', [type], options);
+}
+/** Applies an AddReadonly action to a type. */
+export function AddReadonly(type, options = {}) {
+    return AddReadonlyAction(type, options);
+}

package/node_modules/typebox/build/type/action/_remove_immutable.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveImmutableAction } from '../engine/immutable/instantiate_remove.mjs';
+/** Creates a deferred RemoveImmutable action. */
+export type TRemoveImmutableDeferred<Type extends TSchema> = (TDeferred<'RemoveImmutable', [Type]>);
+/** Creates a deferred RemoveImmutable action. */
+export declare function RemoveImmutableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutableDeferred<Type>;
+/** Applies an RemoveImmutable action to a type. */
+export type TRemoveImmutable<Type extends TSchema> = (TRemoveImmutableAction<Type>);
+/** Applies an RemoveImmutable action to a type. */
+export declare function RemoveImmutable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutable<Type>;

package/node_modules/typebox/build/type/action/_remove_immutable.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { RemoveImmutableAction } from '../engine/immutable/instantiate_remove.mjs';
+/** Creates a deferred RemoveImmutable action. */
+export function RemoveImmutableDeferred(type, options = {}) {
+    return Deferred('RemoveImmutable', [type], options);
+}
+/** Applies an RemoveImmutable action to a type. */
+export function RemoveImmutable(type, options = {}) {
+    return RemoveImmutableAction(type, options);
+}

package/node_modules/typebox/build/type/action/_remove_optional.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveOptionalAction } from '../engine/optional/instantiate_remove.mjs';
+/** Creates a deferred RemoveOptional action. */
+export type TRemoveOptionalDeferred<Type extends TSchema> = (TDeferred<'RemoveOptional', [Type]>);
+/** Creates a deferred RemoveOptional action. */
+export declare function RemoveOptionalDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptionalDeferred<Type>;
+/** Applies an RemoveOptional action to a type. */
+export type TRemoveOptional<Type extends TSchema> = (TRemoveOptionalAction<Type>);
+/** Applies an RemoveOptional action to a type. */
+export declare function RemoveOptional<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptional<Type>;

package/node_modules/typebox/build/type/action/_remove_optional.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { RemoveOptionalAction } from '../engine/optional/instantiate_remove.mjs';
+/** Creates a deferred RemoveOptional action. */
+export function RemoveOptionalDeferred(type, options = {}) {
+    return Deferred('RemoveOptional', [type], options);
+}
+/** Applies an RemoveOptional action to a type. */
+export function RemoveOptional(type, options = {}) {
+    return RemoveOptionalAction(type, options);
+}

package/node_modules/typebox/build/type/action/_remove_readonly.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveReadonlyAction } from '../engine/readonly/instantiate_remove.mjs';
+/** Creates a deferred RemoveReadonly action. */
+export type TRemoveReadonlyDeferred<Type extends TSchema> = (TDeferred<'RemoveReadonly', [Type]>);
+/** Creates a deferred RemoveReadonly action. */
+export declare function RemoveReadonlyDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveReadonlyDeferred<Type>;
+/** Applies an RemoveReadonly action to a type. */
+export type TRemoveReadonly<Type extends TSchema> = (TRemoveReadonlyAction<Type>);
+/** Applies an RemoveReadonly action to a type. */
+export declare function RemoveReadonly<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveReadonly<Type>;

package/node_modules/typebox/build/type/action/_remove_readonly.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { RemoveReadonlyAction } from '../engine/readonly/instantiate_remove.mjs';
+/** Creates a deferred RemoveReadonly action. */
+export function RemoveReadonlyDeferred(type, options = {}) {
+    return Deferred('RemoveReadonly', [type], options);
+}
+/** Applies an RemoveReadonly action to a type. */
+export function RemoveReadonly(type, options = {}) {
+    return RemoveReadonlyAction(type, options);
+}

package/node_modules/typebox/build/type/action/conditional.d.mts

@@ -1,13 +1,12 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TConditionalAction } from '../engine/conditional/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 /** Creates a deferred Conditional action. */
 export type TConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TDeferred<'Conditional', [Left, Right, True, False]>);
 /** Creates a deferred Conditional action. */
 export declare function ConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditionalDeferred<Left, Right, True, False>;
 /** Applies a Conditional action to the given types. */
-export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TConditionalAction<{}, {
-    callstack: [];
-}, Left, Right, True, False>);
+export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TConditionalAction<{}, TState<[], []>, Left, Right, True, False>);
 /** Applies a Conditional action to the given types. */
 export declare function Conditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditional<Left, Right, True, False>;

package/node_modules/typebox/build/type/action/conditional.mjs

@@ -2,11 +2,12 @@
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { ConditionalAction } from '../engine/conditional/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 /** Creates a deferred Conditional action. */
 export function ConditionalDeferred(left, right, true_, false_, options = {}) {
     return Deferred('Conditional', [left, right, true_, false_], options);
 }
 /** Applies a Conditional action to the given types. */
 export function Conditional(left, right, true_, false_, options = {}) {
-    return ConditionalAction({}, { callstack: [] }, left, right, true_, false_, options);
+    return ConditionalAction({}, State([], []), left, right, true_, false_, options);
 }

package/node_modules/typebox/build/type/action/index.d.mts

@@ -1,6 +1,9 @@
-export * from './_optional.mjs';
-export * from './_readonly.mjs';
-export * from './awaited.mjs';
+export * from './_add_immutable.mjs';
+export * from './_add_readonly.mjs';
+export * from './_add_optional.mjs';
+export * from './_remove_immutable.mjs';
+export * from './_remove_readonly.mjs';
+export * from './_remove_optional.mjs';
 export * from './capitalize.mjs';
 export * from './conditional.mjs';
 export * from './constructor_parameters.mjs';
@@ -16,7 +19,6 @@ export * from './mapped.mjs';
 export * from './module.mjs';
 export * from './non_nullable.mjs';
 export * from './omit.mjs';
-export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
@@ -25,3 +27,4 @@ export * from './required.mjs';
 export * from './return_type.mjs';
 export * from './uncapitalize.mjs';
 export * from './uppercase.mjs';
+export * from './with.mjs';

package/node_modules/typebox/build/type/action/index.mjs

@@ -1,6 +1,9 @@
-export * from './_optional.mjs';
-export * from './_readonly.mjs';
-export * from './awaited.mjs';
+export * from './_add_immutable.mjs';
+export * from './_add_readonly.mjs';
+export * from './_add_optional.mjs';
+export * from './_remove_immutable.mjs';
+export * from './_remove_readonly.mjs';
+export * from './_remove_optional.mjs';
 export * from './capitalize.mjs';
 export * from './conditional.mjs';
 export * from './constructor_parameters.mjs';
@@ -16,7 +19,6 @@ export * from './mapped.mjs';
 export * from './module.mjs';
 export * from './non_nullable.mjs';
 export * from './omit.mjs';
-export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
@@ -25,3 +27,4 @@ export * from './required.mjs';
 export * from './return_type.mjs';
 export * from './uncapitalize.mjs';
 export * from './uppercase.mjs';
+export * from './with.mjs';

package/node_modules/typebox/build/type/action/mapped.d.mts

@@ -2,13 +2,12 @@ import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TIdentifier } from '../types/identifier.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TMappedAction } from '../engine/mapped/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
 export type TMappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Type, As, Property]>);
 /** Creates a deferred Mapped action. */
 export declare function MappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Type, As, Property>;
 /** Applies a Mapped action using the given types. */
-export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TMappedAction<{}, {
-    callstack: [];
-}, Identifier, Type, As, Property>);
+export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TMappedAction<{}, TState<[], []>, Identifier, Type, As, Property>);
 /** Applies a Mapped action using the given types. */
 export declare function Mapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Type, As, Property>;

package/node_modules/typebox/build/type/action/mapped.mjs

@@ -2,11 +2,12 @@
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { MappedAction } from '../engine/mapped/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
 export function MappedDeferred(identifier, type, as, property, options = {}) {
     return Deferred('Mapped', [identifier, type, as, property], options);
 }
 /** Applies a Mapped action using the given types. */
 export function Mapped(identifier, type, as, property, options = {}) {
-    return MappedAction({}, { callstack: [] }, identifier, type, as, property, options);
+    return MappedAction({}, State([], []), identifier, type, as, property, options);
 }

package/node_modules/typebox/build/type/action/module.d.mts

@@ -1,12 +1,13 @@
 import { type TSchemaOptions } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
+import { type TModuleInstantiate } from '../engine/module/instantiate.mjs';
 /** Creates a deferred Module action. */
-export type TModuleDeferred<Context extends TProperties> = (TDeferred<'Module', [Context]>);
+export type TModuleDeferred<Declarations extends TProperties> = (TDeferred<'Module', [Declarations]>);
 /** Creates a deferred Module action. */
-export declare function ModuleDeferred<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModuleDeferred<Context>;
-/** Applies a Module transformation action to the embedded property types. */
-export type TModule<Context extends TProperties> = (TInstantiate<{}, TModuleDeferred<Context>>);
-/** Applies a Module transformation action to the embedded property types. */
-export declare function Module<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModule<Context>;
+export declare function ModuleDeferred<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModuleDeferred<Declarations>;
+/** Creates a Module with the given declarations */
+export type TModule<Declarations extends TProperties> = (TModuleInstantiate<{}, TState<[], []>, Declarations>);
+/** Creates a Module with the given declarations */
+export declare function Module<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModule<Declarations>;

package/node_modules/typebox/build/type/action/module.mjs

@@ -1,12 +1,13 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
+import { ModuleInstantiate } from '../engine/module/instantiate.mjs';
 /** Creates a deferred Module action. */
-export function ModuleDeferred(context, options = {}) {
-    return Deferred('Module', [context], options);
+export function ModuleDeferred(declarations, options = {}) {
+    return Deferred('Module', [declarations], options);
 }
-/** Applies a Module transformation action to the embedded property types. */
-export function Module(context, options = {}) {
-    return Instantiate({}, ModuleDeferred(context, options));
+/** Creates a Module with the given declarations */
+export function Module(declarations, options = {}) {
+    return ModuleInstantiate({}, State([], []), declarations, options);
 }

package/node_modules/typebox/build/type/action/readonly_object.d.mts

@@ -9,8 +9,3 @@ export declare function ReadonlyObjectDeferred<Type extends TSchema>(type: Type,
 export type TReadonlyObject<Type extends TSchema> = (TReadonlyObjectAction<Type>);
 /** This type is an alias for TypeScript's `Readonly<T>` utility type. It will make all properties of a TObject readonly or marks an TArray or TTuple as immutable `readonly T[]`. */
 export declare function ReadonlyObject<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReadonlyObject<Type>;
-/**
- * This type has been renamed to ReadonlyObject.
- * @deprecated
-*/
-export declare const ReadonlyType: typeof ReadonlyObject;

package/node_modules/typebox/build/type/action/readonly_object.mjs

@@ -9,8 +9,3 @@ export function ReadonlyObjectDeferred(type, options = {}) {
 export function ReadonlyObject(type, options = {}) {
     return ReadonlyObjectAction(type, options);
 }
-/**
- * This type has been renamed to ReadonlyObject.
- * @deprecated
-*/
-export const ReadonlyType = ReadonlyObject;

package/node_modules/typebox/build/type/action/with.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TWithAction } from '../engine/with/instantiate.mjs';
+/** Creates a deferred With action. */
+export type TWithDeferred<Type extends TSchema, Options extends TSchema> = (TDeferred<'With', [Type, Options]>);
+/** Creates a deferred With action. */
+export declare function WithDeferred<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TWithDeferred<Type, Options>;
+/** Applies annotation options to the given type. */
+export type TWith<Type extends TSchema, Options extends TSchema> = (Type & Options);
+/** Applies annotation options to the given type. */
+export declare function With<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TWithAction<Type, Options>;

package/node_modules/typebox/build/type/action/with.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { WithAction } from '../engine/with/instantiate.mjs';
+/** Creates a deferred With action. */
+export function WithDeferred(type, options) {
+    return Deferred('With', [type, options], {});
+}
+/** Applies annotation options to the given type. */
+export function With(type, options) {
+    return WithAction(type, options);
+}

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

@@ -19,7 +19,7 @@ function BuildDistributionArray(parameters, names) {
     return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
 }
 function ZipDistributionArray(arguments_, distributionArray, result = []) {
-    return Guard.TakeLeft(arguments_, (argumentLeft, argumentRight) => Guard.TakeLeft(distributionArray, (booleanLeft, booleanRight) => ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]]), () => result), () => result);
+    return Guard.ShiftLeft(arguments_, (argumentLeft, argumentRight) => Guard.ShiftLeft(distributionArray, (booleanLeft, booleanRight) => ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]]), () => result), () => result);
 }
 function Expand(type) {
     return (IsUnion(type)

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

@@ -13,9 +13,7 @@ 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 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;

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

@@ -6,6 +6,7 @@ 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
 // ------------------------------------------------------------------
@@ -22,8 +23,8 @@ function IsTailCall(state, name) {
 }
 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);
+    const returnType = InstantiateType(argumentsContext, State([...state['callstack'], target['$ref']], state['visited']), expression);
+    return InstantiateType(argumentsContext, State([], []), returnType);
 }
 function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
     return distributedArguments.reduce((result, arguments_) => [...result, CallDispatch(context, state, target, parameters, expression, arguments_)], []);