effect-machine 0.7.2 → 0.9.0

package/dist/internal/transition.js

@@ -1,7 +1,6 @@
 import { INTERNAL_ENTER_EVENT, isEffect } from "./utils.js";
 import { BuiltMachine } from "../machine.js";
 import { Cause, Effect, Exit, Scope } from "effect";
-
 //#region src/internal/transition.ts
 /**
 * Transition execution and indexing.
@@ -23,8 +22,9 @@ import { Cause, Effect, Exit, Scope } from "effect";
 *
 * @internal
 */
-const runTransitionHandler = Effect.fn("effect-machine.runTransitionHandler")(function* (machine, transition, state, event, self, system) {
+const runTransitionHandler = Effect.fn("effect-machine.runTransitionHandler")(function* (machine, transition, state, event, self, system, actorId) {
 	const ctx = {
+		actorId,
 		state,
 		event,
 		self,
@@ -51,7 +51,7 @@ const runTransitionHandler = Effect.fn("effect-machine.runTransitionHandler")(fu
 *
 * @internal
 */
-const executeTransition = Effect.fn("effect-machine.executeTransition")(function* (machine, currentState, event, self, system) {
+const executeTransition = Effect.fn("effect-machine.executeTransition")(function* (machine, currentState, event, self, system, actorId) {
 	const transition = resolveTransition(machine, currentState, event);
 	if (transition === void 0) return {
 		newState: currentState,
@@ -59,7 +59,7 @@ const executeTransition = Effect.fn("effect-machine.executeTransition")(function
 		reenter: false
 	};
 	return {
-		newState: yield* runTransitionHandler(machine, transition, currentState, event, self, system),
+		newState: yield* runTransitionHandler(machine, transition, currentState, event, self, system, actorId),
 		transitioned: true,
 		reenter: transition.reenter === true
 	};
@@ -76,8 +76,8 @@ const executeTransition = Effect.fn("effect-machine.executeTransition")(function
 *
 * @internal
 */
-const processEventCore = Effect.fn("effect-machine.processEventCore")(function* (machine, currentState, event, self, stateScopeRef, system, hooks) {
-	const result = yield* executeTransition(machine, currentState, event, self, system).pipe(Effect.catchCause((cause) => {
+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);
@@ -102,7 +102,7 @@ const processEventCore = Effect.fn("effect-machine.processEventCore")(function*
 		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, hooks?.onError);
+		yield* runSpawnEffects(machine, newState, { _tag: INTERNAL_ENTER_EVENT }, self, stateScopeRef.current, system, actorId, hooks?.onError);
 	}
 	return {
 		newState,
@@ -117,9 +117,10 @@ const processEventCore = Effect.fn("effect-machine.processEventCore")(function*
 *
 * @internal
 */
-const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (machine, state, event, self, stateScope, system, onError) {
+const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (machine, state, event, self, stateScope, system, actorId, onError) {
 	const spawnEffects = findSpawnEffects(machine, state._tag);
 	const ctx = {
+		actorId,
 		state,
 		event,
 		self,
@@ -129,6 +130,7 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 	const reportError = onError;
 	for (const spawnEffect of spawnEffects) {
 		const effect = spawnEffect.handler({
+			actorId,
 			state,
 			event,
 			self,
@@ -233,6 +235,5 @@ const findTransitions = (input, stateTag, eventTag) => {
 const findSpawnEffects = (machine, stateTag) => {
 	return getIndex(machine).spawn.get(stateTag) ?? [];
 };
-
 //#endregion
-export { executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler };
+export { executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler };

package/dist/internal/utils.js

@@ -1,5 +1,4 @@
 import { Effect, Stream } from "effect";
-
 //#region src/internal/utils.ts
 /**
 * Internal utilities for effect-machine.
@@ -50,6 +49,5 @@ const stubSystem = {
 	restoreMany: () => Effect.die("restoreMany not supported in stub system"),
 	restoreAll: () => Effect.die("restoreAll not supported in stub system")
 };
-
 //#endregion
-export { INTERNAL_ENTER_EVENT, INTERNAL_INIT_EVENT, getTag, isEffect, stubSystem };
+export { INTERNAL_ENTER_EVENT, INTERNAL_INIT_EVENT, getTag, isEffect, stubSystem };

package/dist/machine.d.ts

@@ -5,13 +5,12 @@ import { MachineEventSchema, MachineStateSchema, VariantsUnion } from "./schema.
 import { PersistenceConfig, PersistentMachine } from "./persistence/persistent-machine.js";
 import { DuplicateActorError } from "./errors.js";
 import { findTransitions } from "./internal/transition.js";
-import "./persistence/index.js";
 import { ActorRef, ActorSystem } from "./actor.js";
 import { Cause, Effect, Schedule, Schema, Scope, ServiceMap } from "effect";
 
 //#region src/machine.d.ts
 declare namespace machine_d_exports {
-  export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, PersistenceConfig, PersistentMachine, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, Transition, TransitionHandler, findTransitions, make, spawn };
+  export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, PersistenceConfig, PersistentMachine, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, Transition, TransitionHandler, findTransitions, make, spawn };
 }
 /**
  * Self reference for sending events back to the machine
@@ -37,6 +36,7 @@ interface HandlerContext<State, Event, GD extends GuardsDef, ED extends EffectsD
  * Handler context passed to state effect handlers (onEnter, spawn, background)
  */
 interface StateHandlerContext<State, Event, ED extends EffectsDef> {
+  readonly actorId: string;
   readonly state: State;
   readonly event: Event;
   readonly self: MachineRef<Event>;
@@ -81,6 +81,11 @@ interface PersistOptions {
   readonly journalEvents: boolean;
   readonly machineType?: string;
 }
+interface TaskOptions<State, Event, ED extends EffectsDef, A, E1, ES, EF> {
+  readonly onSuccess: (value: A, ctx: StateHandlerContext<State, Event, ED>) => ES;
+  readonly onFailure?: (cause: Cause.Cause<E1>, ctx: StateHandlerContext<State, Event, ED>) => EF;
+  readonly name?: string;
+}
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false;
 type NormalizeR<T> = IsAny<T> extends true ? T : IsUnknown<T> extends true ? never : T;
@@ -174,6 +179,10 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
   get effectsSchema(): EffectsSchema<EFD> | undefined;
   /** @internal */
   constructor(initial: State, stateSchema?: Schema.Schema<State>, eventSchema?: Schema.Schema<Event>, guardsSchema?: GuardsSchema<GD>, effectsSchema?: EffectsSchema<EFD>);
+  from<NS extends VariantsUnion<_SD> & BrandedState, R1>(state: TaggedOrConstructor<NS>, build: (scope: TransitionScope<State, Event, R, _SD, _ED, GD, EFD, NS>) => R1): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  from<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, R1>(states: NS, build: (scope: TransitionScope<State, Event, R, _SD, _ED, GD, EFD, NS[number] extends TaggedOrConstructor<infer S extends VariantsUnion<_SD> & BrandedState> ? S : never>) => R1): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  /** @internal */
+  scopeTransition<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(states: ReadonlyArray<TaggedOrConstructor<NS>>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, GD, EFD, never>, reenter: boolean): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /** Register transition for a single state */
   on<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, GD, EFD, never>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /** Register transition for multiple states (handler receives union of state types) */
@@ -220,10 +229,7 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * State-scoped task that runs on entry and sends success/failure events.
    * Interrupts do not emit failure events.
    */
-  task<NS extends VariantsUnion<_SD> & BrandedState, A, E1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(state: TaggedOrConstructor<NS>, run: (ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, EFD>) => Effect.Effect<A, E1, Scope.Scope>, options: {
-    readonly onSuccess: (value: A, ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, EFD>) => ES;
-    readonly onFailure?: (cause: Cause.Cause<E1>, ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, EFD>) => EF;
-  }): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  task<NS extends VariantsUnion<_SD> & BrandedState, A, E1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(state: TaggedOrConstructor<NS>, run: (ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, EFD>) => Effect.Effect<A, E1, Scope.Scope>, options: TaskOptions<NS, VariantsUnion<_ED> & BrandedEvent, EFD, A, E1, ES, EF>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /**
    * Machine-lifetime effect that is forked on actor spawn and runs until the actor stops.
    * Use effect slots defined via `Slot.Effects` for the actual work.
@@ -261,6 +267,13 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
   }, R>;
   static make<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(config: MakeConfig<SD, ED, S, E, GD, EFD>): Machine<S, E, never, SD, ED, GD, EFD>;
 }
+declare class TransitionScope<State, Event, R, _SD extends Record<string, Schema.Struct.Fields>, _ED extends Record<string, Schema.Struct.Fields>, GD extends GuardsDef, EFD extends EffectsDef, SelectedState extends VariantsUnion<_SD> & BrandedState> {
+  private readonly machine;
+  private readonly states;
+  constructor(machine: Machine<State, Event, R, _SD, _ED, GD, EFD>, states: ReadonlyArray<TaggedOrConstructor<SelectedState>>);
+  on<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, GD, EFD, never>): TransitionScope<State, Event, R, _SD, _ED, GD, EFD, SelectedState>;
+  reenter<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, GD, EFD, never>): TransitionScope<State, Event, R, _SD, _ED, GD, EFD, SelectedState>;
+}
 declare const make: typeof Machine.make;
 declare const spawn: {
   <S extends {
@@ -275,4 +288,4 @@ declare const spawn: {
   }, R>(machine: BuiltMachine<S, E, R>, id: string): Effect.Effect<ActorRef<S, E>, never, R>;
 };
 //#endregion
-export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, type PersistenceConfig, type PersistentMachine, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, Transition, TransitionHandler, findTransitions, machine_d_exports, make, spawn };
+export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, type PersistenceConfig, type PersistentMachine, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, Transition, TransitionHandler, findTransitions, machine_d_exports, make, spawn };

package/dist/machine.js

@@ -1,12 +1,13 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Inspector } from "./inspection.js";
 import { getTag } from "./internal/utils.js";
 import { ProvisionValidationError, SlotProvisionError } from "./errors.js";
 import { persist } from "./persistence/persistent-machine.js";
+import { emitWithTimestamp } from "./internal/inspection.js";
 import { MachineContextTag } from "./slot.js";
 import { findTransitions, invalidateIndex } from "./internal/transition.js";
 import { createActor } from "./actor.js";
 import { Cause, Effect, Exit, Option, Scope } from "effect";
-
 //#region src/machine.ts
 var machine_exports = /* @__PURE__ */ __exportAll({
 	BuiltMachine: () => BuiltMachine,
@@ -15,6 +16,15 @@ var machine_exports = /* @__PURE__ */ __exportAll({
 	make: () => make,
 	spawn: () => spawn
 });
+const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspector), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
+	type: "@machine.task",
+	actorId: input.actorId,
+	state: input.state,
+	taskName: input.taskName,
+	phase: input.phase,
+	error: input.error,
+	timestamp
+})));
 /**
 * A finalized machine ready for spawning.
 *
@@ -121,6 +131,15 @@ var Machine = class Machine {
 			})) : {}
 		};
 	}
+	from(stateOrStates, build) {
+		build(new TransitionScope(this, Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates]));
+		return this;
+	}
+	/** @internal */
+	scopeTransition(states, event, handler, reenter) {
+		for (const state of states) this.addTransition(state, event, handler, reenter);
+		return this;
+	}
 	on(stateOrStates, event, handler) {
 		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
 		for (const s of states) this.addTransition(s, event, handler, false);
@@ -195,14 +214,41 @@ var Machine = class Machine {
 	*/
 	task(state, run, options) {
 		const handler = Effect.fn("effect-machine.task")(function* (ctx) {
+			yield* emitTaskInspection({
+				actorId: ctx.actorId,
+				state: ctx.state,
+				taskName: options.name,
+				phase: "start"
+			});
 			const exit = yield* Effect.exit(run(ctx));
 			if (Exit.isSuccess(exit)) {
+				yield* emitTaskInspection({
+					actorId: ctx.actorId,
+					state: ctx.state,
+					taskName: options.name,
+					phase: "success"
+				});
 				yield* ctx.self.send(options.onSuccess(exit.value, ctx));
 				yield* Effect.yieldNow;
 				return;
 			}
 			const cause = exit.cause;
-			if (Cause.hasInterruptsOnly(cause)) return;
+			if (Cause.hasInterruptsOnly(cause)) {
+				yield* emitTaskInspection({
+					actorId: ctx.actorId,
+					state: ctx.state,
+					taskName: options.name,
+					phase: "interrupt"
+				});
+				return;
+			}
+			yield* emitTaskInspection({
+				actorId: ctx.actorId,
+				state: ctx.state,
+				taskName: options.name,
+				phase: "failure",
+				error: Cause.pretty(cause)
+			});
 			if (options.onFailure !== void 0) {
 				yield* ctx.self.send(options.onFailure(cause, ctx));
 				yield* Effect.yieldNow;
@@ -282,40 +328,26 @@ var Machine = class Machine {
 		return new Machine(config.initial, config.state, config.event, config.guards, config.effects);
 	}
 };
+var TransitionScope = class {
+	constructor(machine, states) {
+		this.machine = machine;
+		this.states = states;
+	}
+	on(event, handler) {
+		this.machine.scopeTransition(this.states, event, handler, false);
+		return this;
+	}
+	reenter(event, handler) {
+		this.machine.scopeTransition(this.states, event, handler, true);
+		return this;
+	}
+};
 const make = Machine.make;
-/**
-* Spawn an actor directly without ActorSystem ceremony.
-* Accepts only `BuiltMachine` (call `.build()` first).
-*
-* **Single actor, no registry.** Caller manages lifetime via `actor.stop`.
-* If a `Scope` exists in context, cleanup attaches automatically on scope close.
-*
-* For registry, lookup by ID, persistence, or multi-actor coordination,
-* use `ActorSystemService` / `system.spawn` instead.
-*
-* @example
-* ```ts
-* // Fire-and-forget — caller manages lifetime
-* const actor = yield* Machine.spawn(machine.build());
-* yield* actor.send(Event.Start);
-* yield* actor.awaitFinal;
-* yield* actor.stop;
-*
-* // Scope-aware — auto-cleans up on scope close
-* yield* Effect.scoped(Effect.gen(function* () {
-*   const actor = yield* Machine.spawn(machine.build());
-*   yield* actor.send(Event.Start);
-*   // actor.stop called automatically when scope closes
-* }));
-* ```
-*/
-const spawnImpl = Effect.fn("effect-machine.spawn")(function* (built, id) {
+const spawn = Effect.fn("effect-machine.spawn")(function* (built, id) {
 	const actor = yield* createActor(id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner);
 	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
 	return actor;
 });
-const spawn = spawnImpl;
-
 //#endregion
-export { BuiltMachine, Machine, findTransitions, machine_exports, make, spawn };
+export { BuiltMachine, Machine, findTransitions, machine_exports, make, spawn };

package/dist/persistence/adapter.js

@@ -1,5 +1,4 @@
 import { Schema, ServiceMap } from "effect";
-
 //#region src/persistence/adapter.ts
 /**
 * Error type for persistence operations
@@ -22,6 +21,5 @@ var VersionConflictError = class extends Schema.TaggedErrorClass()("VersionConfl
 * PersistenceAdapter service tag
 */
 var PersistenceAdapterTag = class extends ServiceMap.Service()("effect-machine/src/persistence/adapter/PersistenceAdapterTag") {};
-
 //#endregion
-export { PersistenceAdapterTag, PersistenceError, VersionConflictError };
+export { PersistenceAdapterTag, PersistenceError, VersionConflictError };

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,10 @@
 import { Inspector } from "../inspection.js";
 import { INTERNAL_INIT_EVENT, stubSystem } from "../internal/utils.js";
-import { processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler } from "../internal/transition.js";
 import { emitWithTimestamp } from "../internal/inspection.js";
+import { processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler } 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 { 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 +19,7 @@ const replayEvents = Effect.fn("effect-machine.persistentActor.replayEvents")(fu
 	for (const persistedEvent of events) {
 		if (stopVersion !== void 0 && persistedEvent.version > stopVersion) break;
 		const transition = resolveTransition(machine, state, persistedEvent.event);
-		if (transition !== void 0) state = yield* runTransitionHandler(machine, transition, state, persistedEvent.event, self, stubSystem);
+		if (transition !== void 0) state = yield* runTransitionHandler(machine, transition, state, persistedEvent.event, self, stubSystem, "restore");
 		version = persistedEvent.version;
 	}
 	return {
@@ -96,7 +95,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	const self = {
 		send: Effect.fn("effect-machine.persistentActor.self.send")(function* (event) {
 			if (yield* Ref.get(stoppedRef)) return;
-			yield* Queue.offer(eventQueue, event);
+			yield* Queue.offer(eventQueue, { event });
 		}),
 		spawn: (childId, childMachine) => Effect.gen(function* () {
 			const child = yield* system.spawn(childId, childMachine).pipe(Effect.provideService(ActorSystem, system));
@@ -146,6 +145,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	const backgroundFibers = [];
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
 	const initCtx = {
+		actorId: id,
 		state: resolvedInitial,
 		event: initEvent,
 		self,
@@ -154,6 +154,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	const { effects: effectSlots } = typedMachine._slots;
 	for (const bg of typedMachine.backgroundEffects) {
 		const fiber = yield* Effect.forkDetach(bg.handler({
+			actorId: id,
 			state: resolvedInitial,
 			event: initEvent,
 			self,
@@ -228,7 +229,7 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 		}))
 	};
 	while (true) {
-		const event = yield* Queue.take(eventQueue);
+		const { event, reply } = yield* Queue.take(eventQueue);
 		const currentState = yield* SubscriptionRef.get(stateRef);
 		const currentVersion = yield* Ref.get(versionRef);
 		yield* emitWithTimestamp(inspector, (timestamp) => ({
@@ -238,7 +239,8 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 			event,
 			timestamp
 		}));
-		const result = yield* processEventCore(typedMachine, currentState, event, self, stateScopeRef, system, hooks);
+		const result = yield* processEventCore(typedMachine, currentState, event, self, stateScopeRef, system, id, hooks);
+		if (reply !== void 0) yield* Deferred.succeed(reply, result);
 		if (!result.transitioned) continue;
 		const newVersion = currentVersion + 1;
 		yield* Ref.set(versionRef, newVersion);
@@ -286,7 +288,7 @@ const runSpawnEffectsWithInspection = Effect.fn("effect-machine.persistentActor.
 		state,
 		timestamp
 	}));
-	yield* runSpawnEffects(machine, state, event, self, stateScope, system, inspector === void 0 ? void 0 : (info) => emitWithTimestamp(inspector, (timestamp) => ({
+	yield* runSpawnEffects(machine, state, event, self, stateScope, system, actorId, inspector === void 0 ? void 0 : (info) => emitWithTimestamp(inspector, (timestamp) => ({
 		type: "@machine.error",
 		actorId,
 		phase: info.phase,
@@ -362,6 +364,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.
@@ -42,6 +41,7 @@ import { Schema } from "effect";
 /**
 * Build a schema-first definition from a record of tag -> fields
 */
+const RESERVED_DERIVE_KEYS = new Set(["_tag"]);
 const buildMachineSchema = (definition) => {
 	const variants = {};
 	const constructors = {};
@@ -59,7 +59,10 @@ const buildMachineSchema = (definition) => {
 			constructor.derive = (source, partial) => {
 				const result = { _tag: tag };
 				for (const key of fieldNames) if (key in source) result[key] = source[key];
-				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) result[key] = value;
+				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) {
+					if (RESERVED_DERIVE_KEYS.has(key)) continue;
+					result[key] = value;
+				}
 				return result;
 			};
 			constructors[tag] = constructor;
@@ -160,6 +163,5 @@ const State = (definition) => createMachineSchema(definition);
 * ```
 */
 const Event = (definition) => createMachineSchema(definition);
-
 //#endregion
-export { Event, State };
+export { Event, State };

package/dist/slot.d.ts

@@ -43,6 +43,7 @@ type EffectSlots<D extends EffectsDef> = { readonly [K in keyof D & string]: Eff
  * Shared across all machines via MachineContextTag.
  */
 interface MachineContext<State, Event, Self> {
+  readonly actorId: string;
   readonly state: State;
   readonly event: Event;
   readonly self: Self;

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

@@ -3,7 +3,6 @@ import { AssertionError } from "./errors.js";
 import { BuiltMachine } from "./machine.js";
 import { executeTransition } 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.
@@ -34,7 +33,7 @@ const simulate = Effect.fn("effect-machine.simulate")(function* (input, events)
 	let currentState = machine.initial;
 	const states = [currentState];
 	for (const event of events) {
-		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "simulation");
 		if (!result.transitioned) continue;
 		currentState = result.newState;
 		states.push(currentState);
@@ -123,7 +122,7 @@ const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function
 		state: stateRef,
 		send: Effect.fn("effect-machine.testHarness.send")(function* (event) {
 			const currentState = yield* SubscriptionRef.get(stateRef);
-			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "test-harness");
 			if (!result.transitioned) return currentState;
 			const newState = result.newState;
 			yield* SubscriptionRef.set(stateRef, newState);
@@ -133,6 +132,5 @@ const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function
 		getState: SubscriptionRef.get(stateRef)
 	};
 });
-
 //#endregion
-export { AssertionError, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate };
+export { AssertionError, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate };

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

@@ -2,17 +2,12 @@
 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" });
-	}
+	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 };
+export { __exportAll };

package/dist-v3/actor.js

@@ -7,7 +7,6 @@ import { emitWithTimestamp } from "./internal/inspection.js";
 import { PersistenceAdapterTag, PersistenceError } from "./persistence/adapter.js";
 import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
 import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Runtime, Scope, Stream, SubscriptionRef } from "effect";
-
 //#region src-v3/actor.ts
 /**
 * Actor system: spawning, lifecycle, and event processing.
@@ -454,6 +453,5 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 * Default ActorSystem layer
 */
 const Default = Layer.scoped(ActorSystem, make());
-
 //#endregion
-export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };
+export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };

package/dist-v3/cluster/entity-machine.d.ts

@@ -1,7 +1,6 @@
 import { EffectsDef, GuardsDef } from "../slot.js";
 import { ProcessEventHooks } from "../internal/transition.js";
 import { Machine } from "../machine.js";
-import "../actor.js";
 import { Layer } from "effect";
 import { Entity } from "@effect/cluster";
 import { Rpc } from "@effect/rpc";

package/dist-v3/cluster/entity-machine.js

@@ -2,7 +2,6 @@ import { processEventCore, runSpawnEffects } from "../internal/transition.js";
 import { ActorSystem } from "../actor.js";
 import { Effect, Option, Queue, Ref, Scope } from "effect";
 import { Entity } from "@effect/cluster";
-
 //#region src-v3/cluster/entity-machine.ts
 /**
 * EntityMachine adapter - wires a machine to a cluster Entity layer.
@@ -75,6 +74,5 @@ const EntityMachine = { layer: (entity, machine, options) => {
 	});
 	return entity.toLayer(layer());
 } };
-
 //#endregion
-export { EntityMachine };
+export { EntityMachine };

package/dist-v3/cluster/index.js

@@ -1,4 +1,3 @@
 import { EntityMachine } from "./entity-machine.js";
 import { toEntity } from "./to-entity.js";
-
-export { EntityMachine, toEntity };
+export { EntityMachine, toEntity };

package/dist-v3/cluster/to-entity.js

@@ -1,7 +1,6 @@
 import { MissingSchemaError } from "../errors.js";
 import { Entity } from "@effect/cluster";
 import { Rpc } from "@effect/rpc";
-
 //#region src-v3/cluster/to-entity.ts
 /**
 * Generate Entity definition from a machine.
@@ -48,6 +47,5 @@ const toEntity = (machine, options) => {
 		success: stateSchema
 	}), Rpc.make("GetState", { success: stateSchema })]);
 };
-
 //#endregion
-export { toEntity };
+export { toEntity };

package/dist-v3/errors.js

@@ -1,5 +1,4 @@
 import { Schema } from "effect";
-
 //#region src-v3/errors.ts
 /**
 * Typed error classes for effect-machine.
@@ -33,6 +32,5 @@ var ProvisionValidationError = class extends Schema.TaggedError()("ProvisionVali
 }) {};
 /** Assertion failed in testing utilities */
 var AssertionError = class extends Schema.TaggedError()("AssertionError", { message: Schema.String }) {};
-
 //#endregion
-export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };
+export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };