typebox 1.1.27 → 1.1.29

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

@@ -1,14 +1,15 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TFunction } from '../../types/function.mjs';
-import { type TNever } from '../../types/never.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TParametersDeferred } from '../../action/parameters.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TParametersAction<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ extends TSchema> ? TInstantiateType<{}, {
+import { type TInstantiateElements } from '../instantiate.mjs';
+type TParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TFunction ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
     callstack: [];
-}, TTuple<Parameters>> : TNever);
-type TParametersImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantatedType>;
-export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = (TCanInstantiate<Context, [Type]> extends true ? TParametersImmediate<Context, State, Type> : TParametersDeferred<Type>);
+}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+export type TParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TParametersOperation<Type> : TParametersDeferred<Type>> = Result;
+export declare function ParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TParametersAction<Type>;
+export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantiatedType>;
 export declare function ParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TParametersInstantiate<Context, State, Type>;
 export {};

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

@@ -2,21 +2,23 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsFunction } from '../../types/function.mjs';
-import { Never } from '../../types/never.mjs';
 import { Tuple } from '../../types/tuple.mjs';
 import { ParametersDeferred } from '../../action/parameters.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function ParametersAction(type) {
-    return (IsFunction(type)
-        ? InstantiateType({}, { callstack: [] }, Tuple(type.parameters)) // spread-rest
-        : Never());
+import { InstantiateElements } from '../instantiate.mjs';
+function ParametersOperation(type) {
+    const parameters = IsFunction(type) ? type['parameters'] : [];
+    const instantiatedParameters = InstantiateElements({}, { callstack: [] }, parameters);
+    const result = Tuple(instantiatedParameters);
+    return result;
 }
-function ParametersImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(ParametersAction(instantiatedType), {}, options);
+export function ParametersAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(ParametersOperation(type), {}, options)
+        : ParametersDeferred(type, options);
+    return result;
 }
 export function ParametersInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? ParametersImmediate(context, state, type, options)
-        : ParametersDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return ParametersAction(instantiatedType, options);
 }

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

@@ -3,7 +3,7 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TPartialDeferred } from '../../action/partial.mjs';
 import { type TFromType } from './from-type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TPartialImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
-export type TPartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TPartialImmediate<Context, State, Type> : TPartialDeferred<Type>;
+export type TPartialAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TPartialDeferred<Type>> = Result;
+export declare function PartialAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TPartialAction<Type>;
+export type TPartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TPartialAction<InstantiatedType>;
 export declare function PartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TPartialInstantiate<Context, State, Type>;
-export {};

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

@@ -3,12 +3,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { PartialDeferred } from '../../action/partial.mjs';
 import { FromType } from './from-type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function PartialImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(instantiatedType), {}, options);
+export function PartialAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(type), {}, options)
+        : PartialDeferred(type, options);
+    return result;
 }
 export function PartialInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? PartialImmediate(context, state, type, options)
-        : PartialDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return PartialAction(instantiatedType, options);
 }

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

@@ -0,0 +1,13 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { type TToIndexable } from '../indexable/to-indexable.mjs';
+type TComparable<Indexable extends TProperties> = (keyof Indexable extends string | number ? `${keyof Indexable}` : never);
+type TFromKeys<Indexable extends TProperties, Keys extends string[], Result extends TProperties = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends TComparable<Indexable> ? TFromKeys<Indexable, Right, Memory.TAssign<Result, {
+    [_ in Left]: Indexable[Left];
+}>> : TFromKeys<Indexable, Right, Result> : Result);
+export type TFromType<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, Keys extends string[] = TToIndexableKeys<Indexer>, Applied extends TProperties = TFromKeys<Indexable, Keys>, Result extends TSchema = TObject<Applied>> = Result;
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;
+export {};

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

@@ -0,0 +1,20 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { ToIndexable } from '../indexable/to-indexable.mjs';
+function FromKeys(properties, keys) {
+    const result = Guard.Keys(properties).reduce((result, key) => {
+        return keys.includes(key) ? Memory.Assign(result, { [key]: properties[key] }) : result;
+    }, {});
+    return result;
+}
+export function FromType(type, indexer) {
+    const indexable = ToIndexable(type);
+    const keys = ToIndexableKeys(indexer);
+    const applied = FromKeys(indexable, keys);
+    const result = Object(applied);
+    return result;
+}

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

@@ -1,17 +1,9 @@
-import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TObject } from '../../types/object.mjs';
-import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { type TToIndexable } from '../indexable/to-indexable.mjs';
 import { type TPickDeferred } from '../../action/pick.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TComparable<Indexable extends TProperties> = keyof Indexable extends string | number ? `${keyof Indexable}` : never;
-type TFromKeys<Indexable extends TProperties, Keys extends string[], Result extends TProperties = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends TComparable<Indexable> ? TFromKeys<Indexable, Right, Memory.TAssign<Result, {
-    [_ in Left]: Indexable[Left];
-}>> : TFromKeys<Indexable, Right, Result> : Result);
-type TPickAction<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, Keys extends string[] = TToIndexableKeys<Indexer>, Applied extends TProperties = TFromKeys<Indexable, Keys>, Result extends TSchema = TObject<Applied>> = Result;
-type TPickImmediate<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>> = TPickAction<InstantiatedType, InstantiatedIndexer>;
-export type TPickInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TPickImmediate<Context, State, Type, Indexer> : TPickDeferred<Type, Indexer>;
+import { type TFromType } from './from-type.mjs';
+export type TPickAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<Type, Indexer> : TPickDeferred<Type, Indexer>> = Result;
+export declare function PickAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TPickAction<Type, Indexer>;
+export type TPickInstantiate<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>> = TPickAction<InstantiatedType, InstantiatedIndexer>;
 export declare function PickInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TPickInstantiate<Context, State, Type, Indexer>;
-export {};

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

@@ -1,32 +1,16 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { Guard } from '../../../guard/index.mjs';
-import { Object } from '../../types/object.mjs';
-import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { ToIndexable } from '../indexable/to-indexable.mjs';
 import { PickDeferred } from '../../action/pick.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function FromKeys(properties, keys) {
-    const result = Guard.Keys(properties).reduce((result, key) => {
-        return keys.includes(key) ? Memory.Assign(result, { [key]: properties[key] }) : result;
-    }, {});
+import { FromType } from './from-type.mjs';
+export function PickAction(type, indexer, options) {
+    const result = CanInstantiate([type, indexer])
+        ? Memory.Update(FromType(type, indexer), {}, options)
+        : PickDeferred(type, indexer, options);
     return result;
 }
-function PickAction(type, indexer) {
-    const indexable = ToIndexable(type);
-    const keys = ToIndexableKeys(indexer);
-    const applied = FromKeys(indexable, keys);
-    const result = Object(applied);
-    return result;
-}
-function PickImmediate(context, state, type, indexer, options) {
+export function PickInstantiate(context, state, type, indexer, options) {
     const instantiatedType = InstantiateType(context, state, type);
     const instantiatedIndexer = InstantiateType(context, state, indexer);
-    return Memory.Update(PickAction(instantiatedType, instantiatedIndexer), {}, options);
-}
-export function PickInstantiate(context, state, type, indexer, options) {
-    return (CanInstantiate(context, [type, indexer])
-        ? PickImmediate(context, state, type, indexer, options)
-        : PickDeferred(type, indexer, options));
+    return PickAction(instantiatedType, instantiatedIndexer, options);
 }

package/build/type/engine/readonly-object/instantiate.d.mts

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TReadonlyObjectDeferred } from '../../action/readonly-object.mjs';
+import { type TFromType } from './from-type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+export type TReadonlyObjectAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TReadonlyObjectDeferred<Type>> = Result;
+export declare function ReadonlyObjectAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TReadonlyObjectAction<Type>;
+export type TReadonlyObjectInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TReadonlyObjectAction<InstantiateType>;
+export declare function ReadonlyObjectInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TReadonlyObjectInstantiate<Context, State, Type>;

package/build/type/engine/readonly-object/instantiate.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { ReadonlyObjectDeferred } from '../../action/readonly-object.mjs';
+import { FromType } from './from-type.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+export function ReadonlyObjectAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(type), {}, options)
+        : ReadonlyObjectDeferred(type);
+    return result;
+}
+export function ReadonlyObjectInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return ReadonlyObjectAction(instantiatedType, options);
+}

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

