effect-machine 0.4.0 → 0.7.0

package/dist/internal/brands.d.ts

@@ -1,10 +1,8 @@
 import { Brand } from "effect";
 
 //#region src/internal/brands.d.ts
-declare const StateTypeId: unique symbol;
-declare const EventTypeId: unique symbol;
-type StateTypeId = typeof StateTypeId;
-type EventTypeId = typeof EventTypeId;
+type StateTypeId = "effect-machine/StateTypeId";
+type EventTypeId = "effect-machine/EventTypeId";
 interface StateBrand extends Brand.Brand<StateTypeId> {}
 interface EventBrand extends Brand.Brand<EventTypeId> {}
 type BrandedState = {
@@ -13,8 +11,7 @@ type BrandedState = {
 type BrandedEvent = {
   readonly _tag: string;
 } & EventBrand;
-declare const SchemaIdTypeId: unique symbol;
-type SchemaIdTypeId = typeof SchemaIdTypeId;
+type SchemaIdTypeId = "effect-machine/SchemaIdTypeId";
 /**
  * Brand that captures the schema definition type D.
  * Two schemas with identical definition shapes will have compatible brands.

package/dist/internal/inspection.js

@@ -8,7 +8,11 @@ import { Clock, Effect } from "effect";
 const emitWithTimestamp = Effect.fn("effect-machine.emitWithTimestamp")(function* (inspector, makeEvent) {
 	if (inspector === void 0) return;
 	const timestamp = yield* Clock.currentTimeMillis;
-	yield* Effect.try(() => inspector.onInspect(makeEvent(timestamp))).pipe(Effect.ignore);
+	yield* Effect.sync(() => {
+		try {
+			inspector.onInspect(makeEvent(timestamp));
+		} catch {}
+	});
 });
 
 //#endregion

package/dist/internal/transition.d.ts

@@ -102,7 +102,7 @@ declare const processEventCore: <S extends {
 }, E extends {
   readonly _tag: string;
 }, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
-  current: Scope.CloseableScope;
+  current: Scope.Closeable;
 }, system: ActorSystem, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
   newState: S;
   previousState: S;
@@ -119,7 +119,7 @@ declare const runSpawnEffects: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.CloseableScope, system: ActorSystem, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystem, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, 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/transition.js

@@ -77,8 +77,8 @@ const executeTransition = Effect.fn("effect-machine.executeTransition")(function
 * @internal
 */
 const processEventCore = Effect.fn("effect-machine.processEventCore")(function* (machine, currentState, event, self, stateScopeRef, system, hooks) {
-	const result = yield* executeTransition(machine, currentState, event, self, system).pipe(Effect.catchAllCause((cause) => {
-		if (Cause.isInterruptedOnly(cause)) return Effect.interrupt;
+	const result = yield* executeTransition(machine, currentState, event, self, system).pipe(Effect.catchCause((cause) => {
+		if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
 		const onError = hooks?.onError;
 		if (onError === void 0) return Effect.failCause(cause).pipe(Effect.orDie);
 		return onError({
@@ -86,7 +86,7 @@ const processEventCore = Effect.fn("effect-machine.processEventCore")(function*
 			state: currentState,
 			event,
 			cause
-		}).pipe(Effect.zipRight(Effect.failCause(cause).pipe(Effect.orDie)));
+		}).pipe(Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
 	}));
 	if (!result.transitioned) return {
 		newState: currentState,
@@ -134,15 +134,15 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 			self,
 			effects: effectSlots,
 			system
-		}).pipe(Effect.provideService(machine.Context, ctx), Effect.catchAllCause((cause) => {
-			if (Cause.isInterruptedOnly(cause)) return Effect.interrupt;
+		}).pipe(Effect.provideService(machine.Context, ctx), Effect.catchCause((cause) => {
+			if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
 			if (reportError === void 0) return Effect.failCause(cause).pipe(Effect.orDie);
 			return reportError({
 				phase: "spawn",
 				state,
 				event,
 				cause
-			}).pipe(Effect.zipRight(Effect.failCause(cause).pipe(Effect.orDie)));
+			}).pipe(Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
 		}));
 		yield* Effect.forkScoped(effect).pipe(Effect.provideService(Scope.Scope, stateScope));
 	}

package/dist/internal/utils.js

@@ -1,7 +1,11 @@
-import { Effect } from "effect";
+import { Effect, Stream } from "effect";
 
 //#region src/internal/utils.ts
 /**
+* Internal utilities for effect-machine.
+* @internal
+*/
+/**
 * Internal event tags used for lifecycle effect contexts.
 * Prefixed with $ to distinguish from user events.
 * @internal
@@ -25,7 +29,7 @@ const getTag = (constructorOrValue) => {
 	}
 };
 /** Check if a value is an Effect */
-const isEffect = (value) => typeof value === "object" && value !== null && Effect.EffectTypeId in value;
+const isEffect = Effect.isEffect;
 /**
 * Stub ActorSystem that dies on any method call.
 * Used in contexts where spawning/system access isn't supported
@@ -37,6 +41,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/machine.d.ts

@@ -7,7 +7,7 @@ import { DuplicateActorError } from "./errors.js";
 import { findTransitions } from "./internal/transition.js";
 import "./persistence/index.js";
 import { ActorRef, ActorSystem } from "./actor.js";
-import { Cause, Context, Effect, Schedule, Schema, Scope } from "effect";
+import { Cause, Effect, Schedule, Schema, Scope, ServiceMap } from "effect";
 
 //#region src/machine.d.ts
 declare namespace machine_d_exports {
@@ -159,13 +159,13 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
     guards: GuardSlots<GD>;
     effects: EffectSlots<EFD>;
   };
-  readonly stateSchema?: Schema.Schema<State, unknown, never>;
-  readonly eventSchema?: Schema.Schema<Event, unknown, never>;
+  readonly stateSchema?: Schema.Schema<State>;
+  readonly eventSchema?: Schema.Schema<Event>;
   /**
    * Context tag for accessing machine state/event/self in slot handlers.
    * Uses shared module-level tag for all machines.
    */
-  readonly Context: Context.Tag<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
+  readonly Context: ServiceMap.Service<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
   get transitions(): ReadonlyArray<Transition<State, Event, GD, EFD, R>>;
   get spawnEffects(): ReadonlyArray<SpawnEffect<State, Event, EFD, R>>;
   get backgroundEffects(): ReadonlyArray<BackgroundEffect<State, Event, EFD, R>>;
@@ -173,7 +173,7 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
   get guardsSchema(): GuardsSchema<GD> | undefined;
   get effectsSchema(): EffectsSchema<EFD> | undefined;
   /** @internal */
-  constructor(initial: State, stateSchema?: Schema.Schema<State, unknown, never>, eventSchema?: Schema.Schema<Event, unknown, never>, guardsSchema?: GuardsSchema<GD>, effectsSchema?: EffectsSchema<EFD>);
+  constructor(initial: State, stateSchema?: Schema.Schema<State>, eventSchema?: Schema.Schema<Event>, guardsSchema?: GuardsSchema<GD>, effectsSchema?: EffectsSchema<EFD>);
   /** Register transition for a single state */
   on<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, GD, EFD, never>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /** Register transition for multiple states (handler receives union of state types) */

package/dist/machine.js

@@ -98,7 +98,9 @@ var Machine = class Machine {
 		this.stateSchema = stateSchema;
 		this.eventSchema = eventSchema;
 		this._slots = {
-			guards: this._guardsSchema !== void 0 ? this._guardsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOptional(this.Context).pipe(Effect.orDie), (ctx) => {
+			guards: this._guardsSchema !== void 0 ? this._guardsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOption(this.Context), (maybeCtx) => {
+				if (Option.isNone(maybeCtx)) return Effect.die("MachineContext not available");
+				const ctx = maybeCtx.value;
 				const handler = this._guardHandlers.get(name);
 				if (handler === void 0) return Effect.die(new SlotProvisionError({
 					slotName: name,
@@ -107,7 +109,9 @@ var Machine = class Machine {
 				const result = handler(params, ctx);
 				return typeof result === "boolean" ? Effect.succeed(result) : result;
 			})) : {},
-			effects: this._effectsSchema !== void 0 ? this._effectsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOptional(this.Context).pipe(Effect.orDie), (ctx) => {
+			effects: this._effectsSchema !== void 0 ? this._effectsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOption(this.Context), (maybeCtx) => {
+				if (Option.isNone(maybeCtx)) return Effect.die("MachineContext not available");
+				const ctx = maybeCtx.value;
 				const handler = this._effectHandlers.get(name);
 				if (handler === void 0) return Effect.die(new SlotProvisionError({
 					slotName: name,
@@ -194,14 +198,14 @@ var Machine = class Machine {
 			const exit = yield* Effect.exit(run(ctx));
 			if (Exit.isSuccess(exit)) {
 				yield* ctx.self.send(options.onSuccess(exit.value, ctx));
-				yield* Effect.yieldNow();
+				yield* Effect.yieldNow;
 				return;
 			}
 			const cause = exit.cause;
-			if (Cause.isInterruptedOnly(cause)) return;
+			if (Cause.hasInterruptsOnly(cause)) return;
 			if (options.onFailure !== void 0) {
 				yield* ctx.self.send(options.onFailure(cause, ctx));
-				yield* Effect.yieldNow();
+				yield* Effect.yieldNow;
 				return;
 			}
 			return yield* Effect.failCause(cause).pipe(Effect.orDie);

package/dist/persistence/adapter.d.ts

@@ -1,6 +1,7 @@
 import { DuplicateActorError } from "../errors.js";
 import { PersistentActorRef } from "./persistent-actor.js";
-import { Context, Effect, Option, Schema } from "effect";
+import { Effect, Option, Schema, ServiceMap } from "effect";
+import * as effect_Cause0 from "effect/Cause";
 
 //#region src/persistence/adapter.d.ts
 /**
@@ -64,20 +65,20 @@ interface PersistenceAdapter {
    * Save a snapshot of actor state.
    * Implementations should use optimistic locking — fail if version mismatch.
    */
-  readonly saveSnapshot: <S, SI>(id: string, snapshot: Snapshot<S>, schema: Schema.Schema<S, SI, never>) => Effect.Effect<void, PersistenceError | VersionConflictError>;
+  readonly saveSnapshot: <S>(id: string, snapshot: Snapshot<S>, schema: Schema.Codec<S, unknown, never, never>) => Effect.Effect<void, PersistenceError | VersionConflictError>;
   /**
    * Load the latest snapshot for an actor.
    * Returns None if no snapshot exists.
    */
-  readonly loadSnapshot: <S, SI>(id: string, schema: Schema.Schema<S, SI, never>) => Effect.Effect<Option.Option<Snapshot<S>>, PersistenceError>;
+  readonly loadSnapshot: <S>(id: string, schema: Schema.Codec<S, unknown, never, never>) => Effect.Effect<Option.Option<Snapshot<S>>, PersistenceError>;
   /**
    * Append an event to the actor's event journal.
    */
-  readonly appendEvent: <E, EI>(id: string, event: PersistedEvent<E>, schema: Schema.Schema<E, EI, never>) => Effect.Effect<void, PersistenceError>;
+  readonly appendEvent: <E>(id: string, event: PersistedEvent<E>, schema: Schema.Codec<E, unknown, never, never>) => Effect.Effect<void, PersistenceError>;
   /**
    * Load events from the journal, optionally after a specific version.
    */
-  readonly loadEvents: <E, EI>(id: string, schema: Schema.Schema<E, EI, never>, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<E>>, PersistenceError>;
+  readonly loadEvents: <E>(id: string, schema: Schema.Codec<E, unknown, never, never>, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<E>>, PersistenceError>;
   /**
    * Delete all persisted data for an actor (snapshot + events).
    */
@@ -106,30 +107,26 @@ interface PersistenceAdapter {
    */
   readonly loadMetadata?: (id: string) => Effect.Effect<Option.Option<ActorMetadata>, PersistenceError>;
 }
-declare const PersistenceError_base: Schema.TaggedErrorClass<PersistenceError, "PersistenceError", {
-  readonly _tag: Schema.tag<"PersistenceError">;
-} & {
-  operation: typeof Schema.String;
-  actorId: typeof Schema.String;
-  cause: Schema.optional<typeof Schema.Unknown>;
-  message: Schema.optional<typeof Schema.String>;
-}>;
+declare const PersistenceError_base: Schema.ErrorClass<PersistenceError, Schema.TaggedStruct<"PersistenceError", {
+  readonly operation: Schema.String;
+  readonly actorId: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+  readonly message: Schema.optional<Schema.String>;
+}>, effect_Cause0.YieldableError>;
 /**
  * Error type for persistence operations
  */
 declare class PersistenceError extends PersistenceError_base {}
-declare const VersionConflictError_base: Schema.TaggedErrorClass<VersionConflictError, "VersionConflictError", {
-  readonly _tag: Schema.tag<"VersionConflictError">;
-} & {
-  actorId: typeof Schema.String;
-  expectedVersion: typeof Schema.Number;
-  actualVersion: typeof Schema.Number;
-}>;
+declare const VersionConflictError_base: Schema.ErrorClass<VersionConflictError, Schema.TaggedStruct<"VersionConflictError", {
+  readonly actorId: Schema.String;
+  readonly expectedVersion: Schema.Number;
+  readonly actualVersion: Schema.Number;
+}>, effect_Cause0.YieldableError>;
 /**
  * Version conflict error — snapshot version doesn't match expected
  */
 declare class VersionConflictError extends VersionConflictError_base {}
-declare const PersistenceAdapterTag_base: Context.TagClass<PersistenceAdapterTag, "effect-machine/src/persistence/adapter/PersistenceAdapterTag", PersistenceAdapter>;
+declare const PersistenceAdapterTag_base: ServiceMap.ServiceClass<PersistenceAdapterTag, "effect-machine/src/persistence/adapter/PersistenceAdapterTag", PersistenceAdapter>;
 /**
  * PersistenceAdapter service tag
  */

package/dist/persistence/adapter.js

@@ -1,10 +1,10 @@
-import { Context, Schema } from "effect";
+import { Schema, ServiceMap } from "effect";
 
 //#region src/persistence/adapter.ts
 /**
 * Error type for persistence operations
 */
-var PersistenceError = class extends Schema.TaggedError()("PersistenceError", {
+var PersistenceError = class extends Schema.TaggedErrorClass()("PersistenceError", {
 	operation: Schema.String,
 	actorId: Schema.String,
 	cause: Schema.optional(Schema.Unknown),
@@ -13,7 +13,7 @@ var PersistenceError = class extends Schema.TaggedError()("PersistenceError", {
 /**
 * Version conflict error — snapshot version doesn't match expected
 */
-var VersionConflictError = class extends Schema.TaggedError()("VersionConflictError", {
+var VersionConflictError = class extends Schema.TaggedErrorClass()("VersionConflictError", {
 	actorId: Schema.String,
 	expectedVersion: Schema.Number,
 	actualVersion: Schema.Number
@@ -21,7 +21,7 @@ var VersionConflictError = class extends Schema.TaggedError()("VersionConflictEr
 /**
 * PersistenceAdapter service tag
 */
-var PersistenceAdapterTag = class extends Context.Tag("effect-machine/src/persistence/adapter/PersistenceAdapterTag")() {};
+var PersistenceAdapterTag = class extends ServiceMap.Service()("effect-machine/src/persistence/adapter/PersistenceAdapterTag") {};
 
 //#endregion
 export { PersistenceAdapterTag, PersistenceError, VersionConflictError };

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

@@ -42,7 +42,7 @@ const make = Effect.gen(function* () {
 					actualVersion: snapshot.version
 				});
 			}
-			const encoded = yield* Schema.encode(schema)(snapshot.state).pipe(Effect.mapError((cause) => new PersistenceError({
+			const encoded = yield* Schema.encodeEffect(schema)(snapshot.state).pipe(Effect.mapError((cause) => new PersistenceError({
 				operation: "saveSnapshot",
 				actorId: id,
 				cause,
@@ -61,7 +61,7 @@ const make = Effect.gen(function* () {
 			const actorStorage = yield* getOrCreateStorage(id);
 			if (Option.isNone(actorStorage.snapshot)) return Option.none();
 			const stored = actorStorage.snapshot.value;
-			const decoded = yield* Schema.decode(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
+			const decoded = yield* Schema.decodeEffect(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
 				operation: "loadSnapshot",
 				actorId: id,
 				cause,
@@ -75,7 +75,7 @@ const make = Effect.gen(function* () {
 		}),
 		appendEvent: Effect.fn("effect-machine.persistence.inMemory.appendEvent")(function* (id, event, schema) {
 			yield* getOrCreateStorage(id);
-			const encoded = yield* Schema.encode(schema)(event.event).pipe(Effect.mapError((cause) => new PersistenceError({
+			const encoded = yield* Schema.encodeEffect(schema)(event.event).pipe(Effect.mapError((cause) => new PersistenceError({
 				operation: "appendEvent",
 				actorId: id,
 				cause,
@@ -95,7 +95,7 @@ const make = Effect.gen(function* () {
 			const decoded = [];
 			for (const stored of actorStorage.events) {
 				if (afterVersion !== void 0 && stored.version <= afterVersion) continue;
-				const event = yield* Schema.decode(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
+				const event = yield* Schema.decodeEffect(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
 					operation: "loadEvents",
 					actorId: id,
 					cause,

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;
@@ -130,10 +139,10 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	}));
 	const snapshotEnabledRef = yield* Ref.make(true);
 	const persistenceQueue = yield* Queue.unbounded();
-	const persistenceFiber = yield* Effect.forkDaemon(persistenceWorker(persistenceQueue));
+	const persistenceFiber = yield* Effect.forkDetach(persistenceWorker(persistenceQueue));
 	yield* Queue.offer(persistenceQueue, saveMetadata(id, resolvedInitial, initialVersion, createdAt, persistence, adapter));
 	const snapshotQueue = yield* Queue.unbounded();
-	const snapshotFiber = yield* Effect.forkDaemon(snapshotWorker(id, persistence, adapter, snapshotQueue, snapshotEnabledRef));
+	const snapshotFiber = yield* Effect.forkDetach(snapshotWorker(id, persistence, adapter, snapshotQueue, snapshotEnabledRef));
 	const backgroundFibers = [];
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
 	const initCtx = {
@@ -144,7 +153,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	};
 	const { effects: effectSlots } = typedMachine._slots;
 	for (const bg of typedMachine.backgroundEffects) {
-		const fiber = yield* Effect.forkDaemon(bg.handler({
+		const fiber = yield* Effect.forkDetach(bg.handler({
 			state: resolvedInitial,
 			event: initEvent,
 			self,
@@ -167,9 +176,9 @@ 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));
+	const loopFiber = yield* Effect.forkDetach(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* () {
 		const finalState = yield* SubscriptionRef.get(stateRef);
 		yield* emitWithTimestamp(inspector, (timestamp) => ({
@@ -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
@@ -241,7 +250,7 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 				version: newVersion,
 				timestamp: yield* now
 			};
-			const journalTask = adapter.appendEvent(id, persistedEvent, persistence.eventSchema).pipe(Effect.catchAll((e) => Effect.logWarning(`Failed to journal event for actor ${id}`, e)), Effect.asVoid);
+			const journalTask = adapter.appendEvent(id, persistedEvent, persistence.eventSchema).pipe(Effect.catchEager((e) => Effect.logWarning(`Failed to journal event for actor ${id}`, e)), Effect.asVoid);
 			yield* Queue.offer(persistenceQueue, journalTask);
 		}
 		yield* Queue.offer(persistenceQueue, saveMetadata(id, result.newState, newVersion, createdAt, persistence, adapter));
@@ -297,11 +306,11 @@ const persistenceWorker = Effect.fn("effect-machine.persistentActor.persistenceW
 * Snapshot scheduler worker (runs in background).
 */
 const snapshotWorker = Effect.fn("effect-machine.persistentActor.snapshotWorker")(function* (id, persistence, adapter, queue, enabledRef) {
-	const driver = yield* Schedule.driver(persistence.snapshotSchedule);
+	const step = yield* Schedule.toStep(persistence.snapshotSchedule);
 	while (true) {
 		const { state, version } = yield* Queue.take(queue);
 		if (!(yield* Ref.get(enabledRef))) continue;
-		if (!(yield* driver.next(state).pipe(Effect.match({
+		if (!(yield* step(yield* Clock.currentTimeMillis, state).pipe(Effect.match({
 			onFailure: () => false,
 			onSuccess: () => true
 		})))) {
@@ -321,7 +330,7 @@ const saveSnapshot = Effect.fn("effect-machine.persistentActor.saveSnapshot")(fu
 		version,
 		timestamp: yield* now
 	};
-	yield* adapter.saveSnapshot(id, snapshot, persistence.stateSchema).pipe(Effect.catchAll((e) => Effect.logWarning(`Failed to save snapshot for actor ${id}`, e)));
+	yield* adapter.saveSnapshot(id, snapshot, persistence.stateSchema).pipe(Effect.catchEager((e) => Effect.logWarning(`Failed to save snapshot for actor ${id}`, e)));
 });
 /**
 * Save or update actor metadata if adapter supports registry.
@@ -338,7 +347,7 @@ const saveMetadata = Effect.fn("effect-machine.persistentActor.saveMetadata")(fu
 		lastActivityAt,
 		version,
 		stateTag: state._tag
-	}).pipe(Effect.catchAll((e) => Effect.logWarning(`Failed to save metadata for actor ${id}`, e)));
+	}).pipe(Effect.catchEager((e) => Effect.logWarning(`Failed to save metadata for actor ${id}`, e)));
 });
 /**
 * Restore an actor from persistence.

package/dist/persistence/persistent-machine.d.ts

@@ -16,7 +16,7 @@ type BrandedEvent = {
  * Note: Schema types S and E should match the structural shape of the machine's
  * state and event types (without brands). The schemas don't know about brands.
  */
-interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
+interface PersistenceConfig<S, E> {
   /**
    * Schedule controlling when snapshots are taken.
    * Input is the new state after each transition.
@@ -36,12 +36,12 @@ interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
    * Schema for serializing/deserializing state.
    * Always present at runtime (resolved from config or machine).
    */
-  readonly stateSchema: Schema.Schema<S, SSI, never>;
+  readonly stateSchema: Schema.Codec<S, unknown, never, never>;
   /**
    * Schema for serializing/deserializing events.
    * Always present at runtime (resolved from config or machine).
    */
-  readonly eventSchema: Schema.Schema<E, ESI, never>;
+  readonly eventSchema: Schema.Codec<E, unknown, never, never>;
   /**
    * User-provided identifier for the machine type.
    * Used for filtering actors in restoreAll.

package/dist/schema.d.ts

@@ -36,8 +36,8 @@ type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends n
  */
 type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & {
   readonly derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
-} : ((args: Schema.Struct.Constructor<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
-  readonly derive: (source: object, partial?: Partial<Schema.Struct.Constructor<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
+} : ((args: Schema.Struct.Type<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
+  readonly derive: (source: object, partial?: Partial<Schema.Struct.Type<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
   readonly _tag: K;
 } };
 /**
@@ -78,14 +78,14 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
  * The D type parameter captures the definition, creating a unique brand
  * per distinct schema definition shape.
  */
-type MachineStateSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Schema<VariantsUnion<D> & FullStateBrand<D>, VariantsUnion<D>, never> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<D, FullStateBrand<D>>;
+type MachineStateSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Codec<VariantsUnion<D> & FullStateBrand<D>, unknown, never, never> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<D, FullStateBrand<D>>;
 /**
  * Schema-first event definition (same structure as state, different brand)
  *
  * The D type parameter captures the definition, creating a unique brand
  * per distinct schema definition shape.
  */
-type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Schema<VariantsUnion<D> & FullEventBrand<D>, VariantsUnion<D>, never> & MachineSchemaBase<D, FullEventBrand<D>> & VariantConstructors<D, FullEventBrand<D>>;
+type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Codec<VariantsUnion<D> & FullEventBrand<D>, unknown, never, never> & MachineSchemaBase<D, FullEventBrand<D>> & VariantConstructors<D, FullEventBrand<D>>;
 /**
  * Create a schema-first State definition.
  *

package/dist/schema.js

@@ -69,8 +69,8 @@ const buildMachineSchema = (definition) => {
 		};
 	}
 	const variantArray = Object.values(variants);
-	if (variantArray.length === 0) throw new InvalidSchemaError();
-	const unionSchema = variantArray.length === 1 ? variantArray[0] : Schema.Union(...variantArray);
+	if (variantArray.length === 0) throw new InvalidSchemaError({});
+	const unionSchema = variantArray.length === 1 ? variantArray[0] : Schema.Union(variantArray);
 	const $is = (tag) => (u) => typeof u === "object" && u !== null && "_tag" in u && u._tag === tag;
 	const $match = (valueOrCases, maybeCases) => {
 		if (maybeCases !== void 0) {

package/dist/slot.d.ts

@@ -1,9 +1,9 @@
 import { ActorSystem } from "./actor.js";
-import { Context, Effect, Schema } from "effect";
+import { Effect, Schema, ServiceMap } from "effect";
 
 //#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
-type Fields = Record<string, Schema.Schema.All>;
+type Fields = Record<string, Schema.Top>;
 /** Extract the encoded type from schema fields (used for parameters) */
 type FieldsToParams<F extends Fields> = keyof F extends never ? void : Schema.Schema.Type<Schema.Struct<F>>;
 /**
@@ -53,7 +53,7 @@ interface MachineContext<State, Event, Self> {
  * Single module-level tag instead of per-machine allocation.
  * @internal
  */
-declare const MachineContextTag: Context.Tag<MachineContext<any, any, any>, MachineContext<any, any, any>>;
+declare const MachineContextTag: ServiceMap.Service<MachineContext<any, any, any>, MachineContext<any, any, any>>;
 /**
  * Guard handler implementation.
  * Receives params and context, returns Effect<boolean>.

package/dist/slot.js

@@ -1,4 +1,4 @@
-import { Context } from "effect";
+import { ServiceMap } from "effect";
 
 //#region src/slot.ts
 /**
@@ -41,7 +41,7 @@ import { Context } from "effect";
 * Single module-level tag instead of per-machine allocation.
 * @internal
 */
-const MachineContextTag = Context.GenericTag("@effect-machine/Context");
+const MachineContextTag = ServiceMap.Service("@effect-machine/Context");
 /**
 * Generic slot schema factory. Used internally by Guards() and Effects().
 * @internal

package/dist-v3/_virtual/_rolldown/runtime.js

@@ -0,0 +1,18 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll };