typebox 1.1.26 → 1.1.28

package/build/schema/static/properties.d.mts

@@ -1,11 +1,32 @@
 import type { XSchema } from '../types/schema.mjs';
+import type { XRequired } from '../types/required.mjs';
 import type { XStaticSchema } from './schema.mjs';
-import type { XIsReadonly } from './~readonly.mjs';
-type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>> = {
-    readonly [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]?: XStaticSchema<Stack, Root, Properties[Key]>;
+type XIsReadonly<Schema extends XSchema> = (Schema extends {
+    readOnly: true;
+} ? true : Schema extends {
+    '~readonly': true;
+} ? true : false);
+type XRequiredArray<Schema extends XSchema, Result extends PropertyKey[] = Schema extends XRequired<infer Keys extends string[]> ? Keys : []> = Result;
+type XReadonlyKeys<Properties extends Record<PropertyKey, XSchema>, ReadonlyProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]: unknown;
+}, Result extends PropertyKey = keyof ReadonlyProperties> = Result;
+type XRequiredKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? never : Extract<keyof Properties, RequiredArray[number]>> = Result;
+type XUnknownKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = Exclude<RequiredArray[number], keyof Properties>> = Result;
+type XOptionalKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? keyof Properties : Exclude<keyof Properties, RequiredArray[number]>> = Result;
+type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
 };
-type XOptionalProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>> = {
-    [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? never : Key]?: XStaticSchema<Stack, Root, Properties[Key]>;
+type XReadonlyRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
 };
-export type XStaticProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, ReadonlyOptional extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Properties>, Optional extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Properties>, Result extends Record<PropertyKey, unknown> = ReadonlyOptional & Optional> = Result;
+type XOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XUnknownProperties<UnknownKeys extends PropertyKey> = {
+    [Key in UnknownKeys]: unknown;
+};
+export type XStaticProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[] = XRequiredArray<Schema>, ReadonlyKeys extends PropertyKey = XReadonlyKeys<Properties>, OptionalKeys extends PropertyKey = XOptionalKeys<Properties, RequiredArray>, RequiredKeys extends PropertyKey = XRequiredKeys<Properties, RequiredArray>, UnknownKeys extends PropertyKey = XUnknownKeys<Properties, RequiredArray>, ReadonlyOptionalProperties extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Extract<OptionalKeys, ReadonlyKeys>, Properties>, ReadonlyRequiredProperties extends Record<PropertyKey, unknown> = XReadonlyRequiredProperties<Stack, Root, Extract<RequiredKeys, ReadonlyKeys>, Properties>, OptionalProperties extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Exclude<OptionalKeys, ReadonlyKeys>, Properties>, RequiredProperties extends Record<PropertyKey, unknown> = XRequiredProperties<Stack, Root, Exclude<RequiredKeys, ReadonlyKeys>, Properties>, UnknownProperties extends Record<PropertyKey, unknown> = XUnknownProperties<UnknownKeys>, Result extends Record<PropertyKey, unknown> = (ReadonlyOptionalProperties & ReadonlyRequiredProperties & OptionalProperties & RequiredProperties & UnknownProperties)> = Result;
 export {};

package/build/schema/static/required.d.mts

@@ -1,13 +1,3 @@
 import type { XSchema } from '../types/schema.mjs';
 import type { XProperties } from '../types/properties.mjs';
-import type { XIsReadonly } from './~readonly.mjs';
-import type { XStaticSchema } from './schema.mjs';
-type XResolveProperties<Schema extends XSchema, Result extends Record<PropertyKey, XSchema> = (Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? Properties : {})> = Result;
-type XFromKey<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, Key extends string, Readonly extends boolean = Key extends keyof Properties ? XIsReadonly<Properties[Key]> : false, Value extends unknown = Key extends keyof Properties ? XStaticSchema<Stack, Root, Properties[Key]> : unknown, Result extends Record<PropertyKey, unknown> = (Readonly extends true ? {
-    readonly [_ in Key]: Value;
-} : {
-    [_ in Key]: Value;
-})> = Result;
-type XFromKeys<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, Keys extends string[], Result extends Record<PropertyKey, unknown> = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? XFromKeys<Stack, Root, Properties, Right, Result & XFromKey<Stack, Root, Properties, Left>> : Result);
-export type XStaticRequired<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keys extends string[], Properties extends Record<PropertyKey, XSchema> = XResolveProperties<Schema>, Result extends Record<PropertyKey, unknown> = XFromKeys<Stack, Root, Properties, Keys>> = Result;
-export {};
+export type XStaticRequired<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keys extends string[], Result extends Record<PropertyKey, unknown> = Schema extends XProperties ? {} : Record<Keys[number], unknown>> = Result;

