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

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

@@ -1,13 +1,8 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsAny } from '../../types/any.mjs';
-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 { Never } from '../../types/never.mjs';
-import { IsObject } from '../../types/object.mjs';
-import { IsRecord } from '../../types/record.mjs';
-import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { KeyOfDeferred } from '../../action/keyof.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
@@ -15,31 +10,20 @@ import { CollapseToObject } from '../object/index.mjs';
 // ------------------------------------------------------------------
 // Computed
 // ------------------------------------------------------------------
-import { FromAny } from './from-any.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromRecord } from './from-record.mjs';
-import { FromTuple } from './from-tuple.mjs';
+import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
-    const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
-        type);
+    const result = (IsCyclic(type) ||
+        IsDependent(type) ||
+        IsIntersect(type) ||
+        IsUnion(type)) ? CollapseToObject(type) : type;
     return result;
 }
-export function KeyOfAction(type) {
-    const normal = NormalizeType(type);
-    return (IsAny(normal) ? FromAny() :
-        IsArray(normal) ? FromArray(normal.items) :
-            IsObject(normal) ? FromObject(normal.properties) :
-                IsRecord(normal) ? FromRecord(normal) :
-                    IsTuple(normal) ? FromTuple(normal.items) :
-                        Never());
-}
-export function KeyOfImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(KeyOfAction(instantiatedType), {}, options);
+export function KeyOfAction(type, options) {
+    return (CanInstantiate([type])
+        ? Memory.Update(FromType(NormalizeType(type)), {}, options)
+        : KeyOfDeferred(type, options));
 }
 export function KeyOfInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? KeyOfImmediate(context, state, type, options)
-        : KeyOfDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return KeyOfAction(instantiatedType, options);
 }

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

@@ -1,25 +1,10 @@
-import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
-import { type TLiteral } from '../../types/literal.mjs';
-import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TIdentifier } from '../../types/identifier.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TMappedDeferred } from '../../action/mapped.mjs';
-import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-import { type TMappedVariants } from './mapped-variants.mjs';
-import { type TEvaluateIntersect } from '../evaluate/index.mjs';
-type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedAs> = Result;
-type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
-    [_ in Identifier['name']]: Variant;
-}>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {
-    [_ in CanonicalAs['const']]: InstantiatedProperty;
-} : {}> = Result;
-type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variants extends TSchema[], As extends TSchema, Property extends TSchema, Result extends TProperties[] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Property, [...Result, TMappedVariant<Context, State, Identifier, Left, As, Property>]> : Result);
-type TReduceProperties<Properties extends TProperties[], Result extends TSchema[] = []> = (Properties extends [infer Left extends TProperties, ...infer Right extends TProperties[]] ? TReduceProperties<Right, [...Result, TObject<Left>]> : Result);
-type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Variants extends TSchema[] = TMappedVariants<Type>, MappedProperties extends TProperties[] = TMappedProperties<Context, State, Identifier, Variants, As, Property>, MappedObjects extends TSchema[] = TReduceProperties<MappedProperties>, Result extends TSchema = TEvaluateIntersect<MappedObjects>> = Result;
-type TMappedImmediate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstantiatedType, As, Property>;
-export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TMappedImmediate<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>;
+import { type TMappedOperation } from './mapped_operation.mjs';
+export type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TMappedOperation<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>> = Result;
+export declare function MappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedAction<Context, State, Identifier, Type, As, Property>;
+export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstaniatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstaniatedType, As, Property>;
 export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Type, As, Property>;
-export {};

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

@@ -1,50 +1,15 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
-import { Object } from '../../types/object.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
 import { MappedDeferred } from '../../action/mapped.mjs';
