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

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_)], []);

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

@@ -23,10 +23,10 @@ function BindArgument(context, state, name, extends_, type) {
 function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
     const instantiatedExtends = InstantiateType(context, state, parameterLeft.extends);
     const instantiatedEquals = InstantiateType(context, state, parameterLeft.equals);
-    return Guard.TakeLeft(arguments_, (left, right) => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right), () => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
+    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.TakeLeft(parameters, (left, right) => BindArguments(context, state, left, right, arguments_), () => context);
+    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/constructor_parameters/instantiate.d.mts

@@ -3,11 +3,10 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TInstantiateElements } from '../instantiate.mjs';
-type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
-    callstack: [];
-}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+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>;

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

@@ -6,9 +6,10 @@ 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({}, { callstack: [] }, parameters);
+    const instantiatedParameters = InstantiateElements({}, State([], []), parameters);
     const result = Tuple(instantiatedParameters);
     return result;
 }

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

@@ -1,9 +1,8 @@
-import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TProperties, type TPropertyKeys } from '../../types/properties.mjs';
 import { type TCyclicCheck } from './check.mjs';
-type TResolveCandidateKeys<Context extends TProperties, Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Context ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : TUnreachable : Result);
+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 string[] = TPropertyKeys<Context>, Result extends string[] = TResolveCandidateKeys<Context, Keys>> = Result;
+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

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

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

@@ -1,24 +1,21 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TInterfaceDeferred } from '../../action/interface.mjs';
-type TFromRef<Stack extends string[], Context extends TProperties, Ref extends string> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
-type TFromProperties<Stack extends string[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
-type TFromTypes<Stack extends string[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
-type TFromType<Stack extends string[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
+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 string[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
+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 string[], Context extends TProperties, Type extends TSchema>(stack: [...Stack], context: Context, type: Type): TCyclicCheck<Stack, Context, Type>;
+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 {};