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

package/build/type/engine/evaluate/evaluate.mjs

@@ -1,23 +1,49 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsIntersect } from '../../types/intersect.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { Literal } from '../../types/literal.mjs';
+import { IsIntersect, Intersect } from '../../types/intersect.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
-import { Union, IsUnion } from '../../types/union.mjs';
-import { Never } from '../../types/never.mjs';
+import { ExcludeOperation } from '../exclude/operation.mjs';
+import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+export function EvaluateDependent(if_, then_, else_) {
+    const intersect = Intersect([if_, then_]);
+    const excluded = ExcludeOperation(else_, if_);
+    const result = EvaluateUnion([intersect, excluded]);
+    return result;
+}
+export function EvaluateEnum(values) {
+    const result = values.map(value => Literal(value));
+    return EvaluateUnion(result);
+}
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
-    const result = Broaden(distribution);
+    const broadend = Broaden(distribution);
+    const result = EvaluateUnionFast(broadend);
+    return result;
+}
+export function EvaluateTemplateLiteral(pattern) {
+    const evaluated = TemplateLiteralDecode(pattern);
+    const result = EvaluateType(evaluated);
     return result;
 }
 export function EvaluateUnion(types) {
-    const result = Broaden(types);
+    const broadend = Broaden(types);
+    const result = EvaluateUnionFast(broadend);
     return result;
 }
 export function EvaluateType(type) {
-    return (IsIntersect(type) ? EvaluateIntersect(type.allOf) :
-        IsUnion(type) ? EvaluateUnion(type.anyOf) :
-            type);
+    return (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
+        IsEnum(type) ? EvaluateEnum(type.enum) :
+            IsIntersect(type) ? EvaluateIntersect(type.allOf) :
+                IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
+                    IsUnion(type) ? EvaluateUnion(type.anyOf) :
+                        type);
 }
 export function EvaluateUnionFast(types) {
     const result = (Guard.IsEqual(types.length, 1) ? types[0] :

package/build/type/engine/evaluate/flatten.d.mts

@@ -1,4 +1,4 @@
-import { TSchema } from '../../types/schema.mjs';
+import { type TSchema } from '../../types/schema.mjs';
 import { type TUnion } from '../../types/union.mjs';
 type TFlattenType<Type extends TSchema, Result extends TSchema[] = Type extends TUnion<infer Types extends TSchema[]> ? TFlatten<Types> : [Type]> = Result;
 export type TFlatten<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFlatten<Right, [...Result, ...TFlattenType<Left>]> : Result);

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

@@ -2,7 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
-type TEvaluateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TEvaluateType<InstantiatedType>;
-export type TEvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TEvaluateImmediate<Context, State, Type>;
+export type TEvaluateAction<Type extends TSchema, Result extends TSchema = TEvaluateType<Type>> = Result;
+export declare function EvaluateAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TEvaluateAction<Type>;
+export type TEvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TEvaluateAction<InstantiatedType>;
 export declare function EvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TEvaluateInstantiate<Context, State, Type>;
-export {};

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

@@ -2,16 +2,11 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { EvaluateType } from './evaluate.mjs';
-function EvaluateImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(EvaluateType(instantiatedType), {}, options);
+export function EvaluateAction(type, options) {
+    const result = Memory.Update(EvaluateType(type), {}, options);
+    return result;
 }
 export function EvaluateInstantiate(context, state, type, options) {
-    return (
-    // [instantiation-rule]
-    //
-    // Evaluate instantiation should never defer on instantiate as the caller is specifically 
-    // requesting that the type be evaluated in whatever context is available. However, actions 
-    // embedded in the Evaluate call may defer local to themselves.
-    EvaluateImmediate(context, state, type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return EvaluateAction(instantiatedType, options);
 }

package/build/type/engine/evaluate/narrow.d.mts

@@ -1,5 +1,5 @@
-import { TSchema } from '../../types/schema.mjs';
-import { TNever } from '../../types/never.mjs';
-import { TCompare, TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TCompare, type TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
 export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
 export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;

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

@@ -1,16 +1,9 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TExcludeDeferred } from '../../action/exclude.mjs';
-type TExcludeUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
-type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [] : [Left]> = Result;
-type TExcludeAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExcludeUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExcludeUnion<TFlatten<Types>, Right> : TExcludeType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
-type TExcludeImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExcludeAction<InstantiatedLeft, InstantiatedRight>;
-export type TExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExcludeImmediate<Context, State, Left, Right> : TExcludeDeferred<Left, Right>;
+import { type TExcludeOperation } from './operation.mjs';
+export type TExcludeAction<Left extends TSchema, Right extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TExcludeOperation<Left, Right> : TExcludeDeferred<Left, Right>> = Result;
+export declare function ExcludeAction<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions): TExcludeAction<Left, Right>;
+export type TExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExcludeAction<InstantiatedLeft, InstantiatedRight>;
 export declare function ExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExcludeInstantiate<Context, State, Left, Right>;
-export {};

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

@@ -1,37 +1,16 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsEnum } from '../../types/enum.mjs';
-import { IsUnion } from '../../types/union.mjs';
-import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { ExcludeDeferred } from '../../action/exclude.mjs';
-function ExcludeUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExcludeType(head, right)];
-    }, []);
-}
-function ExcludeType(left, right) {
-    const check = Extends({}, left, right);
-    const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
-    return result;
-}
-function ExcludeAction(left, right) {
-    const remaining = (IsEnum(left) ? ExcludeUnion(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExcludeUnion(Flatten(left.anyOf), right) :
-            ExcludeType(left, right));
-    const result = EvaluateUnion(remaining);
+import { ExcludeOperation } from './operation.mjs';
+export function ExcludeAction(left, right, options) {
+    const result = CanInstantiate([left, right])
+        ? Memory.Update(ExcludeOperation(left, right), {}, options)
+        : ExcludeDeferred(left, right, options);
     return result;
 }
-function ExcludeImmediate(context, state, left, right, options) {
+export function ExcludeInstantiate(context, state, left, right, options) {
     const instantiatedLeft = InstantiateType(context, state, left);
     const instantiatedRight = InstantiateType(context, state, right);
-    return Memory.Update(ExcludeAction(instantiatedLeft, instantiatedRight), {}, options);
-}
-export function ExcludeInstantiate(context, state, left, right, options) {
-    return (CanInstantiate(context, [left, right])
-        ? ExcludeImmediate(context, state, left, right, options)
-        : ExcludeDeferred(left, right, options));
+    return ExcludeAction(instantiatedLeft, instantiatedRight, options);
 }

package/build/type/engine/exclude/operation.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [] : [Left]> = Result;
+type TExcludeUnion<Left extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
+export type TExcludeOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExcludeUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+export declare function ExcludeOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExcludeOperation<Left, Right>;
+export {};

package/build/type/engine/exclude/operation.mjs

@@ -0,0 +1,23 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { IsUnion } from '../../types/union.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { EvaluateType } from '../evaluate/evaluate.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+function ExcludeType(left, right) {
+    const check = Extends({}, left, right);
+    const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
+    return result;
+}
+function ExcludeUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExcludeType(head, right)];
+    }, []);
+}
+export function ExcludeOperation(left, right) {
+    const evaluated = EvaluateType(left);
+    const canonical = IsUnion(evaluated) ? evaluated.anyOf : [evaluated];
+    const remaining = ExcludeUnion(canonical, right);
+    const result = EvaluateUnion(remaining);
+    return result;
+}

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

