effect-machine 0.19.0 → 0.21.0

package/dist/atom.js

@@ -1,5 +1,8 @@
+import { Match } from "effect";
 import { dual } from "effect/Function";
+import * as Option$1 from "effect/Option";
 import * as Atom from "effect/unstable/reactivity/Atom";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
 //#region src/atom.ts
 /**
 * Effect Atom integration for actors.
@@ -7,6 +10,17 @@ import * as Atom from "effect/unstable/reactivity/Atom";
 * The adapter keeps the actor as the state owner. Atom registries observe the
 * actor's SubscriptionRef and write events through its synchronous boundary.
 */
+/** Observe the current ActorRef for one ActorSystem key. */
+const fromSystem = dual(2, (system, key) => Atom.make(system.watch(key), { initialValue: Option$1.none() }));
+/** Suspend while an ActorSystem key is absent and follow later generations. */
+const acquire = dual(2, (system, key) => Atom.map(fromSystem(system, key), (result) => Match.value(result).pipe(Match.tagsExhaustive({
+	Initial: (initial) => AsyncResult.initial(initial.waiting),
+	Failure: (failure) => AsyncResult.failure(failure.cause, { waiting: failure.waiting }),
+	Success: (success) => Option$1.match(success.value, {
+		onNone: () => AsyncResult.initial(true),
+		onSome: (actor) => AsyncResult.success(actor, success)
+	})
+}))));
 /**
 * Make a writable Atom from an actor.
 *
@@ -16,7 +30,7 @@ import * as Atom from "effect/unstable/reactivity/Atom";
 */
 const make = (actor) => {
 	const state = Atom.subscriptionRef(actor.state);
-	return Atom.writable((get) => get(state), (_ctx, event) => actor.sync.send(event));
+	return Atom.writable((get) => get(state), (_ctx, event) => actor.client.send(event));
 };
 /**
 * Select part of an actor state.
@@ -25,5 +39,22 @@ const make = (actor) => {
 * The equality function controls when Atom subscribers receive a new value.
 */
 const select = dual((args) => Atom.isAtom(args[0]), (self, selector, equals = Object.is) => Atom.withEquality(Atom.map(self, selector), equals));
+/** Observe actor lifecycle without coupling it to domain state. */
+const lifecycle = (actor) => Atom.subscriptionRef(actor.lifecycle);
+/** Observe the latest accepted edge. The value remains after actor exit. */
+const latestTransition = (actor) => Atom.subscriptionRef(actor.latestTransition);
+/**
+* Observe whether an event has an enabled transition.
+*
+* The Atom reevaluates after each actor state change. It supports pure and
+* Effect predicates. Effect predicates use the context captured by the actor.
+*/
+const can = dual(2, (actor, event) => {
+	const state = Atom.subscriptionRef(actor.state);
+	return Atom.make((get) => {
+		get(state);
+		return actor.can(event);
+	}).pipe(Atom.withEquality((value, next) => AsyncResult.isSuccess(value) && AsyncResult.isSuccess(next) && Object.is(value.value, next.value)));
+});
 //#endregion
-export { make, select };
+export { acquire, can, fromSystem, latestTransition, lifecycle, make, select };

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

@@ -7,7 +7,7 @@ import { Rpc } from "effect/unstable/rpc";
 /**
  * Options for EntityMachine.layer
  */
-interface EntityMachineOptions<S> {
+interface EntityMachineBaseOptions<S> {
   /**
    * Initialize state from entity ID.
    * Called once when entity is first activated.
@@ -38,6 +38,12 @@ interface EntityMachineOptions<S> {
    */
   readonly persistence?: EntityPersistenceConfig;
 }
+type EntityMachineOptions<S, Input = void> = EntityMachineBaseOptions<S> & ([Input] extends [void] ? {
+  readonly input?: never;
+} : {
+  /** Map the entity ID to the machine input. */
+  readonly input: (entityId: string) => Input;
+});
 /**
  * Create an Entity layer that wires a machine to handle RPC calls.
  *
@@ -59,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>, options?: EntityMachineOptions<S>) => Layer.Layer<never, never, R>;
+  }, R, Input, Output, EntityType extends string, Rpcs extends Rpc.Any>(entity: Entity.Entity<EntityType, Rpcs>, machine: Machine<S, E, R, any, any, Input, Output>, ...optionsArgument: [Input] extends [void] ? [options?: EntityMachineOptions<S, Input>] : [options: EntityMachineOptions<S, Input>]) => Layer.Layer<never, never, R>;
 };
 //#endregion
-export { EntityMachine, EntityMachineOptions };
+export { EntityMachine, EntityMachineBaseOptions, EntityMachineOptions };

package/dist/cluster/entity-machine.js

@@ -35,7 +35,8 @@ import { Entity } from "effect/unstable/cluster";
 * })
 * ```
 */
-const EntityMachine = { layer: (entity, machine, options) => {
+const EntityMachine = { layer: (entity, machine, ...optionsArgument) => {
+	const options = optionsArgument[0];
 	const persistence = options?.persistence;
 	const build = Effect.gen(function* () {
 		const entityId = yield* Effect.serviceOption(Entity.CurrentAddress).pipe(Effect.map((opt) => {
@@ -43,23 +44,22 @@ const EntityMachine = { layer: (entity, machine, options) => {
 			return "";
 		}));
 		const inspector = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
+		const machineInitial = machine._initial(options?.input?.(entityId));
 		const existingSystem = yield* Effect.serviceOption(ActorSystem);
 		let system;
 		if (Option.isSome(existingSystem)) system = existingSystem.value;
 		else system = yield* makeSystem();
-		const persistCtx = yield* hydratePersistence(persistence, entity, entityId, machine, options?.initializeState);
+		const persistCtx = yield* hydratePersistence(persistence, entity, entityId, machine, machineInitial, options?.initializeState);
 		let initialState = persistCtx.hydratedState;
 		if (initialState === void 0 && options?.initializeState !== void 0) initialState = options.initializeState(entityId);
-		let machineWithState = machine;
-		if (initialState !== void 0) machineWithState = machine._withInitial(initialState);
 		const versionRef = yield* Ref.make(persistCtx.initialVersion);
-		const computedInitial = initialState ?? machine.initial;
+		const computedInitial = initialState ?? machineInitial;
 		const stateRef = yield* SubscriptionRef.make(computedInitial);
 		const stoppedRef = yield* Ref.make(false);
 		const eventQueue = yield* Queue.unbounded();
 		let hooks = void 0;
 		if (inspector !== void 0) hooks = makeInspectionHooks(entityId, inspector);
-		const runtime = yield* createRuntime(machineWithState, system, {
+		const runtime = yield* createRuntime(machine, system, {
 			actorId: entityId,
 			hooks,
 			childIdPrefix: `${entityId}/`,
@@ -152,7 +152,7 @@ const noPersistence = {
 	initialVersion: 0
 };
 /** Load snapshot/journal and compute hydrated state. */
-const hydratePersistence = (persistence, entityDef, entityId, machine, initializeState) => Effect.gen(function* () {
+const hydratePersistence = (persistence, entityDef, entityId, machine, machineInitial, initializeState) => Effect.gen(function* () {
 	if (persistence === void 0) return noPersistence;
 	const adapter = yield* PersistenceAdapter;
 	const key = {
@@ -164,7 +164,7 @@ const hydratePersistence = (persistence, entityDef, entityId, machine, initializ
 		let baseState;
 		if (Option.isSome(maybeSnapshot)) baseState = maybeSnapshot.value.state;
 		else if (initializeState !== void 0) baseState = initializeState(entityId);
-		else baseState = machine.initial;
+		else baseState = machineInitial;
 		let snapshotVersion = 0;
 		if (Option.isSome(maybeSnapshot)) snapshotVersion = maybeSnapshot.value.version;
 		const events = yield* adapter.loadEvents(key, snapshotVersion);

package/dist/cluster/index.d.ts

@@ -2,5 +2,5 @@ import { EntityPersistenceConfig, PersistedEvent, PersistenceAdapter, Persistenc
 import { makeInMemoryPersistenceAdapter } from "./adapters/in-memory.js";
 import { EntityRpcs, ToEntityOptions, toEntity } from "./to-entity.js";
 import { EntityActorRef, makeEntityActorRef } from "./entity-actor-ref.js";
-import { EntityMachine, EntityMachineOptions } from "./entity-machine.js";
-export { type EntityActorRef, EntityMachine, type EntityMachineOptions, type EntityPersistenceConfig, type EntityRpcs, type PersistedEvent, PersistenceAdapter, type PersistenceAdapterService as PersistenceAdapterInterface, type PersistenceKey, type Snapshot, type ToEntityOptions, makeEntityActorRef, makeInMemoryPersistenceAdapter, toEntity };
+import { EntityMachine, EntityMachineBaseOptions, EntityMachineOptions } from "./entity-machine.js";
+export { type EntityActorRef, EntityMachine, type EntityMachineBaseOptions, type EntityMachineOptions, type EntityPersistenceConfig, type EntityRpcs, type PersistedEvent, PersistenceAdapter, type PersistenceAdapterService as PersistenceAdapterInterface, type PersistenceKey, type Snapshot, type ToEntityOptions, makeEntityActorRef, makeInMemoryPersistenceAdapter, toEntity };

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

@@ -59,7 +59,7 @@ declare const toEntity: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>>(machine: Machine<S, E, R, SD, ED>, options: ToEntityOptions) => Entity.Entity<string, EntityRpcs<MachineStateSchema<SD> & {
+}, R, SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, Input, Output>(machine: Machine<S, E, R, SD, ED, Input, Output>, options: ToEntityOptions) => Entity.Entity<string, EntityRpcs<MachineStateSchema<SD> & {
   readonly Type: S;
 }, MachineEventSchema<ED> & {
   readonly Type: E;

package/dist/index.d.ts

@@ -2,9 +2,9 @@ import { DeferReplyResult, ReplyResult } from "./internal/utils.js";
 import { Event, MachineEventSchema, MachineStateSchema, ReplyFields, State } from "./schema.js";
 import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, NoReplyError, PersistenceError, VersionConflictError } from "./errors.js";
 import { ActorExit, DefectPhase, Supervision } from "./supervision.js";
-import { Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, StateHandlerContext, TaskOptions, TimeoutConfig, machine_d_exports } from "./machine.js";
+import { Durability, DurabilityCommit, FinalContext, GuardPredicate, HandlerContext, InputMakeConfig, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplayOptions, SpawnOptions, StateHandlerContext, TaskOptions, TimeoutConfig, machine_d_exports } from "./machine.js";
 import { ProcessEventResult } from "./internal/transition.js";
-import { ActorRef, ActorRefSync, ActorScope, ActorSystem, ActorSystemService, 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, InspectorService, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-export { ActorExit, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystemService as ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type InspectionEvent, type InspectorService as Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, NoReplyError, PersistenceError, type ProcessEventResult, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, 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 TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };
+import { ActorClient, ActorLifecycle, ActorRef, ActorRefSync, ActorScope, ActorSystem, ActorSystemKey, ActorSystemService, Default, SystemEvent, SystemEventListener, SystemSpawnOptions, TransitionInfo, actorSystemKey } from "./actor.js";
+import { InputTestHarnessOptions, SimulationOptions, SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
+import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, GuardEvent, InspectionEvent, Inspector, InspectorHandler, InspectorService, OperationEvent, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
+export { type ActorClient, ActorExit, type ActorExit as ActorExitType, type ActorLifecycle, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystemService as ActorSystem, Default as ActorSystemDefault, ActorSystemKey, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type FinalContext, type GuardEvent, type GuardPredicate, type HandlerContext, type InputMakeConfig, type InputTestHarnessOptions, type InspectionEvent, type InspectorService as Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, NoReplyError, type OperationEvent, PersistenceError, type ProcessEventResult, type Recovery, type RecoveryContext, type ReplayOptions, type ReplyFields, type ReplyResult, type SimulationOptions, type SimulationResult, type SpawnEvent, type SpawnOptions, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type SystemSpawnOptions, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type TransitionEvent, type TransitionInfo, VersionConflictError, actorSystemKey, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/index.js

@@ -2,7 +2,7 @@ import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaEr
 import { Event, State } from "./schema.js";
 import { Inspector, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
 import { ActorExit, Supervision } from "./supervision.js";
-import { ActorScope, ActorSystem, Default } from "./actor.js";
+import { ActorScope, ActorSystem, ActorSystemKey, Default, actorSystemKey } from "./actor.js";
 import { machine_exports } from "./machine.js";
 import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-export { ActorExit, ActorScope, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, NoReplyError, PersistenceError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };
+export { ActorExit, ActorScope, ActorStoppedError, Default as ActorSystemDefault, ActorSystemKey, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, NoReplyError, PersistenceError, State, Supervision, VersionConflictError, actorSystemKey, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/inspection.d.ts

@@ -10,6 +10,7 @@ type ResolveType<T> = T extends Schema.Schema<infer A> ? A : T;
 interface SpawnEvent<S> {
   readonly type: "@machine.spawn";
   readonly actorId: string;
+  readonly generation: number;
   readonly initialState: S;
   readonly timestamp: number;
 }
@@ -19,6 +20,7 @@ interface SpawnEvent<S> {
 interface EventReceivedEvent<S, E> {
   readonly type: "@machine.event";
   readonly actorId: string;
+  readonly generation: number;
   readonly state: S;
   readonly event: E;
   readonly timestamp: number;
@@ -29,17 +31,40 @@ interface EventReceivedEvent<S, E> {
 interface TransitionEvent<S, E> {
   readonly type: "@machine.transition";
   readonly actorId: string;
+  readonly generation: number;
   readonly fromState: S;
   readonly toState: S;
   readonly event: E;
   readonly timestamp: number;
 }
+/** Event emitted after a transition guard runs. */
+interface GuardEvent<S, E> {
+  readonly type: "@machine.guard";
+  readonly actorId: string;
+  readonly generation: number;
+  readonly state: S;
+  readonly event: E;
+  readonly guard: string;
+  readonly result: boolean;
+  readonly timestamp: number;
+}
+/** Event emitted before an accepted transition handler runs. */
+interface OperationEvent<S, E> {
+  readonly type: "@machine.operation";
+  readonly actorId: string;
+  readonly generation: number;
+  readonly operation: string;
+  readonly state: S;
+  readonly event: E;
+  readonly timestamp: number;
+}
 /**
  * Event emitted when a spawn effect runs
  */
 interface EffectEvent<S> {
   readonly type: "@machine.effect";
   readonly actorId: string;
+  readonly generation: number;
   readonly effectType: "spawn";
   readonly state: S;
   readonly timestamp: number;
@@ -47,9 +72,10 @@ interface EffectEvent<S> {
 interface TaskEvent<S> {
   readonly type: "@machine.task";
   readonly actorId: string;
+  readonly generation: number;
   readonly state: S;
   readonly taskName?: string;
-  readonly phase: "start" | "success" | "failure" | "interrupt";
+  readonly phase: "start" | "success" | "failure" | "defect" | "interrupt";
   readonly error?: string;
   readonly timestamp: number;
 }
@@ -59,6 +85,7 @@ interface TaskEvent<S> {
 interface ErrorEvent<S, E> {
   readonly type: "@machine.error";
   readonly actorId: string;
+  readonly generation: number;
   readonly phase: "transition" | "spawn";
   readonly state: S;
   readonly event: E;
@@ -71,13 +98,14 @@ interface ErrorEvent<S, E> {
 interface StopEvent<S> {
   readonly type: "@machine.stop";
   readonly actorId: string;
+  readonly generation: number;
   readonly finalState: S;
   readonly timestamp: number;
 }
 /**
  * Union of all inspection events
  */
-type InspectionEvent<S, E> = SpawnEvent<S> | EventReceivedEvent<S, E> | TransitionEvent<S, E> | EffectEvent<S> | TaskEvent<S> | ErrorEvent<S, E> | StopEvent<S>;
+type InspectionEvent<S, E> = SpawnEvent<S> | EventReceivedEvent<S, E> | TransitionEvent<S, E> | GuardEvent<S, E> | OperationEvent<S, E> | EffectEvent<S> | TaskEvent<S> | ErrorEvent<S, E> | StopEvent<S>;
 /**
  * Convenience alias for untyped inspection events.
  * Useful for general-purpose inspectors that don't need specific state/event types.
@@ -148,4 +176,4 @@ declare const collectingInspector: <S extends {
   readonly _tag: string;
 }>(events: InspectionEvent<S, E>[]) => InspectorService<S, E>;
 //#endregion
-export { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, InspectorService, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector };
+export { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, GuardEvent, InspectionEvent, Inspector, InspectorHandler, InspectorService, OperationEvent, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector };

package/dist/inspection.js

@@ -29,6 +29,8 @@ const inspectionSpanName = (event) => {
 		case "@machine.spawn": return `Machine.inspect ${event.initialState._tag}`;
 		case "@machine.event": return `Machine.inspect ${event.event._tag}`;
 		case "@machine.transition": return `Machine.inspect ${event.fromState._tag}->${event.toState._tag}`;
+		case "@machine.guard": return `Machine.inspect guard:${event.guard}`;
+		case "@machine.operation": return `Machine.inspect operation:${event.operation}`;
 		case "@machine.effect": return `Machine.inspect ${event.effectType}`;
 		case "@machine.task": return `Machine.inspect task:${event.phase}`;
 		case "@machine.error": return `Machine.inspect ${event.phase}`;
@@ -40,6 +42,8 @@ const inspectionTraceName = (event) => {
 		case "@machine.spawn": return `machine.spawn ${event.initialState._tag}`;
 		case "@machine.event": return `machine.event ${event.event._tag}`;
 		case "@machine.transition": return `machine.transition ${event.fromState._tag}->${event.toState._tag}`;
+		case "@machine.guard": return `machine.guard ${event.guard}`;
+		case "@machine.operation": return `machine.operation ${event.operation}`;
 		case "@machine.effect": return `machine.effect ${event.effectType}`;
 		case "@machine.task": {
 			let taskSuffix = "";
@@ -53,6 +57,7 @@ const inspectionTraceName = (event) => {
 const inspectionAttributes = (event) => {
 	const shared = {
 		"machine.actor.id": event.actorId,
+		"machine.actor.generation": event.generation,
 		"machine.inspection.type": event.type
 	};
 	switch (event.type) {
@@ -71,6 +76,19 @@ const inspectionAttributes = (event) => {
 			"machine.state.to": event.toState._tag,
 			"machine.event.tag": event.event._tag
 		};
+		case "@machine.guard": return {
+			...shared,
+			"machine.state.current": event.state._tag,
+			"machine.event.tag": event.event._tag,
+			"machine.guard.name": event.guard,
+			"machine.guard.result": event.result
+		};
+		case "@machine.operation": return {
+			...shared,
+			"machine.state.current": event.state._tag,
+			"machine.event.tag": event.event._tag,
+			"machine.operation.name": event.operation
+		};
 		case "@machine.effect": return {
 			...shared,
 			"machine.state.current": event.state._tag,
@@ -110,6 +128,7 @@ const tracingInspector = (options) => ({ onInspect: (event) => {
 		const currentSpan = yield* Effect.option(Effect.currentSpan);
 		if (Option.isSome(currentSpan)) currentSpan.value.event(traceName, BigInt(event.timestamp) * 1000000n, {
 			actorId: event.actorId,
+			generation: event.generation,
 			inspectionType: event.type
 		});
 	})().pipe(Effect.withSpan(spanName ?? inspectionSpanName(event), { attributes }));
@@ -123,6 +142,8 @@ const consoleInspector = () => makeInspectorEffect((event) => {
 		case "@machine.spawn": return Effect.log(`${prefix} spawned -> ${event.initialState._tag}`);
 		case "@machine.event": return Effect.log(`${prefix} received ${event.event._tag} in ${event.state._tag}`);
 		case "@machine.transition": return Effect.log(`${prefix} ${event.fromState._tag} -> ${event.toState._tag}`);
+		case "@machine.guard": return Effect.log(`${prefix} guard ${event.guard} -> ${String(event.result)}`);
+		case "@machine.operation": return Effect.log(`${prefix} operation ${event.operation} in ${event.state._tag}`);
 		case "@machine.effect": return Effect.log(`${prefix} ${event.effectType} effect in ${event.state._tag}`);
 		case "@machine.task": return Effect.log(`${prefix} task ${event.phase} ${event.taskName ?? "<unnamed>"} in ${event.state._tag}`);
 		case "@machine.error": return Effect.log(`${prefix} error in ${event.phase} ${event.state._tag} - ${String(event.error)}`);

package/dist/internal/inspection.d.ts

@@ -2,6 +2,6 @@ import { ProcessEventHooks } from "./transition.js";
 import { InspectorService } from "../inspection.js";
 //#region src/internal/inspection.d.ts
 /** Adapt the Inspector service to the transition kernel. */
-declare const makeInspectionHooks: <S, E>(actorId: string, inspector: InspectorService<S, E>) => ProcessEventHooks<S, E>;
+declare const makeInspectionHooks: <S, E>(actorId: string, inspector: InspectorService<S, E>, getGeneration?: () => number) => ProcessEventHooks<S, E>;
 //#endregion
 export { makeInspectionHooks };

package/dist/internal/inspection.js

@@ -11,10 +11,30 @@ const emitWithTimestamp = Effect.fn("effect-machine.emitWithTimestamp")(function
 	if (Effect.isEffect(result)) yield* result.pipe(Effect.ignoreCause);
 });
 /** Adapt the Inspector service to the transition kernel. */
-const makeInspectionHooks = (actorId, inspector) => ({
+const makeInspectionHooks = (actorId, inspector, getGeneration = () => 0) => ({
+	onGuard: (evaluation) => emitWithTimestamp(inspector, (timestamp) => ({
+		type: "@machine.guard",
+		actorId,
+		generation: getGeneration(),
+		state: evaluation.state,
+		event: evaluation.event,
+		guard: evaluation.guard,
+		result: evaluation.result,
+		timestamp
+	})),
+	onOperation: (operation) => emitWithTimestamp(inspector, (timestamp) => ({
+		type: "@machine.operation",
+		actorId,
+		generation: getGeneration(),
+		operation: operation.operation,
+		state: operation.state,
+		event: operation.event,
+		timestamp
+	})),
 	onSpawnEffect: (state) => emitWithTimestamp(inspector, (timestamp) => ({
 		type: "@machine.effect",
 		actorId,
+		generation: getGeneration(),
 		effectType: "spawn",
 		state,
 		timestamp
@@ -22,6 +42,7 @@ const makeInspectionHooks = (actorId, inspector) => ({
 	onTransition: (from, to, event) => emitWithTimestamp(inspector, (timestamp) => ({
 		type: "@machine.transition",
 		actorId,
+		generation: getGeneration(),
 		fromState: from,
 		toState: to,
 		event,
@@ -30,6 +51,7 @@ const makeInspectionHooks = (actorId, inspector) => ({
 	onError: (info) => emitWithTimestamp(inspector, (timestamp) => ({
 		type: "@machine.error",
 		actorId,
+		generation: getGeneration(),
 		phase: info.phase,
 		state: info.state,
 		event: info.event,

package/dist/internal/machine-definition.d.ts

@@ -4,6 +4,7 @@ interface Transition<State, Event, R> {
   readonly eventTag: string;
   readonly handler: TransitionHandler<State, Event, State, R>;
   readonly reenter?: boolean;
+  readonly guard?: GuardPredicate<State, Event, never>;
 }
 interface SpawnEffect<State, Event, R> {
   readonly stateTag: string;

package/dist/internal/machine-initialization.d.ts

@@ -0,0 +1,21 @@
+//#region src/internal/machine-initialization.d.ts
+/** How a machine creates the initial state for one actor. */
+type MachineInitialization<Input, State> = {
+  readonly _tag: "Static";
+  readonly state: State;
+} | {
+  readonly _tag: "Input";
+  readonly initialize: (input: Input) => State;
+};
+declare const make: <Input, State>(initial: State | ((input: Input) => State)) => MachineInitialization<Input, State>;
+/** Resolve one actor initial state. This is the only input erasure seam. */
+declare const resolve: <Input, State>(initialization: MachineInitialization<Input, State>, input: unknown) => State;
+/** Return the static value, or undefined for an input machine. */
+declare const staticValue: <Input, State>(initialization: MachineInitialization<Input, State>) => State | undefined;
+declare const MachineInitialization: {
+  make: typeof make;
+  resolve: typeof resolve;
+  staticValue: typeof staticValue;
+};
+//#endregion
+export { MachineInitialization };

package/dist/internal/machine-initialization.js

@@ -0,0 +1,27 @@
+//#region src/internal/machine-initialization.ts
+const make = (initial) => {
+	if (typeof initial === "function") return {
+		_tag: "Input",
+		initialize: initial
+	};
+	return {
+		_tag: "Static",
+		state: initial
+	};
+};
+/** Resolve one actor initial state. This is the only input erasure seam. */
+const resolve = (initialization, input) => {
+	if (initialization._tag === "Static") return initialization.state;
+	return initialization.initialize(input);
+};
+/** Return the static value, or undefined for an input machine. */
+const staticValue = (initialization) => {
+	if (initialization._tag === "Static") return initialization.state;
+};
+const MachineInitialization = {
+	make,
+	resolve,
+	staticValue
+};
+//#endregion
+export { MachineInitialization };

package/dist/internal/runtime.d.ts

@@ -1 +1,15 @@
-export {}
+import { DefectPhase } from "../supervision.js";
+//#region src/internal/runtime.d.ts
+/** Internal exit reason for one runtime generation. */
+type RuntimeExit<S> = {
+  readonly _tag: "Final";
+  readonly state: S;
+} | {
+  readonly _tag: "Stopped";
+} | {
+  readonly _tag: "Defect";
+  readonly cause: Cause.Cause<unknown>;
+  readonly phase: DefectPhase;
+};
+//#endregion
+export { RuntimeExit };