effect-machine 0.12.0 → 0.14.0

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

@@ -1,7 +1,7 @@
 import { stubSystem } from "../internal/utils.js";
-import { BuiltMachine, replay } from "../machine.js";
-import { ActorSystem } from "../actor.js";
+import { replay } from "../machine.js";
 import { createRuntime } from "../internal/runtime.js";
+import { ActorSystem } from "../actor.js";
 import { PersistenceAdapter } from "./persistence.js";
 import { Effect, Option, Ref } from "effect";
 import { Entity } from "@effect/cluster";
@@ -47,7 +47,8 @@ const EntityMachine = { layer: (entity, machine, options) => {
 		const versionRef = yield* Ref.make(persistCtx.initialVersion);
 		const runtime = yield* createRuntime(machineWithState, system, {
 			actorId: entityId,
-			hooks: options?.hooks
+			hooks: options?.hooks,
+			childIdPrefix: `${entityId}/`
 		});
 		if (persistCtx.adapter !== void 0) {
 			const { adapter: pAdapter, key } = persistCtx;
@@ -110,8 +111,7 @@ const hydratePersistence = (persistence, entityDef, entityId, machine, initializ
 		const snapshotVersion = Option.isSome(maybeSnapshot) ? maybeSnapshot.value.version : 0;
 		const events = yield* adapter.loadEvents(key, snapshotVersion);
 		if (events.length > 0) {
-			const eventValues = events.map((e) => e.event);
-			const hydratedState = yield* replay(new BuiltMachine(machine), eventValues, { from: baseState });
+			const hydratedState = yield* replay(machine, events.map((e) => e.event), { from: baseState });
 			const lastEvent = events[events.length - 1];
 			return {
 				adapter,

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

@@ -8,13 +8,6 @@ declare const DuplicateActorError_base: Schema.TaggedErrorClass<DuplicateActorEr
 }>;
 /** Attempted to spawn/restore actor with ID already in use */
 declare class DuplicateActorError extends DuplicateActorError_base {}
-declare const UnprovidedSlotsError_base: Schema.TaggedErrorClass<UnprovidedSlotsError, "UnprovidedSlotsError", {
-  readonly _tag: Schema.tag<"UnprovidedSlotsError">;
-} & {
-  slots: Schema.Array$<typeof Schema.String>;
-}>;
-/** Machine has unprovided effect slots */
-declare class UnprovidedSlotsError extends UnprovidedSlotsError_base {}
 declare const MissingSchemaError_base: Schema.TaggedErrorClass<MissingSchemaError, "MissingSchemaError", {
   readonly _tag: Schema.tag<"MissingSchemaError">;
 } & {
@@ -24,6 +17,8 @@ declare const MissingSchemaError_base: Schema.TaggedErrorClass<MissingSchemaErro
 declare class MissingSchemaError extends MissingSchemaError_base {}
 declare const InvalidSchemaError_base: Schema.TaggedErrorClass<InvalidSchemaError, "InvalidSchemaError", {
   readonly _tag: Schema.tag<"InvalidSchemaError">;
+} & {
+  message: typeof Schema.String;
 }>;
 /** State/Event schema has no variants */
 declare class InvalidSchemaError extends InvalidSchemaError_base {}
@@ -38,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 {}
@@ -48,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">;
@@ -79,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">;
 } & {
@@ -88,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, UnprovidedSlotsError, 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
@@ -12,20 +12,18 @@ import { Schema } from "effect";
 */
 /** Attempted to spawn/restore actor with ID already in use */
 var DuplicateActorError = class extends Schema.TaggedError()("DuplicateActorError", { actorId: Schema.String }) {};
-/** Machine has unprovided effect slots */
-var UnprovidedSlotsError = class extends Schema.TaggedError()("UnprovidedSlotsError", { slots: Schema.Array(Schema.String) }) {};
 /** Operation requires schemas attached to machine */
 var MissingSchemaError = class extends Schema.TaggedError()("MissingSchemaError", { operation: Schema.String }) {};
 /** State/Event schema has no variants */
-var InvalidSchemaError = class extends Schema.TaggedError()("InvalidSchemaError", {}) {};
+var InvalidSchemaError = class extends Schema.TaggedError()("InvalidSchemaError", { message: Schema.String }) {};
 /** $match called with missing handler for tag */
 var MissingMatchHandlerError = class extends Schema.TaggedError()("MissingMatchHandlerError", { tag: Schema.String }) {};
 /** 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)
@@ -41,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, UnprovidedSlotsError, VersionConflictError };
+export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError };

package/v3/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { EffectHandlers, EffectSlot, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlot, GuardSlots, GuardsDef, GuardsSchema, MachineContext, Slot } from "./slot.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, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.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, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, ProvideHandlers, SpawnEffect, StateHandlerContext, TaskOptions, 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 { type ActorRef, type ActorRefSync, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type BuiltMachine, DuplicateActorError, type EffectEvent, type EffectSlots, type EffectsDef, type EffectsSchema, type ErrorEvent, Event, type EventReceivedEvent, type GuardHandlers, type GuardSlot, type GuardSlots, type GuardsDef, type GuardsSchema, type HandlerContext, 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, type ProcessEventResult, type ProvideHandlers, ProvisionValidationError, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type EffectHandlers as SlotEffectHandlers, type EffectSlot as SlotEffectSlot, SlotProvisionError, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, UnprovidedSlotsError, 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/v3/dist/index.js

@@ -1,8 +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, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.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 { ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, Slot, SlotProvisionError, State, UnprovidedSlotsError, 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);

package/v3/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.
@@ -33,8 +30,7 @@ type FullEventBrand<D extends Record<string, unknown>> = EventBrand & SchemaIdBr
  * Brand that carries the reply type for an event variant.
  * Present only on events defined with Event.reply().
  */
-declare const ReplyTypeId: unique symbol;
-type ReplyTypeId = typeof ReplyTypeId;
+type ReplyTypeId = "effect-machine/ReplyTypeId";
 interface ReplyTypeBrand<R> extends Brand.Brand<ReplyTypeId> {
   readonly _ReplyType: R;
 }

package/v3/dist/internal/inspection.js

@@ -14,7 +14,7 @@ const emitWithTimestamp = Effect.fn("effect-machine.emitWithTimestamp")(function
 			return;
 		}
 	});
-	if (result !== void 0 && Effect.isEffect(result)) yield* result.pipe(Effect.catchAllCause(() => Effect.void));
+	if (Effect.isEffect(result)) yield* result.pipe(Effect.catchAllCause(() => Effect.void));
 });
 //#endregion
 export { emitWithTimestamp };

package/v3/dist/internal/runtime.d.ts

@@ -1,9 +1,10 @@
-import { EffectsDef, GuardsDef, MachineContext } from "../slot.js";
 import { NoReplyError } from "../errors.js";
-import { ProcessEventHooks } from "./transition.js";
+import { MachineContext, SlotsDef } from "../slot.js";
+import { ActorExit } from "../supervision.js";
+import { ProcessEventHooks, ProcessEventResult } from "./transition.js";
 import { Machine, MachineRef } from "../machine.js";
 import { ActorSystem } from "../actor.js";
-import { Deferred, Effect, Queue, Scope } from "effect";
+import { Deferred, Effect, Queue, Ref, Scope, SubscriptionRef } from "effect";
 
 //#region src/internal/runtime.d.ts
 /** @internal */
@@ -13,46 +14,122 @@ type RuntimeQueuedEvent<E> = {
 } | {
   readonly _tag: "sendWait";
   readonly event: E;
-  readonly done: Deferred.Deferred<void>;
+  readonly done: Deferred.Deferred<void, unknown>;
+} | {
+  readonly _tag: "call";
+  readonly event: E;
+  readonly reply: Deferred.Deferred<ProcessEventResult<{
+    readonly _tag: string;
+  }>, unknown>;
 } | {
   readonly _tag: "ask";
   readonly event: E;
   readonly reply: Deferred.Deferred<unknown, NoReplyError>;
+} | {
+  readonly _tag: "drain";
+  readonly done: Deferred.Deferred<void, never>;
 };
+/**
+ * Resources owned by the actor cell (stable across generations).
+ * When provided, createRuntime uses these instead of allocating its own.
+ * @internal
+ */
+interface RuntimeCellResources<S, E> {
+  readonly stateRef: SubscriptionRef.SubscriptionRef<S>;
+  readonly eventQueue: Queue.Queue<RuntimeQueuedEvent<E>>;
+  readonly stoppedRef: Ref.Ref<boolean>;
+}
 /** @internal */
 interface RuntimeHandle<S, E> {
   /** Enqueue a fire-and-forget event */
   readonly send: (event: E) => Effect.Effect<void>;
-  /** Enqueue event and wait for processing to complete (for RPC Send) */
-  readonly sendWait: (event: E) => Effect.Effect<void>;
+  /** Enqueue event and wait for processing to complete (for RPC Send). Fails on defect. */
+  readonly sendWait: (event: E) => Effect.Effect<void, unknown>;
   /** Enqueue an ask event, returns the reply value */
   readonly ask: (event: E) => Effect.Effect<unknown, NoReplyError>;
   /** Get current state */
   readonly getState: Effect.Effect<S>;
+  /** SubscriptionRef for state observation (WatchState streaming) */
+  readonly stateRef: SubscriptionRef.SubscriptionRef<S>;
   /** Whether the runtime has stopped (final state reached) */
   readonly isStopped: Effect.Effect<boolean>;
   /** Stop the runtime (interrupt event loop, clean up) */
   readonly stop: Effect.Effect<void>;
+  /** @internal — raw event queue for direct enqueue (actor.ts uses this for pendingReplies tracking) */
+  readonly _queue: Queue.Queue<RuntimeQueuedEvent<E>>;
+  /** @internal — stopped ref for direct access */
+  readonly _stoppedRef: Ref.Ref<boolean>;
+  /**
+   * Exit deferred — set exactly once with the exit reason when the runtime stops.
+   * Final state → ActorExit.Final, explicit stop → ActorExit.Stopped, defect → ActorExit.Defect.
+   */
+  readonly exitDeferred: Deferred.Deferred<ActorExit<S>, never>;
+  /**
+   * Actor scope — owns background fibers for this generation.
+   * Closing this scope interrupts all background fibers.
+   */
+  readonly actorScope: Scope.CloseableScope;
+}
+/** @internal */
+interface RuntimeLifecycleHooks<S, E> {
+  /** Before processEventCore — actor emits @machine.event inspection */
+  readonly onEvent?: (state: S, event: E) => Effect.Effect<void>;
+  /** After SubscriptionRef.set on transition — actor notifies listeners, annotates spans */
+  readonly onStateChange?: (result: ProcessEventResult<S>, event: E) => Effect.Effect<void>;
+  /** After reply settlement when transition occurred — actor publishes to transitionsPubSub */
+  readonly onProcessed?: (result: ProcessEventResult<S>, event: E) => Effect.Effect<void>;
+  /** When final state detected in event loop — actor emits @machine.stop */
+  readonly onFinal?: (state: S) => Effect.Effect<void>;
+  /** Before stop resource cleanup — actor emits @machine.stop, settles pending replies */
+  readonly onShutdown?: () => Effect.Effect<void>;
+  /** Before initial spawn effects — actor emits @machine.effect inspection */
+  readonly onInitialSpawnEffects?: (state: S) => Effect.Effect<void>;
 }
 /** @internal */
 interface RuntimeConfig<S, E> {
   readonly actorId: string;
   readonly hooks?: ProcessEventHooks<S, E>;
+  /**
+   * Cell-owned resources. When provided, the runtime uses the cell's stateRef,
+   * eventQueue, and stoppedRef instead of creating its own.
+   * Used by actor.ts for supervision (cell owns stable resources across generations).
+   */
+  readonly cellResources?: RuntimeCellResources<S, E>;
   /**
    * Custom queue factory. Default: `Queue.unbounded()`.
    * Use `Queue.sliding(n)` or `Queue.dropping(n)` for bounded queues.
+   * Ignored when cellResources is provided.
    */
   readonly queueFactory?: Effect.Effect<Queue.Queue<RuntimeQueuedEvent<E>>>;
+  /** Lifecycle callbacks for actor-specific concerns */
+  readonly lifecycle?: RuntimeLifecycleHooks<S, E>;
+  /** Wrap each processQueued invocation — actor uses for span annotations */
+  readonly wrapProcess?: (state: S, event: E, inner: Effect.Effect<ProcessQueuedResult<S>>) => Effect.Effect<ProcessQueuedResult<S>>;
+  /** Called after self.spawn succeeds — actor tracks children */
+  readonly onChildSpawned?: (childId: string, child: unknown) => Effect.Effect<void>;
+  /** Skip registering stop as scope finalizer — actor manages its own lifecycle */
+  readonly skipFinalizer?: boolean;
+  /** Prefix for child actor IDs in self.spawn. Entity-machine uses `${actorId}/`. Default: no prefix. */
+  readonly childIdPrefix?: string;
+}
+/** @internal */
+interface ProcessQueuedResult<S> {
+  readonly shouldStop: boolean;
+  readonly stateChanged: boolean;
+  readonly result: ProcessEventResult<S>;
 }
 /**
  * Create a runtime for a machine. Returns a handle for sending events
  * and querying state. The runtime owns:
- * - Single event queue (all events serialized)
  * - Event loop fiber
  * - Postpone buffer
- * - Background effects
+ * - Background effects (under actorScope)
  * - State scope (spawn effects)
  * - Final state detection
+ * - Exit reason via exitDeferred
+ *
+ * Resources (stateRef, eventQueue, stoppedRef) are either cell-provided
+ * or allocated fresh by the runtime.
  *
  * @internal
  */
@@ -60,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 { RuntimeConfig, RuntimeHandle, RuntimeQueuedEvent, createRuntime };
+export { ProcessQueuedResult, RuntimeCellResources, RuntimeConfig, RuntimeHandle, RuntimeLifecycleHooks, RuntimeQueuedEvent, createRuntime };