typebox 1.1.27 → 1.1.28

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 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 { 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,16 @@
+// 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);
+}
+/**
+ * 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

@@ -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

@@ -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/engine/awaited/instantiate.d.mts

@@ -3,8 +3,9 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TPromise } from '../../types/promise.mjs';
 import { type TAwaitedDeferred } from '../../action/awaited.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TAwaitedAction<Type extends TSchema> = (Type extends TPromise<infer Type extends TSchema> ? TAwaitedAction<Type> : Type);
-type TAwaitedImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAwaitedAction<InstantiateType>;
-export type TAwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TAwaitedImmediate<Context, State, Type> : TAwaitedDeferred<Type>;
+type TAwaitedOperation<Type extends TSchema> = (Type extends TPromise<infer Type extends TSchema> ? TAwaitedOperation<Type> : Type);
+export type TAwaitedAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TAwaitedOperation<Type> : TAwaitedDeferred<Type>> = Result;
+export declare function AwaitedAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAwaitedAction<Type>;
+export type TAwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAwaitedAction<InstantiateType>;
 export declare function AwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAwaitedInstantiate<Context, State, Type>;
 export {};

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

@@ -3,17 +3,18 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { IsPromise } from '../../types/promise.mjs';
 import { AwaitedDeferred } from '../../action/awaited.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function AwaitedAction(type) {
+function AwaitedOperation(type) {
     return (IsPromise(type)
-        ? AwaitedAction(type.item)
+        ? AwaitedOperation(type.item)
         : type);
 }
-function AwaitedImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(AwaitedAction(instantiatedType), {}, options);
+export function AwaitedAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(AwaitedOperation(type), {}, options)
+        : AwaitedDeferred(type, options);
+    return result;
 }
 export function AwaitedInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? AwaitedImmediate(context, state, type, options)
-        : AwaitedDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return AwaitedAction(instantiatedType, options);
 }

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

@@ -1,14 +1,15 @@
 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 TNever } from '../../types/never.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';
-type TConstructorParametersAction<Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer _ extends TSchema> ? TInstantiateType<{}, {
+import { type TInstantiateElements } from '../instantiate.mjs';
+type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
     callstack: [];
-}, TTuple<Parameters>> : TNever);
-type TConstructorParametersImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;
-export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TConstructorParametersImmediate<Context, State, Type> : TConstructorParametersDeferred<Type>;
+}, 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

@@ -2,21 +2,23 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
-import { Never } from '../../types/never.mjs';
 import { Tuple } from '../../types/tuple.mjs';
 import { ConstructorParametersDeferred } from '../../action/constructor-parameters.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function ConstructorParametersAction(type) {
-    return (IsConstructor(type)
-        ? InstantiateType({}, { callstack: [] }, Tuple(type.parameters))
-        : Never());
+import { InstantiateElements } from '../instantiate.mjs';
+function ConstructorParametersOperation(type) {
+    const parameters = IsConstructor(type) ? type['parameters'] : [];
+    const instantiatedParameters = InstantiateElements({}, { callstack: [] }, parameters);
+    const result = Tuple(instantiatedParameters);
+    return result;
 }
-function ConstructorParametersImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(ConstructorParametersAction(instantiatedType), {}, options);
+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) {
-    return (CanInstantiate(context, [type])
-        ? ConstructorParametersImmediate(context, state, type, options)
-        : ConstructorParametersDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return ConstructorParametersAction(instantiatedType, options);
 }

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

@@ -2,7 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
-type TEvaluateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TEvaluateType<InstantiatedType>;
-export type TEvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TEvaluateImmediate<Context, State, Type>;
+export type TEvaluateAction<Type extends TSchema, Result extends TSchema = TEvaluateType<Type>> = Result;
+export declare function EvaluateAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TEvaluateAction<Type>;
+export type TEvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TEvaluateAction<InstantiatedType>;
 export declare function EvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TEvaluateInstantiate<Context, State, Type>;
-export {};

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

@@ -2,16 +2,11 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { EvaluateType } from './evaluate.mjs';
-function EvaluateImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(EvaluateType(instantiatedType), {}, options);
+export function EvaluateAction(type, options) {
+    const result = Memory.Update(EvaluateType(type), {}, options);
+    return result;
 }
 export function EvaluateInstantiate(context, state, type, options) {
-    return (
-    // [instantiation-rule]
-    //
-    // Evaluate instantiation should never defer on instantiate as the caller is specifically 
-    // requesting that the type be evaluated in whatever context is available. However, actions 
-    // embedded in the Evaluate call may defer local to themselves.
-    EvaluateImmediate(context, state, type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return EvaluateAction(instantiatedType, options);
 }

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

@@ -1,16 +1,9 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TExcludeDeferred } from '../../action/exclude.mjs';
-type TExcludeUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
-type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [] : [Left]> = Result;
-type TExcludeAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExcludeUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExcludeUnion<TFlatten<Types>, Right> : TExcludeType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
-type TExcludeImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExcludeAction<InstantiatedLeft, InstantiatedRight>;
-export type TExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExcludeImmediate<Context, State, Left, Right> : TExcludeDeferred<Left, Right>;
+import { type TExcludeOperation } from './operation.mjs';
+export type TExcludeAction<Left extends TSchema, Right extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TExcludeOperation<Left, Right> : TExcludeDeferred<Left, Right>> = Result;
+export declare function ExcludeAction<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions): TExcludeAction<Left, Right>;
+export type TExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExcludeAction<InstantiatedLeft, InstantiatedRight>;
 export declare function ExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExcludeInstantiate<Context, State, Left, Right>;
-export {};

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

@@ -1,37 +1,16 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsEnum } from '../../types/enum.mjs';
-import { IsUnion } from '../../types/union.mjs';
-import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { ExcludeDeferred } from '../../action/exclude.mjs';
-function ExcludeUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExcludeType(head, right)];
-    }, []);
-}
-function ExcludeType(left, right) {
-    const check = Extends({}, left, right);
-    const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
-    return result;
-}
-function ExcludeAction(left, right) {
-    const remaining = (IsEnum(left) ? ExcludeUnion(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExcludeUnion(Flatten(left.anyOf), right) :
-            ExcludeType(left, right));
-    const result = EvaluateUnion(remaining);
+import { ExcludeOperation } from './operation.mjs';
+export function ExcludeAction(left, right, options) {
+    const result = CanInstantiate([left, right])
+        ? Memory.Update(ExcludeOperation(left, right), {}, options)
+        : ExcludeDeferred(left, right, options);
     return result;
 }
-function ExcludeImmediate(context, state, left, right, options) {
+export function ExcludeInstantiate(context, state, left, right, options) {
     const instantiatedLeft = InstantiateType(context, state, left);
     const instantiatedRight = InstantiateType(context, state, right);
-    return Memory.Update(ExcludeAction(instantiatedLeft, instantiatedRight), {}, options);
-}
-export function ExcludeInstantiate(context, state, left, right, options) {
-    return (CanInstantiate(context, [left, right])
-        ? ExcludeImmediate(context, state, left, right, options)
-        : ExcludeDeferred(left, right, options));
+    return ExcludeAction(instantiatedLeft, instantiatedRight, options);
 }

package/build/type/engine/exclude/operation.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEnumValuesToVariants } from '../enum/index.mjs';
+import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
+type TExcludeUnionLeft<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnionLeft<Tail, Right, [...Result, ...TExcludeTypeLeft<Head, Right>]> : Result);
+type TExcludeTypeLeft<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [] : [Left]> = Result;
+export type TExcludeOperation<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExcludeUnionLeft<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExcludeUnionLeft<TFlatten<Types>, Right> : TExcludeTypeLeft<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+export declare function ExcludeOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExcludeOperation<Left, Right>;
+export {};

package/build/type/engine/exclude/operation.mjs

@@ -0,0 +1,24 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { IsEnum } from '../../types/enum.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { EnumValuesToVariants } from '../enum/index.mjs';
+import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
+function ExcludeUnionLeft(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExcludeTypeLeft(head, right)];
+    }, []);
+}
+function ExcludeTypeLeft(left, right) {
+    const check = Extends({}, left, right);
+    const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
+    return result;
+}
+export function ExcludeOperation(left, right) {
+    const remaining = (IsEnum(left) ? ExcludeUnionLeft(EnumValuesToVariants(left.enum), right) :
+        IsUnion(left) ? ExcludeUnionLeft(Flatten(left.anyOf), right) :
+            ExcludeTypeLeft(left, right));
+    const result = EvaluateUnion(remaining);
+    return result;
+}

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

@@ -1,16 +1,9 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TExtractDeferred } from '../../action/extract.mjs';
-type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
-type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [Left] : []> = Result;
-type TExtractAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExtractUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtractUnion<TFlatten<Types>, Right> : TExtractType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
-type TExtractImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExtractAction<InstantiatedLeft, InstantiatedRight>;
-export type TExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExtractImmediate<Context, State, Left, Right> : TExtractDeferred<Left, Right>;
+import { type TExtractOperation } from './operation.mjs';
+export type TExtractAction<Left extends TSchema, Right extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TExtractOperation<Left, Right> : TExtractDeferred<Left, Right>> = Result;
+export declare function ExtractAction<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions): TExtractAction<Left, Right>;
+export type TExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExtractAction<InstantiatedLeft, InstantiatedRight>;
 export declare function ExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExtractInstantiate<Context, State, Left, Right>;
-export {};

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

@@ -1,37 +1,16 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsEnum } from '../../types/enum.mjs';
-import { IsUnion } from '../../types/union.mjs';
-import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { ExtractDeferred } from '../../action/extract.mjs';
-function ExtractUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExtractType(head, right)];
-    }, []);
-}
-function ExtractType(left, right) {
-    const check = Extends({}, left, right);
-    const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
-    return result;
-}
-function ExtractAction(left, right) {
-    const remaining = (IsEnum(left) ? ExtractUnion(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExtractUnion(Flatten(left.anyOf), right) :
-            ExtractType(left, right));
-    const result = EvaluateUnion(remaining);
+import { ExtractOperation } from './operation.mjs';
+export function ExtractAction(left, right, options) {
+    const result = CanInstantiate([left, right])
+        ? Memory.Update(ExtractOperation(left, right), {}, options)
+        : ExtractDeferred(left, right, options);
     return result;
 }
-function ExtractImmediate(context, state, left, right, options) {
+export function ExtractInstantiate(context, state, left, right, options) {
     const instantiatedLeft = InstantiateType(context, state, left);
     const instantiatedRight = InstantiateType(context, state, right);
-    return Memory.Update(ExtractAction(instantiatedLeft, instantiatedRight), {}, options);
-}
-export function ExtractInstantiate(context, state, left, right, options) {
-    return (CanInstantiate(context, [left, right])
-        ? ExtractImmediate(context, state, left, right, options)
-        : ExtractDeferred(left, right, options));
+    return ExtractAction(instantiatedLeft, instantiatedRight, options);
 }

package/build/type/engine/extract/operation.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEnumValuesToVariants } from '../enum/index.mjs';
+import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
+type TExtractUnionLeft<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnionLeft<Tail, Right, [...Result, ...TExtractTypeLeft<Head, Right>]> : Result);
+type TExtractTypeLeft<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [Left] : []> = Result;
+export type TExtractOperation<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExtractUnionLeft<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtractUnionLeft<TFlatten<Types>, Right> : TExtractTypeLeft<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
+export {};