mnemonica 1.0.6 → 1.0.8

package/build/types/index.js

@@ -1,3 +1,3 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC","sourcesContent":["'use strict';\n/* eslint no-unused-vars: \"off\" */\n\n// Props type for getProps/setProps\nexport type PropsType = Record<string, unknown>;\n\n// Core type definitions for mnemonica\n\n// Base constructor function type - can be a class constructor or a function.\n// Args defaults to unknown[] so IDEF<T> is backwards compatible;\n// supply Args to get typed constructor params: IDEF<MyType, [string, number]>\nexport type IDEF<T, Args extends unknown[] = unknown[]> = { new(): T } | { (this: T, ...args: Args): void };\n\n// Error message types - all error messages are strings\nexport type ErrorMessageKey =\n\t| 'BASE_ERROR_MESSAGE'\n\t| 'HANDLER_MUST_BE_A_FUNCTION'\n\t| 'WRONG_TYPE_DEFINITION'\n\t| 'WRONG_INSTANCE_INVOCATION'\n\t| 'WRONG_MODIFICATION_PATTERN'\n\t| 'ALREADY_DECLARED'\n\t| 'WRONG_ARGUMENTS_USED'\n\t| 'WRONG_HOOK_TYPE'\n\t| 'MISSING_HOOK_CALLBACK'\n\t| 'MISSING_CALLBACK_ARGUMENT'\n\t| 'OPTIONS_ERROR'\n\t| 'WRONG_STACK_CLEANER';\n\t// | 'TYPENAME_MUST_BE_A_STRING'\n\t// | 'FLOW_CHECKER_REDEFINITION'\n\n// Error messages object type\nexport type ErrorMessages = Record<ErrorMessageKey, string>;\n\n// Hook callback — passed to registerHook and invoked by invokeHook\nexport interface hook extends CallableFunction {\n\t(opts: hooksOpts): unknown;\n}\n\n// Error constructor from constructError - constructable function with prototype\nexport interface MnemonicaErrorConstructor {\n\tnew(addition?: string, stack?: string | string[]): Error;\n\t(name: string): Error;\n\tprototype: {\n\t\tconstructor: MnemonicaErrorConstructor;\n\t};\n}\n\n// Errors types map - indexable record of error constructors\nexport type ErrorsTypesMap = Record<string, MnemonicaErrorConstructor>;\n\n// Mnemonica error interface for extended Error objects\nexport interface MnemonicaError extends Error {\n\texceptionReason?: Error;\n\treasons?: Error[];\n\tsurplus?: Error[];\n}\n\n/**\n * Internal Type Constructor.\n * \"Type\" here is used in the Computer Science sense — an interface/contract\n * describing what a constructor must satisfy (both `new`-able and callable).\n * TC = Type Constructor; \"Internal\" means this is the library's own constructor\n * shape, distinct from user-facing TypeConstructor below.\n */\nexport interface _Internal_TC_<ConstructorInstance extends object> {\n\tnew(...args: unknown[]): ConstructorInstance;\n\t(this: ConstructorInstance, ...args: unknown[]): ConstructorInstance;\n\treadonly prototype: ConstructorInstance & {\n\t\treadonly constructor: _Internal_TC_<ConstructorInstance>\n\t};\n}\n\n/**\n * Public alias for _Internal_TC_ — the shape of constructor functions returned by `define()`.\n * Augmented by tactica-generated TypeRegistry to become user-specific types.\n * Kept as a named alias (rather than inlining _Internal_TC_) so tactica can reference it\n * cleanly in generated declaration files.\n */\nexport type TypeConstructor<ConstructorInstance extends object> = _Internal_TC_<ConstructorInstance>;\n\n// Hook types\nexport type hooksTypes = 'preCreation' | 'postCreation' | 'creationError';\n\n// Hook options passed to hook callbacks\n// P = parent / existent instance (proto)\n// T = child / inherited instance (type being created)\nexport type hooksOpts<P = object, T = P> = {\n\tTypeName: string;\n\ttype: TypeDef;\n\targs: unknown[];\n\texistentInstance: P;\n\tinheritedInstance?: T;\n\tcreator?: { throwModificationError(error: Error): void };\n};\n\n// Callback passed into ModificationConstructor to attach internal props to the prototype\nexport interface AddPropsCallback extends CallableFunction {\n\t(proto: object): void;\n}\n\n// ModificationConstructor: wires prototype chain during instance creation\nexport interface ModificationConstructor extends CallableFunction {\n\t(\n\t\tthis: object,\n\t\tModificatorType: MnemonicaConstructor,\n\t\tModificatorTypePrototype: object,\n\t\t_addProps: AddPropsCallback\n\t): MnemonicaConstructor;\n}\n\n// Factory that returns a ModificationConstructor (used in constructorOptions)\nexport interface ModificationConstructorFactory extends CallableFunction {\n\t(): ModificationConstructor;\n}\n\n// Factory that returns a MnemonicaConstructor (stored in TypeDef.constructHandler)\nexport interface MnemonicaConstructorFactory extends CallableFunction {\n\t(): MnemonicaConstructor;\n}\n\n// Marks the top of a captured stack trace (passed to Error.captureStackTrace as constructorOpt)\nexport interface StackBoundary extends CallableFunction {}\n\n// A wrappable utility method — any callable that wrapThis() can proxy\nexport interface WrappableMethod extends CallableFunction {}\n\n// Constructor options for define\nexport type constructorOptions = {\n\t// explicit declaration we wish use\n\t// an old style based constructors\n\tModificationConstructor?: ModificationConstructorFactory,\n\t// shall or not we use strict checking\n\t// for creation sub-instances Only from current type\n\t// or we might use up-nested sub-instances from chain\n\tstrictChain?: boolean,\n\t// should we use forced errors checking\n\t// to make all inherited types errored\n\t// if there is an error somewhere in chain\n\tblockErrors?: boolean,\n\t// if it is necessary to collect stack\n\t// as a __stack__ prototype property\n\t// during the process of instance creation\n\tsubmitStack?: boolean,\n\t// await new Constructor()\n\t// must return value\n\tawaitReturn?: boolean,\n\t// Force class mode (auto-detected by default)\n\tasClass?: boolean,\n};\n\n// Subtypes map - represents the subtypes property\nexport type SubtypesMap = Map<string, TypeClass>;\n\n// Type definition object (internal properties)\nexport type TypeDef = {\n\tTypeName: string;\n\tproto: object;\n\tisSubType: boolean;\n\tsubtypes: SubtypesMap;\n\tcollection: CollectionDef;\n\tconfig: constructorOptions;\n\tparentType?: TypeDef;\n\tconstructHandler: MnemonicaConstructorFactory;\n\ttitle: string;\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook: (hookType: hooksTypes, opts: hooksOpts) => Set<unknown>;\n\tprototype: unknown;\n\tstack?: string;\n\t[Symbol.hasInstance]: (instance: object) => boolean;\n};\n\n// Collection definition\nexport type CollectionDef = Hookable & {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n};\n\n// Type lookup function type: may have augmentation by Tactica re-definition\nexport interface TypeLookup extends CallableFunction {\n\t(this: Map<string, unknown>, TypeNestedPath: string): TypeClass | undefined;\n}\n\n// Specification for chained subtype creation with .then()\nexport interface ThenSpec {\n\tsubtype: object;\n\targs: unknown[];\n\tname?: string;\n}\n\n// Context object passed through the InstanceCreator pipeline\nexport interface InstanceCreatorContext {\n\ttype: TypeDef;\n\tTypeName: string;\n\texistentInstance: object;\n\targs: unknown[];\n\tModificationConstructor: ModificationConstructor;\n\tModificatorType: MnemonicaConstructor;\n\tInstanceModificator: MnemonicaConstructor;\n\tinheritedInstance: object | Promise<object>;\n\tconfig: constructorOptions;\n\tproto: object;\n\t__proto_proto__?: object;\n\tstack?: string[];\n\n\tgetExistentAsyncStack(existentInstance: object): unknown;\n\tpostProcessing(continuationOf?: TypeDef): void;\n\tmakeAwaiter(type: TypeDef, then?: ThenSpec): Promise<object>;\n\taddThen(then: ThenSpec): void;\n\tinvokePreHooks(): void;\n\tinvokePostHooks(): { type: Set<unknown>; collection: Set<unknown> };\n\tthrowModificationError(error: MnemonicaError): void;\n}\n\n/**\n * Proto merge type - combines parent and child types without property conflicts.\n *\n * When a subtype is defined from a parent instance, we want the child properties\n * to take precedence. `Exclude<keyof P, keyof T>` removes overlapping keys from P,\n * so `Pick<P, ...>` only brings in parent properties that don't clash with child.\n *\n * Result: child T gets all its own props, plus parent's non-overlapping props.\n */\nexport type Proto<P extends object, T extends object> = T & Pick<P, Exclude<keyof P, keyof T>>;\n\n\n// export type ProtoFlat<\n// \tP extends object,\n// \tT extends object,\n// \tF extends Proto<P, T> = Proto<P, T>\n// > = { [key in keyof F]: F[key]} ;\n\nexport type ProtoFlat<\n\tP extends object,\n\tT extends object,\n\tL extends Exclude<keyof P, keyof T> = Exclude<keyof P, keyof T>,\n> = {\n    [key in keyof T]: T[key];\n} & {\n\t[key in L]: P[key];\n};\n\n// Mnemonica instance method keys. These are filtered out of extracted/merged\n// field-only views because they belong to the prototype, not to the user's\n// enumerable data properties.\nexport type MnemonicaInstanceMethodKeys =\n\t'extract' | 'pick' | 'parent' | 'clone' | 'fork' | 'exception' | 'sibling';\n\nexport type Flatten<F> = { [key in keyof F]: F[key] }\n\n// Extracted<T>: the shape returned by utils.extract(instance).\n// It contains the enumerable string-keyed user properties of the instance,\n// omitting MnemonicaInstance methods (extract, pick, parent, clone, fork,\n// exception, sibling). Optionality is preserved from the source type.\n// The `& {}` trick forces TypeScript to expand the alias in hover tooltips\n// so it renders as a plain object literal instead of \"Extracted<{...}>\".\nexport type Extracted<T extends object> = {\n\t[K in keyof T as K extends string ? (K extends MnemonicaInstanceMethodKeys ? never : K) : never]: T[K];\n} & {};\n\n// Parsed<T>: the shape returned by utils.parse(instance).\n// It is a one-level snapshot of the instance's prototype chain.\n// `props` contains the instance's enumerable user properties;\n// `joint` contains enumerable properties copied from the immediate prototype;\n// `parent` is the next link up the chain (currently not recursively parsed).\nexport type Parsed<T extends object> = {\n\tname: string;\n\tprops: Extracted<T>;\n\tself: T;\n\tproto: object;\n\tjoint: Record<string, unknown>;\n\tparent: object | undefined;\n};\n\n// Sibling type accessor\nexport interface SiblingAccessor {\n\t(SiblingTypeName: string): TypeClass | undefined;\n\t[key: string]: TypeClass | undefined;\n}\n\n// Mnemonica instance methods interface (opt-in).\n// These methods used to be auto-injected onto every instance. They are now\n// available only when a type explicitly adds them to its prototype.\n// Users can still use this interface to type their own root-level helpers.\nexport interface MnemonicaInstance<T extends object = object> {\n\textract(): Extracted<T>;\n\tpick<K extends keyof T>(...keys: (K | K[])[]): { [P in K]: T[P] } & {};\n\tpick(...keys: string[]): Record<string, unknown>;\n\tparent(): object | undefined;\n\tparent(constructorLookupPath: string): object | undefined;\n\treadonly clone: this;\n\tfork(...forkArgs: unknown[]): this;\n\texception(error: Error, ...args: unknown[]): Error;\n\treadonly sibling: SiblingAccessor;\n}\n\n// Instance properties for __self__ reference\n// This merges internal props with the instance methods\n// Internal instance properties (non-enumerable)\n// These are always present on instances but accessed via getProps/setProps\nexport type InstanceInternalProps = {\n\t__proto_proto__: object;\n\t__args__: unknown[];\n\t__collection__: CollectionDef;\n\t__subtypes__: Map<string, object>;\n\t__type__: TypeDef;\n\t__parent__: object;\n\t__stack__?: string;\n\t__creator__: InstanceCreatorContext;\n\t__timestamp__: number;\n};\n\n// Combined Props type for internal use inside ./src\nexport type Props = InstanceInternalProps & {\n\t__self__: InstanceInternalProps;\n\t[key: string]: unknown;\n};\n\n// Combined instance type: plain object with the user's fields only.\n// Instance methods (extract, pick, fork, etc.) are no longer auto-injected.\n// The inline mapped type is used instead of the Flatten alias so that hover\n// tooltips show the actual field object literal first, not \"Flatten<{...}>\".\nexport type InstanceResult<\n  N extends object,\n> = { [K in keyof N]: N[K] };\n\n// Definitor instance - the constructor function returned by define\n// N = instance type (properties available on instances)\n// S = subtypes map\nexport interface IDefinitorInstance<\n\tN extends object,\n\tR extends InstanceResult<N> = InstanceResult<N>\n> {\n\n\tTypeName: string;\n\tprototype: N;\n\n\t\n\t// the line below declares a `new ...` invocation,\n\t// so makes interface constructible\n\t// new(...args: unknown[]): { [key in keyof R]: R[key] };\n\tnew(...args: unknown[]): R;\n\n\t\n\t// TODO: need check if line below works\n\t// also TS hinting check as well\n\t// the line below should make is a @decorate decorator working\n\t(...args: unknown[]): IDefinitorInstance<R>;\n\n\n\t// Define method that combines parent N with new type T using Proto\n\tdefine<\n\t\tT extends object,\n\n\t\t// this will be instance type for sub-type !!!\n\t\t// F extends Flatten<Proto<N, T>>\n\t\tF extends Proto<N, T>\n\t>(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<F>;\n\t\n\tlookup: TypeLookup;\n\t\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\n\t\n\tsubtypes: SubtypesMap;\n\t\n\t// Internal properties accessed by tests\n\t__type__?: TypeDef;\n\tcollection?: CollectionDef;\n\n\t/*\n\t// Allow dynamic property access for subtypes\n\t[key: string]: unknown;\n\t*/\n}\n\n// Type absorber function type - used for defining subtypes\n// Supports multiple calling conventions:\n// 1. Modern: define(TypeName, constructHandler, config?)\n// 2. Legacy: define(constructHandler, config?) - TypeName from constructor name\n// 3. Nested: parentType.define(TypeName, constructHandler, config?)\nexport interface TypeAbsorber extends CallableFunction {\n\t<T extends object>(\n\t\tthis: unknown,\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<T>;\n}\n\n// TypesCollection interface for createTypesCollection\n// This represents the actual return type of createTypesCollection\nexport interface TypesCollection extends Hookable {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n}\n\n// Shared interface for objects that support hooks (TypeDef and CollectionDef)\nexport interface Hookable {\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook(hookType: hooksTypes, opts: hooksOpts): Set<unknown>;\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\tregisterFlowChecker(cb: (opts: object) => unknown): void;\n}\n\n// createTypesCollection function type\nexport type CreateTypesCollectionFunction = (config?: constructorOptions) => TypesCollection;\n\n// Type class - base type constructor\nexport type TypeClass = IDefinitorInstance<object>;\n\n// Mnemonica constructor — the constructor function returned by constructHandler()\n// Has SymbolConstructorName attached and is both newable and callable\nexport interface MnemonicaConstructor extends NewableFunction {\n\tnew (...args: unknown[]): object;\n\t(this: object, ...args: unknown[]): unknown;\n\t[key: symbol]: unknown;\n}\n\n// Type descriptor instance — internal shape of TypeDescriptor objects\nexport interface TypeDescriptorDefine extends CallableFunction {\n\t(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: CallableFunction | object,\n\t\tconfig?: object\n\t): TypeClass;\n}\n\nexport interface TypeDescriptorLookup extends CallableFunction {\n\t(TypeNestedPath: string): TypeClass | undefined;\n}\n\nexport type TypeDescriptorInstance = {\n\tdefine: TypeDescriptorDefine;\n\tlookup: TypeDescriptorLookup;\n\tsubtypes: Map<string, object>;\n\tTypeName: string;\n};\n\n// Constructor type for decorate function\nexport type Constructor<T = object> = new (...args: unknown[]) => T;\n\n// Decorated class type - includes call signature for decorator pattern\nexport type DecoratedClass<T extends Constructor<object>> =\n\tT &\n\t(<U extends Constructor<object>>(target: U) => DecoratedClass<U>) & {\n\t\tdefine: TypeAbsorber;\n\t\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\tlookup: TypeLookup;\n\t\tTypeName: string;\n\t};\n\n// Helper: merge parent entity (E) and child constructor instance (T) into a\n// single flat object type, filtering out MnemonicaInstance method names.\n// Used by apply/call/bind.\nexport type Merge<E extends object, T extends object> = {\n\t[K in keyof T | keyof E as K extends MnemonicaInstanceMethodKeys ? never : K]:\n\t\tK extends keyof T ? T[K] : E[K & keyof E];\n};\n\n// Apply/Call/Bind function types\n// The return type merges the parent entity fields with the child constructor\n// fields (filtering out MnemonicaInstance method names), producing the same\n// `{ fields }` hover style as `new Type()`.\nexport interface ApplyFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>,\n\t\targs?: unknown[]\n\t): InstanceResult<Merge<E, T>>;\n}\n\nexport interface CallFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>,\n\t\t...args: unknown[]\n\t): InstanceResult<Merge<E, T>>;\n}\n\nexport interface BindFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>\n\t): (...args: unknown[]) => InstanceResult<Merge<E, T>>;\n}\n\n// Utils object type\nexport interface UtilsCollection {\n\textract<T extends object>(instance: T): Extracted<T>;\n\tpick<T extends object, K extends keyof T>(instance: T, ...args: (K | K[])[]): { [P in K]: T[P] } & {};\n\tpick<T extends object>(instance: T, ...args: (string | string[])[]): Record<string, unknown>;\n\tclone<T extends object>(instance: T): T;\n\tfork<T extends object>(instance: T): (this: object, ...forkArgs: unknown[]) => T;\n\tsibling(instance: object): SiblingAccessor;\n\tcollectConstructors: (instance: object, flat?: boolean) => (CallableFunction | string)[];\n\tmerge<A extends object, B extends object>(\n\t\ta: A,\n\t\tb: B,\n\t\t...args: unknown[]\n\t): InstanceResult<Merge<B, A>>;\n\tparse<T extends object>(self: T): Parsed<T>;\n\tparent<T extends object>(instance: T, path?: string): object | undefined;\n\ttoJSON<T extends object>(instance: T): string;\n\t[key: string]: CallableFunction;\n}\n\n// Main mnemonica module interface - represents the exported module object\nexport interface MnemonicaModule {\n\t// Core functions\n\tdefine: TypeAbsorber;\n\tlookup: (TypeNestedPath: string) => TypeClass | undefined;\n\tapply: ApplyFunction;\n\tcall: CallFunction;\n\tbind: BindFunction;\n\tdecorate: <T extends Constructor<object> | constructorOptions | undefined = undefined>(\n\t\ttarget?: T,\n\t\tconfig?: constructorOptions\n\t) => <U extends Constructor<object>>(cstr: U) => DecoratedClass<U>;\n\tregisterHook: <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook) => void;\n\n\t// Descriptors\n\tdefaultTypes: TypesCollection;\n\n\t// Errors\n\tBASE_MNEMONICA_ERROR: MnemonicaErrorConstructor;\n\tWRONG_TYPE_DEFINITION: MnemonicaErrorConstructor;\n\tWRONG_INSTANCE_INVOCATION: MnemonicaErrorConstructor;\n\tWRONG_MODIFICATION_PATTERN: MnemonicaErrorConstructor;\n\tALREADY_DECLARED: MnemonicaErrorConstructor;\n\tWRONG_ARGUMENTS_USED: MnemonicaErrorConstructor;\n\tWRONG_HOOK_TYPE: MnemonicaErrorConstructor;\n\tMISSING_CALLBACK_ARGUMENT: MnemonicaErrorConstructor;\n\t// FLOW_CHECKER_REDEFINITION: MnemonicaErrorConstructor;\n\tMISSING_HOOK_CALLBACK: MnemonicaErrorConstructor;\n\tTYPENAME_MUST_BE_A_STRING: MnemonicaErrorConstructor;\n\tHANDLER_MUST_BE_A_FUNCTION: MnemonicaErrorConstructor;\n\tOPTIONS_ERROR: MnemonicaErrorConstructor;\n\tWRONG_STACK_CLEANER: MnemonicaErrorConstructor;\n\n\t// Constants\n\tMNEMONICA: string;\n\tMNEMOSYNE: string;\n\tSymbolParentType: symbol;\n\tSymbolConstructorName: symbol;\n\tSymbolDefaultTypesCollection: symbol;\n\tSymbolConfig: symbol;\n\tTYPE_TITLE_PREFIX: string;\n\tErrorMessages: ErrorMessages;\n\n\t// Utils\n\tutils: UtilsCollection;\n\tgetProps: (instance: object) => PropsType | undefined;\n\tsetProps: (instance: object, values: object) => string[] | false;\n\tfindSubTypeFromParent: (instance: object | undefined, subType: string) => object | null;\n\tisClass: (fn: CallableFunction) => boolean;\n\n\t// createTypesCollection\n\tcreateTypesCollection: CreateTypesCollectionFunction;\n\n\t// Allow additional properties\n\t[key: string]: unknown;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC","sourcesContent":["'use strict';\n/* eslint no-unused-vars: \"off\" */\n\nimport type { TypeRegistry } from '../index';\n\n// Props type for getProps/setProps\nexport type PropsType = Record<string, unknown>;\n\n// Core type definitions for mnemonica\n\n// Base constructor function type - can be a class constructor or a function.\n// Args defaults to unknown[] so IDEF<T> is backwards compatible;\n// supply Args to get typed constructor params: IDEF<MyType, [string, number]>\nexport type IDEF<T, Args extends unknown[] = unknown[]> = { new(): T } | { (this: T, ...args: Args): void };\n\n// Error message types - all error messages are strings\nexport type ErrorMessageKey =\n\t| 'BASE_ERROR_MESSAGE'\n\t| 'HANDLER_MUST_BE_A_FUNCTION'\n\t| 'WRONG_TYPE_DEFINITION'\n\t| 'WRONG_INSTANCE_INVOCATION'\n\t| 'WRONG_MODIFICATION_PATTERN'\n\t| 'ALREADY_DECLARED'\n\t| 'WRONG_ARGUMENTS_USED'\n\t| 'WRONG_HOOK_TYPE'\n\t| 'MISSING_HOOK_CALLBACK'\n\t| 'MISSING_CALLBACK_ARGUMENT'\n\t| 'OPTIONS_ERROR'\n\t| 'WRONG_STACK_CLEANER';\n\t// | 'TYPENAME_MUST_BE_A_STRING'\n\t// | 'FLOW_CHECKER_REDEFINITION'\n\n// Error messages object type\nexport type ErrorMessages = Record<ErrorMessageKey, string>;\n\n// Hook callback — passed to registerHook and invoked by invokeHook\nexport interface hook extends CallableFunction {\n\t(opts: hooksOpts): unknown;\n}\n\n// Error constructor from constructError - constructable function with prototype\nexport interface MnemonicaErrorConstructor {\n\tnew(addition?: string, stack?: string | string[]): Error;\n\t(name: string): Error;\n\tprototype: {\n\t\tconstructor: MnemonicaErrorConstructor;\n\t};\n}\n\n// Errors types map - indexable record of error constructors\nexport type ErrorsTypesMap = Record<string, MnemonicaErrorConstructor>;\n\n// Mnemonica error interface for extended Error objects\nexport interface MnemonicaError extends Error {\n\texceptionReason?: Error;\n\treasons?: Error[];\n\tsurplus?: Error[];\n}\n\n/**\n * Internal Type Constructor.\n * \"Type\" here is used in the Computer Science sense — an interface/contract\n * describing what a constructor must satisfy (both `new`-able and callable).\n * TC = Type Constructor; \"Internal\" means this is the library's own constructor\n * shape, distinct from user-facing TypeConstructor below.\n */\nexport interface _Internal_TC_<ConstructorInstance extends object> {\n\tnew(...args: unknown[]): ConstructorInstance;\n\t(this: ConstructorInstance, ...args: unknown[]): ConstructorInstance;\n\treadonly prototype: ConstructorInstance & {\n\t\treadonly constructor: _Internal_TC_<ConstructorInstance>\n\t};\n}\n\n/**\n * Public alias for _Internal_TC_ — the shape of constructor functions returned by `define()`.\n * Augmented by tactica-generated TypeRegistry to become user-specific types.\n * Kept as a named alias (rather than inlining _Internal_TC_) so tactica can reference it\n * cleanly in generated declaration files.\n */\nexport type TypeConstructor<ConstructorInstance extends object> = _Internal_TC_<ConstructorInstance>;\n\n/**\n * Minimal constructor shape used for the TypeRegistry index signature.\n * It accepts any mnemonica-compatible constructor, but deliberately returns\n * `object` so unaugmented registry lookups are not useful without an explicit\n * per-key constructor type.\n */\nexport interface TypeConstructorBase {\n\tnew (...args: unknown[]): object;\n}\n\n/**\n * Instance type produced by a TypeRegistry constructor.\n */\nexport type InstanceOfTypeRegistry<K extends keyof TypeRegistry> =\n\tTypeRegistry[K] extends new (...args: unknown[]) => infer R ? R : never;\n\n\n/**\n * Extract only the literal string keys of a type, filtering out generic\n * index signatures. This lets us iterate over augmented TypeRegistry keys\n * without picking up the `[key: string]` signature.\n */\nexport type LiteralKeysOf<T> = keyof T extends infer K\n\t? K extends string\n\t\t? string extends K ? never : K\n\t\t: never\n\t: never;\n\n/**\n * Given a dotted TypeRegistry key, extract the parent path.\n * `ParentPath<'A.B.C'>` → `'A.B'`.\n */\nexport type ParentPath<K extends string> =\n\tK extends `${infer P}.${string}` ? P : never;\n\n/**\n * Given a dotted TypeRegistry key, return the union of all ancestor prefixes.\n * `AllParentPrefixes<'A.B.C'>` → `'A' | 'A.B'`.\n */\nexport type AllParentPrefixes<K extends string> =\n\tK extends `${infer P}.${string}` ? P | AllParentPrefixes<P> : never;\n\n/**\n * Given a parent path, return the union of TypeRegistry keys that are direct\n * or indirect children of that path.\n */\nexport type ChildKeysOf<P extends string> = {\n\t[K in keyof TypeRegistry]: K extends `${P}.${string}` ? K : never\n}[keyof TypeRegistry];\n\n/**\n * Given an instance type, find the TypeRegistry key(s) whose constructor\n * returns that instance type. This inverts the registry at the type level\n * so utilities like `parent()` can derive an instance's path from its\n * type alone.\n */\nexport type PathOfInstance<T extends object> = {\n\t[K in LiteralKeysOf<TypeRegistry>]: TypeRegistry[K] extends new (...args: unknown[]) => infer R\n\t\t? T extends R ? K : never\n\t\t: never\n}[LiteralKeysOf<TypeRegistry>];\n\n/**\n * Given an instance type, return the union of TypeRegistry paths that are\n * valid parent lookups for that instance. Root types produce `never` because\n * they have no parent path.\n */\nexport type ParentPathOfInstance<T extends object> = {\n\t[K in LiteralKeysOf<TypeRegistry>]: TypeRegistry[K] extends new (...args: unknown[]) => infer R\n\t\t? T extends R ? AllParentPrefixes<K> : never\n\t\t: never\n}[LiteralKeysOf<TypeRegistry>];\n\n// Hook types\nexport type hooksTypes = 'preCreation' | 'postCreation' | 'creationError';\n\n// Hook options passed to hook callbacks\n// P = parent / existent instance (proto)\n// T = child / inherited instance (type being created)\nexport type hooksOpts<P = object, T = P> = {\n\tTypeName: string;\n\ttype: TypeDef;\n\targs: unknown[];\n\texistentInstance: P;\n\tinheritedInstance?: T;\n\tcreator?: { throwModificationError(error: Error): void };\n};\n\n// Callback passed into ModificationConstructor to attach internal props to the prototype\nexport interface AddPropsCallback extends CallableFunction {\n\t(proto: object): void;\n}\n\n// ModificationConstructor: wires prototype chain during instance creation\nexport interface ModificationConstructor extends CallableFunction {\n\t(\n\t\tthis: object,\n\t\tModificatorType: MnemonicaConstructor,\n\t\tModificatorTypePrototype: object,\n\t\t_addProps: AddPropsCallback\n\t): MnemonicaConstructor;\n}\n\n// Factory that returns a ModificationConstructor (used in constructorOptions)\nexport interface ModificationConstructorFactory extends CallableFunction {\n\t(): ModificationConstructor;\n}\n\n// Factory that returns a MnemonicaConstructor (stored in TypeDef.constructHandler)\nexport interface MnemonicaConstructorFactory extends CallableFunction {\n\t(): MnemonicaConstructor;\n}\n\n// Marks the top of a captured stack trace (passed to Error.captureStackTrace as constructorOpt)\nexport interface StackBoundary extends CallableFunction {}\n\n// A wrappable utility method — any callable that wrapThis() can proxy\nexport interface WrappableMethod extends CallableFunction {}\n\n// Constructor options for define\nexport type constructorOptions = {\n\t// explicit declaration we wish use\n\t// an old style based constructors\n\tModificationConstructor?: ModificationConstructorFactory,\n\t// shall or not we use strict checking\n\t// for creation sub-instances Only from current type\n\t// or we might use up-nested sub-instances from chain\n\tstrictChain?: boolean,\n\t// should we use forced errors checking\n\t// to make all inherited types errored\n\t// if there is an error somewhere in chain\n\tblockErrors?: boolean,\n\t// if it is necessary to collect stack\n\t// as a __stack__ prototype property\n\t// during the process of instance creation\n\tsubmitStack?: boolean,\n\t// await new Constructor()\n\t// must return value\n\tawaitReturn?: boolean,\n\t// Force class mode (auto-detected by default)\n\tasClass?: boolean,\n};\n\n// Subtypes map - represents the subtypes property\nexport type SubtypesMap = Map<string, TypeClass>;\n\n// Type definition object (internal properties)\nexport type TypeDef = {\n\tTypeName: string;\n\tproto: object;\n\tisSubType: boolean;\n\tsubtypes: SubtypesMap;\n\tcollection: CollectionDef;\n\tconfig: constructorOptions;\n\tparentType?: TypeDef;\n\tconstructHandler: MnemonicaConstructorFactory;\n\ttitle: string;\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook: (hookType: hooksTypes, opts: hooksOpts) => Set<unknown>;\n\tprototype: unknown;\n\tstack?: string;\n\t[Symbol.hasInstance]: (instance: object) => boolean;\n};\n\n// Collection definition\nexport type CollectionDef = Hookable & {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n};\n\n// Type lookup function type: may have augmentation by Tactica re-definition\nexport interface TypeLookup extends CallableFunction {\n\t(this: Map<string, unknown>, TypeNestedPath: string): TypeClass | undefined;\n}\n\n// Specification for chained subtype creation with .then()\nexport interface ThenSpec {\n\tsubtype: object;\n\targs: unknown[];\n\tname?: string;\n}\n\n// Context object passed through the InstanceCreator pipeline\nexport interface InstanceCreatorContext {\n\ttype: TypeDef;\n\tTypeName: string;\n\texistentInstance: object;\n\targs: unknown[];\n\tModificationConstructor: ModificationConstructor;\n\tModificatorType: MnemonicaConstructor;\n\tInstanceModificator: MnemonicaConstructor;\n\tinheritedInstance: object | Promise<object>;\n\tconfig: constructorOptions;\n\tproto: object;\n\t__proto_proto__?: object;\n\tstack?: string[];\n\n\tgetExistentAsyncStack(existentInstance: object): unknown;\n\tpostProcessing(continuationOf?: TypeDef): void;\n\tmakeAwaiter(type: TypeDef, then?: ThenSpec): Promise<object>;\n\taddThen(then: ThenSpec): void;\n\tinvokePreHooks(): void;\n\tinvokePostHooks(): { type: Set<unknown>; collection: Set<unknown> };\n\tthrowModificationError(error: MnemonicaError): void;\n}\n\n/**\n * Proto merge type - combines parent and child types without property conflicts.\n *\n * When a subtype is defined from a parent instance, we want the child properties\n * to take precedence. `Exclude<keyof P, keyof T>` removes overlapping keys from P,\n * so `Pick<P, ...>` only brings in parent properties that don't clash with child.\n *\n * Result: child T gets all its own props, plus parent's non-overlapping props.\n */\nexport type Proto<P extends object, T extends object> = T & Pick<P, Exclude<keyof P, keyof T>>;\n\n\n// export type ProtoFlat<\n// \tP extends object,\n// \tT extends object,\n// \tF extends Proto<P, T> = Proto<P, T>\n// > = { [key in keyof F]: F[key]} ;\n\nexport type ProtoFlat<\n\tP extends object,\n\tT extends object,\n\tL extends Exclude<keyof P, keyof T> = Exclude<keyof P, keyof T>,\n> = {\n    [key in keyof T]: T[key];\n} & {\n\t[key in L]: P[key];\n};\n\n// Mnemonica instance method keys. These are filtered out of extracted/merged\n// field-only views because they belong to the prototype, not to the user's\n// enumerable data properties.\nexport type MnemonicaInstanceMethodKeys =\n\t'extract' | 'pick' | 'parent' | 'clone' | 'fork' | 'exception' | 'sibling';\n\nexport type Flatten<F> = { [key in keyof F]: F[key] }\n\n// Extracted<T>: the shape returned by utils.extract(instance).\n// It contains the enumerable string-keyed user properties of the instance,\n// omitting MnemonicaInstance methods (extract, pick, parent, clone, fork,\n// exception, sibling). Optionality is preserved from the source type.\n// The `& {}` trick forces TypeScript to expand the alias in hover tooltips\n// so it renders as a plain object literal instead of \"Extracted<{...}>\".\nexport type Extracted<T extends object> = {\n\t[K in keyof T as K extends string ? (K extends MnemonicaInstanceMethodKeys ? never : K) : never]: T[K];\n} & {};\n\n// Parsed<T>: the shape returned by utils.parse(instance).\n// It is a one-level snapshot of the instance's prototype chain.\n// `props` contains the instance's enumerable user properties;\n// `joint` contains enumerable properties copied from the immediate prototype;\n// `parent` is the next link up the chain (currently not recursively parsed).\nexport type Parsed<T extends object> = {\n\tname: string;\n\tprops: Extracted<T>;\n\tself: T;\n\tproto: object;\n\tjoint: Record<string, unknown>;\n\tparent: object | undefined;\n};\n\n// Sibling type accessor\nexport interface SiblingAccessor {\n\t(SiblingTypeName: string): TypeClass | undefined;\n\t[key: string]: TypeClass | undefined;\n}\n\n// Mnemonica instance methods interface (opt-in).\n// These methods used to be auto-injected onto every instance. They are now\n// available only when a type explicitly adds them to its prototype.\n// Users can still use this interface to type their own root-level helpers.\nexport interface MnemonicaInstance<T extends object = object> {\n\textract(): Extracted<T>;\n\tpick<K extends keyof T>(...keys: (K | K[])[]): { [P in K]: T[P] } & {};\n\tpick(...keys: string[]): Record<string, unknown>;\n\tparent(): object | undefined;\n\tparent<K extends ParentPathOfInstance<this> & string>(\n\t\tconstructorLookupPath: K\n\t): InstanceOfTypeRegistry<K> | undefined;\n\tparent(constructorLookupPath: string): object | undefined;\n\treadonly clone: this;\n\tfork(...forkArgs: unknown[]): this;\n\texception(error: Error, ...args: unknown[]): Error;\n\treadonly sibling: SiblingAccessor;\n}\n\n// Instance properties for __self__ reference\n// This merges internal props with the instance methods\n// Internal instance properties (non-enumerable)\n// These are always present on instances but accessed via getProps/setProps\nexport type InstanceInternalProps = {\n\t__proto_proto__: object;\n\t__args__: unknown[];\n\t__collection__: CollectionDef;\n\t__subtypes__: Map<string, object>;\n\t__type__: TypeDef;\n\t__parent__: object;\n\t__stack__?: string;\n\t__creator__: InstanceCreatorContext;\n\t__timestamp__: number;\n};\n\n// Combined Props type for internal use inside ./src\nexport type Props = InstanceInternalProps & {\n\t__self__: InstanceInternalProps;\n\t[key: string]: unknown;\n};\n\n// Combined instance type: plain object with the user's fields only.\n// Instance methods (extract, pick, fork, etc.) are no longer auto-injected.\n// The inline mapped type is used instead of the Flatten alias so that hover\n// tooltips show the actual field object literal first, not \"Flatten<{...}>\".\nexport type InstanceResult<\n  N extends object,\n> = { [K in keyof N]: N[K] };\n\n// Definitor instance - the constructor function returned by define\n// N = instance type (properties available on instances)\n// S = subtypes map\nexport interface IDefinitorInstance<\n\tN extends object,\n\tR extends InstanceResult<N> = InstanceResult<N>\n> {\n\n\tTypeName: string;\n\tprototype: N;\n\n\t\n\t// the line below declares a `new ...` invocation,\n\t// so makes interface constructible\n\t// new(...args: unknown[]): { [key in keyof R]: R[key] };\n\tnew(...args: unknown[]): R;\n\n\t\n\t// TODO: need check if line below works\n\t// also TS hinting check as well\n\t// the line below should make is a @decorate decorator working\n\t(...args: unknown[]): IDefinitorInstance<R>;\n\n\n\t// Define method that combines parent N with new type T using Proto\n\tdefine<\n\t\tT extends object,\n\n\t\t// this will be instance type for sub-type !!!\n\t\t// F extends Flatten<Proto<N, T>>\n\t\tF extends Proto<N, T>\n\t>(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<F>;\n\t\n\tlookup: TypeLookup;\n\t\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\n\t\n\tsubtypes: SubtypesMap;\n\t\n\t// Internal properties accessed by tests\n\t__type__?: TypeDef;\n\tcollection?: CollectionDef;\n\n\t/*\n\t// Allow dynamic property access for subtypes\n\t[key: string]: unknown;\n\t*/\n}\n\n// Type absorber function type - used for defining subtypes\n// Supports multiple calling conventions:\n// 1. Modern: define(TypeName, constructHandler, config?)\n// 2. Legacy: define(constructHandler, config?) - TypeName from constructor name\n// 3. Nested: parentType.define(TypeName, constructHandler, config?)\nexport interface TypeAbsorber extends CallableFunction {\n\t<T extends object>(\n\t\tthis: unknown,\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<T>;\n}\n\n// TypesCollection interface for createTypesCollection\n// This represents the actual return type of createTypesCollection\nexport interface TypesCollection extends Hookable {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n}\n\n// Shared interface for objects that support hooks (TypeDef and CollectionDef)\nexport interface Hookable {\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook(hookType: hooksTypes, opts: hooksOpts): Set<unknown>;\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\tregisterFlowChecker(cb: (opts: object) => unknown): void;\n}\n\n// createTypesCollection function type\nexport type CreateTypesCollectionFunction = (config?: constructorOptions) => TypesCollection;\n\n// Type class - base type constructor\nexport type TypeClass = IDefinitorInstance<object>;\n\n// Mnemonica constructor — the constructor function returned by constructHandler()\n// Has SymbolConstructorName attached and is both newable and callable\nexport interface MnemonicaConstructor extends NewableFunction {\n\tnew (...args: unknown[]): object;\n\t(this: object, ...args: unknown[]): unknown;\n\t[key: symbol]: unknown;\n}\n\n// Type descriptor instance — internal shape of TypeDescriptor objects\nexport interface TypeDescriptorDefine extends CallableFunction {\n\t(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: CallableFunction | object,\n\t\tconfig?: object\n\t): TypeClass;\n}\n\nexport interface TypeDescriptorLookup extends CallableFunction {\n\t(TypeNestedPath: string): TypeClass | undefined;\n}\n\nexport type TypeDescriptorInstance = {\n\tdefine: TypeDescriptorDefine;\n\tlookup: TypeDescriptorLookup;\n\tsubtypes: Map<string, object>;\n\tTypeName: string;\n};\n\n// Constructor type for decorate function\nexport type Constructor<T = object> = new (...args: unknown[]) => T;\n\n// Decorated class type - includes call signature for decorator pattern\nexport type DecoratedClass<T extends Constructor<object>> =\n\tT &\n\t(<U extends Constructor<object>>(target: U) => DecoratedClass<U>) & {\n\t\tdefine: TypeAbsorber;\n\t\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\tlookup: TypeLookup;\n\t\tTypeName: string;\n\t};\n\n// Helper: merge parent entity (E) and child constructor instance (T) into a\n// single flat object type, filtering out MnemonicaInstance method names.\n// Used by apply/call/bind.\nexport type Merge<E extends object, T extends object> = {\n\t[K in keyof T | keyof E as K extends MnemonicaInstanceMethodKeys ? never : K]:\n\t\tK extends keyof T ? T[K] : E[K & keyof E];\n};\n\n// Apply/Call/Bind function types\n// The return type merges the parent entity fields with the child constructor\n// fields (filtering out MnemonicaInstance method names), producing the same\n// `{ fields }` hover style as `new Type()`.\nexport interface ApplyFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>,\n\t\targs?: unknown[]\n\t): InstanceResult<Merge<E, T>>;\n}\n\nexport interface CallFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>,\n\t\t...args: unknown[]\n\t): InstanceResult<Merge<E, T>>;\n}\n\nexport interface BindFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>\n\t): (...args: unknown[]) => InstanceResult<Merge<E, T>>;\n}\n\n// Utils object type\nexport interface UtilsCollection {\n\textract<T extends object>(instance: T): Extracted<T>;\n\tpick<T extends object, K extends keyof T>(instance: T, ...args: (K | K[])[]): { [P in K]: T[P] } & {};\n\tpick<T extends object>(instance: T, ...args: (string | string[])[]): Record<string, unknown>;\n\tclone<T extends object>(instance: T): T;\n\tfork<T extends object>(instance: T): (this: object, ...forkArgs: unknown[]) => T;\n\tsibling(instance: object): SiblingAccessor;\n\tcollectConstructors: (instance: object, flat?: boolean) => (CallableFunction | string)[];\n\tmerge<A extends object, B extends object>(\n\t\ta: A,\n\t\tb: B,\n\t\t...args: unknown[]\n\t): InstanceResult<Merge<B, A>>;\n\tparse<T extends object>(self: T): Parsed<T>;\n\tparent<T extends object>(instance: T): object | undefined;\n\tparent<T extends object, K extends ParentPathOfInstance<T> & string>(\n\t\tinstance: T,\n\t\tpath: K\n\t): InstanceOfTypeRegistry<K> | undefined;\n\tparent<T extends object>(instance: T, path: string): object | undefined;\n\ttoJSON<T extends object>(instance: T): string;\n\t[key: string]: CallableFunction;\n}\n\n// Main mnemonica module interface - represents the exported module object\nexport interface MnemonicaModule {\n\t// Core functions\n\tdefine: TypeAbsorber;\n\tlookup: {\n\t\t(TypeNestedPath: string): TypeClass | undefined;\n\t\t<const K extends keyof TypeRegistry>(TypeNestedPath: K): TypeRegistry[K];\n\t};\n\tapply: ApplyFunction;\n\tcall: CallFunction;\n\tbind: BindFunction;\n\tdecorate: <T extends Constructor<object> | constructorOptions | undefined = undefined>(\n\t\ttarget?: T,\n\t\tconfig?: constructorOptions\n\t) => <U extends Constructor<object>>(cstr: U) => DecoratedClass<U>;\n\tregisterHook: <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook) => void;\n\n\t// Descriptors\n\tdefaultTypes: TypesCollection;\n\n\t// Errors\n\tBASE_MNEMONICA_ERROR: MnemonicaErrorConstructor;\n\tWRONG_TYPE_DEFINITION: MnemonicaErrorConstructor;\n\tWRONG_INSTANCE_INVOCATION: MnemonicaErrorConstructor;\n\tWRONG_MODIFICATION_PATTERN: MnemonicaErrorConstructor;\n\tALREADY_DECLARED: MnemonicaErrorConstructor;\n\tWRONG_ARGUMENTS_USED: MnemonicaErrorConstructor;\n\tWRONG_HOOK_TYPE: MnemonicaErrorConstructor;\n\tMISSING_CALLBACK_ARGUMENT: MnemonicaErrorConstructor;\n\t// FLOW_CHECKER_REDEFINITION: MnemonicaErrorConstructor;\n\tMISSING_HOOK_CALLBACK: MnemonicaErrorConstructor;\n\tTYPENAME_MUST_BE_A_STRING: MnemonicaErrorConstructor;\n\tHANDLER_MUST_BE_A_FUNCTION: MnemonicaErrorConstructor;\n\tOPTIONS_ERROR: MnemonicaErrorConstructor;\n\tWRONG_STACK_CLEANER: MnemonicaErrorConstructor;\n\n\t// Constants\n\tMNEMONICA: string;\n\tMNEMOSYNE: string;\n\tSymbolParentType: symbol;\n\tSymbolConstructorName: symbol;\n\tSymbolDefaultTypesCollection: symbol;\n\tSymbolConfig: symbol;\n\tTYPE_TITLE_PREFIX: string;\n\tErrorMessages: ErrorMessages;\n\n\t// Utils\n\tutils: UtilsCollection;\n\tgetProps: (instance: object) => PropsType | undefined;\n\tsetProps: (instance: object, values: object) => string[] | false;\n\tfindSubTypeFromParent: (instance: object | undefined, subType: string) => object | null;\n\tisClass: (fn: CallableFunction) => boolean;\n\n\t// createTypesCollection\n\tcreateTypesCollection: CreateTypesCollectionFunction;\n\n\t// Allow additional properties\n\t[key: string]: unknown;\n}\n"]}

package/build/utils/parent.d.ts

@@ -1 +1,4 @@
-export declare const parent: <T extends object>(instance: T, path?: string) => object | undefined;
+import type { InstanceOfTypeRegistry, ParentPathOfInstance } from '../types';
+export declare function parent<T extends object>(instance: T): object | undefined;
+export declare function parent<T extends object, K extends ParentPathOfInstance<T> & string>(instance: T, path: K): InstanceOfTypeRegistry<K> | undefined;
+export declare function parent(instance: object, path: string): object | undefined;

package/build/utils/parent.js

@@ -1,10 +1,10 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parent = void 0;
+exports.parent = parent;
 const errors_1 = require("../descriptors/errors");
 const { WRONG_INSTANCE_INVOCATION } = errors_1.ErrorsTypes;
 const Props_1 = require("../api/types/Props");
-const parent = (instance, path) => {
+function parent(instance, path) {
     if (instance !== Object(instance)) {
         throw new WRONG_INSTANCE_INVOCATION;
     }
@@ -18,8 +18,7 @@ const parent = (instance, path) => {
     }
     const { constructor: { name } } = p;
     const result = name === path ?
-        p : (0, exports.parent)(p, path);
+        p : parent(p, path);
     return result;
-};
-exports.parent = parent;
-//# sourceMappingURL=data:application/json;base64,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
+}
+//# sourceMappingURL=data:application/json;base64,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

