@daniel156161/prism 0.2.76 → 0.2.81

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

@@ -0,0 +1,16 @@
+import { type TProperties } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TPropertyKeys } from '../../types/properties.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { type TExpandThis } from '../this/expand_this.mjs';
+type TIndexProperty<Properties extends TProperties, Key extends string, CanonicalKey extends string = keyof Properties extends string | number ? `${keyof Properties}` : never, SelectedType extends TSchema = Key extends CanonicalKey ? Properties[Key] : TNever, Result extends TSchema = TExpandThis<Properties, SelectedType>> = Result;
+type TIndexProperties<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TIndexProperties<Properties, Right, [...Result, TIndexProperty<Properties, Left>]> : Result);
+type TFromIndexer<Properties extends TProperties, Indexer extends TSchema, Keys extends string[] = TToIndexableKeys<Indexer>, Variants extends TSchema[] = TIndexProperties<Properties, Keys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+type TNumericKeys<Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends `${infer _ extends number}` ? TNumericKeys<Right, [...Result, Left]> : TNumericKeys<Right, Result> : Result);
+type TFromIndexerNumber<Properties extends TProperties, Keys extends string[] = TPropertyKeys<Properties>, NumericKeys extends string[] = TNumericKeys<Keys>, Variants extends TSchema[] = TIndexProperties<Properties, NumericKeys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export type TFromObject<Properties extends TProperties, Indexer extends TSchema, Result extends TSchema = Indexer extends TNumber ? TFromIndexerNumber<Properties> : TFromIndexer<Properties, Indexer>> = Result;
+export declare function FromObject<Properties extends TProperties, Indexer extends TSchema>(properties: Properties, indexer: Indexer): TFromObject<Properties, Indexer>;
+export {};

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/type/engine/indexed/from_object.mjs

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+import { IsNumber } from '../../types/number.mjs';
+import { Never } from '../../types/never.mjs';
+import { PropertyKeys } from '../../types/properties.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { ToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { IntegerKey } from '../../types/record.mjs';
+import { ExpandThis } from '../this/expand_this.mjs';
+function IndexProperty(properties, key) {
+    const selectedType = key in properties ? properties[key] : Never();
+    const result = ExpandThis(properties, selectedType);
+    return result;
+}
+function IndexProperties(properties, keys) {
+    return keys.reduce((result, left) => {
+        return [...result, IndexProperty(properties, left)];
+    }, []);
+}
+function FromIndexer(properties, indexer) {
+    const keys = ToIndexableKeys(indexer);
+    const variants = IndexProperties(properties, keys);
+    const result = EvaluateUnion(variants);
+    return result;
+}
+const NumericKeyPattern = new RegExp(IntegerKey);
+function NumericKeys(keys) {
+    const result = keys.filter(key => NumericKeyPattern.test(key));
+    return result;
+}
+function FromIndexerNumber(properties) {
+    const keys = PropertyKeys(properties);
+    const numericKeys = NumericKeys(keys);
+    const variants = IndexProperties(properties, numericKeys);
+    const result = EvaluateUnion(variants);
+    return result;
+}
+export function FromObject(properties, indexer) {
+    const result = IsNumber(indexer) ? FromIndexerNumber(properties) : FromIndexer(properties, indexer);
+    return result;
+}

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

@@ -0,0 +1,13 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TInteger } from '../../types/integer.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TFormatArrayIndexer } from './array_indexer.mjs';
+type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
+type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnionFast<Elements>> = Result;
+type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnionFast<Types>> = Result;
+export type TFromTuple<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema = (Indexer extends TLiteral<infer _ extends 'length'> ? TLiteral<Types['length']> : Indexer extends TNumber | TInteger ? TFromTupleWithoutIndexer<Types> : TFromTupleWithIndexer<Types, Indexer>)> = Result;
+export declare function FromTuple<Types extends TSchema[], Indexer extends TSchema>(types: [...Types], indexer: Indexer): TFromTuple<Types, Indexer>;
+export {};

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/type/engine/indexed/from_tuple.mjs