package/build/schema/static/schema.d.mts

@@ -34,12 +34,13 @@ type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends
     Schema extends XAllOf<infer Types extends XSchema[]> ? XStaticAllOf<Stack, Root, Types> : unknown,
     Schema extends XAnyOf<infer Types extends XSchema[]> ? XStaticAnyOf<Stack, Root, Types> : unknown,
     Schema extends XConst<infer Value extends unknown> ? XStaticConst<Value> : unknown,
-    Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> : Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
+    Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> : unknown,
+    Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
     Schema extends XItems<infer Types extends XSchema[] | XSchema> ? XStaticItems<Stack, Root, Schema, Types> : unknown,
     Schema extends XOneOf<infer Types extends XSchema[]> ? XStaticOneOf<Stack, Root, Types> : unknown,
     Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
     Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
-    Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Properties> : unknown,
+    Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Schema, Properties> : unknown,
     Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
     Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
     Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,

package/build/schema/static/static.d.mts

@@ -1,4 +1,4 @@
 import type { XSchema } from '../types/schema.mjs';
-import type { XNonReadonly } from './~non-readonly.mjs';
+import type { XCanonical } from './~canonical.mjs';
 import type { XStaticSchema } from './schema.mjs';
-export type XStatic<Value extends unknown, Schema extends XSchema = Value extends XSchema ? Value : {}, NonReadonly extends XSchema = XNonReadonly<Schema>, Result extends unknown = XStaticSchema<[], NonReadonly, NonReadonly>> = Result;
+export type XStatic<Value extends unknown, Schema extends XSchema = Value extends XSchema ? Value : {}, Canonical extends XSchema = XCanonical<Schema>, Result extends unknown = XStaticSchema<[], Canonical, Canonical>> = Result;

package/build/schema/static/~canonical.d.mts

@@ -0,0 +1,7 @@
+type XCanonicalTuple<Value extends readonly unknown[]> = (Value extends [infer Left, ...infer Right extends unknown[]] ? [XCanonical<Left>, ...XCanonicalTuple<Right>] : []);
+type XCanonicalArray<Value extends unknown, Result extends unknown[] = XCanonical<Value>[]> = Result;
+type XCanonicalObject<Value extends object, Result extends Record<PropertyKey, unknown> = {
+    -readonly [Key in keyof Value]: XCanonical<Value[Key]>;
+}> = Result;
+export type XCanonical<Schema extends unknown> = (Schema extends readonly [...infer Schemas extends unknown[]] ? XCanonicalTuple<Schemas> : Schema extends readonly (infer Schema)[] ? XCanonicalArray<Schema> : Schema extends object ? XCanonicalObject<Schema> : Schema);
+export {};

package/build/type/action/awaited.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 TAwaitedAction } from '../engine/awaited/instantiate.mjs';
 /** Creates a deferred Awaited action. */
 export type TAwaitedDeferred<Type extends TSchema> = (TDeferred<'Awaited', [Type]>);
 /** Creates a deferred Awaited action. */
 export declare function AwaitedDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAwaitedDeferred<Type>;
 /** Applies an Awaited action to a type. */
-export type TAwaited<Type extends TSchema> = (TInstantiate<{}, TAwaitedDeferred<Type>>);
+export type TAwaited<Type extends TSchema> = (TAwaitedAction<Type>);
 /** Applies an Awaited action to a type. */
 export declare function Awaited<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAwaited<Type>;

package/build/type/action/awaited.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 { AwaitedAction } from '../engine/awaited/instantiate.mjs';
 /** Creates a deferred Awaited action. */
 export function AwaitedDeferred(type, options = {}) {
     return Deferred('Awaited', [type], options);
 }
 /** Applies an Awaited action to a type. */
 export function Awaited(type, options = {}) {
-    return Instantiate({}, AwaitedDeferred(type, options));
+    return AwaitedAction(type, options);
 }

package/build/type/action/capitalize.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 TCapitalizeAction } from '../engine/intrinsics/instantiate.mjs';
 /** Creates a deferred Capitalize action. */
 export type TCapitalizeDeferred<Type extends TSchema> = (TDeferred<'Capitalize', [Type]>);
 /** Creates a deferred Capitalize action. */
 export declare function CapitalizeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TCapitalizeDeferred<Type>;
 /** Applies a Capitalize action to the given type. */
-export type TCapitalize<Type extends TSchema> = (TInstantiate<{}, TCapitalizeDeferred<Type>>);
+export type TCapitalize<Type extends TSchema> = (TCapitalizeAction<Type>);
 /** Applies a Capitalize action to the given type. */
 export declare function Capitalize<Type extends TSchema>(type: Type, options?: TSchemaOptions): TCapitalize<Type>;