package/docs/UTILS.md

@@ -176,7 +176,7 @@ const parent: object | undefined = parsed.parent;
 
 - `utils.parent(instance, 'TypeName')` cannot return a specific nominal parent
   type without a user-augmented `TypeRegistry`. This is the same limitation as
-  `lookupTyped()`: TypeScript cannot retroactively learn the type graph created
+  `lookup()`: TypeScript cannot retroactively learn the type graph created
   by `define()` calls. See [`./typed-lookup.md`](./typed-lookup.md).
 - `utils.parse()` returns `parent` as `object | undefined` because deep recursive
   parsing is not implemented at runtime.

package/docs/ai-learning-trajectory.md

@@ -57,22 +57,22 @@ The user says: "Why are you still casting?"
 
 The agent's internal model: "Direct import gives me the constructor. The generated type gives me the shape. I need both, so I bridge them with a cast."
 
-This is wrong. The agent is thinking in two separate worlds — runtime and compile-time — instead of seeing that `lookupTyped` unifies them.
+This is wrong. The agent is thinking in two separate worlds — runtime and compile-time — instead of seeing that `lookup` unifies them.
 
 ---
 
 ## Phase 3: The Correction (Session 6)
 
-The user insists: "Use `lookupTyped`."
+The user insists: "Use `lookup`."
 
-The agent resists. "But I need the constructor for decoration too. `lookupTyped` is just for lookup, right?"
+The agent resists. "But I need the constructor for decoration too. `lookup` is just for lookup, right?"
 
 The user: "Try it. Move it to module level."
 
 The agent tries:
 
 ```typescript
-const RequestData = lookupTyped('RequestData');
+const RequestData = lookup('RequestData');
 app.decorate('RequestData', RequestData);
 const requestData = new RequestData({ ... });
 const routeData = new requestData.RouteData({ ... });
@@ -82,7 +82,7 @@ It compiles. No cast. TypeScript knows `.RouteData`. TypeScript knows the proper
 
 The agent checks: `RequestData === import('./collections/requestTypes.js').RequestData`? Yes. Same object.
 
-The epiphany: **The runtime object is identical. The only difference is TypeScript's knowledge.** `lookupTyped` doesn't change the runtime. It changes the compile-time view.
+The epiphany: **The runtime object is identical. The only difference is TypeScript's knowledge.** `lookup` doesn't change the runtime. It changes the compile-time view.
 
 ---
 
@@ -92,7 +92,7 @@ The agent documents everything:
 - `core/.ai/TACTICA-DEEP-DIVE.md` — comprehensive technical guide
 - `core/.ai/TACTICA-RULES.md` — agent instructions
 - `core/docs/tactica-pattern.md` — human-friendly explanation
-- `tactica/docs/lookupTyped-pattern.md` — consumption guide
+- `tactica/docs/lookup-pattern.md` — consumption guide
 
 The agent realizes: the pattern is simple, but the path to understanding it is not. The difficulty was not in the code. It was in unlearning the habit of casting.
 
@@ -131,11 +131,11 @@ If you are reading this, you are likely at Phase 0, 1, or 2.
 1. Read `core/.ai/TACTICA-RULES.md` (agent instructions)
 2. Read `core/docs/tactica-pattern.md` (human explanation)
 3. Check if `.tactica/` exists. If not, run `npx tactica`.
-4. Replace all direct imports + casts with `lookupTyped`.
+4. Replace all direct imports + casts with `lookup`.
 5. Run `tsc --noEmit`. Fix errors. Do not cast.
 6. Run tests. Verify.
 
-If you find yourself writing `as unknown as`, you have taken a wrong turn. Stop. Use `lookupTyped`. Trust the registry.
+If you find yourself writing `as unknown as`, you have taken a wrong turn. Stop. Use `lookup`. Trust the registry.
 
 ---
 

package/docs/async-constructors.md

@@ -175,6 +175,24 @@ console.log(child instanceof AsyncChild);  // true
 
 ---
 
+## Why Async Constructors Don't Double-Initialize: `_setSelf`
+
+When a constructor returns a Promise, the initial result of `new Constructor()` is that Promise. mnemonica's async pipeline waits for it to resolve, then must run validation and lifecycle hooks. But it must not run them again if the resolved instance is ever re-examined.
+
+`_setSelf(instance)` solves this by adding a `__self__` getter to the instance's internal props that returns the instance itself, and by storing the props under the instance in the internal `WeakMap`. `makeAwaiter` then checks:
+
+```js
+if (props.__self__ !== self.inheritedInstance) {
+  self.postProcessing(type);
+}
+```
+
+If `__self__` is missing or does not match the resolved instance, post-processing has not run yet, so mnemonica runs it. If it matches, post-processing has already happened and is skipped.
+
+This is how mnemonica handles a problem that has been open in TC39 for years: the constructor can return a Promise, and the library finalizes the instance only after the Promise resolves, using `__self__` as a completion marker.
+
+---
+
 ## Async Chains with Single Await
 
 mnemonica's most powerful async feature is chainable awaits:

package/docs/prototype-chain.md

@@ -0,0 +1,127 @@
+# The Prototype Chain
+
+Every mnemonica instance is the tip of a private prototype chain. This document explains what that chain looks like, what the intermediate layers do, and why they are necessary.
+
+---
+
+## A normal class chain vs a mnemonica chain
+
+In normal JavaScript classes:
+
+```js
+const alice = new Employee({ name: 'Alice' });
+// alice → Employee.prototype → Object.prototype
+```
+
+Every `Employee` instance shares the same `Employee.prototype`. If one request mutates that prototype, all instances are affected.
+
+In mnemonica:
+
+```js
+const UserType = define('UserType', function (data) {
+  Object.assign(this, data);
+});
+
+const user = new UserType({ name: 'Alice' });
+const admin = new user.AdminType({ role: 'admin' });
+const superadmin = new admin.SuperAdminType({ level: 9000 });
+```
+
+Each instance has its own fresh prototype objects above it. The chain for `superadmin` is:
+
+```
+superadmin
+  └── SuperAdminType.prototype
+        └── SuperAdmin memory layer
+              └── admin
+                    └── AdminType.prototype
+                          └── Admin memory layer
+                                └── user
+                                      └── UserType.prototype
+                                            └── User memory layer
+                                                  └── root Mnemosyne proxy
+```
+
+---
+
+## What each layer does
+
+### 1. The instance itself
+
+This is the object returned by `new user.AdminType(...)`. It holds only the properties your constructor assigned:
+
+```js
+superadmin.level === 9000;
+admin.role === 'admin';
+user.name === 'Alice';
+```
+
+### 2. The user prototype layer
+
+This layer holds the methods and getters you put on the type when you defined it:
+
+```js
+const AdminType = UserType.define('AdminType', function (data) {
+  Object.assign(this, data);
+}, {
+  proto: {
+    isAdmin() { return true; }
+  }
+});
+```
+
+`admin.isAdmin()` resolves on this layer. This prototype is **fresh per instance**, so one `admin` cannot pollute the prototype of another.
+
+### 3. The memory layer
+
+This is the invisible layer that makes mnemonica work. It:
+
+- stores the internal construction context (`__type__`, `__parent__`, `__args__`, `__timestamp__`, etc.) in a `WeakMap`, keyed by this layer;
+- provides `constructor` so `admin.constructor.name === 'AdminType'`;
+- links the instance to its parent instance, so `admin instanceof UserType` works.
+
+Because the props live in a `WeakMap` attached to the memory layer, they do **not** show up in `Object.keys(instance)` or `JSON.stringify(instance)`.
+
+For async constructors, the memory layer also receives a `__self__` marker after the Promise resolves. This lets mnemonica defer finalization until the async work is done without running validation and hooks twice.
+
+---
+
+## Why three layers per type?
+
+Normal JavaScript collapses these into one shared `prototype`. mnemonica separates them for three reasons:
+
+1. **Isolation.** Each construction gets fresh prototype objects, so mutations cannot leak between instances or between concurrent requests.
+2. **Identity-as-path.** The parent instance is physically in the prototype chain. `admin instanceof UserType` is true because `admin`’s chain walks up to the exact `user` instance it came from, not to a shared class prototype.
+3. **Clean enumeration.** Internal metadata is stored in a `WeakMap` keyed by the memory layer, not as own properties on the instance.
+
+---
+
+## Subtype lookup
+
+When you write `admin.SuperAdminType`, JavaScript walks the prototype chain until it reaches the **root Mnemosyne proxy**. That proxy looks up `SuperAdminType` in the type’s `__subtypes__` Map and returns a `SubTypeProxy`. When you call `new` on it, the proxy creates the new chain with `admin` as the parent.
+
+Only the root has a Proxy. All intermediate memory layers are plain objects; the root Proxy handles lookups for the whole branch.
+
+The Proxy is kept for an important reason: **subtypes can be defined after an instance already exists**, and the Proxy makes those new subtypes visible on existing instances by doing a live lookup in the type’s `__subtypes__` Map. If subtype constructors were attached to the memory layer at construction time, old instances would miss any subtypes added later.
+
+---
+
+## Your constructor’s `.prototype` is untouched
+
+When you call `define('AdminType', AdminConstructor)`, mnemonica takes a snapshot of `AdminConstructor.prototype`. During each construction it copies that snapshot onto a fresh `AdminType.prototype`. The original `AdminConstructor.prototype` is restored afterward. This is why you can reuse the same constructor function for several type definitions without cross-contamination.
+
+---
+
+## Classes and functions produce the same chain
+
+Whether you define a type with a `function` or a `class`, the final chain has the same shape. For classes, mnemonica generates a wrapper class that extends your class so `super()` works; after construction it rewires the chain to the same three-layer form.
+
+---
+
+## Summary
+
+- Each instance sits on a private, per-construction prototype stack.
+- The visible layer is the user prototype (methods and getters).
+- The invisible layer is the memory layer (internal props, parent link, constructor).
+- The root has a Proxy that answers all subtype lookups for its branch.
+- This design makes `instanceof`, `parent`, and path-based identity correct while keeping instance enumeration clean.

package/docs/purpose.md

@@ -417,16 +417,16 @@ npx tactica  # Analyze and generate types
 
 **Generated Files**:
 - `types.ts` - Complete TypeScript interfaces
-- `registry.ts` - TypeRegistry augmentation for `lookupTyped()`
+- `registry.ts` - TypeRegistry augmentation for `lookup()`
 - `definitions.json` - Type metadata (properties, location)
 - `usages.json` - Where types are instantiated
 
-**The Magic**: Enables type-safe `lookupTyped()`:
+**The Magic**: Enables type-safe `lookup()`:
 ```typescript
