@depup/typebox 1.1.23-depup.0 → 1.3.8-depup.0

package/build/type/engine/{readonly-type/from-array.d.mts → readonly_object/from_array.d.mts}

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TImmutableAdd } from '../../types/_immutable.mjs';
-export type TFromArray<Type extends TSchema, Result extends TSchema = TImmutableAdd<TArray<Type>>> = Result;
+import { type TAddImmutable } from '../../action/_add_immutable.mjs';
+export type TFromArray<Type extends TSchema, Result extends TSchema = TAddImmutable<TArray<Type>>> = Result;
 export declare function FromArray<Type extends TSchema>(type: Type): TFromArray<Type>;

package/build/type/engine/{readonly-type/from-array.mjs → readonly_object/from_array.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Array } from '../../types/array.mjs';
-import { Immutable } from '../../types/_immutable.mjs';
+import { AddImmutable } from '../../action/_add_immutable.mjs';
 export function FromArray(type) {
-    const result = Immutable(Array(type));
+    const result = AddImmutable(Array(type));
     return result;
 }

package/build/type/engine/{partial/from-cyclic.d.mts → readonly_object/from_cyclic.d.mts}

@@ -2,7 +2,7 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TCyclicTarget } from '../cyclic/target.mjs';
 export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
     [_ in Ref]: Partial;

package/build/type/engine/{required/from-cyclic.mjs → readonly_object/from_cyclic.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Cyclic } from '../../types/cyclic.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { CyclicTarget } from '../cyclic/target.mjs';
 export function FromCyclic(defs, ref) {
     const target = CyclicTarget(defs, ref);

package/build/type/engine/readonly_object/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/build/type/engine/readonly_object/from_dependent.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

package/build/type/engine/readonly_object/from_intersect.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/build/type/engine/readonly_object/from_intersect.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+export function FromIntersect(types) {
+    const evaluated = EvaluateIntersect(types);
+    const result = FromType(evaluated);
+    return result;
+}

package/build/type/engine/{partial/from-object.d.mts → readonly_object/from_object.d.mts}

@@ -1,8 +1,8 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TOptionalAdd } from '../../types/_optional.mjs';
+import { type TAddReadonly } from '../../action/_add_readonly.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 export type TFromObject<Properties extends TProperties, Mapped extends TProperties = {
-    [Key in keyof Properties]: TOptionalAdd<Properties[Key]>;
+    [Key in keyof Properties]: TAddReadonly<Properties[Key]>;
 }, Result extends TSchema = TObject<Mapped>> = Result;
 export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

package/build/type/engine/{readonly-type/from-object.mjs → readonly_object/from_object.mjs}

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Object } from '../../types/object.mjs';
-import { Readonly } from '../../types/_readonly.mjs';
+import { AddReadonly } from '../../action/_add_readonly.mjs';
 export function FromObject(properties) {
     const mapped = Guard.Keys(properties).reduce((result, left) => {
-        return { ...result, [left]: Readonly(properties[left]) };
+        return { ...result, [left]: AddReadonly(properties[left]) };
     }, {});
     const result = Object(mapped);
     return result;

package/build/type/engine/{readonly-type/from-tuple.d.mts → readonly_object/from_tuple.d.mts}

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TImmutableAdd } from '../../types/_immutable.mjs';
-export type TFromTuple<Types extends TSchema[], Result extends TSchema = TImmutableAdd<TTuple<Types>>> = Result;
+import { type TAddImmutable } from '../../action/_add_immutable.mjs';
+export type TFromTuple<Types extends TSchema[], Result extends TSchema = TAddImmutable<TTuple<Types>>> = Result;
 export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

package/build/type/engine/{readonly-type/from-tuple.mjs → readonly_object/from_tuple.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Tuple } from '../../types/tuple.mjs';
-import { Immutable } from '../../types/_immutable.mjs';
+import { AddImmutable } from '../../action/_add_immutable.mjs';
 export function FromTuple(types) {
-    const result = Immutable(Tuple(types));
+    const result = AddImmutable(Tuple(types));
     return result;
 }

package/build/type/engine/readonly_object/from_type.d.mts

@@ -0,0 +1,18 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+import { type TFromUnion } from './from_union.mjs';
+export type TFromType<Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

package/build/type/engine/readonly_object/from_type.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { IsArray } from '../../types/array.mjs';
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
+import { IsIntersect } from '../../types/intersect.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 { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
+export function FromType(type) {
+    return (IsArray(type) ? FromArray(type.items) :
+        IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+            IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+                IsIntersect(type) ? FromIntersect(type.allOf) :
+                    IsObject(type) ? FromObject(type.properties) :
+                        IsTuple(type) ? FromTuple(type.items) :
+                            IsUnion(type) ? FromUnion(type.anyOf) :
+                                type);
+}