package/build/type/action/capitalize.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 { CapitalizeAction } from '../engine/intrinsics/instantiate.mjs';
 /** Creates a deferred Capitalize action. */
 export function CapitalizeDeferred(type, options = {}) {
     return Deferred('Capitalize', [type], options);
 }
 /** Applies a Capitalize action to the given type. */
 export function Capitalize(type, options = {}) {
-    return Instantiate({}, CapitalizeDeferred(type, options));
+    return CapitalizeAction(type, options);
 }

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

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

package/build/type/action/conditional.mjs

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

package/build/type/action/constructor-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 TConstructorParametersAction } from '../engine/constructor-parameters/instantiate.mjs';
 /** Creates a deferred ConstructorParameters action. */
 export type TConstructorParametersDeferred<Type extends TSchema> = (TDeferred<'ConstructorParameters', [Type]>);
 /** Creates a deferred ConstructorParameters action. */
 export declare function ConstructorParametersDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TConstructorParametersDeferred<Type>;
 /** Applies a ConstructorParameters action to a type. */
-export type TConstructorParameters<Type extends TSchema> = (TInstantiate<{}, TConstructorParametersDeferred<Type>>);
+export type TConstructorParameters<Type extends TSchema> = (TConstructorParametersAction<Type>);
 /** Applies a ConstructorParameters action to a type. */
 export declare function ConstructorParameters<Type extends TSchema>(type: Type, options?: TSchemaOptions): TConstructorParameters<Type>;

package/build/type/action/constructor-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 { ConstructorParametersAction } from '../engine/constructor-parameters/instantiate.mjs';
 /** Creates a deferred ConstructorParameters action. */
 export function ConstructorParametersDeferred(type, options = {}) {
     return Deferred('ConstructorParameters', [type], options);
 }
 /** Applies a ConstructorParameters action to a type. */
 export function ConstructorParameters(type, options = {}) {
-    return Instantiate({}, ConstructorParametersDeferred(type, options));
+    return ConstructorParametersAction(type, options);
 }

package/build/type/action/evaluate.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 TEvaluateAction } from '../engine/evaluate/instantiate.mjs';
 /** Creates a deferred Evaluate action. */
 export type TEvaluateDeferred<Type extends TSchema> = (TDeferred<'Evaluate', [Type]>);
 /** Creates a deferred Evaluate action. */
 export declare function EvaluateDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TEvaluateDeferred<Type>;
 /** Applies an Evaluate action to a type. */
-export type TEvaluate<Type extends TSchema> = (TInstantiate<{}, TEvaluateDeferred<Type>>);
+export type TEvaluate<Type extends TSchema> = (TEvaluateAction<Type>);
 /** Applies an Evaluate action to a type. */
 export declare function Evaluate<Type extends TSchema>(type: Type, options?: TSchemaOptions): TEvaluate<Type>;

package/build/type/action/evaluate.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 { EvaluateAction } from '../engine/evaluate/instantiate.mjs';
 /** Creates a deferred Evaluate action. */
 export function EvaluateDeferred(type, options = {}) {
     return Deferred('Evaluate', [type], options);
 }
 /** Applies an Evaluate action to a type. */
 export function Evaluate(type, options = {}) {
-    return Instantiate({}, EvaluateDeferred(type, options));
+    return EvaluateAction(type, options);
 }

package/build/type/action/exclude.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 TExcludeAction } from '../engine/exclude/instantiate.mjs';
 /** Creates a deferred Exclude action. */
 export type TExcludeDeferred<Left extends TSchema, Right extends TSchema> = (TDeferred<'Exclude', [Left, Right]>);
 /** Creates a deferred Exclude action. */
 export declare function ExcludeDeferred<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExcludeDeferred<Left, Right>;
 /** Applies a Exclude action using the given types */
-export type TExclude<Left extends TSchema, Right extends TSchema> = (TInstantiate<{}, TExcludeDeferred<Left, Right>>);
+export type TExclude<Left extends TSchema, Right extends TSchema> = (TExcludeAction<Left, Right>);
 /** Applies a Exclude action using the given types */
 export declare function Exclude<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExclude<Left, Right>;

package/build/type/action/exclude.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 { ExcludeAction } from '../engine/exclude/instantiate.mjs';
 /** Creates a deferred Exclude action. */
 export function ExcludeDeferred(left, right, options = {}) {
     return Deferred('Exclude', [left, right], options);
 }
 /** Applies a Exclude action using the given types */
 export function Exclude(left, right, options = {}) {
-    return Instantiate({}, ExcludeDeferred(left, right, options));
+    return ExcludeAction(left, right, options);
 }