@@ -3,7 +3,7 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TRecordDeferred } from '../../types/record.mjs';
 import { type TFromKey } from './from-key.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TRecordImmediate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema, InstantatedKey extends TSchema = TInstantiateType<Context, State, Key>, InstantiatedValue extends TSchema = TInstantiateType<Context, State, Value>, Result extends TSchema = TFromKey<InstantatedKey, InstantiatedValue>> = Result;
-export type TRecordInstantiate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema> = TCanInstantiate<Context, [Key]> extends true ? TRecordImmediate<Context, State, Key, Value> : TRecordDeferred<Key, Value>;
+export type TRecordAction<Key extends TSchema, Value extends TSchema, Result extends TSchema = TCanInstantiate<[Key]> extends true ? TFromKey<Key, Value> : TRecordDeferred<Key, Value>> = Result;
+export declare function RecordAction<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options: TSchemaOptions): TRecordAction<Key, Value>;
+export type TRecordInstantiate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema, InstantiatedKey extends TSchema = TInstantiateType<Context, State, Key>, InstantiatedValue extends TSchema = TInstantiateType<Context, State, Value>> = TRecordAction<InstantiatedKey, InstantiatedValue>;
 export declare function RecordInstantiate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema>(context: Context, state: State, key: Key, value: Value, options: TSchemaOptions): TRecordInstantiate<Context, State, Key, Value>;
-export {};

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

@@ -4,13 +4,14 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { RecordDeferred } from '../../types/record.mjs';
 import { FromKey } from './from-key.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function RecordImmediate(context, state, key, value, options) {
-    const instanstiatedKey = InstantiateType(context, state, key);
-    const instantiatedValue = InstantiateType(context, state, value);
-    return Memory.Update(FromKey(instanstiatedKey, instantiatedValue), {}, options);
+export function RecordAction(key, value, options) {
+    const result = CanInstantiate([key])
+        ? Memory.Update(FromKey(key, value), {}, options)
+        : RecordDeferred(key, value, options);
+    return result;
 }
 export function RecordInstantiate(context, state, key, value, options) {
-    return (CanInstantiate(context, [key])
-        ? RecordImmediate(context, state, key, value, options)
-        : RecordDeferred(key, value, options));
+    const instantiatedKey = InstantiateType(context, state, key);
+    const instantiatedValue = InstantiateType(context, state, value);
+    return RecordAction(instantiatedKey, instantiatedValue, options);
 }

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

@@ -3,7 +3,7 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TFromType } from './from-type.mjs';
 import { type TRequiredDeferred } from '../../action/required.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TRequiredImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
-export type TRequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TRequiredImmediate<Context, State, Type> : TRequiredDeferred<Type>;
+export type TRequiredAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TRequiredDeferred<Type>> = Result;
+export declare function RequiredAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRequiredAction<Type>;
+export type TRequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TRequiredAction<InstantiatedType>;
 export declare function RequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRequiredInstantiate<Context, State, Type>;
-export {};

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

@@ -3,12 +3,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { FromType } from './from-type.mjs';
 import { RequiredDeferred } from '../../action/required.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function RequiredImmediate(context, state, type, options) {
-    const instaniatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(instaniatedType), {}, options);
+export function RequiredAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(type), {}, options)
+        : RequiredDeferred(type, options);
+    return result;
 }
 export function RequiredInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? RequiredImmediate(context, state, type, options)
-        : RequiredDeferred(type, options));
+    const instaniatedType = InstantiateType(context, state, type);
+    return RequiredAction(instaniatedType, options);
 }

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

@@ -4,8 +4,9 @@ import { type TFunction } from '../../types/function.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TReturnTypeDeferred } from '../../action/return-type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TReturnTypeAction<Type extends TSchema> = Type extends TFunction<TSchema[], infer ReturnType extends TSchema> ? ReturnType : TNever;
-type TReturnTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TReturnTypeAction<InstantiatedType>;
-export type TReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TReturnTypeImmediate<Context, State, Type> : TReturnTypeDeferred<Type>;
-export declare function ReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TReturnTypeInstantiate<Context, State, Type>;
+type TReturnTypeOperation<Type extends TSchema> = (Type extends TFunction ? Type['returnType'] : TNever);
+export type TReturnTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TReturnTypeOperation<Type> : TReturnTypeDeferred<Type>> = Result;
+export declare function ReturnTypeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TReturnTypeAction<Type>;
+export type TReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TReturnTypeAction<InstantiatedType>;
+export declare function ReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TReturnTypeInstantiate<Context, State, Type>;
 export {};

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

@@ -4,15 +4,18 @@ import { IsFunction } from '../../types/function.mjs';
 import { Never } from '../../types/never.mjs';
 import { ReturnTypeDeferred } from '../../action/return-type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function ReturnTypeAction(type) {
-    return (IsFunction(type) ? type.returnType : Never());
+function ReturnTypeOperation(type) {
+    return (IsFunction(type)
+        ? type['returnType']
+        : Never());
 }
-function ReturnTypeImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(ReturnTypeAction(instantiatedType), {}, options);
+export function ReturnTypeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(ReturnTypeOperation(type), {}, options)
+        : ReturnTypeDeferred(type, options);
+    return result;
 }
-export function ReturnTypeInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? ReturnTypeImmediate(context, state, type, options)
-        : ReturnTypeDeferred(type, options));
+export function ReturnTypeInstantiate(context, state, type, options = {}) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return ReturnTypeAction(instantiatedType, options);
 }

package/build/type/engine/template-literal/encode.d.mts

@@ -2,7 +2,7 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral, TTemplateLiteralDeferred } from '../../types/template-literal.mjs';
 import { type TBigInt, BigIntPattern } from '../../types/bigint.mjs';
 import { type TString, StringPattern } from '../../types/string.mjs';
 import { type TNumber, NumberPattern } from '../../types/number.mjs';
@@ -10,6 +10,7 @@ import { type TInteger, IntegerPattern } from '../../types/integer.mjs';
 import { type TBoolean } from '../../types/boolean.mjs';
 import { NeverPattern } from '../../types/never.mjs';
 import { type TEnumValuesToVariants } from '../enum/enum-to-union.mjs';