package/build/type/engine/{partial/from-union.d.mts → readonly_object/from_union.d.mts}

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 export type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, TFromType<Left>]> : TUnion<Result>);
 export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;

package/build/type/engine/{partial/from-union.mjs → readonly_object/from_union.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Union } from '../../types/union.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromUnion(types) {
     const result = types.map(type => FromType(type));
     return Union(result);

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/{from-key.d.mts → from_key.d.mts}

@@ -8,17 +8,17 @@ import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TNumber } from '../../types/number.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TString } from '../../types/string.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromAnyKey } from './from-key-any.mjs';
-import { type TFromBooleanKey } from './from-key-boolean.mjs';
-import { type TFromEnumKey } from './from-key-enum.mjs';
-import { type TFromIntegerKey } from './from-key-integer.mjs';
-import { type TFromIntersectKey } from './from-key-intersect.mjs';
-import { type TFromLiteralKey } from './from-key-literal.mjs';
-import { type TFromNumberKey } from './from-key-number.mjs';
-import { type TFromStringKey } from './from-key-string.mjs';
-import { type TFromTemplateKey } from './from-key-template-literal.mjs';
-import { type TFromUnionKey } from './from-key-union.mjs';
+import { type TFromAnyKey } from './from_key_any.mjs';
+import { type TFromBooleanKey } from './from_key_boolean.mjs';
+import { type TFromEnumKey } from './from_key_enum.mjs';
+import { type TFromIntegerKey } from './from_key_integer.mjs';
+import { type TFromIntersectKey } from './from_key_intersect.mjs';
+import { type TFromLiteralKey } from './from_key_literal.mjs';
+import { type TFromNumberKey } from './from_key_number.mjs';
+import { type TFromStringKey } from './from_key_string.mjs';
+import { type TFromTemplateKey } from './from_key_template_literal.mjs';
+import { type TFromUnionKey } from './from_key_union.mjs';
 export type TFromKey<Key extends TSchema, Value extends TSchema, Result extends TSchema = (Key extends TAny ? TFromAnyKey<Value> : Key extends TBoolean ? TFromBooleanKey<Value> : Key extends TEnum<infer Values extends TEnumValue[]> ? TFromEnumKey<Values, Value> : Key extends TInteger ? TFromIntegerKey<Key, Value> : Key extends TIntersect<infer Types extends TSchema[]> ? TFromIntersectKey<Types, Value> : Key extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteralKey<LiteralValue, Value> : Key extends TNumber ? TFromNumberKey<Key, Value> : Key extends TString ? TFromStringKey<Key, Value> : Key extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateKey<Pattern, Value> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Value> : TObject<{}>)> = Result;
 export declare function FromKey<Key extends TSchema, Value extends TSchema>(key: Key, value: Value): TFromKey<Key, Value>;

package/build/type/engine/record/{from-key.mjs → from_key.mjs}

@@ -9,21 +9,21 @@ import { IsLiteral } from '../../types/literal.mjs';
 import { IsNumber } from '../../types/number.mjs';
 import { Object } from '../../types/object.mjs';
 import { IsString } from '../../types/string.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 // ------------------------------------------------------------------
 // Keys and Deferred
 // ------------------------------------------------------------------