@@ -0,0 +1,35 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Literal, IsLiteral } from '../../types/literal.mjs';
+import { IsNumber } from '../../types/number.mjs';
+import { IsInteger } from '../../types/integer.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { FormatArrayIndexer } from './array_indexer.mjs';
+function IndexElementsWithIndexer(types, indexer) {
+    return types.reduceRight((result, right, index) => {
+        const check = Extends({}, Literal(index), indexer);
+        return ExtendsResult.IsExtendsTrueLike(check)
+            ? [right, ...result]
+            : result;
+    }, []);
+}
+function FromTupleWithIndexer(types, indexer) {
+    const formattedArrayIndexer = FormatArrayIndexer(indexer);
+    const elements = IndexElementsWithIndexer(types, formattedArrayIndexer);
+    return EvaluateUnionFast(elements);
+}
+function FromTupleWithoutIndexer(types) {
+    return EvaluateUnionFast(types);
+}
+export function FromTuple(types, indexer) {
+    return (
+    // length (intrinsic)
+    IsLiteral(indexer) && Guard.IsEqual(indexer.const, 'length')
+        ? Literal(types.length)
+        // indexer
+        : IsNumber(indexer) || IsInteger(indexer)
+            ? FromTupleWithoutIndexer(types)
+            : FromTupleWithIndexer(types, indexer));
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+export type TFromType<Type extends TSchema, Indexer extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/type/engine/indexed/from_type.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { IsArray } from '../../types/array.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
+export function FromType(type, indexer) {
+    return (IsArray(type) ? FromArray(type.items, indexer) :
+        IsObject(type) ? FromObject(type.properties, indexer) :
+            IsTuple(type) ? FromTuple(type.items, indexer) :
+                Never());
+}

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

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

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

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

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

@@ -0,0 +1,16 @@
+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';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+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 ? 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>;
+export declare function IndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TIndexInstantiate<Context, State, Type, Indexer>;
+export {};

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

@@ -0,0 +1,28 @@
+// 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';
+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) ||
+        IsDependent(type) ||
+        IsIntersect(type) ||
+        IsUnion(type)) ? CollapseToObject(type) : type;
+    return result;
+}
+export function IndexAction(type, indexer, options) {
+    const result = CanInstantiate([type, indexer])
+        ? Memory.Update(FromType(NormalizeType(type), indexer), {}, options)
+        : IndexDeferred(type, indexer, options);
+    return result;
+}
+export function IndexInstantiate(context, state, type, indexer, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    const instantiatedIndexer = InstantiateType(context, state, indexer);
+    return IndexAction(instantiatedType, instantiatedIndexer, options);
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TInstanceTypeDeferred } from '../../action/instance_type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TInstanceTypeOperation<Type extends TSchema> = (Type extends TConstructor ? Type['instanceType'] : TNever);
+export type TInstanceTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TInstanceTypeOperation<Type> : TInstanceTypeDeferred<Type>> = Result;
+export declare function InstanceTypeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TInstanceTypeAction<Type>;
+export type TInstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TInstanceTypeAction<InstantiatedType>;
+export declare function InstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TInstanceTypeInstantiate<Context, State, Type>;
+export {};

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/type/engine/instance_type/instantiate.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { Never } from '../../types/never.mjs';
+import { InstanceTypeDeferred } from '../../action/instance_type.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function InstanceTypeOperation(type) {
+    return (IsConstructor(type)
+        ? type['instanceType']
+        : Never());
+}
+export function InstanceTypeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(InstanceTypeOperation(type), {}, options)
+        : InstanceTypeDeferred(type, options);
+    return result;
+}
+export function InstanceTypeInstantiate(context, state, type, options = {}) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return InstanceTypeAction(instantiatedType, options);
+}

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

@@ -0,0 +1,178 @@
+import { type TAddImmutableAction } from './immutable/instantiate_add.mjs';
+import { type TAddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { type TAddOptionalAction } from './optional/instantiate_add.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TConstructor } from '../types/constructor.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TFunction } from '../types/function.mjs';
+import { type TCall } from '../types/call.mjs';
+import { type TIdentifier } from '../types/identifier.mjs';
+import { type TDependent } from '../types/dependent.mjs';
+import { type TIntersect } from '../types/intersect.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type 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 TRest } from '../types/rest.mjs';
+import { type TAddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { type TRemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { type TAddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { type TRemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { type TAddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { type TRemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { type TOptional } from '../types/_optional.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
+import { type TReadonly } from '../types/_readonly.mjs';
+import { type TCallInstantiate } from './call/instantiate.mjs';
+import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { type TConditionalInstantiate } from './conditional/index.mjs';
+import { type TConstructorParametersInstantiate } from './constructor_parameters/instantiate.mjs';
+import { type TEvaluateInstantiate } from './evaluate/instantiate.mjs';
+import { type TExcludeInstantiate } from './exclude/instantiate.mjs';
+import { type TExtractInstantiate } from './extract/instantiate.mjs';
+import { type TIndexInstantiate } from './indexed/instantiate.mjs';
+import { type TInstanceTypeInstantiate } from './instance_type/instantiate.mjs';
+import { type TInterfaceInstantiate } from './interface/instantiate.mjs';
+import { type TKeyOfInstantiate } from './keyof/instantiate.mjs';
+import { type TLowercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TMappedInstantiate } from './mapped/instantiate.mjs';
+import { type TModuleInstantiate } from './module/instantiate.mjs';
+import { type TNonNullableInstantiate } from './non_nullable/instantiate.mjs';
+import { type TOmitInstantiate } from './omit/instantiate.mjs';
+import { type TParametersInstantiate } from './parameters/instantiate.mjs';
+import { type TPartialInstantiate } from './partial/instantiate.mjs';
+import { type TPickInstantiate } from './pick/instantiate.mjs';
+import { type TReadonlyObjectInstantiate } from './readonly_object/instantiate.mjs';
+import { type TRecordInstantiate } from './record/instantiate.mjs';
+import { type TRefInstantiate } from './ref/instantiate.mjs';
+import { type TRequiredInstantiate } from './required/instantiate.mjs';
+import { type TReturnTypeInstantiate } from './return_type/instantiate.mjs';
+import { type TTemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
+import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TWithInstantiate } from './with/instantiate.mjs';
+import { type TRestSpread } from './rest/index.mjs';
+export interface TState<CallStack extends string[] = string[], Visited extends string[] = string[]> {
+    callstack: CallStack;
+    visited: Visited;
+}
+export declare function State<CallStack extends string[], Visited extends string[]>(callstack: CallStack, visited: Visited): TState<CallStack, Visited>;
+export type TCanInstantiate<Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef ? false : TCanInstantiate<Right> : true;
+export declare function CanInstantiate<Types extends TSchema[]>(types: [...Types]): TCanInstantiate<Types>;
+export type TInstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TInstantiateType<Context, State, Properties[Key]>;
+}> = Result;
+export declare function InstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, state: State, properties: TProperties): TInstantiateProperties<Context, State, Properties>;
+export type TInstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[], Elements extends TSchema[] = TInstantiateTypes<Context, State, Types>, Result extends TSchema[] = TRestSpread<Elements>> = Result;
+export declare function InstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateElements<Context, State, Types>;
+export type TInstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInstantiateTypes<Context, State, Right, [...Result, TInstantiateType<Context, State, Left>]> : Result);
+export declare function InstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateTypes<Context, State, Types>;
+type TWithModifiers<Type extends TSchema, InstantiatedType extends TSchema, WithOptional extends TSchema = Type extends TOptional ? TAddOptionalAction<InstantiatedType> : InstantiatedType, WithReadonly extends TSchema = Type extends TReadonly ? TAddReadonlyAction<WithOptional> : WithOptional, WithImmutable extends TSchema = Type extends TImmutable ? TAddImmutableAction<WithReadonly> : WithReadonly> = WithImmutable;
+type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
+    Action,
+    Parameters
+] extends ['AddImmutable', [infer Type extends TSchema]] ? TAddImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveImmutable', [infer Type extends TSchema]] ? TRemoveImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddReadonly', [infer Type extends TSchema]] ? TAddReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveReadonly', [infer Type extends TSchema]] ? TRemoveReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddOptional', [infer Type extends TSchema]] ? TAddOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveOptional', [infer Type extends TSchema]] ? TRemoveOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Capitalize', [infer Type extends TSchema]] ? TCapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Conditional', [infer Left extends TSchema, infer Right extends TSchema, infer True extends TSchema, infer False extends TSchema]] ? TConditionalInstantiate<Context, State, Left, Right, True, False> : [
+    Action,
+    Parameters
+] extends ['ConstructorParameters', [infer Type extends TSchema]] ? TConstructorParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Evaluate', [infer Type extends TSchema]] ? TEvaluateInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Exclude', [infer Left extends TSchema, infer Right extends TSchema]] ? TExcludeInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Extract', [infer Left extends TSchema, infer Right extends TSchema]] ? TExtractInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Index', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TIndexInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['InstanceType', [infer Type extends TSchema]] ? TInstanceTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Interface', [infer Heritage extends TSchema[], infer Properties extends TProperties]] ? TInterfaceInstantiate<Context, State, Heritage, Properties> : [
+    Action,
+    Parameters
+] extends ['KeyOf', [infer Type extends TSchema]] ? TKeyOfInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Lowercase', [infer Type extends TSchema]] ? TLowercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Mapped', [infer Name extends TIdentifier, infer Key extends TSchema, infer As extends TSchema, infer Property extends TSchema]] ? TMappedInstantiate<Context, State, Name, Key, As, Property> : [
+    Action,
+    Parameters
+] extends ['Module', [infer Declarations extends TProperties]] ? TModuleInstantiate<Context, State, Declarations> : [
+    Action,
+    Parameters
+] extends ['NonNullable', [infer Type extends TSchema]] ? TNonNullableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Pick', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TPickInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Partial', [infer Type extends TSchema]] ? TPartialInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['ReadonlyObject', [infer Type extends TSchema]] ? TReadonlyObjectInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> : [
+    Action,
+    Parameters
+] extends ['Required', [infer Type extends TSchema]] ? TRequiredInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['ReturnType', [infer Type extends TSchema]] ? TReturnTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['TemplateLiteral', [infer Types extends TSchema[]]] ? TTemplateLiteralInstantiate<Context, State, Types> : [
+    Action,
+    Parameters
+] extends ['Uncapitalize', [infer Type extends TSchema]] ? TUncapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['With', [infer Type extends TSchema, infer Options extends TSchema]] ? TWithInstantiate<Context, State, Type, Options> : TDeferred<Action, Parameters>);
+type TInstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithModifiers extends TSchema = TWithModifiers<Type, InstantiatedType>> = WithModifiers;
+export type TInstantiateType<Context extends TProperties, State extends TState, Type extends TSchema, Result extends TSchema = Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : TInstantiateImmediate<Context, State, Type>> = Result;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type): TInstantiateImmediate<Context, State, Type>;
+/** Instantiates computed schematics using the given context and type. */
+export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, TState<[], []>, Type>);
+/** Instantiates computed schematics using the given context and type. */
+export declare function Instantiate<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): TInstantiate<Context, Type>;
+export {};

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

@@ -0,0 +1,158 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+import { AddImmutableAction } from './immutable/instantiate_add.mjs';
+import { AddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { AddOptionalAction } from './optional/instantiate_add.mjs';
+import { _Array_, IsArray, ArrayOptions } from '../types/array.mjs';
+import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
+import { Deferred, IsDeferred } from '../types/deferred.mjs';
+import { _Function_, IsFunction, FunctionOptions } from '../types/function.mjs';
+import { IsCall } from '../types/call.mjs';
+import { Dependent, IsDependent, DependentOptions } from '../types/dependent.mjs';
+import { Intersect, IsIntersect, IntersectOptions } from '../types/intersect.mjs';
+import { Object, IsObject, ObjectOptions } from '../types/object.mjs';
+import { RecordFromPattern, IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
+import { Tuple, IsTuple, TupleOptions } from '../types/tuple.mjs';
+import { Union, IsUnion, UnionOptions } from '../types/union.mjs';
+import { IsRef } from '../types/ref.mjs';
+import { Rest, IsRest } from '../types/rest.mjs';
+// ------------------------------------------------------------------
+// Modifier Instantiate
+// ------------------------------------------------------------------
+import { AddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { RemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { AddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { RemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { AddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { RemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { IsOptional } from '../types/_optional.mjs';
+import { IsImmutable } from '../types/_immutable.mjs';
+import { IsReadonly } from '../types/_readonly.mjs';
+// ------------------------------------------------------------------
+// Instantiate
+// ------------------------------------------------------------------
+import { CallInstantiate } from './call/instantiate.mjs';
+import { CapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { ConditionalInstantiate } from './conditional/index.mjs';
+import { ConstructorParametersInstantiate } from './constructor_parameters/instantiate.mjs';
+import { EvaluateInstantiate } from './evaluate/instantiate.mjs';
+import { ExcludeInstantiate } from './exclude/instantiate.mjs';
+import { ExtractInstantiate } from './extract/instantiate.mjs';
+import { IndexInstantiate } from './indexed/instantiate.mjs';
+import { InstanceTypeInstantiate } from './instance_type/instantiate.mjs';
+import { InterfaceInstantiate } from './interface/instantiate.mjs';
+import { KeyOfInstantiate } from './keyof/instantiate.mjs';
+import { LowercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { MappedInstantiate } from './mapped/instantiate.mjs';
+import { ModuleInstantiate } from './module/instantiate.mjs';
+import { NonNullableInstantiate } from './non_nullable/instantiate.mjs';
+import { OmitInstantiate } from './omit/instantiate.mjs';
+import { ParametersInstantiate } from './parameters/instantiate.mjs';
+import { PartialInstantiate } from './partial/instantiate.mjs';
+import { PickInstantiate } from './pick/instantiate.mjs';
+import { ReadonlyObjectInstantiate } from './readonly_object/instantiate.mjs';
+import { RecordInstantiate } from './record/instantiate.mjs';
+import { RefInstantiate } from './ref/instantiate.mjs';
+import { RequiredInstantiate } from './required/instantiate.mjs';
+import { ReturnTypeInstantiate } from './return_type/instantiate.mjs';
+import { TemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
+import { UncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { UppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { WithInstantiate } from './with/instantiate.mjs';
+import { RestSpread } from './rest/index.mjs';
+export function State(callstack, visited) {
+    return { callstack, visited };
+}
+export function CanInstantiate(types) {
+    return Guard.ShiftLeft(types, (left, right) => IsRef(left)
+        ? false
+        : CanInstantiate(right), () => true);
+}
+export function InstantiateProperties(context, state, properties) {
+    return Guard.Keys(properties).reduce((result, key) => {
+        return { ...result, [key]: InstantiateType(context, state, properties[key]) };
+    }, {});
+}
+export function InstantiateElements(context, state, types) {
+    const elements = InstantiateTypes(context, state, types);
+    const result = RestSpread(elements);
+    return result;
+}
+export function InstantiateTypes(context, state, types) {
+    return types.map(type => InstantiateType(context, state, type));
+}
+function WithModifiers(type, instantiatedType) {
+    const withOptional = IsOptional(type) ? AddOptionalAction(instantiatedType, {}) : instantiatedType;
+    const withReadonly = IsReadonly(type) ? AddReadonlyAction(withOptional, {}) : withOptional;
+    const withImmutable = IsImmutable(type) ? AddImmutableAction(withReadonly, {}) : withReadonly;
+    return withImmutable;
+}
+function InstantiateDeferred(context, state, action, parameters, options) {
+    return (
+    // Modifiers
+    Guard.IsEqual(action, 'AddImmutable') ? AddImmutableInstantiate(context, state, parameters[0], options) :
+        Guard.IsEqual(action, 'RemoveImmutable') ? RemoveImmutableInstantiate(context, state, parameters[0], options) :
+            Guard.IsEqual(action, 'AddReadonly') ? AddReadonlyInstantiate(context, state, parameters[0], options) :
+                Guard.IsEqual(action, 'RemoveReadonly') ? RemoveReadonlyInstantiate(context, state, parameters[0], options) :
+                    Guard.IsEqual(action, 'AddOptional') ? AddOptionalInstantiate(context, state, parameters[0], options) :
+                        Guard.IsEqual(action, 'RemoveOptional') ? RemoveOptionalInstantiate(context, state, parameters[0], options) :
+                            // Actions
+                            Guard.IsEqual(action, 'Capitalize') ? CapitalizeInstantiate(context, state, parameters[0], options) :
+                                Guard.IsEqual(action, 'Conditional') ? ConditionalInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                    Guard.IsEqual(action, 'ConstructorParameters') ? ConstructorParametersInstantiate(context, state, parameters[0], options) :
+                                        Guard.IsEqual(action, 'Evaluate') ? EvaluateInstantiate(context, state, parameters[0], options) :
+                                            Guard.IsEqual(action, 'Exclude') ? ExcludeInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                Guard.IsEqual(action, 'Extract') ? ExtractInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                    Guard.IsEqual(action, 'Index') ? IndexInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                        Guard.IsEqual(action, 'InstanceType') ? InstanceTypeInstantiate(context, state, parameters[0], options) :
+                                                            Guard.IsEqual(action, 'Interface') ? InterfaceInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                Guard.IsEqual(action, 'KeyOf') ? KeyOfInstantiate(context, state, parameters[0], options) :
+                                                                    Guard.IsEqual(action, 'Lowercase') ? LowercaseInstantiate(context, state, parameters[0], options) :
+                                                                        Guard.IsEqual(action, 'Mapped') ? MappedInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                                                            Guard.IsEqual(action, 'Module') ? ModuleInstantiate(context, state, parameters[0], options) :
+                                                                                Guard.IsEqual(action, 'NonNullable') ? NonNullableInstantiate(context, state, parameters[0], options) :
+                                                                                    Guard.IsEqual(action, 'Pick') ? PickInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                        Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
+                                                                                            Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
+                                                                                                Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                                    Guard.IsEqual(action, 'ReadonlyObject') ? ReadonlyObjectInstantiate(context, state, parameters[0], options) :
+                                                                                                        Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                                            Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
+                                                                                                                Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
+                                                                                                                    Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
+                                                                                                                        Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
+                                                                                                                            Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
+                                                                                                                                Guard.IsEqual(action, 'With') ? WithInstantiate(context, state, parameters[0], parameters[1]) :
+                                                                                                                                    Deferred(action, parameters, options));
+}
+function InstantiateImmediate(context, state, type) {
+    const instantiatedType = (IsRef(type) ? RefInstantiate(context, state, type, type.$ref) :
+        IsArray(type) ? _Array_(InstantiateType(context, state, type.items), ArrayOptions(type)) :
+            IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) :
+                IsConstructor(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) :
+                    IsFunction(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) :
+                        IsDependent(type) ? Dependent(InstantiateType(context, state, type.if), InstantiateType(context, state, type.then), InstantiateType(context, state, type.else), DependentOptions(type)) :
+                            IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
+                                IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :
+                                    IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) :
+                                        IsRest(type) ? Rest(InstantiateType(context, state, type.items)) :
+                                            IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
+                                                IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
+                                                    type);
+    const withModifiers = WithModifiers(type, instantiatedType);
+    return withModifiers;
+}
+export function InstantiateType(context, state, type) {
+    const result = IsDeferred(type)
+        ? InstantiateDeferred(context, state, type.action, type.parameters, type.options)
+        : InstantiateImmediate(context, state, type);
+    return result;
+}
+/** Instantiates computed schematics using the given context and type. */
+export function Instantiate(context, type) {
+    return InstantiateType(context, State([], []), type);
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TInterfaceDeferred } from '../../action/index.mjs';
+import { type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateProperties } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+type TInterfaceOperation<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TEvaluateIntersect<[...Heritage, TObject<Properties>]>> = Result;
+export type TInterfaceAction<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TCanInstantiate<Heritage> extends true ? TInterfaceOperation<Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>> = Result;
+export declare function InterfaceAction<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceAction<Heritage, Properties>;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, State, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, State, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
+export declare function InterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties>(context: Context, state: State, heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceInstantiate<Context, State, Heritage, Properties>;
+export {};