typebox 1.1.26 → 1.1.28

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 {};

package/build/type/engine/extract/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 ExtractUnionLeft(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExtractTypeLeft(head, right)];
+    }, []);
+}
+function ExtractTypeLeft(left, right) {
+    const check = Extends({}, left, right);
+    const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
+    return result;
+}
+export function ExtractOperation(left, right) {
+    const remaining = (IsEnum(left) ? ExtractUnionLeft(EnumValuesToVariants(left.enum), right) :
+        IsUnion(left) ? ExtractUnionLeft(Flatten(left.anyOf), right) :
+            ExtractTypeLeft(left, right));
+    const result = EvaluateUnion(remaining);
+    return result;
+}

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

@@ -23,7 +23,7 @@ export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
-export * from './readonly-type/index.mjs';
+export * from './readonly-object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';

package/build/type/engine/index.mjs

@@ -29,7 +29,7 @@ export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
-export * from './readonly-type/index.mjs';
+export * from './readonly-object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';

package/build/type/engine/indexed/from-type.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TFromArray } from './from-array.mjs';
+import { type TFromObject } from './from-object.mjs';
+import { type TFromTuple } from './from-tuple.mjs';
+export type TFromType<Type extends TSchema, Indexer extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;

package/build/type/engine/indexed/from-type.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { IsArray } from '../../types/array.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromTuple } from './from-tuple.mjs';
+export function FromType(type, indexer) {
+    return (IsArray(type) ? FromArray(type.items, indexer) :
+        IsObject(type) ? FromObject(type.properties, indexer) :
+            IsTuple(type) ? FromTuple(type.items, indexer) :
+                Never());
+}

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

@@ -1,21 +1,15 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
-import { type TArray } from '../../types/array.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TNever } from '../../types/never.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TObject } from '../../types/object.mjs';
-import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromArray } from './from-array.mjs';
-import { type TFromObject } from './from-object.mjs';
-import { type TFromTuple } from './from-tuple.mjs';
-import { type TState, type TInstantiateType, TCanInstantiate } from '../instantiate.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TIndexDeferred } from '../../action/indexed.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
+import { type TFromType } from './from-type.mjs';
 type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
-type TIndexAction<Type extends TSchema, Indexer extends TSchema, Normal extends TSchema = TNormalizeType<Type>> = (Normal extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Normal extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Normal extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
-type TIndexImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;
-export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TIndexImmediate<Context, State, Type, Indexer> : TIndexDeferred<Type, Indexer>;
+export type TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
+export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;
+export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;
 export declare function IndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TIndexInstantiate<Context, State, Type, Indexer>;
 export {};

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

@@ -1,37 +1,25 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsArray } from '../../types/array.mjs';
 import { IsCyclic } from '../../types/cyclic.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { Never } from '../../types/never.mjs';
-import { IsObject } from '../../types/object.mjs';
-import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromTuple } from './from-tuple.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { IndexDeferred } from '../../action/indexed.mjs';
 import { CollapseToObject } from '../object/index.mjs';
+import { FromType } from './from-type.mjs';
 function NormalizeType(type) {
     const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
         type);
     return result;
 }
-function IndexAction(type, indexer) {
-    const normal = NormalizeType(type);
-    return (IsArray(normal) ? FromArray(normal.items, indexer) :
-        IsObject(normal) ? FromObject(normal.properties, indexer) :
-            IsTuple(normal) ? FromTuple(normal.items, indexer) :
-                Never());
+export function IndexAction(type, indexer, options) {
+    const result = CanInstantiate([type, indexer])
+        ? Memory.Update(FromType(NormalizeType(type), indexer), {}, options)
+        : IndexDeferred(type, indexer, options);
+    return result;
 }
-function IndexImmediate(context, state, type, indexer, options) {
+export function IndexInstantiate(context, state, type, indexer, options) {
     const instantiatedType = InstantiateType(context, state, type);
     const instantiatedIndexer = InstantiateType(context, state, indexer);
-    return Memory.Update(IndexAction(instantiatedType, instantiatedIndexer), {}, options);
-}
-export function IndexInstantiate(context, state, type, indexer, options) {
-    return (CanInstantiate(context, [type, indexer])
-        ? IndexImmediate(context, state, type, indexer, options)
-        : IndexDeferred(type, indexer, options));
+    return IndexAction(instantiatedType, instantiatedIndexer, options);
 }

package/build/type/engine/instance-type/instantiate.d.mts

@@ -4,9 +4,9 @@ import { type TConstructor } from '../../types/constructor.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TInstanceTypeDeferred } from '../../action/instance-type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TInstanceTypeAction<Type extends TSchema> = (Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever);
-export type TInstanceTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TInstanceTypeAction<InstantiatedType>;
-export declare function InstanceTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TInstanceTypeImmediate<Context, State, Type>;
-export type TInstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TInstanceTypeImmediate<Context, State, Type> : TInstanceTypeDeferred<Type>;
+type TInstanceTypeOperation<Type extends TSchema> = (Type extends TConstructor ? Type['instanceType'] : TNever);
+export type TInstanceTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TInstanceTypeOperation<Type> : TInstanceTypeDeferred<Type>> = Result;
+export declare function InstanceTypeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TInstanceTypeAction<Type>;
+export type TInstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TInstanceTypeAction<InstantiatedType>;
 export declare function InstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TInstanceTypeInstantiate<Context, State, Type>;
 export {};

package/build/type/engine/instance-type/instantiate.mjs

@@ -4,17 +4,18 @@ import { IsConstructor } from '../../types/constructor.mjs';
 import { Never } from '../../types/never.mjs';
 import { InstanceTypeDeferred } from '../../action/instance-type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function InstanceTypeAction(type) {
+function InstanceTypeOperation(type) {
     return (IsConstructor(type)
-        ? type.instanceType
+        ? type['instanceType']
         : Never());
 }
-export function InstanceTypeImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(InstanceTypeAction(instantiatedType), {}, options);
+export function InstanceTypeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(InstanceTypeOperation(type), {}, options)
+        : InstanceTypeDeferred(type, options);
+    return result;
 }
 export function InstanceTypeInstantiate(context, state, type, options = {}) {
-    return (CanInstantiate(context, [type])
-        ? InstanceTypeImmediate(context, state, type, options)
-        : InstanceTypeDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return InstanceTypeAction(instantiatedType, options);
 }

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

@@ -42,7 +42,7 @@ import { type TOptionsInstantiate } from './options/instantiate.mjs';
 import { type TParametersInstantiate } from './parameters/instantiate.mjs';
 import { type TPartialInstantiate } from './partial/instantiate.mjs';
 import { type TPickInstantiate } from './pick/instantiate.mjs';
-import { type TReadonlyTypeInstantiate } from './readonly-type/instantiate.mjs';
+import { type TReadonlyObjectInstantiate } from './readonly-object/instantiate.mjs';
 import { type TRecordInstantiate } from './record/instantiate.mjs';
 import { type TRefInstantiate } from './ref/instantiate.mjs';
 import { type TRequiredInstantiate } from './required/instantiate.mjs';
@@ -54,10 +54,8 @@ import { type TRestSpread } from './rest/index.mjs';
 export interface TState {
     callstack: string[];
 }
-type TCanInstantiateRef<Context extends TProperties, Ref extends string> = (Ref extends keyof Context ? true : false);
-type TCanInstantiateType<Context extends TProperties, Type extends TSchema> = (Type extends TIntersect<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TRef<infer Ref extends string> ? TCanInstantiateRef<Context, Ref> : true);
-export type TCanInstantiate<Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCanInstantiateType<Context, Left> extends true ? TCanInstantiate<Context, Right> : false : true;
-export declare function CanInstantiate<Context extends TProperties, Types extends TSchema[]>(context: Context, types: [...Types]): TCanInstantiate<Context, Types>;
+export type TCanInstantiate<Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef ? false : TCanInstantiate<Right> : true;
+export declare function CanInstantiate<Types extends TSchema[]>(types: [...Types]): TCanInstantiate<Types>;
 type ModifierAction = 'add' | 'remove' | 'none';
 type TModifierActions<Type extends TSchema, Readonly extends ModifierAction, Optional extends ModifierAction> = (Type extends TReadonlyRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, 'remove', Optional> : Type extends TOptionalRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'remove'> : Type extends TReadonlyAddAction<infer Type extends TSchema> ? TModifierActions<Type, 'add', Optional> : Type extends TOptionalAddAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'add'> : [
     Type,
@@ -137,7 +135,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> : [
     Action,
     Parameters
-] extends ['ReadonlyType', [infer Type extends TSchema]] ? TReadonlyTypeInstantiate<Context, State, Type> : [
+] extends ['ReadonlyObject', [infer Type extends TSchema]] ? TReadonlyObjectInstantiate<Context, State, Type> : [
     Action,
     Parameters
 ] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> : [

package/build/type/engine/instantiate.mjs

@@ -10,10 +10,10 @@ import { IsReadonly, ReadonlyAdd, ReadonlyRemove } from '../types/_readonly.mjs'
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
+import { IsBase } from '../types/base.mjs';
 import { IsSchema } from '../types/schema.mjs';
 import { Array, IsArray, ArrayOptions } from '../types/array.mjs';
 import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async-iterator.mjs';
-import { IsBase } from '../types/base.mjs';
 import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
 import { Deferred, IsDeferred } from '../types/deferred.mjs';
 import { _Function_, IsFunction, FunctionOptions } from '../types/function.mjs';
@@ -21,7 +21,7 @@ import { IsCall } from '../types/call.mjs';
 import { Intersect, IsIntersect, IntersectOptions } from '../types/intersect.mjs';
 import { Iterator, IsIterator, IteratorOptions } from '../types/iterator.mjs';
 import { Object, IsObject, ObjectOptions } from '../types/object.mjs';
-import { Promise, IsPromise, PromiseOptions } from '../types/promise.mjs';
+import { _Promise_, IsPromise, PromiseOptions } from '../types/promise.mjs';
 import { RecordFromPattern, IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
 import { Tuple, IsTuple, TupleOptions } from '../types/tuple.mjs';
 import { Union, IsUnion, UnionOptions } from '../types/union.mjs';
@@ -56,7 +56,7 @@ import { OptionsInstantiate } from './options/instantiate.mjs';
 import { ParametersInstantiate } from './parameters/instantiate.mjs';
 import { PartialInstantiate } from './partial/instantiate.mjs';
 import { PickInstantiate } from './pick/instantiate.mjs';
-import { ReadonlyTypeInstantiate } from './readonly-type/instantiate.mjs';
+import { ReadonlyObjectInstantiate } from './readonly-object/instantiate.mjs';
 import { RecordInstantiate } from './record/instantiate.mjs';
 import { RefInstantiate } from './ref/instantiate.mjs';
 import { RequiredInstantiate } from './required/instantiate.mjs';
@@ -65,21 +65,12 @@ import { TemplateLiteralInstantiate } from './template-literal/instantiate.mjs';
 import { UncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { UppercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { RestSpread } from './rest/index.mjs';
-function CanInstantiateRef(context, ref) {
-    return (ref in context);
-}
-function CanInstantiateType(context, type) {
-    return (IsIntersect(type) ? CanInstantiate(context, type.allOf) :
-        IsUnion(type) ? CanInstantiate(context, type.anyOf) :
-            IsRef(type) ? CanInstantiateRef(context, type.$ref) :
-                true);
-}
-export function CanInstantiate(context, types) {
+export function CanInstantiate(types) {
     const [left, ...right] = types;
     return (IsSchema(left)
-        ? CanInstantiateType(context, left)
-            ? CanInstantiate(context, right)
-            : false
+        ? IsRef(left)
+            ? false
+            : CanInstantiate(right)
         : true);
 }
 function ModifierActions(type, readonly, optional) {
@@ -133,7 +124,7 @@ function InstantiateDeferred(context, state, action, parameters, options) {
                                                                         Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
                                                                             Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
                                                                                 Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                    Guard.IsEqual(action, 'ReadonlyType') ? ReadonlyTypeInstantiate(context, state, parameters[0], options) :
+                                                                                    Guard.IsEqual(action, 'ReadonlyObject') ? ReadonlyObjectInstantiate(context, state, parameters[0], options) :
                                                                                         Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
                                                                                             Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
                                                                                                 Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
@@ -156,7 +147,7 @@ export function InstantiateType(context, state, input) {
                                 IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
                                     IsIterator(type) ? Iterator(InstantiateType(context, state, type.iteratorItems), IteratorOptions(type)) :
                                         IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :
-                                            IsPromise(type) ? Promise(InstantiateType(context, state, type.item), PromiseOptions(type)) :
+                                            IsPromise(type) ? _Promise_(InstantiateType(context, state, type.item), PromiseOptions(type)) :
                                                 IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) :
                                                     IsRest(type) ? Rest(InstantiateType(context, state, type.items)) :
                                                         IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :

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

@@ -6,11 +6,13 @@ import { type TInterfaceDeferred } from '../../action/index.mjs';
 import { type TState, type TCanInstantiate } from '../instantiate.mjs';
 import { type TInstantiateProperties } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
-type TInterfaceImmediate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
+type TInterfaceOperation<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TEvaluateIntersect<[...Heritage, TObject<Properties>]>> = Result;
+export type TInterfaceAction<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TCanInstantiate<Heritage> extends true ? TInterfaceOperation<Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>> = Result;
+export declare function InterfaceAction<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceAction<Heritage, Properties>;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
     callstack: [];
-}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<Context, {
+}, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, {
     callstack: [];
-}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
-export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties> = TCanInstantiate<Context, Heritage> extends true ? TInterfaceImmediate<Context, State, Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>;
+}, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
 export declare function InterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties>(context: Context, state: State, heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceInstantiate<Context, State, Heritage, Properties>;
 export {};

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

@@ -6,14 +6,18 @@ import { InterfaceDeferred } from '../../action/index.mjs';
 import { CanInstantiate } from '../instantiate.mjs';
 import { InstantiateProperties } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
-function InterfaceImmediate(context, _state, heritage, properties, options) {
-    const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
-    const instantiatedProperties = InstantiateProperties(context, { callstack: [] }, properties);
-    const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object(instantiatedProperties)]);
-    return Memory.Update(evaluatedInterface, {}, options);
+function InterfaceOperation(heritage, properties) {
+    const result = EvaluateIntersect([...heritage, Object(properties)]);
+    return result;
+}
+export function InterfaceAction(heritage, properties, options) {
+    const result = CanInstantiate(heritage)
+        ? Memory.Update(InterfaceOperation(heritage, properties), {}, options)
+        : InterfaceDeferred(heritage, properties, options);
+    return result;
 }
 export function InterfaceInstantiate(context, state, heritage, properties, options) {
-    return (CanInstantiate(context, heritage)
-        ? InterfaceImmediate(context, state, heritage, properties, options)
-        : InterfaceDeferred(heritage, properties, options));
+    const instantiatedHeritage = InstantiateTypes(context, state, heritage);
+    const instantiatedProperties = InstantiateProperties(context, state, properties);
+    return InterfaceAction(instantiatedHeritage, instantiatedProperties, options);
 }

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

@@ -19,16 +19,20 @@ interface TUncapitalizeMapping extends TMappingType {
 interface TUppercaseMapping extends TMappingType {
     output: Uppercase<this['input']>;
 }
-type TCapitalizeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TCapitalizeMapping, InstantiatedType>;
-export type TCapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TCapitalizeImmediate<Context, State, Type> : TCapitalizeDeferred<Type>;
+export type TCapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TCapitalizeMapping, Type> : TCapitalizeDeferred<Type>> = Result;
+export declare function CapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TCapitalizeAction<Type>;
+export type TLowercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TLowercaseMapping, Type> : TLowercaseDeferred<Type>> = Result;
+export declare function LowercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TLowercaseAction<Type>;
+export type TUncapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUncapitalizeMapping, Type> : TUncapitalizeDeferred<Type>> = Result;
+export declare function UncapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUncapitalizeAction<Type>;
+export type TUppercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUppercaseMapping, Type> : TUppercaseDeferred<Type>> = Result;
+export declare function UppercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUppercaseAction<Type>;
+export type TCapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TCapitalizeAction<InstantiatedType>;
 export declare function CapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TCapitalizeInstantiate<Context, State, Type>;
-type TLowercaseImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TLowercaseMapping, InstantiatedType>;
-export type TLowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TLowercaseImmediate<Context, State, Type> : TLowercaseDeferred<Type>;
+export type TLowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TLowercaseAction<InstantiatedType>;
 export declare function LowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TLowercaseInstantiate<Context, State, Type>;
-type TUncapitalizeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TUncapitalizeMapping, InstantiatedType>;
-export type TUncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TUncapitalizeImmediate<Context, State, Type> : TUncapitalizeDeferred<Type>;
+export type TUncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUncapitalizeAction<InstantiatedType>;
 export declare function UncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUncapitalizeInstantiate<Context, State, Type>;
-type TUppercaseImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TUppercaseMapping, InstantiatedType>;
-export type TUppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TUppercaseImmediate<Context, State, Type> : TUppercaseDeferred<Type>;
+export type TUppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUppercaseAction<InstantiatedType>;
 export declare function UppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUppercaseInstantiate<Context, State, Type>;
 export {};

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

@@ -10,39 +10,43 @@ const CapitalizeMapping = (input) => input[0].toUpperCase() + input.slice(1);
 const LowercaseMapping = (input) => input.toLowerCase();
 const UncapitalizeMapping = (input) => input[0].toLowerCase() + input.slice(1);
 const UppercaseMapping = (input) => input.toUpperCase();
-function CapitalizeImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(CapitalizeMapping, instantiatedType), {}, options);
+export function CapitalizeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(CapitalizeMapping, type), {}, options)
+        : CapitalizeDeferred(type, options);
+    return result;
+}
+export function LowercaseAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(LowercaseMapping, type), {}, options)
+        : LowercaseDeferred(type, options);
+    return result;
+}
+export function UncapitalizeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(UncapitalizeMapping, type), {}, options)
+        : UncapitalizeDeferred(type, options);
+    return result;
+}
+export function UppercaseAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(UppercaseMapping, type), {}, options)
+        : UppercaseDeferred(type, options);
+    return result;
 }
 export function CapitalizeInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? CapitalizeImmediate(context, state, type, options)
-        : CapitalizeDeferred(type, options));
-}
-function LowercaseImmediate(context, state, type, options) {
     const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(LowercaseMapping, instantiatedType), {}, options);
+    return CapitalizeAction(instantiatedType, options);
 }
 export function LowercaseInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? LowercaseImmediate(context, state, type, options)
-        : LowercaseDeferred(type, options));
-}
-function UncapitalizeImmediate(context, state, type, options) {
     const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(UncapitalizeMapping, instantiatedType), {}, options);
+    return LowercaseAction(instantiatedType, options);
 }
 export function UncapitalizeInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? UncapitalizeImmediate(context, state, type, options)
-        : UncapitalizeDeferred(type, options));
-}
-function UppercaseImmediate(context, state, type, options) {
     const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(UppercaseMapping, instantiatedType), {}, options);
+    return UncapitalizeAction(instantiatedType, options);
 }
 export function UppercaseInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? UppercaseImmediate(context, state, type, options)
-        : UppercaseDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return UppercaseAction(instantiatedType, options);
 }

package/build/type/engine/keyof/from-type.d.mts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TFromAny } from './from-any.mjs';
+import { type TFromArray } from './from-array.mjs';
+import { type TFromObject } from './from-object.mjs';
+import { type TFromRecord } from './from-record.mjs';
+import { type TFromTuple } from './from-tuple.mjs';
+export type TFromType<Type extends TSchema> = (Type extends TAny ? TFromAny : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TRecord ? TFromRecord<Type> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : TNever);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;