typebox 1.2.2 → 1.2.4

package/build/type/script/mapping.d.mts

@@ -1,6 +1,6 @@
 import { Memory } from '../../system/memory/index.mjs';
-import * as C from '../action/index.mjs';
 import * as T from '../types/index.mjs';
+import * as S from '../action/index.mjs';
 type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = ([
     Target,
     Parameters
@@ -16,67 +16,67 @@ type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = (
 ] extends ['Iterator', [infer Type extends T.TSchema]] ? T.TIterator<Type> : [
     Target,
     Parameters
-] extends ['Awaited', [infer Type extends T.TSchema]] ? C.TAwaitedDeferred<Type> : [
+] extends ['Awaited', [infer Type extends T.TSchema]] ? S.TAwaitedDeferred<Type> : [
     Target,
     Parameters
-] extends ['Capitalize', [infer Type extends T.TSchema]] ? C.TCapitalizeDeferred<Type> : [
+] extends ['Capitalize', [infer Type extends T.TSchema]] ? S.TCapitalizeDeferred<Type> : [
     Target,
     Parameters
-] extends ['ConstructorParameters', [infer Type extends T.TSchema]] ? C.TConstructorParametersDeferred<Type> : [
+] extends ['ConstructorParameters', [infer Type extends T.TSchema]] ? S.TConstructorParametersDeferred<Type> : [
     Target,
     Parameters
-] extends ['Evaluate', [infer Type extends T.TSchema]] ? C.TEvaluateDeferred<Type> : [
+] extends ['Evaluate', [infer Type extends T.TSchema]] ? S.TEvaluateDeferred<Type> : [
     Target,
     Parameters
-] extends ['Exclude', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? C.TExcludeDeferred<Left, Right> : [
+] extends ['Exclude', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? S.TExcludeDeferred<Left, Right> : [
     Target,
     Parameters
-] extends ['Extract', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? C.TExtractDeferred<Left, Right> : [
+] extends ['Extract', [infer Left extends T.TSchema, infer Right extends T.TSchema]] ? S.TExtractDeferred<Left, Right> : [
     Target,
     Parameters
-] extends ['Index', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TIndexDeferred<Type, Indexer> : [
+] extends ['Index', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? S.TIndexDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['InstanceType', [infer Type extends T.TSchema]] ? C.TInstanceTypeDeferred<Type> : [
+] extends ['InstanceType', [infer Type extends T.TSchema]] ? S.TInstanceTypeDeferred<Type> : [
     Target,
     Parameters
-] extends ['KeyOf', [infer Type extends T.TSchema]] ? C.TKeyOfDeferred<Type> : [
+] extends ['KeyOf', [infer Type extends T.TSchema]] ? S.TKeyOfDeferred<Type> : [
     Target,
     Parameters
-] extends ['Lowercase', [infer Type extends T.TSchema]] ? C.TLowercaseDeferred<Type> : [
+] extends ['Lowercase', [infer Type extends T.TSchema]] ? S.TLowercaseDeferred<Type> : [
     Target,
     Parameters
-] extends ['NonNullable', [infer Type extends T.TSchema]] ? C.TNonNullableDeferred<Type> : [
+] extends ['NonNullable', [infer Type extends T.TSchema]] ? S.TNonNullableDeferred<Type> : [
     Target,
     Parameters
-] extends ['Omit', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TOmitDeferred<Type, Indexer> : [
+] extends ['Omit', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? S.TOmitDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['Parameters', [infer Type extends T.TSchema]] ? C.TParametersDeferred<Type> : [
+] extends ['Parameters', [infer Type extends T.TSchema]] ? S.TParametersDeferred<Type> : [
     Target,
     Parameters
-] extends ['Partial', [infer Type extends T.TSchema]] ? C.TPartialDeferred<Type> : [
+] extends ['Partial', [infer Type extends T.TSchema]] ? S.TPartialDeferred<Type> : [
     Target,
     Parameters
-] extends ['Pick', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TPickDeferred<Type, Indexer> : [
+] extends ['Pick', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? S.TPickDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['Readonly', [infer Type extends T.TSchema]] ? C.TReadonlyObjectDeferred<Type> : [
+] extends ['Readonly', [infer Type extends T.TSchema]] ? S.TReadonlyObjectDeferred<Type> : [
     Target,
     Parameters
 ] extends ['Record', [infer Key extends T.TSchema, infer Value extends T.TSchema]] ? T.TRecordDeferred<Key, Value> : [
     Target,
     Parameters
-] extends ['Required', [infer Type extends T.TSchema]] ? C.TRequiredDeferred<Type> : [
+] extends ['Required', [infer Type extends T.TSchema]] ? S.TRequiredDeferred<Type> : [
     Target,
     Parameters
-] extends ['ReturnType', [infer Type extends T.TSchema]] ? C.TReturnTypeDeferred<Type> : [
+] extends ['ReturnType', [infer Type extends T.TSchema]] ? S.TReturnTypeDeferred<Type> : [
     Target,
     Parameters
-] extends ['Uncapitalize', [infer Type extends T.TSchema]] ? C.TUncapitalizeDeferred<Type> : [
+] extends ['Uncapitalize', [infer Type extends T.TSchema]] ? S.TUncapitalizeDeferred<Type> : [
     Target,
     Parameters
-] extends ['Uppercase', [infer Type extends T.TSchema]] ? C.TUppercaseDeferred<Type> : T.TCallConstruct<T.TRef<Target>, Parameters>);
+] extends ['Uppercase', [infer Type extends T.TSchema]] ? S.TUppercaseDeferred<Type> : T.TCallConstruct<T.TRef<Target>, Parameters>);
 type TDelimitedDecode<Input extends ([unknown, unknown] | unknown)[], Result extends unknown[] = []> = (Input extends [infer Left, ...infer Right] ? Left extends [infer Item, infer _] ? TDelimitedDecode<Right, [...Result, Item]> : TDelimitedDecode<Right, [...Result, Left]> : Result);
 type TDelimited<Input extends [unknown, unknown]> = Input extends [infer Left extends unknown[], infer Right extends unknown[]] ? TDelimitedDecode<[...Left, ...Right]> : [];
 export type TGenericParameterExtendsEqualsMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer Name extends string, 'extends', infer Extends extends T.TSchema, '=', infer Equals extends T.TSchema] ? T.TParameter<Name, Extends, Equals> : never);
@@ -161,10 +161,10 @@ export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown> =
 export declare function BaseMapping(input: [unknown, unknown, unknown] | unknown): unknown;
 export type TWithMapping<Input extends [unknown, unknown] | []> = (Input extends ['with', infer JsonObject extends Record<PropertyKey, unknown>] ? JsonObject : []);
 export declare function WithMapping(input: [unknown, unknown] | []): unknown;
-type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<C.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
-type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? C.TConditionalDeferred<Type, Right, True, False> : Type);
-type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? C.TWithDeferred<Type, With> : Type);
-export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[], infer WithClause extends unknown] ? TFactorWith<KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend>, WithClause> : never);
+type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<S.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
+type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? S.TConditionalDeferred<Type, Right, True, False> : Type);
+type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? S.TWithDeferred<Type, With> : Type);
+export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[], infer WithClause extends unknown] ? TFactorWith<KeyOf extends true ? TFactorExtends<S.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend>, WithClause> : never);
 export declare function FactorMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (Operator extends '&' ? (Schema extends T.TIntersect<infer Types extends T.TSchema[]> ? T.TIntersect<[Left, ...Types]> : T.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends T.TUnion<infer Types extends T.TSchema[]> ? T.TUnion<[Left, ...Types]> : T.TUnion<[Left, Schema]>) : never) : never) : Left);
 export type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | []> = (Input);
