effect-machine 0.15.2 → 0.17.0

package/README.md

@@ -17,6 +17,10 @@ Use it when a feature has:
 bun add effect-machine effect
 ```
 
+`effect` is a peer dependency. The repository validates both the v4 entrypoint
+and the `effect-machine/v3` mirror with `@effect/tsgo`, the latest Effect beta,
+type-aware oxlint, and Bun tests.
+
 ## Core Pattern
 
 States and events are schemas. Types, validation, and serialization from one place.

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 */
@@ -120,7 +120,7 @@ interface ActorRef<State extends {
   /** Sync helpers for non-Effect boundaries. */
   readonly sync: ActorRefSync<State, Event>;
   /** The actor system this actor belongs to. */
-  readonly system: ActorSystem;
+  readonly system: ActorSystemService;
   /** Child actors spawned via `self.spawn` in this actor's handlers. */
   readonly children: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
 }
@@ -154,7 +154,7 @@ type SystemEventListener = (event: SystemEvent) => void;
 /**
  * Actor system for managing actor lifecycles
  */
-interface ActorSystem {
+interface ActorSystemService {
   /**
    * Spawn a new actor with the given machine.
    *
@@ -196,10 +196,22 @@ interface ActorSystem {
    */
   readonly subscribe: (fn: SystemEventListener) => () => void;
 }
+declare const ActorSystem_base: Context.ServiceClass<ActorSystem, "effect-machine/actor/ActorSystem", ActorSystemService>;
 /**
  * ActorSystem service tag
  */
-declare const ActorSystem: ServiceMap.Service<ActorSystem, ActorSystem>;
+declare class ActorSystem extends ActorSystem_base {}
+declare const ActorScope_base: Context.ServiceClass<ActorScope, "effect-machine/actor/ActorScope", Scope.Scope>;
+/**
+ * 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 class ActorScope extends ActorScope_base {}
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**
@@ -213,7 +225,7 @@ declare const buildActorRefCore: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(id: string, machine: Machine<S, E, R, any, any, SD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueueRef: Ref.Ref<Queue.Queue<QueuedEvent<E>>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, start: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, transitionsPubSub: PubSub.PubSub<TransitionInfo<S, E>> | undefined, exitDeferred: Deferred.Deferred<ActorExit<S>, never>) => ActorRef<S, E>;
+}, R, SD extends SlotsDef>(id: string, machine: Machine<S, E, R, any, any, SD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueueRef: Ref.Ref<Queue.Queue<QueuedEvent<E>>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, start: Effect.Effect<void>, system: ActorSystemService, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, transitionsPubSub: PubSub.PubSub<TransitionInfo<S, E>> | undefined, exitDeferred: Deferred.Deferred<ActorExit<S>>) => ActorRef<S, E>;
 /**
  * Create and start an actor for a machine.
  * Delegates to the shared runtime kernel with actor-specific lifecycle hooks.
@@ -234,10 +246,10 @@ declare const settlePendingReplies: (pendingReplies: Set<Deferred.Deferred<unkno
  * Create an ActorSystem instance. Must be run in a Scope.
  * @internal — use Default layer for normal usage
  */
-declare const makeSystem: () => Effect.Effect<ActorSystem, never, Scope.Scope>;
+declare const makeSystem: () => Effect.Effect<ActorSystemService, never, Scope.Scope>;
 /**
  * Default ActorSystem layer
  */
 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, ActorSystemService, 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");
+var ActorSystem = class extends Context.Service()("effect-machine/actor/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)`.
+*/
+var ActorScope = class extends Context.Service()("effect-machine/actor/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/adapters/in-memory.d.ts

@@ -1,4 +1,4 @@
-import { PersistedEvent, PersistenceAdapter, Snapshot } from "../persistence.js";
+import { PersistedEvent, PersistenceAdapter, PersistenceAdapterService, Snapshot } from "../persistence.js";
 import { Effect, Layer, Ref } from "effect";
 
 //#region src/cluster/adapters/in-memory.d.ts
@@ -9,18 +9,18 @@ interface EntityStore {
 /**
  * Create an in-memory persistence adapter.
  *
- * Returns a Layer providing `PersistenceAdapter` and a ref
+ * Returns a Layer providing `PersistenceAdapterService` and a ref
  * to the backing store for test assertions.
  *
  * @example
  * ```ts
  * const { layer, storeRef } = yield* makeInMemoryPersistenceAdapter
- * // Use layer to provide PersistenceAdapter
+ * // Use layer to provide PersistenceAdapterService
  * // Inspect storeRef for test assertions
  * ```
  */
 declare const makeInMemoryPersistenceAdapter: Effect.Effect<{
-  adapter: PersistenceAdapter;
+  adapter: PersistenceAdapterService;
   storeRef: Ref.Ref<Map<string, EntityStore>>;
   layer: Layer.Layer<PersistenceAdapter, never, never>;
 }, never, never>;

package/dist/cluster/adapters/in-memory.js

@@ -26,13 +26,13 @@ const getOrCreate = (store, key) => {
 /**
 * Create an in-memory persistence adapter.
 *
-* Returns a Layer providing `PersistenceAdapter` and a ref
+* Returns a Layer providing `PersistenceAdapterService` and a ref
 * to the backing store for test assertions.
 *
 * @example
 * ```ts
 * const { layer, storeRef } = yield* makeInMemoryPersistenceAdapter
-* // Use layer to provide PersistenceAdapter
+* // Use layer to provide PersistenceAdapterService
 * // Inspect storeRef for test assertions
 * ```
 */

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

@@ -38,9 +38,9 @@ interface EntityMachineOptions<S, E> {
    * Retry policy for defects (schedule for restarting after defect).
    * Forwarded to Entity.toLayerQueue.
    */
-  readonly defectRetryPolicy?: Schedule.Schedule<any, unknown>;
+  readonly defectRetryPolicy?: Schedule.Schedule<any>;
   /**
-   * Persistence configuration. When set, requires PersistenceAdapter in R.
+   * Persistence configuration. When set, requires PersistenceAdapterService in R.
    */
   readonly persistence?: EntityPersistenceConfig;
 }

package/dist/cluster/index.d.ts

@@ -1,6 +1,6 @@
-import { EntityPersistenceConfig, PersistedEvent, PersistenceAdapter, PersistenceKey, Snapshot } from "./persistence.js";
+import { EntityPersistenceConfig, PersistedEvent, PersistenceAdapter, PersistenceAdapterService, PersistenceKey, Snapshot } from "./persistence.js";
 import { makeInMemoryPersistenceAdapter } from "./adapters/in-memory.js";
 import { EntityRpcs, ToEntityOptions, toEntity } from "./to-entity.js";
 import { EntityActorRef, makeEntityActorRef } from "./entity-actor-ref.js";
 import { EntityMachine, EntityMachineOptions } from "./entity-machine.js";
-export { type EntityActorRef, EntityMachine, type EntityMachineOptions, type EntityPersistenceConfig, type EntityRpcs, type PersistedEvent, PersistenceAdapter, type PersistenceAdapter as PersistenceAdapterInterface, type PersistenceKey, type Snapshot, type ToEntityOptions, makeEntityActorRef, makeInMemoryPersistenceAdapter, toEntity };
+export { type EntityActorRef, EntityMachine, type EntityMachineOptions, type EntityPersistenceConfig, type EntityRpcs, type PersistedEvent, PersistenceAdapter, type PersistenceAdapterService as PersistenceAdapterInterface, type PersistenceKey, type Snapshot, type ToEntityOptions, makeEntityActorRef, makeInMemoryPersistenceAdapter, toEntity };

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). */
@@ -33,7 +33,7 @@ interface EntityPersistenceConfig {
   readonly machineType?: string;
 }
 /** Storage backend for entity state persistence. */
-interface PersistenceAdapter {
+interface PersistenceAdapterService {
   /** Save a state snapshot. Fails with VersionConflictError if version is stale. */
   readonly saveSnapshot: (key: PersistenceKey, snapshot: Snapshot<unknown>) => Effect.Effect<void, PersistenceError | VersionConflictError>;
   /** Load the latest snapshot, or None if no snapshot exists. */
@@ -43,7 +43,8 @@ interface PersistenceAdapter {
   /** Load events from the journal, optionally after a given version. */
   readonly loadEvents: (key: PersistenceKey, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<unknown>>, PersistenceError>;
 }
+declare const PersistenceAdapter_base: Context.ServiceClass<PersistenceAdapter, "effect-machine/cluster/persistence/PersistenceAdapter", PersistenceAdapterService>;
 /** Service tag for PersistenceAdapter — resolve from context for shared infra. */
-declare const PersistenceAdapter: ServiceMap.Service<PersistenceAdapter, PersistenceAdapter>;
+declare class PersistenceAdapter extends PersistenceAdapter_base {}
 //#endregion
-export { EntityPersistenceConfig, PersistedEvent, PersistenceAdapter, PersistenceKey, Snapshot };
+export { EntityPersistenceConfig, PersistedEvent, PersistenceAdapter, PersistenceAdapterService, 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");
+var PersistenceAdapter = class extends Context.Service()("effect-machine/cluster/persistence/PersistenceAdapter") {};
 //#endregion
 export { PersistenceAdapter };

package/dist/cluster/to-entity.d.ts

@@ -23,9 +23,9 @@ interface ToEntityOptions {
  */
 type EntityRpcs<StateSchema extends Schema.Top, EventSchema extends Schema.Top> = readonly [Rpc.Rpc<"Send", Schema.Struct<{
   readonly event: EventSchema;
-}>, StateSchema, typeof Schema.Never, never>, Rpc.Rpc<"Ask", Schema.Struct<{
+}>, StateSchema>, Rpc.Rpc<"Ask", Schema.Struct<{
   readonly event: EventSchema;
-}>, typeof Schema.Unknown, typeof Schema.Never, never>, Rpc.Rpc<"GetState", typeof Schema.Void, StateSchema, typeof Schema.Never, never>];
+}>, typeof Schema.Unknown>, Rpc.Rpc<"GetState", typeof Schema.Void, StateSchema>];
 /**
  * Generate an Entity definition from a machine.
  *

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, ActorSystemService, 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 };
+import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, InspectorService, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
+export { ActorExit, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystemService as 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 InspectorService as 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
 /**
@@ -93,15 +93,16 @@ type AnyInspectionEvent = InspectionEvent<{
 /**
  * Inspector interface for observing machine behavior
  */
-type InspectorHandler<S, E> = (event: InspectionEvent<S, E>) => void | Effect.Effect<void, never, never>;
-interface Inspector<S, E> {
+type InspectorHandler<S, E> = (event: InspectionEvent<S, E>) => void | Effect.Effect<void>;
+interface InspectorService<S, E> {
   readonly onInspect: InspectorHandler<S, E>;
 }
+declare const Inspector_base: Context.ServiceClass<Inspector, "effect-machine/inspection/Inspector", InspectorService<any, any>>;
 /**
  * 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 class Inspector extends Inspector_base {}
 /**
  * Create an inspector from a callback function.
  *
@@ -114,13 +115,13 @@ declare const makeInspector: <S = {
   readonly _tag: string;
 }, E = {
   readonly _tag: string;
-}>(onInspect: InspectorHandler<ResolveType<S>, ResolveType<E>>) => Inspector<ResolveType<S>, ResolveType<E>>;
+}>(onInspect: InspectorHandler<ResolveType<S>, ResolveType<E>>) => InspectorService<ResolveType<S>, ResolveType<E>>;
 declare const makeInspectorEffect: <S = {
   readonly _tag: string;
 }, E = {
   readonly _tag: string;
-}>(onInspect: (event: InspectionEvent<ResolveType<S>, ResolveType<E>>) => Effect.Effect<void, never, never>) => Inspector<ResolveType<S>, ResolveType<E>>;
-declare const combineInspectors: <S, E>(...inspectors: ReadonlyArray<Inspector<S, E>>) => Inspector<S, E>;
+}>(onInspect: (event: InspectionEvent<ResolveType<S>, ResolveType<E>>) => Effect.Effect<void>) => InspectorService<ResolveType<S>, ResolveType<E>>;
+declare const combineInspectors: <S, E>(...inspectors: ReadonlyArray<InspectorService<S, E>>) => InspectorService<S, E>;
 interface TracingInspectorOptions<S, E> {
   readonly spanName?: string | ((event: InspectionEvent<S, E>) => string);
   readonly attributes?: (event: InspectionEvent<S, E>) => Readonly<Record<string, string | number | boolean>>;
@@ -130,11 +131,11 @@ declare const tracingInspector: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}>(options?: TracingInspectorOptions<S, E>) => Inspector<S, E>;
+}>(options?: TracingInspectorOptions<S, E>) => InspectorService<S, E>;
 /**
  * Console inspector that logs events in a readable format
  */
-declare const consoleInspector: () => Inspector<{
+declare const consoleInspector: () => InspectorService<{
   readonly _tag: string;
 }, {
   readonly _tag: string;
@@ -146,6 +147,6 @@ declare const collectingInspector: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}>(events: InspectionEvent<S, E>[]) => Inspector<S, E>;
+}>(events: InspectionEvent<S, E>[]) => InspectorService<S, E>;
 //#endregion
-export { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector };
+export { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, InspectorService, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector };

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");
+var Inspector = class extends Context.Service()("effect-machine/inspection/Inspector") {};
 /**
 * Create an inspector from a callback function.
 *
@@ -106,30 +106,16 @@ const tracingInspector = (options) => ({ onInspect: (event) => {
 /**
 * Console inspector that logs events in a readable format
 */
-const consoleInspector = () => makeInspector((event) => {
+const consoleInspector = () => makeInspectorEffect((event) => {
 	const prefix = `[${event.actorId}]`;
 	switch (event.type) {
-		case "@machine.spawn":
-			console.log(prefix, "spawned →", event.initialState._tag);
-			break;
-		case "@machine.event":
-			console.log(prefix, "received", event.event._tag, "in", event.state._tag);
-			break;
-		case "@machine.transition":
-			console.log(prefix, event.fromState._tag, "→", event.toState._tag);
-			break;
-		case "@machine.effect":
-			console.log(prefix, event.effectType, "effect in", event.state._tag);
-			break;
-		case "@machine.task":
-			console.log(prefix, "task", event.phase, event.taskName ?? "<unnamed>", "in", event.state._tag);
-			break;
-		case "@machine.error":
-			console.log(prefix, "error in", event.phase, event.state._tag, "-", event.error);
-			break;
-		case "@machine.stop":
-			console.log(prefix, "stopped in", event.finalState._tag);
-			break;
+		case "@machine.spawn": return Effect.log(`${prefix} spawned -> ${event.initialState._tag}`);
+		case "@machine.event": return Effect.log(`${prefix} received ${event.event._tag} in ${event.state._tag}`);
+		case "@machine.transition": return Effect.log(`${prefix} ${event.fromState._tag} -> ${event.toState._tag}`);
+		case "@machine.effect": return Effect.log(`${prefix} ${event.effectType} effect in ${event.state._tag}`);
+		case "@machine.task": return Effect.log(`${prefix} task ${event.phase} ${event.taskName ?? "<unnamed>"} in ${event.state._tag}`);
+		case "@machine.error": return Effect.log(`${prefix} error in ${event.phase} ${event.state._tag} - ${String(event.error)}`);
+		case "@machine.stop": return Effect.log(`${prefix} stopped in ${event.finalState._tag}`);
 	}
 });
 /**

package/dist/internal/inspection.d.ts

@@ -1,4 +1,4 @@
-import { InspectionEvent, Inspector } from "../inspection.js";
+import { InspectionEvent, InspectorService } from "../inspection.js";
 import { Effect } from "effect";
 
 //#region src/internal/inspection.d.ts
@@ -6,6 +6,6 @@ import { Effect } from "effect";
  * Emit an inspection event with timestamp from Clock.
  * @internal
  */
-declare const emitWithTimestamp: <S, E>(inspector: Inspector<S, E> | undefined, makeEvent: (timestamp: number) => InspectionEvent<S, E>) => Effect.Effect<void, never, never>;
+declare const emitWithTimestamp: <S, E>(inspector: InspectorService<S, E> | undefined, makeEvent: (timestamp: number) => InspectionEvent<S, E>) => Effect.Effect<void, never, never>;
 //#endregion
 export { emitWithTimestamp };

package/dist/internal/runtime.d.ts

@@ -1,9 +1,9 @@
 import { NoReplyError } from "../errors.js";
-import { MachineContext, SlotsDef } from "../slot.js";
+import { MachineContextTag, SlotsDef } from "../slot.js";
 import { ActorExit } from "../supervision.js";
 import { ProcessEventHooks, ProcessEventResult } from "./transition.js";
-import { Machine, MachineRef } from "../machine.js";
-import { ActorSystem } from "../actor.js";
+import { Machine } from "../machine.js";
+import { ActorSystemService } from "../actor.js";
 import { Deferred, Effect, Queue, Ref, Scope, SubscriptionRef } from "effect";
 
 //#region src/internal/runtime.d.ts
@@ -27,7 +27,7 @@ type RuntimeQueuedEvent<E> = {
   readonly reply: Deferred.Deferred<unknown, NoReplyError>;
 } | {
   readonly _tag: "drain";
-  readonly done: Deferred.Deferred<void, never>;
+  readonly done: Deferred.Deferred<void>;
 };
 /**
  * Resources owned by the actor cell (stable across generations).
@@ -69,7 +69,7 @@ interface RuntimeHandle<S, E> {
    * Exit deferred — set exactly once with the exit reason when the runtime stops.
    * Final state → ActorExit.Final, explicit stop → ActorExit.Stopped, defect → ActorExit.Defect.
    */
-  readonly exitDeferred: Deferred.Deferred<ActorExit<S>, never>;
+  readonly exitDeferred: Deferred.Deferred<ActorExit<S>>;
   /**
    * Actor scope — owns background fibers for this generation.
    * Closing this scope interrupts all background fibers.
@@ -143,9 +143,9 @@ declare const createRuntime: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, system: ActorSystem, config: RuntimeConfig<S, E>) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, system: ActorSystemService, config: RuntimeConfig<S, E>) => Effect.Effect<{
   stop: Effect.Effect<void, never, never>;
-  start: Effect.Effect<void, unknown, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+  start: Effect.Effect<void, unknown, Exclude<R, MachineContextTag> | Exclude<Exclude<R, MachineContextTag>, Scope.Scope>>;
   send: (event: E) => Effect.Effect<void>;
   sendWait: (event: E) => Effect.Effect<void, unknown>;
   ask: (event: E) => Effect.Effect<unknown, NoReplyError>;

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));
@@ -105,15 +105,13 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 		}
 		if (lifecycle?.onInitialSpawnEffects !== void 0) yield* lifecycle.onInitialSpawnEffects(machine.initial);
 		const initialSpawnDefectSignal = (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid);
-		yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchCause((cause) => {
-			return Effect.gen(function* () {
-				yield* Ref.set(stoppedRef, true);
-				yield* Scope.close(stateScopeRef.current, Exit.void);
-				yield* Scope.close(actorScope, Exit.void);
-				yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
-				return yield* Effect.failCause(cause);
-			});
-		}));
+		yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
+			yield* Ref.set(stoppedRef, true);
+			yield* Scope.close(stateScopeRef.current, Exit.void);
+			yield* Scope.close(actorScope, Exit.void);
+			yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
+			return yield* Effect.failCause(cause);
+		})));
 		if (machine.finalStates.has(machine.initial._tag)) {
 			if (lifecycle?.onFinal !== void 0) yield* lifecycle.onFinal(machine.initial);
 			yield* Ref.set(stoppedRef, true);
@@ -262,13 +260,10 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 				if (result.hasReply) {
 					const replySchema = machine._replySchemas?.get(event._tag);
 					if (replySchema !== void 0) {
-						let decoded;
-						try {
-							decoded = Schema.decodeUnknownSync(replySchema)(result.reply);
-						} catch (decodeError) {
+						const decoded = yield* Schema.decodeUnknownEffect(replySchema)(result.reply).pipe(Effect.catch((decodeError) => Effect.gen(function* () {
 							yield* Deferred.die(queued.reply, decodeError);
 							return yield* Effect.die(decodeError);
-						}
+						})));
 						yield* Deferred.succeed(queued.reply, decoded);
 					} else yield* Deferred.succeed(queued.reply, result.reply);
 				} else if (result.deferReply && deferredReplyRef !== void 0) deferredReplyRef.current = queued.reply;