package/build/type/action/extract.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 TExtractAction } from '../engine/extract/instantiate.mjs';
 /** Creates a deferred Extract action. */
 export type TExtractDeferred<Left extends TSchema, Right extends TSchema> = (TDeferred<'Extract', [Left, Right]>);
 /** Creates a deferred Extract action. */
 export declare function ExtractDeferred<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExtractDeferred<Left, Right>;
 /** Applies an Extract action using the given types. */
-export type TExtract<Left extends TSchema, Right extends TSchema> = (TInstantiate<{}, TExtractDeferred<Left, Right>>);
+export type TExtract<Left extends TSchema, Right extends TSchema> = (TExtractAction<Left, Right>);
 /** Applies an Extract action using the given types. */
 export declare function Extract<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExtract<Left, Right>;

package/build/type/action/extract.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 { ExtractAction } from '../engine/extract/instantiate.mjs';
 /** Creates a deferred Extract action. */
 export function ExtractDeferred(left, right, options = {}) {
     return Deferred('Extract', [left, right], options);
 }
 /** Applies an Extract action using the given types. */
 export function Extract(left, right, options = {}) {
-    return Instantiate({}, ExtractDeferred(left, right, options));
+    return ExtractAction(left, right, options);
 }

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

@@ -20,7 +20,7 @@ export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
-export * from './readonly-type.mjs';
+export * from './readonly-object.mjs';
 export * from './required.mjs';
 export * from './return-type.mjs';
 export * from './uncapitalize.mjs';

package/build/type/action/index.mjs

@@ -20,7 +20,7 @@ export * from './options.mjs';
 export * from './parameters.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
-export * from './readonly-type.mjs';
+export * from './readonly-object.mjs';
 export * from './required.mjs';
 export * from './return-type.mjs';
 export * from './uncapitalize.mjs';

package/build/type/action/indexed.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 TIndexAction } from '../engine/indexed/instantiate.mjs';
 /** Creates a deferred Index action. */
 export type TIndexDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Index', [Type, Indexer]>);
 /** Creates a deferred Index action. */
 export declare function IndexDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndexDeferred<Type, Indexer>;
 /** Applies a Index action using the given types. */
-export type TIndex<Type extends TSchema, Indexer extends TSchema> = (TInstantiate<{}, TIndexDeferred<Type, Indexer>>);
+export type TIndex<Type extends TSchema, Indexer extends TSchema> = (TIndexAction<Type, Indexer>);
 /** Applies a Index action using the given types. */
 export declare function Index<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TIndex<Type, TKeysToIndexer<Indexer>>;
 /** Applies a Index action using the given types. */

package/build/type/action/indexed.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 { IndexAction } from '../engine/indexed/instantiate.mjs';
 /** Creates a deferred Index action. */
 export function IndexDeferred(type, indexer, options = {}) {
     return Deferred('Index', [type, indexer], options);
@@ -11,5 +10,5 @@ export function IndexDeferred(type, indexer, options = {}) {
 /** Applies a Index action using the given types. */
 export function Index(type, indexer_or_keys, options = {}) {
     const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
-    return Instantiate({}, IndexDeferred(type, indexer, options));
+    return IndexAction(type, indexer, options);
 }

package/build/type/action/instance-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 TInstanceTypeAction } from '../engine/instance-type/instantiate.mjs';
 /** Creates a deferred InstanceType action. */
 export type TInstanceTypeDeferred<Type extends TSchema> = (TDeferred<'InstanceType', [Type]>);
 /** Creates a deferred InstanceType action. */
 export declare function InstanceTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TInstanceTypeDeferred<Type>;
 /** Applies a InstanceType action to the given type. */
-export type TInstanceType<Type extends TSchema> = (TInstantiate<{}, TInstanceTypeDeferred<Type>>);
+export type TInstanceType<Type extends TSchema> = (TInstanceTypeAction<Type>);
 /** Applies a InstanceType action to the given type. */
 export declare function InstanceType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TInstanceType<Type>;

package/build/type/action/instance-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 { InstanceTypeAction } from '../engine/instance-type/instantiate.mjs';
 /** Creates a deferred InstanceType action. */
 export function InstanceTypeDeferred(type, options = {}) {
     return Deferred('InstanceType', [type], options);
 }
 /** Applies a InstanceType action to the given type. */
 export function InstanceType(type, options = {}) {
-    return Instantiate({}, InstanceTypeDeferred(type, options));
+    return InstanceTypeAction(type, options);
 }

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

@@ -1,7 +1,7 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
+import { type TInterfaceAction } from '../engine/interface/instantiate.mjs';
 /** Creates a deferred Interface action. */
 export type TInterfaceDeferred<Heritage extends TSchema[] = TSchema[], Properties extends TProperties = TProperties> = (TDeferred<'Interface', [Heritage, Properties]>);
 /** Creates a deferred Interface action. */
@@ -9,6 +9,6 @@ export declare function InterfaceDeferred<Heritage extends TSchema[], Properties
 /** Returns true if this value is a deferred Interface action. */
 export declare function IsInterfaceDeferred(value: unknown): value is TInterfaceDeferred;
 /** Creates an Interface using the given heritage and properties. */
-export type TInterface<Heritage extends TSchema[], Properties extends TProperties> = (TInstantiate<{}, TInterfaceDeferred<Heritage, Properties>>);
+export type TInterface<Heritage extends TSchema[], Properties extends TProperties> = (TInterfaceAction<Heritage, Properties>);
 /** Creates an Interface using the given heritage and properties. */
 export declare function Interface<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options?: TSchemaOptions): TInterface<Heritage, Properties>;

