@daniel156161/prism 0.2.59 → 0.2.76

package/node_modules/@earendil-works/pi-ai/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>;

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/evaluate/evaluate.mjs

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/exclude/operation.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/exclude/operation.mjs

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/extract/operation.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/extract/operation.mjs

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/immutable/instantiate_add.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/immutable/instantiate_add.mjs

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/immutable/instantiate_remove.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/immutable/instantiate_remove.mjs

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

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

@@ -1,5 +1,4 @@
 export { Instantiate, type TInstantiate } from './instantiate.mjs';
-export * from './awaited/index.mjs';
 export * from './conditional/index.mjs';
 export * from './constructor_parameters/index.mjs';
 export * from './cyclic/index.mjs';
@@ -18,14 +17,15 @@ export * from './module/index.mjs';
 export * from './non_nullable/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './options/index.mjs';
 export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
+export * from './priority/index.mjs';
 export * from './readonly_object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';
 export * from './return_type/index.mjs';
 export * from './template_literal/index.mjs';
+export * from './with/index.mjs';

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/index.mjs

@@ -5,7 +5,6 @@ export { Instantiate } from './instantiate.mjs';
 // ------------------------------------------------------------------
 // Engine: Internals
 // ------------------------------------------------------------------
-export * from './awaited/index.mjs';
 export * from './conditional/index.mjs';
 export * from './constructor_parameters/index.mjs';
 export * from './cyclic/index.mjs';
@@ -24,14 +23,15 @@ export * from './module/index.mjs';
 export * from './non_nullable/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './options/index.mjs';
 export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
+export * from './priority/index.mjs';
 export * from './readonly_object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';
 export * from './required/index.mjs';
 export * from './return_type/index.mjs';
 export * from './template_literal/index.mjs';
+export * from './with/index.mjs';

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_dependent.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_dependent.mjs

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_enum.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_enum.mjs

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_template_literal.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_template_literal.mjs

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_type.d.mts

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

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexable/from_type.mjs

@@ -1,11 +1,13 @@
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsLiteral } from '../../types/literal.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromEnum } from './from_enum.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromLiteral } from './from_literal.mjs';
@@ -13,10 +15,11 @@ import { FromTemplateLiteral } from './from_template_literal.mjs';
 import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-        IsEnum(type) ? FromEnum(type.enum) :
-            IsIntersect(type) ? FromIntersect(type.allOf) :
-                IsLiteral(type) ? FromLiteral(type.const) :
-                    IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
-                        IsUnion(type) ? FromUnion(type.anyOf) :
-                            []);
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsEnum(type) ? FromEnum(type.enum) :
+                IsIntersect(type) ? FromIntersect(type.allOf) :
+                    IsLiteral(type) ? FromLiteral(type.const) :
+                        IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
+                            IsUnion(type) ? FromUnion(type.anyOf) :
+                                []);
 }

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexed/instantiate.d.mts

@@ -1,5 +1,6 @@
 import { type TSchema, type TSchemaOptions } 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 TUnion } from '../../types/union.mjs';
@@ -7,7 +8,7 @@ import { type TState, type TInstantiateType, type TCanInstantiate } from '../ins
 import { type TIndexDeferred } from '../../action/indexed.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
 import { type TFromType } from './from_type.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic ? TCollapseToObject<Type> : Type extends TDependent ? TCollapseToObject<Type> : Type extends TIntersect ? TCollapseToObject<Type> : Type extends TUnion ? TCollapseToObject<Type> : Type)> = Result;
 export type TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
 export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;
 export type TIndexInstantiate<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>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;

package/node_modules/@earendil-works/pi-ai/node_modules/typebox/build/type/engine/indexed/instantiate.mjs

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
@@ -8,8 +9,10 @@ import { IndexDeferred } from '../../action/indexed.mjs';
 import { CollapseToObject } from '../object/index.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 IndexAction(type, indexer, options) {