effect-machine 0.17.1 → 0.18.0

package/v3/dist/actor.js

@@ -1,577 +0,0 @@
-import { ActorStoppedError, DuplicateActorError } from "./errors.js";
-import { processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
-import { emitWithTimestamp } from "./internal/inspection.js";
-import { Inspector } from "./inspection.js";
-import { materializeMachine } from "./machine.js";
-import { createRuntime } from "./internal/runtime.js";
-import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schedule, Scope, Stream, SubscriptionRef } from "effect";
-//#region src/actor.ts
-/**
-* Actor system: spawning, lifecycle, and event processing.
-*
-* Combines:
-* - ActorRef interface (running actor handle)
-* - ActorSystem service (spawn/stop/get actors)
-* - Actor creation and event loop
-*/
-/**
-* ActorSystem service tag
-*/
-const ActorSystem = Context.GenericTag("@effect/machine/ActorSystem");
-/**
-* Explicit scope for actor lifecycle management.
-*
-* When present in context, actors attach cleanup finalizers to this scope.
-* This replaces ambient `Scope.Scope` detection which caused bugs where
-* unrelated scopes would tear down actors unexpectedly.
-*
-* Provide via `Machine.scoped` or `Effect.provideService(ActorScope, scope)`.
-*/
-const ActorScope = Context.GenericTag("@effect/machine/ActorScope");
-/**
-* Notify all listeners of state change.
-*/
-const notifyListeners = (listeners, state) => {
-	for (const listener of listeners) try {
-		listener(state);
-	} catch {}
-};
-/**
-* Build core ActorRef methods.
-*/
-const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, start, system, childrenMap, pendingReplies, transitionsPubSub, exitDeferred) => {
-	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
-		if (yield* Ref.get(stoppedRef)) return;
-		const q = yield* Ref.get(eventQueueRef);
-		yield* Queue.offer(q, {
-			_tag: "send",
-			event
-		});
-	});
-	const call = Effect.fn("effect-machine.actor.call")(function* (event) {
-		if (yield* Ref.get(stoppedRef)) {
-			yield* Effect.logWarning("effect-machine.actor.call.stopped").pipe(Effect.annotateLogs({
-				actorId: id,
-				eventTag: event._tag
-			}));
-			const currentState = yield* SubscriptionRef.get(stateRef);
-			return {
-				newState: currentState,
-				previousState: currentState,
-				transitioned: false,
-				hasReply: false,
-				deferReply: false,
-				reply: void 0,
-				postponed: false,
-				lifecycleRan: false,
-				isFinal: machine.finalStates.has(currentState._tag)
-			};
-		}
-		const reply = yield* Deferred.make();
-		pendingReplies.add(reply);
-		const q = yield* Ref.get(eventQueueRef);
-		yield* Queue.offer(q, {
-			_tag: "call",
-			event,
-			reply
-		});
-		return yield* Deferred.await(reply).pipe(Effect.ensuring(Effect.sync(() => pendingReplies.delete(reply))), Effect.catchTag("ActorStoppedError", () => SubscriptionRef.get(stateRef).pipe(Effect.map((currentState) => ({
-			newState: currentState,
-			previousState: currentState,
-			transitioned: false,
-			hasReply: false,
-			deferReply: false,
-			reply: void 0,
-			postponed: false,
-			lifecycleRan: false,
-			isFinal: machine.finalStates.has(currentState._tag)
-		})))));
-	});
-	const ask = Effect.fn("effect-machine.actor.ask")(function* (event) {
-		if (yield* Ref.get(stoppedRef)) return yield* new ActorStoppedError({ actorId: id });
-		const reply = yield* Deferred.make();
-		pendingReplies.add(reply);
-		const q = yield* Ref.get(eventQueueRef);
-		yield* Queue.offer(q, {
-			_tag: "ask",
-			event,
-			reply
-		});
-		return yield* Deferred.await(reply).pipe(Effect.ensuring(Effect.sync(() => pendingReplies.delete(reply))));
-	});
-	const snapshot = SubscriptionRef.get(stateRef).pipe(Effect.withSpan("effect-machine.actor.snapshot"));
-	const matches = Effect.fn("effect-machine.actor.matches")(function* (tag) {
-		return (yield* SubscriptionRef.get(stateRef))._tag === tag;
-	});
-	const can = Effect.fn("effect-machine.actor.can")(function* (event) {
-		return resolveTransition(machine, yield* SubscriptionRef.get(stateRef), event) !== void 0;
-	});
-	const waitFor = Effect.fn("effect-machine.actor.waitFor")(function* (predicateOrState) {
-		const predicate = typeof predicateOrState === "function" && !("_tag" in predicateOrState) ? predicateOrState : (s) => s._tag === predicateOrState._tag;
-		const current = yield* SubscriptionRef.get(stateRef);
-		if (predicate(current)) return current;
-		const done = yield* Deferred.make();
-		const listener = (state) => {
-			if (predicate(state)) Effect.runFork(Deferred.succeed(done, state));
-		};
-		listeners.add(listener);
-		const afterSubscribe = yield* SubscriptionRef.get(stateRef);
-		if (predicate(afterSubscribe)) {
-			listeners.delete(listener);
-			return afterSubscribe;
-		}
-		const result = yield* Deferred.await(done);
-		listeners.delete(listener);
-		return result;
-	});
-	const awaitFinal = waitFor((state) => machine.finalStates.has(state._tag)).pipe(Effect.withSpan("effect-machine.actor.awaitFinal"));
-	const sendAndWait = Effect.fn("effect-machine.actor.sendAndWait")(function* (event, predicateOrState) {
-		yield* send(event);
-		if (predicateOrState !== void 0) return yield* waitFor(predicateOrState);
-		return yield* awaitFinal;
-	});
-	return {
-		id,
-		send,
-		cast: send,
-		call,
-		ask,
-		state: stateRef,
-		stop,
-		start,
-		snapshot,
-		matches,
-		can,
-		changes: stateRef.changes,
-		transitions: transitionsPubSub !== void 0 ? Stream.fromPubSub(transitionsPubSub) : Stream.empty,
-		waitFor,
-		awaitFinal,
-		sendAndWait,
-		subscribe: (fn) => {
-			listeners.add(fn);
-			return () => {
-				listeners.delete(fn);
-			};
-		},
-		awaitExit: Deferred.await(exitDeferred),
-		watch: (other) => other.awaitExit,
-		drain: Effect.gen(function* () {
-			if (yield* Ref.get(stoppedRef)) return;
-			const q = yield* Ref.get(eventQueueRef);
-			const done = yield* Deferred.make();
-			yield* Queue.offer(q, {
-				_tag: "drain",
-				done
-			});
-			yield* Deferred.await(done);
-		}).pipe(Effect.asVoid),
-		sync: {
-			send: (event) => {
-				if (!Effect.runSync(Ref.get(stoppedRef))) {
-					const q = Effect.runSync(Ref.get(eventQueueRef));
-					Effect.runSync(Queue.offer(q, {
-						_tag: "send",
-						event
-					}));
-				}
-			},
-			stop: () => Effect.runFork(stop),
-			snapshot: () => Effect.runSync(SubscriptionRef.get(stateRef)),
-			matches: (tag) => Effect.runSync(SubscriptionRef.get(stateRef))._tag === tag,
-			can: (event) => {
-				return resolveTransition(machine, Effect.runSync(SubscriptionRef.get(stateRef)), event) !== void 0;
-			}
-		},
-		system,
-		children: childrenMap
-	};
-};
-/** Build ProcessEventHooks from an inspector */
-const buildInspectionHooks = (actorId, inspector) => ({
-	onSpawnEffect: (state) => emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.effect",
-		actorId,
-		effectType: "spawn",
-		state,
-		timestamp
-	})),
-	onTransition: (from, to, ev) => emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.transition",
-		actorId,
-		fromState: from,
-		toState: to,
-		event: ev,
-		timestamp
-	})),
-	onError: (info) => emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.error",
-		actorId,
-		phase: info.phase,
-		state: info.state,
-		event: info.event,
-		error: Cause.pretty(info.cause),
-		timestamp
-	}))
-});
-/**
-* Resolve actor system from context, creating an implicit one if none exists.
-* @internal
-*/
-const resolveActorSystem = Effect.fn("effect-machine.resolveActorSystem")(function* () {
-	const existingSystem = yield* Effect.serviceOption(ActorSystem);
-	if (Option.isSome(existingSystem)) return {
-		system: existingSystem.value,
-		implicitSystemScope: void 0
-	};
-	const scope = yield* Scope.make();
-	return {
-		system: yield* make().pipe(Effect.provideService(Scope.Scope, scope)),
-		implicitSystemScope: scope
-	};
-});
-/**
-* Run the supervision loop for a supervised actor.
-* Observes exit deferred, applies restart policy, resets cell resources on restart.
-* @internal
-*/
-const runSupervisionLoop = (params) => Effect.gen(function* () {
-	const driver = yield* Schedule.driver(params.supervision.schedule);
-	let generation = 0;
-	while (true) {
-		const currentRuntime = params.runtimeRef.current;
-		if (currentRuntime === void 0) return;
-		const generationExit = yield* Deferred.await(currentRuntime.exitDeferred);
-		if (generationExit._tag !== "Defect") {
-			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
-			return;
-		}
-		if (params.supervision.shouldRestart !== void 0 && !params.supervision.shouldRestart(generationExit)) {
-			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
-			return;
-		}
-		if ((yield* driver.next(generationExit).pipe(Effect.exit))._tag === "Failure") {
-			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
-			return;
-		}
-		let restartState = params.machine.initial;
-		if (params.lifecycle?.recovery !== void 0) {
-			const resolved = yield* params.lifecycle.recovery.resolve({
-				actorId: params.id,
-				generation: generation + 1,
-				machineInitial: params.machine.initial
-			});
-			if (Option.isSome(resolved)) restartState = resolved.value;
-		}
-		yield* settlePendingReplies(params.pendingReplies, params.id);
-		const freshQueue = yield* Queue.unbounded();
-		yield* Ref.set(params.eventQueueRef, freshQueue);
-		yield* SubscriptionRef.set(params.stateRef, restartState);
-		yield* Ref.set(params.stoppedRef, false);
-		params.childrenMap.clear();
-		const machineForRestart = restartState !== params.machine.initial ? Object.create(params.machine, { initial: {
-			value: restartState,
-			enumerable: true
-		} }) : params.machine;
-		const newRuntime = yield* params.spawnGeneration(machineForRestart);
-		params.runtimeRef.current = newRuntime;
-		yield* newRuntime.start;
-		generation++;
-		if (params.onRestart !== void 0) yield* params.onRestart(generation, generationExit);
-		notifyListeners(params.listeners, restartState);
-	}
-});
-/**
-* Create and start an actor for a machine.
-* Delegates to the shared runtime kernel with actor-specific lifecycle hooks.
-*/
-const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine, options) {
-	const lifecycle = options?.lifecycle;
-	const initial = options?.initialState ?? machine.initial;
-	yield* Effect.annotateCurrentSpan("effect_machine.actor.id", id);
-	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", initial._tag);
-	const { system, implicitSystemScope } = yield* resolveActorSystem();
-	const inspectorValue = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
-	const childrenMap = /* @__PURE__ */ new Map();
-	const pendingReplies = /* @__PURE__ */ new Set();
-	const listeners = /* @__PURE__ */ new Set();
-	const transitionsPubSub = yield* PubSub.unbounded();
-	const hooks = inspectorValue !== void 0 ? buildInspectionHooks(id, inspectorValue) : void 0;
-	const machineWithState = initial !== machine.initial ? Object.create(machine, { initial: {
-		value: initial,
-		enumerable: true
-	} }) : machine;
-	const stateRef = yield* SubscriptionRef.make(initial);
-	const stoppedRef = yield* Ref.make(false);
-	const initialQueue = yield* Queue.unbounded();
-	const eventQueueRef = yield* Ref.make(initialQueue);
-	const terminalExitDeferred = yield* Deferred.make();
-	let stopEmitted = false;
-	let generation = 0;
-	const runtimeRef = { current: void 0 };
-	/** Build lifecycle hooks for a generation */
-	const buildLifecycle = () => {
-		stopEmitted = false;
-		return {
-			onEvent: inspectorValue !== void 0 ? (state, event) => emitWithTimestamp(inspectorValue, (timestamp) => ({
-				type: "@machine.event",
-				actorId: id,
-				state,
-				event,
-				timestamp
-			})) : void 0,
-			onStateChange: (result, event) => Effect.gen(function* () {
-				notifyListeners(listeners, result.newState);
-				if (lifecycle?.durability !== void 0 && result.transitioned) {
-					const durability = lifecycle.durability;
-					if (durability.shouldSave === void 0 || durability.shouldSave(result.newState, result.previousState)) yield* durability.save({
-						actorId: id,
-						generation,
-						previousState: result.previousState,
-						nextState: result.newState,
-						event
-					});
-				}
-				yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", true);
-				if (result.lifecycleRan) {
-					yield* Effect.annotateCurrentSpan("effect_machine.state.from", result.previousState._tag);
-					yield* Effect.annotateCurrentSpan("effect_machine.state.to", result.newState._tag);
-				}
-			}),
-			onProcessed: (result, event) => result.transitioned ? PubSub.publish(transitionsPubSub, {
-				fromState: result.previousState,
-				toState: result.newState,
-				event
-			}).pipe(Effect.asVoid) : Effect.void,
-			onFinal: inspectorValue !== void 0 ? (state) => Effect.gen(function* () {
-				stopEmitted = true;
-				yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
-					type: "@machine.stop",
-					actorId: id,
-					finalState: state,
-					timestamp
-				}));
-			}) : void 0,
-			onShutdown: () => Effect.gen(function* () {
-				if (!stopEmitted) {
-					const finalState = yield* SubscriptionRef.get(stateRef);
-					yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
-						type: "@machine.stop",
-						actorId: id,
-						finalState,
-						timestamp
-					}));
-				}
-				yield* settlePendingReplies(pendingReplies, id);
-			}),
-			onInitialSpawnEffects: inspectorValue !== void 0 ? (state) => emitWithTimestamp(inspectorValue, (timestamp) => ({
-				type: "@machine.effect",
-				actorId: id,
-				effectType: "spawn",
-				state,
-				timestamp
-			})) : void 0
-		};
-	};
-	/** Create a single runtime generation. machineForGen is machineWithState for initial, machine for restarts. */
-	const spawnGeneration = (machineForGen) => Ref.get(eventQueueRef).pipe(Effect.flatMap((currentQueue) => createRuntime(machineForGen, system, {
-		actorId: id,
-		hooks,
-		skipFinalizer: true,
-		cellResources: {
-			stateRef,
-			stoppedRef,
-			eventQueue: currentQueue
-		},
-		lifecycle: buildLifecycle(),
-		wrapProcess: (state, event, inner) => Effect.withSpan("effect-machine.event.process", { attributes: {
-			"effect_machine.actor.id": id,
-			"effect_machine.state.current": state._tag,
-			"effect_machine.event.type": event._tag
-		} })(inner.pipe(Effect.tap((r) => Effect.annotateCurrentSpan("effect_machine.transition.matched", r.result.transitioned)))),
-		onChildSpawned: (childId, child) => Effect.gen(function* () {
-			childrenMap.set(childId, child);
-			const maybeScope = yield* Effect.serviceOption(Scope.Scope);
-			if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.sync(() => {
-				childrenMap.delete(childId);
-			}));
-		})
-	})));
-	runtimeRef.current = yield* spawnGeneration(machineWithState);
-	const supervision = options?.supervision;
-	const supervisorFiberRef = { current: void 0 };
-	const stop = Effect.gen(function* () {
-		if (supervisorFiberRef.current !== void 0) yield* Fiber.interrupt(supervisorFiberRef.current);
-		const currentRuntime = runtimeRef.current;
-		if (currentRuntime !== void 0) yield* currentRuntime.stop;
-		yield* Deferred.succeed(terminalExitDeferred, { _tag: "Stopped" });
-		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid);
-	const isHydrated = options?.initialState !== void 0;
-	return buildActorRefCore(id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, Effect.gen(function* () {
-		if (lifecycle?.recovery !== void 0 && !isHydrated) {
-			const resolved = yield* lifecycle.recovery.resolve({
-				actorId: id,
-				generation,
-				machineInitial: machine.initial
-			});
-			if (Option.isSome(resolved)) {
-				yield* SubscriptionRef.set(stateRef, resolved.value);
-				runtimeRef.current = yield* spawnGeneration(Object.create(machine, { initial: {
-					value: resolved.value,
-					enumerable: true
-				} }));
-			}
-		}
-		const currentState = yield* SubscriptionRef.get(stateRef);
-		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
-			type: "@machine.spawn",
-			actorId: id,
-			initialState: currentState,
-			timestamp
-		}));
-		if (supervision !== void 0) supervisorFiberRef.current = yield* Effect.forkDaemon(runSupervisionLoop({
-			supervision,
-			machine,
-			id,
-			runtimeRef,
-			terminalExitDeferred,
-			pendingReplies,
-			eventQueueRef,
-			stateRef,
-			stoppedRef,
-			childrenMap,
-			listeners,
-			spawnGeneration,
-			lifecycle,
-			onRestart: options?.onRestart
-		}));
-		else {
-			const currentRuntime = runtimeRef.current;
-			if (currentRuntime !== void 0) yield* Effect.forkDaemon(Deferred.await(currentRuntime.exitDeferred).pipe(Effect.tap((exit) => Deferred.succeed(terminalExitDeferred, exit))));
-		}
-		const currentRuntime = runtimeRef.current;
-		if (currentRuntime !== void 0) yield* currentRuntime.start;
-	}).pipe(Effect.withSpan("effect-machine.actor.start"), Effect.asVoid), system, childrenMap, pendingReplies, transitionsPubSub, terminalExitDeferred);
-});
-/** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */
-const settlePendingReplies = (pendingReplies, actorId) => Effect.sync(() => {
-	const error = new ActorStoppedError({ actorId });
-	for (const deferred of pendingReplies) Effect.runFork(Deferred.fail(deferred, error));
-	pendingReplies.clear();
-});
-/** Notify all system event listeners (sync). */
-const notifySystemListeners = (listeners, event) => {
-	for (const listener of listeners) try {
-		listener(event);
-	} catch {}
-};
-const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
-	const actorsMap = MutableHashMap.empty();
-	const withSpawnGate = (yield* Effect.makeSemaphore(1)).withPermits(1);
-	const eventPubSub = yield* PubSub.unbounded();
-	const eventListeners = /* @__PURE__ */ new Set();
-	const emitSystemEvent = (event) => Effect.sync(() => notifySystemListeners(eventListeners, event)).pipe(Effect.andThen(PubSub.publish(eventPubSub, event)), Effect.catchAllCause(() => Effect.void), Effect.asVoid);
-	yield* Effect.addFinalizer(() => {
-		const stops = [];
-		MutableHashMap.forEach(actorsMap, (actor) => {
-			stops.push(actor.stop);
-		});
-		return Effect.all(stops, { concurrency: "unbounded" }).pipe(Effect.andThen(PubSub.shutdown(eventPubSub)), Effect.asVoid);
-	});
-	/** Check for duplicate ID, register actor, attach scope cleanup if available */
-	const registerActor = Effect.fn("effect-machine.actorSystem.register")(function* (id, actor) {
-		if (MutableHashMap.has(actorsMap, id)) {
-			yield* actor.stop;
-			return yield* new DuplicateActorError({ actorId: id });
-		}
-		const actorRef = actor;
-		MutableHashMap.set(actorsMap, id, actorRef);
-		yield* emitSystemEvent({
-			_tag: "ActorSpawned",
-			id,
-			actor: actorRef
-		});
-		const maybeScope = yield* Effect.serviceOption(ActorScope);
-		if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.gen(function* () {
-			if (MutableHashMap.has(actorsMap, id)) {
-				yield* emitSystemEvent({
-					_tag: "ActorStopped",
-					id,
-					actor: actorRef,
-					exit: { _tag: "Stopped" }
-				});
-				MutableHashMap.remove(actorsMap, id);
-			}
-			yield* actor.stop;
-		}));
-		return actor;
-	});
-	const spawnRegular = Effect.fn("effect-machine.actorSystem.spawnRegular")(function* (id, machine, spawnOptions) {
-		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
-		const materialized = spawnOptions?.slots !== void 0 ? materializeMachine(machine, spawnOptions.slots) : machine;
-		let actorRef;
-		const actor = yield* createActor(id, materialized, {
-			supervision: spawnOptions?.supervision,
-			lifecycle: spawnOptions?.lifecycle,
-			onRestart: spawnOptions?.supervision !== void 0 ? (generation, exit) => actorRef !== void 0 ? emitSystemEvent({
-				_tag: "ActorRestarted",
-				id,
-				actor: actorRef,
-				generation,
-				exit
-			}) : Effect.void : void 0
-		});
-		actorRef = actor;
-		yield* registerActor(id, actor);
-		yield* actor.start.pipe(Effect.catchAllCause((cause) => actor.stop.pipe(Effect.andThen(Effect.failCause(cause)))));
-		return actor;
-	});
-	const spawn = (id, machine, options) => withSpawnGate(spawnRegular(id, machine, options));
-	const get = Effect.fn("effect-machine.actorSystem.get")(function* (id) {
-		return yield* Effect.sync(() => MutableHashMap.get(actorsMap, id));
-	});
-	const stop = Effect.fn("effect-machine.actorSystem.stop")(function* (id) {
-		const maybeActor = MutableHashMap.get(actorsMap, id);
-		if (Option.isNone(maybeActor)) return false;
-		const actor = maybeActor.value;
-		MutableHashMap.remove(actorsMap, id);
-		yield* emitSystemEvent({
-			_tag: "ActorStopped",
-			id,
-			actor,
-			exit: { _tag: "Stopped" }
-		});
-		yield* actor.stop;
-		return true;
-	});
-	return ActorSystem.of({
-		spawn,
-		get,
-		stop,
-		events: Stream.fromPubSub(eventPubSub),
-		get actors() {
-			const snapshot = /* @__PURE__ */ new Map();
-			MutableHashMap.forEach(actorsMap, (actor, id) => {
-				snapshot.set(id, actor);
-			});
-			return snapshot;
-		},
-		subscribe: (fn) => {
-			eventListeners.add(fn);
-			return () => {
-				eventListeners.delete(fn);
-			};
-		}
-	});
-});
-/**
-* Create an ActorSystem instance. Must be run in a Scope.
-* @internal — use Default layer for normal usage
-*/
-const makeSystem = make;
-/**
-* Default ActorSystem layer
-*/
-const Default = Layer.scoped(ActorSystem, make());
-//#endregion
-export { ActorScope, ActorSystem, Default, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

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

@@ -1,15 +0,0 @@
-import { PersistedEvent, PersistenceAdapter, Snapshot } from "../persistence.js";
-import { Effect, Layer, Ref } from "effect";
-
-//#region src/cluster/adapters/in-memory.d.ts
-interface EntityStore {
-  snapshot: Snapshot<unknown> | undefined;
-  events: Array<PersistedEvent<unknown>>;
-}
-declare const makeInMemoryPersistenceAdapter: Effect.Effect<{
-  adapter: PersistenceAdapter;
-  storeRef: Ref.Ref<Map<string, EntityStore>>;
-  layer: Layer.Layer<PersistenceAdapter, never, never>;
-}, never, never>;
-//#endregion
-export { makeInMemoryPersistenceAdapter };

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

@@ -1,62 +0,0 @@
-import { VersionConflictError } from "../../errors.js";
-import { PersistenceAdapter } from "../persistence.js";
-import { Effect, Layer, Option, Ref } from "effect";
-//#region src/cluster/adapters/in-memory.ts
-/**
-* In-memory persistence adapter for testing and development (v3).
-*
-* @module
-*/
-const makeKey = (key) => `${key.entityType}/${key.entityId}`;
-const getOrCreate = (store, key) => {
-	let entry = store.get(key);
-	if (entry === void 0) {
-		entry = {
-			snapshot: void 0,
-			events: []
-		};
-		store.set(key, entry);
-	}
-	return entry;
-};
-const makeInMemoryPersistenceAdapter = Effect.gen(function* () {
-	const store = /* @__PURE__ */ new Map();
-	const storeRef = yield* Ref.make(store);
-	const adapter = {
-		saveSnapshot: (key, snapshot) => Effect.gen(function* () {
-			const entry = getOrCreate(yield* Ref.get(storeRef), makeKey(key));
-			if (entry.snapshot !== void 0 && snapshot.version < entry.snapshot.version) return yield* new VersionConflictError({
-				expected: snapshot.version,
-				actual: entry.snapshot.version
-			});
-			entry.snapshot = snapshot;
-		}),
-		loadSnapshot: (key) => Effect.gen(function* () {
-			const entry = (yield* Ref.get(storeRef)).get(makeKey(key));
-			return Option.fromNullable(entry?.snapshot);
-		}),
-		appendEvents: (key, events, expectedVersion) => Effect.gen(function* () {
-			const entry = getOrCreate(yield* Ref.get(storeRef), makeKey(key));
-			const lastEvent = entry.events[entry.events.length - 1];
-			const currentVersion = lastEvent !== void 0 ? lastEvent.version : 0;
-			if (currentVersion !== expectedVersion) return yield* new VersionConflictError({
-				expected: expectedVersion,
-				actual: currentVersion
-			});
-			for (const event of events) entry.events.push(event);
-		}),
-		loadEvents: (key, afterVersion) => Effect.gen(function* () {
-			const entry = (yield* Ref.get(storeRef)).get(makeKey(key));
-			if (entry === void 0) return [];
-			if (afterVersion === void 0) return entry.events;
-			return entry.events.filter((e) => e.version > afterVersion);
-		})
-	};
-	return {
-		adapter,
-		storeRef,
-		layer: Layer.succeed(PersistenceAdapter, adapter)
-	};
-});
-//#endregion
-export { makeInMemoryPersistenceAdapter };

package/v3/dist/cluster/entity-actor-ref.d.ts

@@ -1,49 +0,0 @@
-import { ExtractReply, ReplyTypeBrand } from "../internal/brands.js";
-import { NoReplyError } from "../errors.js";
-import { Effect } from "effect";
-import { RpcClient } from "effect/unstable/rpc";
-
-//#region src/cluster/entity-actor-ref.d.ts
-/**
- * Typed client wrapper for remote entity machines.
- *
- * Unlike local `ActorRef`, this communicates over cluster RPCs.
- * Only operations that make sense over the network are exposed.
- *
- * @example
- * ```ts
- * const ref = yield* EntityActorRef.make(OrderEntity, OrderEntityLayer, "order-123")
- * yield* ref.send(OrderEvent.Ship({ trackingId: "abc" }))
- * const state = yield* ref.snapshot
- * ```
- */
-interface EntityActorRef<State extends {
-  readonly _tag: string;
-}, Event extends {
-  readonly _tag: string;
-}> {
-  readonly entityId: string;
-  /** Send event (fire-and-forget). Returns new state after processing. */
-  readonly send: (event: Event) => Effect.Effect<State>;
-  /** Send event and get typed domain reply (via Event.reply() schema). */
-  readonly ask: <E extends Event & ReplyTypeBrand<unknown>>(event: E) => Effect.Effect<ExtractReply<E>, NoReplyError>;
-  /** Get current state. */
-  readonly snapshot: Effect.Effect<State>;
-}
-/**
- * Create an EntityActorRef from a test client factory and entity ID.
- *
- * @example
- * ```ts
- * const makeClient = yield* Entity.makeTestClient(entity, entityLayer)
- * const ref = yield* makeEntityActorRef(makeClient, "order-123")
- * yield* ref.send(OrderEvent.Process)
- * ```
- */
-declare const makeEntityActorRef: <State extends {
-  readonly _tag: string;
-}, Event extends {
-  readonly _tag: string;
-}>(client: RpcClient.RpcClient<any>, entityId: string) => EntityActorRef<State, Event>;
-//#endregion
-export { EntityActorRef, makeEntityActorRef };