+import { type TTemplateLiteralAction } from './instantiate.mjs';
 type TJoinString<Input extends string[], Result extends string = ''> = (Input extends [infer Left extends string, ...infer Right extends string[]] ? Result extends '' ? TJoinString<Right, Left> : TJoinString<Right, `${Result}|${Left}`> : Result);
 type TUnwrapTemplateLiteralPattern<Pattern extends string> = (Pattern extends `^${infer Pattern extends string}$` ? Pattern : never);
 type TEncodeLiteral<Value extends TLiteralValue, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${Value}`>);
@@ -19,9 +20,10 @@ type TEncodeNumber<Right extends TSchema[], Pattern extends string> = (TEncodeTy
 type TEncodeBoolean<Right extends TSchema[], Pattern extends string> = (TEncodeType<TUnion<[TLiteral<'false'>, TLiteral<'true'>]>, Right, Pattern>);
 type TEncodeString<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof StringPattern}`>);
 type TEncodeTemplateLiteral<TemplatePattern extends string, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${TUnwrapTemplateLiteralPattern<TemplatePattern>}`>);
+type TEncodeTemplateLiteralDeferred<Types extends TSchema[], Right extends TSchema[], Pattern extends string, TemplateLiteral extends TSchema = TTemplateLiteralAction<Types>, Result extends TSchema = TEncodeType<TemplateLiteral, Right, Pattern>> = Result;
 type TEncodeEnum<Types extends TEnumValue[], Right extends TSchema[], Pattern extends string, Variants extends TSchema[] = TEnumValuesToVariants<Types>> = TEncodeUnion<Variants, Right, Pattern>;
 type TEncodeUnion<Types extends TSchema[], Right extends TSchema[], Pattern extends string, Result extends string[] = []> = Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TEncodeUnion<Tail, Right, Pattern, [...Result, TEncodeType<Head, [], ''>]> : TEncodeTypes<Right, `${Pattern}(${TJoinString<Result>})`>;
-type TEncodeType<Type extends TSchema, Right extends TSchema[], Pattern extends string> = (Type extends TEnum<infer Values extends TEnumValue[]> ? TEncodeEnum<Values, Right, Pattern> : Type extends TInteger ? TEncodeInteger<Right, Pattern> : Type extends TLiteral<infer Value extends TLiteralValue> ? TEncodeLiteral<Value, Right, Pattern> : Type extends TBigInt ? TEncodeBigInt<Right, Pattern> : Type extends TBoolean ? TEncodeBoolean<Right, Pattern> : Type extends TNumber ? TEncodeNumber<Right, Pattern> : Type extends TString ? TEncodeString<Right, Pattern> : Type extends TTemplateLiteral<infer TemplatePattern extends string> ? TEncodeTemplateLiteral<TemplatePattern, Right, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEncodeUnion<Types, Right, Pattern> : typeof NeverPattern);
+type TEncodeType<Type extends TSchema, Right extends TSchema[], Pattern extends string> = (Type extends TEnum<infer Values extends TEnumValue[]> ? TEncodeEnum<Values, Right, Pattern> : Type extends TInteger ? TEncodeInteger<Right, Pattern> : Type extends TLiteral<infer Value extends TLiteralValue> ? TEncodeLiteral<Value, Right, Pattern> : Type extends TBigInt ? TEncodeBigInt<Right, Pattern> : Type extends TBoolean ? TEncodeBoolean<Right, Pattern> : Type extends TNumber ? TEncodeNumber<Right, Pattern> : Type extends TString ? TEncodeString<Right, Pattern> : Type extends TTemplateLiteral<infer TemplatePattern extends string> ? TEncodeTemplateLiteral<TemplatePattern, Right, Pattern> : Type extends TTemplateLiteralDeferred<infer Types extends TSchema[]> ? TEncodeTemplateLiteralDeferred<Types, Right, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEncodeUnion<Types, Right, Pattern> : typeof NeverPattern);
 type TEncodeTypes<Types extends TSchema[], Pattern extends string> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TEncodeType<Left, Right, Pattern> : Pattern);
 type TEncodePattern<Types extends TSchema[], Encoded extends string = TEncodeTypes<Types, ''>, Result extends string = `^${Encoded}$`> = Result;
 /** Encodes a TemplateLiteral type sequence into a TemplateLiteral */

package/build/type/engine/template-literal/encode.mjs

@@ -3,7 +3,7 @@ import { IsSchema } from '../../types/schema.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral, IsTemplateLiteralDeferred } from '../../types/template-literal.mjs';
 import { IsBigInt, BigIntPattern } from '../../types/bigint.mjs';
 import { IsString, StringPattern } from '../../types/string.mjs';
 import { IsNumber, NumberPattern } from '../../types/number.mjs';
@@ -12,6 +12,7 @@ import { IsBoolean } from '../../types/boolean.mjs';
 import { NeverPattern } from '../../types/never.mjs';
 import { TemplateLiteralCreate } from './create.mjs';
 import { EnumValuesToVariants } from '../enum/enum-to-union.mjs';
+import { TemplateLiteralAction } from './instantiate.mjs';
 function JoinString(input) {
     return input.join('|');
 }
@@ -39,6 +40,11 @@ function EncodeString(right, pattern) {
 function EncodeTemplateLiteral(templatePattern, right, pattern) {
     return EncodeTypes(right, `${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`);
 }
+function EncodeTemplateLiteralDeferred(types, right, pattern) {
+    const templateLiteral = TemplateLiteralAction(types, {});
+    const result = EncodeType(templateLiteral, right, pattern);
+    return result;
+}
 function EncodeEnum(types, right, pattern) {
     const variants = EnumValuesToVariants(types);
     return EncodeUnion(variants, right, pattern);
@@ -58,8 +64,9 @@ function EncodeType(type, right, pattern) {
                         IsNumber(type) ? EncodeNumber(right, pattern) :
                             IsString(type) ? EncodeString(right, pattern) :
                                 IsTemplateLiteral(type) ? EncodeTemplateLiteral(type.pattern, right, pattern) :
-                                    IsUnion(type) ? EncodeUnion(type.anyOf, right, pattern) :
-                                        NeverPattern);
+                                    IsTemplateLiteralDeferred(type) ? EncodeTemplateLiteralDeferred(type.parameters[0], right, pattern) :
+                                        IsUnion(type) ? EncodeUnion(type.anyOf, right, pattern) :
+                                            NeverPattern);
 }
 function EncodeTypes(types, pattern) {
     const [left, ...right] = types;

package/build/type/engine/template-literal/instantiate.d.mts

@@ -3,7 +3,7 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TTemplateLiteralDeferred } from '../../types/template-literal.mjs';
 import { type TTemplateLiteralEncode } from './encode.mjs';
 import { type TState, type TInstantiateTypes, type TCanInstantiate } from '../instantiate.mjs';
-type TTemplateLiteralImmediate<Context extends TProperties, State extends TState, Types extends TSchema[], InstantiatedTypes extends TSchema[] = TInstantiateTypes<Context, State, Types>, Result extends TSchema = TTemplateLiteralEncode<InstantiatedTypes>> = Result;
-export type TTemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[]> = TCanInstantiate<Context, Types> extends true ? TTemplateLiteralImmediate<Context, State, Types> : TTemplateLiteralDeferred<Types>;
+export type TTemplateLiteralAction<Types extends TSchema[], Result extends TSchema = TCanInstantiate<Types> extends true ? TTemplateLiteralEncode<Types> : TTemplateLiteralDeferred<Types>> = Result;
+export declare function TemplateLiteralAction<Types extends TSchema[]>(types: [...Types], options: TSchemaOptions): TTemplateLiteralAction<Types>;
+export type TTemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[], InstantiatedTypes extends TSchema[] = TInstantiateTypes<Context, State, Types>> = TTemplateLiteralAction<InstantiatedTypes>;
 export declare function TemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types], options: TSchemaOptions): TTemplateLiteralInstantiate<Context, State, Types>;
-export {};

package/build/type/engine/template-literal/instantiate.mjs

@@ -3,12 +3,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { TemplateLiteralDeferred } from '../../types/template-literal.mjs';
 import { TemplateLiteralEncode } from './encode.mjs';
 import { InstantiateTypes, CanInstantiate } from '../instantiate.mjs';
-function TemplateLiteralImmediate(context, state, types, options) {
-    const instaniatedTypes = InstantiateTypes(context, state, types);
-    return Memory.Update(TemplateLiteralEncode(instaniatedTypes), {}, options);
+export function TemplateLiteralAction(types, options) {
+    const result = CanInstantiate(types)
+        ? Memory.Update(TemplateLiteralEncode(types), {}, options)
+        : TemplateLiteralDeferred(types, options);
+    return result;
 }
 export function TemplateLiteralInstantiate(context, state, types, options) {
-    return (CanInstantiate(context, types)
-        ? TemplateLiteralImmediate(context, state, types, options)
-        : TemplateLiteralDeferred(types, options));
+    const instantiatedTypes = InstantiateTypes(context, state, types);
+    return TemplateLiteralAction(instantiatedTypes, options);
 }

package/build/type/extends/extends.d.mts

@@ -1,11 +1,13 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TCyclic } from '../types/cyclic.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TUnsafe } from '../types/unsafe.mjs';
 import { type TExtendsLeft } from './extends-left.mjs';
 import { type TCyclicExtends } from '../engine/cyclic/index.mjs';
-type TNormal<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type);
+type TCanonical<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type extends TUnsafe ? TUnknown : Type);
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
-export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TNormal<Left>, NormalRight extends TSchema = TNormal<Right>> = TExtendsLeft<Inferred, NormalLeft, NormalRight>;
+export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, CanonicalLeft extends TSchema = TCanonical<Left>, CanonicalRight extends TSchema = TCanonical<Right>> = TExtendsLeft<Inferred, CanonicalLeft, CanonicalRight>;
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
 export declare function Extends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtends<Inferred, Left, Right>;
 export {};

package/build/type/extends/extends.mjs

@@ -1,15 +1,17 @@
 // deno-fmt-ignore-file
 import { IsCyclic } from '../types/cyclic.mjs';
+import { Unknown } from '../types/unknown.mjs';
+import { IsUnsafe } from '../types/unsafe.mjs';
 import { ExtendsLeft } from './extends-left.mjs';
 import { CyclicExtends } from '../engine/cyclic/index.mjs';
-function Normal(type) {
-    return (IsCyclic(type)
-        ? CyclicExtends(type)
-        : type);
+function Canonical(type) {
+    return (IsCyclic(type) ? CyclicExtends(type) :
+        IsUnsafe(type) ? Unknown() :
+            type);
 }
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
 export function Extends(inferred, left, right) {
-    const normalLeft = Normal(left);
-    const normalRight = Normal(right);
-    return ExtendsLeft(inferred, normalLeft, normalRight);
+    const canonicalLeft = Canonical(left);
+    const canonicalRight = Canonical(right);
+    return ExtendsLeft(inferred, canonicalLeft, canonicalRight);
 }

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

@@ -64,7 +64,7 @@ type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = (
 ] extends ['Pick', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TPickDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['Readonly', [infer Type extends T.TSchema]] ? C.TReadonlyTypeDeferred<Type> : [
+] extends ['Readonly', [infer Type extends T.TSchema]] ? C.TReadonlyObjectDeferred<Type> : [
     Target,
     Parameters
 ] extends ['Record', [infer Key extends T.TSchema, infer Value extends T.TSchema]] ? T.TRecordDeferred<Key, Value> : [

package/build/type/script/mapping.mjs

@@ -27,7 +27,7 @@ function IntrinsicOrCall(ref, parameters) {
                                                                     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.ReadonlyTypeDeferred(parameters[0]) :
+                                                                                Guard.IsEqual(ref, 'Readonly') ? C.ReadonlyObjectDeferred(parameters[0]) :
                                                                                     Guard.IsEqual(ref, 'KeyOf') ? C.KeyOfDeferred(parameters[0]) :
                                                                                         Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
                                                                                             Guard.IsEqual(ref, 'Required') ? C.RequiredDeferred(parameters[0]) :

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

@@ -8,12 +8,19 @@ export declare function RefineAdd<Type extends TSchema>(type: Type, refinement:
 export type TRefine<Type extends TSchema = TSchema> = (Type & {
     '~refine': TRefinement<Type>[];
 });
-export type TRefineCallback<Type extends TSchema> = (value: Static<Type>) => boolean;
+export type TRefineCheckCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => boolean;
+export type TRefineErrorCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => string;
 export interface TRefinement<Type extends TSchema = TSchema> {
-    refine: TRefineCallback<Type>;
-    message: string;
+    check: TRefineCheckCallback<Type>;
+    error: TRefineErrorCallback<Type>;
 }
-/** Applies a Refine check to the given type. */
-export declare function Refine<Type extends TSchema>(type: Type, refine: TRefineCallback<Type>, message?: string): TRefineAdd<Type>;
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, error: TRefineErrorCallback<Type>): TRefineAdd<Type>;
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>): TRefineAdd<Type>;
+/** @deprecated Use the error callback signature to generate error message. This overload will be removed in the next version  */
+export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, message: string): TRefineAdd<Type>;
+/** Returns true if the given value is a TRefinement. */
+export declare function IsRefinement(value: unknown): value is TRefinement;
 /** Returns true if the given value is a TRefine. */
-export declare function IsRefine(value: unknown): value is TRefine<TSchema>;
+export declare function IsRefine(value: unknown): value is TRefine;

package/build/type/types/_refine.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
@@ -7,14 +8,30 @@ export function RefineAdd(type, refinement) {
     const refinements = IsRefine(type) ? [...type['~refine'], refinement] : [refinement];
     return Memory.Update(type, { '~refine': refinements }, {});
 }
-/** Applies a Refine check to the given type. */
-export function Refine(type, refine, message = 'error') {
-    return RefineAdd(type, { refine, message });
+/** Refines a type with an explicit check */
+export function Refine(...args) {
+    const [type, check, error_or_message] = Arguments.Match(args, {
+        3: (type, check, error) => [type, check, error],
+        2: (type, check) => [type, check, () => 'Refine Error'],
+    });
+    const error = Guard.IsString(error_or_message) ? () => error_or_message : error_or_message;
+    return RefineAdd(type, { check, error });
 }
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
+/** Returns true if the given value is a TRefinement. */
+export function IsRefinement(value) {
+    return Guard.IsObjectNotArray(value)
+        && Guard.HasPropertyKey(value, 'check')
+        && Guard.HasPropertyKey(value, 'error')
+        && Guard.IsFunction(value.check)
+        && Guard.IsFunction(value.error);
+}
 /** Returns true if the given value is a TRefine. */
 export function IsRefine(value) {
-    return IsSchema(value) && Guard.HasPropertyKey(value, '~refine');
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, '~refine')
+        && Guard.IsArray(value['~refine'])
+        && Guard.Every(value['~refine'], 0, value => IsRefinement(value));
 }