effect-machine 0.9.0 → 0.11.0

package/dist/actor.js

@@ -1,11 +1,8 @@
 import { Inspector } from "./inspection.js";
 import { INTERNAL_INIT_EVENT } from "./internal/utils.js";
-import { DuplicateActorError } from "./errors.js";
-import { isPersistentMachine } from "./persistence/persistent-machine.js";
+import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
 import { emitWithTimestamp } from "./internal/inspection.js";
-import { processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
-import { PersistenceAdapterTag, PersistenceError } from "./persistence/adapter.js";
-import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
+import { processEventCore, resolveTransition, runSpawnEffects, shouldPostpone } from "./internal/transition.js";
 import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Scope, Semaphore, ServiceMap, Stream, SubscriptionRef } from "effect";
 //#region src/actor.ts
 /**
@@ -29,14 +26,17 @@ const notifyListeners = (listeners, state) => {
 	} catch {}
 };
 /**
-* Build core ActorRef methods shared between regular and persistent actors.
+* Build core ActorRef methods.
 */
-const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap) => {
+const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap, pendingReplies, transitionsPubSub) => {
 	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) return;
-		yield* Queue.offer(eventQueue, { event });
+		yield* Queue.offer(eventQueue, {
+			_tag: "send",
+			event
+		});
 	});
-	const dispatch = Effect.fn("effect-machine.actor.dispatch")(function* (event) {
+	const call = Effect.fn("effect-machine.actor.call")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) {
 			const currentState = yield* SubscriptionRef.get(stateRef);
 			return {
@@ -48,11 +48,30 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 			};
 		}
 		const reply = yield* Deferred.make();
+		pendingReplies.add(reply);
 		yield* Queue.offer(eventQueue, {
+			_tag: "call",
 			event,
 			reply
 		});
-		return yield* Deferred.await(reply);
+		return yield* Deferred.await(reply).pipe(Effect.ensuring(Effect.sync(() => pendingReplies.delete(reply))), Effect.catchTag("ActorStoppedError", () => SubscriptionRef.get(stateRef).pipe(Effect.map((currentState) => ({
+			newState: currentState,
+			previousState: currentState,
+			transitioned: false,
+			lifecycleRan: false,
+			isFinal: machine.finalStates.has(currentState._tag)
+		})))));
+	});
+	const ask = Effect.fn("effect-machine.actor.ask")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) return yield* new ActorStoppedError({ actorId: id });
+		const reply = yield* Deferred.make();
+		pendingReplies.add(reply);
+		yield* Queue.offer(eventQueue, {
+			_tag: "ask",
+			event,
+			reply
+		});
+		return yield* Deferred.await(reply).pipe(Effect.ensuring(Effect.sync(() => pendingReplies.delete(reply))));
 	});
 	const snapshot = SubscriptionRef.get(stateRef).pipe(Effect.withSpan("effect-machine.actor.snapshot"));
 	const matches = Effect.fn("effect-machine.actor.matches")(function* (tag) {
@@ -88,32 +107,39 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 	return {
 		id,
 		send,
+		cast: send,
+		call,
+		ask,
 		state: stateRef,
 		stop,
-		stopSync: () => Effect.runFork(stop),
 		snapshot,
-		snapshotSync: () => Effect.runSync(SubscriptionRef.get(stateRef)),
 		matches,
-		matchesSync: (tag) => Effect.runSync(SubscriptionRef.get(stateRef))._tag === tag,
 		can,
-		canSync: (event) => {
-			return resolveTransition(machine, Effect.runSync(SubscriptionRef.get(stateRef)), event) !== void 0;
-		},
 		changes: SubscriptionRef.changes(stateRef),
+		transitions: transitionsPubSub !== void 0 ? Stream.fromPubSub(transitionsPubSub) : Stream.empty,
 		waitFor,
 		awaitFinal,
 		sendAndWait,
-		sendSync: (event) => {
-			if (!Effect.runSync(Ref.get(stoppedRef))) Effect.runSync(Queue.offer(eventQueue, { event }));
-		},
-		dispatch,
-		dispatchPromise: (event) => Effect.runPromise(dispatch(event)),
 		subscribe: (fn) => {
 			listeners.add(fn);
 			return () => {
 				listeners.delete(fn);
 			};
 		},
+		sync: {
+			send: (event) => {
+				if (!Effect.runSync(Ref.get(stoppedRef))) Effect.runSync(Queue.offer(eventQueue, {
+					_tag: "send",
+					event
+				}));
+			},
+			stop: () => Effect.runFork(stop),
+			snapshot: () => Effect.runSync(SubscriptionRef.get(stateRef)),
+			matches: (tag) => Effect.runSync(SubscriptionRef.get(stateRef))._tag === tag,
+			can: (event) => {
+				return resolveTransition(machine, Effect.runSync(SubscriptionRef.get(stateRef)), event) !== void 0;
+			}
+		},
 		system,
 		children: childrenMap
 	};
@@ -121,7 +147,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 /**
 * Create and start an actor for a machine
 */
-const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine) {
+const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine, options) {
+	const initial = options?.initialState ?? machine.initial;
 	yield* Effect.annotateCurrentSpan("effect_machine.actor.id", id);
 	const existingSystem = yield* Effect.serviceOption(ActorSystem);
 	let system;
@@ -136,11 +163,16 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	const eventQueue = yield* Queue.unbounded();
 	const stoppedRef = yield* Ref.make(false);
 	const childrenMap = /* @__PURE__ */ new Map();
+	const selfSend = Effect.fn("effect-machine.actor.self.send")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) return;
+		yield* Queue.offer(eventQueue, {
+			_tag: "send",
+			event
+		});
+	});
 	const self = {
-		send: Effect.fn("effect-machine.actor.self.send")(function* (event) {
-			if (yield* Ref.get(stoppedRef)) return;
-			yield* Queue.offer(eventQueue, { event });
-		}),
+		send: selfSend,
+		cast: selfSend,
 		spawn: (childId, childMachine) => Effect.gen(function* () {
 			const child = yield* system.spawn(childId, childMachine).pipe(Effect.provideService(ActorSystem, system));
 			childrenMap.set(childId, child);
@@ -151,20 +183,20 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 			return child;
 		})
 	};
