effect-machine 0.9.0 → 0.10.0

package/{dist-v3 → v3/dist}/testing.js

@@ -1,9 +1,9 @@
 import { stubSystem } from "./internal/utils.js";
 import { AssertionError } from "./errors.js";
 import { BuiltMachine } from "./machine.js";
-import { executeTransition } from "./internal/transition.js";
+import { executeTransition, shouldPostpone } from "./internal/transition.js";
 import { Effect, SubscriptionRef } from "effect";
-//#region src-v3/testing.ts
+//#region src/testing.ts
 /**
 * Simulate a sequence of events through a machine without running an actor.
 * Useful for testing state transitions in isolation.
@@ -26,18 +26,44 @@ import { Effect, SubscriptionRef } from "effect";
 */
 const simulate = Effect.fn("effect-machine.simulate")(function* (input, events) {
 	const machine = input instanceof BuiltMachine ? input._inner : input;
+	const dummySend = Effect.fn("effect-machine.testing.simulate.send")((_event) => Effect.void);
 	const dummySelf = {
-		send: Effect.fn("effect-machine.testing.simulate.send")((_event) => Effect.void),
+		send: dummySend,
+		cast: dummySend,
 		spawn: () => Effect.die("spawn not supported in simulation")
 	};
 	let currentState = machine.initial;
 	const states = [currentState];
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const postponed = [];
 	for (const event of events) {
-		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+		if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
+			postponed.push(event);
+			continue;
+		}
+		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "simulation");
 		if (!result.transitioned) continue;
+		const prevTag = currentState._tag;
 		currentState = result.newState;
 		states.push(currentState);
 		if (machine.finalStates.has(currentState._tag)) break;
+		let drainTag = prevTag;
+		while (currentState._tag !== drainTag && postponed.length > 0) {
+			drainTag = currentState._tag;
+			const drained = postponed.splice(0);
+			for (const postponedEvent of drained) {
+				if (shouldPostpone(machine, currentState._tag, postponedEvent._tag)) {
+					postponed.push(postponedEvent);
+					continue;
+				}
+				const drainResult = yield* executeTransition(machine, currentState, postponedEvent, dummySelf, stubSystem, "simulation");
+				if (drainResult.transitioned) {
+					currentState = drainResult.newState;
+					states.push(currentState);
+					if (machine.finalStates.has(currentState._tag)) break;
+				}
+			}
+		}
 	}
 	return {
 		states,
@@ -113,20 +139,48 @@ const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(functi
 */
 const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function* (input, options) {
 	const machine = input instanceof BuiltMachine ? input._inner : input;
+	const dummySend = Effect.fn("effect-machine.testing.harness.send")((_event) => Effect.void);
 	const dummySelf = {
-		send: Effect.fn("effect-machine.testing.harness.send")((_event) => Effect.void),
+		send: dummySend,
+		cast: dummySend,
 		spawn: () => Effect.die("spawn not supported in test harness")
 	};
 	const stateRef = yield* SubscriptionRef.make(machine.initial);
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const postponed = [];
 	return {
 		state: stateRef,
 		send: Effect.fn("effect-machine.testHarness.send")(function* (event) {
 			const currentState = yield* SubscriptionRef.get(stateRef);
-			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+			if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
+				postponed.push(event);
+				return currentState;
+			}
+			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "test-harness");
 			if (!result.transitioned) return currentState;
+			const prevTag = currentState._tag;
 			const newState = result.newState;
 			yield* SubscriptionRef.set(stateRef, newState);
 			if (options?.onTransition !== void 0) options.onTransition(currentState, event, newState);
+			let drainTag = prevTag;
+			let currentTag = newState._tag;
+			while (currentTag !== drainTag && postponed.length > 0) {
+				drainTag = currentTag;
+				const drained = postponed.splice(0);
+				for (const postponedEvent of drained) {
+					const state = yield* SubscriptionRef.get(stateRef);
+					if (shouldPostpone(machine, state._tag, postponedEvent._tag)) {
+						postponed.push(postponedEvent);
+						continue;
+					}
+					const drainResult = yield* executeTransition(machine, state, postponedEvent, dummySelf, stubSystem, "test-harness");
+					if (drainResult.transitioned) {
+						yield* SubscriptionRef.set(stateRef, drainResult.newState);
+						currentTag = drainResult.newState._tag;
+						if (options?.onTransition !== void 0) options.onTransition(state, postponedEvent, drainResult.newState);
+					}
+				}
+			}
 			return newState;
 		}),
 		getState: SubscriptionRef.get(stateRef)

package/dist-v3/errors.d.ts

@@ -1,27 +0,0 @@
-//#region src-v3/errors.d.ts
-declare const DuplicateActorError_base: any;
-/** Attempted to spawn/restore actor with ID already in use */
-declare class DuplicateActorError extends DuplicateActorError_base {}
-declare const UnprovidedSlotsError_base: any;
-/** Machine has unprovided effect slots */
-declare class UnprovidedSlotsError extends UnprovidedSlotsError_base {}
-declare const MissingSchemaError_base: any;
-/** Operation requires schemas attached to machine */
-declare class MissingSchemaError extends MissingSchemaError_base {}
-declare const InvalidSchemaError_base: any;
-/** State/Event schema has no variants */
-declare class InvalidSchemaError extends InvalidSchemaError_base {}
-declare const MissingMatchHandlerError_base: any;
-/** $match called with missing handler for tag */
-declare class MissingMatchHandlerError extends MissingMatchHandlerError_base {}
-declare const SlotProvisionError_base: any;
-/** Slot handler not found at runtime (internal error) */
-declare class SlotProvisionError extends SlotProvisionError_base {}
-declare const ProvisionValidationError_base: any;
-/** Machine.build() validation failed - missing or extra handlers */
-declare class ProvisionValidationError extends ProvisionValidationError_base {}
-declare const AssertionError_base: any;
-/** Assertion failed in testing utilities */
-declare class AssertionError extends AssertionError_base {}
-//#endregion
-export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };

package/dist-v3/index.d.ts

@@ -1,12 +0,0 @@
-import { Event, MachineEventSchema, MachineStateSchema, State } from "./schema.js";
-import { PersistenceConfig, PersistentMachine, isPersistentMachine } from "./persistence/persistent-machine.js";
-import { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.js";
-import { EffectHandlers, EffectSlot, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlot, GuardSlots, GuardsDef, GuardsSchema, MachineContext, Slot } from "./slot.js";
-import { PersistentActorRef, createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
-import { ActorMetadata, PersistedEvent, PersistenceAdapter, PersistenceAdapterTag, PersistenceError, RestoreFailure, RestoreResult, Snapshot, VersionConflictError } from "./persistence/adapter.js";
-import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./persistence/adapters/in-memory.js";
-import { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, ProvideHandlers, SpawnEffect, StateHandlerContext, Transition, machine_d_exports } from "./machine.js";
-import { ActorRef, ActorSystem, Default, SystemEvent, SystemEventListener } from "./actor.js";
-import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, SpawnEvent, StopEvent, TransitionEvent, collectingInspector, consoleInspector, makeInspector } from "./inspection.js";
-export { type ActorMetadata, type ActorRef, 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, InMemoryPersistenceAdapter, type InspectionEvent, type Inspector, 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, type PersistOptions, type PersistedEvent, type PersistenceAdapter, PersistenceAdapterTag, type PersistenceConfig, PersistenceError, type PersistentActorRef, type PersistentMachine, type ProvideHandlers, ProvisionValidationError, type RestoreFailure, type RestoreResult, type SimulationResult, Slot, type EffectHandlers as SlotEffectHandlers, type EffectSlot as SlotEffectSlot, SlotProvisionError, type Snapshot, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, type SystemEvent, type SystemEventListener, type TestHarness, type TestHarnessOptions, type Transition, type TransitionEvent, UnprovidedSlotsError, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, restorePersistentActor, simulate };

package/dist-v3/index.js

@@ -1,13 +0,0 @@
-import { Inspector, collectingInspector, consoleInspector, makeInspector } from "./inspection.js";
-import { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError } from "./errors.js";
-import { isPersistentMachine } from "./persistence/persistent-machine.js";
-import { Slot } from "./slot.js";
-import { machine_exports } from "./machine.js";
-import { PersistenceAdapterTag, PersistenceError, VersionConflictError } from "./persistence/adapter.js";
-import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
-import { ActorSystem, Default } from "./actor.js";
-import { Event, State } from "./schema.js";
-import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./persistence/adapters/in-memory.js";
-import "./persistence/index.js";
-export { Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, InMemoryPersistenceAdapter, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, PersistenceAdapterTag, PersistenceError, ProvisionValidationError, Slot, SlotProvisionError, State, UnprovidedSlotsError, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, consoleInspector, createPersistentActor, createTestHarness, isPersistentMachine, makeInMemoryPersistenceAdapter, makeInspector, restorePersistentActor, simulate };

package/dist-v3/inspection.js

@@ -1,48 +0,0 @@
-import { Context } from "effect";
-//#region src-v3/inspection.ts
-/**
-* Inspector service tag - optional service for machine introspection
-* Uses `any` types to allow variance flexibility when providing the service
-*/
-const Inspector = Context.GenericTag("@effect/machine/Inspector");
-/**
-* Create an inspector from a callback function.
-*
-* Type params accept either raw tagged types or Schema constructors:
-* - `makeInspector(cb)` — defaults to `AnyInspectionEvent`
-* - `makeInspector<MyState, MyEvent>(cb)` — explicit tagged types
-* - `makeInspector<typeof MyState, typeof MyEvent>(cb)` — schema constructors (auto-extracts `.Type`)
-*/
-const makeInspector = (onInspect) => ({ onInspect });
-/**
-* Console inspector that logs events in a readable format
-*/
-const consoleInspector = () => makeInspector((event) => {
-	const prefix = `[${event.actorId}]`;
-	switch (event.type) {
-		case "@machine.spawn":
-			console.log(prefix, "spawned →", event.initialState._tag);
-			break;
-		case "@machine.event":
-			console.log(prefix, "received", event.event._tag, "in", event.state._tag);
-			break;
-		case "@machine.transition":
-			console.log(prefix, event.fromState._tag, "→", event.toState._tag);
-			break;
-		case "@machine.effect":
-			console.log(prefix, event.effectType, "effect in", event.state._tag);
-			break;
-		case "@machine.error":
-			console.log(prefix, "error in", event.phase, event.state._tag, "-", event.error);
-			break;
-		case "@machine.stop":
-			console.log(prefix, "stopped in", event.finalState._tag);
-			break;
-	}
-});
-/**
-* Collecting inspector that stores events in an array for testing
-*/
-const collectingInspector = (events) => ({ onInspect: (event) => events.push(event) });
-//#endregion
-export { Inspector, collectingInspector, consoleInspector, makeInspector };

package/dist-v3/internal/inspection.js

@@ -1,13 +0,0 @@
-import { Clock, Effect } from "effect";
-//#region src-v3/internal/inspection.ts
-/**
-* Emit an inspection event with timestamp from Clock.
-* @internal
-*/
-const emitWithTimestamp = Effect.fn("effect-machine.emitWithTimestamp")(function* (inspector, makeEvent) {
-	if (inspector === void 0) return;
-	const timestamp = yield* Clock.currentTimeMillis;
-	yield* Effect.try(() => inspector.onInspect(makeEvent(timestamp))).pipe(Effect.ignore);
-});
-//#endregion
-export { emitWithTimestamp };