effect-machine 0.9.0 → 0.11.0

package/dist-v3/actor.d.ts

@@ -1,291 +0,0 @@
-import { PersistentMachine } from "./persistence/persistent-machine.js";
-import { DuplicateActorError } from "./errors.js";
-import { EffectsDef, GuardsDef } from "./slot.js";
-import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
-import { PersistentActorRef } from "./persistence/persistent-actor.js";
-import { ActorMetadata, PersistenceAdapterTag, PersistenceError, RestoreResult, VersionConflictError } from "./persistence/adapter.js";
-import { BuiltMachine, Machine } from "./machine.js";
-import { Effect, Option, Queue, Ref, Stream, SubscriptionRef } from "effect";
-
-//#region src-v3/actor.d.ts
-/**
- * Reference to a running actor.
- */
-interface ActorRef<State extends {
-  readonly _tag: string;
-}, Event> {
-  /**
-   * Unique identifier for this actor
-   */
-  readonly id: string;
-  /**
-   * Send an event to the actor
-   */
-  readonly send: (event: Event) => Effect.Effect<void>;
-  /**
-   * Observable state of the actor
-   */
-  readonly state: SubscriptionRef.SubscriptionRef<State>;
-  /**
-   * Stop the actor gracefully
-   */
-  readonly stop: Effect.Effect<void>;
-  /**
-   * Stop the actor (fire-and-forget).
-   * Signals graceful shutdown without waiting for completion.
-   * Use when stopping from sync contexts (e.g. framework cleanup hooks).
-   */
-  readonly stopSync: () => void;
-  /**
-   * Get current state snapshot (Effect)
-   */
-  readonly snapshot: Effect.Effect<State>;
-  /**
-   * Get current state snapshot (sync)
-   */
-  readonly snapshotSync: () => State;
-  /**
-   * Check if current state matches tag (Effect)
-   */
-  readonly matches: (tag: State["_tag"]) => Effect.Effect<boolean>;
-  /**
-   * Check if current state matches tag (sync)
-   */
-  readonly matchesSync: (tag: State["_tag"]) => boolean;
-  /**
-   * Check if event can be handled in current state (Effect)
-   */
-  readonly can: (event: Event) => Effect.Effect<boolean>;
-  /**
-   * Check if event can be handled in current state (sync)
-   */
-  readonly canSync: (event: Event) => boolean;
-  /**
-   * Stream of state changes
-   */
-  readonly changes: Stream.Stream<State>;
-  /**
-   * Wait for a state that matches predicate or state variant (includes current snapshot).
-   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
-   */
-  readonly waitFor: {
-    (predicate: (state: State) => boolean): Effect.Effect<State>;
-    (state: {
-      readonly _tag: State["_tag"];
-    }): Effect.Effect<State>;
-  };
-  /**
-   * Wait for a final state (includes current snapshot)
-   */
-  readonly awaitFinal: Effect.Effect<State>;
-  /**
-   * Send event and wait for predicate, state variant, or final state.
-   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
-   */
-  readonly sendAndWait: {
-    (event: Event, predicate: (state: State) => boolean): Effect.Effect<State>;
-    (event: Event, state: {
-      readonly _tag: State["_tag"];
-    }): Effect.Effect<State>;
-    (event: Event): Effect.Effect<State>;
-  };
-  /**
-   * Send event synchronously (fire-and-forget).
-   * No-op on stopped actors. Use when you need to send from sync contexts
-   * (e.g. framework hooks, event handlers).
-   */
-  readonly sendSync: (event: Event) => void;
-  /**
-   * Subscribe to state changes (sync callback)
-   * Returns unsubscribe function
-   */
-  readonly subscribe: (fn: (state: State) => void) => () => void;
-  /**
-   * The actor system this actor belongs to.
-   * Every actor always has a system — either inherited from context or implicitly created.
-   */
-  readonly system: ActorSystem;
-  /**
-   * Child actors spawned via `self.spawn` in this actor's handlers.
-   * State-scoped children are auto-removed on state exit.
-   */
-  readonly children: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
-}
-/** Base type for stored actors (internal) */
-type AnyState = {
-  readonly _tag: string;
-};
-/**
- * Events emitted by the ActorSystem when actors are spawned or stopped.
- */
-type SystemEvent = {
-  readonly _tag: "ActorSpawned";
-  readonly id: string;
-  readonly actor: ActorRef<AnyState, unknown>;
-} | {
-  readonly _tag: "ActorStopped";
-  readonly id: string;
-  readonly actor: ActorRef<AnyState, unknown>;
-};
-/**
- * Listener callback for system events.
- */
-type SystemEventListener = (event: SystemEvent) => void;
-/**
- * Actor system for managing actor lifecycles
- */
-interface ActorSystem {
-  /**
-   * Spawn a new actor with the given machine.
-   *
-   * For regular machines, returns ActorRef.
-   * For persistent machines (created with Machine.persist), returns PersistentActorRef.
-   *
-   * All effect slots must be provided via `.build()` before spawning.
-   *
-   * @example
-   * ```ts
-   * // Regular machine (built)
-   * const built = machine.build({ fetchData: ... })
-   * const actor = yield* system.spawn("my-actor", built);
-   *
-   * // Persistent machine (auto-detected)
-   * const persistentActor = yield* system.spawn("my-actor", persistentMachine);
-   * persistentActor.persist; // available
-   * persistentActor.version; // available
-   * ```
-   */
-  readonly spawn: {
-    <S extends {
-      readonly _tag: string;
-    }, E extends {
-      readonly _tag: string;
-    }, R>(id: string, machine: BuiltMachine<S, E, R>): Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>;
-    <S extends {
-      readonly _tag: string;
-    }, E extends {
-      readonly _tag: string;
-    }, R>(id: string, machine: PersistentMachine<S, E, R>): Effect.Effect<PersistentActorRef<S, E, R>, PersistenceError | VersionConflictError | DuplicateActorError, R | PersistenceAdapterTag>;
-  };
-  /**
-   * Restore an actor from persistence.
-   * Returns None if no persisted state exists for the given ID.
-   *
-   * @example
-   * ```ts
-   * const maybeActor = yield* system.restore("order-1", persistentMachine);
-   * if (Option.isSome(maybeActor)) {
-   *   const actor = maybeActor.value;
-   *   const state = yield* actor.snapshot;
-   *   console.log(`Restored to state: ${state._tag}`);
-   * }
-   * ```
-   */
-  readonly restore: <S extends {
-    readonly _tag: string;
-  }, E extends {
-    readonly _tag: string;
-  }, R>(id: string, machine: PersistentMachine<S, E, R>) => Effect.Effect<Option.Option<PersistentActorRef<S, E, R>>, PersistenceError | DuplicateActorError, R | PersistenceAdapterTag>;
-  /**
-   * Get an existing actor by ID
-   */
-  readonly get: (id: string) => Effect.Effect<Option.Option<ActorRef<AnyState, unknown>>>;
-  /**
-   * Stop an actor by ID
-   */
-  readonly stop: (id: string) => Effect.Effect<boolean>;
-  /**
-   * Async stream of system events (actor spawned/stopped).
-   * Each subscriber gets their own queue — late subscribers miss prior events.
-   */
-  readonly events: Stream.Stream<SystemEvent>;
-  /**
-   * Sync snapshot of all currently registered actors.
-   * Returns a new Map on each access (not live).
-   */
-  readonly actors: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
-  /**
-   * Subscribe to system events synchronously.
-   * Returns an unsubscribe function.
-   */
-  readonly subscribe: (fn: SystemEventListener) => () => void;
-  /**
-   * List all persisted actor metadata.
-   * Returns empty array if adapter doesn't support registry.
-   *
-   * @example
-   * ```ts
-   * const actors = yield* system.listPersisted();
-   * for (const meta of actors) {
-   *   console.log(`${meta.id}: ${meta.stateTag} (v${meta.version})`);
-   * }
-   * ```
-   */
-  readonly listPersisted: () => Effect.Effect<ReadonlyArray<ActorMetadata>, PersistenceError, PersistenceAdapterTag>;
-  /**
-   * Restore multiple actors by ID.
-   * Returns both successfully restored actors and failures.
-   *
-   * @example
-   * ```ts
-   * const result = yield* system.restoreMany(["order-1", "order-2"], orderMachine);
-   * console.log(`Restored: ${result.restored.length}, Failed: ${result.failed.length}`);
-   * ```
-   */
-  readonly restoreMany: <S extends {
-    readonly _tag: string;
-  }, E extends {
-    readonly _tag: string;
-  }, R>(ids: ReadonlyArray<string>, machine: PersistentMachine<S, E, R>) => Effect.Effect<RestoreResult<S, E, R>, never, R | PersistenceAdapterTag>;
-  /**
-   * Restore all persisted actors for a machine type.
-   * Uses adapter registry if available, otherwise returns empty result.
-   *
-   * @example
-   * ```ts
-   * const result = yield* system.restoreAll(orderMachine, {
-   *   filter: (meta) => meta.stateTag !== "Done"
-   * });
-   * console.log(`Restored ${result.restored.length} active orders`);
-   * ```
-   */
-  readonly restoreAll: <S extends {
-    readonly _tag: string;
-  }, E extends {
-    readonly _tag: string;
-  }, R>(machine: PersistentMachine<S, E, R>, options?: {
-    filter?: (meta: ActorMetadata) => boolean;
-  }) => Effect.Effect<RestoreResult<S, E, R>, PersistenceError, R | PersistenceAdapterTag>;
-}
-/**
- * ActorSystem service tag
- */
-declare const ActorSystem: any;
-/** Listener set for sync subscriptions */
-type Listeners<S> = Set<(state: S) => void>;
-/**
- * Notify all listeners of state change.
- */
-declare const notifyListeners: <S>(listeners: Listeners<S>, state: S) => void;
-/**
- * Build core ActorRef methods shared between regular and persistent actors.
- */
-declare const buildActorRefCore: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, any, any, GD, EFD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueue: Queue.Queue<E>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>) => ActorRef<S, E>;
-/**
- * Create and start an actor for a machine
- */
-declare const createActor: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>) => Effect.Effect<ActorRef<S, E>, unknown, unknown>;
-/**
- * Default ActorSystem layer
- */
-declare const Default: any;
-//#endregion
-export { ActorRef, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, SystemEvent, SystemEventListener, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };

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 };

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

@@ -1,125 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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 };