effect-machine 0.15.2 → 0.16.0

package/dist/actor.d.ts

@@ -5,7 +5,7 @@ import { ActorExit, Supervision } from "./supervision.js";
 import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
 import { Lifecycle, Machine } from "./machine.js";
 import { RuntimeQueuedEvent } from "./internal/runtime.js";
-import { Deferred, Effect, Layer, Option, PubSub, Queue, Ref, Scope, ServiceMap, Stream, SubscriptionRef } from "effect";
+import { Context, Deferred, Effect, Layer, Option, PubSub, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
 
 //#region src/actor.d.ts
 /** Discriminated mailbox request — alias for RuntimeQueuedEvent */
@@ -199,7 +199,17 @@ interface ActorSystem {
 /**
  * ActorSystem service tag
  */
-declare const ActorSystem: ServiceMap.Service<ActorSystem, ActorSystem>;
+declare const ActorSystem: Context.Service<ActorSystem, ActorSystem>;
+/**
+ * Explicit scope for actor lifecycle management.
+ *
+ * When present in context, actors attach cleanup finalizers to this scope.
+ * This replaces ambient `Scope.Scope` detection which caused bugs where
+ * unrelated scopes would tear down actors unexpectedly.
+ *
+ * Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
+ */
+declare const ActorScope: Context.Service<Scope.Scope, Scope.Scope>;
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**
@@ -240,4 +250,4 @@ declare const makeSystem: () => Effect.Effect<ActorSystem, never, Scope.Scope>;
  */
 declare const Default: Layer.Layer<ActorSystem, never, never>;
 //#endregion
-export { ActorRef, ActorRefSync, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };
+export { ActorRef, ActorRefSync, ActorScope, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

package/dist/actor.js

@@ -4,7 +4,7 @@ import { emitWithTimestamp } from "./internal/inspection.js";
 import { Inspector } from "./inspection.js";
 import { materializeMachine } from "./machine.js";
 import { createRuntime } from "./internal/runtime.js";
-import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schedule, Scope, Semaphore, ServiceMap, Stream, SubscriptionRef } from "effect";
+import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schedule, Scope, Semaphore, Stream, SubscriptionRef } from "effect";
 //#region src/actor.ts
 /**
 * Actor system: spawning, lifecycle, and event processing.
@@ -17,7 +17,17 @@ import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, Pu
 /**
 * ActorSystem service tag
 */
-const ActorSystem = ServiceMap.Service("@effect/machine/ActorSystem");
+const ActorSystem = Context.Service("@effect/machine/ActorSystem");
+/**
+* Explicit scope for actor lifecycle management.
+*
+* When present in context, actors attach cleanup finalizers to this scope.
+* This replaces ambient `Scope.Scope` detection which caused bugs where
+* unrelated scopes would tear down actors unexpectedly.
+*
+* Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
+*/
+const ActorScope = Context.Service("@effect/machine/ActorScope");
 /**
 * Notify all listeners of state change.
 */
@@ -40,11 +50,19 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 	});
 	const call = Effect.fn("effect-machine.actor.call")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) {
+			yield* Effect.logWarning("effect-machine.actor.call.stopped").pipe(Effect.annotateLogs({
+				actorId: id,
+				eventTag: event._tag
+			}));
 			const currentState = yield* SubscriptionRef.get(stateRef);
 			return {
 				newState: currentState,
 				previousState: currentState,
 				transitioned: false,
+				hasReply: false,
+				deferReply: false,
+				reply: void 0,
+				postponed: false,
 				lifecycleRan: false,
 				isFinal: machine.finalStates.has(currentState._tag)
 			};
@@ -61,6 +79,10 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 			newState: currentState,
 			previousState: currentState,
 			transitioned: false,
+			hasReply: false,
+			deferReply: false,
+			reply: void 0,
+			postponed: false,
 			lifecycleRan: false,
 			isFinal: machine.finalStates.has(currentState._tag)
 		})))));
@@ -475,7 +497,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 			id,
 			actor: actorRef
 		});
-		const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+		const maybeScope = yield* Effect.serviceOption(ActorScope);
 		if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.gen(function* () {
 			if (MutableHashMap.has(actorsMap, id)) {
 				yield* emitSystemEvent({
@@ -558,4 +580,4 @@ const makeSystem = make;
 */
 const Default = Layer.effect(ActorSystem, make());
 //#endregion
-export { ActorSystem, Default, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };
+export { ActorScope, ActorSystem, Default, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

package/dist/cluster/persistence.d.ts

@@ -1,5 +1,5 @@
 import { PersistenceError, VersionConflictError } from "../errors.js";
-import { Effect, Option, Schedule, ServiceMap } from "effect";
+import { Context, Effect, Option, Schedule } from "effect";
 
 //#region src/cluster/persistence.d.ts
 /** Namespaced key preventing cross-type collisions (e.g. Order/123 vs User/123). */
@@ -44,6 +44,6 @@ interface PersistenceAdapter {
   readonly loadEvents: (key: PersistenceKey, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<unknown>>, PersistenceError>;
 }
 /** Service tag for PersistenceAdapter — resolve from context for shared infra. */
-declare const PersistenceAdapter: ServiceMap.Service<PersistenceAdapter, PersistenceAdapter>;
+declare const PersistenceAdapter: Context.Service<PersistenceAdapter, PersistenceAdapter>;
 //#endregion
 export { EntityPersistenceConfig, PersistedEvent, PersistenceAdapter, PersistenceKey, Snapshot };

package/dist/cluster/persistence.js

@@ -1,4 +1,4 @@
-import { ServiceMap } from "effect";
+import { Context } from "effect";
 //#region src/cluster/persistence.ts
 /**
 * Entity persistence types and adapter interface.
@@ -13,6 +13,6 @@ import { ServiceMap } from "effect";
 * @module
 */
 /** Service tag for PersistenceAdapter — resolve from context for shared infra. */
-const PersistenceAdapter = ServiceMap.Service("@effect-machine/cluster/PersistenceAdapter");
+const PersistenceAdapter = Context.Service("@effect-machine/cluster/PersistenceAdapter");
 //#endregion
 export { PersistenceAdapter };

package/dist/errors.d.ts

@@ -2,67 +2,67 @@ import { Schema } from "effect";
 import * as _$effect_Cause0 from "effect/Cause";
 
 //#region src/errors.d.ts
-declare const DuplicateActorError_base: Schema.ErrorClass<DuplicateActorError, Schema.TaggedStruct<"DuplicateActorError", {
+declare const DuplicateActorError_base: Schema.Class<DuplicateActorError, Schema.TaggedStruct<"DuplicateActorError", {
   readonly actorId: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** Attempted to spawn/restore actor with ID already in use */
 declare class DuplicateActorError extends DuplicateActorError_base {}
-declare const MissingSchemaError_base: Schema.ErrorClass<MissingSchemaError, Schema.TaggedStruct<"MissingSchemaError", {
+declare const MissingSchemaError_base: Schema.Class<MissingSchemaError, Schema.TaggedStruct<"MissingSchemaError", {
   readonly operation: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** Operation requires schemas attached to machine */
 declare class MissingSchemaError extends MissingSchemaError_base {}
-declare const InvalidSchemaError_base: Schema.ErrorClass<InvalidSchemaError, Schema.TaggedStruct<"InvalidSchemaError", {
+declare const InvalidSchemaError_base: Schema.Class<InvalidSchemaError, Schema.TaggedStruct<"InvalidSchemaError", {
   readonly message: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** State/Event schema has no variants */
 declare class InvalidSchemaError extends InvalidSchemaError_base {}
-declare const MissingMatchHandlerError_base: Schema.ErrorClass<MissingMatchHandlerError, Schema.TaggedStruct<"MissingMatchHandlerError", {
+declare const MissingMatchHandlerError_base: Schema.Class<MissingMatchHandlerError, Schema.TaggedStruct<"MissingMatchHandlerError", {
   readonly tag: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** $match called with missing handler for tag */
 declare class MissingMatchHandlerError extends MissingMatchHandlerError_base {}
-declare const SlotProvisionError_base: Schema.ErrorClass<SlotProvisionError, Schema.TaggedStruct<"SlotProvisionError", {
+declare const SlotProvisionError_base: Schema.Class<SlotProvisionError, Schema.TaggedStruct<"SlotProvisionError", {
   readonly slotName: Schema.String;
   readonly slotType: Schema.Literal<"slot">;
 }>, _$effect_Cause0.YieldableError>;
 /** Slot handler not found at runtime (internal error) */
 declare class SlotProvisionError extends SlotProvisionError_base {}
-declare const ProvisionValidationError_base: Schema.ErrorClass<ProvisionValidationError, Schema.TaggedStruct<"ProvisionValidationError", {
+declare const ProvisionValidationError_base: Schema.Class<ProvisionValidationError, Schema.TaggedStruct<"ProvisionValidationError", {
   readonly missing: Schema.$Array<Schema.String>;
   readonly extra: Schema.$Array<Schema.String>;
 }>, _$effect_Cause0.YieldableError>;
 /** Slot provision validation failed — missing or extra handlers */
 declare class ProvisionValidationError extends ProvisionValidationError_base {}
-declare const AssertionError_base: Schema.ErrorClass<AssertionError, Schema.TaggedStruct<"AssertionError", {
+declare const AssertionError_base: Schema.Class<AssertionError, Schema.TaggedStruct<"AssertionError", {
   readonly message: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** Assertion failed in testing utilities */
 declare class AssertionError extends AssertionError_base {}
-declare const ActorStoppedError_base: Schema.ErrorClass<ActorStoppedError, Schema.TaggedStruct<"ActorStoppedError", {
+declare const ActorStoppedError_base: Schema.Class<ActorStoppedError, Schema.TaggedStruct<"ActorStoppedError", {
   readonly actorId: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** Actor was stopped while a call/ask was pending */
 declare class ActorStoppedError extends ActorStoppedError_base {}
-declare const NoReplyError_base: Schema.ErrorClass<NoReplyError, Schema.TaggedStruct<"NoReplyError", {
+declare const NoReplyError_base: Schema.Class<NoReplyError, Schema.TaggedStruct<"NoReplyError", {
   readonly actorId: Schema.String;
   readonly eventTag: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** ask() was used but the transition handler did not call reply */
 declare class NoReplyError extends NoReplyError_base {}
-declare const PersistenceError_base: Schema.ErrorClass<PersistenceError, Schema.TaggedStruct<"PersistenceError", {
+declare const PersistenceError_base: Schema.Class<PersistenceError, Schema.TaggedStruct<"PersistenceError", {
   readonly message: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** Persistence adapter operation failed */
 declare class PersistenceError extends PersistenceError_base {}
-declare const SlotCodecError_base: Schema.ErrorClass<SlotCodecError, Schema.TaggedStruct<"SlotCodecError", {
+declare const SlotCodecError_base: Schema.Class<SlotCodecError, Schema.TaggedStruct<"SlotCodecError", {
   readonly slotName: Schema.String;
   readonly phase: Schema.Literals<readonly ["input", "output"]>;
   readonly message: Schema.String;
 }>, _$effect_Cause0.YieldableError>;
 /** Slot input/output schema validation failed */
 declare class SlotCodecError extends SlotCodecError_base {}
-declare const VersionConflictError_base: Schema.ErrorClass<VersionConflictError, Schema.TaggedStruct<"VersionConflictError", {
+declare const VersionConflictError_base: Schema.Class<VersionConflictError, Schema.TaggedStruct<"VersionConflictError", {
   readonly expected: Schema.Number;
   readonly actual: Schema.Number;
 }>, _$effect_Cause0.YieldableError>;

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { HasSlotKeys, MachineContext, ProvideSlots, Slot, SlotCall, SlotCalls, S
 import { ActorExit, CellPhase, DefectPhase, Supervision } from "./supervision.js";
 import { ProcessEventResult } from "./internal/transition.js";
 import { BackgroundEffect, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, SpawnEffect, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, machine_d_exports } from "./machine.js";
-import { ActorRef, ActorRefSync, ActorSystem, Default, SystemEvent, SystemEventListener, TransitionInfo } from "./actor.js";
+import { ActorRef, ActorRefSync, ActorScope, ActorSystem, Default, SystemEvent, SystemEventListener, TransitionInfo } from "./actor.js";
 import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
 import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-export { ActorExit, type ActorRef, type ActorRefSync, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type CellPhase, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type HasSlotKeys, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, type ProcessEventResult, type ProvideSlots, ProvisionValidationError, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotCall, type SlotCalls, SlotCodecError, type SlotFnDef, type SlotHandler, type SlotInvocation, SlotProvisionError, type SlotRequest, type SlotResult, type SlotsDef, type SlotsSchema, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };
+export { ActorExit, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type CellPhase, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type HasSlotKeys, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, type ProcessEventResult, type ProvideSlots, ProvisionValidationError, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotCall, type SlotCalls, SlotCodecError, type SlotFnDef, type SlotHandler, type SlotInvocation, SlotProvisionError, type SlotRequest, type SlotResult, type SlotsDef, type SlotsSchema, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/index.js

@@ -3,7 +3,7 @@ import { Inspector, collectingInspector, combineInspectors, consoleInspector, ma
 import { Slot } from "./slot.js";
 import { machine_exports } from "./machine.js";
 import { ActorExit, Supervision } from "./supervision.js";
-import { ActorSystem, Default } from "./actor.js";
+import { ActorScope, ActorSystem, Default } from "./actor.js";
 import { Event, State } from "./schema.js";
 import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-export { ActorExit, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotCodecError, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };
+export { ActorExit, ActorScope, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotCodecError, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/inspection.d.ts

@@ -1,4 +1,4 @@
-import { Effect, Schema, ServiceMap } from "effect";
+import { Context, Effect, Schema } from "effect";
 
 //#region src/inspection.d.ts
 /**
@@ -101,7 +101,7 @@ interface Inspector<S, E> {
  * Inspector service tag - optional service for machine introspection
  * Uses `any` types to allow variance flexibility when providing the service
  */
-declare const Inspector: ServiceMap.Service<Inspector<any, any>, Inspector<any, any>>;
+declare const Inspector: Context.Service<Inspector<any, any>, Inspector<any, any>>;
 /**
  * Create an inspector from a callback function.
  *

package/dist/inspection.js

@@ -1,10 +1,10 @@
-import { Effect, Option, ServiceMap } from "effect";
+import { Context, Effect, Option } from "effect";
 //#region src/inspection.ts
 /**
 * Inspector service tag - optional service for machine introspection
 * Uses `any` types to allow variance flexibility when providing the service
 */
-const Inspector = ServiceMap.Service("@effect/machine/Inspector");
+const Inspector = Context.Service("@effect/machine/Inspector");
 /**
 * Create an inspector from a callback function.
 *

package/dist/internal/runtime.js

@@ -40,7 +40,7 @@ import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Schema, Scope, Subscr
 */
 const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (machine, system, config) {
 	const { actorId, hooks, lifecycle } = config;
-	const services = yield* Effect.services();
+	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));

package/dist/machine.d.ts

@@ -6,11 +6,11 @@ import { MachineContext, ProvideSlots, SlotCalls, SlotsDef, SlotsSchema } from "
 import { Supervision } from "./supervision.js";
 import { findTransitions } from "./internal/transition.js";
 import { ActorRef, ActorSystem } from "./actor.js";
-import { Cause, Duration, Effect, Option, Schema, Scope, ServiceMap } from "effect";
+import { Cause, Context, Duration, Effect, Option, Schema, Scope } from "effect";
 
 //#region src/machine.d.ts
 declare namespace machine_d_exports {
-  export { BackgroundEffect, DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, spawn };
+  export { BackgroundEffect, DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, scoped, spawn };
 }
 /**
  * Self reference for sending events back to the machine
@@ -196,7 +196,7 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * Context tag for accessing machine state/event/self in slot handlers.
    * Uses shared module-level tag for all machines.
    */
-  readonly Context: ServiceMap.Service<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
+  readonly Context: Context.Service<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
   get transitions(): ReadonlyArray<Transition<State, Event, SD, R>>;
   get spawnEffects(): ReadonlyArray<SpawnEffect<State, Event, SD, R>>;
   get backgroundEffects(): ReadonlyArray<BackgroundEffect<State, Event, SD, R>>;
@@ -362,6 +362,26 @@ declare const spawn: <S extends {
   supervision?: Supervision.Policy;
   lifecycle?: Lifecycle<S, E>;
 }) => Effect.Effect<ActorRef<S, E>, never, R>;
+/**
+ * Wrap an effect to provide an `ActorScope` from the current `Scope`.
+ *
+ * Actors spawned inside will attach cleanup finalizers to this scope,
+ * so they are automatically stopped when the scope closes.
+ *
+ * @example
+ * ```ts
+ * yield* Effect.scoped(
+ *   Machine.scoped(
+ *     Effect.gen(function* () {
+ *       const actor = yield* Machine.spawn(machine);
+ *       yield* actor.start;
+ *       // actor auto-stopped when scope closes
+ *     }),
+ *   ),
+ * );
+ * ```
+ */
+declare const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Scope.Scope>;
 declare const replay: {
   <S extends {
     readonly _tag: string;
@@ -375,4 +395,4 @@ declare const replay: {
 declare const reply: <State, Reply>(state: State, reply: Reply) => ReplyResult<State, Reply>;
 declare const deferReply: <State>(state: State) => DeferReplyResult<State>;
 //#endregion
-export { BackgroundEffect, type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, spawn };
+export { BackgroundEffect, type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, scoped, spawn };

package/dist/machine.js

@@ -5,7 +5,7 @@ import { findTransitions, invalidateIndex, resolveTransition, runTransitionHandl
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { Inspector } from "./inspection.js";
 import { MachineContextTag } from "./slot.js";
-import { createActor } from "./actor.js";
+import { ActorScope, createActor } from "./actor.js";
 import { Cause, Effect, Exit, Option, Random, Schema, Scope } from "effect";
 //#region src/machine.ts
 var machine_exports = /* @__PURE__ */ __exportAll({
@@ -16,6 +16,7 @@ var machine_exports = /* @__PURE__ */ __exportAll({
 	materializeMachine: () => materializeMachine,
 	replay: () => replay,
 	reply: () => reply,
+	scoped: () => scoped,
 	spawn: () => spawn
 });
 const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspector), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
@@ -75,24 +76,6 @@ const materializeMachine = (machine, handlers) => {
 * - `SD`: Slot definitions
 */
 var Machine = class Machine {
-	initial;
-	/** @internal */ _transitions;
-	/** @internal */ _spawnEffects;
-	/** @internal */ _backgroundEffects;
-	/** @internal */ _finalStates;
-	/** @internal */ _postponeRules;
-	/** @internal */ _slotsSchema;
-	/** @internal */ _slotHandlers;
-	/** @internal */ _slots;
-	/** @internal */ _slotValidation;
-	stateSchema;
-	eventSchema;
-	/** @internal */ _replySchemas;
-	/**
-	* Context tag for accessing machine state/event/self in slot handlers.
-	* Uses shared module-level tag for all machines.
-	*/
-	Context = MachineContextTag;
 	get transitions() {
 		return this._transitions;
 	}
@@ -116,6 +99,7 @@ var Machine = class Machine {
 	}
 	/** @internal */
 	constructor(initial, stateSchema, eventSchema, slotsSchema, slotValidation = true) {
+		this.Context = MachineContextTag;
 		this.initial = initial;
 		this._transitions = [];
 		this._spawnEffects = [];
@@ -411,10 +395,30 @@ const spawn = Effect.fn("effect-machine.spawn")(function* (machine, idOrOptions)
 		supervision: opts?.supervision,
 		lifecycle: opts?.lifecycle
 	});
-	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+	const maybeScope = yield* Effect.serviceOption(ActorScope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
 	return actor;
 });
+/**
+* Wrap an effect to provide an `ActorScope` from the current `Scope`.
+*
+* Actors spawned inside will attach cleanup finalizers to this scope,
+* so they are automatically stopped when the scope closes.
+*
+* @example
+* ```ts
+* yield* Effect.scoped(
+*   Machine.scoped(
+*     Effect.gen(function* () {
+*       const actor = yield* Machine.spawn(machine);
+*       yield* actor.start;
+*       // actor auto-stopped when scope closes
+*     }),
+*   ),
+* );
+* ```
+*/
+const scoped = (effect) => Effect.flatMap(Effect.service(Scope.Scope), (scope) => Effect.provideService(effect, ActorScope, scope));
 const replay = Effect.fn("effect-machine.replay")(function* (input, events, options) {
 	const machine = materializeMachine(input, options?.slots);
 	let state = options?.from ?? machine.initial;
@@ -462,4 +466,4 @@ const replay = Effect.fn("effect-machine.replay")(function* (input, events, opti
 const reply = makeReply;
 const deferReply = makeDeferReply;
 //#endregion
-export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, spawn };
+export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, scoped, spawn };

package/dist/slot.d.ts

@@ -1,5 +1,5 @@
 import { ActorSystem } from "./actor.js";
-import { Effect, Schema, ServiceMap } from "effect";
+import { Context, Effect, Schema } from "effect";
 
 //#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
@@ -132,7 +132,7 @@ interface MachineContext<State, Event, Self> {
  * Single module-level tag instead of per-machine allocation.
  * @internal
  */
-declare const MachineContextTag: ServiceMap.Service<MachineContext<any, any, any>, MachineContext<any, any, any>>;
+declare const MachineContextTag: Context.Service<MachineContext<any, any, any>, MachineContext<any, any, any>>;
 /**
  * Define a set of slots with parameter and return schemas.
  *

package/dist/slot.js

@@ -1,4 +1,4 @@
-import { Schema, ServiceMap } from "effect";
+import { Context, Schema } from "effect";
 //#region src/slot.ts
 /**
 * Slot module — unified, schema-based parameterized slots.
@@ -62,7 +62,7 @@ const fn = (fields, returnSchema) => {
 * Single module-level tag instead of per-machine allocation.
 * @internal
 */
-const MachineContextTag = ServiceMap.Service("@effect-machine/Context");
+const MachineContextTag = Context.Service("@effect-machine/Context");
 /**
 * Define a set of slots with parameter and return schemas.
 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-machine",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
@@ -40,40 +40,44 @@
     "access": "public"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsgo --noEmit",
     "typecheck:v3": "tsc --noEmit -p v3/tsconfig.json",
-    "lint": "oxlint",
+    "lint": "concurrently -n ox,effect -c yellow,blue \"oxlint\" \"bun run lint:effect\"",
+    "lint:ox": "oxlint",
+    "lint:effect": "effect-language-service diagnostics --project tsconfig.json --lspconfig \"$(cat .effect-lsp.json)\"",
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
-    "test": "bun test",
-    "test:v3": "bun test --tsconfig-override=v3/tsconfig.json v3/test/",
+    "test": "bun test --tsconfig-override=tsconfig.json",
+    "test:v3": "cd v3 && bun test --tsconfig-override=tsconfig.json ./test/",
     "test:watch": "bun test --watch",
-    "gate": "concurrently -n type,lint,fmt,test,build -c blue,yellow,magenta,green,cyan \"bun run typecheck\" \"bun run lint:fix\" \"bun run fmt\" \"bun run test\" \"bun run build\"",
-    "prepare": "lefthook install || true && effect-language-service patch",
+    "test:all": "bun run test && bun run test:v3",
+    "gate": "concurrently -n type,lint,fmt,test,build -c blue,yellow,magenta,green,cyan \"bun run typecheck\" \"bun run lint:fix\" \"bun run fmt\" \"bun run test:all\" \"bun run build\"",
+    "prepare": "lefthook install",
     "version": "changeset version",
-    "build": "tsdown && tsdown --config v3/tsdown.config.ts",
+    "build": "concurrently -n v4,v3 -c cyan,magenta \"tsdown\" \"tsdown --config v3/tsdown.config.ts\"",
     "release": "bun run build && changeset publish"
   },
   "dependencies": {
-    "effect": "4.0.0-beta.43"
+    "effect": "4.0.0-beta.47"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.30.0",
-    "@effect/language-service": "^0.84.2",
-    "@types/bun": "1.3.11",
+    "@effect/language-service": "^0.85.1",
+    "@types/bun": "1.3.12",
+    "@typescript/native-preview": "^7.0.0-dev.20260412.1",
     "concurrently": "^9.2.1",
     "effect-bun-test": "0.3.0",
     "effect-v3": "npm:effect@^3.21.0",
-    "lefthook": "^2.1.4",
-    "oxfmt": "^0.42.0",
-    "oxlint": "^1.57.0",
+    "lefthook": "^2.1.5",
+    "oxfmt": "^0.44.0",
+    "oxlint": "^1.59.0",
     "tsdown": "^0.21.7",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "peerDependencies": {
-    "effect": ">=3.19.16"
+    "effect": ">=4.0.0-beta.47"
   },
   "peerDependenciesMeta": {
     "effect": {
@@ -81,6 +85,6 @@
     }
   },
   "overrides": {
-    "effect": "4.0.0-beta.43"
+    "effect": "4.0.0-beta.47"
   }
 }

package/v3/dist/actor.d.ts

@@ -197,6 +197,16 @@ interface ActorSystem {
  * ActorSystem service tag
  */
 declare const ActorSystem: Context.Tag<ActorSystem, ActorSystem>;
+/**
+ * Explicit scope for actor lifecycle management.
+ *
+ * When present in context, actors attach cleanup finalizers to this scope.
+ * This replaces ambient `Scope.Scope` detection which caused bugs where
+ * unrelated scopes would tear down actors unexpectedly.
+ *
+ * Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
+ */
+declare const ActorScope: Context.Tag<Scope.Scope, Scope.Scope>;
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**
@@ -237,4 +247,4 @@ declare const makeSystem: () => Effect.Effect<ActorSystem, never, Scope.Scope>;
  */
 declare const Default: Layer.Layer<ActorSystem, never, never>;
 //#endregion
-export { ActorRef, ActorRefSync, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };
+export { ActorRef, ActorRefSync, ActorScope, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

package/v3/dist/actor.js

@@ -19,6 +19,16 @@ import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, O
 */
 const ActorSystem = Context.GenericTag("@effect/machine/ActorSystem");
 /**
+* Explicit scope for actor lifecycle management.
+*
+* When present in context, actors attach cleanup finalizers to this scope.
+* This replaces ambient `Scope.Scope` detection which caused bugs where
+* unrelated scopes would tear down actors unexpectedly.
+*
+* Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
+*/
+const ActorScope = Context.GenericTag("@effect/machine/ActorScope");
+/**
 * Notify all listeners of state change.
 */
 const notifyListeners = (listeners, state) => {
@@ -40,11 +50,19 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 	});
 	const call = Effect.fn("effect-machine.actor.call")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) {
+			yield* Effect.logWarning("effect-machine.actor.call.stopped").pipe(Effect.annotateLogs({
+				actorId: id,
+				eventTag: event._tag
+			}));
 			const currentState = yield* SubscriptionRef.get(stateRef);
 			return {
 				newState: currentState,
 				previousState: currentState,
 				transitioned: false,
+				hasReply: false,
+				deferReply: false,
+				reply: void 0,
+				postponed: false,
 				lifecycleRan: false,
 				isFinal: machine.finalStates.has(currentState._tag)
 			};
@@ -61,6 +79,10 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 			newState: currentState,
 			previousState: currentState,
 			transitioned: false,
+			hasReply: false,
+			deferReply: false,
+			reply: void 0,
+			postponed: false,
 			lifecycleRan: false,
 			isFinal: machine.finalStates.has(currentState._tag)
 		})))));
@@ -469,7 +491,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 			id,
 			actor: actorRef
 		});
-		const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+		const maybeScope = yield* Effect.serviceOption(ActorScope);
 		if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.gen(function* () {
 			if (MutableHashMap.has(actorsMap, id)) {
 				yield* emitSystemEvent({
@@ -552,4 +574,4 @@ const makeSystem = make;
 */
 const Default = Layer.scoped(ActorSystem, make());
 //#endregion
-export { ActorSystem, Default, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };
+export { ActorScope, ActorSystem, Default, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

package/v3/dist/index.d.ts

@@ -5,7 +5,7 @@ import { HasSlotKeys, MachineContext, ProvideSlots, Slot, SlotCall, SlotCalls, S
 import { ActorExit, CellPhase, DefectPhase, Supervision } from "./supervision.js";
 import { ProcessEventResult } from "./internal/transition.js";
 import { BackgroundEffect, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, SpawnEffect, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, machine_d_exports } from "./machine.js";
-import { ActorRef, ActorRefSync, ActorSystem, Default, SystemEvent, SystemEventListener, TransitionInfo } from "./actor.js";
+import { ActorRef, ActorRefSync, ActorScope, ActorSystem, Default, SystemEvent, SystemEventListener, TransitionInfo } from "./actor.js";
 import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
 import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-export { ActorExit, type ActorRef, type ActorRefSync, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type CellPhase, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type HasSlotKeys, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, type ProcessEventResult, type ProvideSlots, ProvisionValidationError, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotCall, type SlotCalls, SlotCodecError, type SlotFnDef, type SlotHandler, type SlotInvocation, SlotProvisionError, type SlotRequest, type SlotResult, type SlotsDef, type SlotsSchema, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };
+export { ActorExit, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type CellPhase, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type HasSlotKeys, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, type ProcessEventResult, type ProvideSlots, ProvisionValidationError, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotCall, type SlotCalls, SlotCodecError, type SlotFnDef, type SlotHandler, type SlotInvocation, SlotProvisionError, type SlotRequest, type SlotResult, type SlotsDef, type SlotsSchema, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/v3/dist/index.js

@@ -3,7 +3,7 @@ import { Inspector, collectingInspector, combineInspectors, consoleInspector, ma
 import { Slot } from "./slot.js";
 import { machine_exports } from "./machine.js";
 import { ActorExit, Supervision } from "./supervision.js";
-import { ActorSystem, Default } from "./actor.js";
+import { ActorScope, ActorSystem, Default } from "./actor.js";
 import { Event, State } from "./schema.js";
 import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-export { ActorExit, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotCodecError, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };
+export { ActorExit, ActorScope, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotCodecError, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/v3/dist/machine.d.ts

@@ -10,7 +10,7 @@ import { Cause, Context, Duration, Effect, Option, Schema, Scope } from "effect"
 
 //#region src/machine.d.ts
 declare namespace machine_d_exports {
-  export { BackgroundEffect, DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, spawn };
+  export { BackgroundEffect, DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, scoped, spawn };
 }
 /**
  * Self reference for sending events back to the machine
@@ -362,6 +362,26 @@ declare const spawn: <S extends {
   supervision?: Supervision.Policy;
   lifecycle?: Lifecycle<S, E>;
 }) => Effect.Effect<ActorRef<S, E>, never, R>;
+/**
+ * Wrap an effect to provide an `ActorScope` from the current `Scope`.
+ *
+ * Actors spawned inside will attach cleanup finalizers to this scope,
+ * so they are automatically stopped when the scope closes.
+ *
+ * @example
+ * ```ts
+ * yield* Effect.scoped(
+ *   Machine.scoped(
+ *     Effect.gen(function* () {
+ *       const actor = yield* Machine.spawn(machine);
+ *       yield* actor.start;
+ *       // actor auto-stopped when scope closes
+ *     }),
+ *   ),
+ * );
+ * ```
+ */
+declare const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Scope.Scope>;
 declare const replay: {
   <S extends {
     readonly _tag: string;
@@ -375,4 +395,4 @@ declare const replay: {
 declare const reply: <State, Reply>(state: State, reply: Reply) => ReplyResult<State, Reply>;
 declare const deferReply: <State>(state: State) => DeferReplyResult<State>;
 //#endregion
-export { BackgroundEffect, type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, spawn };
+export { BackgroundEffect, type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, scoped, spawn };

package/v3/dist/machine.js

@@ -5,7 +5,7 @@ import { findTransitions, invalidateIndex, resolveTransition, runTransitionHandl
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { Inspector } from "./inspection.js";
 import { MachineContextTag } from "./slot.js";
-import { createActor } from "./actor.js";
+import { ActorScope, createActor } from "./actor.js";
 import { Cause, Effect, Exit, Option, Random, Schema, Scope } from "effect";
 //#region src/machine.ts
 var machine_exports = /* @__PURE__ */ __exportAll({
@@ -16,6 +16,7 @@ var machine_exports = /* @__PURE__ */ __exportAll({
 	materializeMachine: () => materializeMachine,
 	replay: () => replay,
 	reply: () => reply,
+	scoped: () => scoped,
 	spawn: () => spawn
 });
 const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspector), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
@@ -411,10 +412,30 @@ const spawn = Effect.fn("effect-machine.spawn")(function* (machine, idOrOptions)
 		supervision: opts?.supervision,
 		lifecycle: opts?.lifecycle
 	});
-	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+	const maybeScope = yield* Effect.serviceOption(ActorScope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
 	return actor;
 });
+/**
+* Wrap an effect to provide an `ActorScope` from the current `Scope`.
+*
+* Actors spawned inside will attach cleanup finalizers to this scope,
+* so they are automatically stopped when the scope closes.
+*
+* @example
+* ```ts
+* yield* Effect.scoped(
+*   Machine.scoped(
+*     Effect.gen(function* () {
+*       const actor = yield* Machine.spawn(machine);
+*       yield* actor.start;
+*       // actor auto-stopped when scope closes
+*     }),
+*   ),
+* );
+* ```
+*/
+const scoped = (effect) => Effect.flatMap(Scope.Scope, (scope) => Effect.provideService(effect, ActorScope, scope));
 const replay = Effect.fn("effect-machine.replay")(function* (input, events, options) {
 	const machine = materializeMachine(input, options?.slots);
 	let state = options?.from ?? machine.initial;
@@ -462,4 +483,4 @@ const replay = Effect.fn("effect-machine.replay")(function* (input, events, opti
 const reply = makeReply;
 const deferReply = makeDeferReply;
 //#endregion
-export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, spawn };
+export { Machine, deferReply, findTransitions, machine_exports, make, materializeMachine, replay, reply, scoped, spawn };