@mantaq/traversal 0.1.0 → 0.1.2

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AnyActor, Context, Snapshot } from "@mantaq/core";
+import { AnyActor, Context, ErrorInfo, InternalEvent, Snapshot, TransitionInfo } from "@mantaq/core";
 //#region src/types.d.ts
 interface GraphNode {
   id: string;
@@ -49,7 +49,7 @@ interface HistoryEntry {
 //#region src/graph.d.ts
 declare const INITIAL_NODE_ID = "__initial__";
 declare function collectActiveStates(snapshot: Snapshot, prefix: string, activeSet: Set<string>): void;
-declare function buildGraph(actor: AnyActor, options?: {
+declare function buildGraph<C>(actor: AnyActor<C>, options?: {
   internalIds?: Set<string>;
   sampleContext?: Record<string, unknown>;
   sampleContexts?: Record<string, Record<string, unknown>>;
@@ -73,21 +73,29 @@ declare class History {
 }
 //#endregion
 //#region src/instrument.d.ts
-interface InstrumentedActor {
+interface InstrumentedActor<C = Record<string, unknown>> {
   history: History;
   send(event: unknown): void;
   state: AnyActor["state"];
-  snapshot(): Snapshot<Record<string, unknown>>;
+  snapshot(): Snapshot<C>;
   regions: Record<string, AnyActor>;
-  context?: Record<string, unknown>;
+  context?: C;
   clock: AnyActor["clock"];
-  on(event: "change", fn: (snapshot: Snapshot<Record<string, unknown>>, prev: Snapshot<Record<string, unknown>>) => void): () => void;
-  on(event: "error", fn: (error: unknown) => void): () => void;
+  on(event: "change", fn: (snapshot: Snapshot<C>, prev: Snapshot<C>) => void): () => void;
+  on(event: "transition", fn: (info: TransitionInfo) => void): () => void;
   on(event: "done", fn: () => void): () => void;
+  on(event: "error", fn: (info: ErrorInfo) => void): () => void;
+  on(event: "output", fn: (event: InternalEvent) => void): () => void;
+  recover(target: {
+    state: AnyActor["state"];
+    context: C;
+  }): void;
   settled(): Promise<void>;
   options?: AnyActor["options"];
+  inject(event: InternalEvent): void;
+  dispose(): void;
 }
-declare function instrument(actor: AnyActor): InstrumentedActor;
+declare function instrument<C>(actor: AnyActor<C>): InstrumentedActor<C>;
 //#endregion
 //#region src/algorithms.d.ts
 declare function reachable(graph: ActorGraph, fromId: string, toId: string): boolean;

package/dist/index.mjs

@@ -223,11 +223,7 @@ function buildGraph(actor, options) {
 			edges
 		};
 	}), (error) => {
-		console.error("[mantaq/traversal] buildGraph failed:", error);
-		return {
-			nodes: [],
-			edges: []
-		};
+		throw error;
 	}, (result) => result);
 }
 //#endregion
@@ -275,8 +271,8 @@ var History = class {
 };
 //#endregion
 //#region src/instrument.ts
-function wrapWithProxy(actor, hooks) {
-	const { history, origSend, pendingEventId } = hooks;
+function wrapWithProxy(actor, history) {
+	const origSend = actor.send.bind(actor);
 	return {
 		get history() {
 			return history;
@@ -297,42 +293,41 @@ function wrapWithProxy(actor, hooks) {
 			return actor.options;
 		},
 		send(event) {
-			const { type: eventType } = trackSendEvent(history, event);
-			pendingEventId.value = eventType;
-			try {
-				origSend(event);
-			} finally {
-				pendingEventId.value = void 0;
-			}
+			trackSendEvent(history, event);
+			origSend(event);
 		},
 		snapshot() {
 			return actor.snapshot();
 		},
 		on: actor.on.bind(actor),
+		inject: actor.inject.bind(actor),
+		dispose: actor.dispose.bind(actor),
+		recover: actor.recover.bind(actor),
 		settled: actor.settled.bind(actor)
 	};
 }
-function recordTransition(history, from, to, eventId) {
+function recordTransition(history, rec) {
 	history.append({
 		type: "transition",
 		data: {
-			from,
-			event: eventId,
-			to,
+			from: rec.from,
+			event: rec.event,
+			to: rec.to,
 			timestamp: Date.now()
 		}
 	});
+	if (!rec.transitioned) return;
 	history.append({
 		type: "state_visit",
 		data: {
-			stateName: to,
+			stateName: rec.to,
 			timestamp: Date.now()
 		}
 	});
-	history.append({
+	if ((rec.effects[rec.to] ?? []).length > 0) history.append({
 		type: "effect",
 		data: {
-			stateName: to,
+			stateName: rec.to,
 			timestamp: Date.now()
 		}
 	});
@@ -346,13 +341,9 @@ function trackSendEvent(history, event) {
 			timestamp: Date.now()
 		}
 	});
-	return { type: eventId };
 }
 function instrument(actor) {
 	const history = new History();
-	const origSend = actor.send.bind(actor);
-	let prevStateName = actor.state.name;
-	const pendingEventId = { value: void 0 };
 	history.append({
 		type: "state_visit",
 		data: {
@@ -360,17 +351,16 @@ function instrument(actor) {
 			timestamp: Date.now()
 		}
 	});
-	const wrapped = wrapWithProxy(actor, {
-		history,
-		origSend,
-		pendingEventId
-	});
-	actor.on("change", () => {
-		const currentName = actor.state.name;
-		if (currentName !== prevStateName) {
-			recordTransition(history, prevStateName, currentName, pendingEventId.value ?? "unknown");
-			prevStateName = currentName;
-		}
+	const wrapped = wrapWithProxy(actor, history);
+	const effectsByState = actor.options?.effects ?? {};
+	actor.on("transition", ({ event, from, to, transitioned }) => {
+		recordTransition(history, {
+			from,
+			to,
+			event: event.type,
+			transitioned,
+			effects: effectsByState
+		});
 	});
 	return wrapped;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantaq/traversal",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Graph extraction, traversal algorithms, and runtime tracking for mantaq actors.",
   "license": "MIT",
   "repository": {
@@ -20,8 +20,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@mantaq/core": "0.1.0",
-    "@mantaq/utils": "0.0.2"
+    "@mantaq/core": "0.3.0",
+    "@mantaq/utils": "0.0.3"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",