-import { lookupTyped } from 'mnemonica';
+import { lookup } from 'mnemonica';
 import './.tactica/registry';  // Augments TypeRegistry
 
-const UserType = lookupTyped('UserType');  // TypeScript knows the type!
+const UserType = lookup('UserType');  // TypeScript knows the type!
 const user = new UserType({ name: 'Alice' });  // Full intellisense!
 ```
 

package/docs/tactica-pattern.md

@@ -1,6 +1,6 @@
-# How `lookupTyped` works (and where tactica fits)
+# How `lookup` works (and where tactica fits)
 
-> The runtime Trie that mnemonica builds is invisible to TypeScript by default. The fix is one TypeScript-level pattern: declaration-merge mnemonica's `TypeRegistry` interface so that `lookupTyped(path)` resolves to a fully-typed constructor. The augmentation can be hand-written or generated by [`@mnemonica/tactica`](https://www.npmjs.com/package/@mnemonica/tactica). The runtime behaviour is identical either way.
+> The runtime Trie that mnemonica builds is invisible to TypeScript by default. The fix is one TypeScript-level pattern: declaration-merge mnemonica's `TypeRegistry` interface so that `lookup(path)` resolves to a fully-typed constructor. The augmentation can be hand-written or generated by [`@mnemonica/tactica`](https://www.npmjs.com/package/@mnemonica/tactica). The runtime behaviour is identical either way.
 >
 > For a side-by-side recipe of both paths, see [`./typed-lookup.md`](./typed-lookup.md).
 
@@ -8,7 +8,7 @@
 
 ## The problem in one sentence
 
-mnemonica builds a Trie of constructors at runtime. TypeScript has no idea the Trie exists. `lookupTyped` + an augmented `TypeRegistry` tells TypeScript.
+mnemonica builds a Trie of constructors at runtime. TypeScript has no idea the Trie exists. `lookup` + an augmented `TypeRegistry` tells TypeScript.
 
 Without that bridge, every chain operation requires a cast.
 
@@ -39,9 +39,9 @@ This is not type safety. This is type suppression.
 ## What the bridge looks like
 
 ```typescript