@@ -175,7 +175,7 @@ export type TExprTailMapping<Input extends [unknown, unknown, unknown] | []> = (
 export declare function ExprTailMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TExprMapping<Input extends [unknown, unknown]> = (Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]] ? TExprBinaryMapping<Left, Rest> : []);
 export declare function ExprMapping(input: [unknown, unknown]): unknown;
-export type TExprReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? T.TImmutableAdd<Type> : never);
+export type TExprReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? S.TAddImmutableDeferred<Type> : never);
 export declare function ExprReadonlyMapping(input: [unknown, unknown]): unknown;
 export type TExprPipeMapping<Input extends [unknown, unknown]> = (Input extends ['|', infer Type extends T.TSchema] ? Type : never);
 export declare function ExprPipeMapping(input: [unknown, unknown]): unknown;
@@ -203,13 +203,13 @@ export type TPropertyMapping<Input extends [unknown, unknown, unknown, unknown,
     [_ in Key]: ([
         IsReadonly,
         IsOptional
-    ] extends [true, true] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : [
+    ] extends [true, true] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : [
         IsReadonly,
         IsOptional
-    ] extends [true, false] ? T.TReadonlyAdd<Type> : [
+    ] extends [true, false] ? S.TAddReadonlyDeferred<Type> : [
         IsReadonly,
         IsOptional
-    ] extends [false, true] ? T.TOptionalAdd<Type> : Type);
+    ] extends [false, true] ? S.TAddOptionalDeferred<Type> : Type);
 } : never);
 export declare function PropertyMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TPropertyDelimiterMapping<Input extends [unknown, unknown] | [unknown]> = (Input);
@@ -229,13 +229,13 @@ export type TPropertiesMapping<Input extends [unknown, unknown, unknown], Result
 export declare function PropertiesMapping(input: [unknown, unknown, unknown]): unknown;
 export type T_Object_Mapping<Input extends unknown> = (Input extends [infer Properties extends T.TProperties, infer _PatternProperties extends T.TProperties] ? T.TObject<Properties> : never);
 export declare function _Object_Mapping(input: unknown): unknown;
-export type TElementNamedMapping<Input extends [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : Input extends [string, /**/ ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<Type> : Input extends [string, '?', ':', /*      */ infer Type extends T.TSchema] ? T.TOptionalAdd<Type> : Input extends [string, /**/ ':', /*      */ infer Type extends T.TSchema] ? Type : never);
+export type TElementNamedMapping<Input extends [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : Input extends [string, /**/ ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : Input extends [string, '?', ':', /*      */ infer Type extends T.TSchema] ? S.TAddOptionalDeferred<Type> : Input extends [string, /**/ ':', /*      */ infer Type extends T.TSchema] ? Type : never);
 export declare function ElementNamedMapping(input: [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyOptionalMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema, '?'] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : never);
+export type TElementReadonlyOptionalMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema, '?'] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
 export declare function ElementReadonlyOptionalMapping(input: [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<Type> : never);
+export type TElementReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : never);
 export declare function ElementReadonlyMapping(input: [unknown, unknown]): unknown;
-export type TElementOptionalMapping<Input extends [unknown, unknown]> = (Input extends [infer Type extends T.TSchema, '?'] ? T.TOptionalAdd<Type> : never);
+export type TElementOptionalMapping<Input extends [unknown, unknown]> = (Input extends [infer Type extends T.TSchema, '?'] ? S.TAddOptionalDeferred<Type> : never);
 export declare function ElementOptionalMapping(input: [unknown, unknown]): unknown;
 export type TElementBaseMapping<Input extends unknown> = (Input);
 export declare function ElementBaseMapping(input: unknown): unknown;
@@ -245,11 +245,11 @@ export type TElementListMapping<Input extends [unknown, unknown]> = (TDelimited<
 export declare function ElementListMapping(input: [unknown, unknown]): unknown;
 export type T_Tuple_Mapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never);
 export declare function _Tuple_Mapping(input: [unknown, unknown, unknown]): unknown;
-export type TParameterReadonlyOptionalMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<T.TOptionalAdd<Type>> : never);
+export type TParameterReadonlyOptionalMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
 export declare function ParameterReadonlyOptionalMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
-export type TParameterReadonlyMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, ':', 'readonly', infer Type extends T.TSchema] ? T.TReadonlyAdd<Type> : never);
+export type TParameterReadonlyMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : never);
 export declare function ParameterReadonlyMapping(input: [unknown, unknown, unknown, unknown]): unknown;
-export type TParameterOptionalMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', infer Type extends T.TSchema] ? T.TOptionalAdd<Type> : never);
+export type TParameterOptionalMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', infer Type extends T.TSchema] ? S.TAddOptionalDeferred<Type> : never);
 export declare function ParameterOptionalMapping(input: [unknown, unknown, unknown, unknown]): unknown;
 export type TParameterTypeMapping<Input extends [unknown, unknown, unknown]> = (Input extends [string, ':', infer Type extends T.TSchema] ? Type : never);
 export declare function ParameterTypeMapping(input: [unknown, unknown, unknown]): unknown;
@@ -264,15 +264,15 @@ export declare function _Function_Mapping(input: [unknown, unknown, unknown, unk
 export type T_Constructor_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema] ? T.TConstructor<ParameterList, InstanceType> : never);
 export declare function _Constructor_Mapping(input: [unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
 type TModifierOperation = 'add' | 'remove' | 'none';
-type TApplyReadonly<Readonly extends TModifierOperation, Type extends T.TSchema> = (Readonly extends 'remove' ? C.TReadonlyRemoveAction<Type> : Readonly extends 'add' ? C.TReadonlyAddAction<Type> : Type);
+type TApplyReadonly<Readonly extends TModifierOperation, Type extends T.TSchema> = (Readonly extends 'remove' ? S.TRemoveReadonlyDeferred<Type> : Readonly extends 'add' ? S.TAddReadonlyDeferred<Type> : Type);
 export type TMappedReadonlyMapping<Input extends [unknown, unknown] | [unknown] | []> = (Input extends ['-', 'readonly'] ? 'remove' : Input extends ['+', 'readonly'] ? 'add' : Input extends ['readonly'] ? 'add' : 'none');
 export declare function MappedReadonlyMapping(input: [unknown, unknown] | [unknown] | []): unknown;
-type TApplyOptional<Optional extends TModifierOperation, Type extends T.TSchema> = (Optional extends 'remove' ? C.TOptionalRemoveAction<Type> : Optional extends 'add' ? C.TOptionalAddAction<Type> : Type);
+type TApplyOptional<Optional extends TModifierOperation, Type extends T.TSchema> = (Optional extends 'remove' ? S.TRemoveOptionalDeferred<Type> : Optional extends 'add' ? S.TAddOptionalDeferred<Type> : Type);
 export type TMappedOptionalMapping<Input extends [unknown, unknown] | [unknown] | []> = (Input extends ['-', '?'] ? 'remove' : Input extends ['+', '?'] ? 'add' : Input extends ['?'] ? 'add' : 'none');
 export declare function MappedOptionalMapping(input: [unknown, unknown] | [unknown] | []): unknown;
 export type TMappedAsMapping<Input extends [unknown, unknown] | []> = (Input extends ['as', infer Type extends T.TSchema] ? [Type] : []);
 export declare function MappedAsMapping(input: [unknown, unknown] | []): unknown;
-export type T_Mapped_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Type extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Property extends T.TSchema, null, '}'] ? (As extends [infer As extends T.TSchema] ? C.TMappedDeferred<T.TIdentifier<Key>, Type, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>> : C.TMappedDeferred<T.TIdentifier<Key>, Type, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>>) : never);
+export type T_Mapped_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Type extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Property extends T.TSchema, null, '}'] ? (As extends [infer As extends T.TSchema] ? S.TMappedDeferred<T.TIdentifier<Key>, Type, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>> : S.TMappedDeferred<T.TIdentifier<Key>, Type, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>>) : never);
 export declare function _Mapped_Mapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TReferenceMapping<Input extends string, Result extends T.TSchema = T.TRef<Input>> = Result;
 export declare function ReferenceMapping(input: string): unknown;
@@ -331,11 +331,11 @@ export declare function InterfaceDeclarationHeritageListMapping(input: [unknown,
 export type TInterfaceDeclarationHeritageMapping<Input extends [unknown, unknown] | []> = (Input extends ['extends', infer Heritage extends T.TSchema[]] ? Heritage : []);
 export declare function InterfaceDeclarationHeritageMapping(input: [unknown, unknown] | []): unknown;
 export type TInterfaceDeclarationGenericMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['interface', infer Name extends string, infer Parameters extends T.TParameter[], infer Heritage extends T.TSchema[], infer Properties extends [T.TProperties, T.TProperties]] ? {
-    [_ in Name]: T.TGeneric<Parameters, C.TInterfaceDeferred<Heritage, Properties[0]>>;
+    [_ in Name]: T.TGeneric<Parameters, S.TInterfaceDeferred<Heritage, Properties[0]>>;
 } : never);
 export declare function InterfaceDeclarationGenericMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TInterfaceDeclarationMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends ['interface', infer Name extends string, infer Heritage extends T.TSchema[], infer Properties extends [T.TProperties, T.TProperties]] ? {
-    [_ in Name]: C.TInterfaceDeferred<Heritage, Properties[0]>;
+    [_ in Name]: S.TInterfaceDeferred<Heritage, Properties[0]>;
 } : never);
 export declare function InterfaceDeclarationMapping(input: [unknown, unknown, unknown, unknown]): unknown;
 export type TTypeAliasDeclarationGenericMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['type', infer Name extends string, infer Parameters extends T.TParameter[], '=', infer Type extends T.TSchema] ? {
@@ -354,7 +354,7 @@ export type TModuleDeclarationListMapping<Input extends [unknown, unknown]> = (T
 export declare function ModuleDeclarationListMapping(input: [unknown, unknown]): unknown;
 export type TModuleDeclarationMapping<Input extends [unknown, unknown, unknown]> = (Input extends [null, infer ModuleDeclaration extends T.TProperties, null] ? ModuleDeclaration : never);
 export declare function ModuleDeclarationMapping(input: [unknown, unknown, unknown]): unknown;
-export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends [T.TProperties, T.TProperties]] ? C.TModuleDeferred<Memory.TAssign<ModuleDeclaration, ModuleDeclarationList[0]>> : never);
+export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends [T.TProperties, T.TProperties]] ? S.TModuleDeferred<Memory.TAssign<ModuleDeclaration, ModuleDeclarationList[0]>> : never);
 export declare function ModuleMapping(input: [unknown, unknown]): unknown;
 export type TScriptMapping<Input extends unknown> = (Input);
 export declare function ScriptMapping(input: unknown): unknown;

package/build/type/script/mapping.mjs

@@ -2,8 +2,8 @@
 // deno-lint-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import * as C from '../action/index.mjs';
 import * as T from '../types/index.mjs';
+import * as S from '../action/index.mjs';
 function IntrinsicOrCall(ref, parameters) {
     // deno-coverage-ignore-start
     //
@@ -12,27 +12,27 @@ function IntrinsicOrCall(ref, parameters) {
         Guard.IsEqual(ref, 'AsyncIterator') ? T.AsyncIterator(parameters[0]) :
             Guard.IsEqual(ref, 'Iterator') ? T.Iterator(parameters[0]) :
                 Guard.IsEqual(ref, 'Promise') ? T.Promise(parameters[0]) :
-                    Guard.IsEqual(ref, 'Awaited') ? C.AwaitedDeferred(parameters[0]) :
-                        Guard.IsEqual(ref, 'Capitalize') ? C.CapitalizeDeferred(parameters[0]) :
-                            Guard.IsEqual(ref, 'ConstructorParameters') ? C.ConstructorParametersDeferred(parameters[0]) :
-                                Guard.IsEqual(ref, 'Evaluate') ? C.EvaluateDeferred(parameters[0]) :
-                                    Guard.IsEqual(ref, 'Exclude') ? C.ExcludeDeferred(parameters[0], parameters[1]) :
-                                        Guard.IsEqual(ref, 'Extract') ? C.ExtractDeferred(parameters[0], parameters[1]) :
-                                            Guard.IsEqual(ref, 'Index') ? C.IndexDeferred(parameters[0], parameters[1]) :
-                                                Guard.IsEqual(ref, 'InstanceType') ? C.InstanceTypeDeferred(parameters[0]) :
-                                                    Guard.IsEqual(ref, 'Lowercase') ? C.LowercaseDeferred(parameters[0]) :
-                                                        Guard.IsEqual(ref, 'NonNullable') ? C.NonNullableDeferred(parameters[0]) :
-                                                            Guard.IsEqual(ref, 'Omit') ? C.OmitDeferred(parameters[0], parameters[1]) :
-                                                                Guard.IsEqual(ref, 'Parameters') ? C.ParametersDeferred(parameters[0]) :
-                                                                    Guard.IsEqual(ref, 'Partial') ? C.PartialDeferred(parameters[0]) :
-                                                                        Guard.IsEqual(ref, 'Pick') ? C.PickDeferred(parameters[0], parameters[1]) :
-                                                                            Guard.IsEqual(ref, 'Readonly') ? C.ReadonlyObjectDeferred(parameters[0]) :
-                                                                                Guard.IsEqual(ref, 'KeyOf') ? C.KeyOfDeferred(parameters[0]) :
+                    Guard.IsEqual(ref, 'Awaited') ? S.AwaitedDeferred(parameters[0]) :
+                        Guard.IsEqual(ref, 'Capitalize') ? S.CapitalizeDeferred(parameters[0]) :
+                            Guard.IsEqual(ref, 'ConstructorParameters') ? S.ConstructorParametersDeferred(parameters[0]) :
+                                Guard.IsEqual(ref, 'Evaluate') ? S.EvaluateDeferred(parameters[0]) :
+                                    Guard.IsEqual(ref, 'Exclude') ? S.ExcludeDeferred(parameters[0], parameters[1]) :
+                                        Guard.IsEqual(ref, 'Extract') ? S.ExtractDeferred(parameters[0], parameters[1]) :
+                                            Guard.IsEqual(ref, 'Index') ? S.IndexDeferred(parameters[0], parameters[1]) :
+                                                Guard.IsEqual(ref, 'InstanceType') ? S.InstanceTypeDeferred(parameters[0]) :
+                                                    Guard.IsEqual(ref, 'Lowercase') ? S.LowercaseDeferred(parameters[0]) :
+                                                        Guard.IsEqual(ref, 'NonNullable') ? S.NonNullableDeferred(parameters[0]) :
+                                                            Guard.IsEqual(ref, 'Omit') ? S.OmitDeferred(parameters[0], parameters[1]) :
+                                                                Guard.IsEqual(ref, 'Parameters') ? S.ParametersDeferred(parameters[0]) :
+                                                                    Guard.IsEqual(ref, 'Partial') ? S.PartialDeferred(parameters[0]) :
+                                                                        Guard.IsEqual(ref, 'Pick') ? S.PickDeferred(parameters[0], parameters[1]) :
+                                                                            Guard.IsEqual(ref, 'Readonly') ? S.ReadonlyObjectDeferred(parameters[0]) :
+                                                                                Guard.IsEqual(ref, 'KeyOf') ? S.KeyOfDeferred(parameters[0]) :
                                                                                     Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
-                                                                                        Guard.IsEqual(ref, 'Required') ? C.RequiredDeferred(parameters[0]) :
-                                                                                            Guard.IsEqual(ref, 'ReturnType') ? C.ReturnTypeDeferred(parameters[0]) :
-                                                                                                Guard.IsEqual(ref, 'Uncapitalize') ? C.UncapitalizeDeferred(parameters[0]) :
-                                                                                                    Guard.IsEqual(ref, 'Uppercase') ? C.UppercaseDeferred(parameters[0]) :
+                                                                                        Guard.IsEqual(ref, 'Required') ? S.RequiredDeferred(parameters[0]) :
+                                                                                            Guard.IsEqual(ref, 'ReturnType') ? S.ReturnTypeDeferred(parameters[0]) :
+                                                                                                Guard.IsEqual(ref, 'Uncapitalize') ? S.UncapitalizeDeferred(parameters[0]) :
+                                                                                                    Guard.IsEqual(ref, 'Uppercase') ? S.UppercaseDeferred(parameters[0]) :
                                                                                                         T.CallConstruct(T.Ref(ref), parameters));
     // deno-coverage-ignore-stop
 }
@@ -189,7 +189,7 @@ export function WithMapping(input) {
 function FactorIndexArray(Type, indexArray) {
     return indexArray.reduce((result, left) => {
         const _left = left;
-        return (Guard.IsEqual(_left.length, 1) ? C.IndexDeferred(result, _left[0]) :
+        return (Guard.IsEqual(_left.length, 1) ? S.IndexDeferred(result, _left[0]) :
             Guard.IsEqual(_left.length, 0) ? T.Array(result) :
                 Unreachable());
     }, Type);
@@ -197,18 +197,18 @@ function FactorIndexArray(Type, indexArray) {
 // deno-coverage-ignore-stop
 function FactorExtends(type, extend) {
     return Guard.IsEqual(extend.length, 3)
-        ? C.ConditionalDeferred(type, extend[0], extend[1], extend[2])
+        ? S.ConditionalDeferred(type, extend[0], extend[1], extend[2])
         : type;
 }
 function FactorWith(type, withClause) {
     return Guard.IsArray(withClause) && Guard.IsEqual(withClause.length, 0)
         ? type
-        : C.WithDeferred(type, withClause);
+        : S.WithDeferred(type, withClause);
 }
 export function FactorMapping(input) {
     const [keyOf, type, indexArray, extend, withClause] = input;
     return FactorWith(keyOf
-        ? FactorExtends(C.KeyOfDeferred(FactorIndexArray(type, indexArray)), extend)
+        ? FactorExtends(S.KeyOfDeferred(FactorIndexArray(type, indexArray)), extend)
         : FactorExtends(FactorIndexArray(type, indexArray), extend), withClause);
 }
 // deno-coverage-ignore-start
@@ -244,7 +244,7 @@ export function ExprMapping(input) {
     return ExprBinaryMapping(left, rest);
 }
 export function ExprReadonlyMapping(input) {
-    return T.ImmutableAdd(input[1]);
+    return S.AddImmutableDeferred(input[1]);
 }
 export function ExprPipeMapping(input) {
     return input[1];
@@ -290,9 +290,9 @@ export function OptionalMapping(input) {
 export function PropertyMapping(input) {
     const [isReadonly, key, isOptional, _colon, type] = input;
     return {
-        [key]: (isReadonly && isOptional ? T.ReadonlyAdd(T.OptionalAdd(type)) :
-            isReadonly && !isOptional ? T.ReadonlyAdd(type) :
-                !isReadonly && isOptional ? T.OptionalAdd(type) :
+        [key]: (isReadonly && isOptional ? S.AddReadonlyDeferred(S.AddOptionalDeferred(type)) :
+            isReadonly && !isOptional ? S.AddReadonlyDeferred(type) :
+                !isReadonly && isOptional ? S.AddOptionalDeferred(type) :
                     type)
     };
 }
@@ -321,19 +321,19 @@ export function _Object_Mapping(input) {
 }
 // deno-coverage-ignore-start
 export function ElementNamedMapping(input) {
-    return (Guard.IsEqual(input.length, 5) ? T.ReadonlyAdd(T.OptionalAdd(input[4])) :
+    return (Guard.IsEqual(input.length, 5) ? S.AddReadonlyDeferred(S.AddOptionalDeferred(input[4])) :
         Guard.IsEqual(input.length, 3) ? input[2] :
-            Guard.IsEqual(input.length, 4) ? (Guard.IsEqual(input[2], 'readonly') ? T.ReadonlyAdd(input[3]) : T.OptionalAdd(input[3])) :
+            Guard.IsEqual(input.length, 4) ? (Guard.IsEqual(input[2], 'readonly') ? S.AddReadonlyDeferred(input[3]) : S.AddOptionalDeferred(input[3])) :
                 Unreachable());
 }
 export function ElementReadonlyOptionalMapping(input) {
-    return T.ReadonlyAdd(T.OptionalAdd(input[1]));
+    return S.AddReadonlyDeferred(S.AddOptionalDeferred(input[1]));
 }
 export function ElementReadonlyMapping(input) {
-    return T.ReadonlyAdd(input[1]);
+    return S.AddReadonlyDeferred(input[1]);
 }
 export function ElementOptionalMapping(input) {
-    return T.OptionalAdd(input[0]);
+    return S.AddOptionalDeferred(input[0]);
 }
 export function ElementBaseMapping(input) {
     return input;
@@ -351,13 +351,13 @@ export function _Tuple_Mapping(input) {
     return T.Tuple(input[1]);
 }
 export function ParameterReadonlyOptionalMapping(input) {
-    return T.ReadonlyAdd(T.OptionalAdd(input[4]));
+    return S.AddReadonlyDeferred(S.AddOptionalDeferred(input[4]));
 }
 export function ParameterReadonlyMapping(input) {
-    return T.ReadonlyAdd(input[3]);
+    return S.AddReadonlyDeferred(input[3]);
 }
 export function ParameterOptionalMapping(input) {
-    return T.OptionalAdd(input[3]);
+    return S.AddOptionalDeferred(input[3]);
 }
 export function ParameterTypeMapping(input) {
     return input[2];
@@ -381,8 +381,8 @@ export function _Constructor_Mapping(input) {
     return T.Constructor(input[2], input[5]);
 }
 function ApplyReadonly(state, type) {
-    return (Guard.IsEqual(state, 'remove') ? C.ReadonlyRemoveAction(type) :
-        Guard.IsEqual(state, 'add') ? C.ReadonlyAddAction(type) :
+    return (Guard.IsEqual(state, 'remove') ? S.RemoveReadonlyDeferred(type) :
+        Guard.IsEqual(state, 'add') ? S.AddReadonlyDeferred(type) :
             type);
 }
 export function MappedReadonlyMapping(input) {
@@ -392,8 +392,8 @@ export function MappedReadonlyMapping(input) {
                 'none');
 }
 function ApplyOptional(state, type) {
-    return (Guard.IsEqual(state, 'remove') ? C.OptionalRemoveAction(type) :
-        Guard.IsEqual(state, 'add') ? C.OptionalAddAction(type) :
+    return (Guard.IsEqual(state, 'remove') ? S.RemoveOptionalDeferred(type) :
+        Guard.IsEqual(state, 'add') ? S.AddOptionalDeferred(type) :
             type);
 }
 export function MappedOptionalMapping(input) {
@@ -407,8 +407,8 @@ export function MappedAsMapping(input) {
 }
 export function _Mapped_Mapping(input) {
     return (Guard.IsArray(input[6]) && Guard.IsEqual(input[6].length, 1)
-        ? C.MappedDeferred(T.Identifier(input[3]), input[5], input[6][0], ApplyReadonly(input[1], ApplyOptional(input[8], input[10])))
-        : C.MappedDeferred(T.Identifier(input[3]), input[5], T.Ref(input[3]), ApplyReadonly(input[1], ApplyOptional(input[8], input[10]))));
+        ? S.MappedDeferred(T.Identifier(input[3]), input[5], input[6][0], ApplyReadonly(input[1], ApplyOptional(input[8], input[10])))
+        : S.MappedDeferred(T.Identifier(input[3]), input[5], T.Ref(input[3]), ApplyReadonly(input[1], ApplyOptional(input[8], input[10]))));
 }
 export function ReferenceMapping(input) {
     return T.Ref(input);
@@ -497,13 +497,13 @@ export function InterfaceDeclarationGenericMapping(input) {
     const heritage = input[3];
     const [properties, patternProperties] = input[4];
     const options = Guard.IsEqual(Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
-    return { [input[1]]: T.Generic(parameters, C.InterfaceDeferred(heritage, properties, options)) };
+    return { [input[1]]: T.Generic(parameters, S.InterfaceDeferred(heritage, properties, options)) };
 }
 export function InterfaceDeclarationMapping(input) {
     const heritage = input[2];
     const [properties, patternProperties] = input[3];
     const options = Guard.IsEqual(Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
-    return { [input[1]]: C.InterfaceDeferred(heritage, properties, options) };
+    return { [input[1]]: S.InterfaceDeferred(heritage, properties, options) };
 }
 export function TypeAliasDeclarationGenericMapping(input) {
     return { [input[1]]: T.Generic(input[2], input[4]) };
@@ -526,7 +526,7 @@ export function ModuleDeclarationMapping(input) {
 export function ModuleMapping(input) {
     const moduleDeclaration = input[0];
     const moduleDeclarationList = input[1];
-    return C.ModuleDeferred(Memory.Assign(moduleDeclaration, moduleDeclarationList[0]));
+    return S.ModuleDeferred(Memory.Assign(moduleDeclaration, moduleDeclarationList[0]));
 }
 export function ScriptMapping(input) {
     return input;

package/build/type/script/script.d.mts

@@ -1,12 +1,11 @@
 import type { TArrayOptions, TIntersectOptions, TNumberOptions, TObjectOptions, TStringOptions, TTupleOptions } from '../../type/index.mjs';
-import { type TInstantiateType } from '../engine/instantiate.mjs';
 import { type TNever, type TSchema, type TProperties } from '../types/index.mjs';
+import { type TInstantiateType } from '../engine/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 import * as Parser from './parser.mjs';
 export type TScriptOptions = TArrayOptions | TIntersectOptions | TNumberOptions | TObjectOptions | TStringOptions | TTupleOptions;
 /** Parses a string-based TypeScript type expression into a TypeBox type. */
-export type TScript<Context extends TProperties, Input extends string> = (Parser.TScript<Input> extends [infer Type extends TSchema, string] ? TInstantiateType<Context, {
-    callstack: [];
-}, Type> : TNever);
+export type TScript<Context extends TProperties, Input extends string> = (Parser.TScript<Input> extends [infer Type extends TSchema, string] ? TInstantiateType<Context, TState<[], []>, Type> : TNever);
 /** Parses a type from a TypeScript type expression */
 export declare function Script<Script extends string>(input: Script): TScript<{}, Script>;
 /** Parses a type from a TypeScript type expression */

package/build/type/script/script.mjs

@@ -3,8 +3,9 @@
 import { Arguments } from '../../system/arguments/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { InstantiateType } from '../engine/instantiate.mjs';
 import { Never } from '../types/index.mjs';
+import { InstantiateType } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 import * as Parser from './parser.mjs';
 /** Parses a type from a TypeScript type expression */
 export function Script(...args) {
@@ -15,7 +16,7 @@ export function Script(...args) {
     });
     const result = Parser.Script(input);
     const parsed = Guard.IsArray(result) && Guard.IsEqual(result.length, 2)
-        ? InstantiateType(context, { callstack: [] }, result[0])
+        ? InstantiateType(context, State([], []), result[0])
         : Never();
     return Memory.Update(parsed, {}, options);
 }

package/build/type/types/_immutable.d.mts

@@ -1,16 +1,9 @@
 import { type TSchema } from './schema.mjs';
-/** Removes Immutable from the given type. */
-export type TImmutableRemove<Type extends TSchema, Result extends TSchema = Type extends TImmutable<infer Type extends TSchema> ? Type : Type> = Result;
-/** Removes Immutable from the given type. */
-export declare function ImmutableRemove<Type extends TSchema>(type: Type): TImmutableRemove<Type>;
-/** Adds Immutable to the given type. */
-export type TImmutableAdd<Type extends TSchema = TSchema> = ('~immutable' extends keyof Type ? Type : TImmutable<Type>);
-/** Adds Immutable to the given type. */
-export declare function ImmutableAdd<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+import { type TAddImmutable } from '../action/_add_immutable.mjs';
 export type TImmutable<Type extends TSchema = TSchema> = (Type & {
     '~immutable': true;
 });
 /** Applies an Immutable modifier to the given type. */
-export declare function Immutable<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+export declare function Immutable<Type extends TSchema>(type: Type): TAddImmutable<Type>;
 /** Returns true if the given value is a TImmutable */
 export declare function IsImmutable(value: unknown): value is TImmutable<TSchema>;

package/build/type/types/_immutable.mjs

@@ -1,21 +1,13 @@
 // deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
-/** Removes Immutable from the given type. */
-export function ImmutableRemove(type) {
-    return Memory.Discard(type, ['~immutable']);
-}
-/** Adds Immutable to the given type. */
-export function ImmutableAdd(type) {
-    return Memory.Update(type, { '~immutable': true }, {});
-}
+import { AddImmutable } from '../action/_add_immutable.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Applies an Immutable modifier to the given type. */
 export function Immutable(type) {
-    return ImmutableAdd(type);
+    return AddImmutable(type);
 }
 // ------------------------------------------------------------------
 // Guard

package/build/type/types/_optional.d.mts

@@ -1,16 +1,9 @@
 import { type TSchema } from './schema.mjs';
-/** Removes Optional from the given type. */
-export type TOptionalRemove<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? Type : Type> = Result;
-/** Removes Optional from the given type. */
-export declare function OptionalRemove<Type extends TSchema>(type: Type): TOptionalRemove<Type>;
-/** Adds Optional to the given type. */
-export type TOptionalAdd<Type extends TSchema = TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
-/** Adds Optional to the given type. */
-export declare function OptionalAdd<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+import { type TAddOptional } from '../action/_add_optional.mjs';
 export type TOptional<Type extends TSchema = TSchema> = (Type & {
     '~optional': true;
 });
 /** Applies an Optional modifier to the given type. */
-export declare function Optional<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+export declare function Optional<Type extends TSchema>(type: Type): TAddOptional<Type>;
 /** Returns true if the given value is TOptional */
 export declare function IsOptional(value: unknown): value is TOptional<TSchema>;

package/build/type/types/_optional.mjs

@@ -1,22 +1,13 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { Memory } from '../../system/memory/index.mjs';
 import { IsSchema } from './schema.mjs';
-/** Removes Optional from the given type. */
-export function OptionalRemove(type) {
-    const result = Memory.Discard(type, ['~optional']);
-    return result;
-}
-/** Adds Optional to the given type. */
-export function OptionalAdd(type) {
-    return Memory.Update(type, { '~optional': true }, {});
-}
+import { AddOptional } from '../action/_add_optional.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Applies an Optional modifier to the given type. */
 export function Optional(type) {
-    return OptionalAdd(type);
+    return AddOptional(type);
 }
 // ------------------------------------------------------------------
 // Guard

package/build/type/types/_readonly.d.mts

@@ -1,16 +1,9 @@
 import { type TSchema } from './schema.mjs';
-/** Removes a Readonly property modifier from the given type. */
-export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? Type : Type> = Result;
-/** Removes a Readonly property modifier from the given type. */
-export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
-/** Adds a Readonly property modifier to the given type. */
-export type TReadonlyAdd<Type extends TSchema = TSchema> = ('~readonly' extends keyof Type ? Type : TReadonly<Type>);
-/** Adds a Readonly property modifier to the given type. */
-export declare function ReadonlyAdd<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+import { type TAddReadonly } from '../action/_add_readonly.mjs';
 export type TReadonly<Type extends TSchema = TSchema> = (Type & {
     '~readonly': true;
 });
 /** Applies an Readonly property modifier to the given type. */
-export declare function Readonly<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+export declare function Readonly<Type extends TSchema>(type: Type): TAddReadonly<Type>;
 /** Returns true if the given value is a TReadonly */
 export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;

package/build/type/types/_readonly.mjs

@@ -1,21 +1,13 @@
 // deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
-/** Removes a Readonly property modifier from the given type. */
-export function ReadonlyRemove(type) {
-    return Memory.Discard(type, ['~readonly']);
-}
-/** Adds a Readonly property modifier to the given type. */
-export function ReadonlyAdd(type) {
-    return Memory.Update(type, { '~readonly': true }, {});
-}
+import { AddReadonly } from '../action/_add_readonly.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Applies an Readonly property modifier to the given type. */
 export function Readonly(type) {
-    return ReadonlyAdd(type);
+    return AddReadonly(type);
 }
 // ------------------------------------------------------------------
 // Guard