effect-machine 0.8.0 → 0.10.0

package/{dist-v3 → v3/dist}/persistence/persistent-actor.js

@@ -1,12 +1,12 @@
 import { Inspector } from "../inspection.js";
 import { INTERNAL_INIT_EVENT, stubSystem } from "../internal/utils.js";
-import { processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler } from "../internal/transition.js";
+import { NoReplyError } from "../errors.js";
 import { emitWithTimestamp } from "../internal/inspection.js";
+import { processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler, shouldPostpone } from "../internal/transition.js";
 import { PersistenceAdapterTag } from "./adapter.js";
-import { ActorSystem, buildActorRefCore, notifyListeners } from "../actor.js";
-import { Cause, Clock, Effect, Exit, Fiber, Option, Queue, Ref, Schedule, Scope, SubscriptionRef } from "effect";
-
-//#region src-v3/persistence/persistent-actor.ts
+import { ActorSystem, buildActorRefCore, notifyListeners, settlePendingReplies } from "../actor.js";
+import { Cause, Clock, Deferred, Effect, Exit, Fiber, Option, Queue, Ref, Schedule, Scope, SubscriptionRef } from "effect";
+//#region src/persistence/persistent-actor.ts
 /** Get current time in milliseconds using Effect Clock */
 const now = Clock.currentTimeMillis;
 /**
@@ -20,7 +20,7 @@ const replayEvents = Effect.fn("effect-machine.persistentActor.replayEvents")(fu
 	for (const persistedEvent of events) {
 		if (stopVersion !== void 0 && persistedEvent.version > stopVersion) break;
 		const transition = resolveTransition(machine, state, persistedEvent.event);
-		if (transition !== void 0) state = yield* runTransitionHandler(machine, transition, state, persistedEvent.event, self, stubSystem);
+		if (transition !== void 0) state = (yield* runTransitionHandler(machine, transition, state, persistedEvent.event, self, stubSystem, "restore")).newState;
 		version = persistedEvent.version;
 	}
 	return {
@@ -31,7 +31,7 @@ const replayEvents = Effect.fn("effect-machine.persistentActor.replayEvents")(fu
 /**
 * Build PersistentActorRef with all methods
 */
-const buildPersistentActorRef = (id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, stop, adapter, system, childrenMap) => {
+const buildPersistentActorRef = (id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, stop, adapter, system, childrenMap, pendingReplies) => {
 	const { machine, persistence } = persistentMachine;
 	const typedMachine = machine;
 	const persist = Effect.gen(function* () {
@@ -45,8 +45,10 @@ const buildPersistentActorRef = (id, persistentMachine, stateRef, versionRef, ev
 	const version = Ref.get(versionRef).pipe(Effect.withSpan("effect-machine.persistentActor.version"));
 	const replayTo = Effect.fn("effect-machine.persistentActor.replayTo")(function* (targetVersion) {
 		if (targetVersion <= (yield* Ref.get(versionRef))) {
+			const dummySend = Effect.fn("effect-machine.persistentActor.replay.send")((_event) => Effect.void);
 			const dummySelf = {
-				send: Effect.fn("effect-machine.persistentActor.replay.send")((_event) => Effect.void),
+				send: dummySend,
+				cast: dummySend,
 				spawn: () => Effect.die("spawn not supported in replay")
 			};
 			const maybeSnapshot = yield* adapter.loadSnapshot(id, persistence.stateSchema);
@@ -71,7 +73,7 @@ const buildPersistentActorRef = (id, persistentMachine, stateRef, versionRef, ev
 		}
 	});
 	return {
-		...buildActorRefCore(id, typedMachine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap),
+		...buildActorRefCore(id, typedMachine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap, pendingReplies),
 		persist,
 		version,
 		replayTo
@@ -93,11 +95,16 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	const eventQueue = yield* Queue.unbounded();
 	const stoppedRef = yield* Ref.make(false);
 	const childrenMap = /* @__PURE__ */ new Map();
+	const selfSend = Effect.fn("effect-machine.persistentActor.self.send")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) return;
+		yield* Queue.offer(eventQueue, {
+			_tag: "send",
+			event
+		});
+	});
 	const self = {
-		send: Effect.fn("effect-machine.persistentActor.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);
@@ -146,6 +153,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	const backgroundFibers = [];
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
 	const initCtx = {
+		actorId: id,
 		state: resolvedInitial,
 		event: initEvent,
 		self,
@@ -154,6 +162,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	const { effects: effectSlots } = typedMachine._slots;
 	for (const bg of typedMachine.backgroundEffects) {
 		const fiber = yield* Effect.forkDaemon(bg.handler({
+			actorId: id,
 			state: resolvedInitial,
 			event: initEvent,
 			self,
@@ -176,9 +185,10 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 			finalState: resolvedInitial,
 			timestamp
 		}));
-		return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system, childrenMap);
+		return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system, childrenMap, /* @__PURE__ */ new Set());
 	}
-	const loopFiber = yield* Effect.forkDaemon(persistentEventLoop(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, self, listeners, adapter, createdAt, stateScopeRef, backgroundFibers, snapshotQueue, snapshotEnabledRef, persistenceQueue, snapshotFiber, persistenceFiber, inspector, system));
+	const pendingReplies = /* @__PURE__ */ new Set();
+	const loopFiber = yield* Effect.forkDaemon(persistentEventLoop(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, self, listeners, adapter, createdAt, stateScopeRef, backgroundFibers, snapshotQueue, snapshotEnabledRef, persistenceQueue, snapshotFiber, persistenceFiber, inspector, system, pendingReplies));
 	return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
 		const finalState = yield* SubscriptionRef.get(stateRef);
 		yield* emitWithTimestamp(inspector, (timestamp) => ({
@@ -189,16 +199,17 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 		}));
 		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" });
 		yield* Fiber.interrupt(snapshotFiber);
 		yield* Fiber.interrupt(persistenceFiber);
-	}).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system, childrenMap);
+	}).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system, childrenMap, pendingReplies);
 });
 /**
 * Main event loop for persistent actor
 */
