effect-machine 0.13.0 → 0.15.0

package/v3/dist/actor.js

@@ -12,7 +12,7 @@ import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, O
 * Combines:
 * - ActorRef interface (running actor handle)
 * - ActorSystem service (spawn/stop/get actors)
-* - Actor creation (delegates to runtime kernel)
+* - Actor creation and event loop
 */
 /**
 * ActorSystem service tag
@@ -29,7 +29,7 @@ const notifyListeners = (listeners, state) => {
 /**
 * Build core ActorRef methods.
 */
-const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, system, childrenMap, pendingReplies, transitionsPubSub, exitDeferred) => {
+const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, start, system, childrenMap, pendingReplies, transitionsPubSub, exitDeferred) => {
 	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) return;
 		const q = yield* Ref.get(eventQueueRef);
@@ -116,6 +116,7 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 		ask,
 		state: stateRef,
 		stop,
+		start,
 		snapshot,
 		matches,
 		can,
@@ -163,60 +164,116 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 		children: childrenMap
 	};
 };
+/** Build ProcessEventHooks from an inspector */
+const buildInspectionHooks = (actorId, inspector) => ({
+	onSpawnEffect: (state) => emitWithTimestamp(inspector, (timestamp) => ({
+		type: "@machine.effect",
+		actorId,
+		effectType: "spawn",
+		state,
+		timestamp
+	})),
+	onTransition: (from, to, ev) => emitWithTimestamp(inspector, (timestamp) => ({
+		type: "@machine.transition",
+		actorId,
+		fromState: from,
+		toState: to,
+		event: ev,
+		timestamp
+	})),
+	onError: (info) => emitWithTimestamp(inspector, (timestamp) => ({
+		type: "@machine.error",
+		actorId,
+		phase: info.phase,
+		state: info.state,
+		event: info.event,
+		error: Cause.pretty(info.cause),
+		timestamp
+	}))
+});
+/**
+* Resolve actor system from context, creating an implicit one if none exists.
+* @internal
+*/
+const resolveActorSystem = Effect.fn("effect-machine.resolveActorSystem")(function* () {
+	const existingSystem = yield* Effect.serviceOption(ActorSystem);
+	if (Option.isSome(existingSystem)) return {
+		system: existingSystem.value,
+		implicitSystemScope: void 0
+	};
+	const scope = yield* Scope.make();
+	return {
+		system: yield* make().pipe(Effect.provideService(Scope.Scope, scope)),
+		implicitSystemScope: scope
+	};
+});
+/**
+* Run the supervision loop for a supervised actor.
+* Observes exit deferred, applies restart policy, resets cell resources on restart.
+* @internal
+*/
+const runSupervisionLoop = (params) => Effect.gen(function* () {
+	const driver = yield* Schedule.driver(params.supervision.schedule);
+	let generation = 0;
+	while (true) {
+		const currentRuntime = params.runtimeRef.current;
+		if (currentRuntime === void 0) return;
+		const generationExit = yield* Deferred.await(currentRuntime.exitDeferred);
+		if (generationExit._tag !== "Defect") {
+			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			return;
+		}
+		if (params.supervision.shouldRestart !== void 0 && !params.supervision.shouldRestart(generationExit)) {
+			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			return;
+		}
+		if ((yield* driver.next(generationExit).pipe(Effect.exit))._tag === "Failure") {
+			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			return;
+		}
+		let restartState = params.machine.initial;
+		if (params.lifecycle?.recovery !== void 0) {
+			const resolved = yield* params.lifecycle.recovery.resolve({
+				actorId: params.id,
+				generation: generation + 1,
+				machineInitial: params.machine.initial
+			});
+			if (Option.isSome(resolved)) restartState = resolved.value;
+		}
+		yield* settlePendingReplies(params.pendingReplies, params.id);
+		const freshQueue = yield* Queue.unbounded();
+		yield* Ref.set(params.eventQueueRef, freshQueue);
+		yield* SubscriptionRef.set(params.stateRef, restartState);
+		yield* Ref.set(params.stoppedRef, false);
+		params.childrenMap.clear();
+		const machineForRestart = restartState !== params.machine.initial ? Object.create(params.machine, { initial: {
+			value: restartState,
+			enumerable: true
+		} }) : params.machine;
+		const newRuntime = yield* params.spawnGeneration(machineForRestart);
+		params.runtimeRef.current = newRuntime;
+		yield* newRuntime.start;
+		generation++;
+		if (params.onRestart !== void 0) yield* params.onRestart(generation, generationExit);
+		notifyListeners(params.listeners, restartState);
+	}
+});
 /**
 * Create and start an actor for a machine.
-* Uses the shared runtime kernel with lifecycle hooks for actor-specific concerns.
+* Delegates to the shared runtime kernel with actor-specific lifecycle hooks.
 */
 const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine, options) {
+	const lifecycle = options?.lifecycle;
 	const initial = options?.initialState ?? machine.initial;
 	yield* Effect.annotateCurrentSpan("effect_machine.actor.id", id);
 	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", initial._tag);
-	const existingSystem = yield* Effect.serviceOption(ActorSystem);
-	let system;
-	let implicitSystemScope;
-	if (Option.isSome(existingSystem)) system = existingSystem.value;
-	else {
-		const scope = yield* Scope.make();
-		system = yield* make().pipe(Effect.provideService(Scope.Scope, scope));
-		implicitSystemScope = scope;
-	}
+	const { system, implicitSystemScope } = yield* resolveActorSystem();
 	const inspectorValue = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
 	const childrenMap = /* @__PURE__ */ new Map();
 	const pendingReplies = /* @__PURE__ */ new Set();
 	const listeners = /* @__PURE__ */ new Set();
 	const transitionsPubSub = yield* PubSub.unbounded();
-	yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
-		type: "@machine.spawn",
-		actorId: id,
-		initialState: initial,
-		timestamp
-	}));
-	const hooks = inspectorValue === void 0 ? void 0 : {
-		onSpawnEffect: (state) => emitWithTimestamp(inspectorValue, (timestamp) => ({
-			type: "@machine.effect",
-			actorId: id,
-			effectType: "spawn",
-			state,
-			timestamp
-		})),
-		onTransition: (from, to, ev) => emitWithTimestamp(inspectorValue, (timestamp) => ({
-			type: "@machine.transition",
-			actorId: id,
-			fromState: from,
-			toState: to,
-			event: ev,
-			timestamp
-		})),
-		onError: (info) => emitWithTimestamp(inspectorValue, (timestamp) => ({
-			type: "@machine.error",
-			actorId: id,
-			phase: info.phase,
-			state: info.state,
-			event: info.event,
-			error: Cause.pretty(info.cause),
-			timestamp
-		}))
-	};
+	const hooks = inspectorValue !== void 0 ? buildInspectionHooks(id, inspectorValue) : void 0;
 	const machineWithState = initial !== machine.initial ? Object.create(machine, { initial: {
 		value: initial,
 		enumerable: true
@@ -227,6 +284,7 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	const eventQueueRef = yield* Ref.make(initialQueue);
 	const terminalExitDeferred = yield* Deferred.make();
 	let stopEmitted = false;
+	let generation = 0;
 	const runtimeRef = { current: void 0 };
 	/** Build lifecycle hooks for a generation */
 	const buildLifecycle = () => {
@@ -239,8 +297,18 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 				event,
 				timestamp
 			})) : void 0,
-			onStateChange: (result, _event) => Effect.gen(function* () {
+			onStateChange: (result, event) => Effect.gen(function* () {
 				notifyListeners(listeners, result.newState);
+				if (lifecycle?.durability !== void 0 && result.transitioned) {
+					const durability = lifecycle.durability;
+					if (durability.shouldSave === void 0 || durability.shouldSave(result.newState, result.previousState)) yield* durability.save({
+						actorId: id,
+						generation,
+						previousState: result.previousState,
+						nextState: result.newState,
+						event
+					});
+				}
 				yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", true);
 				if (result.lifecycleRan) {
 					yield* Effect.annotateCurrentSpan("effect_machine.state.from", result.previousState._tag);
@@ -282,7 +350,7 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 			})) : void 0
 		};
 	};
-	/** Create a single runtime generation */
+	/** Create a single runtime generation. machineForGen is machineWithState for initial, machine for restarts. */
 	const spawnGeneration = (machineForGen) => Ref.get(eventQueueRef).pipe(Effect.flatMap((currentQueue) => createRuntime(machineForGen, system, {
 		actorId: id,
 		hooks,
@@ -306,49 +374,62 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 			}));
 		})
 	})));
+	runtimeRef.current = yield* spawnGeneration(machineWithState);
 	const supervision = options?.supervision;
-	const runtime = yield* spawnGeneration(machineWithState);
-	runtimeRef.current = runtime;
-	let supervisorFiber;
-	if (supervision !== void 0) supervisorFiber = yield* Effect.forkDaemon(Effect.gen(function* () {
-		const driver = yield* Schedule.driver(supervision.schedule);
-		let generation = 0;
-		while (true) {
-			const currentRuntime = runtimeRef.current;
-			if (currentRuntime === void 0) return;
-			const generationExit = yield* Deferred.await(currentRuntime.exitDeferred);
-			if (generationExit._tag !== "Defect") {
-				yield* Deferred.succeed(terminalExitDeferred, generationExit);
-				return;
-			}
-			if (supervision.shouldRestart !== void 0 && !supervision.shouldRestart(generationExit)) {
-				yield* Deferred.succeed(terminalExitDeferred, generationExit);
-				return;
-			}
-			if ((yield* driver.next(generationExit).pipe(Effect.exit))._tag === "Failure") {
-				yield* Deferred.succeed(terminalExitDeferred, generationExit);
-				return;
-			}
-			yield* settlePendingReplies(pendingReplies, id);
-			const freshQueue = yield* Queue.unbounded();
-			yield* Ref.set(eventQueueRef, freshQueue);
-			yield* SubscriptionRef.set(stateRef, machine.initial);
-			yield* Ref.set(stoppedRef, false);
-			childrenMap.clear();
-			runtimeRef.current = yield* spawnGeneration(machine);
-			generation++;
-			if (options?.onRestart !== void 0) yield* options.onRestart(generation, generationExit);
-			notifyListeners(listeners, machine.initial);
-		}
-	}));
-	else yield* Deferred.await(runtime.exitDeferred).pipe(Effect.tap((exit) => Deferred.succeed(terminalExitDeferred, exit)), Effect.catchAllCause(() => Effect.void), Effect.fork);
-	return buildActorRefCore(id, machine, stateRef, eventQueueRef, stoppedRef, listeners, Effect.gen(function* () {
-		if (supervisorFiber !== void 0) yield* Fiber.interrupt(supervisorFiber);
+	const supervisorFiberRef = { current: void 0 };
+	const stop = Effect.gen(function* () {
+		if (supervisorFiberRef.current !== void 0) yield* Fiber.interrupt(supervisorFiberRef.current);
 		const currentRuntime = runtimeRef.current;
 		if (currentRuntime !== void 0) yield* currentRuntime.stop;
 		yield* Deferred.succeed(terminalExitDeferred, { _tag: "Stopped" });
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap, pendingReplies, transitionsPubSub, terminalExitDeferred);
+	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid);
+	const isHydrated = options?.initialState !== void 0;
+	return buildActorRefCore(id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, Effect.gen(function* () {
+		if (lifecycle?.recovery !== void 0 && !isHydrated) {
+			const resolved = yield* lifecycle.recovery.resolve({
+				actorId: id,
+				generation,
+				machineInitial: machine.initial
+			});
+			if (Option.isSome(resolved)) {
+				yield* SubscriptionRef.set(stateRef, resolved.value);
+				runtimeRef.current = yield* spawnGeneration(Object.create(machine, { initial: {
+					value: resolved.value,
+					enumerable: true
+				} }));
+			}
+		}
+		const currentState = yield* SubscriptionRef.get(stateRef);
+		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
+			type: "@machine.spawn",
+			actorId: id,
+			initialState: currentState,
+			timestamp
+		}));
+		if (supervision !== void 0) supervisorFiberRef.current = yield* Effect.forkDaemon(runSupervisionLoop({
+			supervision,
+			machine,
+			id,
+			runtimeRef,
+			terminalExitDeferred,
+			pendingReplies,
+			eventQueueRef,
+			stateRef,
+			stoppedRef,
+			childrenMap,
+			listeners,
+			spawnGeneration,
+			lifecycle,
+			onRestart: options?.onRestart
+		}));
+		else {
+			const currentRuntime = runtimeRef.current;
+			if (currentRuntime !== void 0) yield* Effect.forkDaemon(Deferred.await(currentRuntime.exitDeferred).pipe(Effect.tap((exit) => Deferred.succeed(terminalExitDeferred, exit))));
+		}
+		const currentRuntime = runtimeRef.current;
+		if (currentRuntime !== void 0) yield* currentRuntime.start;
+	}).pipe(Effect.withSpan("effect-machine.actor.start"), Effect.asVoid), system, childrenMap, pendingReplies, transitionsPubSub, terminalExitDeferred);
 });
 /** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */
 const settlePendingReplies = (pendingReplies, actorId) => Effect.sync(() => {
@@ -367,14 +448,15 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 	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.zipRight(PubSub.publish(eventPubSub, event)), Effect.catchAllCause(() => Effect.void), Effect.asVoid);
+	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(actorsMap, (actor) => {
 			stops.push(actor.stop);
 		});
-		return Effect.all(stops, { concurrency: "unbounded" }).pipe(Effect.zipRight(PubSub.shutdown(eventPubSub)), 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(actorsMap, id)) {
 			yield* actor.stop;
@@ -404,10 +486,11 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 	});
 	const spawnRegular = Effect.fn("effect-machine.actorSystem.spawnRegular")(function* (id, machine, spawnOptions) {
 		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
-		const materialized = materializeMachine(machine, spawnOptions?.slots);
+		const materialized = spawnOptions?.slots !== void 0 ? materializeMachine(machine, spawnOptions.slots) : machine;
 		let actorRef;
 		const actor = yield* createActor(id, materialized, {
 			supervision: spawnOptions?.supervision,
+			lifecycle: spawnOptions?.lifecycle,
 			onRestart: spawnOptions?.supervision !== void 0 ? (generation, exit) => actorRef !== void 0 ? emitSystemEvent({
 				_tag: "ActorRestarted",
 				id,
@@ -417,7 +500,9 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 			}) : Effect.void : void 0
 		});
 		actorRef = actor;
-		return yield* registerActor(id, actor);
+		yield* registerActor(id, actor);
+		yield* actor.start.pipe(Effect.catchAllCause((cause) => actor.stop.pipe(Effect.andThen(Effect.failCause(cause)))));
+		return actor;
 	});
 	const spawn = (id, machine, options) => withSpawnGate(spawnRegular(id, machine, options));
 	const get = Effect.fn("effect-machine.actorSystem.get")(function* (id) {
@@ -465,6 +550,6 @@ const makeSystem = make;
 /**
 * Default ActorSystem layer
 */
-const Default = Layer.effect(ActorSystem, make());
+const Default = Layer.scoped(ActorSystem, make());
 //#endregion
 export { ActorSystem, Default, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

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

@@ -68,7 +68,7 @@ declare const EntityMachine: {
     readonly _tag: string;
   }, E extends {
     readonly _tag: string;
-  }, R, EntityType extends string, Rpcs extends Rpc.Any>(entity: Entity.Entity<EntityType, Rpcs>, machine: Machine<S, E, R, any, any, any, any>, options?: EntityMachineOptions<S, E>) => Layer.Layer<never, never, R>;
+  }, R, EntityType extends string, Rpcs extends Rpc.Any>(entity: Entity.Entity<EntityType, Rpcs>, machine: Machine<S, E, R, any, any, any>, options?: EntityMachineOptions<S, E>) => Layer.Layer<never, never, R>;
 };
 //#endregion
 export { EntityMachine, EntityMachineOptions };

package/v3/dist/cluster/entity-machine.js

@@ -50,6 +50,7 @@ const EntityMachine = { layer: (entity, machine, options) => {
 			hooks: options?.hooks,
 			childIdPrefix: `${entityId}/`
 		});
+		yield* runtime.start;
 		if (persistCtx.adapter !== void 0) {
 			const { adapter: pAdapter, key } = persistCtx;
 			yield* Effect.addFinalizer(() => Effect.gen(function* () {

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

@@ -59,6 +59,6 @@ declare const toEntity: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any, any>, options: ToEntityOptions) => any;
+}, R>(machine: Machine<S, E, R, any, any, any>, options: ToEntityOptions) => any;
 //#endregion
 export { EntityRpcs, ToEntityOptions, toEntity };

package/v3/dist/errors.d.ts

@@ -33,7 +33,7 @@ declare const SlotProvisionError_base: Schema.TaggedErrorClass<SlotProvisionErro
   readonly _tag: Schema.tag<"SlotProvisionError">;
 } & {
   slotName: typeof Schema.String;
-  slotType: Schema.Literal<["guard", "effect"]>;
+  slotType: Schema.Literal<["slot"]>;
 }>;
 /** Slot handler not found at runtime (internal error) */
 declare class SlotProvisionError extends SlotProvisionError_base {}
@@ -43,7 +43,7 @@ declare const ProvisionValidationError_base: Schema.TaggedErrorClass<ProvisionVa
   missing: Schema.Array$<typeof Schema.String>;
   extra: Schema.Array$<typeof Schema.String>;
 }>;
-/** Machine.build() validation failed - missing or extra handlers */
+/** Slot provision 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">;
@@ -74,6 +74,15 @@ declare const PersistenceError_base: Schema.TaggedErrorClass<PersistenceError, "
 }>;
 /** Persistence adapter operation failed */
 declare class PersistenceError extends PersistenceError_base {}
+declare const SlotCodecError_base: Schema.TaggedErrorClass<SlotCodecError, "SlotCodecError", {
+  readonly _tag: Schema.tag<"SlotCodecError">;
+} & {
+  slotName: typeof Schema.String;
+  phase: Schema.Literal<["input", "output"]>;
+  message: typeof Schema.String;
+}>;
+/** Slot input/output schema validation failed */
+declare class SlotCodecError extends SlotCodecError_base {}
 declare const VersionConflictError_base: Schema.TaggedErrorClass<VersionConflictError, "VersionConflictError", {
   readonly _tag: Schema.tag<"VersionConflictError">;
 } & {
@@ -83,4 +92,4 @@ declare const VersionConflictError_base: Schema.TaggedErrorClass<VersionConflict
 /** Optimistic locking failure — stored version doesn't match expected */
 declare class VersionConflictError extends VersionConflictError_base {}
 //#endregion
-export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotProvisionError, VersionConflictError };
+export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError };

package/v3/dist/errors.js

@@ -3,7 +3,7 @@ import { Schema } from "effect";
 /**
 * Typed error classes for effect-machine.
 *
-* All errors extend Schema.TaggedError for:
+* All errors extend Schema.TaggedErrorClass for:
 * - Type-safe catching via Effect.catchTag
 * - Serialization support
 * - Composable error handling
@@ -21,9 +21,9 @@ var MissingMatchHandlerError = class extends Schema.TaggedError()("MissingMatchH
 /** Slot handler not found at runtime (internal error) */
 var SlotProvisionError = class extends Schema.TaggedError()("SlotProvisionError", {
 	slotName: Schema.String,
-	slotType: Schema.Literal("guard", "effect")
+	slotType: Schema.Literal("slot")
 }) {};
-/** Machine.build() validation failed - missing or extra handlers */
+/** Slot provision validation failed — missing or extra handlers */
 var ProvisionValidationError = class extends Schema.TaggedError()("ProvisionValidationError", {
 	missing: Schema.Array(Schema.String),
 	extra: Schema.Array(Schema.String)
@@ -39,10 +39,16 @@ var NoReplyError = class extends Schema.TaggedError()("NoReplyError", {
 }) {};
 /** Persistence adapter operation failed */
 var PersistenceError = class extends Schema.TaggedError()("PersistenceError", { message: Schema.String }) {};
+/** Slot input/output schema validation failed */
+var SlotCodecError = class extends Schema.TaggedError()("SlotCodecError", {
+	slotName: Schema.String,
+	phase: Schema.Literal("input", "output"),
+	message: Schema.String
+}) {};
 /** Optimistic locking failure — stored version doesn't match expected */
 var VersionConflictError = class extends Schema.TaggedError()("VersionConflictError", {
 	expected: Schema.Number,
 	actual: Schema.Number
 }) {};
 //#endregion
-export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotProvisionError, VersionConflictError };
+export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError };

package/v3/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { ActorExit, CellPhase, DefectPhase, Supervision } from "./supervision.js";
-import { ReplyResult } from "./internal/utils.js";
+import { DeferReplyResult, ReplyResult } from "./internal/utils.js";
 import { Event, MachineEventSchema, MachineStateSchema, ReplyFields, State } from "./schema.js";
-import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotProvisionError, VersionConflictError } from "./errors.js";
-import { EffectHandlers, EffectSlot, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlot, GuardSlots, GuardsDef, GuardsSchema, MachineContext, Slot } from "./slot.js";
+import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError } from "./errors.js";
+import { HasSlotKeys, MachineContext, ProvideSlots, Slot, SlotCall, SlotCalls, SlotFnDef, SlotHandler, SlotInvocation, SlotRequest, SlotResult, SlotsDef, SlotsSchema } from "./slot.js";
+import { ActorExit, CellPhase, DefectPhase, Supervision } from "./supervision.js";
 import { ProcessEventResult } from "./internal/transition.js";
-import { BackgroundEffect, HandlerContext, Machine, MachineRef, MakeConfig, ProvideHandlers, SlotContext, SpawnEffect, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, machine_d_exports } from "./machine.js";
+import { BackgroundEffect, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, SpawnEffect, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, machine_d_exports } from "./machine.js";
 import { ActorRef, ActorRefSync, ActorSystem, Default, SystemEvent, SystemEventListener, TransitionInfo } from "./actor.js";
 import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
 import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-export { ActorExit, type ActorRef, type ActorRefSync, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type CellPhase, type DefectPhase, 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, type InspectionEvent, type Inspector, type InspectorHandler, 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, NoReplyError, PersistenceError, type ProcessEventResult, type ProvideHandlers, ProvisionValidationError, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotContext, type EffectHandlers as SlotEffectHandlers, type EffectSlot as SlotEffectSlot, SlotProvisionError, 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 };
+export { ActorExit, type ActorRef, type ActorRefSync, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type CellPhase, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type HasSlotKeys, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, type ProcessEventResult, type ProvideSlots, ProvisionValidationError, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotCall, type SlotCalls, SlotCodecError, type SlotFnDef, type SlotHandler, type SlotInvocation, SlotProvisionError, type SlotRequest, type SlotResult, type SlotsDef, type SlotsSchema, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/v3/dist/index.js

@@ -1,4 +1,4 @@
-import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotProvisionError, VersionConflictError } from "./errors.js";
+import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError } from "./errors.js";
 import { Inspector, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
 import { Slot } from "./slot.js";
 import { machine_exports } from "./machine.js";
@@ -6,4 +6,4 @@ import { ActorExit, Supervision } from "./supervision.js";
 import { ActorSystem, Default } from "./actor.js";
 import { Event, State } from "./schema.js";
 import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-export { ActorExit, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };
+export { ActorExit, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotCodecError, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/v3/dist/inspection.d.ts

@@ -4,7 +4,7 @@ import { Context, Effect, Schema } from "effect";
 /**
  * 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
  */
@@ -45,9 +45,6 @@ interface EffectEvent<S> {
   readonly state: S;
   readonly timestamp: number;
 }
-/**
- * Event emitted when a task lifecycle phase occurs
- */
 interface TaskEvent<S> {
   readonly type: "@machine.task";
   readonly actorId: string;
@@ -93,13 +90,10 @@ type AnyInspectionEvent = InspectionEvent<{
 }, {
   readonly _tag: string;
 }>;
-/**
- * Inspector handler — sync callback or Effect-returning callback.
- */
-type InspectorHandler<S, E> = (event: InspectionEvent<S, E>) => void | Effect.Effect<void, never, never>;
 /**
  * Inspector interface for observing machine behavior
  */
+type InspectorHandler<S, E> = (event: InspectionEvent<S, E>) => void | Effect.Effect<void, never, never>;
 interface Inspector<S, E> {
   readonly onInspect: InspectorHandler<S, E>;
 }
@@ -109,7 +103,7 @@ interface Inspector<S, E> {
  */
 declare const Inspector: Context.Tag<Inspector<any, any>, Inspector<any, any>>;
 /**
- * Create an inspector from a sync callback function.
+ * Create an inspector from a callback function.
  *
  * Type params accept either raw tagged types or Schema constructors:
  * - `makeInspector(cb)` — defaults to `AnyInspectionEvent`
@@ -121,30 +115,17 @@ declare const makeInspector: <S = {
 }, E = {
   readonly _tag: string;
 }>(onInspect: InspectorHandler<ResolveType<S>, ResolveType<E>>) => Inspector<ResolveType<S>, ResolveType<E>>;
-/**
- * Create an inspector from an Effect-returning callback function.
- */
 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>>;
-/**
- * Combine multiple inspectors into one. All run concurrently per event.
- * Individual inspector failures are swallowed.
- */
 declare const combineInspectors: <S, E>(...inspectors: ReadonlyArray<Inspector<S, E>>) => Inspector<S, E>;
-/**
- * Options for the tracing inspector.
- */
 interface TracingInspectorOptions<S, E> {
   readonly spanName?: string | ((event: InspectionEvent<S, E>) => string);
   readonly attributes?: (event: InspectionEvent<S, E>) => Readonly<Record<string, string | number | boolean>>;
   readonly eventName?: (event: InspectionEvent<S, E>) => string;
 }
-/**
- * Inspector that emits OpenTelemetry spans and events for each inspection event.
- */
 declare const tracingInspector: <S extends {
   readonly _tag: string;
 }, E extends {

package/v3/dist/inspection.js

@@ -6,7 +6,7 @@ import { Context, Effect, Option } from "effect";
 */
 const Inspector = Context.GenericTag("@effect/machine/Inspector");
 /**
-* Create an inspector from a sync callback function.
+* Create an inspector from a callback function.
 *
 * Type params accept either raw tagged types or Schema constructors:
 * - `makeInspector(cb)` — defaults to `AnyInspectionEvent`
@@ -14,22 +14,11 @@ const Inspector = Context.GenericTag("@effect/machine/Inspector");
 * - `makeInspector<typeof MyState, typeof MyEvent>(cb)` — schema constructors (auto-extracts `.Type`)
 */
 const makeInspector = (onInspect) => ({ onInspect });
-/**
-* Create an inspector from an Effect-returning callback function.
-*/
 const makeInspectorEffect = (onInspect) => ({ onInspect });
-/**
-* Run an inspector handler, handling both sync and Effect returns.
-* @internal
-*/
 const inspectionEffect = (inspector, event) => {
 	const result = inspector.onInspect(event);
 	return Effect.isEffect(result) ? result : Effect.void;
 };
-/**
-* Combine multiple inspectors into one. All run concurrently per event.
-* Individual inspector failures are swallowed.
-*/
 const combineInspectors = (...inspectors) => ({ onInspect: (event) => Effect.forEach(inspectors, (inspector) => inspectionEffect(inspector, event).pipe(Effect.catchAllCause(() => Effect.void)), {
 	concurrency: "unbounded",
 	discard: true
@@ -99,9 +88,6 @@ const inspectionAttributes = (event) => {
 		};
 	}
 };
-/**
-* Inspector that emits OpenTelemetry spans and events for each inspection event.
-*/
 const tracingInspector = (options) => ({ onInspect: (event) => {
 	const spanName = typeof options?.spanName === "function" ? options.spanName(event) : options?.spanName;
 	const traceName = options?.eventName?.(event) ?? inspectionTraceName(event);