effect-machine 0.17.1 → 0.19.0

package/dist/internal/transition.js

@@ -11,53 +11,35 @@ import { Cause, Effect, Exit, Scope } from "effect";
 *
 * @internal
 */
-/**
-* 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
-*/
-const runTransitionHandler = Effect.fn("effect-machine.runTransitionHandler")(function* (machine, transition, state, event, self, system, actorId) {
-	const ctx = {
-		actorId,
-		state,
-		event,
-		self,
-		system
-	};
-	const handlerCtx = {
-		state,
-		event,
-		slots: machine._slots
-	};
-	const raw = transition.handler(handlerCtx);
-	const resolved = isEffect(raw) ? yield* raw.pipe(Effect.provideService(machine.Context, ctx)) : raw;
+const completeTransition = (transition, resolved) => {
 	if (isReplyResult(resolved)) return {
 		newState: resolved.state,
+		transitioned: true,
+		reenter: transition.reenter === true,
 		hasReply: true,
 		deferReply: false,
 		reply: resolved.reply
 	};
 	if (isDeferReplyResult(resolved)) return {
 		newState: resolved.state,
+		transitioned: true,
+		reenter: transition.reenter === true,
 		hasReply: false,
 		deferReply: true,
 		reply: void 0
 	};
 	return {
 		newState: resolved,
+		transitioned: true,
+		reenter: transition.reenter === true,
 		hasReply: false,
 		deferReply: false,
 		reply: void 0
 	};
-});
+};
 /**
 * Execute a transition for a given state and event.
-* Handles transition resolution, handler invocation, and guard/effect slot creation.
+* Handles transition resolution and handler invocation.
 *
 * Used by:
 * - processEvent in actor.ts (actual actor event loop)
@@ -66,7 +48,18 @@ const runTransitionHandler = Effect.fn("effect-machine.runTransitionHandler")(fu
 *
 * @internal
 */
-const executeTransition = Effect.fn("effect-machine.executeTransition")(function* (machine, currentState, event, self, system, actorId) {
+const executeTransition = (machine, currentState, event) => Effect.suspend(() => {
+	const result = executeTransitionImmediate(machine, currentState, event);
+	if (isEffect(result)) return result;
+	return Effect.succeed(result);
+});
+/**
+* Execute a transition without adding an Effect boundary for a synchronous handler.
+* A throwing handler becomes a defect Effect.
+*
+* @internal
+*/
+const executeTransitionImmediate = (machine, currentState, event) => {
 	const transition = resolveTransition(machine, currentState, event);
 	if (transition === void 0) return {
 		newState: currentState,
@@ -76,24 +69,24 @@ const executeTransition = Effect.fn("effect-machine.executeTransition")(function
 		deferReply: false,
 		reply: void 0
 	};
-	const { newState, hasReply, deferReply, reply } = yield* runTransitionHandler(machine, transition, currentState, event, self, system, actorId);
-	return {
-		newState,
-		transitioned: true,
-		reenter: transition.reenter === true,
-		hasReply,
-		deferReply,
-		reply
+	const handlerCtx = {
+		state: currentState,
+		event
 	};
-});
+	let raw;
+	try {
+		raw = transition.handler(handlerCtx);
+	} catch (defect) {
+		return Effect.die(defect);
+	}
+	if (isEffect(raw)) return raw.pipe(Effect.map((resolved) => completeTransition(transition, resolved)));
+	return completeTransition(transition, raw);
+};
 /**
 * Check if an event should be postponed in the current state.
 * @internal
 */
-const shouldPostpone = (machine, stateTag, eventTag) => {
-	for (const rule of machine.postponeRules) if (rule.stateTag === stateTag && rule.eventTag === eventTag) return true;
-	return false;
-};
+const shouldPostpone = (machine, stateTag, eventTag) => machine._shouldPostpone(stateTag, eventTag);
 /**
 * Process a single event through the machine.
 *
@@ -106,18 +99,12 @@ const shouldPostpone = (machine, stateTag, eventTag) => {
 *
 * @internal
 */
-const processEventCore = Effect.fn("effect-machine.processEventCore")(function* (machine, currentState, event, self, stateScopeRef, system, actorId, hooks) {
-	const result = yield* executeTransition(machine, currentState, event, self, system, actorId).pipe(Effect.catchCause((cause) => {
-		if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
-		const onError = hooks?.onError;
-		if (onError === void 0) return Effect.failCause(cause).pipe(Effect.orDie);
-		return onError({
-			phase: "transition",
-			state: currentState,
-			event,
-			cause
-		}).pipe(Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
-	}));
+const processEventCore = (machine, currentState, event, self, stateScopeRef, system, actorId, hooks) => Effect.suspend(() => {
+	const processed = processEventCoreImmediate(machine, currentState, event, self, stateScopeRef, system, actorId, hooks);
+	if (isEffect(processed)) return processed;
+	return Effect.succeed(processed);
+});
+const completeProcessedEvent = (machine, currentState, event, result, self, stateScopeRef, system, actorId, hooks) => {
 	if (!result.transitioned) return {
 		newState: currentState,
 		previousState: currentState,
@@ -131,40 +118,55 @@ const processEventCore = Effect.fn("effect-machine.processEventCore")(function*
 	};
 	const newState = result.newState;
 	const runLifecycle = newState._tag !== currentState._tag || result.reenter;
-	if (runLifecycle) {
-		yield* Scope.close(stateScopeRef.current, Exit.void);
-		stateScopeRef.current = yield* Scope.make();
-		if (hooks?.onTransition !== void 0) yield* hooks.onTransition(currentState, newState, event);
-		if (hooks?.onSpawnEffect !== void 0) yield* hooks.onSpawnEffect(newState);
-		yield* runSpawnEffects(machine, newState, { _tag: INTERNAL_ENTER_EVENT }, self, stateScopeRef.current, system, actorId, hooks?.onError, hooks?.onSpawnDefect);
-	}
-	return {
+	const processed = {
 		newState,
 		previousState: currentState,
 		transitioned: true,
 		lifecycleRan: runLifecycle,
-		isFinal: machine.finalStates.has(newState._tag),
+		isFinal: machine._isFinal(newState._tag),
 		hasReply: result.hasReply,
 		deferReply: result.deferReply,
 		reply: result.reply,
 		postponed: false
 	};
-});
+	if (!runLifecycle) return processed;
+	return Effect.gen(function* () {
+		yield* Scope.close(stateScopeRef.current, Exit.void);
+		stateScopeRef.current = yield* Scope.make();
+		if (hooks?.onTransition !== void 0) yield* hooks.onTransition(currentState, newState, event);
+		if (hooks?.onSpawnEffect !== void 0) yield* hooks.onSpawnEffect(newState);
+		yield* runSpawnEffects(machine, newState, { _tag: INTERNAL_ENTER_EVENT }, self, stateScopeRef.current, system, actorId, hooks?.onError, hooks?.onSpawnDefect);
+		return processed;
+	});
+};
+/** @internal */
+const processEventCoreImmediate = (machine, currentState, event, self, stateScopeRef, system, actorId, hooks) => {
+	const execution = executeTransitionImmediate(machine, currentState, event);
+	const complete = (result) => completeProcessedEvent(machine, currentState, event, result, self, stateScopeRef, system, actorId, hooks);
+	if (!isEffect(execution)) return complete(execution);
+	return execution.pipe(Effect.catchCause((cause) => {
+		if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
+		const onError = hooks?.onError;
+		if (onError === void 0) return Effect.failCause(cause).pipe(Effect.orDie);
+		return onError({
+			phase: "transition",
+			state: currentState,
+			event,
+			cause
+		}).pipe(Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
+	}), Effect.flatMap((result) => {
+		const processed = complete(result);
+		if (isEffect(processed)) return processed;
+		return Effect.succeed(processed);
+	}));
+};
 /**
 * Run spawn effects for a state (forked into state scope, auto-cancelled on state exit).
 *
 * @internal
 */
 const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (machine, state, event, self, stateScope, system, actorId, onError, onSpawnDefect) {
-	const spawnEffects = findSpawnEffects(machine, state._tag);
-	const ctx = {
-		actorId,
-		state,
-		event,
-		self,
-		system
-	};
-	const slots = machine._slots;
+	const spawnEffects = machine._findSpawnEffects(state._tag);
 	const reportError = onError;
 	const defectSignal = onSpawnDefect;
 	for (const spawnEffect of spawnEffects) {
@@ -173,17 +175,18 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 			state,
 			event,
 			self,
-			slots,
 			system
-		}).pipe(Effect.provideService(machine.Context, ctx), Effect.catchCause((cause) => {
+		}).pipe(Effect.catchCause((cause) => {
 			if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
-			const report = reportError !== void 0 ? reportError({
+			let report = Effect.void;
+			if (reportError !== void 0) report = reportError({
 				phase: "spawn",
 				state,
 				event,
 				cause
-			}) : Effect.void;
-			const signal = defectSignal !== void 0 ? defectSignal(cause) : Effect.void;
+			});
+			let signal = Effect.void;
+			if (defectSignal !== void 0) signal = defectSignal(cause);
 			return report.pipe(Effect.andThen(signal), Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
 		}));
 		yield* Effect.forkScoped(effect).pipe(Effect.provideService(Scope.Scope, stateScope));
@@ -194,85 +197,7 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 * Uses indexed O(1) lookup. First matching transition wins.
 */
 const resolveTransition = (machine, currentState, event) => {
-	return findTransitions(machine, currentState._tag, event._tag)[0];
-};
-const indexCache = /* @__PURE__ */ new WeakMap();
-/**
-* Invalidate cached index for a machine (call after mutation).
-*/
-const invalidateIndex = (machine) => {
-	indexCache.delete(machine);
-};
-/**
-* Build transition index from machine definition.
-* O(n) where n = number of transitions.
-*/
-const buildTransitionIndex = (transitions) => {
-	const index = /* @__PURE__ */ new Map();
-	for (const t of transitions) {
-		let stateMap = index.get(t.stateTag);
-		if (stateMap === void 0) {
-			stateMap = /* @__PURE__ */ new Map();
-			index.set(t.stateTag, stateMap);
-		}
-		let eventList = stateMap.get(t.eventTag);
-		if (eventList === void 0) {
-			eventList = [];
-			stateMap.set(t.eventTag, eventList);
-		}
-		eventList.push(t);
-	}
-	return index;
-};
-/**
-* Build spawn index from machine definition.
-*/
-const buildSpawnIndex = (effects) => {
-	const index = /* @__PURE__ */ new Map();
-	for (const e of effects) {
-		let stateList = index.get(e.stateTag);
-		if (stateList === void 0) {
-			stateList = [];
-			index.set(e.stateTag, stateList);
-		}
-		stateList.push(e);
-	}
-	return index;
-};
-/**
-* Get or build index for a machine.
-*/
-const getIndex = (machine) => {
-	let index = indexCache.get(machine);
-	if (index === void 0) {
-		index = {
-			transitions: buildTransitionIndex(machine.transitions),
-			spawn: buildSpawnIndex(machine.spawnEffects)
-		};
-		indexCache.set(machine, index);
-	}
-	return index;
-};
-/**
-* Find all transitions matching a state/event pair.
-* Returns empty array if no matches.
-*
-* O(1) lookup after first access (index is lazily built).
-*/
-const findTransitions = (machine, stateTag, eventTag) => {
-	const index = getIndex(machine);
-	const specific = index.transitions.get(stateTag)?.get(eventTag) ?? [];
-	if (specific.length > 0) return specific;
-	return index.transitions.get("*")?.get(eventTag) ?? [];
-};
-/**
-* Find all spawn effects for a state.
-* Returns empty array if no matches.
-*
-* O(1) lookup after first access (index is lazily built).
-*/
-const findSpawnEffects = (machine, stateTag) => {
-	return getIndex(machine).spawn.get(stateTag) ?? [];
+	return machine._findTransitions(currentState._tag, event._tag)[0];
 };
 //#endregion
-export { executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler, shouldPostpone };
+export { executeTransition, executeTransitionImmediate, processEventCore, processEventCoreImmediate, resolveTransition, runSpawnEffects, shouldPostpone };

package/dist/internal/utils.d.ts

@@ -1,28 +1,4 @@
-import { ActorSystemService } from "../actor.js";
-import { Effect } from "effect";
-
 //#region src/internal/utils.d.ts
-/**
- * Extracts _tag from a tagged union member
- */
-type TagOf<T> = T extends {
-  readonly _tag: infer Tag;
-} ? Tag : never;
-/**
- * Extracts args type from a Data.taggedEnum constructor
- */
-type ArgsOf<C> = C extends ((args: infer A) => unknown) ? A : never;
-/**
- * Extracts return type from a Data.taggedEnum constructor
- * @internal
- */
-type InstanceOf<C> = C extends ((...args: unknown[]) => infer R) ? R : never;
-/**
- * A tagged union constructor (from Data.taggedEnum)
- */
-type TaggedConstructor<T extends {
-  readonly _tag: string;
-}> = (args: Omit<T, "_tag">) => T;
 declare const ReplyResultSymbol: unique symbol;
 type ReplyResultSymbol = typeof ReplyResultSymbol;
 /**
@@ -68,19 +44,13 @@ declare const isDeferReplyResult: (value: unknown) => value is DeferReplyResult<
  * - When Reply is concrete: handler must return ReplyResult via Machine.reply()
  */
 type TransitionResult<State, R, Reply = never> = [Reply] extends [never] ? State | Effect.Effect<State, never, R> : ReplyResult<State, Reply> | DeferReplyResult<State> | Effect.Effect<ReplyResult<State, Reply> | DeferReplyResult<State>, never, R>;
-/**
- * Internal event tags used for lifecycle effect contexts.
- * Prefixed with $ to distinguish from user events.
- * @internal
- */
-declare const INTERNAL_INIT_EVENT: "$init";
 declare const INTERNAL_ENTER_EVENT: "$enter";
 /**
  * Extract _tag from a tagged value or constructor.
  *
  * Supports:
- * - Plain values with `_tag` (MachineSchema empty structs)
- * - Constructors with static `_tag` (MachineSchema non-empty structs)
+ * - Plain values with `_tag` (`State` and `Event` empty structs)
+ * - Constructors with static `_tag` (`State` and `Event` non-empty structs)
  * - Data.taggedEnum constructors (fallback via instantiation)
  */
 declare const getTag: (constructorOrValue: {
@@ -90,12 +60,5 @@ declare const getTag: (constructorOrValue: {
 })) => string;
 /** Check if a value is an Effect */
 declare const isEffect: (value: unknown) => value is Effect.Effect<unknown, unknown, unknown>;
-/**
- * Stub ActorSystemService that dies on any method call.
- * Used in contexts where spawning/system access isn't supported
- * (testing simulation, persistent actor replay).
- * @internal
- */
-declare const stubSystem: ActorSystemService;
 //#endregion
-export { ArgsOf, DeferReplyResult, DeferReplySymbol, INTERNAL_ENTER_EVENT, INTERNAL_INIT_EVENT, InstanceOf, ReplyResult, ReplyResultSymbol, TagOf, TaggedConstructor, TransitionResult, getTag, isDeferReplyResult, isEffect, isReplyResult, makeDeferReply, makeReply, stubSystem };
+export { DeferReplyResult, DeferReplySymbol, INTERNAL_ENTER_EVENT, ReplyResult, ReplyResultSymbol, TransitionResult, getTag, isDeferReplyResult, isEffect, isReplyResult, makeDeferReply, makeReply };

package/dist/internal/utils.js

@@ -41,8 +41,8 @@ const INTERNAL_ENTER_EVENT = "$enter";
 * Extract _tag from a tagged value or constructor.
 *
 * Supports:
-* - Plain values with `_tag` (MachineSchema empty structs)
-* - Constructors with static `_tag` (MachineSchema non-empty structs)
+* - Plain values with `_tag` (`State` and `Event` empty structs)
+* - Constructors with static `_tag` (`State` and `Event` non-empty structs)
 * - Data.taggedEnum constructors (fallback via instantiation)
 */
 const getTag = (constructorOrValue) => {