mnemonica 1.0.1 → 1.0.6

package/docs/purpose.md

@@ -48,6 +48,35 @@ for (item of items) {      // Control flow: iteration
 
 **Mnemonica does NOT touch this**: Algorithms remain unchanged. Services stay intact. Control flow is crafted by developers (and AI agents) as needed.
 
+### What Mnemonica Does NOT Do — Concrete Examples
+
+```typescript
+// ❌ Mnemonica does NOT replace if/else
+if (user.role === 'admin') {
+    // This logic is yours. Mnemonica provides the typed data,
+    // not the decision rule.
+}
+
+// ❌ Mnemonica does NOT replace loops
+for (const item of items) {
+    // Iteration control is yours.
+}
+
+// ❌ Mnemonica does NOT replace async/await orchestration
+const a = await serviceA.get();
+const b = await serviceB.process(a);
+// Mnemonica types the data, not the execution order.
+
+// ❌ Mnemonica does NOT replace service boundaries
+// You still write HTTP handlers, database queries, message queues.
+// Mnemonica types the data that flows through them.
+
+// ✅ Mnemonica DOES type the data at each stage
+const RequestData = define('RequestData', function(req) { this.method = req.method; });
+const ResponseData = RequestData.define('ResponseData', function(res) { this.body = res.body; });
+// The types track lineage; the services remain unchanged.
+```
+
 ---
 
 ## Part 2: The Problem - Data Without Memory
@@ -246,7 +275,7 @@ p instanceof Vector; // false - same shape, different nominal type!
 
 Mnemonica cares about **constructor identity**. Same shape, different type = not compatible.
 
-### Protected `constructor.name` - MITM-Resistant
+### Protected `constructor.name` - Defense-in-Depth
 
 Mnemonica types have **read-only, protected constructor names**:
 
@@ -261,11 +290,13 @@ user.constructor.name = 'Admin';  // ✗ Ignored/Fails - protected
 ```
 
 **Why This Matters**:
-- MITM (Man-in-the-Middle) attacks on prototype chains are **impossible**
-- An attacker cannot spoof a type by overwriting constructor names
-- `instanceof` checks are cryptographically reliable
+- Prototype pollution attacks that rely on name spoofing are **blocked at the assignment level**
+- `instanceof` checks **prototype object references**, not constructor names, so name changes do not affect type identity
+- Constructor names are getter-protected and non-enumerable, making casual tampering impossible
 - Type identity is immutable once established
 
+**Threat Model**: This is defense-in-depth, not cryptographic security. A fully compromised execution environment can still use `Object.defineProperty` to redefine the getter. The protection targets casual prototype pollution and accidental corruption, not a determined attacker with full runtime access.
+
 ### Security Through `Object.create(null)`
 
 Mnemonica instances are **NOT instances of Object or Function**:
@@ -501,8 +532,8 @@ const superAdmin = new SuperAdmin({});
 
 **The Hot Connection**: In HoTT, paths can be composed, inverted, and transformed. In Mnemonica:
 - **Composition**: `new user.SubType()` extends the path
-- **Inversion**: `instance.parent()` traverses backward
-- **Transformation**: `.fork()` creates a new path with same starting point
+- **Inversion**: `utils.parent(instance)` traverses backward
+- **Transformation**: `utils.fork(instance)` creates a new path with same starting point
 
 ### Higher Inductive Types: The Family Tree
 
@@ -640,7 +671,7 @@ console.log(props.__parent__);            // undefined (root type)
 - Historical reflection embedded in data structures
 - The DNA of data as it moves through systems
 - A **nominal type system** (constructor identity, not shape)
-- A **secure** system (MITM-resistant, prototype pollution immune)
+- A **secure** system (defense-in-depth against prototype pollution, nominal typing prevents type confusion)
 
 **Mnemonica Is NOT**:
 - A control flow framework

package/docs/tactica-pattern.md

@@ -88,22 +88,22 @@ Include the file in `tsconfig.json` `include`. You are done.
 
 ### Via tactica
 
-For projects with many types or for hands-off maintenance, install [`@mnemonica/tactica`](https://www.npmjs.com/package/@mnemonica/tactica) and configure it as a TS Language Service Plugin. It scans your `define()` calls and generates the augmentation continuously:
+For projects with many types or for hands-off maintenance, install [`@mnemonica/tactica`](https://www.npmjs.com/package/@mnemonica/tactica) and run it as a CLI/codegen utility. It scans your `define()` calls and generates the augmentation:
+
+```bash
+npm install --save-dev @mnemonica/tactica
+npx tactica --output ./.tactica --include "src/**/*.ts"
+```
+
+Include the generated files in `tsconfig.json`:
 
 ```json
 {
-    "compilerOptions": {
-        "plugins": [{
-            "name"      : "@mnemonica/tactica",
-            "outputDir" : ".tactica",
-            "include"   : ["src/**/*.ts"]
-        }]
-    },
     "include": ["src/**/*.ts", ".tactica/**/*.ts"]
 }
 ```
 
-Tactica writes the same shape of augmentation a careful human would, using `ProtoFlat<Parent, ...>` for nested types and filling in instance-level subtype constructors automatically. The runtime is unaffected.
+Tactica writes the same shape of augmentation a careful human would, using `ProtoFlat<Parent, ...>` for nested types and filling in instance-level subtype constructors automatically. The runtime is unaffected. Re-run the CLI whenever your type graph changes, or wire it into your build script.
 
 See [`./typed-lookup.md`](./typed-lookup.md) for a side-by-side recipe with both paths.
 
@@ -134,7 +134,7 @@ The anti-patterns are the same whether you augment by hand or via tactica:
 What changes is how you keep the `TypeRegistry` augmentation in sync with your code:
 
 - **Hand-written:** edit the `.d.ts` when types change.
-- **Tactica:** the LSP plugin keeps `.tactica/` in sync.
+- **Tactica:** the CLI/codegen utility keeps `.tactica/` in sync.
 
 Pick whichever fits your project. Both are first-class.
 

package/docs/theory-of-operations.md

@@ -0,0 +1,224 @@
+# Theory of Operations
+
+## The Full Construction Pipeline
+
+This document traces a single `new instance.SubType(args)` call through every stage of mnemonica's internals, with references to the source files that implement each stage. It exists so that contributors (human and AI) can understand the exact data flow without reverse-engineering the code.
+
+---
+
+## Stage 0: Type Definition (`define()`)
+
+**File:** [`src/api/types/index.ts`](../src/api/types/index.ts)
+
+Before any instance exists, the type must be declared. `define('TypeName', ctor, config?)` performs:
+
+1. **Resolve definition context** — determines whether this is a root type or a nested path (`Parent.SubType`)
+2. **Check for duplicates** — throws `ALREADY_DECLARED` if the name exists in the target collection
+3. **Compile the constructor body** — `compileNewModificatorFunctionBody.ts` wraps the user's constructor in a function that preserves `new.target` and handles both class and function constructors
+4. **Create a `TypeDescriptor`** — stores: name, compiled handler, prototype, config, parent type reference
+5. **Register in the `TypesCollection` Proxy** — makes the type findable via `.lookup()` and `.define()`
+
+The result is a `TypeProxy` — a constructor function with additional methods (`.define()`, `.lookup()`, `.registerHook()`).
+
+**Key invariant:** A type is immutable once defined. Its name, handler, and prototype are frozen.
+
+---
+
+## Stage 1: Subtype Access (`instance.SubType`)
+
+**File:** [`src/api/types/Mnemosyne.ts`](../src/api/types/Mnemosyne.ts)
+
+When code reads `instance.SubType`, the `Mnemosyne` proxy's `get` trap fires:
+
+1. Look up `SubType` in the instance's `__subtypes__` Map (stored in the WeakMap)
+2. If found, call `prepareSubtypeForConstruction(subtype, instance)`
+3. This creates a **subtype proxy** — a function that closes over both the `TypeDef` and the parent `instance`
+
+The subtype proxy is what makes `new instance.SubType()` work. It is not the raw constructor; it is a wrapper that knows which parent instance to use.
+
+**Key invariant:** Every access to `instance.SubType` creates a fresh proxy (this was a deliberate design decision; caching is possible but not implemented to keep the code simple).
+
+---
+
+## Stage 2: Construction Invocation (`new instance.SubType(args)`)
+
+**File:** [`src/api/types/Mnemosyne.ts`](../src/api/types/Mnemosyne.ts)
+
+The subtype proxy's `construct` trap fires:
+
+1. Call `new InstanceCreator(subtype, instance, args)`
+2. The `InstanceCreator` is the orchestrator for the full lifecycle
+
+---
+
+## Stage 3: Instance Creator Setup
+
+**File:** [`src/api/types/InstanceCreator.ts`](../src/api/types/InstanceCreator.ts)
+
+`InstanceCreator` is a class (not a proxy) that manages the 8-stage pipeline:
+
+### 3.1 Extract context
+- `type` — the `TypeDef` for `SubType`
+- `existentInstance` — the parent instance (`instance` in our example)
+- `args` — the arguments array
+- `config` — from the type definition
+
+### 3.2 Resolve the `ModificatorType`
+- For sync constructors: compile the user handler into a new constructor function
+- For async constructors: wrap in an async-compatible class pattern
+
+### 3.3 Prepare hooks
+- `invokePreHooks()` — calls `preCreation` hooks on the type's collection and the type itself
+- If any hook throws, `creationError` hooks fire and construction aborts
+
+---
+
+## Stage 4: Prototype Chain Assembly
+
+**File:** [`src/api/types/createInstanceModificator.ts`](../src/api/types/createInstanceModificator.ts)
+
+This is where the Trie structure is physically built:
+
+1. **Create `Mnemosyne`** — `const Mnemosyne = {}`
+2. **Link to parent** — `Reflect.setPrototypeOf(Mnemosyne, existentInstance)`
+   - This is the critical step: the new instance's prototype chain will go through the **specific parent instance**
+3. **Add internal properties** — `_addProps(Mnemosyne)` attaches getters for `__type__`, `__parent__`, `__args__`, `__timestamp__`, etc.
+4. **Create `ModificatorType`** — a new constructor function with `Mnemosyne` as its prototype
+5. **Copy user prototype properties** — `Object.getOwnPropertyDescriptors(ModificatorTypePrototype)` are copied onto `ModificatorType.prototype`
+6. **Link ModificatorType to Mnemosyne** — `Reflect.setPrototypeOf(ModificatorType.prototype, Mnemosyne)`
+
+The resulting chain:
+```
+newObj
+  ↓ __proto__
+ModificatorType.prototype
+  ↓ __proto__
+Mnemosyne  (has __type__, __parent__, etc.)
+  ↓ __proto__
+existentInstance  (the specific parent)
+  ↓ __proto__
+... (rest of chain to root)
+```
+
+---
+
+## Stage 5: User Constructor Execution
+
+**File:** [`src/api/types/InstanceCreator.ts`](../src/api/types/InstanceCreator.ts)
+
+The `ModificatorType` is instantiated with `new ModificatorType(...args)`:
+
+1. The compiled constructor body (from Stage 0) runs
+2. `this` is the new object whose prototype chain was built in Stage 4
+3. The user constructor assigns properties to `this`
+4. If the constructor returns a non-primitive, that value is used as the instance
+
+---
+
+## Stage 6: Post-Processing
+
+**File:** [`src/api/types/InstanceCreator.ts`](../src/api/types/InstanceCreator.ts)
+
+After the user constructor:
+
+1. **Set `__self__`** — `_setSelf(instance)` stores a reference to the instance itself in the props
+2. **Validation** (if `strictChain: true`):
+   - Verify the instance is actually an instance of the expected parent type
+   - Verify the parent's constructor name matches the expected parent type name
+3. **Invoke `postCreation` hooks**
+
+---
+
+## Stage 7: Return
+
+**File:** [`src/api/types/InstanceCreator.ts`](../src/api/types/InstanceCreator.ts)
+
+The instance is returned. It carries:
+- All user-assigned properties (own properties)
+- The prototype chain linking back to the root type
+- Internal construction context in the WeakMap (not enumerable, not own properties)
+
+---
+
+## The WeakMap Architecture
+
+**File:** [`src/api/types/Props.ts`](../src/api/types/Props.ts)
+
+Internal properties are stored in a `WeakMap` keyed by the **prototype object** (Mnemosyne), not the instance itself:
+
+```typescript
+const __props__ = new WeakMap<object, PropsType>();
+```
+
+Why the prototype?
+- Multiple instances of the same type share the same Mnemosyne prototype
+- Storing props on the prototype means all instances of the same construction share the same type metadata
+- This saves memory and keeps instance enumeration clean
+
+`getProps(instance)` walks the prototype chain to find the Mnemosyne object, then looks it up in the WeakMap.
+
+---
+
+## Hook Invocation Details
+
+**File:** [`src/api/hooks/invokeHook.ts`](../src/api/hooks/invokeHook.ts)
+
+Hooks are stored per-type and per-collection:
+
+```typescript
+type.hooks = {
+  preCreation: [fn1, fn2],
+  postCreation: [fn3],
+  creationError: [fn4]
+};
+```
+
+When `invokeHook('preCreation', hookData)` fires:
+1. Create a `HookInvocation` builder
+2. For each registered hook, call it with the builder
+3. Collect results in a Set
+4. If any hook throws, the error propagates (aborting construction)
+
+The `flowCheckers` Map allows hooks to be conditionally enabled/disabled per invocation.
+
+---
+
+## Error Handling
+
+**File:** [`src/api/errors/throwModificationError.ts`](../src/api/errors/throwModificationError.ts)
+
+If any stage throws:
+
+1. `creationError` hooks fire with the error and partial construction context
+2. A `BASE_MNEMONICA_ERROR` is constructed with:
+   - Cleaned stack trace (mnemonica internals removed)
+   - References to the instance, type, and parent
+3. The error is thrown to the caller
+
+If `config.blockErrors` is true (default for most types), errors during construction are caught and re-thrown as mnemonica errors. If false (used internally for exception construction), errors propagate raw.
+
+---
+
+## Summary Table
+
+| Stage | File | What Happens |
+|---|---|---|
+| 0. Type Definition | `src/api/types/index.ts` | Compile handler, create TypeDescriptor, register in collection |
+| 1. Subtype Access | `src/api/types/Mnemosyne.ts` | Resolve `instance.SubType` via proxy get trap |
+| 2. Construction Start | `src/api/types/Mnemosyne.ts` | Subtype proxy's construct trap fires |
+| 3. Creator Setup | `src/api/types/InstanceCreator.ts` | Extract context, resolve ModificatorType, run pre-hooks |
+| 4. Prototype Assembly | `src/api/types/createInstanceModificator.ts` | Build Mnemosyne → link to parent → create ModificatorType |
+| 5. User Constructor | `src/api/types/InstanceCreator.ts` | Run compiled handler with `this` bound to new object |
+| 6. Post-Processing | `src/api/types/InstanceCreator.ts` | Set __self__, validate, run post-hooks |
+| 7. Return | `src/api/types/InstanceCreator.ts` | Return instance with full prototype chain and WeakMap props |
+
+---
+
+## For Contributors
+
+When modifying any of these files, remember:
+
+- **Prototype links are load-bearing.** Changing `Reflect.setPrototypeOf` calls changes the Trie structure.
+- **WeakMap keys are prototype objects, not instances.** `_getProps` walks the chain; `_addProps` writes to the Mnemosyne.
+- **Hook order matters.** `preCreation` → construction → `postCreation`. Errors in `preCreation` abort before `Object.create`.
+- **The `__self__` reference is used by `utils.fork()` and `utils.clone()` to detect self-calls.**

package/docs/typed-lookup.md

@@ -1,6 +1,6 @@
 # Typed lookup with `lookupTyped()` — 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.
+`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.
 
 ```typescript
 // src/index.ts (mnemonica core)
@@ -96,22 +96,22 @@ Install:
 npm install --save-dev @mnemonica/tactica
 ```
 
-Configure as a TypeScript Language Service Plugin in `tsconfig.json`:
+Install and run the CLI:
+
+```bash
+npm install --save-dev @mnemonica/tactica
+npx tactica --output ./.tactica --include "src/**/*.ts"
+```
+
+Then include the generated files in `tsconfig.json`:
 
 ```json
 {
-    "compilerOptions": {
-        "plugins": [{
-            "name"      : "@mnemonica/tactica",
-            "outputDir" : ".tactica",
-            "include"   : ["src/**/*.ts"]
-        }]
-    },
     "include": ["src/**/*.ts", ".tactica/**/*.ts"]
 }
 ```
 
-Tactica scans your `define()` and `@decorate()` calls and generates `.tactica/types.ts` + `.tactica/registry.ts`. The generated registry has the same shape as the hand-written one above, but tactica also fills in instance-level subtypes (`alice.Employee`) automatically and uses `ProtoFlat<Parent, ...>` for nested types so they merge correctly.
+Tactica scans your `define()` and `@decorate()` calls and generates `.tactica/types.ts` + `.tactica/registry.ts`. The generated registry has the same shape as the hand-written one above, but tactica also fills in instance-level subtypes (`alice.Employee`) automatically and uses `ProtoFlat<Parent, ...>` for nested types so they merge correctly. You can re-run the CLI manually or from a build script; mnemographica can also run it on your behalf.
 
 You write nothing for the augmentation; tactica regenerates as your types evolve. See [`@mnemonica/tactica`](https://www.npmjs.com/package/@mnemonica/tactica) for the full configuration surface.
 
@@ -124,14 +124,14 @@ You write nothing for the augmentation; tactica regenerates as your types evolve
 - Small projects (a handful of types)
 - Bootstrap / learning — writing the augmentation by hand is the fastest way to understand what `lookupTyped()` actually does
 - Projects that want to keep the `TypeRegistry` surface stable and curated, independent of source-code churn
-- Environments where adding a TypeScript Language Service plugin is inconvenient
+- Environments where running a CLI/codegen utility is inconvenient
 
 **Tactica** is the right choice when:
 
 - You have many types or expect the type graph to grow
 - You don't want to maintain the augmentation by hand as `define()` calls are added or refactored
 - You want full instance-subtype typing (`alice.Employee`) without writing it
-- You're already on a TS-LSP-friendly setup
+- You're already running tactica as part of your build or IDE workflow
 
 The runtime is identical either way. There is no "tactica path" vs "non-tactica path" in mnemonica core itself — there is only the `TypeRegistry` augmentation, and two ways to produce it.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mnemonica",
-  "version": "1.0.1",
+  "version": "1.0.6",
   "description": "AI-agent ready instance inheritance system for JavaScript/TypeScript via prototype chains",
   "type": "commonjs",
   "main": "./build/index.js",
@@ -51,7 +51,7 @@
     "example:v8bug": "npm run build && node ./examples/v8bug.js",
     "example:ts": "npx tsc ./test-ts/*.ts && npx eslint --fix ./test-ts/*.js && node ./test-ts/test-no-types.js && node ./test-ts/test-with-types.js",
     "deopt": "node --trace-deopt --trace-opt ./node_modules/mocha/bin/mocha.js ./test/index.js",
-    "decorate:ts": "npx tsc --target ES2021 --moduleResolution NodeNext --module NodeNext --sourceMap ./test/decorate.ts",
+    "decorate:ts": "npx tsc --ignoreConfig --target ES2021 --moduleResolution NodeNext --module NodeNext --sourceMap ./test/decorate.ts",
     "lint:md": "find . -name '*.md' -not -path '*/node_modules/*' | xargs markdown-link-check -q --config .markdown-link-check.json",
     "lint": "npx eslint",
     "lint:check": "npx eslint ./src ./test",
@@ -99,9 +99,9 @@
     "@eslint/eslintrc": "^3.3.5",
     "@eslint/js": "^9.21.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.19.19",
-    "@typescript-eslint/eslint-plugin": "^8.59.4",
-    "@typescript-eslint/parser": "^8.59.4",
+    "@types/node": "^22.19.21",
+    "@typescript-eslint/eslint-plugin": "^8.61.1",
+    "@typescript-eslint/parser": "^8.61.1",
     "chai": "^5.3.3",
     "eslint": "^9.39.4",
     "eslint-plugin-import": "^2.32.0",
@@ -112,18 +112,23 @@
     "jest": "^29.7.0",
     "json5": "^2.2.3",
     "lint-staged": "^15.5.2",
+    "markdown-link-check": "^3.14.2",
     "mocha": "^11.7.6",
     "mocha-lcov-reporter": "^1.3.0",
     "nyc": "^17.1.0",
     "oxlint": "^0.16.12",
     "ts-jest": "^29.4.11",
     "typeomatica": "^0.3.57",
-    "markdown-link-check": "^3.13.6",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
   },
   "engines": {
     "node": ">=18 <26"
   },
+  "overrides": {
+    "serialize-javascript": "^7.0.5",
+    "uuid": "^11.1.1",
+    "diff": "^9.0.0"
+  },
   "lint-staged": {
     "src/**/*.ts": "eslint --fix",
     "test/**/*.js": "eslint --fix"

package/src/api/errors/exceptionConstructor.ts

@@ -13,8 +13,8 @@ import {
 	cleanupStack, getStack 
 } from '../errors';
 
-import { utils } from '../../utils';
-const { parse } = utils;
+import { parse } from '../../utils/parse';
+import { extract } from '../../utils/extract';
 
 import TypesUtils from '../utils';
 
@@ -140,9 +140,11 @@ const exceptionConsctructHandler = function ( this: Error, opts: { [ index: stri
 		'extract',
 		{
 			get () {
-				return () => {
-					return instance.extract();
+				const result = () => {
+					const extractResult = extract(instance);
+					return extractResult;
 				};
+				return result;
 			}
 		} 
 	);
@@ -152,10 +154,11 @@ const exceptionConsctructHandler = function ( this: Error, opts: { [ index: stri
 		'parse',
 		{
 			get () {
-				return () => {
-					const result = parse( instance );
-					return result;
+				const result = () => {
+					const parseResult = parse( instance );
+					return parseResult;
 				};
+				return result;
 			}
 		} 
 	);
@@ -250,7 +253,7 @@ const prepareException = function ( this: object, target: unknown, error: Error,
 	ExceptionCreator.ModificatorType = makeErrorModificatorType(
 		TypeName,
 		function (this: Error) {
-			return exceptionConsctructHandler.call(
+			const handlerResult = exceptionConsctructHandler.call(
 				this,
 				{
 					instance,
@@ -260,12 +263,14 @@ const prepareException = function ( this: object, target: unknown, error: Error,
 					error
 				} 
 			);
+			return handlerResult;
 		} 
 	);
 
 	ExceptionCreator.InstanceModificator = makeInstanceModificator( ExceptionCreator );
 
-	return new ExceptionCreator.InstanceModificator();
+	const result = new ExceptionCreator.InstanceModificator();
+	return result;
 };
 
 export default prepareException;

package/src/api/errors/index.ts

@@ -31,7 +31,8 @@ export const cleanupStack = ( stack: string[] ) => {
 		},
 		[] 
 	);
-	return cleaned.length ? cleaned : stack;
+	const result = cleaned.length ? cleaned : stack;
+	return result;
 };
 
 export const getStack = function (
@@ -90,7 +91,8 @@ export class BASE_MNEMONICA_ERROR extends Error {
 	}
 
 	static get [ SymbolConstructorName ] () {
-		return new String( `base of : ${MNEMONICA} : errors` );
+		const result = new String( `base of : ${MNEMONICA} : errors` );
+		return result;
 	}
 
 }
@@ -100,7 +102,8 @@ Object.defineProperty(
 	'name',
 	{
 		get () {
-			return new String( 'BASE_MNEMONICA_ERROR' );
+			const result = new String( 'BASE_MNEMONICA_ERROR' );
+			return result;
 		}
 	} 
 );
@@ -130,7 +133,8 @@ export const constructError = ( name: string, message: string ) => {
 		'name',
 		{
 			get () {
-				return new String( name );
+				const result = new String( name );
+				return result;
 			}
 		} 
 	);

package/src/api/errors/throwModificationError.ts

@@ -21,12 +21,9 @@ import {
 import TypesUtils from '../utils';
 const { makeErrorModificatorType } = TypesUtils;
 
-import { utils } from '../../utils';
-const {
-	parse,
-	parent,
-	extract
-} = utils;
+import { parse } from '../../utils/parse';
+import { parent } from '../../utils/parent';
+import { extract } from '../../utils/extract';
 
 import { makeInstanceModificator } from '../types/InstanceModificator';
 
@@ -244,11 +241,14 @@ export const throwModificationError = function ( this: InstanceCreatorContext, e
 			'extract',
 			{
 				get () {
-					return () => {
-						const _parent = parent(erroredInstance);
+					const extractGetter = () => {
+						// mnemonica instances always have a parent object,
+						// so the runtime value is guaranteed to be object here
+						const _parent = parent(erroredInstance) as object;
 						const extractResult = extract(_parent);
 						return extractResult;
 					};
+					return extractGetter;
 				}
 			} 
 		);
@@ -258,10 +258,11 @@ export const throwModificationError = function ( this: InstanceCreatorContext, e
 			'parse',
 			{
 				get () {
-					return () => {
+					const parseGetter = () => {
 						const parseResult = parse( erroredInstance );
 						return parseResult;
 					};
+					return parseGetter;
 				}
 			} 
 		);

package/src/api/types/InstanceCreator.ts

@@ -281,14 +281,11 @@ const makeAwaiter = function ( this: InstanceCreatorContext, type: TypeDef, then
 	type.subtypes.forEach( ( subtype: object, name: string ) => {
 		 
 		(self.inheritedInstance as Record<string, unknown>)[ name ] = ( ...args: unknown[] ) => {
-			self.inheritedInstance = self.makeAwaiter(
- subtype as TypeDef,
- {
- 	name,
- 	subtype,
- 	args,
- } 
-			);
+			self.inheritedInstance = self.makeAwaiter( subtype as TypeDef, {
+				name,
+				subtype,
+				args,
+			} );
 			return self.inheritedInstance;
 		};
 	} );