@openclaw/typesafe 2026.9.6

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TNonNullableAction } from '../engine/non_nullable/instantiate.mjs';
+/** Creates a deferred NonNullable action. */
+export type TNonNullableDeferred<Type extends TSchema> = (TDeferred<'NonNullable', [Type]>);
+/** Creates a deferred NonNullable action. */
+export declare function NonNullableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TNonNullableDeferred<Type>;
+/** Applies a NonNullable action to the given type. */
+export type TNonNullable<Type extends TSchema> = (TNonNullableAction<Type>);
+/** Applies a NonNullable action to the given type. */
+export declare function NonNullable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TNonNullable<Type>;

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

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TKeysToIndexer } from '../engine/helpers/keys_to_indexer.mjs';
+import { type TOmitAction } from '../engine/omit/instantiate.mjs';
+/** Creates a deferred Omit action. */
+export type TOmitDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Omit', [Type, Indexer]>);
+/** Creates a deferred Omit action. */
+export declare function OmitDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmitDeferred<Type, Indexer>;
+/** Applies a Omit action using the given types. */
+export type TOmit<Type extends TSchema, Indexer extends TSchema> = (TOmitAction<Type, Indexer>);
+/** Applies a Omit action using the given types. */
+export declare function Omit<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TOmit<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Omit action using the given types. */
+export declare function Omit<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmit<Type, Indexer>;

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

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { KeysToIndexer } from '../engine/helpers/keys_to_indexer.mjs';
+import { OmitAction } from '../engine/omit/instantiate.mjs';
+/** Creates a deferred Omit action. */
+export function OmitDeferred(type, indexer, options = {}) {
+    return Deferred('Omit', [type, indexer], options);
+}
+/** Applies a Omit action using the given types. */
+export function Omit(type, indexer_or_keys, options = {}) {
+    const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
+    return OmitAction(type, indexer, options);
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TParametersAction } from '../engine/parameters/instantiate.mjs';
+/** Creates a deferred Parameters action. */
+export type TParametersDeferred<Type extends TSchema> = (TDeferred<'Parameters', [Type]>);
+/** Creates a deferred Parameters action. */
+export declare function ParametersDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TParametersDeferred<Type>;
+/** Applies a Parameters action to the given type. */
+export type TParameters<Type extends TSchema> = (TParametersAction<Type>);
+/** Applies a Parameters action to the given type. */
+export declare function Parameters<Type extends TSchema>(type: Type, options?: TSchemaOptions): TParameters<Type>;

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

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

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TPartialAction } from '../engine/partial/instantiate.mjs';
+/** Creates a deferred Partial action. */
+export type TPartialDeferred<Type extends TSchema> = (TDeferred<'Partial', [Type]>);
+/** Creates a deferred Partial action. */
+export declare function PartialDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TPartialDeferred<Type>;
+/** Applies a Partial action to the given type. */
+export type TPartial<Type extends TSchema> = (TPartialAction<Type>);
+/** Applies a Partial action to the given type. */
+export declare function Partial<Type extends TSchema>(type: Type, options?: TSchemaOptions): TPartial<Type>;

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

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TKeysToIndexer } from '../engine/helpers/keys_to_indexer.mjs';
+import { type TPickAction } from '../engine/pick/instantiate.mjs';
+/** Creates a deferred Pick action. */
+export type TPickDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Pick', [Type, Indexer]>);
+/** Creates a deferred Pick action. */
+export declare function PickDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPickDeferred<Type, Indexer>;
+/** Applies a Pick action using the given types. */
+export type TPick<Type extends TSchema, Indexer extends TSchema> = (TPickAction<Type, Indexer>);
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TPick<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPick<Type, Indexer>;

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

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { KeysToIndexer } from '../engine/helpers/keys_to_indexer.mjs';
+import { PickAction } from '../engine/pick/instantiate.mjs';
+/** Creates a deferred Pick action. */
+export function PickDeferred(type, indexer, options = {}) {
+    return Deferred('Pick', [type, indexer], options);
+}
+/** Applies a Pick action using the given types. */
+export function Pick(type, indexer_or_keys, options = {}) {
+    const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
+    return PickAction(type, indexer, options);
+}

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

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TReadonlyObjectAction } from '../engine/readonly_object/instantiate.mjs';
+/** Creates a deferred ReadonlyType action. */
+export type TReadonlyObjectDeferred<Type extends TSchema> = (TDeferred<'ReadonlyObject', [Type]>);
+/** Creates a deferred ReadonlyType action. */
+export declare function ReadonlyObjectDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"ReadonlyObject", [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 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

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { ReadonlyObjectAction } from '../engine/readonly_object/instantiate.mjs';
+/** Creates a deferred ReadonlyType action. */
+export function ReadonlyObjectDeferred(type, options = {}) {
+    return Deferred('ReadonlyObject', [type], options);
+}
+/** 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 function ReadonlyObject(type, options = {}) {
+    return ReadonlyObjectAction(type, options);
+}
+// ------------------------------------------------------------------
+// Alias
+// ------------------------------------------------------------------
+/**
+ * This type has been renamed to ReadonlyObject.
+ * @deprecated
+*/
+export const ReadonlyType = ReadonlyObject;

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRequiredAction } from '../engine/required/instantiate.mjs';
+/** Creates a deferred Required action. */
+export type TRequiredDeferred<Type extends TSchema> = (TDeferred<'Required', [Type]>);
+/** Creates a deferred Required action. */
+export declare function RequiredDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"Required", [Type]>;
+/** Applies a Required action to the given type. */
+export type TRequired<Type extends TSchema> = (TRequiredAction<Type>);
+/** Applies a Required action to the given type. */
+export declare function Required<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRequired<Type>;

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

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

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TReturnTypeAction } from '../engine/return_type/instantiate.mjs';
+/** Creates a deferred ReturnType action. */
+export type TReturnTypeDeferred<Type extends TSchema> = (TDeferred<'ReturnType', [Type]>);
+/** Creates a deferred ReturnType action. */
+export declare function ReturnTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnTypeDeferred<Type>;
+/** Applies a ReturnType action to the given type. */
+export type TReturnType<Type extends TSchema> = (TReturnTypeAction<Type>);
+/** Applies a ReturnType action to the given type. */
+export declare function ReturnType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnType<Type>;

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

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

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TUncapitalizeAction } from '../engine/intrinsics/instantiate.mjs';
+/** Creates a deferred Uncapitalize action. */
+export type TUncapitalizeDeferred<Type extends TSchema> = (TDeferred<'Uncapitalize', [Type]>);
+/** Creates a deferred Uncapitalize action. */
+export declare function UncapitalizeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalizeDeferred<Type>;
+/** Applies a Uncapitalize action to the given type. */
+export type TUncapitalize<Type extends TSchema> = (TUncapitalizeAction<Type>);
+/** Applies a Uncapitalize action to the given type. */
+export declare function Uncapitalize<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalize<Type>;

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

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

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TUppercaseAction } from '../engine/intrinsics/instantiate.mjs';
+/** Creates a deferred Uppercase action. */
+export type TUppercaseDeferred<Type extends TSchema> = (TDeferred<'Uppercase', [Type]>);
+/** Creates a deferred Uppercase action. */
+export declare function UppercaseDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercaseDeferred<Type>;
+/** Applies a Uppercase action to the given type. */
+export type TUppercase<Type extends TSchema> = (TUppercaseAction<Type>);
+/** Applies a Uppercase action to the given type. */
+export declare function Uppercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercase<Type>;

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

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

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.d.mts

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

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

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

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

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

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

@@ -0,0 +1,79 @@
+// deno-fmt-ignore-file
+import { Settings } from '../../../system/settings/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { CallConstruct } from '../../types/call.mjs';
+import { Ref } from '../../types/ref.mjs';
+import { IsGeneric } from '../../types/generic.mjs';
+import { EvaluateUnion } from '../evaluate/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+import { InstantiateTypes } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { DistributeArguments } from './distribute_arguments.mjs';
+import { ResolveTarget } from './resolve_target.mjs';
+import { ResolveArgumentsContext } from './resolve_arguments.mjs';
+// ------------------------------------------------------------------
+// InstantiationGuard
+// ------------------------------------------------------------------
+let instantiationDepth = 0;
+let instantiationCount = 0;
+function InstantiationAssert() {
+    if (Guard.IsLessThan(instantiationCount, Settings.Get().maxInstantiationCount))
+        return;
+    throw Error('Type instantiation is excessively deep and possibly infinite');
+}
+function InstantiationIncrement() {
+    InstantiationAssert();
+    instantiationCount++;
+    instantiationDepth++;
+}
+function InstantiationDecrement() {
+    instantiationDepth--;
+    if (Guard.IsEqual(instantiationDepth, 0))
+        instantiationCount = 0;
+}
+function Peek(state) {
+    const result = Guard.IsGreaterThan(state.callstack.length, 0) ? state.callstack[state.callstack.length - 1] : '';
+    return result;
+}
+function IsTailCall(state, name) {
+    const result = Guard.IsEqual(Peek(state), name);
+    return result;
+}
+function CallDispatch(context, state, target, parameters, expression, arguments_) {
+    InstantiationIncrement();
+    try {
+        const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
+        const returnType = InstantiateType(argumentsContext, State([...state['callstack'], target['$ref']], state['visited']), expression);
+        return InstantiateType(argumentsContext, State([], []), returnType);
+    }
+    finally {
+        InstantiationDecrement();
+    }
+}
+function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
+    return distributedArguments.reduce((result, arguments_) => {
+        const returnType = CallDispatch(context, state, target, parameters, expression, arguments_);
+        return [...result, returnType];
+    }, []);
+}
+function CallImmediate(context, state, target, parameters, expression, arguments_) {
+    const distributedArguments = DistributeArguments(parameters, arguments_, expression);
+    const returnTypes = CallDistributed(context, state, target, parameters, expression, distributedArguments);
+    const result = Guard.IsEqual(returnTypes.length, 1) ? returnTypes[0] : EvaluateUnion(returnTypes);
+    return result;
+}
+export function CallInstantiate(context, state, target, arguments_) {
+    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
+    const resolved = ResolveTarget(context, target, arguments_);
+    const name = resolved[0];
+    const type = resolved[1];
+    const result = (IsGeneric(type)
+        ? IsTailCall(state, name)
+            ? CallConstruct(Ref(name), instantiatedArguments)
+            : CallImmediate(context, state, Ref(name), type.parameters, type.expression, instantiatedArguments)
+        : CallConstruct(target, instantiatedArguments));
+    return result;
+}

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

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

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

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

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

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

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

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

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

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

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

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