effect-machine 0.17.1 → 0.18.0

package/dist/internal/runtime.js

@@ -1,6 +1,7 @@
-import { INTERNAL_INIT_EVENT } from "./utils.js";
-import { NoReplyError } from "../errors.js";
-import { processEventCore, runSpawnEffects, shouldPostpone } from "./transition.js";
+import { INTERNAL_INIT_EVENT, isEffect } from "./utils.js";
+import { ActorStoppedError, NoReplyError } from "../errors.js";
+import { makeEventAdvancement } from "./event-advancement.js";
+import { processEventCoreImmediate, runSpawnEffects, shouldPostpone } from "./transition.js";
 import { ActorExit } from "../supervision.js";
 import { ActorSystem } from "../actor.js";
 import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Schema, Scope, SubscriptionRef } from "effect";
@@ -42,9 +43,8 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 	const { actorId, hooks, lifecycle } = config;
 	const services = yield* Effect.context();
 	const fork = Effect.runForkWith(services);
-	const stateRef = config.cellResources?.stateRef ?? (yield* SubscriptionRef.make(machine.initial));
-	const stoppedRef = config.cellResources?.stoppedRef ?? (yield* Ref.make(false));
-	const eventQueue = config.cellResources?.eventQueue ?? (yield* config.queueFactory ?? Queue.unbounded());
+	const { stateRef, stoppedRef, eventQueue } = config.cellResources;
+	const pendingRequests = /* @__PURE__ */ new Set();
 	const exitDeferred = yield* Deferred.make();
 	const actorScope = yield* Scope.make();
 	const deferredReplyRef = { current: void 0 };
@@ -57,10 +57,11 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 	const childPrefix = config.childIdPrefix ?? "";
 	const defaultSpawn = (childId, childMachine) => system.spawn(`${childPrefix}${childId}`, childMachine).pipe(Effect.provideService(ActorSystem, system));
 	const onChildSpawned = config.onChildSpawned;
+	let spawn = defaultSpawn;
+	if (onChildSpawned !== void 0) spawn = (childId, childMachine) => defaultSpawn(childId, childMachine).pipe(Effect.tap((child) => onChildSpawned(childId, child)));
 	const self = {
 		send: selfSend,
-		cast: selfSend,
-		spawn: onChildSpawned !== void 0 ? (childId, childMachine) => defaultSpawn(childId, childMachine).pipe(Effect.tap((child) => onChildSpawned(childId, child))) : defaultSpawn,
+		spawn,
 		reply: (value) => Effect.sync(() => {
 			const deferred = deferredReplyRef.current;
 			if (deferred !== void 0) {
@@ -73,14 +74,6 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 	};
 	const stateScopeRef = { current: yield* Scope.make() };
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
-	const ctx = {
-		actorId,
-		state: machine.initial,
-		event: initEvent,
-		self,
-		system
-	};
-	const slots = machine._slots;
 	const loopFiberRef = { current: void 0 };
 	/** Set the exit deferred exactly once. */
 	const setExit = (exit) => Deferred.succeed(exitDeferred, exit).pipe(Effect.asVoid);
@@ -92,19 +85,22 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 			return;
 		}
 		const backgroundFibers = [];
-		for (const bg of machine.backgroundEffects) {
+		for (const bg of machine._backgroundEffectEntries()) {
 			const fiber = yield* bg.handler({
 				actorId,
 				state: machine.initial,
 				event: initEvent,
 				self,
-				slots,
 				system
-			}).pipe(Effect.provideService(machine.Context, ctx), Effect.forkIn(actorScope));
+			}).pipe(Effect.forkIn(actorScope));
 			backgroundFibers.push(fiber);
 		}
 		if (lifecycle?.onInitialSpawnEffects !== void 0) yield* lifecycle.onInitialSpawnEffects(machine.initial);
-		const initialSpawnDefectSignal = (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid);
+		const initialSpawnDefectSignal = (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => {
+			const loopFiber = loopFiberRef.current;
+			if (loopFiber !== void 0) return Fiber.interrupt(loopFiber);
+			return Effect.void;
+		})), Effect.asVoid);
 		yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
 			yield* Ref.set(stoppedRef, true);
 			yield* Scope.close(stateScopeRef.current, Exit.void);
@@ -112,7 +108,7 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 			yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
 			return yield* Effect.failCause(cause);
 		})));