-import { lookupTyped } from 'mnemonica';
+import { lookup } from 'mnemonica';
 
-const RequestData = lookupTyped('RequestData');
+const RequestData = lookup('RequestData');
 
 const requestData = new RequestData({ method: 'GET', url: '/' });
 const routeData   = new requestData.RouteData({ pagePath: '/' });
@@ -111,13 +111,13 @@ See [`./typed-lookup.md`](./typed-lookup.md) for a side-by-side recipe with both
 
 ## The runtime is identical
 
-`lookupTyped('RequestData')` and `import { RequestData }` return the **same constructor object** at runtime. The only difference is what TypeScript sees at compile time:
+`lookup('RequestData')` and `import { RequestData }` return the **same constructor object** at runtime. The only difference is what TypeScript sees at compile time:
 
 | Approach | Runtime | Compile-time |
 |---|---|---|
 | Direct import without augmentation | ✅ Constructor works | ❌ TypeScript blind to sub-types |
-| `lookupTyped` with augmentation (manual) | ✅ Same constructor | ✅ TypeScript knows the Trie |
-| `lookupTyped` with augmentation (tactica) | ✅ Same constructor | ✅ TypeScript knows the Trie |
+| `lookup` with augmentation (manual) | ✅ Same constructor | ✅ TypeScript knows the Trie |
+| `lookup` with augmentation (tactica) | ✅ Same constructor | ✅ TypeScript knows the Trie |
 
 There is no runtime cost. There is no indirection. There is only **type safety, conditional on the augmentation being present**.
 
@@ -128,7 +128,7 @@ There is no runtime cost. There is no indirection. There is only **type safety,
 The anti-patterns are the same whether you augment by hand or via tactica:
 
 - Do not write `as unknown as` casts on mnemonica types.
-- Do not import constructors directly from collection files when `lookupTyped` would work.
+- Do not import constructors directly from collection files when `lookup` would work.
 - Do not accept "it compiles with casts" as good enough.
 
 What changes is how you keep the `TypeRegistry` augmentation in sync with your code:
@@ -142,6 +142,6 @@ Pick whichever fits your project. Both are first-class.
 
 ## Learn more
 
-- [`./typed-lookup.md`](./typed-lookup.md) — `lookupTyped` with or without tactica (canonical side-by-side reference)
+- [`./typed-lookup.md`](./typed-lookup.md) — `lookup` with or without tactica (canonical side-by-side reference)
 - [`../.ai/TACTICA-RULES.md`](../.ai/TACTICA-RULES.md) — anti-patterns and "when to insist on what"
 - [`../.ai/TACTICA-DEEP-DIVE.md`](../.ai/TACTICA-DEEP-DIVE.md) — comprehensive technical guide, declaration-merging deep dive

package/docs/typed-lookup.md

@@ -1,21 +1,25 @@
-# Typed lookup with `lookupTyped()` — with or without tactica
+# Typed lookup with `lookup()` — with or without tactica
 
-`lookupTyped()` is a runtime lookup with compile-time type safety. The type safety comes from one mechanism: declaration merging on the `TypeRegistry` interface that mnemonica exports. The path argument may use dots, slashes, colons, or bracket notation (e.g. `'UserType.AdminType'`, `'UserType/AdminType'`, `'UserType:AdminType'`, or `'UserType[AdminType]'`), and a single-segment name is resolved relative to the collection or type constructor the lookup is called on.
+`lookup()` is a runtime lookup with compile-time type safety. The type safety comes from one mechanism: declaration merging on the `TypeRegistry` interface that mnemonica exports. The path argument may use dots, slashes, colons, or bracket notation (e.g. `'UserType.AdminType'`, `'UserType/AdminType'`, `'UserType:AdminType'`, or `'UserType[AdminType]'`), and a single-segment name is resolved relative to the collection or type constructor the lookup is called on.
 
 ```typescript
 // src/index.ts (mnemonica core)
 export interface TypeRegistry {
-    [key: string]: TypeConstructor<never>;
+    // Intentionally empty. Augment this interface via declaration merging
+    // (hand-written or generated by @mnemonica/tactica).
 }
 
-export const lookupTyped = function <const K extends keyof TypeRegistry>(
-    path: K
-): TypeRegistry[K] {
-    return lookup(path as string) as TypeRegistry[K];
-};
+export function lookup<const K extends keyof TypeRegistry>(
+    this: unknown,
+    TypeNestedPath: K
+): TypeRegistry[K];
+export function lookup(
+    this: unknown,
+    TypeNestedPath: string
+): TypeClass | undefined;
 ```
 
-The `[key: string]: TypeConstructor<never>` index makes any lookup against an unaugmented registry resolve to a useless type. Until you (or a tool) augment `TypeRegistry`, `lookupTyped('Anything')` returns nothing useful at compile time.
+Until you (or a tool) augment `TypeRegistry`, `lookup('Anything')` falls back to the broad `TypeClass | undefined` return type.
 
 Two ways to do the augmentation: **by hand**, or via **[`@mnemonica/tactica`](https://www.npmjs.com/package/@mnemonica/tactica)**. Runtime behavior is identical. The trade-off is purely maintenance overhead.
 
@@ -44,7 +48,7 @@ Write a `.d.ts` file (or any `.ts` file outside the build output) with the augme
 // types/mnemonica-registry.d.ts
 import type { ProtoFlat } from 'mnemonica';
 
-// Instance shapes — what `lookupTyped` returns will construct.
+// Instance shapes — what `lookup` returns will construct.
 export type PersonInstance = {
     name : string;
     // Subtypes available on instances of this type:
@@ -75,10 +79,10 @@ Include the `.d.ts` in `tsconfig.json`:
 Use it:
 
 ```typescript
-import { lookupTyped } from 'mnemonica';
+import { lookup } from 'mnemonica';
 
-const Person   = lookupTyped('Person');           // fully typed
-const Employee = lookupTyped('Person.Employee');  // fully typed
+const Person   = lookup('Person');           // fully typed
+const Employee = lookup('Person.Employee');  // fully typed
 
 const alice    = new Person({ name: 'Alice' });
 const engineer = new alice.Employee({ role: 'Engineer' });  // alice.Employee is typed
@@ -122,7 +126,7 @@ You write nothing for the augmentation; tactica regenerates as your types evolve
 **Hand-augmented** is fine for:
 
 - Small projects (a handful of types)
-- Bootstrap / learning — writing the augmentation by hand is the fastest way to understand what `lookupTyped()` actually does
+- Bootstrap / learning — writing the augmentation by hand is the fastest way to understand what `lookup()` actually does
 - Projects that want to keep the `TypeRegistry` surface stable and curated, independent of source-code churn
 - Environments where running a CLI/codegen utility is inconvenient
 
@@ -149,7 +153,7 @@ const child       = new (instance as any).Child({ ... });
 
 ```typescript
 // ✓ instead
-const RequestData = lookupTyped('RequestData');
+const RequestData = lookup('RequestData');
 const requestData = new RequestData({ ... });
 const child       = new requestData.Child({ ... });
 ```

package/module/index.js

@@ -25,7 +25,6 @@ const m = mnemonicaModule;
 // defaultTypes` picks the namespace object (which has `.define` pointing back).
 export const define = m.define.bind(undefined);
 export const lookup = m.lookup.bind(undefined);
-export const lookupTyped = m.lookupTyped.bind(undefined);
 export const apply = m.apply.bind(undefined);
 export const call = m.call.bind(undefined);
 export const bind = m.bind.bind(undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mnemonica",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "AI-agent ready instance inheritance system for JavaScript/TypeScript via prototype chains",
   "type": "commonjs",
   "main": "./build/index.js",
@@ -98,6 +98,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.5",
     "@eslint/js": "^9.21.0",
+    "@mnemonica/tactica": "^0.1.2",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.19.21",
     "@typescript-eslint/eslint-plugin": "^8.61.1",

package/src/api/types/createInstanceModificator.ts

@@ -22,6 +22,19 @@ export default function () {
 		const existentInstance = this;
 
 		// inherited
+		// TODO: subtype constructors could be attached directly to this
+		// Mnemosyne object as non-enumerable getters, which would let us
+		// remove the root Mnemosyne Proxy entirely and rely on normal
+		// prototype-chain lookup for `instance.SubType`. Getters give lazy
+		// initialization, prevent accidental re-definition, and let each
+		// access rely on the current runtime state of the type graph
+		// (ModificatorType, ModificatorTypePrototype, and any factories that
+		// may produce new fields or constructors). That would simplify
+		// subtype access but would increase cyclomatic complexity here and
+		// would lose the ability to define new subtypes after the instance
+		// is created. Users who need dynamic post-creation definitions can
+		// use `.fork()` or `.clone()` to get fresh instances that carry the
+		// updated constructors on their chain.
 		const Mnemosyne = {};
 		Reflect.setPrototypeOf(
 			Mnemosyne,

package/src/descriptors/types/index.ts

@@ -257,7 +257,7 @@ interface TypesCollectionTarget {
 const typesCollectionProxyHandler = {
 	get ( target: TypesCollectionTarget, prop: string ) {
 		if ( target.subtypes.has( prop ) ) {
-			// access to suptype
+			// access to subtype
 			// for new call or defining new type
 			const subtypeResult = target.subtypes.get( prop );
 			return subtypeResult;