typebox 1.1.26 → 1.1.28

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/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/promise.d.mts

@@ -9,7 +9,8 @@ export interface TPromise<Type extends TSchema = TSchema> extends TSchema {
     item: Type;
 }
 /** Creates a Promise type. */
-export declare function Promise<Type extends TSchema>(item: Type, options?: TSchemaOptions): TPromise<Type>;
+export declare function _Promise_<Type extends TSchema>(item: Type, options?: TSchemaOptions): TPromise<Type>;
+export { _Promise_ as Promise };
 /** Returns true if the given type is TPromise. */
 export declare function IsPromise(value: unknown): value is TPromise;
 /** Extracts options from a TPromise. */

package/build/type/types/promise.mjs

@@ -5,9 +5,10 @@ import { IsKind } from './schema.mjs';
 // Factory
 // ------------------------------------------------------------------
 /** Creates a Promise type. */
-export function Promise(item, options) {
+export function _Promise_(item, options) {
     return Memory.Create({ ['~kind']: 'Promise' }, { type: 'promise', item }, options);
 }
+export { _Promise_ as Promise };
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------

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

@@ -5,9 +5,9 @@ import { type TInteger } from './integer.mjs';
 import { type TNumber } from './number.mjs';
 import { type TString } from './string.mjs';
 import { type TDeferred } from './deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
 import { type TTemplateLiteralStatic } from '../engine/template-literal/index.mjs';
 import { type TTemplateLiteralDecodeUnsafe } from '../engine/template-literal/decode.mjs';
+import { type TRecordAction } from '../engine/record/instantiate.mjs';
 type StaticPropertyKey<Key extends string, Result extends PropertyKey = (Key extends TStringKey ? string : Key extends TIntegerKey ? number : Key extends TNumberKey ? number : Key extends `^${string}$` ? TTemplateLiteralStatic<Key> : string)> = Result;
 export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticKey extends PropertyKey = StaticPropertyKey<Key>, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = Record<StaticKey, StaticValue>> = Result;
 export type TStringKey = typeof StringKey;
@@ -24,13 +24,13 @@ export interface TRecord<Key extends string = string, Value extends TSchema = TS
     };
 }
 /** Represents a deferred Record action. */
-export type TRecordDeferred<Key extends TSchema, Value extends TSchema> = (TDeferred<'Record', [Key, Value]>);
+export type TRecordDeferred<Key extends TSchema = TSchema, Value extends TSchema = TSchema> = (TDeferred<'Record', [Key, Value]>);
 /** Represents a deferred Record action. */
 export declare function RecordDeferred<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordDeferred<Key, Value>;
-export type TRecordConstruct<Key extends TSchema, Value extends TSchema> = (TInstantiate<{}, TRecordDeferred<Key, Value>>);
-export declare function RecordConstruct<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
+/** Returns true if this value is a deferred Interface action. */
+export declare function IsRecordDeferred(value: unknown): value is TRecordDeferred;
 /** Creates a Record type. */
-export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
+export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordAction<Key, Value>;
 /** Creates a Record type from regular expression pattern. */
 export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(key: Pattern, value: Value): TRecord<Pattern, Value>;
 /** Returns the raw string pattern used for the Record key  */

package/build/type/types/record.mjs

@@ -1,15 +1,14 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { IsKind } from './schema.mjs';
+import { IsKind, IsSchema } from './schema.mjs';
 import { Integer, IntegerPattern } from './integer.mjs';
 import { Number, NumberPattern } from './number.mjs';
 import { String, StringPattern } from './string.mjs';
 import { Deferred } from './deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
 import { TemplateLiteralDecodeUnsafe } from '../engine/template-literal/decode.mjs';
 import { CreateRecord } from '../engine/record/record-create.mjs';
+import { RecordAction } from '../engine/record/instantiate.mjs';
 export const IntegerKey = `^${IntegerPattern}$`;
 export const NumberKey = `^${NumberPattern}$`;
 export const StringKey = `^${StringPattern}$`;
@@ -17,15 +16,21 @@ export const StringKey = `^${StringPattern}$`;
 export function RecordDeferred(key, value, options = {}) {
     return Deferred('Record', [key, value], options);
 }
-export function RecordConstruct(key, value, options = {}) {
-    return Instantiate({}, RecordDeferred(key, value, options));
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if this value is a deferred Interface action. */
+export function IsRecordDeferred(value) {
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, 'action')
+        && Guard.IsEqual(value.action, 'Record');
 }
 // -------------------------------------------------------------------
 // Factory
 // -------------------------------------------------------------------
 /** Creates a Record type. */
 export function Record(key, value, options = {}) {
-    return RecordConstruct(key, value, options);
+    return RecordAction(key, value, options);
 }
 // -------------------------------------------------------------------
 // FromPattern

package/build/type/types/template-literal.d.mts

@@ -1,8 +1,8 @@
 import { type TSchema, type TSchemaOptions } from './schema.mjs';
 import { type TDeferred } from './deferred.mjs';
 import { type TParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
 import { type TTemplateLiteralStatic } from '../engine/template-literal/static.mjs';
+import { type TTemplateLiteralAction } from '../engine/template-literal/instantiate.mjs';
 export type StaticTemplateLiteral<Pattern extends string> = (TTemplateLiteralStatic<Pattern>);
 /** Represents a TemplateLiteral type. */
 export interface TTemplateLiteral<Pattern extends string = string> extends TSchema {
@@ -11,10 +11,12 @@ export interface TTemplateLiteral<Pattern extends string = string> extends TSche
     pattern: Pattern;
 }
 /** Creates a deferred TemplateLiteral action. */
-export type TTemplateLiteralDeferred<Types extends TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
+export type TTemplateLiteralDeferred<Types extends TSchema[] = TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
 /** Creates a deferred TemplateLiteral action. */
 export declare function TemplateLiteralDeferred<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralDeferred<Types>;
-export type TTemplateLiteralFromTypes<Types extends TSchema[], Result extends TSchema = TInstantiate<{}, TTemplateLiteralDeferred<Types>>> = Result;
+/** Returns true if this value is a deferred Interface action. */
+export declare function IsTemplateLiteralDeferred(value: unknown): value is TTemplateLiteralDeferred;
+export type TTemplateLiteralFromTypes<Types extends TSchema[], Result extends TSchema = TTemplateLiteralAction<Types>> = Result;
 export declare function TemplateLiteralFromTypes<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralFromTypes<Types>;
 export type TTemplateLiteralFromString<Template extends string, Types extends TSchema[] = TParseTemplateIntoTypes<Template>, Result extends TSchema = TTemplateLiteralFromTypes<Types>> = Result;
 export declare function TemplateLiteralFromString<Template extends string>(template: Template): TTemplateLiteralFromString<Template>;

package/build/type/types/template-literal.mjs

@@ -1,17 +1,23 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
+import { Memory } from '../../system/system.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { IsKind } from './schema.mjs';
+import { IsSchema, IsKind } from './schema.mjs';
 import { Deferred } from './deferred.mjs';
 import { ParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
-import { Memory } from '../../system/system.mjs';
+import { TemplateLiteralAction } from '../engine/template-literal/instantiate.mjs';
 /** Creates a deferred TemplateLiteral action. */
 export function TemplateLiteralDeferred(types, options = {}) {
     return Deferred('TemplateLiteral', [types], options);
 }
+/** Returns true if this value is a deferred Interface action. */
+export function IsTemplateLiteralDeferred(value) {
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, 'action')
+        && Guard.IsEqual(value.action, 'TemplateLiteral');
+}
 export function TemplateLiteralFromTypes(types) {
-    return Instantiate({}, TemplateLiteralDeferred(types, {}));
+    return TemplateLiteralAction(types, {});
 }
 export function TemplateLiteralFromString(template) {
     const types = ParseTemplateIntoTypes(template);

package/build/typebox.d.mts

@@ -1,7 +1,7 @@
 export { Instantiate, type TInstantiate } from './type/engine/instantiate.mjs';
 export { Extends, ExtendsResult, type TExtends } from './type/extends/index.mjs';
 export { Script, type TScript } from './type/script/index.mjs';
-export { Awaited, type AwaitedDeferred, type TAwaited } from './type/action/awaited.mjs';
+export { Awaited, type TAwaited, type TAwaitedDeferred } from './type/action/awaited.mjs';
 export { Capitalize, type TCapitalize, type TCapitalizeDeferred } from './type/action/capitalize.mjs';
 export { Conditional, type TConditional, type TConditionalDeferred } from './type/action/conditional.mjs';
 export { ConstructorParameters, type TConstructorParameters, type TConstructorParametersDeferred } from './type/action/constructor-parameters.mjs';
@@ -21,7 +21,7 @@ export { Options, type TOptions } from './type/action/options.mjs';
 export { Parameters, type TParameters, type TParametersDeferred } from './type/action/parameters.mjs';
 export { Partial, type TPartial, type TPartialDeferred } from './type/action/partial.mjs';
 export { Pick, type TPick, type TPickDeferred } from './type/action/pick.mjs';
-export { ReadonlyType, type TReadonlyType, type TReadonlyTypeDeferred } from './type/action/readonly-type.mjs';
+export { ReadonlyObject, ReadonlyType, type TReadonlyObject, type TReadonlyObjectDeferred } from './type/action/readonly-object.mjs';
 export { Required, type TRequired, type TRequiredDeferred } from './type/action/required.mjs';
 export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return-type.mjs';
 export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize.mjs';
@@ -56,7 +56,7 @@ export { IsObject, Object, type TObject } from './type/types/object.mjs';
 export { IsParameter, Parameter, type TParameter } from './type/types/parameter.mjs';
 export { IsPromise, Promise, type TPromise } from './type/types/promise.mjs';
 export { type TProperties, type TRequiredArray } from './type/types/properties.mjs';
-export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue, type TRecord, type TRecordKey as TRecordKey, type TRecordPattern as TRecordKeyAsPattern, type TRecordValue } from './type/types/record.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern, RecordValue, type TRecord, type TRecordKey, type TRecordPattern, type TRecordValue } from './type/types/record.mjs';
 export { IsRef, Ref, type TRef } from './type/types/ref.mjs';
 export { IsRest, Rest, type TRest } from './type/types/rest.mjs';
 export { IsKind, IsSchema, type TArrayOptions, type TFormat, type TIntersectOptions, type TNumberOptions, type TObjectOptions, type TSchema, type TSchemaOptions, type TStringOptions, type TTupleOptions } from './type/types/schema.mjs';

package/build/typebox.mjs

@@ -33,7 +33,7 @@ export { Options } from './type/action/options.mjs';
 export { Parameters } from './type/action/parameters.mjs';
 export { Partial } from './type/action/partial.mjs';
 export { Pick } from './type/action/pick.mjs';
-export { ReadonlyType } from './type/action/readonly-type.mjs';
+export { ReadonlyObject, ReadonlyType } from './type/action/readonly-object.mjs';
 export { Required } from './type/action/required.mjs';
 export { ReturnType } from './type/action/return-type.mjs';
 export { Uncapitalize } from './type/action/uncapitalize.mjs';
@@ -73,7 +73,7 @@ export { IsNumber, Number } from './type/types/number.mjs';
 export { IsObject, Object } from './type/types/object.mjs';
 export { IsParameter, Parameter } from './type/types/parameter.mjs';
 export { IsPromise, Promise } from './type/types/promise.mjs';
-export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue } from './type/types/record.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern, RecordValue } from './type/types/record.mjs';
 export { IsRef, Ref } from './type/types/ref.mjs';
 export { IsRest, Rest } from './type/types/rest.mjs';
 export { IsKind, IsSchema } from './type/types/schema.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.26",
+  "version": "1.1.28",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -196,7 +196,7 @@ type UserUpdate = Type.Static<typeof UserUpdate>  // type UserUpdate = {
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQokscAKuWrnyES-ajXZs6dOAFo58hYqXKVqteo0zJ0gMIEwwADZptszeYuWr8tmyQQAdg3gBVBmihwAvImZYAdHrgRmgAFHwU-gDylABWaEgwoQDebHBwwAAmAFy8-P4IMFDADgDmoQCUADRpcA6YIGi5EWgFRSXl1bUsRs35hcVlKbjQWDC5RD2GRHAAvhVs8wum1qtr61pScAAKmFDuKxtHx6q29k7wAK7unj5uHv67+2HJ6W-vH5-vW+fOcNceXKpdJZCYANgArDgAIyYABMlAAzEgACyZCFoME4ADsmAAHJQAJxIAAMmWhRCqX2pcC2IJycGcg1KNXS9UaEwBUEpNN5fO+0jZDSajPaZVZcCmnJuAAFMgRMCV-PYQDN+by6ZKsL1RczFhV1YajR8trNvHB-JagA) | [Example 2](https://www.typescriptlang.org/play/#code/JYWwDg9gTgLgBAZQMYAsCmICGcBmUIhwDkMAnmGgEYQAeA9AM6oaZEBQbddcAtH-wMFDhI0WPESenbgGECYYABs003pPUbNW-hyQQAdg3gBVBmihwAvImZYAdHPBK0ACgDebOHDIUAXMQhKACs0JBgiABpPODB8ClhgNAZ-Dy8vYAATFO9yNH8iIyhgfQBzIjgAXyi0uH1MEDy4Nxy-YkLissrqtJYlbJ9Ggpgi0sjcaCwYfN7FcoroquioNABHAFdgZay4AG1oryJMsf3iOobjmqIZ9i8AXTYKgEoOLjVtd4+P1QAFTCgzVSfIHAyS6AxGOBrMwWaymcx2X7-VzNGqotHouCvPSGeBQ8wpaKZfIANgArDgAIyYABMlAAzEgACwZUloYk4ADsmAAHJQAJxIAAMGQpYwx6Ne6W27VK3TOgzxUDF4pVqq8ktq9UaMpK3Rm+UVAAEMgRMMU7HoQOU1SqNfq4DqHo8bS7XajXhUrHA7D6gA) | [Specification](https://sinclairzx81.github.io/typebox/#/docs/schema/1_spec)
 
-TypeBox has a high-performance JSON Schema compiler with support for drafts 3 through to 2020-12. The compiler is designed to be a lightweight industry-grade alternative to Ajv and offers improved compilation and validation performance. The compiler also offers automatic fallback to dynamic checking in JIT-restricted environments such as Cloudflare Workers.
+TypeBox includes a high-performance JSON Schema compiler with support for drafts 3 through to 2020-12. The compiler is designed to be a lightweight industry-grade alternative to Ajv and offers improved compilation and validation performance. The compiler also offers automatic fallback to dynamic checking in JIT-restricted environments such as Cloudflare Workers.
 
 ### Example
 

package/build/schema/static/~non-readonly.d.mts

@@ -1,7 +0,0 @@
-type XFromTuple<Value extends readonly unknown[]> = (Value extends [infer Left, ...infer Right extends unknown[]] ? [XNonReadonly<Left>, ...XFromTuple<Right>] : []);
-type XFromArray<Value extends unknown, Result extends unknown[] = XNonReadonly<Value>[]> = Result;
-type XFromObject<Value extends object, Result extends Record<PropertyKey, unknown> = {
-    -readonly [K in keyof Value]: XNonReadonly<Value[K]>;
-}> = Result;
-export type XNonReadonly<Value extends unknown> = (Value extends readonly [...infer Schemas extends unknown[]] ? XFromTuple<Schemas> : Value extends readonly (infer Schema)[] ? XFromArray<Schema> : Value extends object ? XFromObject<Value> : Value);
-export {};

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

@@ -1,6 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-export type XIsReadonly<Schema extends XSchema> = (Schema extends {
-    readOnly: true;
-} ? true : Schema extends {
-    '~readonly': true;
-} ? true : false);

package/build/schema/static/~readonly.mjs

@@ -1,2 +0,0 @@
-// deno-fmt-ignore-file
-export {};