-		if (machine.finalStates.has(machine.initial._tag)) {
+		if (machine._isFinal(machine.initial._tag)) {
 			if (lifecycle?.onFinal !== void 0) yield* lifecycle.onFinal(machine.initial);
 			yield* Ref.set(stoppedRef, true);
 			yield* Scope.close(stateScopeRef.current, Exit.void);
@@ -123,9 +119,13 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 		}
 		const augmentedHooks = {
 			...hooks,
-			onSpawnDefect: (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid)
+			onSpawnDefect: (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => {
+				const loopFiber = loopFiberRef.current;
+				if (loopFiber !== void 0) return Fiber.interrupt(loopFiber);
+				return Effect.void;
+			})), Effect.asVoid)
 		};
-		const loopFiber = yield* Effect.forkDetach(runtimeEventLoop(machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, augmentedHooks, deferredReplyRef, lifecycle, config.wrapProcess, fork));
+		const loopFiber = yield* runtimeEventLoop(machine, stateRef, eventQueue, pendingRequests, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, augmentedHooks, deferredReplyRef, lifecycle, fork).pipe(Effect.provide(services), Effect.forkDetach);
 		loopFiberRef.current = loopFiber;
 		if (backgroundFibers.length > 0) yield* Effect.raceAll(backgroundFibers.map((fiber) => Fiber.await(fiber).pipe(Effect.flatMap((exit) => {
 			if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) return setExit(ActorExit.Defect(exit.cause, "background")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Fiber.interrupt(loopFiber)));
@@ -141,6 +141,7 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 	const stop = Effect.gen(function* () {
 		if (yield* Ref.get(stoppedRef)) return;
 		if (lifecycle?.onShutdown !== void 0) yield* lifecycle.onShutdown();
+		yield* settlePendingRequests(pendingRequests, actorId);
 		yield* Ref.set(stoppedRef, true);
 		const loopFiber = loopFiberRef.current;
 		if (loopFiber !== void 0) yield* Fiber.interrupt(loopFiber);
@@ -150,105 +151,140 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 	}).pipe(Effect.asVoid);
 	if (config.skipFinalizer !== true) yield* Effect.addFinalizer(() => stop);
 	return {
-		...makeHandle(stateRef, stoppedRef, eventQueue, exitDeferred, actorScope),
-		stop,
-		start
+		...makeHandle(actorId, stateRef, stoppedRef, eventQueue, pendingRequests, exitDeferred),
+		stop: stop.pipe(Effect.provide(services)),
+		start: start.pipe(Effect.provide(services))
 	};
 });
 /**
-* Build the runtime handle (send/ask/getState/isStopped).
+* Build the runtime handle.
 * Shared between initial-final and normal paths.
 */
-const makeHandle = (stateRef, stoppedRef, eventQueue, exitDeferred, actorScope) => ({
-	send: (event) => Effect.gen(function* () {
-		if (!(yield* Ref.get(stoppedRef))) yield* Queue.offer(eventQueue, {
+const makeHandle = (actorId, stateRef, stoppedRef, eventQueue, pendingRequests, exitDeferred) => {
+	const track = (deferred, settle) => {
+		pendingRequests.add(settle);
+		return Deferred.await(deferred).pipe(Effect.ensuring(Effect.sync(() => pendingRequests.delete(settle))));
+	};
+	const send = (event) => Ref.get(stoppedRef).pipe(Effect.flatMap((stopped) => {
+		if (stopped) return Effect.void;
+		return Queue.offer(eventQueue, {
 			_tag: "send",
 			event
-		});
-	}),
-	sendWait: (event) => Effect.gen(function* () {
-		if (!(yield* Ref.get(stoppedRef))) {
-			const done = yield* Deferred.make();
+		}).pipe(Effect.asVoid);
+	}));
+	return {
+		send,
+		sendWait: (event) => Effect.gen(function* () {
+			if (!(yield* Ref.get(stoppedRef))) {
+				const done = yield* Deferred.make();
+				yield* Queue.offer(eventQueue, {
+					_tag: "sendWait",
+					event,
+					done
+				});
+				yield* track(done, (error) => Deferred.fail(done, error).pipe(Effect.asVoid));
+			}
+		}),
+		call: (event) => Effect.gen(function* () {
+			if (yield* Ref.get(stoppedRef)) return yield* ActorStoppedError.make({ actorId });
+			const reply = yield* Deferred.make();
+			yield* Queue.offer(eventQueue, {
+				_tag: "call",
+				event,
+				reply
+			});
+			return yield* track(reply, (error) => Deferred.fail(reply, error).pipe(Effect.asVoid));
+		}),
+		ask: (event) => Effect.gen(function* () {
+			if (yield* Ref.get(stoppedRef)) return yield* ActorStoppedError.make({ actorId });
+			const reply = yield* Deferred.make();
 			yield* Queue.offer(eventQueue, {
-				_tag: "sendWait",
+				_tag: "ask",
 				event,
+				reply
+			});
+			return yield* track(reply, (error) => Deferred.fail(reply, error).pipe(Effect.asVoid));
+		}),
+		drain: Effect.gen(function* () {
+			if (yield* Ref.get(stoppedRef)) return;
+			const done = yield* Deferred.make();
+			yield* Queue.offer(eventQueue, {
+				_tag: "drain",
 				done
 			});
 			yield* Deferred.await(done);
-		}
-	}),
-	ask: (event) => Effect.gen(function* () {
-		if (yield* Ref.get(stoppedRef)) return yield* new NoReplyError({
-			actorId: "stopped",
-			eventTag: event._tag
-		});
-		const reply = yield* Deferred.make();
-		yield* Queue.offer(eventQueue, {
-			_tag: "ask",
-			event,
-			reply
-		});
-		return yield* Deferred.await(reply);
-	}),
-	getState: SubscriptionRef.get(stateRef),
-	stateRef,
-	isStopped: Ref.get(stoppedRef),
-	stop: Effect.void,
-	start: Effect.void,
-	_queue: eventQueue,
-	_stoppedRef: stoppedRef,
-	exitDeferred,
-	actorScope
+		}).pipe(Effect.asVoid),
+		sendSync: (event) => {
+			if (!Effect.runSync(Ref.get(stoppedRef))) Effect.runSync(Queue.offer(eventQueue, {
+				_tag: "send",
+				event
+			}));
+		},
+		getState: SubscriptionRef.get(stateRef),
+		stateRef,
+		stop: Effect.void,
+		start: Effect.void,
+		settlePendingRequests: settlePendingRequests(pendingRequests, actorId),
+		exitDeferred
+	};
+};
+const settlePendingRequests = (pendingRequests, actorId) => Effect.gen(function* () {
+	const error = ActorStoppedError.make({ actorId });
+	for (const settle of pendingRequests) yield* settle(error);
+	pendingRequests.clear();
 });
-const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, hooks, deferredReplyRef, lifecycle, wrapProcess, fork) {
+const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function* (machine, stateRef, eventQueue, pendingRequests, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, hooks, deferredReplyRef, lifecycle, fork) {
 	const forkEffect = fork ?? Effect.runFork;
 	/** Set the exit deferred exactly once. */
 	const setExit = (exit) => Deferred.succeed(exitDeferred, exit).pipe(Effect.asVoid);
-	const postponed = [];
-	const hasPostponeRules = machine.postponeRules.length > 0;
-	const processQueued = Effect.fn("effect-machine.runtime.processQueued")(function* (queued) {
+	const postponeQueued = Effect.fn("effect-machine.runtime.postponeQueued")(function* (currentState, queued) {
 		const event = queued.event;
-		const currentState = yield* SubscriptionRef.get(stateRef);
-		if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
-			if (queued._tag === "call") {
-				const postponedResult = {
-					newState: currentState,
-					previousState: currentState,
-					transitioned: false,
-					lifecycleRan: false,
-					isFinal: false,
-					hasReply: false,
-					deferReply: false,
-					reply: void 0,
-					postponed: true
-				};
-				yield* Deferred.succeed(queued.reply, postponedResult);
-			}
-			if (queued._tag === "sendWait") yield* Deferred.succeed(queued.done, void 0);
-			postponed.push({
+		const postponedResult = {
+			newState: currentState,
+			previousState: currentState,
+			transitioned: false,
+			lifecycleRan: false,
+			isFinal: false,
+			hasReply: false,
+			deferReply: false,
+			reply: void 0,
+			postponed: true
+		};
+		let input = queued;
+		if (queued._tag === "call") {
+			yield* Deferred.succeed(queued.reply, postponedResult);
+			input = {
+				_tag: "send",
+				event
+			};
+		} else if (queued._tag === "sendWait") {
+			yield* Deferred.succeed(queued.done, void 0);
+			input = {
 				_tag: "send",
 				event
-			});
-			return {
-				shouldStop: false,
-				stateChanged: false,
-				result: {
-					newState: currentState,
-					previousState: currentState,
-					transitioned: false,
-					lifecycleRan: false,
-					isFinal: false,
-					hasReply: false,
-					deferReply: false,
-					reply: void 0,
-					postponed: true
-				}
 			};
 		}
+		return {
+			input,
+			value: {
+				shouldStop: false,
+				stateChanged: false,
+				result: postponedResult
+			}
+		};
+	});
+	const processQueued = (currentState, queued) => Effect.gen(function* () {
+		const event = queued.event;
 		if (lifecycle?.onEvent !== void 0) yield* lifecycle.onEvent(currentState, event);
-		const result = yield* processEventCore(machine, currentState, event, self, stateScopeRef, system, actorId, hooks);
+		const processing = processEventCoreImmediate(machine, currentState, event, self, stateScopeRef, system, actorId, hooks);
+		let result;
+		if (isEffect(processing)) result = yield* processing;
+		else result = processing;
 		if (result.transitioned) yield* SubscriptionRef.set(stateRef, result.newState);
-		if (lifecycle?.onStateChange !== void 0 && result.transitioned) yield* lifecycle.onStateChange(result, event);
+		if (lifecycle?.onStateChange !== void 0 && result.transitioned) {
+			const stateChange = lifecycle.onStateChange(result, event);
+			if (isEffect(stateChange)) yield* stateChange;
+		}
 		switch (queued._tag) {
 			case "call":
 				yield* Deferred.succeed(queued.reply, result);
@@ -256,24 +292,25 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 			case "sendWait":
 				yield* Deferred.succeed(queued.done, void 0);
 				break;
-			case "ask":
-				if (result.hasReply) {
-					const replySchema = machine._replySchemas?.get(event._tag);
-					if (replySchema !== void 0) {
-						const decoded = yield* Schema.decodeUnknownEffect(replySchema)(result.reply).pipe(Effect.catch((decodeError) => Effect.gen(function* () {
-							yield* Deferred.die(queued.reply, decodeError);
-							return yield* Effect.die(decodeError);
-						})));
-						yield* Deferred.succeed(queued.reply, decoded);
-					} else yield* Deferred.succeed(queued.reply, result.reply);
-				} else if (result.deferReply && deferredReplyRef !== void 0) deferredReplyRef.current = queued.reply;
-				else yield* Deferred.fail(queued.reply, new NoReplyError({
-					actorId,
-					eventTag: event._tag
-				}));
-				break;
+			case "ask": if (result.hasReply) {
+				const replySchema = machine._replySchema(event._tag);
+				if (replySchema !== void 0) {
+					const decoded = yield* Schema.decodeUnknownEffect(replySchema)(result.reply).pipe(Effect.catch((decodeError) => Effect.gen(function* () {
+						yield* Deferred.die(queued.reply, decodeError);
+						return yield* Effect.die(decodeError);
+					})));
+					yield* Deferred.succeed(queued.reply, decoded);
+				} else yield* Deferred.succeed(queued.reply, result.reply);
+			} else if (result.deferReply && deferredReplyRef !== void 0) deferredReplyRef.current = queued.reply;
+			else yield* Deferred.fail(queued.reply, NoReplyError.make({
+				actorId,
+				eventTag: event._tag
+			}));
+		}
+		if (lifecycle?.onProcessed !== void 0 && result.transitioned) {
+			const processed = lifecycle.onProcessed(result, event);
+			if (isEffect(processed)) yield* processed;
 		}
-		if (lifecycle?.onProcessed !== void 0 && result.transitioned) yield* lifecycle.onProcessed(result, event);
 		const shouldStop = result.isFinal && result.lifecycleRan;
 		if (shouldStop && lifecycle?.onFinal !== void 0) yield* lifecycle.onFinal(result.newState);
 		return {
@@ -282,24 +319,48 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 			result
 		};
 	});
+	const initialState = yield* SubscriptionRef.get(stateRef);
+	let currentState = initialState;
+	const makePostponeAdvancement = () => makeEventAdvancement({
+		initial: initialState,
+		isFinal: (state) => machine._isFinal(state._tag),
+		shouldPostpone: (state, queued) => shouldPostpone(machine, state._tag, queued.event._tag),
+		postpone: postponeQueued,
+		process: (state, queued, _draining) => processQueued(state, queued).pipe(Effect.map((processed) => ({
+			state: processed.result.newState,
+			transitioned: processed.result.transitioned,
+			stateChanged: processed.stateChanged,
+			shouldStop: processed.shouldStop,
+			value: processed
+		}))),
+		discard: (queued) => {
+			if (queued._tag === "ask") return Deferred.fail(queued.reply, NoReplyError.make({
+				actorId,
+				eventTag: queued.event._tag
+			})).pipe(Effect.asVoid);
+			return Effect.void;
+		}
+	});
+	let advancement;
+	if (machine._hasPostponeRules()) advancement = makePostponeAdvancement();
 	const shutdown = (exitReason) => Effect.gen(function* () {
 		yield* Ref.set(stoppedRef, true);
 		if (lifecycle?.onShutdown !== void 0) yield* lifecycle.onShutdown();
-		settlePostponed(postponed, actorId, forkEffect);
+		if (advancement !== void 0) yield* advancement.close();
 		const remaining = yield* Queue.clear(eventQueue);
 		for (const entry of remaining) if (entry._tag === "sendWait") forkEffect(Deferred.succeed(entry.done, void 0));
-		else if (entry._tag === "ask") forkEffect(Deferred.fail(entry.reply, new NoReplyError({
+		else if (entry._tag === "ask") forkEffect(Deferred.fail(entry.reply, NoReplyError.make({
 			actorId,
 			eventTag: entry.event._tag
 		})));
 		else if (entry._tag === "call") {
-			const currentState = yield* SubscriptionRef.get(stateRef);
+			const state = yield* SubscriptionRef.get(stateRef);
 			forkEffect(Deferred.succeed(entry.reply, {
-				newState: currentState,
-				previousState: currentState,
+				newState: state,
+				previousState: state,
 				transitioned: false,
 				lifecycleRan: false,
-				isFinal: machine.finalStates.has(currentState._tag),
+				isFinal: machine._isFinal(state._tag),
 				hasReply: false,
 				deferReply: false,
 				reply: void 0,
@@ -317,44 +378,24 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 			return;
 		}
 		const eventQueued = queued;
-		const processInner = processQueued(eventQueued);
-		const { shouldStop, stateChanged } = yield* (wrapProcess !== void 0 ? Effect.gen(function* () {
-			return yield* wrapProcess(yield* SubscriptionRef.get(stateRef), eventQueued.event, processInner);
-		}) : processInner).pipe(Effect.catchCause((cause) => {
+		const catchEventDefect = (effect) => effect.pipe(Effect.catchCause((cause) => {
 			if (queued._tag === "sendWait") forkEffect(Deferred.failCause(queued.done, cause));
 			else if (queued._tag === "ask") forkEffect(Deferred.die(queued.reply, cause));
 			else if (queued._tag === "call") forkEffect(Deferred.failCause(queued.reply, cause));
 			return shutdown(ActorExit.Defect(cause, "transition")).pipe(Effect.andThen(Effect.failCause(cause)));
 		}));
-		if (shouldStop) {
+		let stopped;
+		if (advancement === void 0) {
+			const processed = yield* catchEventDefect(processQueued(currentState, eventQueued));
+			currentState = processed.result.newState;
+			stopped = processed.shouldStop;
+		} else stopped = (yield* catchEventDefect(advancement.advance(eventQueued))).stopped;
+		if (stopped) {
 			const finalState = yield* SubscriptionRef.get(stateRef);
 			yield* shutdown(ActorExit.Final(finalState));
 			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) {
-					const finalState = yield* SubscriptionRef.get(stateRef);
-					yield* shutdown(ActorExit.Final(finalState));
-					return;
-				}
-				if (drain.stateChanged) drainTriggered = true;
-			}
-		}
 	}
 });
-/** Settle all pending Deferreds in the postpone buffer on shutdown. */
-const settlePostponed = (postponed, actorId, forkFn) => {
-	for (const entry of postponed) if (entry._tag === "ask") forkFn(Deferred.fail(entry.reply, new NoReplyError({
-		actorId,
-		eventTag: entry.event._tag
-	})));
-	else if (entry._tag === "sendWait") forkFn(Deferred.succeed(entry.done, void 0));
-	postponed.length = 0;
-};
 //#endregion
 export { createRuntime };

package/dist/internal/transition.d.ts

@@ -1,63 +1,6 @@
-import { MachineContextTag, SlotsDef } from "../slot.js";
-import { Machine, MachineRef, SpawnEffect, Transition } from "../machine.js";
-import { ActorSystemService } from "../actor.js";
-import { Cause, Effect, Scope } from "effect";
-
+import { Machine } from "../machine.js";
+import { Transition } from "./machine-definition.js";
 //#region src/internal/transition.d.ts
-/**
- * Result of executing a transition.
- */
-interface TransitionExecutionResult<S> {
-  /** New state after transition (or current state if no transition matched) */
-  readonly newState: S;
-  /** Whether a transition was executed */
-  readonly transitioned: boolean;
-  /** Whether reenter was specified on the transition */
-  readonly reenter: boolean;
-}
-/**
- * Run a transition handler and return the new state.
- * Shared logic for executing handlers with proper context.
- *
- * Used by:
- * - executeTransition (actor event loop, testing)
- * - Machine.replay (event sourcing restore)
- *
- * @internal
- */
-declare const runTransitionHandler: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, transition: Transition<S, E, SD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystemService, actorId: string) => Effect.Effect<{
-  newState: S;
-  hasReply: boolean;
-  deferReply: boolean;
-  reply: unknown;
-}, never, Exclude<R, MachineContextTag>>;
-/**
- * Execute a transition for a given state and event.
- * Handles transition resolution, handler invocation, and guard/effect slot creation.
- *
- * Used by:
- * - processEvent in actor.ts (actual actor event loop)
- * - simulate in testing.ts (pure transition simulation)
- * - createTestHarness.send in testing.ts (step-by-step testing)
- *
- * @internal
- */
-declare const executeTransition: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystemService, actorId: string) => Effect.Effect<{
-  newState: S;
-  transitioned: boolean;
-  reenter: boolean;
-  hasReply: boolean;
-  deferReply: boolean;
-  reply: unknown;
-}, never, Exclude<R, MachineContextTag>>;
 /**
  * Optional hooks for event processing inspection/tracing.
  */
@@ -103,54 +46,6 @@ interface ProcessEventResult<S> {
   /** 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>, stateTag: string, eventTag: string) => boolean;
-/**
- * Process a single event through the machine.
- *
- * Handles:
- * - Transition execution
- * - State scope lifecycle (close old, create new)
- * - Running spawn effects
- *
- * Optional hooks allow inspection/tracing without coupling to specific impl.
- *
- * @internal
- */
-declare const processEventCore: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
-  current: Scope.Closeable;
-}, system: ActorSystemService, actorId: string, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
-  newState: S;
-  previousState: S;
-  transitioned: boolean;
-  lifecycleRan: boolean;
-  isFinal: boolean;
-  hasReply: boolean;
-  deferReply: boolean;
-  reply: unknown;
-  postponed: boolean;
-}, never, Exclude<R, MachineContextTag> | Exclude<Exclude<R, MachineContextTag>, Scope.Scope>>;
-/**
- * Run spawn effects for a state (forked into state scope, auto-cancelled on state exit).
- *
- * @internal
- */
-declare const runSpawnEffects: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystemService, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContextTag>, Scope.Scope>>;
 /**
  * Resolve which transition should fire for a given state and event.
  * Uses indexed O(1) lookup. First matching transition wins.
@@ -159,32 +54,6 @@ declare const resolveTransition: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any>, currentState: S, event: E) => (typeof machine.transitions)[number] | undefined;
-/**
- * Invalidate cached index for a machine (call after mutation).
- */
-declare const invalidateIndex: (machine: object) => void;
-/**
- * Find all transitions matching a state/event pair.
- * Returns empty array if no matches.
- *
- * O(1) lookup after first access (index is lazily built).
- */
-declare const findTransitions: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, stateTag: string, eventTag: string) => ReadonlyArray<Transition<S, E, SD, R>>;
-/**
- * Find all spawn effects for a state.
- * Returns empty array if no matches.
- *
- * O(1) lookup after first access (index is lazily built).
- */
-declare const findSpawnEffects: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, stateTag: string) => ReadonlyArray<SpawnEffect<S, E, SD, R>>;
+}, R>(machine: Machine<S, E, R, any, any>, currentState: S, event: E) => Transition<S, E, never> | undefined;
 //#endregion
-export { ProcessEventError, ProcessEventHooks, ProcessEventResult, TransitionExecutionResult, executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler, shouldPostpone };
+export { ProcessEventError, ProcessEventHooks, ProcessEventResult, resolveTransition };