effect-machine 0.17.1 → 0.19.0

package/v3/dist/internal/runtime.js

@@ -1,360 +0,0 @@
-import { INTERNAL_INIT_EVENT } from "./utils.js";
-import { NoReplyError } from "../errors.js";
-import { processEventCore, runSpawnEffects, shouldPostpone } from "./transition.js";
-import { ActorExit } from "../supervision.js";
-import { ActorSystem } from "../actor.js";
-import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Runtime, Schema, Scope, SubscriptionRef } from "effect";
-//#region src/internal/runtime.ts
-/**
-* Shared runtime kernel for machine event processing.
-*
-* Provides a single-queue event loop with:
-* - Sequential event processing (no split-mailbox race)
-* - Postpone buffer with drain-on-state-change (gen_statem)
-* - Background effect lifecycle (under actorScope fault boundary)
-* - Spawn effect lifecycle (per-state scope)
-* - Final state detection → stop
-* - Reply settlement (call/ask Deferreds)
-* - Reply schema validation
-* - Lifecycle hooks for actor-specific concerns (inspection, listeners, etc.)
-* - ActorExit with exit reason (Final/Stopped/Defect) via exitDeferred
-*
-* Used by entity-machine and local actor (actor.ts delegates here).
-*
-* @internal
-*/
-/**
-* Create a runtime for a machine. Returns a handle for sending events
-* and querying state. The runtime owns:
-* - Event loop fiber
-* - Postpone buffer
-* - Background effects (under actorScope)
-* - State scope (spawn effects)
-* - Final state detection
-* - Exit reason via exitDeferred
-*
-* Resources (stateRef, eventQueue, stoppedRef) are either cell-provided
-* or allocated fresh by the runtime.
-*
-* @internal
-*/
-const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (machine, system, config) {
-	const { actorId, hooks, lifecycle } = config;
-	const rt = yield* Effect.runtime();
-	const fork = Runtime.runFork(rt);
-	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 exitDeferred = yield* Deferred.make();
-	const actorScope = yield* Scope.make();
-	const deferredReplyRef = { current: void 0 };
-	const selfSend = Effect.fn("effect-machine.runtime.self.send")(function* (event) {
-		if (!(yield* Ref.get(stoppedRef))) yield* Queue.offer(eventQueue, {
-			_tag: "send",
-			event
-		});
-	});
-	const childPrefix = config.childIdPrefix ?? "";
-	const defaultSpawn = (childId, childMachine) => system.spawn(`${childPrefix}${childId}`, childMachine).pipe(Effect.provideService(ActorSystem, system));
-	const onChildSpawned = config.onChildSpawned;
-	const self = {
-		send: selfSend,
-		cast: selfSend,
-		spawn: onChildSpawned !== void 0 ? (childId, childMachine) => defaultSpawn(childId, childMachine).pipe(Effect.tap((child) => onChildSpawned(childId, child))) : defaultSpawn,
-		reply: (value) => Effect.sync(() => {
-			const deferred = deferredReplyRef.current;
-			if (deferred !== void 0) {
-				deferredReplyRef.current = void 0;
-				fork(Deferred.succeed(deferred, value));
-				return true;
-			}
-			return false;
-		})
-	};
-	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);
-	const startDeferred = yield* Deferred.make();
-	const startedRef = yield* Ref.make(false);
-	const start = Effect.gen(function* () {
-		if (yield* Ref.getAndSet(startedRef, true)) {
-			yield* Deferred.await(startDeferred);
-			return;
-		}
-		const backgroundFibers = [];
-		for (const bg of machine.backgroundEffects) {
-			const fiber = yield* bg.handler({
-				actorId,
-				state: machine.initial,
-				event: initEvent,
-				self,
-				slots,
-				system
-			}).pipe(Effect.provideService(machine.Context, ctx), 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);
-		yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchAllCause((cause) => Effect.gen(function* () {
-			yield* Ref.set(stoppedRef, true);
-			yield* Scope.close(stateScopeRef.current, Exit.void);
-			yield* Scope.close(actorScope, Exit.void);
-			yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
-			return yield* Effect.failCause(cause);
-		})));
-		if (machine.finalStates.has(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);
-			yield* Scope.close(actorScope, Exit.void);
-			yield* setExit(ActorExit.Final(machine.initial));
-			yield* Deferred.succeed(startDeferred, void 0);
-			return;
-		}
-		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)
-		};
-		const loopFiber = yield* Effect.forkDaemon(runtimeEventLoop(machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, augmentedHooks, deferredReplyRef, lifecycle, config.wrapProcess, fork));
-		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.isInterruptedOnly(exit.cause)) return setExit(ActorExit.Defect(exit.cause, "background")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Fiber.interrupt(loopFiber)));
-			return Effect.never;
-		})))).pipe(Effect.forkIn(actorScope));
-		yield* Effect.forkDaemon(Effect.gen(function* () {
-			const loopExit = yield* Fiber.await(loopFiber);
-			if (loopExit._tag === "Success") yield* Scope.close(actorScope, Exit.void);
-			else yield* Scope.close(actorScope, loopExit);
-		}));
-		yield* Deferred.succeed(startDeferred, void 0);
-	}).pipe(Effect.catchAllCause((cause) => Deferred.failCause(startDeferred, cause).pipe(Effect.andThen(Effect.failCause(cause)))));
-	const stop = Effect.gen(function* () {
-		if (yield* Ref.get(stoppedRef)) return;
-		if (lifecycle?.onShutdown !== void 0) yield* lifecycle.onShutdown();
-		yield* Ref.set(stoppedRef, true);
-		const loopFiber = loopFiberRef.current;
-		if (loopFiber !== void 0) yield* Fiber.interrupt(loopFiber);
-		yield* Scope.close(stateScopeRef.current, Exit.void);
-		yield* Scope.close(actorScope, Exit.void);
-		yield* setExit(ActorExit.Stopped);
-	}).pipe(Effect.asVoid);
-	if (config.skipFinalizer !== true) yield* Effect.addFinalizer(() => stop);
-	return {
-		...makeHandle(stateRef, stoppedRef, eventQueue, exitDeferred, actorScope),
-		stop,
-		start
-	};
-});
-/**
-* Build the runtime handle (send/ask/getState/isStopped).
-* 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, {
-			_tag: "send",
-			event
-		});
-	}),
-	sendWait: (event) => Effect.gen(function* () {
-		if (!(yield* Ref.get(stoppedRef))) {
-			const done = yield* Deferred.make();
-			yield* Queue.offer(eventQueue, {
-				_tag: "sendWait",
-				event,
-				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
-});
-const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, hooks, deferredReplyRef, lifecycle, wrapProcess, 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 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({
-				_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
-				}
-			};
-		}
-		if (lifecycle?.onEvent !== void 0) yield* lifecycle.onEvent(currentState, event);
-		const result = yield* processEventCore(machine, currentState, event, self, stateScopeRef, system, actorId, hooks);
-		if (result.transitioned) yield* SubscriptionRef.set(stateRef, result.newState);
-		if (lifecycle?.onStateChange !== void 0 && result.transitioned) yield* lifecycle.onStateChange(result, event);
-		switch (queued._tag) {
-			case "call":
-				yield* Deferred.succeed(queued.reply, result);
-				break;
-			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.decodeUnknown(replySchema)(result.reply).pipe(Effect.catchAll((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;
-		}
-		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 {
-			shouldStop,
-			stateChanged: result.lifecycleRan,
-			result
-		};
-	});
-	const shutdown = (exitReason) => Effect.gen(function* () {
-		yield* Ref.set(stoppedRef, true);
-		if (lifecycle?.onShutdown !== void 0) yield* lifecycle.onShutdown();
-		settlePostponed(postponed, actorId, forkEffect);
-		const remaining = yield* Queue.takeAll(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({
-			actorId,
-			eventTag: entry.event._tag
-		})));
-		else if (entry._tag === "call") {
-			const currentState = yield* SubscriptionRef.get(stateRef);
-			forkEffect(Deferred.succeed(entry.reply, {
-				newState: currentState,
-				previousState: currentState,
-				transitioned: false,
-				lifecycleRan: false,
-				isFinal: machine.finalStates.has(currentState._tag),
-				hasReply: false,
-				deferReply: false,
-				reply: void 0,
-				postponed: false
-			}));
-		}
-		yield* Scope.close(stateScopeRef.current, Exit.void);
-		yield* setExit(exitReason);
-	});
-	while (true) {
-		const queued = yield* Queue.take(eventQueue);
-		if (queued._tag === "drain") {
-			yield* shutdown(ActorExit.Stopped);
-			yield* Deferred.succeed(queued.done, void 0);
-			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.catchAllCause((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) {
-			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/v3/dist/internal/transition.d.ts

@@ -1,190 +0,0 @@
-import { MachineContext, SlotsDef } from "../slot.js";
-import { Machine, MachineRef, SpawnEffect, Transition } from "../machine.js";
-import { ActorSystem } from "../actor.js";
-import { Cause, Effect, Scope } from "effect";
-
-//#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: ActorSystem, actorId: string) => Effect.Effect<{
-  newState: S;
-  hasReply: boolean;
-  deferReply: boolean;
-  reply: unknown;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
-/**
- * Execute a transition for a given state and event.
- * Handles transition resolution, handler invocation, and guard/effect slot creation.
- *
- * 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: ActorSystem, actorId: string) => Effect.Effect<{
-  newState: S;
-  transitioned: boolean;
-  reenter: boolean;
-  hasReply: boolean;
-  deferReply: boolean;
-  reply: unknown;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
-/**
- * Optional hooks for event processing inspection/tracing.
- */
-interface ProcessEventHooks<S, E> {
-  /** Called before running spawn effects */
-  readonly onSpawnEffect?: (state: S) => Effect.Effect<void>;
-  /** Called after transition completes */
-  readonly onTransition?: (from: S, to: S, event: E) => Effect.Effect<void>;
-  /** Called when a transition handler or spawn effect fails with a defect */
-  readonly onError?: (info: ProcessEventError<S, E>) => Effect.Effect<void>;
-  /** Called when a forked spawn fiber defects — signals the runtime to set exitDeferred */
-  readonly onSpawnDefect?: (cause: Cause.Cause<unknown>) => Effect.Effect<void>;
-}
-/**
- * Error info for inspection hooks.
- */
-interface ProcessEventError<S, E> {
-  readonly phase: "transition" | "spawn";
-  readonly state: S;
-  readonly event: E;
-  readonly cause: Cause.Cause<unknown>;
-}
-/**
- * Result of processing an event through the machine.
- */
-interface ProcessEventResult<S> {
-  /** New state after processing */
-  readonly newState: S;
-  /** Previous state before processing */
-  readonly previousState: S;
-  /** Whether a transition occurred */
-  readonly transitioned: boolean;
-  /** Whether lifecycle effects ran (state change or reenter) */
-  readonly lifecycleRan: boolean;
-  /** Whether new state is final */
-  readonly isFinal: boolean;
-  /** Whether the handler provided a reply (structural, not value-based) */
-  readonly hasReply: boolean;
-  /** Whether the handler deferred the reply to a spawn handler (Machine.deferReply) */
-  readonly deferReply: boolean;
-  /** Domain reply value from handler (used by ask). Only meaningful when hasReply is true. */
-  readonly reply?: unknown;
-  /** Whether the event was postponed (buffered for retry after next state change) */
-  readonly postponed: boolean;
-}
-/**
- * Check if an event should be postponed in the current state.
- * @internal
- */
-declare const shouldPostpone: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any>, 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.CloseableScope;
-}, system: ActorSystem, 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, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
-/**
- * Run spawn effects for a state (forked into state scope, auto-cancelled on state exit).
- *
- * @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.CloseableScope, system: ActorSystem, 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, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
-/**
- * Resolve which transition should fire for a given state and event.
- * Uses indexed O(1) lookup. First matching transition wins.
- */
-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>>;
-//#endregion
-export { ProcessEventError, ProcessEventHooks, ProcessEventResult, TransitionExecutionResult, executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler, shouldPostpone };