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

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

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { ToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { ToIndexable } from '../indexable/to_indexable.mjs';
+function FromKeys(properties, keys) {
+    const result = Guard.Keys(properties).reduce((result, key) => {
+        return keys.includes(key) ? result : { ...result, [key]: properties[key] };
+    }, {});
+    return result;
+}
+export function FromType(type, indexer) {
+    const indexable = ToIndexable(type);
+    const indexableKeys = ToIndexableKeys(indexer);
+    const omitted = FromKeys(indexable, indexableKeys);
+    const result = Object(omitted);
+    return result;
+}

package/build/type/engine/omit/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 TObject } from '../../types/object.mjs';
-import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { type TToIndexable } from '../indexable/to-indexable.mjs';
 import { type TOmitDeferred } from '../../action/omit.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TNormalKeys<Keys extends string[], UnionKeys extends string = Keys[number], Result extends string | number = (UnionKeys extends `${infer Value extends number}` ? UnionKeys | Value : UnionKeys)> = Result;
-type TFromKeys<Properties extends TProperties, Keys extends string[], Omitted extends TProperties = Omit<Properties, TNormalKeys<Keys>>, Result extends TProperties = {
-    [Key in keyof Omitted]: Omitted[Key];
-}> = Result;
-type TOmitAction<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, IndexableKeys extends string[] = TToIndexableKeys<Indexer>, Omitted extends TProperties = TFromKeys<Indexable, IndexableKeys>, Result extends TSchema = TObject<Omitted>> = Result;
-type TOmitImmediate<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>, Result extends TSchema = TOmitAction<InstantiatedType, InstantiatedIndexer>> = Result;
-export type TOmitInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TOmitImmediate<Context, State, Type, Indexer> : TOmitDeferred<Type, Indexer>;
+import { type TFromType } from './from_type.mjs';
+export type TOmitAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<Type, Indexer> : TOmitDeferred<Type, Indexer>> = Result;
+export declare function OmitAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TOmitAction<Type, Indexer>;
+export type TOmitInstantiate<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>> = TOmitAction<InstantiatedType, InstantiatedIndexer>;
 export declare function OmitInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TOmitInstantiate<Context, State, Type, Indexer>;
-export {};

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

@@ -1,31 +1,16 @@
 // 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 { OmitDeferred } from '../../action/omit.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function FromKeys(properties, keys) {
-    const result = Guard.Keys(properties).reduce((result, key) => {
-        return keys.includes(key) ? result : { ...result, [key]: properties[key] };
-    }, {});
+import { FromType } from './from_type.mjs';
+export function OmitAction(type, indexer, options) {
+    const result = CanInstantiate([type, indexer])
+        ? Memory.Update(FromType(type, indexer), {}, options)
+        : OmitDeferred(type, indexer, options);
     return result;
 }
-function OmitAction(type, indexer) {
-    const indexable = ToIndexable(type);
-    const indexableKeys = ToIndexableKeys(indexer);
-    const omitted = FromKeys(indexable, indexableKeys);
-    const result = Object(omitted);
-    return result;
-}
-function OmitImmediate(context, state, type, indexer, options) {
+export function OmitInstantiate(context, state, type, indexer, options) {
     const instantiatedType = InstantiateType(context, state, type);
     const instantiatedIndexer = InstantiateType(context, state, indexer);
-    return Memory.Update(OmitAction(instantiatedType, instantiatedIndexer), {}, options);
-}
-export function OmitInstantiate(context, state, type, indexer, options) {
-    return (CanInstantiate(context, [type, indexer])
-        ? OmitImmediate(context, state, type, indexer, options)
-        : OmitDeferred(type, indexer, options));
+    return OmitAction(instantiatedType, instantiatedIndexer, options);
 }

package/build/type/engine/optional/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 TOptional } from '../../types/_optional.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddOptionalOperation<Type extends TSchema, Result extends TSchema = `~optional` extends keyof Type ? Type : TOptional<Type>> = Result;
+export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = TAddOptionalOperation<Type>> = Result;
+export declare function AddOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddOptionalAction<Type>;
+export type TAddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddOptionalAction<InstantiateType>;
+export declare function AddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddOptionalInstantiate<Context, State, Type>;
+export {};

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

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

package/build/type/engine/optional/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 TOptional } from '../../types/_optional.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveOptionalOperation<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalOperation<Type> : Type> = Result;
+export type TRemoveOptionalAction<Type extends TSchema, Result extends TSchema = TRemoveOptionalOperation<Type>> = Result;
+export declare function RemoveOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveOptionalAction<Type>;
+export type TRemoveOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveOptionalAction<InstantiateType>;
+export declare function RemoveOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveOptionalInstantiate<Context, State, Type>;
+export {};

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

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

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

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

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

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

package/build/type/engine/{readonly-type/from-cyclic.d.mts → partial/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/partial/{from-cyclic.mjs → 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/partial/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/partial/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/partial/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/partial/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/{readonly-type/from-object.d.mts → partial/from_object.d.mts}

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

package/build/type/engine/partial/{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 { Optional } from '../../types/_optional.mjs';
+import { AddOptional } from '../../action/_add_optional.mjs';
 export function FromObject(properties) {
     const mapped = Guard.Keys(properties).reduce((result, left) => {
-        return { ...result, [left]: Optional(properties[left]) };
+        return { ...result, [left]: AddOptional(properties[left]) };
     }, {});
     const result = Object(mapped);
     return result;

package/build/type/engine/partial/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/partial/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({}));
+}

package/build/type/engine/{readonly-type/from-union.d.mts → partial/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/{readonly-type/from-union.mjs → partial/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/partial/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 TPartialDeferred } from '../../action/partial.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TPartialImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
-export type TPartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TPartialImmediate<Context, State, Type> : TPartialDeferred<Type>;
+export type TPartialAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TPartialDeferred<Type>> = Result;
+export declare function PartialAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TPartialAction<Type>;
+export type TPartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TPartialAction<InstantiatedType>;
 export declare function PartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TPartialInstantiate<Context, State, Type>;
-export {};

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export * from './priority.mjs';

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

@@ -0,0 +1 @@
+export * from './priority.mjs';

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

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCompare, type TCompareResult } from '../evaluate/compare.mjs';
+type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends 'right-inside' ? 1 : CompareResult extends 'disjoint' ? 1 : 0)> = Result;
+type TInsert<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TComparer<Type, Left> extends 1 ? TInsert<Type, Right, [...Result, Left]> : [...Result, Type, ...Types] : [...Result, Type]);
+type TSort<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TSort<Right, TInsert<Left, Result>> : Result);
+/**
+ * Priority sorts types in sequence of narrowest to broadest using an Insertion Sort
+ * algorithm. This function is typically used to sequence types for union variant
+ * checks to ensure that values are checked against the most narrow types before
+ * the broadest, which in turn helps ensure order-independent Union checking.
+ */
+export type TPriority<Types extends TSchema[], Result extends TSchema[] = TSort<Types>> = Result;
+/**
+ * Priority sorts types in sequence of narrowest to broadest using an Insertion Sort
+ * algorithm. This function is typically used to sequence types for union variant
+ * checks to ensure that values are checked against the most narrow types before
+ * the broadest, which in turn helps ensure order-independent Union checking.
+ */
+export declare function Priority<Types extends TSchema[]>(types: [...Types]): TPriority<Types>;
+export {};

package/build/type/engine/priority/priority.mjs

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Compare } from '../evaluate/compare.mjs';
+function Comparer(left, right) {
+    const compareResult = Compare(left, right);
+    const result = (Guard.IsEqual(compareResult, 'right-inside') ? 1 :
+        Guard.IsEqual(compareResult, 'disjoint') ? 1 :
+            0);
+    return result;
+}
+function Insert(type, types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Guard.IsEqual(Comparer(type, left), 1)
+        ? Insert(type, right, [...result, left])
+        : [...result, type, ...types], () => [...result, type]);
+}
+function Sort(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Sort(right, Insert(left, result)), () => result);
+}
+/**
+ * Priority sorts types in sequence of narrowest to broadest using an Insertion Sort
+ * algorithm. This function is typically used to sequence types for union variant
+ * checks to ensure that values are checked against the most narrow types before
+ * the broadest, which in turn helps ensure order-independent Union checking.
+ */
+export function Priority(types) {
+    const result = Sort(types);
+    return result;
+}

package/build/type/engine/readonly/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 TReadonly } from '../../types/_readonly.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddReadonlyOperation<Type extends TSchema, Result extends TSchema = `~readonly` extends keyof Type ? Type : TReadonly<Type>> = Result;
+export type TAddReadonlyAction<Type extends TSchema, Result extends TSchema = TAddReadonlyOperation<Type>> = Result;
+export declare function AddReadonlyAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddReadonlyAction<Type>;
+export type TAddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddReadonlyAction<InstantiateType>;
+export declare function AddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddReadonlyInstantiate<Context, State, Type>;
+export {};

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

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

package/build/type/engine/readonly/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 TReadonly } from '../../types/_readonly.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveReadonlyOperation<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? TRemoveReadonlyOperation<Type> : Type> = Result;
+export type TRemoveReadonlyAction<Type extends TSchema, Result extends TSchema = TRemoveReadonlyOperation<Type>> = Result;
+export declare function RemoveReadonlyAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveReadonlyAction<Type>;
+export type TRemoveReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveReadonlyAction<InstantiateType>;
+export declare function RemoveReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveReadonlyInstantiate<Context, State, Type>;
+export {};

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

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