effect-machine 0.4.0 → 0.6.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

@@ -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.
@@ -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,10 +6,18 @@ 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, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Runtime, Scope, 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");
@@ -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);
@@ -89,7 +97,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 				listeners.delete(fn);
 			};
 		},
-		system
+		system,
+		children: childrenMap
 	};
 };
 /**
@@ -109,12 +118,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) => ({
@@ -157,7 +175,7 @@ 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));
 	return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
@@ -173,7 +191,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 +295,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.catchAllCause(() => 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 +365,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,7 +389,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		const restored = [];
 		const failed = [];
 		for (const id of ids) {
-			if (MutableHashMap.has(actors, id)) continue;
+			if (MutableHashMap.has(actorsMap, id)) continue;
 			const result = yield* Effect.either(restore(id, persistentMachine));
 			if (result._tag === "Left") failed.push({
 				id,
@@ -388,6 +431,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

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/internal/utils.js

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Stream } from "effect";
 
 //#region src/internal/utils.ts
 /**
@@ -37,6 +37,11 @@ const stubSystem = {
 	restore: () => Effect.die("restore not supported in stub system"),
 	get: () => Effect.die("get not supported in stub system"),
 	stop: () => Effect.die("stop not supported in stub system"),
+	events: Stream.empty,
+	get actors() {
+		return /* @__PURE__ */ new Map();
+	},
+	subscribe: () => () => {},
 	listPersisted: () => Effect.die("listPersisted not supported in stub system"),
 	restoreMany: () => Effect.die("restoreMany not supported in stub system"),
 	restoreAll: () => Effect.die("restoreAll not supported in stub system")

package/dist/persistence/persistent-actor.js

@@ -31,7 +31,7 @@ const replayEvents = Effect.fn("effect-machine.persistentActor.replayEvents")(fu
 /**
 * Build PersistentActorRef with all methods
 */
-const buildPersistentActorRef = (id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, stop, adapter, system) => {
+const buildPersistentActorRef = (id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, stop, adapter, system, childrenMap) => {
 	const { machine, persistence } = persistentMachine;
 	const typedMachine = machine;
 	const persist = Effect.gen(function* () {
@@ -71,7 +71,7 @@ const buildPersistentActorRef = (id, persistentMachine, stateRef, versionRef, ev
 		}
 	});
 	return {
-		...buildActorRefCore(id, typedMachine, stateRef, eventQueue, stoppedRef, listeners, stop, system),
+		...buildActorRefCore(id, typedMachine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap),
 		persist,
 		version,
 		replayTo
@@ -92,12 +92,21 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	const inspector = 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.persistentActor.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;
+		})
 	};
 	let resolvedInitial;
 	let initialVersion;
@@ -167,7 +176,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 			finalState: resolvedInitial,
 			timestamp
 		}));
-		return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system);
+		return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system, childrenMap);
 	}
 	const loopFiber = yield* Effect.forkDaemon(persistentEventLoop(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, self, listeners, adapter, createdAt, stateScopeRef, backgroundFibers, snapshotQueue, snapshotEnabledRef, persistenceQueue, snapshotFiber, persistenceFiber, inspector, system));
 	return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
@@ -184,7 +193,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 		yield* Fiber.interrupt(snapshotFiber);
 		yield* Fiber.interrupt(persistenceFiber);
-	}).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system);
+	}).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system, childrenMap);
 });
 /**
 * Main event loop for persistent actor

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-machine",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"