@daniel156161/prism 0.2.60 → 0.2.76

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/call/resolve_arguments.mjs

@@ -23,10 +23,10 @@ function BindArgument(context, state, name, extends_, type) {
 function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
     const instantiatedExtends = InstantiateType(context, state, parameterLeft.extends);
     const instantiatedEquals = InstantiateType(context, state, parameterLeft.equals);
-    return Guard.TakeLeft(arguments_, (left, right) => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right), () => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
+    return Guard.ShiftLeft(arguments_, (left, right) => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right), () => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
 }
 function BindParameters(context, state, parameters, arguments_) {
-    return Guard.TakeLeft(parameters, (left, right) => BindArguments(context, state, left, right, arguments_), () => context);
+    return Guard.ShiftLeft(parameters, (left, right) => BindArguments(context, state, left, right, arguments_), () => context);
 }
 export function ResolveArgumentsContext(context, state, parameters, arguments_) {
     return BindParameters(context, state, parameters, arguments_);

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/constructor_parameters/instantiate.d.mts

@@ -3,11 +3,10 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TInstantiateElements } from '../instantiate.mjs';
-type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
-    callstack: [];
-}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+import { type TState } from '../instantiate.mjs';
+type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
 export type TConstructorParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TConstructorParametersOperation<Type> : TConstructorParametersDeferred<Type>> = Result;
 export declare function ConstructorParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TConstructorParametersAction<Type>;
 export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/constructor_parameters/instantiate.mjs

@@ -6,9 +6,10 @@ import { Tuple } from '../../types/tuple.mjs';
 import { ConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { InstantiateElements } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
 function ConstructorParametersOperation(type) {
     const parameters = IsConstructor(type) ? type['parameters'] : [];
-    const instantiatedParameters = InstantiateElements({}, { callstack: [] }, parameters);
+    const instantiatedParameters = InstantiateElements({}, State([], []), parameters);
     const result = Tuple(instantiatedParameters);
     return result;
 }

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/candidates.d.mts

@@ -1,9 +1,8 @@
-import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TProperties, type TPropertyKeys } from '../../types/properties.mjs';
 import { type TCyclicCheck } from './check.mjs';
-type TResolveCandidateKeys<Context extends TProperties, Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Context ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : TUnreachable : Result);
+type TResolveCandidateKeys<Context extends TProperties, Keys extends (keyof Context)[], Result extends (keyof Context)[] = []> = (Keys extends [infer Left extends keyof Context, ...infer Right extends (keyof Context)[]] ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : Result);
 /** Returns keys for context types that need to be transformed to TCyclic. */
-export type TCyclicCandidates<Context extends TProperties, Keys extends string[] = TPropertyKeys<Context>, Result extends string[] = TResolveCandidateKeys<Context, Keys>> = Result;
+export type TCyclicCandidates<Context extends TProperties, Keys extends (keyof Context)[] = TPropertyKeys<Context>, Result extends (keyof Context)[] = TResolveCandidateKeys<Context, Keys>> = Result;
 /** Returns keys for context types that need to be transformed to TCyclic. */
 export declare function CyclicCandidates<Context extends TProperties>(context: Context): TCyclicCandidates<Context>;
 export {};

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/candidates.mjs

@@ -1,14 +1,11 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { PropertyKeys } from '../../types/properties.mjs';
 import { CyclicCheck } from './check.mjs';
 function ResolveCandidateKeys(context, keys) {
     return keys.reduce((result, left) => {
-        return left in context
-            ? CyclicCheck([left], context, context[left])
-                ? [...result, left]
-                : result
-            : Unreachable();
+        return CyclicCheck([left], context, context[left])
+            ? [...result, left]
+            : result;
     }, []);
 }
 /** Returns keys for context types that need to be transformed to TCyclic. */

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/check.d.mts

