effect-machine 0.4.0 → 0.7.0

package/README.md

@@ -206,6 +206,30 @@ const child = yield * parent.system.get("worker-1"); // Option<ActorRef>
 
 Every actor always has a system — `Machine.spawn` creates an implicit one if no `ActorSystem` is in context.
 
+### System Observation
+
+React to actors joining and leaving the system:
+
+```ts
+const system = yield * ActorSystemService;
+
+// Sync callback — like ActorRef.subscribe
+const unsub = system.subscribe((event) => {
+  // event._tag: "ActorSpawned" | "ActorStopped"
+  console.log(`${event._tag}: ${event.id}`);
+});
+
+// Sync snapshot of all registered actors
+const actors = system.actors; // ReadonlyMap<string, ActorRef>
+
+// Async stream (each subscriber gets own queue)
+yield *
+  system.events.pipe(
+    Stream.tap((e) => Effect.log(e._tag, e.id)),
+    Stream.runDrain,
+  );
+```
+
 ### Testing
 
 Test transitions without actors:
@@ -297,6 +321,18 @@ See the [primer](./primer/) for comprehensive documentation:
 | `actor.sendAndWait(ev, State.X)` | Send + wait for state              |
 | `actor.subscribe(fn)`            | Sync callback                      |
 | `actor.system`                   | Access the actor's `ActorSystem`   |
+| `actor.children`                 | Child actors (`ReadonlyMap`)       |
+
+### ActorSystem
+
+| Method / Property      | Description                                 |
+| ---------------------- | ------------------------------------------- |
+| `system.spawn(id, m)`  | Spawn actor                                 |
+| `system.get(id)`       | Get actor by ID                             |
+| `system.stop(id)`      | Stop actor by ID                            |
+| `system.actors`        | Sync snapshot of all actors (`ReadonlyMap`) |
+| `system.subscribe(fn)` | Sync callback for spawn/stop events         |
+| `system.events`        | Async `Stream<SystemEvent>` for spawn/stop  |
 
 ## License
 

package/dist/actor.d.ts

@@ -5,7 +5,7 @@ import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventC
 import { PersistentActorRef } from "./persistence/persistent-actor.js";
 import { ActorMetadata, PersistenceAdapterTag, PersistenceError, RestoreResult, VersionConflictError } from "./persistence/adapter.js";
 import { BuiltMachine, Machine, MachineRef } from "./machine.js";
-import { Context, Effect, Layer, Option, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
+import { Effect, Layer, Option, Queue, Ref, Scope, ServiceMap, Stream, SubscriptionRef } from "effect";
 import * as effect_Tracer0 from "effect/Tracer";
 
 //#region src/actor.d.ts
@@ -106,11 +106,32 @@ interface ActorRef<State extends {
    * Every actor always has a system — either inherited from context or implicitly created.
    */
   readonly system: ActorSystem;
+  /**
+   * Child actors spawned via `self.spawn` in this actor's handlers.
+   * State-scoped children are auto-removed on state exit.
+   */
+  readonly children: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
 }
 /** Base type for stored actors (internal) */
 type AnyState = {
   readonly _tag: string;
 };
+/**
+ * Events emitted by the ActorSystem when actors are spawned or stopped.
+ */
+type SystemEvent = {
+  readonly _tag: "ActorSpawned";
+  readonly id: string;
+  readonly actor: ActorRef<AnyState, unknown>;
+} | {
+  readonly _tag: "ActorStopped";
+  readonly id: string;
+  readonly actor: ActorRef<AnyState, unknown>;
+};
+/**
+ * Listener callback for system events.
+ */
+type SystemEventListener = (event: SystemEvent) => void;
 /**
  * Actor system for managing actor lifecycles
  */
@@ -174,6 +195,21 @@ interface ActorSystem {
    * Stop an actor by ID
    */
   readonly stop: (id: string) => Effect.Effect<boolean>;
+  /**
+   * Async stream of system events (actor spawned/stopped).
+   * Each subscriber gets their own queue — late subscribers miss prior events.
+   */
+  readonly events: Stream.Stream<SystemEvent>;
+  /**
+   * Sync snapshot of all currently registered actors.
+   * Returns a new Map on each access (not live).
+   */
+  readonly actors: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
+  /**
+   * Subscribe to system events synchronously.
+   * Returns an unsubscribe function.
+   */
+  readonly subscribe: (fn: SystemEventListener) => () => void;
   /**
    * List all persisted actor metadata.
    * Returns empty array if adapter doesn't support registry.
@@ -225,7 +261,7 @@ interface ActorSystem {
 /**
  * ActorSystem service tag
  */
-declare const ActorSystem: Context.Tag<ActorSystem, ActorSystem>;
+declare const ActorSystem: ServiceMap.Service<ActorSystem, ActorSystem>;
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**
@@ -239,7 +275,7 @@ declare const buildActorRefCore: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, any, any, GD, EFD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueue: Queue.Queue<E>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem) => ActorRef<S, E>;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, any, any, GD, EFD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueue: Queue.Queue<E>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>) => ActorRef<S, E>;
 /**
  * Create and start an actor for a machine
  */
@@ -253,4 +289,4 @@ declare const createActor: <S extends {
  */
 declare const Default: Layer.Layer<ActorSystem, never, never>;
 //#endregion
-export { ActorRef, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };
+export { ActorRef, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, SystemEvent, SystemEventListener, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };

package/dist/actor.js

@@ -6,13 +6,21 @@ import { processEventCore, resolveTransition, runSpawnEffects } from "./internal
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { PersistenceAdapterTag, PersistenceError } from "./persistence/adapter.js";
 import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
-import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, Queue, Ref, Runtime, Scope, SubscriptionRef } from "effect";
+import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Scope, ServiceMap, Stream, SubscriptionRef } from "effect";
 
 //#region src/actor.ts
 /**
+* Actor system: spawning, lifecycle, and event processing.
+*
+* Combines:
+* - ActorRef interface (running actor handle)
+* - ActorSystem service (spawn/stop/get actors)
+* - Actor creation and event loop
+*/
+/**
 * ActorSystem service tag
 */
-const ActorSystem = Context.GenericTag("@effect/machine/ActorSystem");
+const ActorSystem = ServiceMap.Service("@effect/machine/ActorSystem");
 /**
 * Notify all listeners of state change.
 */
@@ -24,7 +32,7 @@ const notifyListeners = (listeners, state) => {
 /**
 * Build core ActorRef methods shared between regular and persistent actors.
 */
-const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop, system) => {
+const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap) => {
 	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) return;
 		yield* Queue.offer(eventQueue, event);
@@ -41,10 +49,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 		const current = yield* SubscriptionRef.get(stateRef);
 		if (predicate(current)) return current;
 		const done = yield* Deferred.make();
-		const rt = yield* Effect.runtime();
-		const runFork = Runtime.runFork(rt);
 		const listener = (state) => {
-			if (predicate(state)) runFork(Deferred.succeed(done, state));
+			if (predicate(state)) Effect.runFork(Deferred.succeed(done, state));
 		};
 		listeners.add(listener);
 		const afterSubscribe = yield* SubscriptionRef.get(stateRef);
@@ -76,7 +82,7 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 		canSync: (event) => {
 			return resolveTransition(machine, Effect.runSync(SubscriptionRef.get(stateRef)), event) !== void 0;
 		},
-		changes: stateRef.changes,
+		changes: SubscriptionRef.changes(stateRef),
 		waitFor,
 		awaitFinal,
 		sendAndWait,
@@ -89,7 +95,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 				listeners.delete(fn);
 			};
 		},
-		system
+		system,
+		children: childrenMap
 	};
 };
 /**
@@ -109,12 +116,21 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	const inspectorValue = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
 	const eventQueue = yield* Queue.unbounded();
 	const stoppedRef = yield* Ref.make(false);
+	const childrenMap = /* @__PURE__ */ new Map();
 	const self = {
 		send: Effect.fn("effect-machine.actor.self.send")(function* (event) {
 			if (yield* Ref.get(stoppedRef)) return;
 			yield* Queue.offer(eventQueue, event);
 		}),
-		spawn: (childId, childMachine) => system.spawn(childId, childMachine).pipe(Effect.provideService(ActorSystem, system))
+		spawn: (childId, childMachine) => Effect.gen(function* () {
+			const child = yield* system.spawn(childId, childMachine).pipe(Effect.provideService(ActorSystem, system));
+			childrenMap.set(childId, child);
+			const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+			if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.sync(() => {
+				childrenMap.delete(childId);
+			}));
+			return child;
+		})
 	};
 	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", machine.initial._tag);
 	yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
@@ -135,7 +151,7 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	};
 	const { effects: effectSlots } = machine._slots;
 	for (const bg of machine.backgroundEffects) {
-		const fiber = yield* Effect.forkDaemon(bg.handler({
+		const fiber = yield* Effect.forkDetach(bg.handler({
 			state: machine.initial,
 			event: initEvent,
 			self,
@@ -157,9 +173,9 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		}));
 		yield* Ref.set(stoppedRef, true);
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system);
+		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap);
 	}
-	const loopFiber = yield* Effect.forkDaemon(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system));
+	const loopFiber = yield* Effect.forkDetach(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system));
 	return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
 		const finalState = yield* SubscriptionRef.get(stateRef);
 		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
@@ -173,7 +189,7 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		yield* Scope.close(stateScopeRef.current, Exit.void);
 		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system);
+	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap);
 });
 /**
 * Main event loop for the actor
@@ -277,39 +293,58 @@ const runSpawnEffectsWithInspection = Effect.fn("effect-machine.actor.spawnEffec
 		timestamp
 	})));
 });
-/**
-* Internal implementation
-*/
+/** Notify all system event listeners (sync). */
+const notifySystemListeners = (listeners, event) => {
+	for (const listener of listeners) try {
+		listener(event);
+	} catch {}
+};
 const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
-	const actors = MutableHashMap.empty();
+	const actorsMap = MutableHashMap.empty();
 	const withSpawnGate = (yield* Effect.makeSemaphore(1)).withPermits(1);
+	const eventPubSub = yield* PubSub.unbounded();
+	const eventListeners = /* @__PURE__ */ new Set();
+	const emitSystemEvent = (event) => Effect.sync(() => notifySystemListeners(eventListeners, event)).pipe(Effect.andThen(PubSub.publish(eventPubSub, event)), Effect.catchCause(() => Effect.void), Effect.asVoid);
 	yield* Effect.addFinalizer(() => {
 		const stops = [];
-		MutableHashMap.forEach(actors, (actor) => {
+		MutableHashMap.forEach(actorsMap, (actor) => {
 			stops.push(actor.stop);
 		});
-		return Effect.all(stops, { concurrency: "unbounded" }).pipe(Effect.asVoid);
+		return Effect.all(stops, { concurrency: "unbounded" }).pipe(Effect.andThen(PubSub.shutdown(eventPubSub)), Effect.asVoid);
 	});
 	/** Check for duplicate ID, register actor, attach scope cleanup if available */
 	const registerActor = Effect.fn("effect-machine.actorSystem.register")(function* (id, actor) {
-		if (MutableHashMap.has(actors, id)) {
+		if (MutableHashMap.has(actorsMap, id)) {
 			yield* actor.stop;
 			return yield* new DuplicateActorError({ actorId: id });
 		}
-		MutableHashMap.set(actors, id, actor);
+		const actorRef = actor;
+		MutableHashMap.set(actorsMap, id, actorRef);
+		yield* emitSystemEvent({
+			_tag: "ActorSpawned",
+			id,
+			actor: actorRef
+		});
 		const maybeScope = yield* Effect.serviceOption(Scope.Scope);
 		if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.gen(function* () {
+			if (MutableHashMap.has(actorsMap, id)) {
+				yield* emitSystemEvent({
+					_tag: "ActorStopped",
+					id,
+					actor: actorRef
+				});
+				MutableHashMap.remove(actorsMap, id);
+			}
 			yield* actor.stop;
-			MutableHashMap.remove(actors, id);
 		}));
 		return actor;
 	});
 	const spawnRegular = Effect.fn("effect-machine.actorSystem.spawnRegular")(function* (id, built) {
-		if (MutableHashMap.has(actors, id)) return yield* new DuplicateActorError({ actorId: id });
+		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
 		return yield* registerActor(id, yield* createActor(id, built._inner));
 	});
 	const spawnPersistent = Effect.fn("effect-machine.actorSystem.spawnPersistent")(function* (id, persistentMachine) {
-		if (MutableHashMap.has(actors, id)) return yield* new DuplicateActorError({ actorId: id });
+		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
 		const adapter = yield* PersistenceAdapterTag;
 		const maybeSnapshot = yield* adapter.loadSnapshot(id, persistentMachine.persistence.stateSchema);
 		return yield* registerActor(id, yield* createPersistentActor(id, persistentMachine, maybeSnapshot, yield* adapter.loadEvents(id, persistentMachine.persistence.eventSchema, Option.isSome(maybeSnapshot) ? maybeSnapshot.value.version : void 0)));
@@ -328,13 +363,19 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 	});
 	const restore = (id, persistentMachine) => withSpawnGate(restoreImpl(id, persistentMachine));
 	const get = Effect.fn("effect-machine.actorSystem.get")(function* (id) {
-		return yield* Effect.sync(() => MutableHashMap.get(actors, id));
+		return yield* Effect.sync(() => MutableHashMap.get(actorsMap, id));
 	});
 	const stop = Effect.fn("effect-machine.actorSystem.stop")(function* (id) {
-		const maybeActor = MutableHashMap.get(actors, id);
+		const maybeActor = MutableHashMap.get(actorsMap, id);
 		if (Option.isNone(maybeActor)) return false;
-		yield* maybeActor.value.stop;
-		MutableHashMap.remove(actors, id);
+		const actor = maybeActor.value;
+		MutableHashMap.remove(actorsMap, id);
+		yield* emitSystemEvent({
+			_tag: "ActorStopped",
+			id,
+			actor
+		});
+		yield* actor.stop;
 		return true;
 	});
 	const listPersisted = Effect.fn("effect-machine.actorSystem.listPersisted")(function* () {
@@ -346,13 +387,13 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		const restored = [];
 		const failed = [];
 		for (const id of ids) {
-			if (MutableHashMap.has(actors, id)) continue;
-			const result = yield* Effect.either(restore(id, persistentMachine));
-			if (result._tag === "Left") failed.push({
+			if (MutableHashMap.has(actorsMap, id)) continue;
+			const result = yield* Effect.result(restore(id, persistentMachine));
+			if (result._tag === "Failure") failed.push({
 				id,
-				error: result.left
+				error: result.failure
 			});
-			else if (Option.isSome(result.right)) restored.push(result.right.value);
+			else if (Option.isSome(result.success)) restored.push(result.success.value);
 			else failed.push({
 				id,
 				error: new PersistenceError({
@@ -388,6 +429,20 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		restore,
 		get,
 		stop,
+		events: Stream.fromPubSub(eventPubSub),
+		get actors() {
+			const snapshot = /* @__PURE__ */ new Map();
+			MutableHashMap.forEach(actorsMap, (actor, id) => {
+				snapshot.set(id, actor);
+			});
+			return snapshot;
+		},
+		subscribe: (fn) => {
+			eventListeners.add(fn);
+			return () => {
+				eventListeners.delete(fn);
+			};
+		},
 		listPersisted,
 		restoreMany,
 		restoreAll
@@ -396,7 +451,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 /**
 * Default ActorSystem layer
 */
-const Default = Layer.scoped(ActorSystem, make());
+const Default = Layer.effect(ActorSystem, make());
 
 //#endregion
 export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };

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

@@ -3,8 +3,8 @@ import { ProcessEventHooks } from "../internal/transition.js";
 import { Machine } from "../machine.js";
 import "../actor.js";
 import { Layer } from "effect";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
+import { Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
 
 //#region src/cluster/entity-machine.d.ts
 /**

package/dist/cluster/entity-machine.js

@@ -1,7 +1,7 @@
 import { processEventCore, runSpawnEffects } from "../internal/transition.js";
 import { ActorSystem } from "../actor.js";
 import { Effect, Option, Queue, Ref, Scope } from "effect";
-import { Entity } from "@effect/cluster";
+import { Entity } from "effect/unstable/cluster";
 
 //#region src/cluster/entity-machine.ts
 /**

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

@@ -1,7 +1,7 @@
 import { Machine } from "../machine.js";
 import { Schema } from "effect";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
+import { Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
 
 //#region src/cluster/to-entity.d.ts
 /**
@@ -19,7 +19,7 @@ interface ToEntityOptions {
  * - `Send` - Send event to machine, returns new state
  * - `GetState` - Get current state
  */
-type EntityRpcs<StateSchema extends Schema.Schema.Any, EventSchema extends Schema.Schema.Any> = readonly [Rpc.Rpc<"Send", Schema.Struct<{
+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<"GetState", typeof Schema.Void, StateSchema, typeof Schema.Never, never>];
 /**
@@ -58,7 +58,7 @@ declare const toEntity: <S extends {
 }, E extends {
   readonly _tag: string;
 }, R>(machine: Machine<S, E, R, any, any, any, any>, options: ToEntityOptions) => Entity.Entity<string, Rpc.Rpc<"Send", Schema.Struct<{
-  event: Schema.Schema<E, unknown, never>;
-}>, Schema.Schema<S, unknown, never>, typeof Schema.Never, never> | Rpc.Rpc<"GetState", typeof Schema.Void, Schema.Schema<S, unknown, never>, typeof Schema.Never, never>>;
+  event: Schema.Schema<E>;
+}>, Schema.Schema<S>, Schema.Never, never, never> | Rpc.Rpc<"GetState", Schema.Void, Schema.Schema<S>, Schema.Never, never, never>>;
 //#endregion
 export { EntityRpcs, ToEntityOptions, toEntity };

package/dist/cluster/to-entity.js

@@ -1,6 +1,6 @@
 import { MissingSchemaError } from "../errors.js";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
+import { Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
 
 //#region src/cluster/to-entity.ts
 /**

package/dist/errors.d.ts

@@ -1,60 +1,45 @@
 import { Schema } from "effect";
+import * as effect_Cause0 from "effect/Cause";
 
 //#region src/errors.d.ts
-declare const DuplicateActorError_base: Schema.TaggedErrorClass<DuplicateActorError, "DuplicateActorError", {
-  readonly _tag: Schema.tag<"DuplicateActorError">;
-} & {
-  actorId: typeof Schema.String;
-}>;
+declare const DuplicateActorError_base: Schema.ErrorClass<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 UnprovidedSlotsError_base: Schema.TaggedErrorClass<UnprovidedSlotsError, "UnprovidedSlotsError", {
-  readonly _tag: Schema.tag<"UnprovidedSlotsError">;
-} & {
-  slots: Schema.Array$<typeof Schema.String>;
-}>;
+declare const UnprovidedSlotsError_base: Schema.ErrorClass<UnprovidedSlotsError, Schema.TaggedStruct<"UnprovidedSlotsError", {
+  readonly slots: Schema.Array$<Schema.String>;
+}>, effect_Cause0.YieldableError>;
 /** Machine has unprovided effect slots */
 declare class UnprovidedSlotsError extends UnprovidedSlotsError_base {}
-declare const MissingSchemaError_base: Schema.TaggedErrorClass<MissingSchemaError, "MissingSchemaError", {
-  readonly _tag: Schema.tag<"MissingSchemaError">;
-} & {
-  operation: typeof Schema.String;
-}>;
+declare const MissingSchemaError_base: Schema.ErrorClass<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.TaggedErrorClass<InvalidSchemaError, "InvalidSchemaError", {
-  readonly _tag: Schema.tag<"InvalidSchemaError">;
-}>;
+declare const InvalidSchemaError_base: Schema.ErrorClass<InvalidSchemaError, Schema.TaggedStruct<"InvalidSchemaError", {}>, effect_Cause0.YieldableError>;
 /** State/Event schema has no variants */
 declare class InvalidSchemaError extends InvalidSchemaError_base {}
-declare const MissingMatchHandlerError_base: Schema.TaggedErrorClass<MissingMatchHandlerError, "MissingMatchHandlerError", {
-  readonly _tag: Schema.tag<"MissingMatchHandlerError">;
-} & {
-  tag: typeof Schema.String;
-}>;
+declare const MissingMatchHandlerError_base: Schema.ErrorClass<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.TaggedErrorClass<SlotProvisionError, "SlotProvisionError", {
-  readonly _tag: Schema.tag<"SlotProvisionError">;
-} & {
-  slotName: typeof Schema.String;
-  slotType: Schema.Literal<["guard", "effect"]>;
-}>;
+declare const SlotProvisionError_base: Schema.ErrorClass<SlotProvisionError, Schema.TaggedStruct<"SlotProvisionError", {
+  readonly slotName: Schema.String;
+  readonly slotType: Schema.Literals<readonly ["guard", "effect"]>;
+}>, effect_Cause0.YieldableError>;
 /** Slot handler not found at runtime (internal error) */
 declare class SlotProvisionError extends SlotProvisionError_base {}
-declare const ProvisionValidationError_base: Schema.TaggedErrorClass<ProvisionValidationError, "ProvisionValidationError", {
-  readonly _tag: Schema.tag<"ProvisionValidationError">;
-} & {
-  missing: Schema.Array$<typeof Schema.String>;
-  extra: Schema.Array$<typeof Schema.String>;
-}>;
+declare const ProvisionValidationError_base: Schema.ErrorClass<ProvisionValidationError, Schema.TaggedStruct<"ProvisionValidationError", {
+  readonly missing: Schema.Array$<Schema.String>;
+  readonly extra: Schema.Array$<Schema.String>;
+}>, effect_Cause0.YieldableError>;
 /** Machine.build() validation failed - missing or extra handlers */
 declare class ProvisionValidationError extends ProvisionValidationError_base {}
-declare const AssertionError_base: Schema.TaggedErrorClass<AssertionError, "AssertionError", {
-  readonly _tag: Schema.tag<"AssertionError">;
-} & {
-  message: typeof Schema.String;
-}>;
+declare const AssertionError_base: Schema.ErrorClass<AssertionError, Schema.TaggedStruct<"AssertionError", {
+  readonly message: Schema.String;
+}>, effect_Cause0.YieldableError>;
 /** Assertion failed in testing utilities */
 declare class AssertionError extends AssertionError_base {}
 //#endregion

package/dist/errors.js

@@ -4,7 +4,7 @@ import { Schema } from "effect";
 /**
 * Typed error classes for effect-machine.
 *
-* All errors extend Schema.TaggedError for:
+* All errors extend Schema.TaggedErrorClassClass for:
 * - Type-safe catching via Effect.catchTag
 * - Serialization support
 * - Composable error handling
@@ -12,27 +12,27 @@ import { Schema } from "effect";
 * @module
 */
 /** Attempted to spawn/restore actor with ID already in use */
-var DuplicateActorError = class extends Schema.TaggedError()("DuplicateActorError", { actorId: Schema.String }) {};
+var DuplicateActorError = class extends Schema.TaggedErrorClass()("DuplicateActorError", { actorId: Schema.String }) {};
 /** Machine has unprovided effect slots */
-var UnprovidedSlotsError = class extends Schema.TaggedError()("UnprovidedSlotsError", { slots: Schema.Array(Schema.String) }) {};
+var UnprovidedSlotsError = class extends Schema.TaggedErrorClass()("UnprovidedSlotsError", { slots: Schema.Array(Schema.String) }) {};
 /** Operation requires schemas attached to machine */
-var MissingSchemaError = class extends Schema.TaggedError()("MissingSchemaError", { operation: Schema.String }) {};
+var MissingSchemaError = class extends Schema.TaggedErrorClass()("MissingSchemaError", { operation: Schema.String }) {};
 /** State/Event schema has no variants */
-var InvalidSchemaError = class extends Schema.TaggedError()("InvalidSchemaError", {}) {};
+var InvalidSchemaError = class extends Schema.TaggedErrorClass()("InvalidSchemaError", {}) {};
 /** $match called with missing handler for tag */
-var MissingMatchHandlerError = class extends Schema.TaggedError()("MissingMatchHandlerError", { tag: Schema.String }) {};
+var MissingMatchHandlerError = class extends Schema.TaggedErrorClass()("MissingMatchHandlerError", { tag: Schema.String }) {};
 /** Slot handler not found at runtime (internal error) */
-var SlotProvisionError = class extends Schema.TaggedError()("SlotProvisionError", {
+var SlotProvisionError = class extends Schema.TaggedErrorClass()("SlotProvisionError", {
 	slotName: Schema.String,
-	slotType: Schema.Literal("guard", "effect")
+	slotType: Schema.Literals(["guard", "effect"])
 }) {};
 /** Machine.build() validation failed - missing or extra handlers */
-var ProvisionValidationError = class extends Schema.TaggedError()("ProvisionValidationError", {
+var ProvisionValidationError = class extends Schema.TaggedErrorClass()("ProvisionValidationError", {
 	missing: Schema.Array(Schema.String),
 	extra: Schema.Array(Schema.String)
 }) {};
 /** Assertion failed in testing utilities */
-var AssertionError = class extends Schema.TaggedError()("AssertionError", { message: Schema.String }) {};
+var AssertionError = class extends Schema.TaggedErrorClass()("AssertionError", { message: Schema.String }) {};
 
 //#endregion
 export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };

package/dist/index.d.ts

@@ -7,7 +7,7 @@ import { ActorMetadata, PersistedEvent, PersistenceAdapter, PersistenceAdapterTa
 import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./persistence/adapters/in-memory.js";
 import "./persistence/index.js";
 import { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, ProvideHandlers, SpawnEffect, StateHandlerContext, Transition, machine_d_exports } from "./machine.js";
-import { ActorRef, ActorSystem, Default } from "./actor.js";
+import { ActorRef, ActorSystem, Default, SystemEvent, SystemEventListener } from "./actor.js";
 import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
 import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, SpawnEvent, StopEvent, TransitionEvent, collectingInspector, consoleInspector, makeInspector } from "./inspection.js";
-export { type ActorMetadata, type ActorRef, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type BuiltMachine, DuplicateActorError, type EffectEvent, type EffectSlots, type EffectsDef, type EffectsSchema, type ErrorEvent, Event, type EventReceivedEvent, type GuardHandlers, type GuardSlot, type GuardSlots, type GuardsDef, type GuardsSchema, type HandlerContext, InMemoryPersistenceAdapter, type InspectionEvent, type Inspector, Inspector as InspectorService, InvalidSchemaError, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, type PersistOptions, type PersistedEvent, type PersistenceAdapter, PersistenceAdapterTag, type PersistenceConfig, PersistenceError, type PersistentActorRef, type PersistentMachine, type ProvideHandlers, ProvisionValidationError, type RestoreFailure, type RestoreResult, type SimulationResult, Slot, type EffectHandlers as SlotEffectHandlers, type EffectSlot as SlotEffectSlot, SlotProvisionError, type Snapshot, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, type TestHarness, type TestHarnessOptions, type Transition, type TransitionEvent, UnprovidedSlotsError, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, restorePersistentActor, simulate };
+export { type ActorMetadata, type ActorRef, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type BuiltMachine, DuplicateActorError, type EffectEvent, type EffectSlots, type EffectsDef, type EffectsSchema, type ErrorEvent, Event, type EventReceivedEvent, type GuardHandlers, type GuardSlot, type GuardSlots, type GuardsDef, type GuardsSchema, type HandlerContext, InMemoryPersistenceAdapter, type InspectionEvent, type Inspector, Inspector as InspectorService, InvalidSchemaError, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, type PersistOptions, type PersistedEvent, type PersistenceAdapter, PersistenceAdapterTag, type PersistenceConfig, PersistenceError, type PersistentActorRef, type PersistentMachine, type ProvideHandlers, ProvisionValidationError, type RestoreFailure, type RestoreResult, type SimulationResult, Slot, type EffectHandlers as SlotEffectHandlers, type EffectSlot as SlotEffectSlot, SlotProvisionError, type Snapshot, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, type SystemEvent, type SystemEventListener, type TestHarness, type TestHarnessOptions, type Transition, type TransitionEvent, UnprovidedSlotsError, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, restorePersistentActor, simulate };

package/dist/inspection.d.ts

@@ -1,10 +1,10 @@
-import { Context, Schema } from "effect";
+import { Schema, ServiceMap } from "effect";
 
 //#region src/inspection.d.ts
 /**
  * Resolve a type param: if it's a Schema, extract `.Type`; otherwise use as-is.
  */
-type ResolveType<T> = T extends Schema.Schema<infer A, infer _I, infer _R> ? A : T;
+type ResolveType<T> = T extends Schema.Schema<infer A> ? A : T;
 /**
  * Event emitted when an actor is spawned
  */
@@ -91,7 +91,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: Context.Tag<Inspector<any, any>, Inspector<any, any>>;
+declare const Inspector: ServiceMap.Service<Inspector<any, any>, Inspector<any, any>>;
 /**
  * Create an inspector from a callback function.
  *

package/dist/inspection.js

@@ -1,11 +1,11 @@
-import { Context } from "effect";
+import { ServiceMap } 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 = Context.GenericTag("@effect/machine/Inspector");
+const Inspector = ServiceMap.Service("@effect/machine/Inspector");
 /**
 * Create an inspector from a callback function.
 *