@depup/typebox 1.1.23-depup.0 → 1.3.8-depup.0

package/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/build/type/action/{non-nullable.d.mts → non_nullable.d.mts}

@@ -1,11 +1,11 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TNonNullableDeferred<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/build/type/action/{non-nullable.mjs → non_nullable.mjs}

@@ -1,12 +1,11 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.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 Instantiate({}, NonNullableDeferred(type, options));
+    return NonNullableAction(type, options);
 }

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

@@ -1,13 +1,13 @@
 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 TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TOmitDeferred<Type, Indexer>>);
+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. */

package/build/type/action/omit.mjs

@@ -1,9 +1,8 @@
-// deno-lint-ignore-file ban-types
 // 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 { Instantiate } from '../engine/instantiate.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);
@@ -11,5 +10,5 @@ export function OmitDeferred(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 Instantiate({}, OmitDeferred(type, indexer, options));
+    return OmitAction(type, indexer, options);
 }

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

@@ -1,11 +1,11 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TParametersDeferred<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/build/type/action/parameters.mjs

@@ -1,12 +1,11 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.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 Instantiate({}, ParametersDeferred(type, options));
+    return ParametersAction(type, options);
 }

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

@@ -1,11 +1,11 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.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): TDeferred<"Partial", [Type]>;
+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> = (TInstantiate<{}, TPartialDeferred<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/build/type/action/partial.mjs

@@ -1,12 +1,11 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.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 Instantiate({}, PartialDeferred(type, options));
+    return PartialAction(type, options);
 }

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

@@ -1,13 +1,13 @@
 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 TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TPickDeferred<Type, Indexer>>);
+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. */

package/build/type/action/pick.mjs

@@ -1,9 +1,8 @@
-// deno-lint-ignore-file ban-types
 // 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 { Instantiate } from '../engine/instantiate.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);
@@ -11,5 +10,5 @@ export function PickDeferred(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 Instantiate({}, PickDeferred(type, indexer, options));
+    return PickAction(type, indexer, options);
 }

package/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/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/build/type/action/required.d.mts

@@ -1,11 +1,11 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TRequiredDeferred<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/build/type/action/required.mjs

@@ -1,12 +1,11 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.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 Instantiate({}, RequiredDeferred(type, options));
+    return RequiredAction(type, options);
 }

package/build/type/action/{return-type.d.mts → return_type.d.mts}

@@ -1,11 +1,11 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TReturnTypeDeferred<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/build/type/action/{return-type.mjs → return_type.mjs}

@@ -1,12 +1,11 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.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 Instantiate({}, ReturnTypeDeferred(type, options));
+    return ReturnTypeAction(type, options);
 }

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

@@ -1,11 +1,11 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TUncapitalizeDeferred<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/build/type/action/uncapitalize.mjs

@@ -1,12 +1,11 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.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 Instantiate({}, UncapitalizeDeferred(type, options));
+    return UncapitalizeAction(type, options);
 }

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

@@ -1,11 +1,11 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.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> = (TInstantiate<{}, TUppercaseDeferred<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/build/type/action/uppercase.mjs

@@ -1,12 +1,11 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.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 Instantiate({}, UppercaseDeferred(type, options));
+    return UppercaseAction(type, options);
 }

package/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/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/build/type/engine/call/{distribute-arguments.mjs → distribute_arguments.mjs}

@@ -19,13 +19,7 @@ function BuildDistributionArray(parameters, names) {
     return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
 }
 function ZipDistributionArray(arguments_, distributionArray, result = []) {
-    const [argumentLeft, ...argumentRight] = arguments_;
-    const [booleanLeft, ...booleanRight] = distributionArray;
-    return (Guard.IsGreaterThan(arguments_.length, 0)
-        ? Guard.IsGreaterThan(distributionArray.length, 0)
-            ? 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/build/type/engine/call/instantiate.d.mts

@@ -8,14 +8,12 @@ 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';
+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, {
-    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/build/type/engine/call/instantiate.mjs

@@ -6,12 +6,13 @@ 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';
+import { DistributeArguments } from './distribute_arguments.mjs';
+import { ResolveTarget } from './resolve_target.mjs';
+import { ResolveArgumentsContext } from './resolve_arguments.mjs';
 function Peek(state) {
     const result = Guard.IsGreaterThan(state.callstack.length, 0) ? state.callstack[state.callstack.length - 1] : '';
     return result;
@@ -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/build/type/engine/call/{resolve-arguments.mjs → resolve_arguments.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { IsInfer } from '../../types/infer.mjs';
@@ -23,16 +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);
-    const [left, ...right] = arguments_;
-    return (IsSchema(left)
-        ? 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_) {
-    const [left, ...right] = parameters;
-    return (IsSchema(left)
-        ? 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/build/type/engine/conditional/instantiate.d.mts

@@ -4,7 +4,9 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TConditionalDeferred } from '../../action/conditional.mjs';
-type TConditionalImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, InstaniatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstaniatedRight extends TSchema = TInstantiateType<Context, State, Right>, ExtendsResult extends ExtendsResult.TResult = TExtends<Context, InstaniatedLeft, InstaniatedRight>> = (ExtendsResult extends ExtendsResult.TExtendsUnion<infer InferredContext extends TProperties> ? TUnion<[TInstantiateType<InferredContext, State, True>, TInstantiateType<Context, State, False>]> : ExtendsResult extends ExtendsResult.TExtendsTrue<infer InferredContext extends TProperties> ? TInstantiateType<InferredContext, State, True> : TInstantiateType<Context, State, False>);
-export type TConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TConditionalImmediate<Context, State, Left, Right, True, False> : TConditionalDeferred<Left, Right, True, False>;
+type TConditionalOperation<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, ExtendsResult extends ExtendsResult.TResult = TExtends<Context, Left, Right>> = (ExtendsResult extends ExtendsResult.TExtendsUnion<infer InferredContext extends TProperties> ? TUnion<[TInstantiateType<InferredContext, State, True>, TInstantiateType<Context, State, False>]> : ExtendsResult extends ExtendsResult.TExtendsTrue<infer InferredContext extends TProperties> ? TInstantiateType<InferredContext, State, True> : TInstantiateType<Context, State, False>);
+export type TConditionalAction<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TConditionalOperation<Context, State, Left, Right, True, False> : TConditionalDeferred<Left, Right, True, False>> = Result;
+export declare function ConditionalAction<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalAction<Context, State, Left, Right, True, False>;
+export type TConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, InstaniatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstaniatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TConditionalAction<Context, State, InstaniatedLeft, InstaniatedRight, True, False>;
 export declare function ConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalInstantiate<Context, State, Left, Right, True, False>;
 export {};

package/build/type/engine/conditional/instantiate.mjs

@@ -4,16 +4,20 @@ import { Union } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { ConditionalDeferred } from '../../action/conditional.mjs';
-function ConditionalImmediate(context, state, left, right, true_, false_, options) {
-    const instantiatedLeft = InstantiateType(context, state, left);
-    const instantiatedRight = InstantiateType(context, state, right);
-    const extendsResult = Extends(context, instantiatedLeft, instantiatedRight);
-    return Memory.Update((ExtendsResult.IsExtendsUnion(extendsResult) ? Union([InstantiateType(extendsResult.inferred, state, true_), InstantiateType(context, state, false_)]) :
+function ConditionalOperation(context, state, left, right, true_, false_) {
+    const extendsResult = Extends(context, left, right);
+    return (ExtendsResult.IsExtendsUnion(extendsResult) ? Union([InstantiateType(extendsResult.inferred, state, true_), InstantiateType(context, state, false_)]) :
         ExtendsResult.IsExtendsTrue(extendsResult) ? InstantiateType(extendsResult.inferred, state, true_) :
-            InstantiateType(context, state, false_)), {}, options);
+            InstantiateType(context, state, false_));
+}
+export function ConditionalAction(context, state, left, right, true_, false_, options) {
+    const result = CanInstantiate([left, right])
+        ? Memory.Update(ConditionalOperation(context, state, left, right, true_, false_), {}, options)
+        : ConditionalDeferred(left, right, true_, false_, options);
+    return result;
 }
 export function ConditionalInstantiate(context, state, left, right, true_, false_, options) {
-    return (CanInstantiate(context, [left, right])
-        ? ConditionalImmediate(context, state, left, right, true_, false_, options)
-        : ConditionalDeferred(left, right, true_, false_, options));
+    const instantiatedLeft = InstantiateType(context, state, left);
+    const instantiatedRight = InstantiateType(context, state, right);
+    return ConditionalAction(context, state, instantiatedLeft, instantiatedRight, true_, false_, options);
 }

package/build/type/engine/constructor_parameters/instantiate.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
+import { type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateElements } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+export type TConstructorParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TConstructorParametersOperation<Type> : TConstructorParametersDeferred<Type>> = Result;
+export declare function ConstructorParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TConstructorParametersAction<Type>;
+export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;
+export declare function ConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TConstructorParametersInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,25 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { Tuple } from '../../types/tuple.mjs';
+import { ConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { InstantiateElements } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
+function ConstructorParametersOperation(type) {
+    const parameters = IsConstructor(type) ? type['parameters'] : [];
+    const instantiatedParameters = InstantiateElements({}, State([], []), parameters);
+    const result = Tuple(instantiatedParameters);
+    return result;
+}
+export function ConstructorParametersAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(ConstructorParametersOperation(type), {}, options)
+        : ConstructorParametersDeferred(type, options);
+    return result;
+}
+export function ConstructorParametersInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return ConstructorParametersAction(instantiatedType, options);
+}

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

@@ -1,9 +1,8 @@
-import { type TUnreachable } from '../../../system/unreachable/index.mjs';
-import { type TProperties, TPropertyKeys } from '../../types/properties.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 {};