@@ -1,24 +1,21 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TInterfaceDeferred } from '../../action/interface.mjs';
-type TFromRef<Stack extends string[], Context extends TProperties, Ref extends string> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
-type TFromProperties<Stack extends string[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
-type TFromTypes<Stack extends string[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
-type TFromType<Stack extends string[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
+type TFromRef<Stack extends (keyof Context)[], Context extends TProperties, Ref extends (keyof Context)> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
+type TFromProperties<Stack extends (keyof Context)[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
+type TFromTypes<Stack extends (keyof Context)[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
+type TFromType<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
 /** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
-export type TCyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
+export type TCyclicCheck<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
 /** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
-export declare function CyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema>(stack: [...Stack], context: Context, type: Type): TCyclicCheck<Stack, Context, Type>;
+export declare function CyclicCheck<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema>(stack: [...Stack], context: Context, type: Type): TCyclicCheck<Stack, Context, Type>;
 export {};

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/check.mjs

@@ -1,13 +1,10 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { IsArray } from '../../types/array.mjs';
-import { IsAsyncIterator } from '../../types/async_iterator.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
 import { IsFunction } from '../../types/function.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { IsIterator } from '../../types/iterator.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { IsPromise } from '../../types/promise.mjs';
 import { PropertyValues } from '../../types/properties.mjs';
 import { IsRecord, RecordValue } from '../../types/record.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
@@ -24,25 +21,22 @@ function FromProperties(stack, context, properties) {
     return FromTypes(stack, context, types);
 }
 function FromTypes(stack, context, types) {
-    return Guard.TakeLeft(types, (left, right) => FromType(stack, context, left)
+    return Guard.ShiftLeft(types, (left, right) => FromType(stack, context, left)
         ? true
         : FromTypes(stack, context, right), () => false);
 }
 function FromType(stack, context, type) {
     return (IsRef(type) ? FromRef(stack, context, type.$ref) :
         IsArray(type) ? FromType(stack, context, type.items) :
-            IsAsyncIterator(type) ? FromType(stack, context, type.iteratorItems) :
-                IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
-                    IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
-                        IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
-                            IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
-                                IsIterator(type) ? FromType(stack, context, type.iteratorItems) :
-                                    IsObject(type) ? FromProperties(stack, context, type.properties) :
-                                        IsPromise(type) ? FromType(stack, context, type.item) :
-                                            IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
-                                                IsTuple(type) ? FromTypes(stack, context, type.items) :
-                                                    IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
-                                                        false);
+            IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
+                IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
+                    IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
+                        IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
+                            IsObject(type) ? FromProperties(stack, context, type.properties) :
+                                IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
+                                    IsTuple(type) ? FromTypes(stack, context, type.items) :
+                                        IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
+                                            false);
 }
 /** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
 export function CyclicCheck(stack, context, type) {

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/dependencies.d.mts

@@ -1,13 +1,10 @@
 import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
@@ -17,7 +14,7 @@ import { type TInterfaceDeferred } from '../../action/interface.mjs';
 type TFromRef<Context extends TProperties, Ref extends string, Dependencies extends string[]> = Ref extends Dependencies[number] ? Dependencies : Ref extends keyof Context ? TFromType<Context, Context[Ref], [...Dependencies, Ref]> : TUnreachable;
 type TFromProperties<Context extends TProperties, Properties extends TProperties, Dependencies extends string[], Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Context, Types, Dependencies>;
 type TFromTypes<Context extends TProperties, Types extends TSchema[], Dependencies extends string[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Context, Right, TFromType<Context, Left, Dependencies>> : Dependencies;
-type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
+type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
 /** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
 export type TCyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema, Result extends string[] = TFromType<Context, Type, [Key]>> = Result;
 /** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/dependencies.mjs

@@ -1,13 +1,10 @@
 // deno-fmt-ignore-file
 import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { IsArray } from '../../types/array.mjs';
-import { IsAsyncIterator } from '../../types/async_iterator.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
 import { IsFunction } from '../../types/function.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { IsIterator } from '../../types/iterator.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { IsPromise } from '../../types/promise.mjs';
 import { PropertyValues } from '../../types/properties.mjs';
 import { IsRecord, RecordValue } from '../../types/record.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
@@ -33,18 +30,15 @@ function FromTypes(context, types, result) {
 function FromType(context, type, result) {
     return (IsRef(type) ? FromRef(context, type.$ref, result) :
         IsArray(type) ? FromType(context, type.items, result) :
-            IsAsyncIterator(type) ? FromType(context, type.iteratorItems, result) :
-                IsConstructor(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
-                    IsFunction(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
-                        IsInterfaceDeferred(type) ? FromProperties(context, type.parameters[1], result) :
-                            IsIntersect(type) ? FromTypes(context, type.allOf, result) :
-                                IsIterator(type) ? FromType(context, type.iteratorItems, result) :
-                                    IsObject(type) ? FromProperties(context, type.properties, result) :
-                                        IsPromise(type) ? FromType(context, type.item, result) :
-                                            IsUnion(type) ? FromTypes(context, type.anyOf, result) :
-                                                IsTuple(type) ? FromTypes(context, type.items, result) :
-                                                    IsRecord(type) ? FromType(context, RecordValue(type), result) :
-                                                        result);
+            IsConstructor(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
+                IsFunction(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
+                    IsInterfaceDeferred(type) ? FromProperties(context, type.parameters[1], result) :
+                        IsIntersect(type) ? FromTypes(context, type.allOf, result) :
+                            IsObject(type) ? FromProperties(context, type.properties, result) :
+                                IsUnion(type) ? FromTypes(context, type.anyOf, result) :
+                                    IsTuple(type) ? FromTypes(context, type.items, result) :
+                                        IsRecord(type) ? FromType(context, RecordValue(type), result) :
+                                            result);
 }
 /** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
 export function CyclicDependencies(context, key, type) {

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/extends.d.mts

@@ -1,14 +1,11 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TAny } from '../../types/any.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TRef } from '../../types/ref.mjs';
@@ -22,7 +19,7 @@ type TFromProperties<Properties extends TProperties, Result extends TProperties
     [Key in keyof Result]: Result[Key];
 };
 type TFromTypes<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, [...Result, TFromType<Left>]> : Result;
-type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
+type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
 type TCyclicAnyFromParameters<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? TFromType<Defs[Ref]> : TUnknown);
 /** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
 export type TCyclicExtends<Type extends TCyclic, Result extends TSchema = TCyclicAnyFromParameters<Type['$defs'], Type['$ref']>> = Result;

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/extends.mjs

@@ -2,13 +2,10 @@
 import { Guard } from '../../../guard/index.mjs';
 import { Any } from '../../types/any.mjs';
 import { Array as _Array_, IsArray, ArrayOptions } from '../../types/array.mjs';
-import { AsyncIterator, IsAsyncIterator } from '../../types/async_iterator.mjs';
 import { Constructor, IsConstructor } from '../../types/constructor.mjs';
 import { Function as _Function_, IsFunction } from '../../types/function.mjs';
 import { Intersect, IsIntersect } from '../../types/intersect.mjs';
-import { Iterator, IsIterator } from '../../types/iterator.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
-import { Promise, IsPromise } from '../../types/promise.mjs';
 import { IsRecord, Record, RecordKey, RecordValue } from '../../types/record.mjs';
 import { IsRef } from '../../types/ref.mjs';
 import { Tuple, IsTuple } from '../../types/tuple.mjs';
@@ -30,17 +27,14 @@ function FromTypes(types) {
 function FromType(type) {
     return (IsRef(type) ? FromRef(type.$ref) :
         IsArray(type) ? _Array_(FromType(type.items), ArrayOptions(type)) :
-            IsAsyncIterator(type) ? AsyncIterator(FromType(type.iteratorItems)) :
-                IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
-                    IsFunction(type) ? _Function_(FromTypes(type.parameters), FromType(type.returnType)) :
-                        IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
-                            IsIterator(type) ? Iterator(FromType(type.iteratorItems)) :
-                                IsObject(type) ? Object(FromProperties(type.properties)) :
-                                    IsPromise(type) ? Promise(FromType(type.item)) :
-                                        IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
-                                            IsUnion(type) ? Union(FromTypes(type.anyOf)) :
-                                                IsTuple(type) ? Tuple(FromTypes(type.items)) :
-                                                    type);
+            IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
+                IsFunction(type) ? _Function_(FromTypes(type.parameters), FromType(type.returnType)) :
+                    IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
+                        IsObject(type) ? Object(FromProperties(type.properties)) :
+                            IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
+                                IsUnion(type) ? Union(FromTypes(type.anyOf)) :
+                                    IsTuple(type) ? Tuple(FromTypes(type.items)) :
+                                        type);
 }
 function CyclicAnyFromParameters(defs, ref) {
     return (ref in defs

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/instantiate.d.mts

@@ -6,12 +6,9 @@ import { type TCyclicDependencies } from '../cyclic/dependencies.mjs';
 import { type TInterfaceDeferred } from '../../action/index.mjs';
 import { type TInstantiateProperties } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
-    callstack: [];
-}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, {
-    callstack: [];
-}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, TState<[], []>, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, TState<[], []>, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
 type TCyclicDefinitions<Context extends TProperties, Dependencies extends string[], Result extends TProperties = {
     [Key in Extract<keyof Context, Dependencies[number]>]: Context[Key] extends TInterfaceDeferred<infer Heritage extends TSchema[], infer Properties extends TProperties> ? TCyclicInterface<Context, Heritage, Properties> : Context[Key];
 }> = Result;

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/cyclic/instantiate.mjs

@@ -7,10 +7,11 @@ import { CyclicDependencies } from '../cyclic/dependencies.mjs';
 import { IsInterfaceDeferred } from '../../action/index.mjs';
 import { InstantiateProperties } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 function CyclicInterface(context, heritage, properties) {
-    const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
-    const instantiatedProperties = InstantiateProperties({}, { callstack: [] }, properties);
+    const instantiatedHeritage = InstantiateTypes(context, State([], []), heritage);
+    const instantiatedProperties = InstantiateProperties({}, State([], []), properties);
     const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object(instantiatedProperties)]);
     return evaluatedInterface;
 }

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/enum/index.d.mts

@@ -1,2 +1 @@
-export * from './enum_to_union.mjs';
 export * from './typescript_enum_to_enum_values.mjs';

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/enum/index.mjs

@@ -1,2 +1 @@
-export * from './enum_to_union.mjs';
 export * from './typescript_enum_to_enum_values.mjs';

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/evaluate/broaden.d.mts

@@ -2,7 +2,6 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TUnion } from '../../types/union.mjs';
 import { type TCompare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
 import { type TFlatten } from './flatten.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
@@ -10,7 +9,7 @@ type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends
 type TIsBroadestType<Type extends TSchema, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultLeftInside | typeof ResultEqual ? false : TIsBroadestType<Type, Right> : true);
 type TBroadenType<Type extends TSchema, Types extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>, Result extends TSchema[] = (Evaluated extends TAny ? [Evaluated] : TIsBroadestType<Evaluated, Types> extends true ? [...TBroadFilter<Evaluated, Types>, Evaluated] : Types)> = Result;
 type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : Left extends TNever ? TBroadenTypes<Right, Result> : TBroadenTypes<Right, TBroadenType<Left, Result>>) : Result);
-export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>, Result extends TSchema = (Flattened extends [] ? TNever : Flattened extends [infer Type extends TSchema] ? Type : TUnion<Flattened>)> = Result;
+export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>> = Flattened;
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export declare function Broaden<Types extends TSchema[]>(types: [...Types]): TBroaden<Types>;
 export {};

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/evaluate/broaden.mjs

@@ -1,9 +1,8 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { IsAny } from '../../types/any.mjs';
-import { Never, IsNever } from '../../types/never.mjs';
+import { IsNever } from '../../types/never.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { Union } from '../../types/union.mjs';
 import { Compare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
 import { Flatten } from './flatten.mjs';
 import { EvaluateType } from './evaluate.mjs';
@@ -40,8 +39,5 @@ function BroadenTypes(types) {
 export function Broaden(types) {
     const broadened = BroadenTypes(types);
     const flattened = Flatten(broadened);
-    const result = (flattened.length === 0 ? Never() :
-        flattened.length === 1 ? flattened[0] :
-            Union(flattened));
-    return result;
+    return flattened;
 }

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/evaluate/composite.d.mts

@@ -1,25 +1,29 @@
 import { type TUnreachable } from '../../../system/unreachable/index.mjs';
-import { type TReadonly, type TReadonlyAdd, type TReadonlyRemove } from '../../types/_readonly.mjs';
-import { type TOptional, type TOptionalAdd, type TOptionalRemove } from '../../types/_optional.mjs';
+import { type TReadonly } from '../../types/_readonly.mjs';
+import { type TOptional } from '../../types/_optional.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
+import { type TAddReadonly } from '../../action/_add_readonly.mjs';
+import { type TAddOptional } from '../../action/_add_optional.mjs';
+import { type TRemoveReadonly } from '../../action/_remove_readonly.mjs';
+import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
 import { type TTupleElementsToProperties } from '../tuple/to_object.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
 type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
 type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
-type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TReadonlyRemove<TOptionalRemove<Evaluated>>> = ([
+type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TRemoveReadonly<TRemoveOptional<Evaluated>>> = ([
     IsReadonly,
     IsOptional
-] extends [true, true] ? TReadonlyAdd<TOptionalAdd<Property>> : [
+] extends [true, true] ? TAddReadonly<TAddOptional<Property>> : [
     IsReadonly,
     IsOptional
-] extends [true, false] ? TReadonlyAdd<Property> : [
+] extends [true, false] ? TAddReadonly<Property> : [
     IsReadonly,
     IsOptional
-] extends [false, true] ? TOptionalAdd<Property> : Property);
+] extends [false, true] ? TAddOptional<Property> : Property);
 type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
 type TCompositeProperties<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
     [Key in keyof (Right & Left)]: TCompositePropertyKey<Left, Right, Key>;

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/evaluate/composite.mjs

@@ -2,11 +2,15 @@
 // deno-lint-ignore-file
 import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
-import { ReadonlyAdd, ReadonlyRemove, IsReadonly } from '../../types/_readonly.mjs';
-import { OptionalAdd, OptionalRemove, IsOptional } from '../../types/_optional.mjs';
+import { IsReadonly } from '../../types/_readonly.mjs';
+import { IsOptional } from '../../types/_optional.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
+import { AddReadonly } from '../../action/_add_readonly.mjs';
+import { AddOptional } from '../../action/_add_optional.mjs';
+import { RemoveReadonly } from '../../action/_remove_readonly.mjs';
+import { RemoveOptional } from '../../action/_remove_optional.mjs';
 import { TupleElementsToProperties } from '../tuple/to_object.mjs';
 import { EvaluateIntersect } from './evaluate.mjs';
 function IsReadonlyProperty(left, right) {
@@ -20,10 +24,10 @@ function CompositeProperty(left, right) {
     const isOptional = IsOptionalProperty(left, right);
     const evaluated = EvaluateIntersect([left, right]);
     // Modifiers need to be discarded and re-applied
-    const property = ReadonlyRemove(OptionalRemove(evaluated));
-    return (isReadonly && isOptional ? ReadonlyAdd(OptionalAdd(property)) :
-        isReadonly && !isOptional ? ReadonlyAdd(property) :
-            !isReadonly && isOptional ? OptionalAdd(property) :
+    const property = RemoveReadonly(RemoveOptional(evaluated));
+    return (isReadonly && isOptional ? AddReadonly(AddOptional(property)) :
+        isReadonly && !isOptional ? AddReadonly(property) :
+            !isReadonly && isOptional ? AddOptional(property) :
                 property);
 }
 function CompositePropertyKey(left, right, key) {

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/evaluate/distribute.d.mts

@@ -1,4 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
@@ -6,7 +7,7 @@ import { type TComposite } from './composite.mjs';
 import { type TNarrow } from './narrow.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
-type TIsObjectLike<Type extends TSchema> = Type extends TObject | TTuple ? true : false;
+type TIsObjectLike<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
 type TIsUnionOperand<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
 type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, IsUnionOperand extends boolean = TIsUnionOperand<EvaluatedLeft, EvaluatedRight>, IsObjectLeft extends boolean = TIsObjectLike<EvaluatedLeft>, IsObjectRight extends boolean = TIsObjectLike<EvaluatedRight>, Result extends TSchema = ([
     IsUnionOperand

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/evaluate/distribute.mjs

@@ -31,15 +31,15 @@ function DistributeOperation(left, right) {
     return result;
 }
 function DistributeType(type, types, result = []) {
-    return Guard.TakeLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(type, left)]), () => Guard.IsEqual(result.length, 0)
+    return Guard.ShiftLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(type, left)]), () => Guard.IsEqual(result.length, 0)
         ? [type]
         : result);
 }
 function DistributeUnion(types, distribution, result = []) {
-    return Guard.TakeLeft(types, (left, right) => DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]), () => result);
+    return Guard.ShiftLeft(types, (left, right) => DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]), () => result);
 }
 export function Distribute(types, result = []) {
-    return Guard.TakeLeft(types, (left, right) => IsUnion(left)
+    return Guard.ShiftLeft(types, (left, right) => IsUnion(left)
         ? Distribute(right, DistributeUnion(left.anyOf, result))
         : Distribute(right, DistributeType(left, result)), () => result);
 }

package/node_modules/@earendil-works/pi-coding-agent/node_modules/typebox/build/type/engine/evaluate/evaluate.d.mts

@@ -1,14 +1,26 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
 import { type TDistribute } from './distribute.mjs';
 import { type TBroaden } from './broaden.mjs';
-import { type TUnion } from '../../types/union.mjs';
-import { type TNever } from '../../types/never.mjs';
-export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Result extends TSchema = TBroaden<Distribution>> = Result;
+import { type TExcludeOperation } from '../exclude/operation.mjs';
+import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
+export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersect extends TSchema = TIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersect, Excluded]>> = Result;
+export declare function EvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TEvaluateDependent<If, Then, Else>;
+export type TEvaluateEnum<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEvaluateEnum<Right, [...Result, TLiteral<Left>]> : TEvaluateUnion<Result>);
+export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values]): TEvaluateEnum<Values>;
+export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Broadend extends TSchema[] = TBroaden<Distribution>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = Result;
 export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
-export type TEvaluateUnion<Types extends TSchema[], Result extends TSchema = TBroaden<Types>> = Result;
+export type TEvaluateTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TEvaluateType<Evaluated>> = Result;
+export declare function EvaluateTemplateLiteral<Pattern extends string>(pattern: Pattern): TEvaluateTemplateLiteral<Pattern>;
+export type TEvaluateUnion<Types extends TSchema[], Broadend extends TSchema[] = TBroaden<Types>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = Result;
 export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
-export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
+export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TEvaluateDependent<If, Then, Else> : Type extends TEnum<infer Values extends TEnumValue[]> ? TEvaluateEnum<Values> : Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
 export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;
 export type TEvaluateUnionFast<Types extends TSchema[], Result extends TSchema = (Types extends [infer Type extends TSchema] ? Type : Types extends [] ? TNever : TUnion<Types>)> = Result;
 export declare function EvaluateUnionFast<Types extends TSchema[]>(types: [...Types]): TEvaluateUnionFast<Types>;