@ddd-ts/event-tree 0.0.0-eventviz.15 → 0.0.0-eventviz.16

package/dist/engine/defaults/_utils.d.ts

@@ -5,10 +5,25 @@ export declare function walkSubtree(node: Node | null | undefined, visit: (n: No
 export declare function readStringLiteral(node: Node | null | undefined): string | null;
 export declare function superGenericIdentifier(node: Class): string | null;
 export declare function reactorEvents(decorators: Decorator[] | undefined, allowedCallees: Set<string>): string[];
+/**
+ * Resolves the constructed type name from the ddd-ts construction idioms:
+ * `new X(...)`, `X.new(...)` and `X.parse(...)`. Events and commands are most
+ * often created through the static `.new()`/`.parse()` factories rather than
+ * the `new` operator, so both must be recognised.
+ */
+export declare function constructedName(node: Node | null | undefined): string | null;
 export declare function methodEffects(method: MethodDefinition): {
     sends: string[];
     emits: string[];
 };
+/**
+ * Events applied within a method via the aggregate idiom `this.apply(Event.new(...))`
+ * (or `this.apply(new Event(...))`). Unlike `methodEffects`, this is scoped to
+ * `this.apply(...)` only, so it captures event-application methods (the
+ * behaviours a command handler delegates to) without sweeping up command
+ * dispatching or unrelated constructions.
+ */
+export declare function appliedEvents(method: MethodDefinition): string[];
 export declare function classMethods(node: Class): MethodDefinition[];
 export declare function methodName(method: MethodDefinition): string | null;
 //# sourceMappingURL=_utils.d.ts.map

package/dist/engine/defaults/_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_utils.d.ts","sourceRoot":"","sources":["../../../src/engine/defaults/_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,SAAS,EACT,gBAAgB,EAChB,IAAI,EACL,MAAM,YAAY,CAAC;AAEpB,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAM3E;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQvE;AAOD,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,IAAI,QAYlF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,iBAK9D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,KAAK,iBAKjD;AAED,wBAAgB,aAAa,CAC3B,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EACnC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,YAc5B;AAKD,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB;;;EAmCrD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,KAAK,sBAQvC;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,iBAElD"}
+{"version":3,"file":"_utils.d.ts","sourceRoot":"","sources":["../../../src/engine/defaults/_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,SAAS,EACT,gBAAgB,EAChB,IAAI,EACL,MAAM,YAAY,CAAC;AAEpB,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAM3E;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQvE;AAOD,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,IAAI,QAYlF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,iBAK9D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,KAAK,iBAKjD;AAED,wBAAgB,aAAa,CAC3B,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EACnC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,YAc5B;AAKD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAU5E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB;;;EAiCrD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAWhE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,KAAK,sBAQvC;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,iBAElD"}

package/dist/engine/defaults/_utils.mjs

@@ -59,40 +59,73 @@ const SEND_MEMBERS = new Set([
 	"dispatch",
 	"send"
 ]);
-const EMIT_MEMBERS = new Set(["publish", "emit"]);
+const EMIT_MEMBERS = new Set([
+	"publish",
+	"emit",
+	"apply"
+]);
+/**
+* Resolves the constructed type name from the ddd-ts construction idioms:
+* `new X(...)`, `X.new(...)` and `X.parse(...)`. Events and commands are most
+* often created through the static `.new()`/`.parse()` factories rather than
+* the `new` operator, so both must be recognised.
+*/
+function constructedName(node) {
+	if (!node) return null;
+	if (node.type === "NewExpression") return identifierName(node.callee);
+	if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
+		const factory = identifierName(node.callee.property);
+		if (factory === "new" || factory === "parse") return identifierName(node.callee.object);
+	}
+	return null;
+}
 function methodEffects(method) {
 	const sends = /* @__PURE__ */ new Set();
 	const emits = /* @__PURE__ */ new Set();
-	const consumedNew = /* @__PURE__ */ new WeakSet();
+	const consumed = /* @__PURE__ */ new WeakSet();
 	walkSubtree(method.value.body, (n) => {
 		if (n.type !== "CallExpression") return;
-		const a0 = n.arguments[0];
-		let arg0New = null;
-		if (a0?.type === "NewExpression") arg0New = identifierName(a0.callee);
-		else if (a0?.type === "Identifier") arg0New = a0.name;
-		if (!arg0New) return;
 		if (n.callee.type !== "MemberExpression") return;
 		const member = identifierName(n.callee.property);
 		if (!member) return;
-		if (SEND_MEMBERS.has(member)) {
-			sends.add(arg0New);
-			if (a0?.type === "NewExpression") consumedNew.add(a0);
-		} else if (EMIT_MEMBERS.has(member)) {
-			emits.add(arg0New);
-			if (a0?.type === "NewExpression") consumedNew.add(a0);
-		}
+		const isSend = SEND_MEMBERS.has(member);
+		const isEmit = EMIT_MEMBERS.has(member);
+		if (!isSend && !isEmit) return;
+		const a0 = n.arguments[0];
+		const name = constructedName(a0) ?? (a0?.type === "Identifier" ? a0.name : null);
+		if (!name) return;
+		(isSend ? sends : emits).add(name);
+		if (a0 && (a0.type === "NewExpression" || a0.type === "CallExpression")) consumed.add(a0);
 	});
 	walkSubtree(method.value.body, (n) => {
-		if (n.type !== "NewExpression") return;
-		if (consumedNew.has(n)) return;
-		const id = identifierName(n.callee);
-		if (id) emits.add(id);
+		if (consumed.has(n)) return;
+		const name = constructedName(n);
+		if (name) emits.add(name);
 	});
 	return {
 		sends: [...sends],
 		emits: [...emits]
 	};
 }
+/**
+* Events applied within a method via the aggregate idiom `this.apply(Event.new(...))`
+* (or `this.apply(new Event(...))`). Unlike `methodEffects`, this is scoped to
+* `this.apply(...)` only, so it captures event-application methods (the
+* behaviours a command handler delegates to) without sweeping up command
+* dispatching or unrelated constructions.
+*/
+function appliedEvents(method) {
+	const events = /* @__PURE__ */ new Set();
+	walkSubtree(method.value.body, (n) => {
+		if (n.type !== "CallExpression") return;
+		if (n.callee.type !== "MemberExpression") return;
+		if (n.callee.object.type !== "ThisExpression") return;
+		if (identifierName(n.callee.property) !== "apply") return;
+		const name = constructedName(n.arguments[0]);
+		if (name) events.add(name);
+	});
+	return [...events];
+}
 function classMethods(node) {
 	const out = [];
 	for (const member of node.body.body) if (member.type === "MethodDefinition" || member.type === "TSAbstractMethodDefinition") out.push(member);
@@ -102,4 +135,4 @@ function methodName(method) {
 	return identifierName(method.key);
 }
 //#endregion
-export { classMethods, identifierName, memberPath, methodEffects, methodName, reactorEvents, readStringLiteral, superGenericIdentifier, walkSubtree };
+export { appliedEvents, classMethods, constructedName, identifierName, memberPath, methodEffects, methodName, reactorEvents, readStringLiteral, superGenericIdentifier, walkSubtree };

package/dist/engine/defaults/command-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-handler.d.ts","sourceRoot":"","sources":["../../../src/engine/defaults/command-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,QA4BzD"}
+{"version":3,"file":"command-handler.d.ts","sourceRoot":"","sources":["../../../src/engine/defaults/command-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAQxC,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,QAsDzD"}

package/dist/engine/defaults/command-handler.mjs

@@ -1,4 +1,4 @@
-import { identifierName, superGenericIdentifier, walkSubtree } from "./_utils.mjs";
+import { constructedName, identifierName, superGenericIdentifier, walkSubtree } from "./_utils.mjs";
 //#region src/engine/defaults/command-handler.ts
 function applyCommandHandlerDefaults(engine) {
 	engine.on((node, parent, ctx, file) => {
@@ -9,25 +9,46 @@ function applyCommandHandlerDefaults(engine) {
 		const command = superGenericIdentifier(node);
 		if (!command) return;
 		const seen = /* @__PURE__ */ new Set();
+		const invoked = /* @__PURE__ */ new Set();
 		walkSubtree(node.body, (n) => {
-			if (n.type !== "NewExpression") return;
-			const event = identifierName(n.callee);
-			if (!event || seen.has(event)) return;
-			seen.add(event);
-			engine.saveEdge({
-				from: {
-					type: "command",
-					name: command
-				},
-				to: {
-					type: "event",
-					name: event
-				},
-				source: {
-					file,
-					start: n.start
+			const created = constructedName(n);
+			if (created) {
+				if (!seen.has(created)) {
+					seen.add(created);
+					engine.saveEdge({
+						from: {
+							type: "command",
+							name: command
+						},
+						to: {
+							type: "event",
+							name: created
+						},
+						source: {
+							file,
+							start: n.start
+						}
+					});
 				}
-			});
+				return;
+			}
+			if (n.type === "CallExpression" && n.callee.type === "MemberExpression" && n.callee.object.type === "Identifier") {
+				const method = identifierName(n.callee.property);
+				if (method && !invoked.has(method)) {
+					invoked.add(method);
+					engine.saveInvocation({
+						from: {
+							type: "command",
+							name: command
+						},
+						method,
+						source: {
+							file,
+							start: n.start
+						}
+					});
+				}
+			}
 		});
 	});
 }

package/dist/engine/defaults/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/defaults/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AASxC,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,QAQ3C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/defaults/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAUxC,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,QAS3C"}

package/dist/engine/defaults/index.mjs

@@ -2,6 +2,7 @@ import { applyCommandDefaults } from "./command.mjs";
 import { applyCommandHandlerDefaults } from "./command-handler.mjs";
 import { applyEsAggregateDefaults } from "./es-aggregate.mjs";
 import { applyEventDefaults } from "./event.mjs";
+import { applyMethodIndexDefaults } from "./method-index.mjs";
 import { applyProjectionDefaults } from "./projection.mjs";
 import { applySagaDefaults } from "./saga.mjs";
 import { applyScannerDefaults } from "./scanner.mjs";
@@ -13,6 +14,7 @@ function applyDefaults(engine) {
 	applyEsAggregateDefaults(engine);
 	applyProjectionDefaults(engine);
 	applyCommandHandlerDefaults(engine);
+	applyMethodIndexDefaults(engine);
 	applyScannerDefaults(engine);
 }
 //#endregion

package/dist/engine/defaults/method-index.d.ts

@@ -0,0 +1,11 @@
+import type { Engine } from "../engine";
+/**
+ * Indexes aggregate/entity event-application methods (`this.apply(Event.new(...))`)
+ * by method name. The engine later joins these against recorded
+ * `receiver.method(...)` calls so a caller (e.g. a command handler) is linked to
+ * the events it ultimately produces, even when the emit happens in another
+ * class. Scoped to `this.apply(...)` so command-dispatch methods (every
+ * handler's `execute`, command buses, …) don't become catch-all matches.
+ */
+export declare function applyMethodIndexDefaults(engine: Engine): void;
+//# sourceMappingURL=method-index.d.ts.map

package/dist/engine/defaults/method-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-index.d.ts","sourceRoot":"","sources":["../../../src/engine/defaults/method-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,QAatD"}

package/dist/engine/defaults/method-index.mjs

@@ -0,0 +1,24 @@
+import { appliedEvents, classMethods, methodName } from "./_utils.mjs";
+//#region src/engine/defaults/method-index.ts
+/**
+* Indexes aggregate/entity event-application methods (`this.apply(Event.new(...))`)
+* by method name. The engine later joins these against recorded
+* `receiver.method(...)` calls so a caller (e.g. a command handler) is linked to
+* the events it ultimately produces, even when the emit happens in another
+* class. Scoped to `this.apply(...)` so command-dispatch methods (every
+* handler's `execute`, command buses, …) don't become catch-all matches.
+*/
+function applyMethodIndexDefaults(engine) {
+	engine.on((node) => {
+		if (node.type !== "ClassDeclaration" || !node.id) return;
+		const owner = node.id.name;
+		for (const method of classMethods(node)) {
+			const name = methodName(method);
+			if (!name) continue;
+			const events = appliedEvents(method);
+			if (events.length) engine.indexBehaviour(name, owner, events);
+		}
+	});
+}
+//#endregion
+export { applyMethodIndexDefaults };

package/dist/engine/engine.d.ts

@@ -13,6 +13,32 @@ export declare class Engine {
     private nodes;
     saveNode(node: Node): void;
     getNodes(): readonly Node[];
+    private behaviours;
+    indexBehaviour(method: string, owner: string, events: readonly string[]): void;
+    private invocations;
+    saveInvocation(invocation: {
+        from: {
+            type: "command";
+            name: string;
+        };
+        method: string;
+        source: {
+            file: string;
+            start: number;
+        };
+    }): void;
+    /**
+     * Expands recorded `receiver.method(...)` calls into edges from the caller to
+     * whatever the callee emits/sends. This links a command handler that
+     * delegates to an aggregate method (e.g. `message.destroy()` →
+     * `this.apply(SomeEvent.new(...))`) to the events it ultimately produces.
+     * Matching is by method name only — no receiver type resolution. To stay
+     * precise we attribute a method's events only when that name is declared in a
+     * single class; a name shared across classes (e.g. `enable`/`disable` on many
+     * feature aggregates) is ambiguous and skipped. Edges to unknown targets are
+     * dropped later by resolveEdges().
+     */
+    private resolveInvocations;
     /**
      * Edge targets discovered from `new X()` calls are speculative: when a walker
      * records them it only knows the constructor name, not whether `X` is a

package/dist/engine/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/engine/engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAGpC,KAAK,SAAS,GAAG,CACf,GAAG,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,KAChD,UAAU,CAAC,WAAW,CAAC,CAAC;AAE7B,qBAAa,MAAM;IACjB,OAAO,CAAC,UAAU,CAAmB;IAErC,EAAE,CAAC,MAAM,EAAE,SAAS;IAKpB,OAAO,CAAC,WAAW,CAIjB;IACF,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAC;IAKpD,OAAO,CAAC,KAAK,CAAc;IAC3B,QAAQ,CAAC,IAAI,EAAE,IAAI;IAGnB,QAAQ,IAAI,SAAS,IAAI,EAAE;IAI3B,OAAO,CAAC,KAAK,CAAc;IAC3B,QAAQ,CAAC,IAAI,EAAE,IAAI;IAGnB,QAAQ,IAAI,SAAS,IAAI,EAAE;IAI3B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,YAAY;IAiCpB,KAAK;IAKL,GAAG,CAAC,IAAI,GAAE,MAAsB;CAqBjC;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAI5C;AAED,eAAO,MAAM,MAAM,QAAwB,CAAC"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/engine/engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAGpC,KAAK,SAAS,GAAG,CACf,GAAG,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,KAChD,UAAU,CAAC,WAAW,CAAC,CAAC;AAE7B,qBAAa,MAAM;IACjB,OAAO,CAAC,UAAU,CAAmB;IAErC,EAAE,CAAC,MAAM,EAAE,SAAS;IAKpB,OAAO,CAAC,WAAW,CAIjB;IACF,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAC;IAKpD,OAAO,CAAC,KAAK,CAAc;IAC3B,QAAQ,CAAC,IAAI,EAAE,IAAI;IAGnB,QAAQ,IAAI,SAAS,IAAI,EAAE;IAI3B,OAAO,CAAC,KAAK,CAAc;IAC3B,QAAQ,CAAC,IAAI,EAAE,IAAI;IAGnB,QAAQ,IAAI,SAAS,IAAI,EAAE;IAS3B,OAAO,CAAC,UAAU,CAA+C;IACjE,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE;IAiBvE,OAAO,CAAC,WAAW,CAIV;IACT,cAAc,CAAC,UAAU,EAAE;QACzB,IAAI,EAAE;YAAE,IAAI,EAAE,SAAS,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;QACxC,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;KACzC;IAID;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,YAAY;IAiCpB,KAAK;IAOL,GAAG,CAAC,IAAI,GAAE,MAAsB;CAsBjC;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAI5C;AAED,eAAO,MAAM,MAAM,QAAwB,CAAC"}

package/dist/engine/engine.mjs

@@ -29,6 +29,50 @@ var Engine = class {
 	getNodes() {
 		return this.nodes;
 	}
+	behaviours = /* @__PURE__ */ new Map();
+	indexBehaviour(method, owner, events) {
+		let byOwner = this.behaviours.get(method);
+		if (!byOwner) {
+			byOwner = /* @__PURE__ */ new Map();
+			this.behaviours.set(method, byOwner);
+		}
+		let entry = byOwner.get(owner);
+		if (!entry) {
+			entry = /* @__PURE__ */ new Set();
+			byOwner.set(owner, entry);
+		}
+		for (const e of events) entry.add(e);
+	}
+	invocations = [];
+	saveInvocation(invocation) {
+		this.invocations.push(invocation);
+	}
+	/**
+	* Expands recorded `receiver.method(...)` calls into edges from the caller to
+	* whatever the callee emits/sends. This links a command handler that
+	* delegates to an aggregate method (e.g. `message.destroy()` →
+	* `this.apply(SomeEvent.new(...))`) to the events it ultimately produces.
+	* Matching is by method name only — no receiver type resolution. To stay
+	* precise we attribute a method's events only when that name is declared in a
+	* single class; a name shared across classes (e.g. `enable`/`disable` on many
+	* feature aggregates) is ambiguous and skipped. Edges to unknown targets are
+	* dropped later by resolveEdges().
+	*/
+	resolveInvocations() {
+		for (const { from, method, source } of this.invocations) {
+			const byOwner = this.behaviours.get(method);
+			if (!byOwner || byOwner.size !== 1) continue;
+			const [events] = byOwner.values();
+			for (const name of events) this.edges.push({
+				from,
+				to: {
+					type: "event",
+					name
+				},
+				source
+			});
+		}
+	}
 	/**
 	* Edge targets discovered from `new X()` calls are speculative: when a walker
 	* records them it only knows the constructor name, not whether `X` is a
@@ -65,6 +109,8 @@ var Engine = class {
 	reset() {
 		this.edges = [];
 		this.nodes = [];
+		this.invocations = [];
+		this.behaviours = /* @__PURE__ */ new Map();
 	}
 	run(root = process.cwd()) {
 		for (const file of this.fileScanner(root)) {
@@ -78,6 +124,7 @@ var Engine = class {
 				}
 			} });
 		}
+		this.resolveInvocations();
 		this.resolveEdges();
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddd-ts/event-tree",
-  "version": "0.0.0-eventviz.15",
+  "version": "0.0.0-eventviz.16",
   "types": "dist/server/index.d.ts",
   "license": "MIT",
   "repository": {
@@ -15,7 +15,7 @@
     "oxc-walker": "^1.0.0"
   },
   "devDependencies": {
-    "@ddd-ts/tools": "0.0.0-eventviz.15",
+    "@ddd-ts/tools": "0.0.0-eventviz.16",
     "@types/node": "^22.14.1"
   },
   "exports": {