-import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-import { MappedVariants } from './mapped-variants.mjs';
-import { EvaluateIntersect } from '../evaluate/index.mjs';
-function CanonicalAs(instantiatedAs) {
-    const result = IsTemplateLiteral(instantiatedAs) ? TemplateLiteralDecode(instantiatedAs.pattern) : instantiatedAs;
+import { MappedOperation } from './mapped_operation.mjs';
+export function MappedAction(context, state, identifier, type, as, property, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(MappedOperation(context, state, identifier, type, as, property), {}, options)
+        : MappedDeferred(identifier, type, as, property, options);
     return result;
 }
-function MappedVariant(context, state, identifier, variant, as, property) {
-    const variantContext = Memory.Assign(context, { [identifier['name']]: variant });
-    const instantiatedAs = InstantiateType(variantContext, state, as);
-    const canonicalAs = CanonicalAs(instantiatedAs);
-    const instantiatedProperty = InstantiateType(variantContext, state, property);
-    return (IsLiteralNumber(canonicalAs) || IsLiteralString(canonicalAs)
-        ? { [canonicalAs.const]: instantiatedProperty }
-        : {});
-}
-function MappedProperties(context, state, identifier, variants, as, property) {
-    return variants.reduce((result, left) => {
-        return [...result, MappedVariant(context, state, identifier, left, as, property)];
-    }, []);
-}
-function MappedObjects(properties) {
-    return properties.reduce((result, left) => {
-        return [...result, Object(left)];
-    }, []);
-}
-function MappedAction(context, state, identifier, type, as, property) {
-    const variants = MappedVariants(type);
-    const mappedProperties = MappedProperties(context, state, identifier, variants, as, property);
-    const mappedObjects = MappedObjects(mappedProperties);
-    const result = EvaluateIntersect(mappedObjects);
-    return result;
-}
-function MappedImmediate(context, state, identifier, type, as, property, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(MappedAction(context, state, identifier, instantiatedType, as, property), {}, options);
-}
 export function MappedInstantiate(context, state, identifier, type, as, property, options) {
-    return (CanInstantiate(context, [type])
-        ? MappedImmediate(context, state, identifier, type, as, property, options)
-        : MappedDeferred(identifier, type, as, property, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return MappedAction(context, state, identifier, instantiatedType, as, property, options);
 }

package/build/type/engine/mapped/mapped_operation.d.mts

@@ -0,0 +1,22 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TIdentifier } from '../../types/identifier.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TInstantiateType, type TState } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { type TMappedVariants } from './mapped_variants.mjs';
+type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : InstantiatedAs> = Result;
+type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
+    [_ in Identifier['name']]: Variant;
+}>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {
+    [_ in CanonicalAs['const']]: InstantiatedProperty;
+} : {}> = Result;
+type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variants extends TSchema[], As extends TSchema, Property extends TSchema, Result extends TProperties[] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Property, [...Result, TMappedVariant<Context, State, Identifier, Left, As, Property>]> : Result);
+type TReduceProperties<Properties extends TProperties[], Result extends TSchema[] = []> = (Properties extends [infer Left extends TProperties, ...infer Right extends TProperties[]] ? TReduceProperties<Right, [...Result, TObject<Left>]> : Result);
+export type TMappedOperation<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Variants extends TSchema[] = TMappedVariants<Type>, MappedProperties extends TProperties[] = TMappedProperties<Context, State, Identifier, Variants, As, Property>, MappedObjects extends TSchema[] = TReduceProperties<MappedProperties>, Result extends TSchema = TEvaluateIntersect<MappedObjects>> = Result;
+export declare function MappedOperation<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property): TMappedOperation<Context, State, Identifier, Type, As, Property>;
+export {};

package/build/type/engine/mapped/mapped_operation.mjs

@@ -0,0 +1,42 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
+import { Object } from '../../types/object.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { MappedVariants } from './mapped_variants.mjs';
+function CanonicalAs(instantiatedAs) {
+    const result = IsTemplateLiteral(instantiatedAs)
+        ? EvaluateTemplateLiteral(instantiatedAs.pattern)
+        : instantiatedAs;
+    return result;
+}
+function MappedVariant(context, state, identifier, variant, as, property) {
+    const variantContext = Memory.Assign(context, { [identifier['name']]: variant });
+    const instantiatedAs = InstantiateType(variantContext, state, as);
+    const canonicalAs = CanonicalAs(instantiatedAs);
+    const instantiatedProperty = InstantiateType(variantContext, state, property);
+    return (IsLiteralNumber(canonicalAs) || IsLiteralString(canonicalAs)
+        ? { [canonicalAs.const]: instantiatedProperty }
+        : {});
+}
+function MappedProperties(context, state, identifier, variants, as, property) {
+    return variants.reduce((result, left) => {
+        return [...result, MappedVariant(context, state, identifier, left, as, property)];
+    }, []);
+}
+function MappedObjects(properties) {
+    return properties.reduce((result, left) => {
+        return [...result, Object(left)];
+    }, []);
+}
+export function MappedOperation(context, state, identifier, type, as, property) {
+    const variants = MappedVariants(type);
+    const mappedProperties = MappedProperties(context, state, identifier, variants, as, property);
+    const mappedObjects = MappedObjects(mappedProperties);
+    const result = EvaluateIntersect(mappedObjects);
+    return result;
+}

package/build/type/engine/mapped/mapped_variants.d.mts

@@ -0,0 +1,17 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+type TFromTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
+type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+type TFromEnum<Values extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Values>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
+type TFromLiteral<Value extends TLiteralValue, Result extends TSchema[] = Value extends number ? [TLiteral<`${Value}`>] : [TLiteral<Value>]> = Result;
+type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Type extends TLiteral<infer Value extends number> ? TFromLiteral<Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+    Type
+])> = Result;
+export type TMappedVariants<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;
+export declare function MappedVariants<Type extends TSchema>(type: Type): TMappedVariants<Type>;
+export {};

package/build/type/engine/mapped/mapped_variants.mjs

@@ -0,0 +1,39 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Literal, IsLiteral } from '../../types/literal.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+function FromTemplateLiteral(pattern) {
+    const evaluated = EvaluateTemplateLiteral(pattern);
+    const result = FromType(evaluated);
+    return result;
+}
+function FromUnion(types) {
+    return types.reduce((result, left) => {
+        return [...result, ...FromType(left)];
+    }, []);
+}
+function FromEnum(values) {
+    const evaluated = EvaluateEnum(values);
+    const result = FromType(evaluated);
+    return result;
+}
+function FromLiteral(value) {
+    const result = Guard.IsNumber(value) ? [Literal(`${value}`)] : [Literal(value)];
+    return result;
+}
+function FromType(type) {
+    const result = (IsEnum(type) ? FromEnum(type.enum) :
+        IsLiteral(type) ? FromLiteral(type.const) :
+            IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    [type]);
+    return result;
+}
+export function MappedVariants(type) {
+    const result = FromType(type);
+    return result;
+}

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

@@ -5,17 +5,15 @@ import { type TState } from '../instantiate.mjs';
 import { type TCyclicCandidates } from '../cyclic/candidates.mjs';
 import { type TInstantiateCyclic } from '../cyclic/instantiate.mjs';
 import { type TInstantiateType } from '../instantiate.mjs';
-type TInstantiateCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
-    [Key in Extract<keyof Context, CyclicKeys[number]>]: TInstantiateCyclic<Context, Key, Context[Key]>;
+type TInstantiateCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Extract<keyof Declarations, CyclicKeys[number]>]: TInstantiateCyclic<DeclarationContext, Key, Declarations[Key]>;
 }> = Result;
-type TInstantiateNonCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
-    [Key in Exclude<keyof Context, CyclicKeys[number]>]: TInstantiateType<Context, {
-        callstack: [];
-    }, Context[Key]>;
+type TInstantiateNonCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Exclude<keyof Declarations, CyclicKeys[number]>]: TInstantiateType<DeclarationContext, TState<[], []>, Declarations[Key]>;
 }> = Result;
-type TInstantiateModule<Context extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Context>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
+type TInstantiateModule<Context extends TProperties, Declarations extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Declarations>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, Declarations, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, Declarations, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
     [Key in keyof InstantiatedModule]: InstantiatedModule[Key];
 } & {};