-import { FromAnyKey } from './from-key-any.mjs';
-import { FromBooleanKey } from './from-key-boolean.mjs';
-import { FromEnumKey } from './from-key-enum.mjs';
-import { FromIntegerKey } from './from-key-integer.mjs';
-import { FromIntersectKey } from './from-key-intersect.mjs';
-import { FromLiteralKey } from './from-key-literal.mjs';
-import { FromNumberKey } from './from-key-number.mjs';
-import { FromStringKey } from './from-key-string.mjs';
-import { FromTemplateKey } from './from-key-template-literal.mjs';
-import { FromUnionKey } from './from-key-union.mjs';
+import { FromAnyKey } from './from_key_any.mjs';
+import { FromBooleanKey } from './from_key_boolean.mjs';
+import { FromEnumKey } from './from_key_enum.mjs';
+import { FromIntegerKey } from './from_key_integer.mjs';
+import { FromIntersectKey } from './from_key_intersect.mjs';
+import { FromLiteralKey } from './from_key_literal.mjs';
+import { FromNumberKey } from './from_key_number.mjs';
+import { FromStringKey } from './from_key_string.mjs';
+import { FromTemplateKey } from './from_key_template_literal.mjs';
+import { FromUnionKey } from './from_key_union.mjs';
 export function FromKey(key, value) {
     const result = (IsAny(key) ? FromAnyKey(value) :
         IsBoolean(key) ? FromBooleanKey(value) :

package/build/type/engine/record/{from-key-any.mjs → from_key_any.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { StringKey } from '../../types/record.mjs';
-import { CreateRecord } from './record-create.mjs';
+import { CreateRecord } from './record_create.mjs';
 export function FromAnyKey(value) {
     return CreateRecord(StringKey, value);
 }

package/build/type/engine/record/{from-key-enum.d.mts → from_key_enum.d.mts}

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/index.mjs';
 import { type TEnumValue } from '../../types/enum.mjs';
-import { type TEnumValuesToUnion } from '../enum/enum-to-union.mjs';
-import { type TFromKey } from './from-key.mjs';
-export type TFromEnumKey<Values extends TEnumValue[], Value extends TSchema, UnionKey extends TSchema = TEnumValuesToUnion<Values>, Result extends TSchema = TFromKey<UnionKey, Value>> = Result;
+import { type TFromKey } from './from_key.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+export type TFromEnumKey<Values extends TEnumValue[], Value extends TSchema, UnionKey extends TSchema = TEvaluateEnum<Values>, Result extends TSchema = TFromKey<UnionKey, Value>> = Result;
 export declare function FromEnumKey<Values extends TEnumValue[], Value extends TSchema>(values: [...Values], value: Value): TFromEnumKey<Values, Value>;

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

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromKey } from './from_key.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
+export function FromEnumKey(values, value) {
+    const unionKey = EvaluateEnum(values);
+    const result = FromKey(unionKey, value);
+    return result;
+}

package/build/type/engine/record/{from-key-integer.mjs → from_key_integer.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IntegerKey } from '../../types/record.mjs';
-import { CreateRecord } from './record-create.mjs';
+import { CreateRecord } from './record_create.mjs';
 export function FromIntegerKey(_key, value) {
     const result = CreateRecord(IntegerKey, value);
     return result;

package/build/type/engine/record/{from-key-intersect.d.mts → from_key_intersect.d.mts}

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-import { type TFromKey } from './from-key.mjs';
+import { type TFromKey } from './from_key.mjs';
 export type TFromIntersectKey<Types extends TSchema[], Value extends TSchema, EvaluatedKey extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromKey<EvaluatedKey, Value>> = Result;
 export declare function FromIntersectKey<Types extends TSchema[], Value extends TSchema>(types: [...Types], value: Value): TFromIntersectKey<Types, Value>;

package/build/type/engine/record/{from-key-intersect.mjs → from_key_intersect.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
-import { FromKey } from './from-key.mjs';
+import { FromKey } from './from_key.mjs';
 export function FromIntersectKey(types, value) {
     const evaluatedKey = EvaluateIntersect(types);
     const result = FromKey(evaluatedKey, value);

package/build/type/engine/record/{from-key-number.mjs → from_key_number.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { NumberKey } from '../../types/record.mjs';
-import { CreateRecord } from './record-create.mjs';
+import { CreateRecord } from './record_create.mjs';
 export function FromNumberKey(_key, value) {
     const result = CreateRecord(NumberKey, value);
     return result;

package/build/type/engine/record/{from-key-string.mjs → from_key_string.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { StringKey } from '../../types/record.mjs';
-import { CreateRecord } from './record-create.mjs';
+import { CreateRecord } from './record_create.mjs';
 export function FromStringKey(key, value) {
     // special case: override for string with raw pattern. We do not observe inference for the
     // raw string patterns, but as a pattern (assuming non-never) is in the set of string, we

package/build/type/engine/record/{from-key-template-literal.d.mts → from_key_template_literal.d.mts}

@@ -1,8 +1,8 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TRecord } from '../../types/record.mjs';
-import { type TFromKey } from './from-key.mjs';
+import { type TFromKey } from './from_key.mjs';
 import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { type TIsTemplateLiteralFinite } from '../template-literal/is-finite.mjs';
-import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
-export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TTemplateLiteralDecode<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
+import { type TIsTemplateLiteralFinite } from '../template_literal/is_finite.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TEvaluateTemplateLiteral<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
 export declare function FromTemplateKey<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TFromTemplateKey<Pattern, Value>;

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

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { FromKey } from './from_key.mjs';
+import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
+import { IsTemplateLiteralFinite } from '../template_literal/is_finite.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { CreateRecord } from './record_create.mjs';
+export function FromTemplateKey(pattern, value) {
+    const types = ParsePatternIntoTypes(pattern);
+    const finite = IsTemplateLiteralFinite(types);
+    const result = finite ? FromKey(EvaluateTemplateLiteral(pattern), value) : CreateRecord(pattern, value);
+    return result;
+}

package/build/type/engine/record/{from-key-union.mjs → from_key_union.mjs}

@@ -9,7 +9,7 @@ import { Object } from '../../types/object.mjs';
 import { IsString } from '../../types/string.mjs';
 import { StringKey } from '../../types/record.mjs';
 import { Flatten } from '../evaluate/flatten.mjs';
-import { CreateRecord } from './record-create.mjs';
+import { CreateRecord } from './record_create.mjs';
 function StringOrNumberCheck(types) {
     return types.some(type => IsString(type) || IsNumber(type) || IsInteger(type));
 }

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

@@ -1,9 +1,9 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TRecordDeferred } from '../../types/record.mjs';
-import { type TFromKey } from './from-key.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

@@ -2,15 +2,16 @@
 // deno-lint-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { RecordDeferred } from '../../types/record.mjs';
-import { FromKey } from './from-key.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/ref/instantiate.d.mts

@@ -1,6 +1,6 @@
-import { TProperties } from '../../types/properties.mjs';
-import { type TState, type TInstantiateType } from '../instantiate.mjs';
-import { type TCyclicCheck } from '../cyclic/check.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TInstantiateType } from '../instantiate.mjs';
 import { type TRef } from '../../types/ref.mjs';
-export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends keyof Context ? TCyclicCheck<[Ref], Context, Context[Ref]> extends true ? Type : TInstantiateType<Context, State, Context[Ref]> : Type);
+import { type TState } from '../instantiate.mjs';
+export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends State['visited'][number] ? Type : Ref extends keyof Context ? TInstantiateType<Context, TState<State['callstack'], [...State['visited'], Ref]>, Context[Ref]> : Type);
 export declare function RefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string>(context: Context, state: State, type: Type, ref: Ref): TRefInstantiate<Context, State, Type, Ref>;

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

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { InstantiateType } from '../instantiate.mjs';
-import { CyclicCheck } from '../cyclic/check.mjs';
+import { State } from '../instantiate.mjs';
 export function RefInstantiate(context, state, type, ref) {
-    return (ref in context
-        ? CyclicCheck([ref], context, context[ref])
-            ? type
-            : InstantiateType(context, state, context[ref])
-        : type);
+    return (state.visited.includes(ref)
+        ? type
+        : ref in context
+            ? InstantiateType(context, State(state['callstack'], [...state['visited'], ref]), context[ref])
+            : type);
 }

package/build/type/engine/required/{from-cyclic.d.mts → from_cyclic.d.mts}

@@ -2,7 +2,7 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TCyclicTarget } from '../cyclic/target.mjs';
 export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
     [_ in Ref]: Partial;

package/build/type/engine/{readonly-type/from-cyclic.mjs → required/from_cyclic.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Cyclic } from '../../types/cyclic.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { CyclicTarget } from '../cyclic/target.mjs';
 export function FromCyclic(defs, ref) {
     const target = CyclicTarget(defs, ref);

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

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

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

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

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+export function FromIntersect(types) {
+    const evaluated = EvaluateIntersect(types);
+    const result = FromType(evaluated);
+    return result;
+}

package/build/type/engine/required/{from-object.d.mts → from_object.d.mts}

@@ -1,8 +1,8 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TOptionalRemove } from '../../types/_optional.mjs';
+import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 export type TFromObject<Properties extends TProperties, Mapped extends TProperties = {
-    [Key in keyof Properties]: TOptionalRemove<Properties[Key]>;
+    [Key in keyof Properties]: TRemoveOptional<Properties[Key]>;
 }, Result extends TSchema = TObject<Mapped>> = Result;
 export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

package/build/type/engine/required/{from-object.mjs → from_object.mjs}

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Object } from '../../types/object.mjs';
-import { OptionalRemove } from '../../types/_optional.mjs';
+import { RemoveOptional } from '../../action/_remove_optional.mjs';
 export function FromObject(properties) {
     const mapped = Guard.Keys(properties).reduce((result, left) => {
-        return { ...result, [left]: OptionalRemove(properties[left]) };
+        return { ...result, [left]: RemoveOptional(properties[left]) };
     }, {});
     const result = Object(mapped);
     return result;

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

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromUnion } from './from_union.mjs';
+import { type TFromObject } from './from_object.mjs';
+export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -0,0 +1,20 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { Object, IsObject } from '../../types/object.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromUnion } from './from_union.mjs';
+import { FromObject } from './from_object.mjs';
+export function FromType(type) {
+    return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    IsObject(type) ? FromObject(type.properties) :
+                        Object({}));
+}