@@ -1,16 +1,9 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TEvaluateUnion, type TFlatten } from '../evaluate/index.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TExtractDeferred } from '../../action/extract.mjs';
-type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
-type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [Left] : []> = Result;
-type TExtractAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExtractUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtractUnion<TFlatten<Types>, Right> : TExtractType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
-type TExtractImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExtractAction<InstantiatedLeft, InstantiatedRight>;
-export type TExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExtractImmediate<Context, State, Left, Right> : TExtractDeferred<Left, Right>;
+import { type TExtractOperation } from './operation.mjs';
+export type TExtractAction<Left extends TSchema, Right extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TExtractOperation<Left, Right> : TExtractDeferred<Left, Right>> = Result;
+export declare function ExtractAction<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions): TExtractAction<Left, Right>;
+export type TExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExtractAction<InstantiatedLeft, InstantiatedRight>;
 export declare function ExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExtractInstantiate<Context, State, Left, Right>;
-export {};

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

@@ -1,37 +1,16 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsEnum } from '../../types/enum.mjs';
-import { IsUnion } from '../../types/union.mjs';
-import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { EvaluateUnion, Flatten } from '../evaluate/index.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { ExtractDeferred } from '../../action/extract.mjs';
-function ExtractUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExtractType(head, right)];
-    }, []);
-}
-function ExtractType(left, right) {
-    const check = Extends({}, left, right);
-    const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
-    return result;
-}
-function ExtractAction(left, right) {
-    const remaining = (IsEnum(left) ? ExtractUnion(EnumValuesToVariants(left.enum), right) :
-        IsUnion(left) ? ExtractUnion(Flatten(left.anyOf), right) :
-            ExtractType(left, right));
-    const result = EvaluateUnion(remaining);
+import { ExtractOperation } from './operation.mjs';
+export function ExtractAction(left, right, options) {
+    const result = CanInstantiate([left, right])
+        ? Memory.Update(ExtractOperation(left, right), {}, options)
+        : ExtractDeferred(left, right, options);
     return result;
 }
-function ExtractImmediate(context, state, left, right, options) {
+export function ExtractInstantiate(context, state, left, right, options) {
     const instantiatedLeft = InstantiateType(context, state, left);
     const instantiatedRight = InstantiateType(context, state, right);
-    return Memory.Update(ExtractAction(instantiatedLeft, instantiatedRight), {}, options);
-}
-export function ExtractInstantiate(context, state, left, right, options) {
-    return (CanInstantiate(context, [left, right])
-        ? ExtractImmediate(context, state, left, right, options)
-        : ExtractDeferred(left, right, options));
+    return ExtractAction(instantiatedLeft, instantiatedRight, options);
 }

package/build/type/engine/extract/operation.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [Left] : []> = Result;
+type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+export type TExtractOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExtractUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
+export {};

package/build/type/engine/extract/operation.mjs

@@ -0,0 +1,23 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { IsUnion } from '../../types/union.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { EvaluateType } from '../evaluate/evaluate.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+function ExtractType(left, right) {
+    const check = Extends({}, left, right);
+    const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
+    return result;
+}
+function ExtractUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExtractType(head, right)];
+    }, []);
+}
+export function ExtractOperation(left, right) {
+    const evaluated = EvaluateType(left);
+    const canonical = IsUnion(evaluated) ? evaluated.anyOf : [evaluated];
+    const remaining = ExtractUnion(canonical, right);
+    const result = EvaluateUnion(remaining);
+    return result;
+}

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

@@ -1,3 +1,3 @@
-export * from './keys-to-indexer.mjs';
+export * from './keys_to_indexer.mjs';
 export * from './keys.mjs';
 export * from './union.mjs';

package/build/type/engine/helpers/index.mjs

@@ -1,3 +1,3 @@
-export * from './keys-to-indexer.mjs';
+export * from './keys_to_indexer.mjs';
 export * from './keys.mjs';
 export * from './union.mjs';

package/build/type/engine/immutable/instantiate_add.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TImmutable } from '../../types/_immutable.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddImmutableOperation<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
+export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = TAddImmutableOperation<Type>> = Result;
+export declare function AddImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddImmutableAction<Type>;
+export type TAddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddImmutableAction<InstantiateType>;
+export declare function AddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddImmutableInstantiate<Context, State, Type>;
+export {};

package/build/type/engine/immutable/instantiate_add.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+function AddImmutableOperation(type) {
+    return Memory.Update(type, { '~immutable': true }, {});
+}
+export function AddImmutableAction(type, options) {
+    const result = Memory.Update(AddImmutableOperation(type), {}, options);
+    return result;
+}
+export function AddImmutableInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return AddImmutableAction(instantiatedType, options);
+}

package/build/type/engine/immutable/instantiate_remove.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TImmutable } from '../../types/_immutable.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveImmutableOperation<Type extends TSchema, Result extends TSchema = Type extends TImmutable<infer Type extends TSchema> ? TRemoveImmutableOperation<Type> : Type> = Result;
+export type TRemoveImmutableAction<Type extends TSchema, Result extends TSchema = TRemoveImmutableOperation<Type>> = Result;
+export declare function RemoveImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveImmutableAction<Type>;
+export type TRemoveImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveImmutableAction<InstantiateType>;
+export declare function RemoveImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveImmutableInstantiate<Context, State, Type>;
+export {};

package/build/type/engine/immutable/instantiate_remove.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+function RemoveImmutableOperation(type) {
+    return Memory.Discard(type, ['~immutable']);
+}
+export function RemoveImmutableAction(type, options) {
+    const result = Memory.Update(RemoveImmutableOperation(type), {}, options);
+    return result;
+}
+export function RemoveImmutableInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return RemoveImmutableAction(instantiatedType, options);
+}

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

@@ -1,7 +1,6 @@
 export { Instantiate, type TInstantiate } from './instantiate.mjs';
-export * from './awaited/index.mjs';
 export * from './conditional/index.mjs';
-export * from './constructor-parameters/index.mjs';
+export * from './constructor_parameters/index.mjs';
 export * from './cyclic/index.mjs';
 export * from './enum/index.mjs';
 export * from './evaluate/index.mjs';
@@ -9,23 +8,24 @@ export * from './exclude/index.mjs';
 export * from './extract/index.mjs';
 export * from './helpers/index.mjs';
 export * from './indexed/index.mjs';
-export * from './instance-type/index.mjs';
+export * from './instance_type/index.mjs';
 export * from './interface/index.mjs';
 export * from './intrinsics/index.mjs';
 export * from './keyof/index.mjs';
 export * from './mapped/index.mjs';
 export * from './module/index.mjs';
-export * from './non-nullable/index.mjs';
+export * from './non_nullable/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './options/index.mjs';
 export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
-export * from './readonly-type/index.mjs';
+export * from './priority/index.mjs';
+export * from './readonly_object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';
-export * from './return-type/index.mjs';
-export * from './template-literal/index.mjs';
+export * from './return_type/index.mjs';
+export * from './template_literal/index.mjs';
+export * from './with/index.mjs';

package/build/type/engine/index.mjs

@@ -5,9 +5,8 @@ export { Instantiate } from './instantiate.mjs';
 // ------------------------------------------------------------------
 // Engine: Internals
 // ------------------------------------------------------------------
-export * from './awaited/index.mjs';
 export * from './conditional/index.mjs';
-export * from './constructor-parameters/index.mjs';
+export * from './constructor_parameters/index.mjs';
 export * from './cyclic/index.mjs';
 export * from './enum/index.mjs';
 export * from './evaluate/index.mjs';
@@ -15,23 +14,24 @@ export * from './exclude/index.mjs';
 export * from './extract/index.mjs';
 export * from './helpers/index.mjs';
 export * from './indexed/index.mjs';
-export * from './instance-type/index.mjs';
+export * from './instance_type/index.mjs';
 export * from './interface/index.mjs';
 export * from './intrinsics/index.mjs';
 export * from './keyof/index.mjs';
 export * from './mapped/index.mjs';
 export * from './module/index.mjs';
-export * from './non-nullable/index.mjs';
+export * from './non_nullable/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './options/index.mjs';
 export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
-export * from './readonly-type/index.mjs';
+export * from './priority/index.mjs';
+export * from './readonly_object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';
-export * from './return-type/index.mjs';
-export * from './template-literal/index.mjs';
+export * from './return_type/index.mjs';
+export * from './template_literal/index.mjs';
+export * from './with/index.mjs';

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

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.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>, Result extends string[] = TFromType<Target>> = Result;
 export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/build/type/engine/{object/from-cyclic.mjs → indexable/from_cyclic.mjs}

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-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/indexable/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 string[] = 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/indexable/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/indexable/from_enum.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEnumValue } from '../../types/enum.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+export type TFromEnum<Values extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Values>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromEnum<Values extends TEnumValue[]>(values: [...Values]): TFromEnum<Values>;

package/build/type/engine/indexable/from_enum.mjs

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

package/build/type/engine/indexable/{from-intersect.d.mts → from_intersect.d.mts}

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

package/build/type/engine/indexable/{from-intersect.mjs → from_intersect.mjs}

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

package/build/type/engine/indexable/{from-literal.d.mts → from_literal.d.mts}

@@ -1,3 +1,3 @@
-import { TLiteralValue } from '../../types/literal.mjs';
+import { type TLiteralValue } from '../../types/literal.mjs';
 export type TFromLiteral<Value extends TLiteralValue, Result extends string[] = [`${Value}`]> = Result;
 export declare function FromLiteral<Value extends TLiteralValue>(value: Value): TFromLiteral<Value>;

package/build/type/engine/indexable/from_template_literal.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+export type TFromTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromTemplateLiteral<Pattern extends string>(pattern: Pattern): TFromTemplateLiteral<Pattern>;

package/build/type/engine/indexable/from_template_literal.mjs

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

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

@@ -0,0 +1,19 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
+import { type TFromEnum } from './from_enum.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromLiteral } from './from_literal.mjs';
+import { type TFromTemplateLiteral } from './from_template_literal.mjs';
+import { type TFromUnion } from './from_union.mjs';
+export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+])> = Result;
+export declare function FromType<Indexer extends TSchema>(type: Indexer): TFromType<Indexer>;