mnemonica 1.0.0 → 1.0.6

package/build/utils/parse.js

@@ -42,4 +42,4 @@ const parse = (self) => {
     return result;
 };
 exports.parse = parse;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/pick.d.ts

@@ -1,3 +1,4 @@
-export declare const pick: (instance: object, ...args: (string | string[])[]) => {
-    [index: string]: unknown;
-};
+export declare function pick<T extends object, K extends keyof T>(instance: T, ...args: (K | K[])[]): {
+    [P in K]: T[P];
+} & {};
+export declare function pick<T extends object>(instance: T, ...args: (string | string[])[]): Record<string, unknown>;

package/build/utils/pick.js

@@ -1,9 +1,9 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pick = void 0;
+exports.pick = pick;
 const errors_1 = require("../descriptors/errors");
 const { WRONG_INSTANCE_INVOCATION } = errors_1.ErrorsTypes;
-const pick = (instance, ...args) => {
+function pick(instance, ...args) {
     if (instance !== Object(instance)) {
         throw new WRONG_INSTANCE_INVOCATION;
     }
@@ -22,6 +22,5 @@ const pick = (instance, ...args) => {
         return obj;
     }, {});
     return picked;
-};
-exports.pick = pick;
-//# sourceMappingURL=data:application/json;base64,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
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/sibling.d.ts

@@ -0,0 +1 @@
+export declare const sibling: (instance: object) => unknown;

package/build/utils/sibling.js

@@ -0,0 +1,25 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sibling = void 0;
+const Props_1 = require("../api/types/Props");
+const sibling = (instance) => {
+    const siblings = (SiblingTypeName) => {
+        const props = (0, Props_1.getProps)(instance);
+        const { __collection__: collection, } = props;
+        const answer = collection[SiblingTypeName];
+        return answer;
+    };
+    const result = new Proxy(siblings, {
+        get(_, prop) {
+            const proxyResult = siblings(prop);
+            return proxyResult;
+        },
+        apply(_, __, args) {
+            const proxyResult = siblings(args[0]);
+            return proxyResult;
+        }
+    });
+    return result;
+};
+exports.sibling = sibling;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2libGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9zaWJsaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsOENBRzRCO0FBRXJCLE1BQU0sT0FBTyxHQUFHLENBQUMsUUFBZ0IsRUFBVyxFQUFFO0lBRXBELE1BQU0sUUFBUSxHQUFHLENBQUMsZUFBdUIsRUFBRSxFQUFFO1FBQzVDLE1BQU0sS0FBSyxHQUFHLElBQUEsZ0JBQVEsRUFBQyxRQUFRLENBQVUsQ0FBQztRQUMxQyxNQUFNLEVBQUUsY0FBYyxFQUFFLFVBQVUsR0FBRyxHQUFHLEtBQUssQ0FBQztRQUM5QyxNQUFNLE1BQU0sR0FBRyxVQUFVLENBQUUsZUFBZSxDQUFFLENBQUM7UUFDN0MsT0FBTyxNQUFNLENBQUM7SUFDZixDQUFDLENBQUM7SUFFRixNQUFNLE1BQU0sR0FBRyxJQUFJLEtBQUssQ0FDdkIsUUFBUSxFQUNSO1FBQ0MsR0FBRyxDQUFFLENBQUMsRUFBRSxJQUFZO1lBQ25CLE1BQU0sV0FBVyxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNuQyxPQUFPLFdBQVcsQ0FBQztRQUNwQixDQUFDO1FBQ0QsS0FBSyxDQUFFLENBQUMsRUFBRSxFQUFFLEVBQUUsSUFBSTtZQUNqQixNQUFNLFdBQVcsR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFFLENBQUMsQ0FBRSxDQUFDLENBQUM7WUFDeEMsT0FBTyxXQUFXLENBQUM7UUFDcEIsQ0FBQztLQUNELENBQ0QsQ0FBQztJQUVGLE9BQU8sTUFBTSxDQUFDO0FBRWYsQ0FBQyxDQUFDO0FBekJXLFFBQUEsT0FBTyxXQXlCbEIiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7XG5cdGdldFByb3BzLFxuXHRQcm9wc1xufSBmcm9tICcuLi9hcGkvdHlwZXMvUHJvcHMnO1xuXG5leHBvcnQgY29uc3Qgc2libGluZyA9IChpbnN0YW5jZTogb2JqZWN0KTogdW5rbm93biA9PiB7XG5cblx0Y29uc3Qgc2libGluZ3MgPSAoU2libGluZ1R5cGVOYW1lOiBzdHJpbmcpID0+IHtcblx0XHRjb25zdCBwcm9wcyA9IGdldFByb3BzKGluc3RhbmNlKSBhcyBQcm9wcztcblx0XHRjb25zdCB7IF9fY29sbGVjdGlvbl9fOiBjb2xsZWN0aW9uLCB9ID0gcHJvcHM7XG5cdFx0Y29uc3QgYW5zd2VyID0gY29sbGVjdGlvblsgU2libGluZ1R5cGVOYW1lIF07XG5cdFx0cmV0dXJuIGFuc3dlcjtcblx0fTtcblxuXHRjb25zdCByZXN1bHQgPSBuZXcgUHJveHkoXG5cdFx0c2libGluZ3MsXG5cdFx0e1xuXHRcdFx0Z2V0IChfLCBwcm9wOiBzdHJpbmcpIHtcblx0XHRcdFx0Y29uc3QgcHJveHlSZXN1bHQgPSBzaWJsaW5ncyhwcm9wKTtcblx0XHRcdFx0cmV0dXJuIHByb3h5UmVzdWx0O1xuXHRcdFx0fSxcblx0XHRcdGFwcGx5IChfLCBfXywgYXJncywpIHtcblx0XHRcdFx0Y29uc3QgcHJveHlSZXN1bHQgPSBzaWJsaW5ncyhhcmdzWyAwIF0pO1xuXHRcdFx0XHRyZXR1cm4gcHJveHlSZXN1bHQ7XG5cdFx0XHR9XG5cdFx0fVxuXHQpO1xuXG5cdHJldHVybiByZXN1bHQ7XG5cbn07XG4iXX0=

package/build/utils/toJSON.d.ts

@@ -1 +1 @@
-export declare const toJSON: (instance: object) => string;
+export declare const toJSON: <T extends object>(instance: T) => string;

package/build/utils/toJSON.js

@@ -4,7 +4,7 @@ exports.toJSON = void 0;
 const extract_1 = require("./extract");
 const toJSON = (instance) => {
     const extracted = (0, extract_1.extract)(instance);
-    return Object.entries(extracted).reduce((o, entry) => {
+    const result = Object.entries(extracted).reduce((o, entry) => {
         const [name, _value] = entry;
         if ([null, undefined].includes(_value)) {
             return o;
@@ -26,6 +26,7 @@ const toJSON = (instance) => {
         return o;
     }, '{')
         .replace(/,$/, '}');
+    return result;
 };
 exports.toJSON = toJSON;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/docs/UTILS.md

@@ -0,0 +1,184 @@
+# Mnemonica utilities
+
+The `utils` export provides standalone versions of the instance introspection
+and manipulation methods. Every utility that accepts an instance infers its
+type parameter from that instance, so ordinary code needs no explicit `<T>`
+casts.
+
+```typescript
+import { utils } from 'mnemonica';
+
+const extracted = utils.extract(user); // Extracted<typeof user>
+const picked    = utils.pick(user, 'name', 'age');
+const cloned    = utils.clone(user);   // typeof user
+```
+
+---
+
+## Core helper types
+
+These types live in `src/types/index.ts` and define how the utilities present
+their results.
+
+### `Extracted<T>`
+
+A plain-object view of an instance's enumerable string-keyed user properties.
+`MnemonicaInstance` method names (`extract`, `pick`, `parent`, `clone`, `fork`,
+`exception`, `sibling`) are filtered out. Optionality is preserved from the
+source type.
+
+```typescript
+export type Extracted<T extends object> = {
+    [K in keyof T as K extends string ? (K extends MnemonicaInstanceMethodKeys ? never : K) : never]: T[K];
+} & {};
+```
+
+### `MnemonicaInstanceMethodKeys`
+
+The set of prototype method names that must disappear from data-only views:
+
+```typescript
+export type MnemonicaInstanceMethodKeys =
+    'extract' | 'pick' | 'parent' | 'clone' | 'fork' | 'exception' | 'sibling';
+```
+
+### `Merge<E, T>`
+
+Merges two instance shapes into a flat field object. `T` wins on conflicts;
+`E` contributes only keys that `T` does not define. Method names are filtered
+out. Used by `apply` / `call` / `bind` and by `utils.merge`.
+
+```typescript
+export type Merge<E extends object, T extends object> = {
+    [K in keyof T | keyof E as K extends MnemonicaInstanceMethodKeys ? never : K]:
+        K extends keyof T ? T[K] : E[K & keyof E];
+};
+```
+
+### `InstanceResult<N, Config>`
+
+The public instance surface. It renders in hover tooltips as a plain field
+object literal first, then `& MnemonicaInstance<{ ... }>` once:
+
+```typescript
+export type InstanceResult<
+    N extends object,
+    Config extends constructorOptions,
+> = IsHidingMethods<Config> extends true
+    ? { [K in keyof N]: N[K] }
+    : { [K in keyof N]: N[K] } & MnemonicaInstance<{ [K in keyof N]: N[K] }>;
+```
+
+### `Parsed<T>`
+
+The shape returned by `utils.parse(instance)` — a one-level snapshot of the
+instance's prototype chain:
+
+```typescript
+export type Parsed<T extends object> = {
+    name: string;
+    props: Extracted<T>;
+    self: T;
+    proto: object;
+    joint: Record<string, unknown>;
+    parent: object | undefined;
+};
+```
+
+### `SiblingAccessor`
+
+A callable/proxy object returned by `utils.sibling(instance)`:
+
+```typescript
+export interface SiblingAccessor {
+    (SiblingTypeName: string): TypeClass | undefined;
+    [key: string]: TypeClass | undefined;
+}
+```
+
+---
+
+## Utility reference
+
+| Utility | Inferred return type | Notes |
+|---|---|---|
+| `utils.extract(instance)` | `Extracted<T>` | Data-only view; methods filtered. |
+| `utils.pick(instance, 'a', 'b')` | `{ a: T['a'], b: T['b'] } & {}` | Literal keys → typed subset. Dynamic `string[]` → `Record<string, unknown>`. |
+| `utils.clone(instance)` | `T` | Same instance type. |
+| `utils.fork(instance)` | `(this: object, ...args: unknown[]) => T` | Returns a fork constructor. |
+| `utils.parent(instance, path?)` | `object \| undefined` | Structural only; nominal path typing needs `TypeRegistry`. |
+| `utils.sibling(instance)` | `SiblingAccessor` | Look up sibling constructors by string name or property access. |
+| `utils.merge(A, B, ...args)` | `InstanceResult<Merge<B, A>, constructorOptions>` | `A` wins; `B` fills non-overlapping keys; methods shown once. |
+| `utils.parse(instance)` | `Parsed<T>` | One-level prototype-chain snapshot. |
+| `utils.toJSON(instance)` | `string` | Generic so the instance type is captured at the call site. |
+| `utils.collectConstructors(instance, flat?)` | `(CallableFunction \| string)[]` | Introspection helper. |
+
+---
+
+## `utils.merge(A, B, ...args)` in detail
+
+`merge(a, b)` is implemented as `fork(a).call(b, ...args)`. The result is a **new
+instance of `a`’s type** whose parent/existent instance is `b`. That means:
+
+- `a` provides the primary fields.
+- `b` contributes only the fields `a` does not define.
+- The result is a flat field object (`A` wins) with no auto-injected instance
+  methods.
+
+The type `InstanceResult<Merge<B, A>>` expresses this: a flat field object
+(`A` wins).
+
+```typescript
+const UserType = define('User', function (this: { name: string; age: number }) {
+    this.name = 'Alice';
+    this.age = 30;
+});
+
+const RoleType = define('Role', function (this: { role: string }) {
+    this.role = 'admin';
+});
+
+const user = new UserType();
+const role = new RoleType();
+
+// hover: { name: string; age: number; role: string; }
+const merged = utils.merge(user, role);
+merged.name;      // string
+merged.role;      // string
+utils.extract(merged); // OK
+```
+
+---
+
+## `utils.parse(instance)` in detail
+
+`parse` returns a one-level snapshot of the instance's prototype chain:
+
+- `name` — constructor name of the immediate prototype.
+- `props` — `Extracted<T>` from the instance itself.
+- `self` — the original instance reference (`T`).
+- `proto` — `Object.getPrototypeOf(instance)`.
+- `joint` — enumerable properties copied from `proto`.
+- `parent` — `Object.getPrototypeOf(proto)` (the next link up; currently not
+  recursively parsed).
+
+```typescript
+const parsed = utils.parse(user);
+const name: string = parsed.name;
+const propsName: string | undefined = parsed.props.name;
+const self: typeof user = parsed.self;
+const parent: object | undefined = parsed.parent;
+```
+
+---
+
+## Limitations
+
+- `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
+  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.
+- `utils.toJSON()` always returns `string`; the generic parameter only preserves
+  the instance type at the call site for consistency with the other utilities.

package/docs/ai-learning-trajectory.md

@@ -114,7 +114,7 @@ Three things accelerated learning:
 
 After understanding mnemonica, the agent read `hott/AI-REFLECTION-THEORY.md` (internal docs). It noticed structural parallels:
 
-- **Path induction** ↔ prototype chain traversal (`instance.parent()`)
+- **Path induction** ↔ prototype chain traversal (`utils.parent(instance)`)
 - **Univalence** ↔ capability equivalence (two types with same behavior are equivalent)
 - **Runtime augmentation** ↔ path composition (adding a subtype extends the path)
 - **Stored `__args__`** ↔ path recording (every constructor call is a recorded step)

package/docs/async-constructors.md

@@ -180,6 +180,8 @@ console.log(child instanceof AsyncChild);  // true
 mnemonica's most powerful async feature is chainable awaits:
 
 ```js
+const { utils } = require('mnemonica');
+
 const result = await new UserTypeConstructor({
 		email: 'async@gmail.com',
 		password: 32123
@@ -191,7 +193,7 @@ const result = await new UserTypeConstructor({
 	.Async2Sync2nd({ sync: 'is' })
 	.AsyncChain3rd({ async: '3rd' });
 
-console.log(result.extract());
+console.log(utils.extract(result));
 // {
 //   email: 'async@gmail.com',
 //   password: undefined,

package/docs/empathy-in-ai.md

@@ -0,0 +1,170 @@
+# Empathy in AI: Data That Remembers Its Path
+
+This document connects mnemonica's data-flow model to a specific AI design problem: **how an agent understands another agent's state**. The connection is not metaphorical decoration. It follows directly from the library's structure.
+
+> If you want the deeper theory first, see the HoTT framing in [`docs/hott-primer.md`](./hott-primer.md) and the original vision in [`../../articles/inheritance.md`](../../articles/inheritance.md). This document stays at the API level.
+
+---
+
+## The problem with stateless understanding
+
+Most AI pipelines process inputs as snapshots:
+
+```typescript
+const intent = classifyIntent(userMessage);
+const response = generateResponse(intent);
+```
+
+`intent` is a label. It carries no history. If the classifier says `"frustrated"`, the generator has no access to:
+- what the user asked three turns ago
+- which previous response led to the current message
+- whether the frustration is new or accumulated
+
+The data is **amnesiac**. It answers "what" without "how did we get here." Empathy — in the minimal, technical sense of understanding another's state in context — requires the second question.
+
+---
+
+## Mnemonica's contribution: state as lineage
+
+Mnemonica makes every data value carry its own construction history. The mechanism is the same one used everywhere else in the library: `new current.Next(args)`.
+
+```typescript
+import { define } from 'mnemonica';
+
+const UserInput = define('UserInput', function (this: UserInput, text: string) {
+	this.text = text;
+	this.turn = 1;
+});
+
+const UnderstoodIntent = UserInput.define('UnderstoodIntent', function (this: UnderstoodIntent, intent: string) {
+	this.intent = intent;
+});
+
+const EmotionalState = UnderstoodIntent.define('EmotionalState', function (this: EmotionalState, emotion: string) {
+	this.emotion = emotion;
+});
+
+const ResponsePlan = EmotionalState.define('ResponsePlan', function (this: ResponsePlan, plan: string) {
+	this.plan = plan;
+});
+```
+
+A single conversation turn is now a typed path:
+
+```typescript
+const raw = new UserInput('I already told you the shipping address.');
+const intent = new raw.UnderstoodIntent('correction');
+const emotion = new intent.EmotionalState('frustrated');
+const plan = new emotion.ResponsePlan('acknowledge + locate prior turn');
+```
+
+The `plan` instance is not a flat object. Its prototype chain is the conversation history. `getProps(plan)` returns the full trace: type, parent, args, timestamp, creator.
+
+---
+
+## Why this is empathy-infrastructure
+
+Empathy, stripped to a design requirement, is **understanding another's present state as the endpoint of a path that includes their history**. Mnemonica provides the path.
+
+| Capability | mnemonica operation | What it gives an AI agent |
+|---|---|---|
+| **Provenance** | `getProps(instance)` | "This response plan came from an `EmotionalState('frustrated')` that came from an `UnderstoodIntent('correction')` that came from `UserInput('I already told you...')`." |
+| **Perspective-taking** | `utils.parent(instance, 'UserInput')` | "Let me look at the original input again, from the current endpoint." |
+| **Reconstruction** | `utils.extract(instance)` | "Flatten the whole interaction into a single state object for the model prompt." |
+| **Continuity** | `new current.Next(args)` | "Every transformation preserves the previous state as context; nothing is overwritten." |
+
+The agent does not "feel" frustration. It has structural access to the fact that the current state is path-connected to a correction-intent and a repeated prior claim. That access is sufficient for behavior that humans experience as empathetic.
+
+---
+
+## Concrete example: multi-turn intent resolution
+
+Consider a support bot. A user's real goal may only become clear across several turns. Without lineage, each turn is re-classified from scratch. With mnemonica, the type graph itself records the unfolding understanding.
+
+```typescript
+const Turn = define('Turn', function (this: Turn, text: string) {
+	this.text = text;
+});
+
+const ClarifiedNeed = Turn.define('ClarifiedNeed', function (this: ClarifiedNeed, need: string) {
+	this.need = need;
+});
+
+const EscalationReason = ClarifiedNeed.define('EscalationReason', function (this: EscalationReason, reason: string) {
+	this.reason = reason;
+});
+
+// Turn 1
+const t1 = new Turn('My order is wrong.');
+const c1 = new t1.ClarifiedNeed('missing_item');
+
+// Turn 2: the user adds detail
+const t2 = new c1.Turn('I ordered two, only one arrived.');
+const c2 = new t2.ClarifiedNeed('quantity_error');
+
+// Turn 3: escalation becomes appropriate
+const t3 = new c2.Turn('This is the third time this month.');
+const escalation = new t3.EscalationReason('repeat_issue');
+```
+
+`escalation` knows it is a `EscalationReason` whose parent is `Turn('This is the third time this month.')`, whose parent is `ClarifiedNeed('quantity_error')`, whose parent is `Turn('I ordered two, only one arrived.')`, and so on. The decision to escalate is not a label produced by a classifier. It is a position in a reconstructible path.
+
+---
+
+## Self-reflection: an agent understanding its own path
+
+The same structure lets an AI reflect on its own reasoning. Define a type for each stage of internal deliberation:
+
+```typescript
+const Observation = define('Observation', function (this: Observation, fact: string) {
+	this.fact = fact;
+});
+
+const Hypothesis = Observation.define('Hypothesis', function (this: Hypothesis, guess: string) {
+	this.guess = guess;
+});
+
+const Action = Hypothesis.define('Action', function (this: Action, action: string) {
+	this.action = action;
+});
+
+const observed = new Observation('user repeated the question');
+const hypothesis = new observed.Hypothesis('previous answer was unclear');
+const action = new hypothesis.Action('rephrase with concrete example');
+```
+
+The agent can query `utils.parent(action, 'Observation')` to recover the original evidence that justified its action. This is not logging. The evidence is part of the action's identity. The agent can answer "why did you do that?" by walking its own type chain.
+
+---
+
+## Connection to the original vision
+
+The earliest mnemonica article asked: **"How will you explain Empathy in JavaScript?"** The answer proposed there was the prototype chain: each instance inherits from a specific predecessor, so data carries its own history by construction.
+
+This document is the same answer, made operational. In mnemonica:
+
+- **Identity is not shape**. Two instances with identical fields but different construction paths are different types. This matches the intuition that "I'm fine" can mean different things depending on history.
+- **Transformation is not replacement**. `new current.Next(args)` extends the path; it does not delete the previous point. The past remains reachable.
+- **Understanding is traversal**. To understand an instance is to walk its chain and see what it came from.
+
+---
+
+## Scope boundary
+
+Mnemonica provides **infrastructure** for empathetic AI, not empathy itself. It does not:
+
+- classify emotions
+- model Theory of Mind
+- generate appropriate responses
+- guarantee benevolent behavior
+
+What it provides is a data model where context and lineage are first-class. Higher layers — classifiers, planners, safety filters — can then operate on data that already knows where it came from.
+
+---
+
+## See also
+
+- [`docs/hott-primer.md`](./hott-primer.md) — formal background on paths, identity, and transport
+- [`docs/purpose.md`](./purpose.md) — data flow vs control flow, and what mnemonica does not do
+- [`../../articles/inheritance.md`](../../articles/inheritance.md) — the original 2019 essay that posed the empathy question
+- [`../../hott/theory/MEMORY-AND-ESSENCE.md`](../../hott/theory/MEMORY-AND-ESSENCE.md) — the HoTT treatment of identity as path-connectedness

package/docs/hott-primer.md

@@ -0,0 +1,47 @@
+# A brief HoTT primer (for agents who don't have one loaded)
+
+You don't need to know Homotopy Type Theory to use mnemonica. You do need it to appreciate *why* the design is what it is. Five concepts matter here.
+
+**Scope boundary first.** Mnemonica is **inspired by** HoTT, not a formal implementation of it. The structural correspondences are productive analogies that illuminate why the Trie model is the right structure for typed data pipelines. They are not claims of a mathematical embedding. Specifically:
+- **Higher paths** (paths between paths) have no direct analogue in mnemonica
+- **Univalence** is an intuition about nominal typing, not a formal axiom
+- **Higher Inductive Types** are a useful framing, not a literal implementation
+
+Where the correspondence *is* exact — the monad laws, path uniqueness, and the Trie structure — that precision is worth highlighting.
+
+---
+
+## The Trie as a monad
+
+The monad claim is the most precisely correct analogy. In mnemonica:
+
+| Monad Law | mnemonica Equivalent | Holds? |
+|---|---|---|
+| **Left identity** (`return x >>= f = f x`) | `define(T) >>= construct` produces an instance of `T` | Structurally ✓ |
+| **Right identity** (`m >>= return = m`) | `instance >>= define(SubT)` produces `instance` with `SubT` context | By construction ✓ |
+| **Associativity** (`(m >>= f) >>= g = m >>= (λx. f x >>= g)`) | Chaining `a.SubType().SubSubType()` is prototype-chain associative | Structurally ✓ |
+
+The `bind` operation is `new instance.SubType(args)`: it takes a value in context (`instance`), applies a function that produces a new contextualized value (`SubType` constructor), and returns a value in the combined context (`child` inherits from `instance` and carries `SubType` type). The associativity holds because the prototype chain is inherently associative: `instance -> Mnemosyne -> parent` extends linearly without reordering.
+
+## The five HoTT concepts
+
+**Univalence Axiom.** In HoTT, equivalence and identity coincide — there is no gap between "same structure" and "same thing." Mnemonica's nominal typing makes this intuition natural: two instances with identical property shapes but different constructors are *different types*. The constructor name (frozen at `define()` time) is the identity, not the shape. This is an **analogy** — mnemonica does not implement the univalence axiom formally, but the intuition that "identity is determined by constructor, not structure" is HoTT-inspired.
+
+**Path Types.** In HoTT, equality is a type. `Id(a, b)` is the type of *paths* witnessing that `a` and `b` are equal. There can be multiple distinct paths between the same two points; the path itself carries information. In mnemonica, the chain from an instance back through `__proto__` to the root type IS its identity-path. The `__args__` along the way parameterize that path. This correspondence is **structurally exact**.
+
+**Higher Inductive Types (HITs).** A type defined by its constructors AND by paths between values. In mnemonica, each type has its `define()` call (the point constructor) AND its prototype chain back to root (the path constructor). The Trie structure can be **viewed as** a HIT. This is a productive analogy, not a formal encoding — mnemonica does not implement path constructors as first-class operations.
+
+**Synthetic Topology.** In HoTT, types are spaces and functions between types are continuous maps. Mnemonica's Trie is a connected topological space: every defined type is reachable from the root by construction edges, and the connectivity persists for the lifetime of the process. The `defaultTypes.subtypes` Map is the runtime representation of this space. This is a **useful metaphor** for understanding type reachability.
+
+**Fibrations.** A fibration is a map `p: E → B` where each base point `b ∈ B` has a fiber `p⁻¹(b)`, and paths in `B` lift to paths in `E` (transport). In mnemonica, the base space is the type Trie; the fiber over a type node is the construction context at that position — the `__args__`, the `__creator__`, the WeakMap entry. A subtype creation `new instance.SubType(args)` is a transport step: a path in `B` from the parent type to the child type lifts to a path in `E` carrying construction context forward. Hooks are the *lifting protocol*: `preCreation` can refuse the lift, `postCreation` observes the lifted endpoint, `creationError` records when the lift fails. This is a **productive analogy** for understanding how construction context propagates.
+
+## Summary table
+
+| HoTT Concept | Status | Mnemonica Realization | Code in this package |
+|---|---|---|---|
+| Monad (bind/unit/associativity) | **Exact** | `new instance.SubType()` threads context; prototype chain is associative | [`src/api/types/InstanceCreator.ts`](../src/api/types/InstanceCreator.ts) |
+| Path Types | **Exact** | The proto chain to root IS the identity-path | [`src/api/types/createInstanceModificator.ts`](../src/api/types/createInstanceModificator.ts) |
+| Univalence | **Analogy** | Nominal typing: constructor name = identity, not shape | [`src/api/types/index.ts`](../src/api/types/index.ts) (`Symbol.hasInstance`) |
+| HITs | **Analogy** | Types as point constructors + parent-edge path constructors | The Trie itself |
+| Synthetic Topology | **Metaphor** | Trie as connected, always-on topological space | `defaultTypes.subtypes` Map |
+| Fibrations | **Analogy** | Construction contexts as fibers; hooks as lifting protocol | `preCreation` / `postCreation` / `creationError` |