effect-machine 0.8.0 → 0.10.0

package/dist/persistence/adapters/in-memory.js

@@ -1,6 +1,5 @@
 import { PersistenceAdapterTag, PersistenceError, VersionConflictError } from "../adapter.js";
 import { Effect, Layer, Option, Ref, Schema } from "effect";
-
 //#region src/persistence/adapters/in-memory.ts
 /**
 * Create an in-memory persistence adapter.
@@ -171,6 +170,5 @@ const makeInMemoryPersistenceAdapter = make;
 * ```
 */
 const InMemoryPersistenceAdapter = Layer.effect(PersistenceAdapterTag, make);
-
 //#endregion
-export { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter };
+export { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter };

package/dist/persistence/index.js

@@ -2,5 +2,4 @@ import { isPersistentMachine, persist } from "./persistent-machine.js";
 import { PersistenceAdapterTag, PersistenceError, VersionConflictError } from "./adapter.js";
 import { createPersistentActor, restorePersistentActor } from "./persistent-actor.js";
 import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./adapters/in-memory.js";
-
-export { InMemoryPersistenceAdapter, PersistenceAdapterTag, PersistenceError, VersionConflictError, createPersistentActor, isPersistentMachine, makeInMemoryPersistenceAdapter, persist, restorePersistentActor };
+export { InMemoryPersistenceAdapter, PersistenceAdapterTag, PersistenceError, VersionConflictError, createPersistentActor, isPersistentMachine, makeInMemoryPersistenceAdapter, persist, restorePersistentActor };

package/dist/persistence/persistent-actor.js

@@ -1,11 +1,11 @@
 import { Inspector } from "../inspection.js";
 import { INTERNAL_INIT_EVENT, stubSystem } from "../internal/utils.js";
+import { NoReplyError } from "../errors.js";
 import { emitWithTimestamp } from "../internal/inspection.js";
-import { processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler } from "../internal/transition.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";
-
+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, "restore");
+		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);
@@ -178,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.forkDetach(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.forkDetach(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) => ({
@@ -191,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 : {
@@ -229,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,
@@ -241,6 +268,12 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 			timestamp
 		}));
 		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);
@@ -268,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));
 	}
 });
 /**
@@ -364,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/persistence/persistent-machine.js

@@ -1,5 +1,4 @@
 import { MissingSchemaError } from "../errors.js";
-
 //#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/schema.js

@@ -1,6 +1,5 @@
 import { InvalidSchemaError, MissingMatchHandlerError } from "./errors.js";
 import { Schema } from "effect";
-
 //#region src/schema.ts
 /**
 * Schema-first State/Event definitions for effect-machine.
@@ -164,6 +163,5 @@ const State = (definition) => createMachineSchema(definition);
 * ```
 */
 const Event = (definition) => createMachineSchema(definition);
-
 //#endregion
-export { Event, State };
+export { Event, State };

package/dist/slot.js

@@ -1,5 +1,4 @@
 import { ServiceMap } from "effect";
-
 //#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/testing.js

