@mantaq/core 0.1.0 → 0.2.0

package/README.md

@@ -10,19 +10,19 @@ npm install @mantaq/core
 
 ## Quick Reference
 
-| Pattern         | Correct                                | Anti-pattern                          |
-| --------------- | -------------------------------------- | ------------------------------------- |
-| Type context    | `context: {} as MyContext`             | casting in every handler              |
-| Write context   | `context.set({ ...context.get() })`    | mutate without `set()`                |
-| Type events     | `event("ID")<Payload>()`               | `event("ID")()` without generic       |
-| Send events     | `actor.send(signInEvent.create(data))` | raw `{ type: "ID", payload }` objects |
-| Effect data     | Use state payload                      | Depend on `event` in effect           |
-| Error handling  | Emit internal event                    | Throw in effect or transition         |
-| Internal events | Declare in `internal: [...]`           | Put user events in internal           |
-| Signal check    | `if (signal.aborted) return`           | Skip abort check in async work        |
-| Regions         | Child outputs in parent `internal`     | Forget to declare child outputs       |
-| Snapshot        | `snapshot()` carries path + context    | Re-serialize context by hand          |
-| Any handler     | Universal events only (CANCEL)         | State-specific logic in `onAny`       |
+| Pattern         | Correct                                       | Anti-pattern                          |
+| --------------- | --------------------------------------------- | ------------------------------------- |
+| Type context    | `context: {} as MyContext`                    | casting in every handler              |
+| Write context   | `context.set({ ...context.get() })`           | mutate without `set()`                |
+| Type events     | `event("ID")<Payload>()`                      | `event("ID")()` without generic       |
+| Send events     | `actor.send(signInEvent.create(data))`        | raw `{ type: "ID", payload }` objects |
+| Effect data     | Use state payload                             | Depend on `event` in effect           |
+| Error handling  | Emit internal event                           | Throw in effect or transition         |
+| Internal events | Declare in `internal: [...]`                  | Put user events in internal           |
+| Signal check    | `if (signal.aborted) return`                  | Skip abort check in async work        |
+| Regions         | Child outputs in parent `internal`            | Forget to declare child outputs       |
+| Snapshot        | `snapshot()` carries path + context + payload | Re-serialize context by hand          |
+| Any handler     | Universal events only (CANCEL)                | State-specific logic in `onAny`       |
 
 ## Contents
 
@@ -42,6 +42,7 @@ npm install @mantaq/core
   - [Any Handler](#any-handler)
   - [Testing with VirtualClock](#testing-with-virtualclock)
 - [Development](#development)
+- [Testing](#testing)
 - [License](#license)
 
 ## Quick Start
@@ -337,7 +338,7 @@ m.effect(workingState, ({ signal, emit, clock }) => {
 
 ### Snapshot & Restore
 
-`actor.snapshot()` returns a `Snapshot` — `{ path, context, regions, done?, error? }`. Context is included. Use it to save/restore actor state across sessions.
+`actor.snapshot()` returns a `Snapshot` — `{ path, context, payload?, regions, done?, error? }`. Context is included; `payload` is the payload the current state was entered with (present only when the transition carried one). Use it to save/restore actor state across sessions.
 
 ```ts
 // Snapshot carries path, context, and regions — serialize it directly
@@ -425,17 +426,24 @@ const parent = new Actor({
 
 ### Error Handling
 
-Never throw from effects or transitions. Emit an error as an internal event and let a transition handle it. If user code throws anyway, the machine does **not** misbehave silently: it dies into a built-in terminal `__error` state, records `snapshot().error` (the thrown value, the last known good state/context, the bad event), drops remaining events, and ignores later `send`s. Errors never escape `send()` and the machine stays deterministic — same inputs, same trace.
+Never throw from effects or transitions. Emit an error as an internal event and let a transition handle it. If user code throws anyway, the machine does **not** misbehave silently: it dies into a built-in terminal `__error` state, records `snapshot().error` (the thrown value, the state/context at the point of failure, the bad event), drops remaining events, and ignores later `send`s. Errors never escape `send()` and the machine stays deterministic — same inputs, same trace.
 
 ```ts
 const snap = actor.snapshot();
 if (snap.error) {
-  snap.error.reason; // "transition" | "effect" | "budget" | "output" | "internal" | "async"
-  snap.error.state.name; // last known good state
+  snap.error.reason; // "transition" | "effect" | "budget" | "output" | "internal" | "async" | "unhandled"
+  snap.error.state.name; // the state at the point of failure
   snap.error.event.type; // the bad event
 }
 ```
 
+Two deliberate exceptions to "every failure is loud":
+
+- **Subscribers only watch.** They read snapshots and never change the machine, so a throwing `on("change")`/`on("done")`/`on("transition")` callback is swallowed — the machine and its callers are unaffected.
+- **Unhandled external events are ignored.** An event with no handler in the current state is dropped by design (broadcast fan-out, cross-state sends). An **internal** event with no handler, however, is a machine-authoring bug and routes to the error state (`reason: "unhandled"`).
+
+A dead machine can be manually resumed with `actor.recover({ state, context })` — an explicit, **inherently dangerous** escape hatch (the caller injects state and context, so determinism no longer holds). Effects are not re-run and timers are not re-armed; processing resumes on the next event. Prefer fixing the root cause and recreating the actor.
+
 Catch errors inside effects and emit recovery events:
 
 ```ts
@@ -662,6 +670,25 @@ vp test
 vp pack
 ```
 
+## Testing
+
+The package ships with a full test suite you can run and audit:
+
+```bash
+vp test          # feature + error + property tests
+vp check         # format, lint, typecheck (includes type-level contract tests)
+vp run mutation:core   # mutation score must stay ≥ 90
+```
+
+**Test contract.** Behavior is pinned by four kinds of tests, split by filename:
+
+- `*.test.ts` — features and happy paths, hand-maintained.
+- `*.error.test.ts` — failure paths: warnings, budgets, abort, unregistered, the `__error` state.
+- `*.property.test.ts` — property-based invariants against a reference model (fast-check, replayable via `MANTAQ_SEED`).
+- `*.mutation.test.ts` — directed tests that kill specific mutants; regenerable and thrown away between stryker runs.
+
+Coverage is analyzed per test (stryker `perTest` coverage analysis) so every mutant is attributed to the test that pins it. The mutation break threshold is 90 — a change that drops the score below 90 fails the build.
+
 ## License
 
 MIT

package/dist/{actor-internal-DYAL1iYK.d.mts → actor-internal-B4iAxUG_.d.mts}

@@ -88,7 +88,7 @@ interface EffectInput<ActorContext, Payload = unknown> {
   clock: Clock;
 }
 type EffectFn<ActorContext, Payload = unknown> = (input: EffectInput<ActorContext, Payload>) => void | Promise<void>;
-type ErrorReason = "transition" | "effect" | "budget" | "output" | "internal" | "async";
+type ErrorReason = "transition" | "effect" | "budget" | "output" | "internal" | "async" | "unhandled";
 interface ErrorInfo {
   error: unknown;
   state: AnyStateRef;
@@ -96,7 +96,13 @@ interface ErrorInfo {
   event: InternalEvent;
   reason: ErrorReason;
 }
-type ErrorState = StateRef<"__error", unknown, false>;
+interface TransitionInfo {
+  event: InternalEvent;
+  from: string;
+  to: string;
+  transitioned: boolean;
+}
+type ErrorState = StateRef<"__error", unknown, true>;
 type TransitionResult<AllowedState extends AnyStateRef = AnyStateRef, AllowedEmit extends string = string> = {
   state?: AllowedState | {
     state: AllowedState;
@@ -105,6 +111,7 @@ type TransitionResult<AllowedState extends AnyStateRef = AnyStateRef, AllowedEmi
   payload?: unknown;
   emit?: Array<{
     type: AllowedEmit;
+    payload?: unknown;
   }>;
 };
 //#endregion
@@ -112,6 +119,7 @@ type TransitionResult<AllowedState extends AnyStateRef = AnyStateRef, AllowedEmi
 interface Snapshot<C = unknown> {
   path: string[];
   context: C;
+  payload?: unknown;
   regions: Record<string, Snapshot<unknown>>;
   done?: boolean;
   error?: ErrorInfo;
@@ -124,6 +132,11 @@ interface AnyActor<C = Record<string, unknown>> {
   snapshot(): Snapshot<C>;
   on(event: "change", fn: (snapshot: Snapshot<C>, prev: Snapshot<C>) => void): () => void;
   on(event: "done", fn: () => void): () => void;
+  on(event: "transition", fn: (info: TransitionInfo) => void): () => void;
+  recover(target: {
+    state: AnyStateRef;
+    context: C;
+  }): void;
   settled(): Promise<void>;
   context?: C;
   options?: {
@@ -136,4 +149,4 @@ interface AnyActor<C = Record<string, unknown>> {
   };
 }
 //#endregion
-export { AnyStateRef as _, EffectInput as a, NonFinalStateRef as c, Clock as d, AnyEventRef as f, event as g, InternalEvent as h, EffectFn as i, TransitionResult as l, EventRef as m, Snapshot as n, ErrorInfo as o, CreatedOfEvent as p, CreatedOf as r, ErrorState as s, AnyActor as t, Context as u, StateRef as v, state as y };
+export { InternalEvent as _, EffectInput as a, StateRef as b, ErrorState as c, TransitionResult as d, Context as f, EventRef as g, CreatedOfEvent as h, EffectFn as i, NonFinalStateRef as l, AnyEventRef as m, Snapshot as n, ErrorInfo as o, Clock as p, CreatedOf as r, ErrorReason as s, AnyActor as t, TransitionInfo as u, event as v, state as x, AnyStateRef as y };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as AnyStateRef, a as EffectInput, c as NonFinalStateRef, d as Clock, f as AnyEventRef, g as event, h as InternalEvent, i as EffectFn, l as TransitionResult, m as EventRef, n as Snapshot, o as ErrorInfo, p as CreatedOfEvent, r as CreatedOf, s as ErrorState, t as AnyActor, u as Context, v as StateRef, y as state } from "./actor-internal-DYAL1iYK.mjs";
+import { _ as InternalEvent, a as EffectInput, b as StateRef, c as ErrorState, d as TransitionResult, f as Context, g as EventRef, h as CreatedOfEvent, i as EffectFn, l as NonFinalStateRef, m as AnyEventRef, n as Snapshot, o as ErrorInfo, p as Clock, r as CreatedOf, s as ErrorReason, t as AnyActor, u as TransitionInfo, v as event, x as state, y as AnyStateRef } from "./actor-internal-B4iAxUG_.mjs";
 //#region src/real-clock.d.ts
 declare class RealClock implements Clock {
   #private;
@@ -101,10 +101,22 @@ declare class Actor<const States extends readonly AnyStateRef[], const Inputs ex
   get regions(): Record<string, AnyActor>;
   get options(): InternalActorOptions<States, Inputs, Internal, Outputs, ActorContext>;
   constructor(options: ActorOptions<States, Inputs, Internal, Outputs, ActorContext>);
-  on(event: "change" | "done", fn: ((snapshot: Snapshot<ActorContext>, prev: Snapshot<ActorContext>) => void) | (() => void)): () => void;
+  on(event: "change", fn: (snapshot: Snapshot<ActorContext>, prev: Snapshot<ActorContext>) => void): () => void;
+  on(event: "done", fn: () => void): () => void;
+  on(event: "transition", fn: (info: TransitionInfo) => void): () => void;
   settled(): Promise<void>;
   send(event: CreatedOf$1<Inputs[number]>): void;
+  /**
+   * Manually restore the actor to a live state after a fatal `__error`.
+   * DANGER: the caller supplies state and context, so the trajectory is no
+   * longer deterministic ("same inputs, same trace"). Effects are not re-run
+   * and timers are not re-armed — processing resumes on the next event.
+   */
+  recover(target: {
+    state: States[number];
+    context: ActorContext;
+  }): void;
   snapshot(): Snapshot<ActorContext>;
 }
 //#endregion
-export { Actor, type ActorBuilder, type AnyActor, type AnyEventRef, type AnyStateRef, type Clock, Context, type CreatedOf, type CreatedOfEvent, type EffectFn, type EffectInput, type ErrorInfo, type ErrorState, EventRef, type InternalEvent, type NonFinalStateRef, RealClock, type SetupFn, type Snapshot, StateRef, VirtualClock, event, state };
+export { Actor, type ActorBuilder, type ActorOptions, type AnyActor, type AnyEventRef, type AnyStateRef, type BuiltMaps, type Clock, Context, type CreatedOf, type CreatedOfEvent, type EffectFn, type EffectInput, type ErrorInfo, type ErrorReason, type ErrorState, EventRef, type EventTypeOf, type InitialState, type InternalEvent, type NonFinalStateRef, type PayloadOf, RealClock, type SetupFn, type Snapshot, StateRef, type TransitionHandler, type TransitionInfo, type TransitionResult, VirtualClock, event, state };

package/dist/index.mjs

@@ -86,13 +86,23 @@ var VirtualClock = class {
 	now() {
 		return this.#now;
 	}
+	/**
+	* Delay normalization: NaN and ±Infinity throw (programmer error); negative
+	* and 0 clamp to 0 for timeouts like the platform, to a 1ms floor for
+	* intervals (a 0ms interval would spin the synchronous advance loop
+	* forever). Finite positive values schedule at their real deadline.
+	*/
+	#delay(ms, method, interval) {
+		if (!Number.isFinite(ms)) throw new RangeError(`[VirtualClock] invalid ${method} ms value: ${ms}`);
+		return ms <= 0 ? interval ? 1 : 0 : ms;
+	}
 	setTimeout(ms, cb, options) {
 		const signal = options?.signal;
 		if (signal?.aborted) return -1;
 		const id = this.#nextId++;
 		const onAbort = trackAbort(signal, id, this.#timers);
 		this.#timers.set(id, {
-			deadline: this.#now + ms,
+			deadline: this.#now + this.#delay(ms, "setTimeout", false),
 			cb,
 			signal,
 			onAbort,
@@ -112,9 +122,10 @@ var VirtualClock = class {
 		if (signal?.aborted) return -1;
 		const id = this.#nextId++;
 		const onAbort = trackAbort(signal, id, this.#intervals);
+		const d = this.#delay(ms, "setInterval", true);
 		this.#intervals.set(id, {
-			ms,
-			next: this.#now + ms,
+			ms: d,
+			next: this.#now + d,
 			cb,
 			signal,
 			onAbort
@@ -165,7 +176,8 @@ var VirtualClock = class {
 		}
 	}
 	advance(ms) {
-		const target = this.#now + ms;
+		if (!Number.isFinite(ms)) throw new RangeError(`[VirtualClock] invalid advance ms value: ${ms}`);
+		const target = this.#now + Math.max(0, ms);
 		while (true) {
 			const deadline = this.#findEarliestDeadline(target);
 			if (deadline === null) break;
@@ -246,6 +258,7 @@ var InternalQueue = class {
 var Subscribers = class {
 	change = /* @__PURE__ */ new Set();
 	done = /* @__PURE__ */ new Set();
+	transition = /* @__PURE__ */ new Set();
 	#last = null;
 	seed(snapshot) {
 		this.#last = snapshot;
@@ -260,6 +273,10 @@ var Subscribers = class {
 		this.done.add(fn);
 		return () => this.done.delete(fn);
 	}
+	addTransition(fn) {
+		this.transition.add(fn);
+		return () => this.transition.delete(fn);
+	}
 	emitChange(snapshot) {
 		const prev = this.#last ?? snapshot;
 		this.#last = snapshot;
@@ -268,18 +285,21 @@ var Subscribers = class {
 	emitDone() {
 		for (const fn of this.done) this.#safe(fn);
 	}
+	emitTransition(info) {
+		for (const fn of this.transition) this.#safe(() => fn(info));
+	}
 	clear() {
 		this.change.clear();
 		this.done.clear();
+		this.transition.clear();
 	}
 	#safe(fn) {
-		const err = Either.from(fn);
-		if (err[0] !== void 0) console.warn(`[Actor] subscriber threw: ${err[0] instanceof Error ? err[0].message : "unknown error"}`);
+		Either.from(fn);
 	}
 };
 //#endregion
 //#region src/snapshot.ts
-function buildSnapshot(s, regions, context, error) {
+function buildSnapshot(s, regions, context, opts = {}) {
 	const path = [s.name];
 	const regionSnapshots = {};
 	for (const [regionName, child] of Object.entries(regions)) regionSnapshots[regionName] = child.snapshot();
@@ -288,15 +308,15 @@ function buildSnapshot(s, regions, context, error) {
 		context,
 		regions: regionSnapshots
 	};
+	if (opts.payload !== void 0) snap.payload = opts.payload;
 	if (s.isFinal) snap.done = true;
-	if (error !== void 0) snap.error = error;
+	if (opts.error !== void 0) snap.error = opts.error;
 	return snap;
 }
 //#endregion
 //#region src/effects.ts
 function runEffects(options) {
 	const pending = [];
-	if (options.state.isFinal) return { pending };
 	const list = options.effects[options.state.name];
 	if (!list) return { pending };
 	for (const effectFn of list) {
@@ -438,32 +458,38 @@ var Actor = class {
 		this.clock.setDrain?.(() => this.#drainInternal());
 		const initState = resolveInitial(options.initial);
 		const stateNames = new Set(options.states.map((s) => s.name));
-		if (!stateNames.has(initState.name)) console.warn(`[Actor] initial state "${initState.name}" not found in declared states [${[...stateNames].join(", ")}]`);
+		if (!stateNames.has(initState.name)) throw new Error(`[Actor] initial state "${initState.name}" not found in declared states [${[...stateNames].join(", ")}]`);
 		this.state = initState;
+		this.#statePayload = options.initial instanceof StateRef ? void 0 : options.initial.payload;
 		this.#context = options.context ?? {};
 		this.#lastState = initState;
 		this.#contextHandle = new Context(() => this.#context, (value) => {
 			this.#context = value;
 			this.#contextWritten = true;
 		});
-		this.#subs.seed(this.snapshot());
 		if (options.regions) for (const [key, child] of Object.entries(options.regions)) {
 			this.#regions[key] = child;
 			const result = setOutputHandler(child, (event) => {
 				this.#queue.push(event);
 				this.#drainInternal();
 			});
-			if (result[0] !== void 0) console.error(result[0].message);
+			if (result[0] !== void 0) throw new Error(result[0].message);
 			this.#children.set(key, child);
 		}
+		this.#runEffects({ type: "__init" }, this.#statePayload);
+		this.#subs.seed(this.snapshot());
 	}
 	on(event, fn) {
 		if (event === "change") {
 			const cb = fn;
 			return this.#subs.addChange(cb);
 		}
+		if (event === "done") {
+			const cb = fn;
+			return this.#subs.addDone(cb);
+		}
 		const cb = fn;
-		return this.#subs.addDone(cb);
+		return this.#subs.addTransition(cb);
 	}
 	settled() {
 		return Promise.all([this.#queue.settled(), ...this.#pendingEffects]).then(() => void 0);
@@ -472,6 +498,26 @@ var Actor = class {
 		this.#dispatch(event);
 		this.#emitChangeIfDirty();
 	}
+	/**
+	* Manually restore the actor to a live state after a fatal `__error`.
+	* DANGER: the caller supplies state and context, so the trajectory is no
+	* longer deterministic ("same inputs, same trace"). Effects are not re-run
+	* and timers are not re-armed — processing resumes on the next event.
+	*/
+	recover(target) {
+		if (this.#error === null) return;
+		this.#error = null;
+		this.#queue = new InternalQueue();
+		this.#effectAbort = null;
+		this.state = target.state;
+		this.#statePayload = void 0;
+		this.#context = target.context;
+		this.#lastState = target.state;
+		this.#contextWritten = false;
+		this.#entry = null;
+		this.#pendingEffects = [];
+		this.#subs.emitChange(this.snapshot());
+	}
 	#emitChangeIfDirty() {
 		if (this.state === this.#lastState && !this.#contextWritten) return;
 		this.#lastState = this.state;
@@ -480,6 +526,11 @@ var Actor = class {
 	}
 	#dispatch(event) {
 		if (this.#error !== null || this.state.isFinal) return;
+		const normalized = {
+			...event,
+			payload: event.payload ?? {}
+		};
+		const from = this.state.name;
 		const prev = this.#entry;
 		this.#entry = {
 			state: this.state,
@@ -489,15 +540,44 @@ var Actor = class {
 			const transitions = this.#options.transitions;
 			const stateTransition = transitions[this.state.name]?.[event.type];
 			const anyTransition = transitions["Any"]?.[event.type];
-			const transitionApplied = stateTransition ? this.#applyStateStep(event, stateTransition) : false;
-			if ((this.#error === null ? this.#applyAnyStep(event, anyTransition, !transitionApplied) : false) || this.#queue.length > 0) this.#drainInternal();
-			else if (!stateTransition && !anyTransition) console.warn(`[Actor] no transition for event "${event.type}" in state "${this.state.name}". Event dropped.`);
+			const result = this.#step(normalized, stateTransition, anyTransition);
+			this.#maybeEmitTransition(normalized, from, Boolean(stateTransition || anyTransition), result);
+			if (result.emitted || this.#queue.length > 0) this.#drainInternal();
+			else if (!stateTransition && !anyTransition) {
+				if (this.#internalIds.has(event.type)) this.#enterError("unhandled", event, /* @__PURE__ */ new Error(`[Actor] internal event "${event.type}" emitted but no handler in state "${this.state.name}"`));
+			}
 		} finally {
 			this.#entry = prev;
 		}
 	}
+	#step(normalized, stateTransition, anyTransition) {
+		const stateOutcome = stateTransition ? this.#applyStateStep(normalized, stateTransition) : { applied: false };
+		if (this.#error === null) {
+			const anyOutcome = this.#applyAnyStep(normalized, anyTransition, !stateOutcome.applied);
+			return {
+				emitted: anyOutcome.emitted,
+				transitioned: stateOutcome.applied || anyOutcome.transitioned,
+				target: stateOutcome.target ?? anyOutcome.target
+			};
+		}
+		return {
+			emitted: false,
+			transitioned: false
+		};
+	}
+	#maybeEmitTransition(event, from, handled, outcome) {
+		if (this.#error !== null) return;
+		if (!handled) return;
+		this.#subs.emitTransition({
+			event,
+			from,
+			to: outcome.target ?? this.state.name,
+			transitioned: outcome.transitioned
+		});
+	}
 	#applyStateStep(event, transition) {
 		let applied = false;
+		let target;
 		this.#safe("transition", event, () => {
 			const step = transition(event, {
 				context: this.#contextHandle,
@@ -505,47 +585,72 @@ var Actor = class {
 			});
 			if (step.emit) this.#queue.push(...step.emit);
 			if (step.state) {
-				this.#applyTransition(event, step);
+				target = this.#applyTransition(event, step);
 				applied = true;
 			}
 		});
-		return applied;
+		return {
+			applied,
+			target
+		};
 	}
 	#applyAnyStep(event, transition, allowTransition) {
-		if (transition === void 0) return false;
+		if (transition === void 0) return {
+			emitted: false,
+			transitioned: false
+		};
 		let emitted = false;
+		let transitioned = false;
+		let target;
 		this.#safe("transition", event, () => {
 			const step = transition(event, {
 				context: this.#contextHandle,
 				actor: this
 			});
-			if (step.state && allowTransition) this.#applyTransition(event, step);
+			if (step.state && allowTransition) {
+				target = this.#applyTransition(event, step);
+				transitioned = true;
+			}
 			if (step.emit) {
 				this.#queue.push(...step.emit);
 				emitted = true;
 			}
 		});
-		return emitted;
+		return {
+			emitted,
+			transitioned,
+			target
+		};
 	}
 	snapshot() {
-		return buildSnapshot(this.state, this.#regions, this.#context, this.#error ?? void 0);
+		return buildSnapshot(this.state, this.#regions, this.#context, {
+			error: this.#error ?? void 0,
+			payload: this.#statePayload
+		});
 	}
 	#abortEffects() {
 		this.#effectAbort?.abort();
 		this.#subs.clear();
 	}
 	#applyTransition(event, step) {
-		if (this.#error !== null || !step.state) return;
+		if (this.#error !== null || !step.state) return void 0;
 		const resolved = parseTarget(step);
-		if (!resolved) return;
+		if (!resolved) return void 0;
 		if (!(resolved.state instanceof StateRef)) {
 			this.#enterError("transition", event, /* @__PURE__ */ new Error("invalid transition target"));
 			return;
 		}
 		this.#effectAbort?.abort();
 		this.state = resolved.state;
+		const target = this.state.name;
+		this.#statePayload = resolved.payload;
+		this.#entry = {
+			state: this.state,
+			context: this.#context
+		};
 		this.#runEffects(event, resolved.payload);
-		if (this.state.isFinal) this.#subs.emitDone();
+		if (resolved.state.isFinal && this.#error === null) this.#subs.emitDone();
+		return target;
 	}
 	#runEffects(event, statePayload) {
 		const list = this.#options.effects[this.state.name];
@@ -566,7 +671,7 @@ var Actor = class {
 			event,
 			context: this.#contextHandle,
 			emit: (e) => {
-				if (this.#error !== null) return;
+				if (this.#error !== null || abort.signal.aborted) return;
 				this.#queue.push(e);
 				this.#drainInternal();
 			},
@@ -604,10 +709,11 @@ var Actor = class {
 			this.#emitChangeIfDirty();
 		}
 	}
-	#errorState = new StateRef("__error", false);
+	#statePayload;
+	#pendingEffects = [];
+	#errorState = new StateRef("__error", true);
 	#error = null;
 	#entry = null;
-	#pendingEffects = [];
 	#safe(reason, event, fn) {
 		const attempt = Either.from(fn);
 		if (attempt[0] === void 0) return true;
@@ -629,9 +735,11 @@ var Actor = class {
 		};
 		this.#effectAbort?.abort();
 		this.state = this.#errorState;
+		this.#statePayload = void 0;
 		this.#lastState = this.#errorState;
 		this.#contextWritten = false;
 		this.#subs.emitChange(this.snapshot());
+		this.#subs.emitDone();
 	}
 };
 //#endregion

package/dist/internal.d.mts

@@ -1,4 +1,4 @@
-import { h as InternalEvent, t as AnyActor } from "./actor-internal-DYAL1iYK.mjs";
+import { _ as InternalEvent, t as AnyActor } from "./actor-internal-B4iAxUG_.mjs";
 import { Either } from "@mantaq/utils";
 //#region src/internal-registry.d.ts
 interface ActorInternal {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantaq/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "State machine runtime with actor model, event system, state hierarchy, effects, and virtual clock.",
   "license": "MIT",
   "repository": {