effect-machine 0.13.0 → 0.14.0

package/README.md

@@ -39,14 +39,14 @@ const CheckoutEvent = Event({
   Cancel: {},
 });
 
-const CheckoutEffects = Slot.Effects({
-  chargeCard: { cartId: Schema.String, totalCents: Schema.Number },
+const CheckoutSlots = Slot.define({
+  chargeCard: Slot.fn({ cartId: Schema.String, totalCents: Schema.Number }),
 });
 
 const checkoutMachine = Machine.make({
   state: CheckoutState,
   event: CheckoutEvent,
-  effects: CheckoutEffects,
+  slots: CheckoutSlots,
   initial: CheckoutState.ReviewingCart({ cartId: "cart_123", totalCents: 4200 }),
 })
   .on(CheckoutState.ReviewingCart, CheckoutEvent.Submit, ({ state }) =>
@@ -61,8 +61,8 @@ const checkoutMachine = Machine.make({
   .onAny(CheckoutEvent.Cancel, ({ state }) =>
     CheckoutState.Failed.derive(state, { reason: "cancelled" }),
   )
-  .spawn(CheckoutState.ChargingCard, ({ effects, state }) =>
-    effects.chargeCard({ cartId: state.cartId, totalCents: state.totalCents }),
+  .spawn(CheckoutState.ChargingCard, ({ slots, state }) =>
+    slots.chargeCard({ cartId: state.cartId, totalCents: state.totalCents }),
   )
   .final(CheckoutState.Confirmed)
   .final(CheckoutState.Failed);
@@ -86,10 +86,11 @@ const actor =
   yield *
   Machine.spawn(checkoutMachine, {
     slots: {
-      chargeCard: ({ cartId, totalCents }, { self }) =>
+      chargeCard: ({ cartId, totalCents }) =>
         Effect.gen(function* () {
+          const ctx = yield* checkoutMachine.Context;
           const result = yield* PaymentService.charge(cartId, totalCents);
-          yield* self.send(
+          yield* ctx.self.send(
             result.ok
               ? CheckoutEvent.Charged({ receiptId: result.receiptId })
               : CheckoutEvent.Declined({ reason: result.error }),
@@ -114,8 +115,12 @@ The same machine can run with different slot implementations in tests, local app
 const program = Effect.gen(function* () {
   const actor = yield* Machine.spawn(checkoutMachine, {
     slots: {
-      chargeCard: ({ cartId }, { self }) =>
-        self.send(CheckoutEvent.Charged({ receiptId: `rcpt_${cartId}` })),
+      chargeCard: ({ cartId }) =>
+        checkoutMachine.Context.pipe(
+          Effect.flatMap((ctx) =>
+            ctx.self.send(CheckoutEvent.Charged({ receiptId: `rcpt_${cartId}` })),
+          ),
+        ),
     },
   });
 

package/dist/actor.d.ts

@@ -1,9 +1,9 @@
 import { ExtractReply, ReplyTypeBrand } from "./internal/brands.js";
 import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
-import { EffectsDef, GuardsDef } from "./slot.js";
+import { ProvideSlots, SlotsDef } from "./slot.js";
 import { ActorExit, Supervision } from "./supervision.js";
 import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
-import { Machine } from "./machine.js";
+import { Machine, PersistConfig } from "./machine.js";
 import { RuntimeQueuedEvent } from "./internal/runtime.js";
 import { Deferred, Effect, Layer, Option, PubSub, Queue, Ref, Scope, ServiceMap, Stream, SubscriptionRef } from "effect";
 
@@ -158,8 +158,10 @@ interface ActorSystem {
     readonly _tag: string;
   }, E extends {
     readonly _tag: string;
-  }, R>(id: string, machine: Machine<S, E, R, any, any, any, any>, options?: {
+  }, R, SD extends SlotsDef = Record<string, never>>(id: string, machine: Machine<S, E, R, any, any, SD>, options?: {
     readonly supervision?: Supervision.Policy;
+    readonly slots?: ProvideSlots<SD, any>;
+    readonly persist?: PersistConfig<S>;
   }) => Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>;
   /**
    * Get an existing actor by ID
@@ -202,7 +204,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>, eventQueueRef: Ref.Ref<Queue.Queue<QueuedEvent<E>>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, transitionsPubSub: PubSub.PubSub<TransitionInfo<S, E>> | undefined, exitDeferred: Deferred.Deferred<ActorExit<S>, never>) => ActorRef<S, E>;
+}, R, SD extends SlotsDef>(id: string, machine: Machine<S, E, R, any, any, SD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueueRef: Ref.Ref<Queue.Queue<QueuedEvent<E>>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, transitionsPubSub: PubSub.PubSub<TransitionInfo<S, E>> | undefined, exitDeferred: Deferred.Deferred<ActorExit<S>, never>) => ActorRef<S, E>;
 /**
  * Create and start an actor for a machine.
  * Delegates to the shared runtime kernel with actor-specific lifecycle hooks.
@@ -211,9 +213,10 @@ declare const createActor: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, options?: {
+}, R, SD extends SlotsDef>(id: string, machine: Machine<S, E, R, any, any, SD>, options?: {
   initialState?: S;
-  supervision?: Supervision.Policy; /** @internal Called by system after each restart — emits ActorRestarted system event */
+  supervision?: Supervision.Policy;
+  persist?: PersistConfig<S>; /** @internal Called by system after each restart — emits ActorRestarted system event */
   onRestart?: (generation: number, exit: ActorExit<unknown>) => Effect.Effect<void>;
 } | undefined) => Effect.Effect<ActorRef<S, E>, never, never>;
 /** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */

package/dist/actor.js

@@ -1,7 +1,8 @@
-import { Inspector } from "./inspection.js";
+import { ActorStoppedError, DuplicateActorError } from "./errors.js";
 import { processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
 import { emitWithTimestamp } from "./internal/inspection.js";
-import { ActorStoppedError, DuplicateActorError } from "./errors.js";
+import { Inspector } from "./inspection.js";
+import { materializeMachine } from "./machine.js";
 import { createRuntime } from "./internal/runtime.js";
 import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schedule, Scope, Semaphore, ServiceMap, Stream, SubscriptionRef } from "effect";
 //#region src/actor.ts
@@ -190,22 +191,85 @@ const buildInspectionHooks = (actorId, inspector) => ({
 	}))
 });
 /**
+* Load persisted state and run onRestore hook if present.
+* Returns the resolved initial state (loaded, restored, or fallback to machineInitial).
+* @internal
+*/
+const loadAndRestore = (persist, machineInitial) => Effect.gen(function* () {
+	const loaded = yield* persist.load();
+	if (Option.isNone(loaded)) return machineInitial;
+	if (persist.onRestore === void 0) return loaded.value;
+	const restored = yield* persist.onRestore(loaded.value, { initial: machineInitial });
+	return Option.getOrElse(restored, () => machineInitial);
+});
+/**
+* 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 step = yield* Schedule.toStepWithSleep(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* step(generationExit).pipe(Effect.exit))._tag === "Failure") {
+			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			return;
+		}
+		const restartState = params.persist !== void 0 ? yield* loadAndRestore(params.persist, params.machine.initial) : params.machine.initial;
+		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;
+		generation++;
+		if (params.onRestart !== void 0) yield* params.onRestart(generation, generationExit);
+		notifyListeners(params.listeners, restartState);
+	}
+});
+/**
 * Create and start an actor for a machine.
 * Delegates to the shared runtime kernel with actor-specific lifecycle hooks.
 */
 const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine, options) {
-	const initial = options?.initialState ?? machine.initial;
+	const persist = options?.persist;
+	const initial = options?.initialState ?? (persist !== void 0 ? yield* loadAndRestore(persist, machine.initial) : 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();
@@ -242,6 +306,9 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 			})) : void 0,
 			onStateChange: (result, _event) => Effect.gen(function* () {
 				notifyListeners(listeners, result.newState);
+				if (persist !== void 0 && result.transitioned) {
+					if (persist.shouldSave === void 0 || persist.shouldSave(result.newState, result.previousState)) yield* persist.save(result.newState);
+				}
 				yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", true);
 				if (result.lifecycleRan) {
 					yield* Effect.annotateCurrentSpan("effect_machine.state.from", result.previousState._tag);
@@ -311,36 +378,21 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	runtimeRef.current = runtime;
 	const supervision = options?.supervision;
 	let supervisorFiber;
-	if (supervision !== void 0) supervisorFiber = yield* Effect.forkDetach(Effect.gen(function* () {
-		const step = yield* Schedule.toStepWithSleep(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* step(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);
-		}
+	if (supervision !== void 0) supervisorFiber = yield* Effect.forkDetach(runSupervisionLoop({
+		supervision,
+		machine,
+		id,
+		runtimeRef,
+		terminalExitDeferred,
+		pendingReplies,
+		eventQueueRef,
+		stateRef,
+		stoppedRef,
+		childrenMap,
+		listeners,
+		spawnGeneration,
+		persist,
+		onRestart: options?.onRestart
 	}));
 	else yield* Effect.forkDetach(Deferred.await(runtime.exitDeferred).pipe(Effect.tap((exit) => Deferred.succeed(terminalExitDeferred, exit))));
 	return buildActorRefCore(id, machine, stateRef, eventQueueRef, stoppedRef, listeners, Effect.gen(function* () {
@@ -406,9 +458,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 = spawnOptions?.slots !== void 0 ? materializeMachine(machine, spawnOptions.slots) : machine;
 		let actorRef;
-		const actor = yield* createActor(id, machine, {
+		const actor = yield* createActor(id, materialized, {
 			supervision: spawnOptions?.supervision,
+			persist: spawnOptions?.persist,
 			onRestart: spawnOptions?.supervision !== void 0 ? (generation, exit) => actorRef !== void 0 ? emitSystemEvent({
 				_tag: "ActorRestarted",
 				id,

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

@@ -65,7 +65,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/dist/cluster/entity-machine.js

@@ -1,6 +1,6 @@
+import { replay } from "../machine.js";
 import { createRuntime } from "../internal/runtime.js";
 import { ActorSystem, makeSystem } from "../actor.js";
-import { replay } from "../machine.js";
 import { PersistenceAdapter } from "./persistence.js";
 import { Clock, Effect, Option, Queue, Ref, Stream, SubscriptionRef } from "effect";
 import { Entity } from "effect/unstable/cluster";

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

@@ -61,7 +61,7 @@ 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) => Entity.Entity<string, Rpc.Rpc<"Send", Schema.Struct<{
+}, R>(machine: Machine<S, E, R, any, any, any>, options: ToEntityOptions) => Entity.Entity<string, Rpc.Rpc<"Send", Schema.Struct<{
   event: Schema.Schema<E>;
 }>, Schema.Schema<S>, Schema.Never, never, never> | Rpc.Rpc<"Ask", Schema.Struct<{
   event: Schema.Schema<E>;

package/dist/errors.d.ts

@@ -24,7 +24,7 @@ declare const MissingMatchHandlerError_base: Schema.ErrorClass<MissingMatchHandl
 declare class MissingMatchHandlerError extends MissingMatchHandlerError_base {}
 declare const SlotProvisionError_base: Schema.ErrorClass<SlotProvisionError, Schema.TaggedStruct<"SlotProvisionError", {
   readonly slotName: Schema.String;
-  readonly slotType: Schema.Literals<readonly ["guard", "effect"]>;
+  readonly slotType: Schema.Literal<"slot">;
 }>, _$effect_Cause0.YieldableError>;
 /** Slot handler not found at runtime (internal error) */
 declare class SlotProvisionError extends SlotProvisionError_base {}
@@ -55,6 +55,13 @@ declare const PersistenceError_base: Schema.ErrorClass<PersistenceError, Schema.
 }>, _$effect_Cause0.YieldableError>;
 /** Persistence adapter operation failed */
 declare class PersistenceError extends PersistenceError_base {}
+declare const SlotCodecError_base: Schema.ErrorClass<SlotCodecError, Schema.TaggedStruct<"SlotCodecError", {
+  readonly slotName: Schema.String;
+  readonly phase: Schema.Literals<readonly ["input", "output"]>;
+  readonly message: Schema.String;
+}>, _$effect_Cause0.YieldableError>;
+/** Slot input/output schema validation failed */
+declare class SlotCodecError extends SlotCodecError_base {}
 declare const VersionConflictError_base: Schema.ErrorClass<VersionConflictError, Schema.TaggedStruct<"VersionConflictError", {
   readonly expected: Schema.Number;
   readonly actual: Schema.Number;
@@ -62,4 +69,4 @@ declare const VersionConflictError_base: Schema.ErrorClass<VersionConflictError,
 /** 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/dist/errors.js

@@ -21,7 +21,7 @@ var MissingMatchHandlerError = class extends Schema.TaggedErrorClass()("MissingM
 /** Slot handler not found at runtime (internal error) */
 var SlotProvisionError = class extends Schema.TaggedErrorClass()("SlotProvisionError", {
 	slotName: Schema.String,
-	slotType: Schema.Literals(["guard", "effect"])
+	slotType: Schema.Literal("slot")
 }) {};
 /** Slot provision validation failed — missing or extra handlers */
 var ProvisionValidationError = class extends Schema.TaggedErrorClass()("ProvisionValidationError", {
@@ -39,10 +39,16 @@ var NoReplyError = class extends Schema.TaggedErrorClass()("NoReplyError", {
 }) {};
 /** Persistence adapter operation failed */
 var PersistenceError = class extends Schema.TaggedErrorClass()("PersistenceError", { message: Schema.String }) {};
+/** Slot input/output schema validation failed */
+var SlotCodecError = class extends Schema.TaggedErrorClass()("SlotCodecError", {
+	slotName: Schema.String,
+	phase: Schema.Literals(["input", "output"]),
+	message: Schema.String
+}) {};
 /** Optimistic locking failure — stored version doesn't match expected */
 var VersionConflictError = class extends Schema.TaggedErrorClass()("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/dist/index.d.ts

@@ -1,11 +1,11 @@
 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, HandlerContext, Machine, MachineRef, MakeConfig, 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, type DeferReplyResult, 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 EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type HasSlotKeys, 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 ProvideSlots, ProvisionValidationError, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotCall, type SlotCalls, SlotCodecError, type SlotFnDef, type SlotHandler, type SlotInvocation, SlotProvisionError, type SlotRequest, type SlotResult, type SlotsDef, type SlotsSchema, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/index.js

@@ -1,9 +1,9 @@
+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 { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotProvisionError, VersionConflictError } from "./errors.js";
-import { ActorExit, Supervision } from "./supervision.js";
-import { ActorSystem, Default } from "./actor.js";
 import { Slot } from "./slot.js";
 import { machine_exports } from "./machine.js";
+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/dist/internal/runtime.d.ts

@@ -1,5 +1,5 @@
 import { NoReplyError } from "../errors.js";
-import { EffectsDef, GuardsDef, MachineContext } from "../slot.js";
+import { MachineContext, SlotsDef } from "../slot.js";
 import { ActorExit } from "../supervision.js";
 import { ProcessEventHooks, ProcessEventResult } from "./transition.js";
 import { Machine, MachineRef } from "../machine.js";
@@ -137,6 +137,6 @@ declare const createRuntime: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, any, any, GD, EFD>, system: ActorSystem, config: RuntimeConfig<S, E>) => Effect.Effect<RuntimeHandle<S, E>, never, Scope.Scope | Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, system: ActorSystem, config: RuntimeConfig<S, E>) => Effect.Effect<RuntimeHandle<S, E>, never, Scope.Scope | Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
 //#endregion
 export { ProcessQueuedResult, RuntimeCellResources, RuntimeConfig, RuntimeHandle, RuntimeLifecycleHooks, RuntimeQueuedEvent, createRuntime };

package/dist/internal/runtime.js

@@ -1,9 +1,9 @@
 import { INTERNAL_INIT_EVENT } from "./utils.js";
-import { processEventCore, runSpawnEffects, shouldPostpone } from "./transition.js";
 import { NoReplyError } from "../errors.js";
+import { processEventCore, runSpawnEffects, shouldPostpone } from "./transition.js";
 import { ActorExit } from "../supervision.js";
 import { ActorSystem } from "../actor.js";
-import { Cause, Deferred, Effect, Exit, Fiber, Option, Queue, Ref, Schema, Scope, SubscriptionRef } from "effect";
+import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Schema, Scope, SubscriptionRef } from "effect";
 //#region src/internal/runtime.ts
 /**
 * Shared runtime kernel for machine event processing.
@@ -81,14 +81,14 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 		self,
 		system
 	};
-	const { effects: effectSlots } = machine._slots;
+	const slots = machine._slots;
 	for (const bg of machine.backgroundEffects) {
 		const fiber = yield* bg.handler({
 			actorId,
 			state: machine.initial,
 			event: initEvent,
 			self,
-			effects: effectSlots,
+			slots,
 			system
 		}).pipe(Effect.provideService(machine.Context, ctx), Effect.forkIn(actorScope));
 		backgroundFibers.push(fiber);
@@ -278,12 +278,7 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 		yield* Ref.set(stoppedRef, true);
 		if (lifecycle?.onShutdown !== void 0) yield* lifecycle.onShutdown();
 		settlePostponed(postponed, actorId, forkEffect);
-		const remaining = [];
-		let next = yield* Queue.poll(eventQueue);
-		while (Option.isSome(next)) {
-			remaining.push(next.value);
-			next = yield* Queue.poll(eventQueue);
-		}
+		const remaining = yield* Queue.clear(eventQueue);
 		for (const entry of remaining) if (entry._tag === "sendWait") forkEffect(Deferred.succeed(entry.done, void 0));
 		else if (entry._tag === "ask") forkEffect(Deferred.fail(entry.reply, new NoReplyError({
 			actorId,

package/dist/internal/transition.d.ts

@@ -1,4 +1,4 @@
-import { EffectsDef, GuardsDef, MachineContext } from "../slot.js";
+import { MachineContext, SlotsDef } from "../slot.js";
 import { Machine, MachineRef, SpawnEffect, Transition } from "../machine.js";
 import { ActorSystem } from "../actor.js";
 import { Cause, Effect, Scope } from "effect";
@@ -29,7 +29,7 @@ declare const runTransitionHandler: <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>, transition: Transition<S, E, GD, EFD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, transition: Transition<S, E, SD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
   newState: S;
   hasReply: boolean;
   deferReply: boolean;
@@ -50,7 +50,7 @@ declare const executeTransition: <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>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
   newState: S;
   transitioned: boolean;
   reenter: boolean;
@@ -111,7 +111,7 @@ declare const shouldPostpone: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any, any>, stateTag: string, eventTag: string) => boolean;
+}, R>(machine: Machine<S, E, R, any, any, any>, stateTag: string, eventTag: string) => boolean;
 /**
  * Process a single event through the machine.
  *
@@ -128,7 +128,7 @@ declare const processEventCore: <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>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
   current: Scope.Closeable;
 }, system: ActorSystem, actorId: string, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
   newState: S;
@@ -150,7 +150,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.Closeable, system: ActorSystem, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystem, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
 /**
  * Resolve which transition should fire for a given state and event.
  * Uses indexed O(1) lookup. First matching transition wins.
@@ -159,7 +159,7 @@ declare const resolveTransition: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any, any>, currentState: S, event: E) => (typeof machine.transitions)[number] | undefined;
+}, R>(machine: Machine<S, E, R, any, any, any>, currentState: S, event: E) => (typeof machine.transitions)[number] | undefined;
 /**
  * Invalidate cached index for a machine (call after mutation).
  */
@@ -174,7 +174,7 @@ declare const findTransitions: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, GD, EFD>, stateTag: string, eventTag: string) => ReadonlyArray<Transition<S, E, GD, EFD, R>>;
+}, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, stateTag: string, eventTag: string) => ReadonlyArray<Transition<S, E, SD, R>>;
 /**
  * Find all spawn effects for a state.
  * Returns empty array if no matches.
@@ -185,6 +185,6 @@ declare const findSpawnEffects: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, GD, EFD>, stateTag: string) => ReadonlyArray<SpawnEffect<S, E, EFD, R>>;
+}, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, stateTag: string) => ReadonlyArray<SpawnEffect<S, E, SD, R>>;
 //#endregion
 export { ProcessEventError, ProcessEventHooks, ProcessEventResult, TransitionExecutionResult, executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler, shouldPostpone };

package/dist/internal/transition.js

@@ -29,12 +29,10 @@ const runTransitionHandler = Effect.fn("effect-machine.runTransitionHandler")(fu
 		self,
 		system
 	};
-	const { guards, effects } = machine._slots;
 	const handlerCtx = {
 		state,
 		event,
-		guards,
-		effects
+		slots: machine._slots
 	};
 	const raw = transition.handler(handlerCtx);
 	const resolved = isEffect(raw) ? yield* raw.pipe(Effect.provideService(machine.Context, ctx)) : raw;
@@ -166,7 +164,7 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 		self,
 		system
 	};
-	const { effects: effectSlots } = machine._slots;
+	const slots = machine._slots;
 	const reportError = onError;
 	const defectSignal = onSpawnDefect;
 	for (const spawnEffect of spawnEffects) {
@@ -175,7 +173,7 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 			state,
 			event,
 			self,
-			effects: effectSlots,
+			slots,
 			system
 		}).pipe(Effect.provideService(machine.Context, ctx), Effect.catchCause((cause) => {
 			if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;