-const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop")(function* (id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, self, listeners, adapter, createdAt, stateScopeRef, backgroundFibers, snapshotQueue, snapshotEnabledRef, persistenceQueue, snapshotFiber, persistenceFiber, inspector, system) {
+const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop")(function* (id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, self, listeners, adapter, createdAt, stateScopeRef, backgroundFibers, snapshotQueue, snapshotEnabledRef, persistenceQueue, snapshotFiber, persistenceFiber, inspector, system, pendingReplies) {
 	const { machine, persistence } = persistentMachine;
 	const typedMachine = machine;
 	const hooks = inspector === void 0 ? void 0 : {
@@ -227,10 +238,28 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 			timestamp
 		}))
 	};
+	const postponed = [];
+	const pendingDrain = [];
+	const hasPostponeRules = machine.postponeRules.length > 0;
 	while (true) {
-		const event = yield* Queue.take(eventQueue);
+		const queued = pendingDrain.length > 0 ? pendingDrain.shift() : yield* Queue.take(eventQueue);
+		const event = queued.event;
 		const currentState = yield* SubscriptionRef.get(stateRef);
 		const currentVersion = yield* Ref.get(versionRef);
+		if (hasPostponeRules && shouldPostpone(typedMachine, currentState._tag, event._tag)) {
+			postponed.push(queued);
+			if (queued._tag === "call") yield* Deferred.succeed(queued.reply, {
+				newState: currentState,
+				previousState: currentState,
+				transitioned: false,
+				lifecycleRan: false,
+				isFinal: false,
+				hasReply: false,
+				reply: void 0,
+				postponed: true
+			});
+			continue;
+		}
 		yield* emitWithTimestamp(inspector, (timestamp) => ({
 			type: "@machine.event",
 			actorId: id,
@@ -238,7 +267,13 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 			event,
 			timestamp
 		}));
-		const result = yield* processEventCore(typedMachine, currentState, event, self, stateScopeRef, system, hooks);
+		const result = yield* processEventCore(typedMachine, currentState, event, self, stateScopeRef, system, id, hooks);
+		if (queued._tag === "call") yield* Deferred.succeed(queued.reply, result);
+		else if (queued._tag === "ask") if (result.hasReply) yield* Deferred.succeed(queued.reply, result.reply);
+		else yield* Deferred.fail(queued.reply, new NoReplyError({
+			actorId: id,
+			eventTag: event._tag
+		}));
 		if (!result.transitioned) continue;
 		const newVersion = currentVersion + 1;
 		yield* Ref.set(versionRef, newVersion);
@@ -266,12 +301,15 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 				timestamp
 			}));
 			yield* Ref.set(stoppedRef, true);
+			postponed.length = 0;
+			yield* settlePendingReplies(pendingReplies, id);
 			yield* Scope.close(stateScopeRef.current, Exit.void);
 			yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 			yield* Fiber.interrupt(snapshotFiber);
 			yield* Fiber.interrupt(persistenceFiber);
 			return;
 		}
+		if (result.lifecycleRan && postponed.length > 0) pendingDrain.push(...postponed.splice(0));
 	}
 });
 /**
@@ -286,7 +324,7 @@ const runSpawnEffectsWithInspection = Effect.fn("effect-machine.persistentActor.
 		state,
 		timestamp
 	}));
-	yield* runSpawnEffects(machine, state, event, self, stateScope, system, inspector === void 0 ? void 0 : (info) => emitWithTimestamp(inspector, (timestamp) => ({
+	yield* runSpawnEffects(machine, state, event, self, stateScope, system, actorId, inspector === void 0 ? void 0 : (info) => emitWithTimestamp(inspector, (timestamp) => ({
 		type: "@machine.error",
 		actorId,
 		phase: info.phase,
@@ -362,6 +400,5 @@ const restorePersistentActor = Effect.fn("effect-machine.persistentActor.restore
 	const actor = yield* createPersistentActor(id, persistentMachine, maybeSnapshot, events);
 	return Option.some(actor);
 });
-
 //#endregion
-export { createPersistentActor, restorePersistentActor };
+export { createPersistentActor, restorePersistentActor };

package/{dist-v3 → v3/dist}/persistence/persistent-machine.d.ts

@@ -2,7 +2,7 @@ import { EventBrand, StateBrand } from "../internal/brands.js";
 import { Machine } from "../machine.js";
 import { Schedule, Schema } from "effect";
 
-//#region src-v3/persistence/persistent-machine.d.ts
+//#region src/persistence/persistent-machine.d.ts
 type BrandedState = {
   readonly _tag: string;
 } & StateBrand;

package/{dist-v3 → v3/dist}/persistence/persistent-machine.js

@@ -1,6 +1,5 @@
 import { MissingSchemaError } from "../errors.js";
-
-//#region src-v3/persistence/persistent-machine.ts
+//#region src/persistence/persistent-machine.ts
 /**
 * Type guard to check if a value is a PersistentMachine
 */
@@ -19,6 +18,5 @@ const persist = (config) => (machine) => {
 		}
 	};
 };
-
 //#endregion
-export { isPersistentMachine, persist };
+export { isPersistentMachine, persist };

package/{dist-v3 → v3/dist}/schema.d.ts

@@ -1,7 +1,7 @@
 import { FullEventBrand, FullStateBrand } from "./internal/brands.js";
 import { Schema } from "effect";
 
-//#region src-v3/schema.d.ts
+//#region src/schema.d.ts
 /**
  * Extract the TypeScript type from a TaggedStruct schema
  */

package/{dist-v3 → v3/dist}/schema.js

@@ -1,7 +1,6 @@
 import { InvalidSchemaError, MissingMatchHandlerError } from "./errors.js";
 import { Schema } from "effect";
-
-//#region src-v3/schema.ts
+//#region src/schema.ts
 /**
 * Schema-first State/Event definitions for effect-machine.
 *
@@ -59,7 +58,10 @@ const buildMachineSchema = (definition) => {
 			constructor.derive = (source, partial) => {
 				const result = { _tag: tag };
 				for (const key of fieldNames) if (key in source) result[key] = source[key];
-				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) result[key] = value;
+				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) {
+					if (key === "_tag") continue;
+					result[key] = value;
+				}
 				return result;
 			};
 			constructors[tag] = constructor;
@@ -160,6 +162,5 @@ const State = (definition) => createMachineSchema(definition);
 * ```
 */
 const Event = (definition) => createMachineSchema(definition);
-
 //#endregion
-export { Event, State };
+export { Event, State };

package/{dist-v3 → v3/dist}/slot.d.ts

@@ -1,7 +1,7 @@
 import { ActorSystem } from "./actor.js";
-import { Effect, Schema } from "effect";
+import { Context, Effect, Schema } from "effect";
 
-//#region src-v3/slot.d.ts
+//#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
 type Fields = Record<string, Schema.Schema.All>;
 /** Extract the encoded type from schema fields (used for parameters) */
@@ -43,6 +43,7 @@ type EffectSlots<D extends EffectsDef> = { readonly [K in keyof D & string]: Eff
  * Shared across all machines via MachineContextTag.
  */
 interface MachineContext<State, Event, Self> {
+  readonly actorId: string;
   readonly state: State;
   readonly event: Event;
   readonly self: Self;
@@ -53,7 +54,7 @@ interface MachineContext<State, Event, Self> {
  * Single module-level tag instead of per-machine allocation.
  * @internal
  */
-declare const MachineContextTag: any;
+declare const MachineContextTag: Context.Tag<MachineContext<any, any, any>, MachineContext<any, any, any>>;
 /**
  * Guard handler implementation.
  * Receives params and context, returns Effect<boolean>.

package/{dist-v3 → v3/dist}/slot.js

@@ -1,6 +1,5 @@
 import { Context } from "effect";
-
-//#region src-v3/slot.ts
+//#region src/slot.ts
 /**
 * Slot module - schema-based, parameterized guards and effects.
 *
@@ -94,6 +93,5 @@ const Slot = {
 	Guards,
 	Effects
 };
-
 //#endregion
-export { Effects, Guards, MachineContextTag, Slot };
+export { Effects, Guards, MachineContextTag, Slot };

package/{dist-v3 → v3/dist}/testing.d.ts

@@ -1,9 +1,9 @@
+import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
 import { AssertionError } from "./errors.js";
-import { EffectsDef, GuardsDef } from "./slot.js";
-import { BuiltMachine, Machine } from "./machine.js";
+import { BuiltMachine, Machine, MachineRef } from "./machine.js";
 import { Effect, SubscriptionRef } from "effect";
 
-//#region src-v3/testing.d.ts
+//#region src/testing.d.ts
 /** Accept either Machine or BuiltMachine for testing utilities. */
 type MachineInput<S, E, R, GD extends GuardsDef, EFD extends EffectsDef> = Machine<S, E, R, any, any, GD, EFD> | BuiltMachine<S, E, R>;
 /**
@@ -40,7 +40,7 @@ declare const simulate: <S extends {
 }, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[]) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, never, Exclude<R, unknown>>;
+}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Assert that a machine can reach a specific state given a sequence of events
  */
@@ -48,7 +48,7 @@ declare const assertReaches: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedTag: string) => Effect.Effect<any, unknown, unknown>;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedTag: string) => Effect.Effect<S, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Assert that a machine follows a specific path of state tags
  *
@@ -65,7 +65,10 @@ declare const assertPath: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedPath: readonly string[]) => Effect.Effect<any, unknown, unknown>;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedPath: readonly string[]) => Effect.Effect<{
+  states: S[];
+  finalState: S;
+}, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Assert that a machine never reaches a specific state given a sequence of events
  *
@@ -83,7 +86,10 @@ declare const assertNeverReaches: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], forbiddenTag: string) => Effect.Effect<any, unknown, unknown>;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], forbiddenTag: string) => Effect.Effect<{
+  states: S[];
+  finalState: S;
+}, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Create a controllable test harness for a machine
  */
@@ -129,7 +135,7 @@ declare const createTestHarness: <S extends {
   readonly _tag: string;
 }, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, options?: TestHarnessOptions<S, E> | undefined) => Effect.Effect<{
   state: SubscriptionRef.SubscriptionRef<S>;
-  send: (event: E) => Effect.Effect<S, never, never>;
+  send: (event: E) => Effect.Effect<S, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
   getState: Effect.Effect<S, never, never>;
 }, never, never>;
 //#endregion

package/{dist-v3 → v3/dist}/testing.js

@@ -1,10 +1,9 @@
 import { stubSystem } from "./internal/utils.js";
 import { AssertionError } from "./errors.js";
 import { BuiltMachine } from "./machine.js";
-import { executeTransition } from "./internal/transition.js";
+import { executeTransition, shouldPostpone } from "./internal/transition.js";
 import { Effect, SubscriptionRef } from "effect";
-
-//#region src-v3/testing.ts
+//#region src/testing.ts
 /**
 * Simulate a sequence of events through a machine without running an actor.
 * Useful for testing state transitions in isolation.
@@ -27,18 +26,44 @@ import { Effect, SubscriptionRef } from "effect";
 */
 const simulate = Effect.fn("effect-machine.simulate")(function* (input, events) {
 	const machine = input instanceof BuiltMachine ? input._inner : input;
+	const dummySend = Effect.fn("effect-machine.testing.simulate.send")((_event) => Effect.void);
 	const dummySelf = {
-		send: Effect.fn("effect-machine.testing.simulate.send")((_event) => Effect.void),
+		send: dummySend,
+		cast: dummySend,
 		spawn: () => Effect.die("spawn not supported in simulation")
 	};
 	let currentState = machine.initial;
 	const states = [currentState];
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const postponed = [];
 	for (const event of events) {
-		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+		if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
+			postponed.push(event);
+			continue;
+		}
+		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "simulation");
 		if (!result.transitioned) continue;
+		const prevTag = currentState._tag;
 		currentState = result.newState;
 		states.push(currentState);
 		if (machine.finalStates.has(currentState._tag)) break;
+		let drainTag = prevTag;
+		while (currentState._tag !== drainTag && postponed.length > 0) {
+			drainTag = currentState._tag;
+			const drained = postponed.splice(0);
+			for (const postponedEvent of drained) {
+				if (shouldPostpone(machine, currentState._tag, postponedEvent._tag)) {
+					postponed.push(postponedEvent);
+					continue;
+				}
+				const drainResult = yield* executeTransition(machine, currentState, postponedEvent, dummySelf, stubSystem, "simulation");
+				if (drainResult.transitioned) {
+					currentState = drainResult.newState;
+					states.push(currentState);
+					if (machine.finalStates.has(currentState._tag)) break;
+				}
+			}
+		}
 	}
 	return {
 		states,
@@ -114,25 +139,52 @@ const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(functi
 */
 const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function* (input, options) {
 	const machine = input instanceof BuiltMachine ? input._inner : input;
+	const dummySend = Effect.fn("effect-machine.testing.harness.send")((_event) => Effect.void);
 	const dummySelf = {
-		send: Effect.fn("effect-machine.testing.harness.send")((_event) => Effect.void),
+		send: dummySend,
+		cast: dummySend,
 		spawn: () => Effect.die("spawn not supported in test harness")
 	};
 	const stateRef = yield* SubscriptionRef.make(machine.initial);
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const postponed = [];
 	return {
 		state: stateRef,
 		send: Effect.fn("effect-machine.testHarness.send")(function* (event) {
 			const currentState = yield* SubscriptionRef.get(stateRef);
-			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+			if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
+				postponed.push(event);
+				return currentState;
+			}
+			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "test-harness");
 			if (!result.transitioned) return currentState;
+			const prevTag = currentState._tag;
 			const newState = result.newState;
 			yield* SubscriptionRef.set(stateRef, newState);
 			if (options?.onTransition !== void 0) options.onTransition(currentState, event, newState);
+			let drainTag = prevTag;
+			let currentTag = newState._tag;
+			while (currentTag !== drainTag && postponed.length > 0) {
+				drainTag = currentTag;
+				const drained = postponed.splice(0);
+				for (const postponedEvent of drained) {
+					const state = yield* SubscriptionRef.get(stateRef);
+					if (shouldPostpone(machine, state._tag, postponedEvent._tag)) {
+						postponed.push(postponedEvent);
+						continue;
+					}
+					const drainResult = yield* executeTransition(machine, state, postponedEvent, dummySelf, stubSystem, "test-harness");
+					if (drainResult.transitioned) {
+						yield* SubscriptionRef.set(stateRef, drainResult.newState);
+						currentTag = drainResult.newState._tag;
+						if (options?.onTransition !== void 0) options.onTransition(state, postponedEvent, drainResult.newState);
+					}
+				}
+			}
 			return newState;
 		}),
 		getState: SubscriptionRef.get(stateRef)
 	};
 });
-
 //#endregion
-export { AssertionError, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate };
+export { AssertionError, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate };

package/dist-v3/_virtual/_rolldown/runtime.js

@@ -1,18 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-export { __exportAll };

package/dist-v3/errors.d.ts

@@ -1,27 +0,0 @@
-//#region src-v3/errors.d.ts
-declare const DuplicateActorError_base: any;
-/** Attempted to spawn/restore actor with ID already in use */
-declare class DuplicateActorError extends DuplicateActorError_base {}
-declare const UnprovidedSlotsError_base: any;
-/** Machine has unprovided effect slots */
-declare class UnprovidedSlotsError extends UnprovidedSlotsError_base {}
-declare const MissingSchemaError_base: any;
-/** Operation requires schemas attached to machine */
-declare class MissingSchemaError extends MissingSchemaError_base {}
-declare const InvalidSchemaError_base: any;
-/** State/Event schema has no variants */
-declare class InvalidSchemaError extends InvalidSchemaError_base {}
-declare const MissingMatchHandlerError_base: any;
-/** $match called with missing handler for tag */
-declare class MissingMatchHandlerError extends MissingMatchHandlerError_base {}
-declare const SlotProvisionError_base: any;
-/** Slot handler not found at runtime (internal error) */
-declare class SlotProvisionError extends SlotProvisionError_base {}
-declare const ProvisionValidationError_base: any;
-/** Machine.build() validation failed - missing or extra handlers */
-declare class ProvisionValidationError extends ProvisionValidationError_base {}
-declare const AssertionError_base: any;
-/** Assertion failed in testing utilities */
-declare class AssertionError extends AssertionError_base {}
-//#endregion
-export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };

package/dist-v3/index.d.ts

@@ -1,13 +0,0 @@
-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 { EffectHandlers, EffectSlot, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlot, GuardSlots, GuardsDef, GuardsSchema, MachineContext, Slot } from "./slot.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 "./persistence/index.js";
-import { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, ProvideHandlers, SpawnEffect, StateHandlerContext, Transition, machine_d_exports } from "./machine.js";
-import { ActorRef, ActorSystem, Default, SystemEvent, SystemEventListener } from "./actor.js";
-import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, SpawnEvent, StopEvent, TransitionEvent, collectingInspector, consoleInspector, makeInspector } 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, 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 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 TestHarness, type TestHarnessOptions, type Transition, type TransitionEvent, UnprovidedSlotsError, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, restorePersistentActor, simulate };

package/dist-v3/index.js

@@ -1,14 +0,0 @@
-import { Inspector, collectingInspector, consoleInspector, makeInspector } from "./inspection.js";
-import { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.js";
-import { isPersistentMachine } from "./persistence/persistent-machine.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, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, restorePersistentActor, simulate };

package/dist-v3/inspection.js

@@ -1,50 +0,0 @@
-import { Context } from "effect";
-
-//#region src-v3/inspection.ts
-/**
-* Inspector service tag - optional service for machine introspection
-* Uses `any` types to allow variance flexibility when providing the service
-*/
-const Inspector = Context.GenericTag("@effect/machine/Inspector");
-/**
-* Create an inspector from a callback function.
-*
-* Type params accept either raw tagged types or Schema constructors:
-* - `makeInspector(cb)` — defaults to `AnyInspectionEvent`
-* - `makeInspector<MyState, MyEvent>(cb)` — explicit tagged types
-* - `makeInspector<typeof MyState, typeof MyEvent>(cb)` — schema constructors (auto-extracts `.Type`)
-*/
-const makeInspector = (onInspect) => ({ onInspect });
-/**
-* Console inspector that logs events in a readable format
-*/
-const consoleInspector = () => makeInspector((event) => {
-	const prefix = `[${event.actorId}]`;
-	switch (event.type) {
-		case "@machine.spawn":
-			console.log(prefix, "spawned →", event.initialState._tag);
-			break;
-		case "@machine.event":
-			console.log(prefix, "received", event.event._tag, "in", event.state._tag);
-			break;
-		case "@machine.transition":
-			console.log(prefix, event.fromState._tag, "→", event.toState._tag);
-			break;
-		case "@machine.effect":
-			console.log(prefix, event.effectType, "effect in", event.state._tag);
-			break;
-		case "@machine.error":
-			console.log(prefix, "error in", event.phase, event.state._tag, "-", event.error);
-			break;
-		case "@machine.stop":
-			console.log(prefix, "stopped in", event.finalState._tag);
-			break;
-	}
-});
-/**
-* Collecting inspector that stores events in an array for testing
-*/
-const collectingInspector = (events) => ({ onInspect: (event) => events.push(event) });
-
-//#endregion
-export { Inspector, collectingInspector, consoleInspector, makeInspector };

package/dist-v3/internal/inspection.js

@@ -1,15 +0,0 @@
-import { Clock, Effect } from "effect";
-
-//#region src-v3/internal/inspection.ts
-/**
-* Emit an inspection event with timestamp from Clock.
-* @internal
-*/
-const emitWithTimestamp = Effect.fn("effect-machine.emitWithTimestamp")(function* (inspector, makeEvent) {
-	if (inspector === void 0) return;
-	const timestamp = yield* Clock.currentTimeMillis;
-	yield* Effect.try(() => inspector.onInspect(makeEvent(timestamp))).pipe(Effect.ignore);
-});
-
-//#endregion
-export { emitWithTimestamp };