-	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", machine.initial._tag);
+	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", initial._tag);
 	yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
 		type: "@machine.spawn",
 		actorId: id,
-		initialState: machine.initial,
+		initialState: initial,
 		timestamp
 	}));
-	const stateRef = yield* SubscriptionRef.make(machine.initial);
+	const stateRef = yield* SubscriptionRef.make(initial);
 	const listeners = /* @__PURE__ */ new Set();
 	const backgroundFibers = [];
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
 	const ctx = {
 		actorId: id,
-		state: machine.initial,
+		state: initial,
 		event: initEvent,
 		self,
 		system
@@ -173,7 +205,7 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	for (const bg of machine.backgroundEffects) {
 		const fiber = yield* Effect.forkDetach(bg.handler({
 			actorId: id,
-			state: machine.initial,
+			state: initial,
 			event: initEvent,
 			self,
 			effects: effectSlots,
@@ -182,21 +214,23 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		backgroundFibers.push(fiber);
 	}
 	const stateScopeRef = { current: yield* Scope.make() };
-	yield* runSpawnEffectsWithInspection(machine, machine.initial, initEvent, self, stateScopeRef.current, id, inspectorValue, system);
-	if (machine.finalStates.has(machine.initial._tag)) {
+	yield* runSpawnEffectsWithInspection(machine, initial, initEvent, self, stateScopeRef.current, id, inspectorValue, system);
+	if (machine.finalStates.has(initial._tag)) {
 		yield* Scope.close(stateScopeRef.current, Exit.void);
 		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
 			type: "@machine.stop",
 			actorId: id,
-			finalState: machine.initial,
+			finalState: initial,
 			timestamp
 		}));
 		yield* Ref.set(stoppedRef, true);
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap);
+		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap, /* @__PURE__ */ new Set());
 	}
-	const loopFiber = yield* Effect.forkDetach(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system));
+	const pendingReplies = /* @__PURE__ */ new Set();
+	const transitionsPubSub = yield* PubSub.unbounded();
+	const loopFiber = yield* Effect.forkDetach(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system, pendingReplies, transitionsPubSub));
 	return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
 		const finalState = yield* SubscriptionRef.get(stateRef);
 		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
@@ -207,33 +241,115 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		}));
 		yield* Ref.set(stoppedRef, true);
 		yield* Fiber.interrupt(loopFiber);
+		yield* settlePendingReplies(pendingReplies, id);
 		yield* Scope.close(stateScopeRef.current, Exit.void);
 		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap);
+	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap, pendingReplies, transitionsPubSub);
+});
+/** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */
+const settlePendingReplies = (pendingReplies, actorId) => Effect.sync(() => {
+	const error = new ActorStoppedError({ actorId });
+	for (const deferred of pendingReplies) Effect.runFork(Deferred.fail(deferred, error));
+	pendingReplies.clear();
 });
 /**
-* Main event loop for the actor
+* Main event loop for the actor.
+* Includes postpone buffer — events matching postpone rules are buffered
+* and drained after state tag changes (gen_statem semantics).
 */
-const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, actorId, inspector, system) {
-	while (true) {
-		const { event, reply } = yield* Queue.take(eventQueue);
+const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, actorId, inspector, system, pendingReplies, transitionsPubSub) {
+	const postponed = [];
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const processQueued = Effect.fn("effect-machine.actor.processQueued")(function* (queued) {
+		const event = queued.event;
 		const currentState = yield* SubscriptionRef.get(stateRef);
+		if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
+			postponed.push(queued);
+			if (queued._tag === "call") {
+				const postponedResult = {
+					newState: currentState,
+					previousState: currentState,
+					transitioned: false,
+					lifecycleRan: false,
+					isFinal: false,
+					hasReply: false,
+					reply: void 0,
+					postponed: true
+				};
+				yield* Deferred.succeed(queued.reply, postponedResult);
+			}
+			return {
+				shouldStop: false,
+				stateChanged: false
+			};
+		}
 		const { shouldStop, result } = yield* Effect.withSpan("effect-machine.event.process", { attributes: {
 			"effect_machine.actor.id": actorId,
 			"effect_machine.state.current": currentState._tag,
 			"effect_machine.event.type": event._tag
 		} })(processEvent(machine, currentState, event, stateRef, self, listeners, stateScopeRef, actorId, inspector, system));
-		if (reply !== void 0) yield* Deferred.succeed(reply, result);
+		switch (queued._tag) {
+			case "call":
+				yield* Deferred.succeed(queued.reply, result);
+				break;
+			case "ask":
+				if (result.hasReply) yield* Deferred.succeed(queued.reply, result.reply);
+				else yield* Deferred.fail(queued.reply, new NoReplyError({
+					actorId,
+					eventTag: event._tag
+				}));
+				break;
+		}
+		if (result.transitioned) yield* PubSub.publish(transitionsPubSub, {
+			fromState: result.previousState,
+			toState: result.newState,
+			event
+		});
+		return {
+			shouldStop,
+			stateChanged: result.lifecycleRan
+		};
+	});
+	while (true) {
+		const { shouldStop, stateChanged } = yield* processQueued(yield* Queue.take(eventQueue));
 		if (shouldStop) {
 			yield* Ref.set(stoppedRef, true);
+			settlePostponedBuffer(postponed, pendingReplies, actorId);
+			yield* settlePendingReplies(pendingReplies, actorId);
 			yield* Scope.close(stateScopeRef.current, Exit.void);
 			yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 			return;
 		}
+		let drainTriggered = stateChanged;
+		while (drainTriggered && postponed.length > 0) {
+			drainTriggered = false;
+			const drained = postponed.splice(0);
+			for (const entry of drained) {
+				const drain = yield* processQueued(entry);
+				if (drain.shouldStop) {
+					yield* Ref.set(stoppedRef, true);
+					settlePostponedBuffer(postponed, pendingReplies, actorId);
+					yield* settlePendingReplies(pendingReplies, actorId);
+					yield* Scope.close(stateScopeRef.current, Exit.void);
+					yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
+					return;
+				}
+				if (drain.stateChanged) drainTriggered = true;
+			}
+		}
 	}
 });
 /**
+* Settle all reply-bearing entries in the postpone buffer on shutdown.
+* Call entries already had their Deferred settled with the postponed result
+* (so their pendingReplies entry is already removed). Ask/send entries
+* with Deferreds are settled via the pendingReplies registry.
+*/
+const settlePostponedBuffer = (postponed, _pendingReplies, _actorId) => {
+	postponed.length = 0;
+};
+/**
 * Process a single event, returning true if the actor should stop.
 * Wraps processEventCore with actor-specific concerns (inspection, listeners, state ref).
 */
@@ -375,25 +491,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
 		return yield* registerActor(id, yield* createActor(id, built._inner));
 	});
-	const spawnPersistent = Effect.fn("effect-machine.actorSystem.spawnPersistent")(function* (id, persistentMachine) {
-		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
-		const adapter = yield* PersistenceAdapterTag;
-		const maybeSnapshot = yield* adapter.loadSnapshot(id, persistentMachine.persistence.stateSchema);
-		return yield* registerActor(id, yield* createPersistentActor(id, persistentMachine, maybeSnapshot, yield* adapter.loadEvents(id, persistentMachine.persistence.eventSchema, Option.isSome(maybeSnapshot) ? maybeSnapshot.value.version : void 0)));
-	});
-	const spawnImpl = Effect.fn("effect-machine.actorSystem.spawn")(function* (id, machine) {
-		if (isPersistentMachine(machine)) return yield* spawnPersistent(id, machine);
-		return yield* spawnRegular(id, machine);
-	});
-	function spawn(id, machine) {
-		return withSpawnGate(spawnImpl(id, machine));
-	}
-	const restoreImpl = Effect.fn("effect-machine.actorSystem.restore")(function* (id, persistentMachine) {
-		const maybeActor = yield* restorePersistentActor(id, persistentMachine);
-		if (Option.isSome(maybeActor)) yield* registerActor(id, maybeActor.value);
-		return maybeActor;
-	});
-	const restore = (id, persistentMachine) => withSpawnGate(restoreImpl(id, persistentMachine));
+	const spawn = (id, machine) => withSpawnGate(spawnRegular(id, machine));
 	const get = Effect.fn("effect-machine.actorSystem.get")(function* (id) {
 		return yield* Effect.sync(() => MutableHashMap.get(actorsMap, id));
 	});
@@ -410,55 +508,8 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		yield* actor.stop;
 		return true;
 	});
-	const listPersisted = Effect.fn("effect-machine.actorSystem.listPersisted")(function* () {
-		const adapter = yield* PersistenceAdapterTag;
-		if (adapter.listActors === void 0) return [];
-		return yield* adapter.listActors();
-	});
-	const restoreMany = Effect.fn("effect-machine.actorSystem.restoreMany")(function* (ids, persistentMachine) {
-		const restored = [];
-		const failed = [];
-		for (const id of ids) {
-			if (MutableHashMap.has(actorsMap, id)) continue;
-			const result = yield* Effect.result(restore(id, persistentMachine));
-			if (result._tag === "Failure") failed.push({
-				id,
-				error: result.failure
-			});
-			else if (Option.isSome(result.success)) restored.push(result.success.value);
-			else failed.push({
-				id,
-				error: new PersistenceError({
-					operation: "restore",
-					actorId: id,
-					message: "No persisted state found"
-				})
-			});
-		}
-		return {
-			restored,
-			failed
-		};
-	});
-	const restoreAll = Effect.fn("effect-machine.actorSystem.restoreAll")(function* (persistentMachine, options) {
-		const adapter = yield* PersistenceAdapterTag;
-		if (adapter.listActors === void 0) return {
-			restored: [],
-			failed: []
-		};
-		const machineType = persistentMachine.persistence.machineType;
-		if (machineType === void 0) return yield* new PersistenceError({
-			operation: "restoreAll",
-			actorId: "*",
-			message: "restoreAll requires explicit machineType in persistence config"
-		});
-		let filtered = (yield* adapter.listActors()).filter((meta) => meta.machineType === machineType);
-		if (options?.filter !== void 0) filtered = filtered.filter(options.filter);
-		return yield* restoreMany(filtered.map((meta) => meta.id), persistentMachine);
-	});
 	return ActorSystem.of({
 		spawn,
-		restore,
 		get,
 		stop,
 		events: Stream.fromPubSub(eventPubSub),
@@ -474,10 +525,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 			return () => {
 				eventListeners.delete(fn);
 			};
-		},
-		listPersisted,
-		restoreMany,
-		restoreAll
+		}
 	});
 });
 /**
@@ -485,4 +533,4 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 */
 const Default = Layer.effect(ActorSystem, make());
 //#endregion
-export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };
+export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

package/dist/cluster/entity-machine.js

@@ -54,10 +54,12 @@ const EntityMachine = { layer: (entity, machine, options) => {
 		if (Option.isNone(existingSystem)) return yield* Effect.die("EntityMachine requires ActorSystem in context");
 		const system = existingSystem.value;
 		const internalQueue = yield* Queue.unbounded();
+		const clusterSend = Effect.fn("effect-machine.cluster.self.send")(function* (event) {
+			yield* Queue.offer(internalQueue, event);
+		});
 		const self = {
-			send: Effect.fn("effect-machine.cluster.self.send")(function* (event) {
-				yield* Queue.offer(internalQueue, event);
-			}),
+			send: clusterSend,
+			cast: clusterSend,
 			spawn: (childId, childMachine) => system.spawn(childId, childMachine).pipe(Effect.provideService(ActorSystem, system))
 		};
 		const stateRef = yield* Ref.make(initialState);

package/dist/errors.d.ts

@@ -42,5 +42,16 @@ declare const AssertionError_base: Schema.ErrorClass<AssertionError, Schema.Tagg
 }>, effect_Cause0.YieldableError>;
 /** Assertion failed in testing utilities */
 declare class AssertionError extends AssertionError_base {}
+declare const ActorStoppedError_base: Schema.ErrorClass<ActorStoppedError, Schema.TaggedStruct<"ActorStoppedError", {
+  readonly actorId: Schema.String;
+}>, effect_Cause0.YieldableError>;
+/** Actor was stopped while a call/ask was pending */
+declare class ActorStoppedError extends ActorStoppedError_base {}
+declare const NoReplyError_base: Schema.ErrorClass<NoReplyError, Schema.TaggedStruct<"NoReplyError", {
+  readonly actorId: Schema.String;
+  readonly eventTag: Schema.String;
+}>, effect_Cause0.YieldableError>;
+/** ask() was used but the transition handler did not call reply */
+declare class NoReplyError extends NoReplyError_base {}
 //#endregion
-export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };
+export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };

package/dist/errors.js

@@ -32,5 +32,12 @@ var ProvisionValidationError = class extends Schema.TaggedErrorClass()("Provisio
 }) {};
 /** Assertion failed in testing utilities */
 var AssertionError = class extends Schema.TaggedErrorClass()("AssertionError", { message: Schema.String }) {};
+/** Actor was stopped while a call/ask was pending */
+var ActorStoppedError = class extends Schema.TaggedErrorClass()("ActorStoppedError", { actorId: Schema.String }) {};
+/** ask() was used but the transition handler did not call reply */
+var NoReplyError = class extends Schema.TaggedErrorClass()("NoReplyError", {
+	actorId: Schema.String,
+	eventTag: Schema.String
+}) {};
 //#endregion
-export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };
+export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };

package/dist/index.d.ts

@@ -1,13 +1,9 @@
 import { EffectHandlers, EffectSlot, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlot, GuardSlots, GuardsDef, GuardsSchema, MachineContext, Slot } from "./slot.js";
 import { Event, MachineEventSchema, MachineStateSchema, State } from "./schema.js";
-import { PersistenceConfig, PersistentMachine, isPersistentMachine } from "./persistence/persistent-machine.js";
-import { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.js";
+import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.js";
 import { ProcessEventResult } from "./internal/transition.js";
-import { PersistentActorRef, createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
-import { ActorMetadata, PersistedEvent, PersistenceAdapter, PersistenceAdapterTag, PersistenceError, RestoreFailure, RestoreResult, Snapshot, VersionConflictError } from "./persistence/adapter.js";
-import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./persistence/adapters/in-memory.js";
-import { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, ProvideHandlers, SpawnEffect, StateHandlerContext, TaskOptions, Transition, machine_d_exports } from "./machine.js";
-import { ActorRef, ActorSystem, Default, SystemEvent, SystemEventListener } from "./actor.js";
+import { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, ProvideHandlers, SpawnEffect, StateHandlerContext, TaskOptions, Transition, machine_d_exports } from "./machine.js";
+import { ActorRef, ActorRefSync, ActorSystem, Default, SystemEvent, SystemEventListener, TransitionInfo } from "./actor.js";
 import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
 import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-export { type ActorMetadata, type ActorRef, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type BuiltMachine, DuplicateActorError, type EffectEvent, type EffectSlots, type EffectsDef, type EffectsSchema, type ErrorEvent, Event, type EventReceivedEvent, type GuardHandlers, type GuardSlot, type GuardSlots, type GuardsDef, type GuardsSchema, type HandlerContext, InMemoryPersistenceAdapter, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, type PersistOptions, type PersistedEvent, type PersistenceAdapter, PersistenceAdapterTag, type PersistenceConfig, PersistenceError, type PersistentActorRef, type PersistentMachine, type ProcessEventResult, type ProvideHandlers, ProvisionValidationError, type RestoreFailure, type RestoreResult, type SimulationResult, Slot, type EffectHandlers as SlotEffectHandlers, type EffectSlot as SlotEffectSlot, SlotProvisionError, type Snapshot, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TracingInspectorOptions, type Transition, type TransitionEvent, UnprovidedSlotsError, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, makeInspectorEffect, restorePersistentActor, simulate, tracingInspector };
+export { type ActorRef, type ActorRefSync, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type BuiltMachine, DuplicateActorError, type EffectEvent, type EffectSlots, type EffectsDef, type EffectsSchema, type ErrorEvent, Event, type EventReceivedEvent, type GuardHandlers, type GuardSlot, type GuardSlots, type GuardsDef, type GuardsSchema, type HandlerContext, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, NoReplyError, type ProcessEventResult, type ProvideHandlers, ProvisionValidationError, type SimulationResult, Slot, type EffectHandlers as SlotEffectHandlers, type EffectSlot as SlotEffectSlot, SlotProvisionError, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, UnprovidedSlotsError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/index.js

@@ -1,13 +1,8 @@
 import { Inspector, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-import { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.js";
-import { isPersistentMachine } from "./persistence/persistent-machine.js";
+import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.js";
 import { Slot } from "./slot.js";
 import { machine_exports } from "./machine.js";
-import { PersistenceAdapterTag, PersistenceError, VersionConflictError } from "./persistence/adapter.js";
-import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
 import { ActorSystem, Default } from "./actor.js";
 import { Event, State } from "./schema.js";
 import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./persistence/adapters/in-memory.js";
-import "./persistence/index.js";
-export { Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, InMemoryPersistenceAdapter, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, PersistenceAdapterTag, PersistenceError, ProvisionValidationError, Slot, SlotProvisionError, State, UnprovidedSlotsError, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, makeInspectorEffect, restorePersistentActor, simulate, tracingInspector };
+export { ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, Slot, SlotProvisionError, State, UnprovidedSlotsError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/internal/transition.d.ts

@@ -21,7 +21,7 @@ interface TransitionExecutionResult<S> {
  *
  * Used by:
  * - executeTransition (actor event loop, testing)
- * - persistent-actor replay (restore, replayTo)
+ * - Machine.replay (event sourcing restore)
  *
  * @internal
  */
@@ -29,7 +29,11 @@ declare const runTransitionHandler: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, transition: Transition<S, E, GD, EFD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<S, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, transition: Transition<S, E, GD, EFD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+  newState: S;
+  hasReply: boolean;
+  reply: unknown;
+}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Execute a transition for a given state and event.
  * Handles transition resolution, handler invocation, and guard/effect slot creation.
@@ -49,6 +53,8 @@ declare const executeTransition: <S extends {
   newState: S;
   transitioned: boolean;
   reenter: boolean;
+  hasReply: boolean;
+  reply: unknown;
 }, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Optional hooks for event processing inspection/tracing.
@@ -84,7 +90,22 @@ interface ProcessEventResult<S> {
   readonly lifecycleRan: boolean;
   /** Whether new state is final */
   readonly isFinal: boolean;
+  /** Whether the handler provided a reply (structural, not value-based) */
+  readonly hasReply: boolean;
+  /** Domain reply value from handler (used by ask). Only meaningful when hasReply is true. */
+  readonly reply?: unknown;
+  /** Whether the event was postponed (buffered for retry after next state change) */
+  readonly postponed: boolean;
 }
+/**
+ * Check if an event should be postponed in the current state.
+ * @internal
+ */
+declare const shouldPostpone: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R>(machine: Machine<S, E, R, any, any, any, any>, stateTag: string, eventTag: string) => boolean;
 /**
  * Process a single event through the machine.
  *
@@ -109,6 +130,9 @@ declare const processEventCore: <S extends {
   transitioned: boolean;
   lifecycleRan: boolean;
   isFinal: boolean;
+  hasReply: boolean;
+  reply: unknown;
+  postponed: boolean;
 }, never, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
 /**
  * Run spawn effects for a state (forked into state scope, auto-cancelled on state exit).
@@ -157,4 +181,4 @@ declare const findSpawnEffects: <S extends {
   readonly _tag: string;
 }, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, GD, EFD>, stateTag: string) => ReadonlyArray<SpawnEffect<S, E, EFD, R>>;
 //#endregion
-export { ProcessEventError, ProcessEventHooks, ProcessEventResult, TransitionExecutionResult, executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler };
+export { ProcessEventError, ProcessEventHooks, ProcessEventResult, TransitionExecutionResult, executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler, shouldPostpone };