package/build/type/action/interface.mjs

@@ -1,13 +1,15 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from '../types/schema.mjs';
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
+import { InterfaceAction } from '../engine/interface/instantiate.mjs';
 /** Creates a deferred Interface action. */
 export function InterfaceDeferred(heritage, properties, options = {}) {
     return Deferred('Interface', [heritage, properties], options);
 }
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
 /** Returns true if this value is a deferred Interface action. */
 export function IsInterfaceDeferred(value) {
     return IsSchema(value)
@@ -16,5 +18,5 @@ export function IsInterfaceDeferred(value) {
 }
 /** Creates an Interface using the given heritage and properties. */
 export function Interface(heritage, properties, options = {}) {
-    return Instantiate({}, InterfaceDeferred(heritage, properties, options));
+    return InterfaceAction(heritage, properties, options);
 }

package/build/type/action/keyof.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 TKeyOfAction } from '../engine/keyof/instantiate.mjs';
 /** Creates a deferred KeyOf action. */
 export type TKeyOfDeferred<Type extends TSchema> = (TDeferred<'KeyOf', [Type]>);
 /** Creates a deferred KeyOf action. */
 export declare function KeyOfDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOfDeferred<Type>;
 /** Applies a KeyOf action to the given type. */
-export type TKeyOf<Type extends TSchema> = (TInstantiate<{}, TKeyOfDeferred<Type>>);
+export type TKeyOf<Type extends TSchema> = (TKeyOfAction<Type>);
 /** Applies a KeyOf action to the given type. */
 export declare function KeyOf<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOf<Type>;

package/build/type/action/keyof.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 { KeyOfAction } from '../engine/keyof/instantiate.mjs';
 /** Creates a deferred KeyOf action. */
 export function KeyOfDeferred(type, options = {}) {
     return Deferred('KeyOf', [type], options);
 }
 /** Applies a KeyOf action to the given type. */
 export function KeyOf(type, options = {}) {
-    return Instantiate({}, KeyOfDeferred(type, options));
+    return KeyOfAction(type, options);
 }

package/build/type/action/lowercase.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 TLowercaseAction } from '../engine/intrinsics/instantiate.mjs';
 /** Creates a deferred Lowercase action. */
 export type TLowercaseDeferred<Type extends TSchema> = (TDeferred<'Lowercase', [Type]>);
 /** Creates a deferred Lowercase action. */
 export declare function LowercaseDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TLowercaseDeferred<Type>;
 /** Applies a Lowercase action to the given type. */
-export type TLowercase<Type extends TSchema> = (TInstantiate<{}, TLowercaseDeferred<Type>>);
+export type TLowercase<Type extends TSchema> = (TLowercaseAction<Type>);
 /** Applies a Lowercase action to the given type. */
 export declare function Lowercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TLowercase<Type>;

package/build/type/action/lowercase.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 { LowercaseAction } from '../engine/intrinsics/instantiate.mjs';
 /** Creates a deferred Lowercase action. */
 export function LowercaseDeferred(type, options = {}) {
     return Deferred('Lowercase', [type], options);
 }
 /** Applies a Lowercase action to the given type. */
 export function Lowercase(type, options = {}) {
-    return Instantiate({}, LowercaseDeferred(type, options));
+    return LowercaseAction(type, options);
 }

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

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

package/build/type/action/mapped.mjs

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

package/build/type/action/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

@@ -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 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. */