-export type TModuleInstantiate<Context extends TProperties, _State extends TState, Properties extends TProperties, ModuleContext extends TProperties = Memory.TAssign<Context, Properties>, InstantiatedModule extends TProperties = TInstantiateModule<ModuleContext>> = InstantiatedModule;
-export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, _state: State, properties: Properties, options: TSchemaOptions): TModuleInstantiate<Context, State, Properties>;
+export type TModuleInstantiate<Context extends TProperties, _State extends TState, Declarations extends TProperties, InstantiatedModule extends TProperties = TInstantiateModule<Context, Declarations>> = InstantiatedModule;
+export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Declarations extends TProperties>(context: Context, _state: State, declarations: Declarations, options: TSchemaOptions): TModuleInstantiate<Context, State, Declarations>;
 export {};

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

@@ -2,33 +2,35 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Memory } from '../../../system/memory/index.mjs';
+import { State } from '../instantiate.mjs';
 // ------------------------------------------------------------------
 // Module: Instantiation Infrastructure
 // ------------------------------------------------------------------
 import { CyclicCandidates } from '../cyclic/candidates.mjs';
 import { InstantiateCyclic } from '../cyclic/instantiate.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function InstantiateCyclics(context, cyclicKeys) {
-    const keys = Guard.Keys(context).filter(key => cyclicKeys.includes(key));
-    return keys.reduce((result, key) => {
-        return { ...result, [key]: InstantiateCyclic(context, key, context[key]) };
+function InstantiateCyclics(context, declarations, cyclicKeys) {
+    const declarationContext = Memory.Assign(context, declarations);
+    const declarationKeys = Guard.Keys(declarations).filter(key => cyclicKeys.includes(key));
+    return declarationKeys.reduce((result, key) => {
+        return { ...result, [key]: InstantiateCyclic(declarationContext, key, declarations[key]) };
     }, {});
 }
-function InstantiateNonCyclics(context, cyclicKeys) {
-    const keys = Guard.Keys(context).filter(key => !cyclicKeys.includes(key));
-    return keys.reduce((result, key) => {
-        return { ...result, [key]: InstantiateType(context, { callstack: [] }, context[key]) };
+function InstantiateNonCyclics(context, declarations, cyclicKeys) {
+    const declarationContext = Memory.Assign(context, declarations);
+    const declarationKeys = Guard.Keys(declarations).filter(key => !cyclicKeys.includes(key));
+    return declarationKeys.reduce((result, key) => {
+        return { ...result, [key]: InstantiateType(declarationContext, State([], []), declarations[key]) };
     }, {});
 }
-function InstantiateModule(context, options) {
-    const cyclicCandidates = CyclicCandidates(context);
-    const instantiatedCyclics = InstantiateCyclics(context, cyclicCandidates);
-    const instantiatedNonCyclics = InstantiateNonCyclics(context, cyclicCandidates);
+function InstantiateModule(context, declarations, options) {
+    const cyclicCandidates = CyclicCandidates(declarations);
+    const instantiatedCyclics = InstantiateCyclics(context, declarations, cyclicCandidates);
+    const instantiatedNonCyclics = InstantiateNonCyclics(context, declarations, cyclicCandidates);
     const instantiatedModule = { ...instantiatedCyclics, ...instantiatedNonCyclics };
     return Memory.Update(instantiatedModule, {}, options);
 }
-export function ModuleInstantiate(context, _state, properties, options) {
-    const moduleContext = Memory.Assign(context, properties);
-    const instantiatedModule = InstantiateModule(moduleContext, options);
+export function ModuleInstantiate(context, _state, declarations, options) {
+    const instantiatedModule = InstantiateModule(context, declarations, options);
     return instantiatedModule;
 }

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TNull } from '../../types/null.mjs';
+import { type TUndefined } from '../../types/undefined.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExcludeAction } from '../exclude/instantiate.mjs';
+import { type TNonNullableDeferred } from '../../action/non_nullable.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TNonNullableOperation<Type extends TSchema, Excluded extends TSchema = TUnion<[TNull, TUndefined]>> = TExcludeAction<Type, Excluded>;
+export type TNonNullableAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TNonNullableOperation<Type> : TNonNullableDeferred<Type>> = Result;
+export declare function NonNullableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TNonNullableAction<Type>;
+export type TNonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TNonNullableAction<InstantiatedType>;
+export declare function NonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TNonNullableInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,22 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Null } from '../../types/null.mjs';
+import { Undefined } from '../../types/undefined.mjs';
+import { Union } from '../../types/union.mjs';
+import { ExcludeAction } from '../exclude/instantiate.mjs';
+import { NonNullableDeferred } from '../../action/non_nullable.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function NonNullableOperation(type) {
+    const excluded = Union([Null(), Undefined()]);
+    return ExcludeAction(type, excluded, {});
+}
+export function NonNullableAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(NonNullableOperation(type), {}, options)
+        : NonNullableDeferred(type, options);
+    return result;
+}
+export function NonNullableInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return NonNullableAction(instantiatedType, options);
+}

package/build/type/engine/object/collapse.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 export type TCollapseToObject<Type extends TSchema, Properties extends TProperties = TFromType<Type>, Result extends TSchema = TObject<Properties>> = Result;
 /**
  * Collapses a type into a TObject schema. This is a lossy fast path used to

package/build/type/engine/object/collapse.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Object } from '../../types/object.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 /**
  * Collapses a type into a TObject schema. This is a lossy fast path used to
  * normalize arbitrary TSchema types into a TObject structure. This function is

package/build/type/engine/object/{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 TProperties = TFromType<Target>> = Result;
 export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/build/type/engine/{indexable/from-cyclic.mjs → object/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/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/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/object/{from-intersect.d.mts → from_intersect.d.mts}

@@ -1,7 +1,7 @@
 import { Memory } from '../../../system/memory/index.mjs';
 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 TEvaluateIntersect } from '../evaluate/evaluate.mjs';
 type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties, LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>, RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>, SharedKeys extends keyof Left & keyof Right = Extract<keyof Left, keyof Right>, LeftProperties extends TProperties = {
     [Key in LeftKeys]: Left[Key];

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

@@ -2,7 +2,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 function CollapseIntersectProperties(left, right) {
     const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key));

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

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TTupleToObject } from '../tuple/to-object.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TTupleToObject } from '../tuple/to_object.mjs';
+import { type TFromType } from './from_type.mjs';
 export type TFromTuple<Types extends TSchema[], Object extends TSchema = TTupleToObject<TTuple<Types>>, Result extends TSchema = TFromType<Object>> = Result;
 export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Tuple } from '../../types/tuple.mjs';
-import { TupleToObject } from '../tuple/to-object.mjs';
-import { FromType } from './from-type.mjs';
+import { TupleToObject } from '../tuple/to_object.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTuple(types) {
     const object = TupleToObject(Tuple(types));
     const result = FromType(object);

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

@@ -0,0 +1,16 @@
+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 TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.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 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, Result extends TProperties = (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 TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -0,0 +1,23 @@
+// 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 { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.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 { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.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) :
+                    IsTuple(type) ? FromTuple(type.items) :
+                        IsObject(type) ? FromObject(type.properties) :
+                            {});
+}

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

@@ -2,7 +2,7 @@ import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 type TCollapseUnionProperties<Left extends TProperties, Right extends TProperties, SharedKeys extends PropertyKey = keyof Left & keyof Right, Result extends TProperties = {
     [Key in SharedKeys]: TEvaluateUnion<[Left[Key], Right[Key]]>;
 }> = Result;

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

@@ -1,9 +1,8 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
+import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { EvaluateUnion } from '../evaluate/evaluate.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 function CollapseUnionProperties(left, right) {
     const sharedKeys = Guard.Keys(left).filter((key) => key in right);
     const result = sharedKeys.reduce((result, key) => {
@@ -12,15 +11,9 @@ function CollapseUnionProperties(left, right) {
     return result;
 }
 function ReduceVariants(types, result) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? ReduceVariants(right, CollapseUnionProperties(result, FromType(left)))
-        : result);
+    return Guard.ShiftLeft(types, (left, right) => ReduceVariants(right, CollapseUnionProperties(result, FromType(left))), () => result);
 }
 export function FromUnion(types) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? ReduceVariants(right, FromType(left))
-        : Unreachable());
+    return Guard.ShiftLeft(types, (left, right) => ReduceVariants(right, FromType(left)), () => Unreachable());
 }
 // deno-coverage-ignore-stop

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

@@ -0,0 +1,12 @@
+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 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;
+export type TFromType<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;
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;
+export {};