@code-yeongyu/senpi 2026.8.18 → 2026.8.19

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/interface/instantiate.mjs

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { InterfaceDeferred } from '../../action/index.mjs';
+import { CanInstantiate } from '../instantiate.mjs';
+import { InstantiateProperties } from '../instantiate.mjs';
+import { InstantiateTypes } from '../instantiate.mjs';
+function InterfaceOperation(heritage, properties) {
+    const result = EvaluateIntersect([...heritage, Object(properties)]);
+    return result;
+}
+export function InterfaceAction(heritage, properties, options) {
+    const result = CanInstantiate(heritage)
+        ? Memory.Update(InterfaceOperation(heritage, properties), {}, options)
+        : InterfaceDeferred(heritage, properties, options);
+    return result;
+}
+export function InterfaceInstantiate(context, state, heritage, properties, options) {
+    const instantiatedHeritage = InstantiateTypes(context, state, heritage);
+    const instantiatedProperties = InstantiateProperties(context, state, properties);
+    return InterfaceAction(instantiatedHeritage, instantiatedProperties, options);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_literal.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TMappingType, type TMappingFunc, type TApplyMapping } from './mapping.mjs';
+export type TFromLiteral<Mapping extends TMappingType, Value extends TLiteralValue> = (Value extends string ? TLiteral<TApplyMapping<Mapping, Value>> : TLiteral<Value>);
+export declare function FromLiteral(mapping: TMappingFunc, value: TLiteralValue): TSchema;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_literal.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Literal } from '../../types/literal.mjs';
+import { ApplyMapping } from './mapping.mjs';
+export function FromLiteral(mapping, value) {
+    return (Guard.IsString(value)
+        ? Literal(ApplyMapping(mapping, value))
+        : Literal(value));
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_template_literal.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TMappingType, type TMappingFunc } from './mapping.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/index.mjs';
+export type TFromTemplateLiteral<Mapping extends TMappingType, Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends TSchema = TFromType<Mapping, Evaluated>> = Result;
+export declare function FromTemplateLiteral(mapping: TMappingFunc, pattern: string): TSchema;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_template_literal.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_type.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TMappingType, type TMappingFunc } from './mapping.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<Mapping extends TMappingType, Type extends TSchema> = (Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Mapping, Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Mapping, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Mapping, Types> : Type);
+export declare function FromType(mapping: TMappingFunc, type: TSchema): TSchema;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_type.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { IsLiteral } from '../../types/literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromLiteral } from './from_literal.mjs';
+import { FromTemplateLiteral } from './from_template_literal.mjs';
+import { FromUnion } from './from_union.mjs';
+export function FromType(mapping, type) {
+    return (IsLiteral(type) ? FromLiteral(mapping, type.const) :
+        IsTemplateLiteral(type) ? FromTemplateLiteral(mapping, type.pattern) :
+            IsUnion(type) ? FromUnion(mapping, type.anyOf) :
+                type);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_union.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TMappingType, type TMappingFunc } from './mapping.mjs';
+import { type TFromType } from './from_type.mjs';
+export type TFromUnion<Mapping extends TMappingType, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Mapping, Right, [...Result, TFromType<Mapping, Left>]> : TUnion<Result>);
+export declare function FromUnion(mapping: TMappingFunc, types: TSchema[]): TSchema;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/from_union.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Union } from '../../types/union.mjs';
+import { FromType } from './from_type.mjs';
+export function FromUnion(mapping, types) {
+    const result = types.map(type => FromType(mapping, type));
+    return Union(result);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/index.d.mts

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/index.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/instantiate.d.mts

@@ -0,0 +1,38 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TMappingType } from './mapping.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TCapitalizeDeferred } from '../../action/capitalize.mjs';
+import { type TLowercaseDeferred } from '../../action/lowercase.mjs';
+import { type TUncapitalizeDeferred } from '../../action/uncapitalize.mjs';
+import { type TUppercaseDeferred } from '../../action/uppercase.mjs';
+interface TCapitalizeMapping extends TMappingType {
+    output: Capitalize<this['input']>;
+}
+interface TLowercaseMapping extends TMappingType {
+    output: Lowercase<this['input']>;
+}
+interface TUncapitalizeMapping extends TMappingType {
+    output: Uncapitalize<this['input']>;
+}
+interface TUppercaseMapping extends TMappingType {
+    output: Uppercase<this['input']>;
+}
+export type TCapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TCapitalizeMapping, Type> : TCapitalizeDeferred<Type>> = Result;
+export declare function CapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TCapitalizeAction<Type>;
+export type TLowercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TLowercaseMapping, Type> : TLowercaseDeferred<Type>> = Result;
+export declare function LowercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TLowercaseAction<Type>;
+export type TUncapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUncapitalizeMapping, Type> : TUncapitalizeDeferred<Type>> = Result;
+export declare function UncapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUncapitalizeAction<Type>;
+export type TUppercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUppercaseMapping, Type> : TUppercaseDeferred<Type>> = Result;
+export declare function UppercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUppercaseAction<Type>;
+export type TCapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TCapitalizeAction<InstantiatedType>;
+export declare function CapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TCapitalizeInstantiate<Context, State, Type>;
+export type TLowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TLowercaseAction<InstantiatedType>;
+export declare function LowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TLowercaseInstantiate<Context, State, Type>;
+export type TUncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUncapitalizeAction<InstantiatedType>;
+export declare function UncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUncapitalizeInstantiate<Context, State, Type>;
+export type TUppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUppercaseAction<InstantiatedType>;
+export declare function UppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUppercaseInstantiate<Context, State, Type>;
+export {};

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/instantiate.mjs

@@ -0,0 +1,52 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { FromType } from './from_type.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { CapitalizeDeferred } from '../../action/capitalize.mjs';
+import { LowercaseDeferred } from '../../action/lowercase.mjs';
+import { UncapitalizeDeferred } from '../../action/uncapitalize.mjs';
+import { UppercaseDeferred } from '../../action/uppercase.mjs';
+const CapitalizeMapping = (input) => input[0].toUpperCase() + input.slice(1);
+const LowercaseMapping = (input) => input.toLowerCase();
+const UncapitalizeMapping = (input) => input[0].toLowerCase() + input.slice(1);
+const UppercaseMapping = (input) => input.toUpperCase();
+export function CapitalizeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(CapitalizeMapping, type), {}, options)
+        : CapitalizeDeferred(type, options);
+    return result;
+}
+export function LowercaseAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(LowercaseMapping, type), {}, options)
+        : LowercaseDeferred(type, options);
+    return result;
+}
+export function UncapitalizeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(UncapitalizeMapping, type), {}, options)
+        : UncapitalizeDeferred(type, options);
+    return result;
+}
+export function UppercaseAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(UppercaseMapping, type), {}, options)
+        : UppercaseDeferred(type, options);
+    return result;
+}
+export function CapitalizeInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return CapitalizeAction(instantiatedType, options);
+}
+export function LowercaseInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return LowercaseAction(instantiatedType, options);
+}
+export function UncapitalizeInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return UncapitalizeAction(instantiatedType, options);
+}
+export function UppercaseInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return UppercaseAction(instantiatedType, options);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/mapping.d.mts

@@ -0,0 +1,9 @@
+export interface TMappingType {
+    input: string;
+    output: string;
+}
+export type TApplyMapping<Mapping extends TMappingType, Value extends string> = ((Mapping & {
+    input: Value;
+})['output']);
+export type TMappingFunc = (input: string) => string;
+export declare function ApplyMapping(mapping: TMappingFunc, value: string): string;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/intrinsics/mapping.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export function ApplyMapping(mapping, value) {
+    return mapping(value);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_any.d.mts

@@ -0,0 +1,6 @@
+import { type TNumber } from '../../types/number.mjs';
+import { type TString } from '../../types/string.mjs';
+import { type TSymbol } from '../../types/symbol.mjs';
+import { type TUnion } from '../../types/union.mjs';
+export type TFromAny<Result = TUnion<[TNumber, TString, TSymbol]>> = Result;
+export declare function FromAny(): TFromAny;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_any.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { Number } from '../../types/number.mjs';
+import { String } from '../../types/string.mjs';
+import { Symbol } from '../../types/symbol.mjs';
+import { Union } from '../../types/union.mjs';
+export function FromAny() {
+    return Union([Number(), String(), Symbol()]);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_array.d.mts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TNumber } from '../../types/number.mjs';
+export type TFromArray<_Type extends TSchema> = TNumber;
+export declare function FromArray<_Type extends TSchema>(_type: _Type): TFromArray<_Type>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_array.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import { Number } from '../../types/number.mjs';
+export function FromArray(_type) {
+    return Number();
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_object.d.mts

@@ -0,0 +1,10 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/index.mjs';
+import { type TUnionToTuple } from '../helpers/index.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+type TFromPropertyKeys<Keys extends PropertyKey[], Result extends TSchema[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Left extends TLiteralValue ? TFromPropertyKeys<Right, [...Result, TLiteral<Left>]> : TUnreachable : Result);
+export type TFromObject<Properties extends TProperties, PropertyKeys extends PropertyKey[] = TUnionToTuple<keyof Properties>, Variants extends TSchema[] = TFromPropertyKeys<PropertyKeys>, Result extends TSchema = TEvaluateUnionFast<Variants>> = Result;
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;
+export {};

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_object.mjs

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { Literal, IsLiteralValue } from '../../types/literal.mjs';
+import { ConvertToIntegerKey } from '../helpers/keys.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
+function FromPropertyKeys(keys) {
+    const result = keys.reduce((result, left) => {
+        return IsLiteralValue(left)
+            ? [...result, Literal(ConvertToIntegerKey(left))]
+            : Unreachable();
+    }, []);
+    return result;
+}
+export function FromObject(properties) {
+    const propertyKeys = Guard.Keys(properties);
+    const variants = FromPropertyKeys(propertyKeys);
+    const result = EvaluateUnionFast(variants);
+    return result;
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_record.d.mts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TRecord, type TRecordKey } from '../../types/record.mjs';
+export type TFromRecord<Type extends TRecord, Result extends TSchema = TRecordKey<Type>> = Result;
+export declare function FromRecord<Type extends TRecord>(type: Type): TFromRecord<Type>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_record.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import { RecordKey } from '../../types/record.mjs';
+export function FromRecord(type) {
+    return RecordKey(type);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_tuple.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+export type TFromTuple<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer _ extends TSchema] ? TFromTuple<Left, [TLiteral<Left['length']>, ...Result]> : TEvaluateUnionFast<Result>);
+export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_tuple.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Literal } from '../../types/literal.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
+export function FromTuple(types) {
+    const result = types.map((_, index) => Literal(index));
+    return EvaluateUnionFast(result);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_type.d.mts

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/from_type.mjs

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { IsAny } from '../../types/any.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsRecord } from '../../types/record.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+// ------------------------------------------------------------------
+// Computed
+// ------------------------------------------------------------------
+import { FromAny } from './from_any.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromTuple } from './from_tuple.mjs';
+export function FromType(type) {
+    return (IsAny(type) ? FromAny() :
+        IsArray(type) ? FromArray(type.items) :
+            IsObject(type) ? FromObject(type.properties) :
+                IsRecord(type) ? FromRecord(type) :
+                    IsTuple(type) ? FromTuple(type.items) :
+                        Never());
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/index.d.mts

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/index.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/instantiate.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TKeyOfDeferred } from '../../action/keyof.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.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 TKeyOfAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TNormalizeType<Type>> : TKeyOfDeferred<Type>> = Result;
+export declare function KeyOfAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TKeyOfAction<Type>;
+export type TKeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TKeyOfAction<InstantiatedType>;
+export declare function KeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TKeyOfInstantiate<Context, State, Type>;
+export {};

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/keyof/instantiate.mjs

@@ -0,0 +1,29 @@
+// 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 { KeyOfDeferred } from '../../action/keyof.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { CollapseToObject } from '../object/index.mjs';
+// ------------------------------------------------------------------
+// Computed
+// ------------------------------------------------------------------
+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 KeyOfAction(type, options) {
+    return (CanInstantiate([type])
+        ? Memory.Update(FromType(NormalizeType(type)), {}, options)
+        : KeyOfDeferred(type, options));
+}
+export function KeyOfInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return KeyOfAction(instantiatedType, options);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/index.d.mts

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/index.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/instantiate.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TIdentifier } from '../../types/identifier.mjs';
+import { type TMappedDeferred } from '../../action/mapped.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TMappedOperation } from './mapped_operation.mjs';
+export type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TMappedOperation<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>> = Result;
+export declare function MappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedAction<Context, State, Identifier, Type, As, Property>;
+export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstaniatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstaniatedType, As, Property>;
+export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Type, As, Property>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/instantiate.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { MappedDeferred } from '../../action/mapped.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { MappedOperation } from './mapped_operation.mjs';
+export function MappedAction(context, state, identifier, type, as, property, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(MappedOperation(context, state, identifier, type, as, property), {}, options)
+        : MappedDeferred(identifier, type, as, property, options);
+    return result;
+}
+export function MappedInstantiate(context, state, identifier, type, as, property, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return MappedAction(context, state, identifier, instantiatedType, as, property, options);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/mapped_operation.d.mts

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/mapped_operation.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/mapped_variants.d.mts

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/mapped/mapped_variants.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/module/index.d.mts

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/module/index.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/module/instantiate.d.mts

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