effect-machine 0.6.0 → 0.7.0

package/dist-v3/machine.js

@@ -0,0 +1,317 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { getTag } from "./internal/utils.js";
+import { ProvisionValidationError, SlotProvisionError } from "./errors.js";
+import { persist } from "./persistence/persistent-machine.js";
+import { MachineContextTag } from "./slot.js";
+import { findTransitions, invalidateIndex } from "./internal/transition.js";
+import { createActor } from "./actor.js";
+import { Cause, Effect, Exit, Option, Scope } from "effect";
+
+//#region src-v3/machine.ts
+var machine_exports = /* @__PURE__ */ __exportAll({
+	BuiltMachine: () => BuiltMachine,
+	Machine: () => Machine,
+	findTransitions: () => findTransitions,
+	make: () => make,
+	spawn: () => spawn
+});
+/**
+* A finalized machine ready for spawning.
+*
+* Created by calling `.build()` on a `Machine`. This is the only type
+* accepted by `Machine.spawn` and `ActorSystem.spawn` (regular overload).
+* Testing utilities (`simulate`, `createTestHarness`, etc.) still accept `Machine`.
+*/
+var BuiltMachine = class {
+	/** @internal */
+	_inner;
+	/** @internal */
+	constructor(machine) {
+		this._inner = machine;
+	}
+	get initial() {
+		return this._inner.initial;
+	}
+	persist(config) {
+		return this._inner.persist(config);
+	}
+};
+/**
+* Machine definition with fluent builder API.
+*
+* Type parameters:
+* - `State`: The state union type
+* - `Event`: The event union type
+* - `R`: Effect requirements
+* - `_SD`: State schema definition (for compile-time validation)
+* - `_ED`: Event schema definition (for compile-time validation)
+* - `GD`: Guard definitions
+* - `EFD`: Effect definitions
+*/
+var Machine = class Machine {
+	initial;
+	/** @internal */ _transitions;
+	/** @internal */ _spawnEffects;
+	/** @internal */ _backgroundEffects;
+	/** @internal */ _finalStates;
+	/** @internal */ _guardsSchema;
+	/** @internal */ _effectsSchema;
+	/** @internal */ _guardHandlers;
+	/** @internal */ _effectHandlers;
+	/** @internal */ _slots;
+	stateSchema;
+	eventSchema;
+	/**
+	* Context tag for accessing machine state/event/self in slot handlers.
+	* Uses shared module-level tag for all machines.
+	*/
+	Context = MachineContextTag;
+	get transitions() {
+		return this._transitions;
+	}
+	get spawnEffects() {
+		return this._spawnEffects;
+	}
+	get backgroundEffects() {
+		return this._backgroundEffects;
+	}
+	get finalStates() {
+		return this._finalStates;
+	}
+	get guardsSchema() {
+		return this._guardsSchema;
+	}
+	get effectsSchema() {
+		return this._effectsSchema;
+	}
+	/** @internal */
+	constructor(initial, stateSchema, eventSchema, guardsSchema, effectsSchema) {
+		this.initial = initial;
+		this._transitions = [];
+		this._spawnEffects = [];
+		this._backgroundEffects = [];
+		this._finalStates = /* @__PURE__ */ new Set();
+		this._guardsSchema = guardsSchema;
+		this._effectsSchema = effectsSchema;
+		this._guardHandlers = /* @__PURE__ */ new Map();
+		this._effectHandlers = /* @__PURE__ */ new Map();
+		this.stateSchema = stateSchema;
+		this.eventSchema = eventSchema;
+		this._slots = {
+			guards: this._guardsSchema !== void 0 ? this._guardsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOptional(this.Context).pipe(Effect.orDie), (ctx) => {
+				const handler = this._guardHandlers.get(name);
+				if (handler === void 0) return Effect.die(new SlotProvisionError({
+					slotName: name,
+					slotType: "guard"
+				}));
+				const result = handler(params, ctx);
+				return typeof result === "boolean" ? Effect.succeed(result) : result;
+			})) : {},
+			effects: this._effectsSchema !== void 0 ? this._effectsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOptional(this.Context).pipe(Effect.orDie), (ctx) => {
+				const handler = this._effectHandlers.get(name);
+				if (handler === void 0) return Effect.die(new SlotProvisionError({
+					slotName: name,
+					slotType: "effect"
+				}));
+				return handler(params, ctx);
+			})) : {}
+		};
+	}
+	on(stateOrStates, event, handler) {
+		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
+		for (const s of states) this.addTransition(s, event, handler, false);
+		return this;
+	}
+	reenter(stateOrStates, event, handler) {
+		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
+		for (const s of states) this.addTransition(s, event, handler, true);
+		return this;
+	}
+	/**
+	* Register a wildcard transition that fires from any state when no specific transition matches.
+	* Specific `.on()` transitions always take priority over `.onAny()`.
+	*/
+	onAny(event, handler) {
+		const transition = {
+			stateTag: "*",
+			eventTag: getTag(event),
+			handler,
+			reenter: false
+		};
+		this._transitions.push(transition);
+		invalidateIndex(this);
+		return this;
+	}
+	/** @internal */
+	addTransition(state, event, handler, reenter) {
+		const transition = {
+			stateTag: getTag(state),
+			eventTag: getTag(event),
+			handler,
+			reenter
+		};
+		this._transitions.push(transition);
+		invalidateIndex(this);
+		return this;
+	}
+	/**
+	* State-scoped effect that is forked on state entry and automatically cancelled on state exit.
+	* Use effect slots defined via `Slot.Effects` for the actual work.
+	*
+	* @example
+	* ```ts
+	* const MyEffects = Slot.Effects({
+	*   fetchData: { url: Schema.String },
+	* });
+	*
+	* machine
+	*   .spawn(State.Loading, ({ effects, state }) => effects.fetchData({ url: state.url }))
+	*   .build({
+	*     fetchData: ({ url }, { self }) =>
+	*       Effect.gen(function* () {
+	*         yield* Effect.addFinalizer(() => Effect.log("Leaving Loading"));
+	*         const data = yield* Http.get(url);
+	*         yield* self.send(Event.Loaded({ data }));
+	*       }),
+	*   });
+	* ```
+	*/
+	spawn(state, handler) {
+		const stateTag = getTag(state);
+		this._spawnEffects.push({
+			stateTag,
+			handler
+		});
+		invalidateIndex(this);
+		return this;
+	}
+	/**
+	* State-scoped task that runs on entry and sends success/failure events.
+	* Interrupts do not emit failure events.
+	*/
+	task(state, run, options) {
+		const handler = Effect.fn("effect-machine.task")(function* (ctx) {
+			const exit = yield* Effect.exit(run(ctx));
+			if (Exit.isSuccess(exit)) {
+				yield* ctx.self.send(options.onSuccess(exit.value, ctx));
+				yield* Effect.yieldNow();
+				return;
+			}
+			const cause = exit.cause;
+			if (Cause.isInterruptedOnly(cause)) return;
+			if (options.onFailure !== void 0) {
+				yield* ctx.self.send(options.onFailure(cause, ctx));
+				yield* Effect.yieldNow();
+				return;
+			}
+			return yield* Effect.failCause(cause).pipe(Effect.orDie);
+		});
+		return this.spawn(state, handler);
+	}
+	/**
+	* Machine-lifetime effect that is forked on actor spawn and runs until the actor stops.
+	* Use effect slots defined via `Slot.Effects` for the actual work.
+	*
+	* @example
+	* ```ts
+	* const MyEffects = Slot.Effects({
+	*   heartbeat: {},
+	* });
+	*
+	* machine
+	*   .background(({ effects }) => effects.heartbeat())
+	*   .build({
+	*     heartbeat: (_, { self }) =>
+	*       Effect.forever(
+	*         Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping)))
+	*       ),
+	*   });
+	* ```
+	*/
+	background(handler) {
+		this._backgroundEffects.push({ handler });
+		return this;
+	}
+	final(state) {
+		const stateTag = getTag(state);
+		this._finalStates.add(stateTag);
+		return this;
+	}
+	/**
+	* Finalize the machine. Returns a `BuiltMachine` — the only type accepted by `Machine.spawn`.
+	*
+	* - Machines with slots: pass implementations as the first argument.
+	* - Machines without slots: call with no arguments.
+	*/
+	build(...args) {
+		const handlers = args[0];
+		if (handlers !== void 0) {
+			const requiredSlots = /* @__PURE__ */ new Set();
+			if (this._guardsSchema !== void 0) for (const name of Object.keys(this._guardsSchema.definitions)) requiredSlots.add(name);
+			if (this._effectsSchema !== void 0) for (const name of Object.keys(this._effectsSchema.definitions)) requiredSlots.add(name);
+			const providedSlots = new Set(Object.keys(handlers));
+			const missing = [];
+			const extra = [];
+			for (const name of requiredSlots) if (!providedSlots.has(name)) missing.push(name);
+			for (const name of providedSlots) if (!requiredSlots.has(name)) extra.push(name);
+			if (missing.length > 0 || extra.length > 0) throw new ProvisionValidationError({
+				missing,
+				extra
+			});
+			const result = new Machine(this.initial, this.stateSchema, this.eventSchema, this._guardsSchema, this._effectsSchema);
+			result._transitions = [...this._transitions];
+			result._finalStates = new Set(this._finalStates);
+			result._spawnEffects = [...this._spawnEffects];
+			result._backgroundEffects = [...this._backgroundEffects];
+			const anyHandlers = handlers;
+			if (this._guardsSchema !== void 0) for (const name of Object.keys(this._guardsSchema.definitions)) result._guardHandlers.set(name, anyHandlers[name]);
+			if (this._effectsSchema !== void 0) for (const name of Object.keys(this._effectsSchema.definitions)) result._effectHandlers.set(name, anyHandlers[name]);
+			return new BuiltMachine(result);
+		}
+		return new BuiltMachine(this);
+	}
+	/** @internal Persist from raw Machine — prefer BuiltMachine.persist() */
+	persist(config) {
+		return persist(config)(this);
+	}
+	static make(config) {
+		return new Machine(config.initial, config.state, config.event, config.guards, config.effects);
+	}
+};
+const make = Machine.make;
+/**
+* Spawn an actor directly without ActorSystem ceremony.
+* Accepts only `BuiltMachine` (call `.build()` first).
+*
+* **Single actor, no registry.** Caller manages lifetime via `actor.stop`.
+* If a `Scope` exists in context, cleanup attaches automatically on scope close.
+*
+* For registry, lookup by ID, persistence, or multi-actor coordination,
+* use `ActorSystemService` / `system.spawn` instead.
+*
+* @example
+* ```ts
+* // Fire-and-forget — caller manages lifetime
+* const actor = yield* Machine.spawn(machine.build());
+* yield* actor.send(Event.Start);
+* yield* actor.awaitFinal;
+* yield* actor.stop;
+*
+* // Scope-aware — auto-cleans up on scope close
+* yield* Effect.scoped(Effect.gen(function* () {
+*   const actor = yield* Machine.spawn(machine.build());
+*   yield* actor.send(Event.Start);
+*   // actor.stop called automatically when scope closes
+* }));
+* ```
+*/
+const spawnImpl = Effect.fn("effect-machine.spawn")(function* (built, id) {
+	const actor = yield* createActor(id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner);
+	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
+	return actor;
+});
+const spawn = spawnImpl;
+
+//#endregion
+export { BuiltMachine, Machine, findTransitions, machine_exports, make, spawn };

package/dist-v3/persistence/adapter.d.ts

@@ -0,0 +1,125 @@
+import { DuplicateActorError } from "../errors.js";
+import { PersistentActorRef } from "./persistent-actor.js";
+import { Effect, Option, Schema } from "effect";
+
+//#region src-v3/persistence/adapter.d.ts
+/**
+ * Metadata for a persisted actor.
+ * Used for discovery and filtering during bulk restore.
+ */
+interface ActorMetadata {
+  readonly id: string;
+  /** User-provided identifier for the machine type */
+  readonly machineType: string;
+  readonly createdAt: number;
+  readonly lastActivityAt: number;
+  readonly version: number;
+  /** Current state _tag value */
+  readonly stateTag: string;
+}
+/**
+ * Result of a bulk restore operation.
+ * Contains both successfully restored actors and failures.
+ */
+interface RestoreResult<S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R = never> {
+  readonly restored: ReadonlyArray<PersistentActorRef<S, E, R>>;
+  readonly failed: ReadonlyArray<RestoreFailure>;
+}
+/**
+ * A single restore failure with actor ID and error details.
+ */
+interface RestoreFailure {
+  readonly id: string;
+  readonly error: PersistenceError | DuplicateActorError;
+}
+/**
+ * Snapshot of actor state at a point in time
+ */
+interface Snapshot<S> {
+  readonly state: S;
+  readonly version: number;
+  readonly timestamp: number;
+}
+/**
+ * Persisted event with metadata
+ */
+interface PersistedEvent<E> {
+  readonly event: E;
+  readonly version: number;
+  readonly timestamp: number;
+}
+/**
+ * Adapter for persisting actor state and events.
+ *
+ * Implementations handle serialization and storage of snapshots and event journals.
+ * Schema parameters ensure type-safe serialization/deserialization.
+ * Schemas must have no context requirements (use Schema<S, SI, never>).
+ */
+interface PersistenceAdapter {
+  /**
+   * Save a snapshot of actor state.
+   * Implementations should use optimistic locking — fail if version mismatch.
+   */
+  readonly saveSnapshot: <S, SI>(id: string, snapshot: Snapshot<S>, schema: Schema.Schema<S, SI, never>) => Effect.Effect<void, PersistenceError | VersionConflictError>;
+  /**
+   * Load the latest snapshot for an actor.
+   * Returns None if no snapshot exists.
+   */
+  readonly loadSnapshot: <S, SI>(id: string, schema: Schema.Schema<S, SI, never>) => Effect.Effect<Option.Option<Snapshot<S>>, PersistenceError>;
+  /**
+   * Append an event to the actor's event journal.
+   */
+  readonly appendEvent: <E, EI>(id: string, event: PersistedEvent<E>, schema: Schema.Schema<E, EI, never>) => Effect.Effect<void, PersistenceError>;
+  /**
+   * Load events from the journal, optionally after a specific version.
+   */
+  readonly loadEvents: <E, EI>(id: string, schema: Schema.Schema<E, EI, never>, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<E>>, PersistenceError>;
+  /**
+   * Delete all persisted data for an actor (snapshot + events).
+   */
+  readonly deleteActor: (id: string) => Effect.Effect<void, PersistenceError>;
+  /**
+   * List all persisted actor metadata.
+   * Optional — adapters without registry support can omit this.
+   */
+  readonly listActors?: () => Effect.Effect<ReadonlyArray<ActorMetadata>, PersistenceError>;
+  /**
+   * Save or update actor metadata.
+   * Called on spawn and state transitions.
+   * Optional — adapters without registry support can omit this.
+   */
+  readonly saveMetadata?: (metadata: ActorMetadata) => Effect.Effect<void, PersistenceError>;
+  /**
+   * Delete actor metadata.
+   * Called when actor is deleted.
+   * Optional — adapters without registry support can omit this.
+   */
+  readonly deleteMetadata?: (id: string) => Effect.Effect<void, PersistenceError>;
+  /**
+   * Load metadata for a specific actor by ID.
+   * Returns None if no metadata exists.
+   * Optional — adapters without registry support can omit this.
+   */
+  readonly loadMetadata?: (id: string) => Effect.Effect<Option.Option<ActorMetadata>, PersistenceError>;
+}
+declare const PersistenceError_base: any;
+/**
+ * Error type for persistence operations
+ */
+declare class PersistenceError extends PersistenceError_base {}
+declare const VersionConflictError_base: any;
+/**
+ * Version conflict error — snapshot version doesn't match expected
+ */
+declare class VersionConflictError extends VersionConflictError_base {}
+declare const PersistenceAdapterTag_base: any;
+/**
+ * PersistenceAdapter service tag
+ */
+declare class PersistenceAdapterTag extends PersistenceAdapterTag_base {}
+//#endregion
+export { ActorMetadata, PersistedEvent, PersistenceAdapter, PersistenceAdapterTag, PersistenceError, RestoreFailure, RestoreResult, Snapshot, VersionConflictError };

package/dist-v3/persistence/adapter.js

@@ -0,0 +1,27 @@
+import { Context, Schema } from "effect";
+
+//#region src-v3/persistence/adapter.ts
+/**
+* Error type for persistence operations
+*/
+var PersistenceError = class extends Schema.TaggedError()("PersistenceError", {
+	operation: Schema.String,
+	actorId: Schema.String,
+	cause: Schema.optional(Schema.Unknown),
+	message: Schema.optional(Schema.String)
+}) {};
+/**
+* Version conflict error — snapshot version doesn't match expected
+*/
+var VersionConflictError = class extends Schema.TaggedError()("VersionConflictError", {
+	actorId: Schema.String,
+	expectedVersion: Schema.Number,
+	actualVersion: Schema.Number
+}) {};
+/**
+* PersistenceAdapter service tag
+*/
+var PersistenceAdapterTag = class extends Context.Tag("effect-machine/src/persistence/adapter/PersistenceAdapterTag")() {};
+
+//#endregion
+export { PersistenceAdapterTag, PersistenceError, VersionConflictError };

package/dist-v3/persistence/adapters/in-memory.d.ts

@@ -0,0 +1,32 @@
+import { PersistenceAdapter, PersistenceAdapterTag } from "../adapter.js";
+import { Effect, Layer } from "effect";
+
+//#region src-v3/persistence/adapters/in-memory.d.ts
+/**
+ * Create an in-memory persistence adapter effect.
+ * Returns the adapter directly for custom layer composition.
+ */
+declare const makeInMemoryPersistenceAdapter: Effect.Effect<PersistenceAdapter, never, never>;
+/**
+ * In-memory persistence adapter layer.
+ * Data is not persisted across process restarts.
+ *
+ * NOTE: Each `Effect.provide(InMemoryPersistenceAdapter)` creates a NEW adapter
+ * with empty storage. For tests that need persistent storage across multiple
+ * runPromise calls, use `makeInMemoryPersistenceAdapter` with a shared scope.
+ *
+ * @example
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const system = yield* ActorSystemService;
+ *   const actor = yield* system.spawn("my-actor", persistentMachine);
+ *   // ...
+ * }).pipe(
+ *   Effect.provide(InMemoryPersistenceAdapter),
+ *   Effect.provide(ActorSystemDefault),
+ * );
+ * ```
+ */
+declare const InMemoryPersistenceAdapter: Layer.Layer<PersistenceAdapterTag>;
+//#endregion
+export { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter };

package/dist-v3/persistence/adapters/in-memory.js

@@ -0,0 +1,176 @@
+import { PersistenceAdapterTag, PersistenceError, VersionConflictError } from "../adapter.js";
+import { Effect, Layer, Option, Ref, Schema } from "effect";
+
+//#region src-v3/persistence/adapters/in-memory.ts
+/**
+* Create an in-memory persistence adapter.
+* Useful for testing and development.
+*/
+const make = Effect.gen(function* () {
+	const storage = yield* Ref.make(/* @__PURE__ */ new Map());
+	const registry = yield* Ref.make(/* @__PURE__ */ new Map());
+	const getOrCreateStorage = Effect.fn("effect-machine.persistence.inMemory.getOrCreateStorage")(function* (id) {
+		return yield* Ref.modify(storage, (map) => {
+			const existing = map.get(id);
+			if (existing !== void 0) return [existing, map];
+			const newStorage = {
+				snapshot: Option.none(),
+				events: []
+			};
+			const newMap = new Map(map);
+			newMap.set(id, newStorage);
+			return [newStorage, newMap];
+		});
+	});
+	const updateStorage = Effect.fn("effect-machine.persistence.inMemory.updateStorage")(function* (id, update) {
+		yield* Ref.update(storage, (map) => {
+			const existing = map.get(id);
+			if (existing === void 0) return map;
+			const newMap = new Map(map);
+			newMap.set(id, update(existing));
+			return newMap;
+		});
+	});
+	return {
+		saveSnapshot: Effect.fn("effect-machine.persistence.inMemory.saveSnapshot")(function* (id, snapshot, schema) {
+			const actorStorage = yield* getOrCreateStorage(id);
+			if (Option.isSome(actorStorage.snapshot)) {
+				const existingVersion = actorStorage.snapshot.value.version;
+				if (snapshot.version < existingVersion) return yield* new VersionConflictError({
+					actorId: id,
+					expectedVersion: existingVersion,
+					actualVersion: snapshot.version
+				});
+			}
+			const encoded = yield* Schema.encode(schema)(snapshot.state).pipe(Effect.mapError((cause) => new PersistenceError({
+				operation: "saveSnapshot",
+				actorId: id,
+				cause,
+				message: "Failed to encode state"
+			})));
+			yield* updateStorage(id, (s) => ({
+				...s,
+				snapshot: Option.some({
+					data: encoded,
+					version: snapshot.version,
+					timestamp: snapshot.timestamp
+				})
+			}));
+		}),
+		loadSnapshot: Effect.fn("effect-machine.persistence.inMemory.loadSnapshot")(function* (id, schema) {
+			const actorStorage = yield* getOrCreateStorage(id);
+			if (Option.isNone(actorStorage.snapshot)) return Option.none();
+			const stored = actorStorage.snapshot.value;
+			const decoded = yield* Schema.decode(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
+				operation: "loadSnapshot",
+				actorId: id,
+				cause,
+				message: "Failed to decode state"
+			})));
+			return Option.some({
+				state: decoded,
+				version: stored.version,
+				timestamp: stored.timestamp
+			});
+		}),
+		appendEvent: Effect.fn("effect-machine.persistence.inMemory.appendEvent")(function* (id, event, schema) {
+			yield* getOrCreateStorage(id);
+			const encoded = yield* Schema.encode(schema)(event.event).pipe(Effect.mapError((cause) => new PersistenceError({
+				operation: "appendEvent",
+				actorId: id,
+				cause,
+				message: "Failed to encode event"
+			})));
+			yield* updateStorage(id, (s) => ({
+				...s,
+				events: [...s.events, {
+					data: encoded,
+					version: event.version,
+					timestamp: event.timestamp
+				}]
+			}));
+		}),
+		loadEvents: Effect.fn("effect-machine.persistence.inMemory.loadEvents")(function* (id, schema, afterVersion) {
+			const actorStorage = yield* getOrCreateStorage(id);
+			const decoded = [];
+			for (const stored of actorStorage.events) {
+				if (afterVersion !== void 0 && stored.version <= afterVersion) continue;
+				const event = yield* Schema.decode(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
+					operation: "loadEvents",
+					actorId: id,
+					cause,
+					message: "Failed to decode event"
+				})));
+				decoded.push({
+					event,
+					version: stored.version,
+					timestamp: stored.timestamp
+				});
+			}
+			return decoded;
+		}),
+		deleteActor: Effect.fn("effect-machine.persistence.inMemory.deleteActor")(function* (id) {
+			yield* Ref.update(storage, (map) => {
+				const newMap = new Map(map);
+				newMap.delete(id);
+				return newMap;
+			});
+			yield* Ref.update(registry, (map) => {
+				const newMap = new Map(map);
+				newMap.delete(id);
+				return newMap;
+			});
+		}),
+		listActors: Effect.fn("effect-machine.persistence.inMemory.listActors")(function* () {
+			const map = yield* Ref.get(registry);
+			return Array.from(map.values());
+		}),
+		saveMetadata: Effect.fn("effect-machine.persistence.inMemory.saveMetadata")(function* (metadata) {
+			yield* Ref.update(registry, (map) => {
+				const newMap = new Map(map);
+				newMap.set(metadata.id, metadata);
+				return newMap;
+			});
+		}),
+		deleteMetadata: Effect.fn("effect-machine.persistence.inMemory.deleteMetadata")(function* (id) {
+			yield* Ref.update(registry, (map) => {
+				const newMap = new Map(map);
+				newMap.delete(id);
+				return newMap;
+			});
+		}),
+		loadMetadata: Effect.fn("effect-machine.persistence.inMemory.loadMetadata")(function* (id) {
+			const meta = (yield* Ref.get(registry)).get(id);
+			return meta !== void 0 ? Option.some(meta) : Option.none();
+		})
+	};
+}).pipe(Effect.withSpan("effect-machine.persistence.inMemory.make"));
+/**
+* Create an in-memory persistence adapter effect.
+* Returns the adapter directly for custom layer composition.
+*/
+const makeInMemoryPersistenceAdapter = make;
+/**
+* In-memory persistence adapter layer.
+* Data is not persisted across process restarts.
+*
+* NOTE: Each `Effect.provide(InMemoryPersistenceAdapter)` creates a NEW adapter
+* with empty storage. For tests that need persistent storage across multiple
+* runPromise calls, use `makeInMemoryPersistenceAdapter` with a shared scope.
+*
+* @example
+* ```ts
+* const program = Effect.gen(function* () {
+*   const system = yield* ActorSystemService;
+*   const actor = yield* system.spawn("my-actor", persistentMachine);
+*   // ...
+* }).pipe(
+*   Effect.provide(InMemoryPersistenceAdapter),
+*   Effect.provide(ActorSystemDefault),
+* );
+* ```
+*/
+const InMemoryPersistenceAdapter = Layer.effect(PersistenceAdapterTag, make);
+
+//#endregion
+export { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter };

package/dist-v3/persistence/index.d.ts

@@ -0,0 +1,5 @@
+import { PersistenceConfig, PersistentMachine, isPersistentMachine, persist } from "./persistent-machine.js";
+import { PersistentActorRef, createPersistentActor, restorePersistentActor } from "./persistent-actor.js";
+import { ActorMetadata, PersistedEvent, PersistenceAdapter, PersistenceAdapterTag, PersistenceError, RestoreFailure, RestoreResult, Snapshot, VersionConflictError } from "./adapter.js";
+import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./adapters/in-memory.js";
+export { type ActorMetadata, InMemoryPersistenceAdapter, type PersistedEvent, type PersistenceAdapter, PersistenceAdapterTag, type PersistenceConfig, PersistenceError, type PersistentActorRef, type PersistentMachine, type RestoreFailure, type RestoreResult, type Snapshot, VersionConflictError, createPersistentActor, isPersistentMachine, makeInMemoryPersistenceAdapter, persist, restorePersistentActor };

package/dist-v3/persistence/index.js

@@ -0,0 +1,6 @@
+import { isPersistentMachine, persist } from "./persistent-machine.js";
+import { PersistenceAdapterTag, PersistenceError, VersionConflictError } from "./adapter.js";
+import { createPersistentActor, restorePersistentActor } from "./persistent-actor.js";
+import { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter } from "./adapters/in-memory.js";
+
+export { InMemoryPersistenceAdapter, PersistenceAdapterTag, PersistenceError, VersionConflictError, createPersistentActor, isPersistentMachine, makeInMemoryPersistenceAdapter, persist, restorePersistentActor };