effect-machine 0.16.0 → 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

@@ -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,12 @@ 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: Context.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.
  *
@@ -209,7 +211,7 @@ declare const ActorSystem: Context.Service<ActorSystem, ActorSystem>;
  *
  * Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
  */
-declare const ActorScope: Context.Service<Scope.Scope, Scope.Scope>;
+declare class ActorScope extends ActorScope_base {}
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**
@@ -223,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.
@@ -244,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, ActorScope, 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

@@ -17,7 +17,7 @@ import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, O
 /**
 * ActorSystem service tag
 */
-const ActorSystem = Context.Service("@effect/machine/ActorSystem");
+var ActorSystem = class extends Context.Service()("effect-machine/actor/ActorSystem") {};
 /**
 * Explicit scope for actor lifecycle management.
 *
@@ -27,7 +27,7 @@ const ActorSystem = Context.Service("@effect/machine/ActorSystem");
 *
 * Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
 */
-const ActorScope = Context.Service("@effect/machine/ActorScope");
+var ActorScope = class extends Context.Service()("effect-machine/actor/ActorScope") {};
 /**
 * Notify all listeners of state change.
 */

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

@@ -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: Context.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

@@ -13,6 +13,6 @@ import { Context } from "effect";
 * @module
 */
 /** Service tag for PersistenceAdapter — resolve from context for shared infra. */
-const PersistenceAdapter = Context.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/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, ActorScope, 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, 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 };
+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/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: Context.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

@@ -4,7 +4,7 @@ import { Context, Effect, Option } from "effect";
 * Inspector service tag - optional service for machine introspection
 * Uses `any` types to allow variance flexibility when providing the service
 */
-const Inspector = Context.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

@@ -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;

package/dist/internal/transition.d.ts

@@ -1,6 +1,6 @@
-import { MachineContext, SlotsDef } from "../slot.js";
+import { MachineContextTag, SlotsDef } from "../slot.js";
 import { Machine, MachineRef, SpawnEffect, Transition } from "../machine.js";
-import { ActorSystem } from "../actor.js";
+import { ActorSystemService } from "../actor.js";
 import { Cause, Effect, Scope } from "effect";
 
 //#region src/internal/transition.d.ts
@@ -29,12 +29,12 @@ declare const runTransitionHandler: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, transition: Transition<S, E, SD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, transition: Transition<S, E, SD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystemService, actorId: string) => Effect.Effect<{
   newState: S;
   hasReply: boolean;
   deferReply: boolean;
   reply: unknown;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, never, Exclude<R, MachineContextTag>>;
 /**
  * Execute a transition for a given state and event.
  * Handles transition resolution, handler invocation, and guard/effect slot creation.
@@ -50,14 +50,14 @@ declare const executeTransition: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystemService, actorId: string) => Effect.Effect<{
   newState: S;
   transitioned: boolean;
   reenter: boolean;
   hasReply: boolean;
   deferReply: boolean;
   reply: unknown;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, never, Exclude<R, MachineContextTag>>;
 /**
  * Optional hooks for event processing inspection/tracing.
  */
@@ -130,7 +130,7 @@ declare const processEventCore: <S extends {
   readonly _tag: string;
 }, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
   current: Scope.Closeable;
-}, system: ActorSystem, actorId: string, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
+}, system: ActorSystemService, actorId: string, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
   newState: S;
   previousState: S;
   transitioned: boolean;
@@ -140,7 +140,7 @@ declare const processEventCore: <S extends {
   deferReply: boolean;
   reply: unknown;
   postponed: boolean;
-}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, never, Exclude<R, MachineContextTag> | Exclude<Exclude<R, MachineContextTag>, Scope.Scope>>;
 /**
  * Run spawn effects for a state (forked into state scope, auto-cancelled on state exit).
  *
@@ -150,7 +150,7 @@ declare const runSpawnEffects: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystem, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystemService, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContextTag>, Scope.Scope>>;
 /**
  * Resolve which transition should fire for a given state and event.
  * Uses indexed O(1) lookup. First matching transition wins.

package/dist/internal/utils.d.ts

@@ -1,4 +1,4 @@
-import { ActorSystem } from "../actor.js";
+import { ActorSystemService } from "../actor.js";
 import { Effect } from "effect";
 
 //#region src/internal/utils.d.ts
@@ -91,11 +91,11 @@ declare const getTag: (constructorOrValue: {
 /** Check if a value is an Effect */
 declare const isEffect: (value: unknown) => value is Effect.Effect<unknown, unknown, unknown>;
 /**
- * Stub ActorSystem that dies on any method call.
+ * Stub ActorSystemService that dies on any method call.
  * Used in contexts where spawning/system access isn't supported
  * (testing simulation, persistent actor replay).
  * @internal
  */
-declare const stubSystem: ActorSystem;
+declare const stubSystem: ActorSystemService;
 //#endregion
 export { ArgsOf, DeferReplyResult, DeferReplySymbol, INTERNAL_ENTER_EVENT, INTERNAL_INIT_EVENT, InstanceOf, ReplyResult, ReplyResultSymbol, TagOf, TaggedConstructor, TransitionResult, getTag, isDeferReplyResult, isEffect, isReplyResult, makeDeferReply, makeReply, stubSystem };

package/dist/internal/utils.js

@@ -56,7 +56,7 @@ const getTag = (constructorOrValue) => {
 /** Check if a value is an Effect */
 const isEffect = Effect.isEffect;
 /**
-* Stub ActorSystem that dies on any method call.
+* Stub ActorSystemService that dies on any method call.
 * Used in contexts where spawning/system access isn't supported
 * (testing simulation, persistent actor replay).
 * @internal

package/dist/machine.d.ts

@@ -2,10 +2,10 @@ import { DeferReplyResult, ReplyResult, TransitionResult } from "./internal/util
 import { BrandedEvent, BrandedState, ExtractReply, TaggedOrConstructor } from "./internal/brands.js";
 import { MachineEventSchema, MachineStateSchema, VariantsUnion } from "./schema.js";
 import { DuplicateActorError } from "./errors.js";
-import { MachineContext, ProvideSlots, SlotCalls, SlotsDef, SlotsSchema } from "./slot.js";
+import { MachineContext, MachineContextTag, ProvideSlots, SlotCalls, SlotsDef, SlotsSchema } from "./slot.js";
 import { Supervision } from "./supervision.js";
 import { findTransitions } from "./internal/transition.js";
-import { ActorRef, ActorSystem } from "./actor.js";
+import { ActorRef, ActorSystemService } from "./actor.js";
 import { Cause, Context, Duration, Effect, Option, Schema, Scope } from "effect";
 
 //#region src/machine.d.ts
@@ -48,7 +48,7 @@ interface StateHandlerContext<State, Event, SD extends SlotsDef = Record<string,
   readonly event: Event;
   readonly self: MachineRef<Event>;
   readonly slots: SlotCalls<SD>;
-  readonly system: ActorSystem;
+  readonly system: ActorSystemService;
 }
 /**
  * Transition handler function.
@@ -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: Context.Service<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
+  readonly Context: Context.Service<MachineContextTag, 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>>;

package/dist/machine.js

@@ -76,6 +76,24 @@ 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;
 	}
@@ -99,7 +117,6 @@ var Machine = class Machine {
 	}
 	/** @internal */
 	constructor(initial, stateSchema, eventSchema, slotsSchema, slotValidation = true) {
-		this.Context = MachineContextTag;
 		this.initial = initial;
 		this._transitions = [];
 		this._spawnEffects = [];
@@ -161,7 +178,8 @@ var Machine = class Machine {
 		this._slots = this._slotsSchema !== void 0 ? this._slotsSchema._createSlots(resolve) : {};
 	}
 	from(stateOrStates, build) {
-		build(new TransitionScope(this, Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates]));
+		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
+		build(new TransitionScope(this, states));
 		return this;
 	}
 	/** @internal */