@code-yeongyu/senpi 2026.8.18 → 2026.8.19

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TFromType } from './from_type.mjs';
+export type TCollapseToObject<Type extends TSchema, Properties extends TProperties = TFromType<Type>, Result extends TSchema = TObject<Properties>> = Result;
+/**
+ * Collapses a type into a TObject schema. This is a lossy fast path used to
+ * normalize arbitrary TSchema types into a TObject structure. This function is
+ * primarily used in indexing operations where a normalized object structure
+ * is required. If the type cannot be collapsed, an empty object schema is returned.
+ */
+export declare function CollapseToObject<Type extends TSchema>(type: Type): TCollapseToObject<Type>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/object/collapse.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Object } from '../../types/object.mjs';
+import { FromType } from './from_type.mjs';
+/**
+ * Collapses a type into a TObject schema. This is a lossy fast path used to
+ * normalize arbitrary TSchema types into a TObject structure. This function is
+ * primarily used in indexing operations where a normalized object structure
+ * is required. If the type cannot be collapsed, an empty object schema is returned.
+ */
+export function CollapseToObject(type) {
+    const properties = FromType(type);
+    const result = Object(properties);
+    return result;
+}

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

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TCyclicTarget } from '../cyclic/target.mjs';
+export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Result extends TProperties = TFromType<Target>> = Result;
+export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/object/from_cyclic.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { CyclicTarget } from '../cyclic/target.mjs';
+export function FromCyclic(defs, ref) {
+    const target = CyclicTarget(defs, ref);
+    const result = FromType(target);
+    return result;
+}

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

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/object/from_dependent.mjs

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

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

@@ -0,0 +1,17 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties, LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>, RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>, SharedKeys extends keyof Left & keyof Right = Extract<keyof Left, keyof Right>, LeftProperties extends TProperties = {
+    [Key in LeftKeys]: Left[Key];
+}, RightProperties extends TProperties = {
+    [Key in RightKeys]: Right[Key];
+}, SharedProperties extends TProperties = {
+    [Key in SharedKeys]: TEvaluateIntersect<[Left[Key], Right[Key]]>;
+}, Unique extends TProperties = Memory.TAssign<LeftProperties, RightProperties>, Shared extends TProperties = Memory.TAssign<Unique, SharedProperties>> = Shared;
+export type TFromIntersect<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, TCollapseIntersectProperties<Result, TFromType<Left>>> : {
+    [Key in keyof Result]: Result[Key];
+});
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;
+export {};

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/object/from_intersect.mjs

@@ -0,0 +1,22 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { FromType } from './from_type.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+function CollapseIntersectProperties(left, right) {
+    const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key));
+    const rightKeys = Guard.Keys(right).filter((key) => !Guard.HasPropertyKey(left, key));
+    const sharedKeys = Guard.Keys(left).filter((key) => Guard.HasPropertyKey(right, key));
+    const leftProperties = leftKeys.reduce((result, key) => ({ ...result, [key]: left[key] }), {});
+    const rightProperties = rightKeys.reduce((result, key) => ({ ...result, [key]: right[key] }), {});
+    const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: EvaluateIntersect([left[key], right[key]]) }), {});
+    const unique = Memory.Assign(leftProperties, rightProperties);
+    const shared = Memory.Assign(unique, sharedProperties);
+    return shared;
+}
+export function FromIntersect(types) {
+    return types.reduce((result, left) => {
+        return CollapseIntersectProperties(result, FromType(left));
+    }, {});
+}

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

@@ -0,0 +1,3 @@
+import { type TProperties } from '../../types/properties.mjs';
+export type TFromObject<Properties extends TProperties> = (Properties);
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+import { type TFromUnion } from './from_union.mjs';
+export type TFromType<Type extends TSchema, Result extends TProperties = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -0,0 +1,23 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
+export function FromType(type) {
+    return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    IsTuple(type) ? FromTuple(type.items) :
+                        IsObject(type) ? FromObject(type.properties) :
+                            {});
+}

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

@@ -0,0 +1,12 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TFromType } from './from_type.mjs';
+type TCollapseUnionProperties<Left extends TProperties, Right extends TProperties, SharedKeys extends PropertyKey = keyof Left & keyof Right, Result extends TProperties = {
+    [Key in SharedKeys]: TEvaluateUnion<[Left[Key], Right[Key]]>;
+}> = Result;
+type TReduceVariants<Types extends TSchema[], Result extends TProperties> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TCollapseUnionProperties<Result, TFromType<Left>>> : Result);
+export type TFromUnion<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TFromType<Left>> : TUnreachable);
+export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;
+export {};

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { type TToIndexable } from '../indexable/to_indexable.mjs';
+type TNormalKeys<Keys extends string[], UnionKeys extends string = Keys[number], Result extends string | number = (UnionKeys extends `${infer Value extends number}` ? UnionKeys | Value : UnionKeys)> = Result;
+type TFromKeys<Properties extends TProperties, Keys extends string[], Omitted extends TProperties = Omit<Properties, TNormalKeys<Keys>>, Result extends TProperties = {
+    [Key in keyof Omitted]: Omitted[Key];
+}> = Result;
+export type TFromType<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, IndexableKeys extends string[] = TToIndexableKeys<Indexer>, Omitted extends TProperties = TFromKeys<Indexable, IndexableKeys>, Result extends TSchema = TObject<Omitted>> = Result;
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;
+export {};

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

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { ToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { ToIndexable } from '../indexable/to_indexable.mjs';
+function FromKeys(properties, keys) {
+    const result = Guard.Keys(properties).reduce((result, key) => {
+        return keys.includes(key) ? result : { ...result, [key]: properties[key] };
+    }, {});
+    return result;
+}
+export function FromType(type, indexer) {
+    const indexable = ToIndexable(type);
+    const indexableKeys = ToIndexableKeys(indexer);
+    const omitted = FromKeys(indexable, indexableKeys);
+    const result = Object(omitted);
+    return result;
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TOmitDeferred } from '../../action/omit.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TFromType } from './from_type.mjs';
+export type TOmitAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<Type, Indexer> : TOmitDeferred<Type, Indexer>> = Result;
+export declare function OmitAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TOmitAction<Type, Indexer>;
+export type TOmitInstantiate<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>> = TOmitAction<InstantiatedType, InstantiatedIndexer>;
+export declare function OmitInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TOmitInstantiate<Context, State, Type, Indexer>;

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

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { OmitDeferred } from '../../action/omit.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { FromType } from './from_type.mjs';
+export function OmitAction(type, indexer, options) {
+    const result = CanInstantiate([type, indexer])
+        ? Memory.Update(FromType(type, indexer), {}, options)
+        : OmitDeferred(type, indexer, options);
+    return result;
+}
+export function OmitInstantiate(context, state, type, indexer, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    const instantiatedIndexer = InstantiateType(context, state, indexer);
+    return OmitAction(instantiatedType, instantiatedIndexer, options);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/optional/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 TOptional } from '../../types/_optional.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddOptionalOperation<Type extends TSchema, Result extends TSchema = `~optional` extends keyof Type ? Type : TOptional<Type>> = Result;
+export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = TAddOptionalOperation<Type>> = Result;
+export declare function AddOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddOptionalAction<Type>;
+export type TAddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddOptionalAction<InstantiateType>;
+export declare function AddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddOptionalInstantiate<Context, State, Type>;
+export {};

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/optional/instantiate_add.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/optional/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 TOptional } from '../../types/_optional.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveOptionalOperation<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalOperation<Type> : Type> = Result;
+export type TRemoveOptionalAction<Type extends TSchema, Result extends TSchema = TRemoveOptionalOperation<Type>> = Result;
+export declare function RemoveOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveOptionalAction<Type>;
+export type TRemoveOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveOptionalAction<InstantiateType>;
+export declare function RemoveOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveOptionalInstantiate<Context, State, Type>;
+export {};

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/optional/instantiate_remove.mjs

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TParametersDeferred } from '../../action/parameters.mjs';
+import { type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateElements } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+type TParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TFunction ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+export type TParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TParametersOperation<Type> : TParametersDeferred<Type>> = Result;
+export declare function ParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TParametersAction<Type>;
+export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantiatedType>;
+export declare function ParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TParametersInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,25 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { Tuple } from '../../types/tuple.mjs';
+import { ParametersDeferred } from '../../action/parameters.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { InstantiateElements } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
+function ParametersOperation(type) {
+    const parameters = IsFunction(type) ? type['parameters'] : [];
+    const instantiatedParameters = InstantiateElements({}, State([], []), parameters);
+    const result = Tuple(instantiatedParameters);
+    return result;
+}
+export function ParametersAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(ParametersOperation(type), {}, options)
+        : ParametersDeferred(type, options);
+    return result;
+}
+export function ParametersInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return ParametersAction(instantiatedType, options);
+}

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

@@ -0,0 +1,10 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TCyclicTarget } from '../cyclic/target.mjs';
+export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
+    [_ in Ref]: Partial;
+}>, Ref>> = Result;
+export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/partial/from_cyclic.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Cyclic } from '../../types/cyclic.mjs';
+import { FromType } from './from_type.mjs';
+import { CyclicTarget } from '../cyclic/target.mjs';
+export function FromCyclic(defs, ref) {
+    const target = CyclicTarget(defs, ref);
+    const partial = FromType(target);
+    const result = Cyclic(Memory.Assign(defs, { [ref]: partial }), ref);
+    return result;
+}

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

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/partial/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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/partial/from_intersect.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/engine/partial/from_intersect.mjs

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

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

@@ -0,0 +1,8 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TAddOptional } from '../../action/_add_optional.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+export type TFromObject<Properties extends TProperties, Mapped extends TProperties = {
+    [Key in keyof Properties]: TAddOptional<Properties[Key]>;
+}, Result extends TSchema = TObject<Mapped>> = Result;
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { AddOptional } from '../../action/_add_optional.mjs';
+export function FromObject(properties) {
+    const mapped = Guard.Keys(properties).reduce((result, left) => {
+        return { ...result, [left]: AddOptional(properties[left]) };
+    }, {});
+    const result = Object(mapped);
+    return result;
+}

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

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromUnion } from './from_union.mjs';
+import { type TFromObject } from './from_object.mjs';
+export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -0,0 +1,20 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { Object, IsObject } from '../../types/object.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromUnion } from './from_union.mjs';
+import { FromObject } from './from_object.mjs';
+export function FromType(type) {
+    return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    IsObject(type) ? FromObject(type.properties) :
+                        Object({}));
+}