@@ -1,9 +1,8 @@
 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/testing.ts
 /**
 * Simulate a sequence of events through a machine without running an actor.
@@ -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) {
+		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);
+			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/package.json

@@ -1,13 +1,13 @@
 {
   "name": "effect-machine",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
   },
   "files": [
     "dist",
-    "dist-v3"
+    "v3/dist"
   ],
   "type": "module",
   "exports": {
@@ -25,14 +25,14 @@
     },
     "./v3": {
       "import": {
-        "types": "./dist-v3/index.d.ts",
-        "default": "./dist-v3/index.js"
+        "types": "./v3/dist/index.d.ts",
+        "default": "./v3/dist/index.js"
       }
     },
     "./v3/cluster": {
       "import": {
-        "types": "./dist-v3/cluster/index.d.ts",
-        "default": "./dist-v3/cluster/index.js"
+        "types": "./v3/dist/cluster/index.d.ts",
+        "default": "./v3/dist/cluster/index.js"
       }
     }
   },
@@ -41,34 +41,35 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "typecheck:v3": "tsc --noEmit -p tsconfig.v3.json",
+    "typecheck:v3": "tsc --noEmit -p v3/tsconfig.json",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "test": "bun test",
+    "test:v3": "bun test --tsconfig-override=v3/tsconfig.json v3/test/",
     "test:watch": "bun test --watch",
     "gate": "concurrently -n type,lint,fmt,test,build -c blue,yellow,magenta,green,cyan \"bun run typecheck\" \"bun run lint:fix\" \"bun run fmt\" \"bun run test\" \"bun run build\"",
     "prepare": "lefthook install || true && effect-language-service patch",
     "version": "changeset version",
-    "build": "tsdown && tsdown --config tsdown.v3.config.ts",
+    "build": "tsdown && tsdown --config v3/tsdown.config.ts",
     "release": "bun run build && changeset publish"
   },
   "dependencies": {
     "effect": "4.0.0-beta.35"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.5.2",
-    "@changesets/cli": "^2.29.8",
-    "@effect/language-service": "^0.75.1",
-    "@types/bun": "1.3.9",
+    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/cli": "^2.30.0",
+    "@effect/language-service": "^0.82.0",
+    "@types/bun": "1.3.11",
     "concurrently": "^9.2.1",
-    "effect-bun-test": "0.2.0",
-    "effect-v3": "npm:effect@^3.19.18",
-    "lefthook": "^2.1.1",
-    "oxfmt": "^0.33.0",
-    "oxlint": "^1.48.0",
-    "tsdown": "^0.20.3",
+    "effect-bun-test": "0.2.1",
+    "effect-v3": "npm:effect@^3.21.0",
+    "lefthook": "^2.1.4",
+    "oxfmt": "^0.41.0",
+    "oxlint": "^1.56.0",
+    "tsdown": "^0.21.4",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

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

@@ -0,0 +1,13 @@
+//#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 → v3/dist}/actor.d.ts

@@ -1,87 +1,85 @@
+import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
 import { PersistentMachine } from "./persistence/persistent-machine.js";
-import { DuplicateActorError } from "./errors.js";
-import { EffectsDef, GuardsDef } from "./slot.js";
+import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
 import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
 import { PersistentActorRef } from "./persistence/persistent-actor.js";
 import { ActorMetadata, PersistenceAdapterTag, PersistenceError, RestoreResult, VersionConflictError } from "./persistence/adapter.js";
-import { BuiltMachine, Machine } from "./machine.js";
-import { Effect, Option, Queue, Ref, Stream, SubscriptionRef } from "effect";
+import { BuiltMachine, Machine, MachineRef } from "./machine.js";
+import { Context, Deferred, Effect, Layer, Option, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
+import * as effect_dist_dts_Tracer_js0 from "effect/dist/dts/Tracer.js";
 
-//#region src-v3/actor.d.ts
+//#region src/actor.d.ts
+/** Discriminated mailbox request */
+type QueuedEvent<E> = {
+  readonly _tag: "send";
+  readonly event: E;
+} | {
+  readonly _tag: "call";
+  readonly event: E;
+  readonly reply: Deferred.Deferred<ProcessEventResult<{
+    readonly _tag: string;
+  }>, ActorStoppedError>;
+} | {
+  readonly _tag: "ask";
+  readonly event: E;
+  readonly reply: Deferred.Deferred<unknown, NoReplyError | ActorStoppedError>;
+};
 /**
  * Reference to a running actor.
  */
+/**
+ * Sync projection of ActorRef for non-Effect boundaries (React hooks, framework callbacks).
+ */
+interface ActorRefSync<State extends {
+  readonly _tag: string;
+}, Event> {
+  readonly send: (event: Event) => void;
+  readonly stop: () => void;
+  readonly snapshot: () => State;
+  readonly matches: (tag: State["_tag"]) => boolean;
+  readonly can: (event: Event) => boolean;
+}
 interface ActorRef<State extends {
   readonly _tag: string;
 }, Event> {
-  /**
-   * Unique identifier for this actor
-   */
   readonly id: string;
-  /**
-   * Send an event to the actor
-   */
+  /** Send an event (fire-and-forget). */
   readonly send: (event: Event) => Effect.Effect<void>;
+  /** Fire-and-forget alias for send (OTP gen_server:cast). */
+  readonly cast: (event: Event) => Effect.Effect<void>;
   /**
-   * Observable state of the actor
+   * Serialized request-reply (OTP gen_server:call).
+   * Event is processed through the queue; caller gets ProcessEventResult back.
    */
-  readonly state: SubscriptionRef.SubscriptionRef<State>;
+  readonly call: (event: Event) => Effect.Effect<ProcessEventResult<State>>;
   /**
-   * Stop the actor gracefully
+   * Typed request-reply. Event is processed through the queue; caller gets
+   * the domain value returned by the handler's `reply` field.
+   * Fails with NoReplyError if the handler doesn't provide a reply.
    */
+  readonly ask: <R>(event: Event) => Effect.Effect<R, NoReplyError | ActorStoppedError>;
+  /** Observable state. */
+  readonly state: SubscriptionRef.SubscriptionRef<State>;
+  /** Stop the actor gracefully. */
   readonly stop: Effect.Effect<void>;
-  /**
-   * Stop the actor (fire-and-forget).
-   * Signals graceful shutdown without waiting for completion.
-   * Use when stopping from sync contexts (e.g. framework cleanup hooks).
-   */
-  readonly stopSync: () => void;
-  /**
-   * Get current state snapshot (Effect)
-   */
+  /** Get current state snapshot. */
   readonly snapshot: Effect.Effect<State>;
-  /**
-   * Get current state snapshot (sync)
-   */
-  readonly snapshotSync: () => State;
-  /**
-   * Check if current state matches tag (Effect)
-   */
+  /** Check if current state matches tag. */
   readonly matches: (tag: State["_tag"]) => Effect.Effect<boolean>;
-  /**
-   * Check if current state matches tag (sync)
-   */
-  readonly matchesSync: (tag: State["_tag"]) => boolean;
-  /**
-   * Check if event can be handled in current state (Effect)
-   */
+  /** Check if event can be handled in current state. */
   readonly can: (event: Event) => Effect.Effect<boolean>;
-  /**
-   * Check if event can be handled in current state (sync)
-   */
-  readonly canSync: (event: Event) => boolean;
-  /**
-   * Stream of state changes
-   */
+  /** Stream of state changes. */
   readonly changes: Stream.Stream<State>;
-  /**
-   * Wait for a state that matches predicate or state variant (includes current snapshot).
-   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
-   */
+  /** Wait for a state matching predicate or variant (includes current snapshot). */
   readonly waitFor: {
     (predicate: (state: State) => boolean): Effect.Effect<State>;
     (state: {
       readonly _tag: State["_tag"];
     }): Effect.Effect<State>;
   };
-  /**
-   * Wait for a final state (includes current snapshot)
-   */
+  /** Wait for a final state (includes current snapshot). */
   readonly awaitFinal: Effect.Effect<State>;
-  /**
-   * Send event and wait for predicate, state variant, or final state.
-   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
-   */
+  /** Send event and wait for predicate, state variant, or final state. */
   readonly sendAndWait: {
     (event: Event, predicate: (state: State) => boolean): Effect.Effect<State>;
     (event: Event, state: {
@@ -89,26 +87,13 @@ interface ActorRef<State extends {
     }): Effect.Effect<State>;
     (event: Event): Effect.Effect<State>;
   };
-  /**
-   * Send event synchronously (fire-and-forget).
-   * No-op on stopped actors. Use when you need to send from sync contexts
-   * (e.g. framework hooks, event handlers).
-   */
-  readonly sendSync: (event: Event) => void;
-  /**
-   * Subscribe to state changes (sync callback)
-   * Returns unsubscribe function
-   */
+  /** Subscribe to state changes (sync callback). Returns unsubscribe function. */
   readonly subscribe: (fn: (state: State) => void) => () => void;
-  /**
-   * The actor system this actor belongs to.
-   * Every actor always has a system — either inherited from context or implicitly created.
-   */
+  /** Sync helpers for non-Effect boundaries. */
+  readonly sync: ActorRefSync<State, Event>;
+  /** The actor system this actor belongs to. */
   readonly system: ActorSystem;
-  /**
-   * Child actors spawned via `self.spawn` in this actor's handlers.
-   * State-scoped children are auto-removed on state exit.
-   */
+  /** Child actors spawned via `self.spawn` in this actor's handlers. */
   readonly children: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
 }
 /** Base type for stored actors (internal) */
@@ -260,7 +245,7 @@ interface ActorSystem {
 /**
  * ActorSystem service tag
  */
-declare const ActorSystem: any;
+declare const ActorSystem: Context.Tag<ActorSystem, ActorSystem>;
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**
@@ -274,7 +259,7 @@ declare const buildActorRefCore: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, any, any, GD, EFD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueue: Queue.Queue<E>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>) => ActorRef<S, E>;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, any, any, GD, EFD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueue: Queue.Queue<QueuedEvent<E>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>) => ActorRef<S, E>;
 /**
  * Create and start an actor for a machine
  */
@@ -282,10 +267,12 @@ declare const createActor: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>) => Effect.Effect<ActorRef<S, E>, unknown, unknown>;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>) => Effect.Effect<ActorRef<S, E>, never, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, effect_dist_dts_Tracer_js0.ParentSpan> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope> | Exclude<Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>, effect_dist_dts_Tracer_js0.ParentSpan>>;
+/** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */
+declare const settlePendingReplies: (pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, actorId: string) => Effect.Effect<void, never, never>;
 /**
  * Default ActorSystem layer
  */
-declare const Default: any;
+declare const Default: Layer.Layer<ActorSystem, never, never>;
 //#endregion
-export { ActorRef, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, SystemEvent, SystemEventListener, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };
+export { ActorRef, ActorRefSync, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };