effect-machine 0.17.1 → 0.19.0

package/v3/dist/cluster/entity-actor-ref.js

@@ -1,19 +0,0 @@
-//#region src/cluster/entity-actor-ref.ts
-/**
-* 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)
-* ```
-*/
-const makeEntityActorRef = (client, entityId) => ({
-	entityId,
-	send: (event) => client.Send({ event }),
-	ask: ((event) => client.Ask({ event })),
-	snapshot: client.GetState()
-});
-//#endregion
-export { makeEntityActorRef };

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

@@ -1,74 +0,0 @@
-import { ProcessEventHooks } from "../internal/transition.js";
-import { Machine } from "../machine.js";
-import { EntityPersistenceConfig } from "./persistence.js";
-import { Duration, Layer, Schedule } from "effect";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
-
-//#region src/cluster/entity-machine.d.ts
-/**
- * Options for EntityMachine.layer
- */
-interface EntityMachineOptions<S, E> {
-  /**
-   * Initialize state from entity ID.
-   * Called once when entity is first activated.
-   */
-  readonly initializeState?: (entityId: string) => S;
-  /**
-   * Optional hooks for inspection/tracing.
-   */
-  readonly hooks?: ProcessEventHooks<S, E>;
-  /**
-   * Maximum idle time before entity deactivation.
-   * Forwarded to Entity.toLayer.
-   */
-  readonly maxIdleTime?: Duration.DurationInput;
-  /**
-   * Concurrency for handler execution.
-   * Forwarded to Entity.toLayer.
-   */
-  readonly concurrency?: number | "unbounded";
-  /**
-   * Mailbox capacity. Default: "unbounded".
-   * Forwarded to Entity.toLayer.
-   */
-  readonly mailboxCapacity?: number | "unbounded";
-  /**
-   * Disable fatal defects (defects won't crash the entity activation).
-   * Forwarded to Entity.toLayer.
-   */
-  readonly disableFatalDefects?: boolean;
-  /**
-   * Retry policy for defects (schedule for restarting after defect).
-   * Forwarded to Entity.toLayer.
-   */
-  readonly defectRetryPolicy?: Schedule.Schedule<any>;
-  /**
-   * Persistence configuration. When set, requires PersistenceAdapter in R.
-   */
-  readonly persistence?: EntityPersistenceConfig;
-}
-/**
- * Create an Entity layer that wires a machine to handle RPC calls.
- *
- * v3: Uses `Entity.toLayer` with handler objects backed by the runtime kernel.
- *
- * @example
- * ```ts
- * const OrderEntity = toEntity(orderMachine, { type: "Order" })
- *
- * const OrderEntityLayer = EntityMachine.layer(OrderEntity, orderMachine, {
- *   initializeState: (entityId) => OrderState.Pending({ orderId: entityId }),
- * })
- * ```
- */
-declare const EntityMachine: {
-  layer: <S extends {
-    readonly _tag: string;
-  }, E extends {
-    readonly _tag: string;
-  }, R, EntityType extends string, Rpcs extends Rpc.Any>(entity: Entity.Entity<EntityType, Rpcs>, machine: Machine<S, E, R, any, any, any>, options?: EntityMachineOptions<S, E>) => Layer.Layer<never, never, R>;
-};
-//#endregion
-export { EntityMachine, EntityMachineOptions };

package/v3/dist/cluster/entity-machine.js

@@ -1,166 +0,0 @@
-import { stubSystem } from "../internal/utils.js";
-import { replay } from "../machine.js";
-import { createRuntime } from "../internal/runtime.js";
-import { ActorSystem } from "../actor.js";
-import { PersistenceAdapter } from "./persistence.js";
-import { Clock, Effect, Option, Ref } from "effect";
-import { Entity } from "@effect/cluster";
-//#region src/cluster/entity-machine.ts
-/**
-* EntityMachine adapter - wires a machine to a cluster Entity layer.
-*
-* Uses the runtime kernel for a single serialized event loop per entity.
-* All events (external RPCs + internal self.send) go through the
-* runtime kernel's single queue — no split-mailbox race.
-*
-* v3 uses `entity.toLayer` with handler objects (no `toLayerQueue`/`toLayerMailbox`).
-* Supports opt-in persistence (snapshot or journal strategy).
-*
-* @module
-*/
-/**
-* Create an Entity layer that wires a machine to handle RPC calls.
-*
-* v3: Uses `Entity.toLayer` with handler objects backed by the runtime kernel.
-*
-* @example
-* ```ts
-* const OrderEntity = toEntity(orderMachine, { type: "Order" })
-*
-* const OrderEntityLayer = EntityMachine.layer(OrderEntity, orderMachine, {
-*   initializeState: (entityId) => OrderState.Pending({ orderId: entityId }),
-* })
-* ```
-*/
-const EntityMachine = { layer: (entity, machine, options) => {
-	const persistence = options?.persistence;
-	const build = Effect.gen(function* () {
-		const entityId = yield* Effect.serviceOption(Entity.CurrentAddress).pipe(Effect.map((opt) => opt._tag === "Some" ? opt.value.entityId : ""));
-		const existingSystem = yield* Effect.serviceOption(ActorSystem);
-		const system = Option.isSome(existingSystem) ? existingSystem.value : stubSystem;
-		const persistCtx = yield* hydratePersistence(persistence, entity, entityId, machine, options?.initializeState);
-		const initialState = persistCtx.hydratedState ?? (options?.initializeState !== void 0 ? options.initializeState(entityId) : void 0);
-		const machineWithState = initialState !== void 0 ? Object.create(machine, { initial: {
-			value: initialState,
-			enumerable: true
-		} }) : machine;
-		const versionRef = yield* Ref.make(persistCtx.initialVersion);
-		const runtime = yield* createRuntime(machineWithState, system, {
-			actorId: entityId,
-			hooks: options?.hooks,
-			childIdPrefix: `${entityId}/`
-		});
-		yield* runtime.start;
-		if (persistCtx.adapter !== void 0) {
-			const { adapter: pAdapter, key } = persistCtx;
-			yield* Effect.addFinalizer(() => Effect.gen(function* () {
-				const state = yield* runtime.getState;
-				const version = yield* Ref.get(versionRef);
-				const now = yield* Clock.currentTimeMillis;
-				yield* pAdapter.saveSnapshot(key, {
-					state,
-					version,
-					timestamp: now
-				});
-			}).pipe(Effect.catchAll(() => Effect.void)));
-		}
-		const hasPersistence = persistCtx.adapter !== void 0;
-		const journalCtx = hasPersistence && (persistence?.strategy ?? "snapshot") === "journal" ? {
-			adapter: persistCtx.adapter,
-			key: persistCtx.key
-		} : void 0;
-		return entity.of({
-			Send: (envelope) => Effect.gen(function* () {
-				yield* runtime.sendWait(envelope.payload.event);
-				if (journalCtx !== void 0) yield* persistEvent(journalCtx.adapter, journalCtx.key, versionRef, envelope.payload.event);
-				else if (hasPersistence) yield* Ref.update(versionRef, (v) => v + 1);
-				return yield* runtime.getState;
-			}),
-			Ask: (envelope) => Effect.gen(function* () {
-				const reply = yield* runtime.ask(envelope.payload.event);
-				if (journalCtx !== void 0) yield* persistEvent(journalCtx.adapter, journalCtx.key, versionRef, envelope.payload.event);
-				else if (hasPersistence) yield* Ref.update(versionRef, (v) => v + 1);
-				return reply;
-			}),
-			GetState: () => runtime.getState
-		});
-	});
-	const clusterOptions = {};
-	if (options?.maxIdleTime !== void 0) clusterOptions.maxIdleTime = options.maxIdleTime;
-	if (options?.concurrency !== void 0) clusterOptions.concurrency = options.concurrency;
-	if (options?.mailboxCapacity !== void 0) clusterOptions.mailboxCapacity = options.mailboxCapacity;
-	if (options?.disableFatalDefects !== void 0) clusterOptions.disableFatalDefects = options.disableFatalDefects;
-	if (options?.defectRetryPolicy !== void 0) clusterOptions.defectRetryPolicy = options.defectRetryPolicy;
-	return entity.toLayer(build.pipe(Effect.orDie), Object.keys(clusterOptions).length > 0 ? clusterOptions : void 0);
-} };
-const noPersistence = {
-	adapter: void 0,
-	key: void 0,
-	hydratedState: void 0,
-	initialVersion: 0
-};
-/** Load snapshot/journal and compute hydrated state. */
-const hydratePersistence = (persistence, entityDef, entityId, machine, initializeState) => Effect.gen(function* () {
-	if (persistence === void 0) return noPersistence;
-	const adapter = yield* PersistenceAdapter;
-	const key = {
-		entityType: persistence.machineType ?? entityDef.type,
-		entityId
-	};
-	const maybeSnapshot = yield* adapter.loadSnapshot(key);
-	if ((persistence.strategy ?? "snapshot") === "journal") {
-		const baseState = Option.isSome(maybeSnapshot) ? maybeSnapshot.value.state : initializeState !== void 0 ? initializeState(entityId) : machine.initial;
-		const snapshotVersion = Option.isSome(maybeSnapshot) ? maybeSnapshot.value.version : 0;
-		const events = yield* adapter.loadEvents(key, snapshotVersion);
-		if (events.length > 0) {
-			const hydratedState = yield* replay(machine, events.map((e) => e.event), { from: baseState });
-			const lastEvent = events[events.length - 1];
-			return {
-				adapter,
-				key,
-				hydratedState,
-				initialVersion: lastEvent !== void 0 ? lastEvent.version : snapshotVersion
-			};
-		}
-		return {
-			adapter,
-			key,
-			hydratedState: Option.isSome(maybeSnapshot) ? maybeSnapshot.value.state : void 0,
-			initialVersion: snapshotVersion
-		};
-	}
-	if (Option.isSome(maybeSnapshot)) return {
-		adapter,
-		key,
-		hydratedState: maybeSnapshot.value.state,
-		initialVersion: maybeSnapshot.value.version
-	};
-	return {
-		adapter,
-		key,
-		hydratedState: void 0,
-		initialVersion: 0
-	};
-});
-/**
-* Append a single event to the journal, incrementing version.
-*
-* On failure: defects the entity activation. The cluster's defectRetryPolicy
-* restarts the entity from the last consistent snapshot.
-*/
-const persistEvent = (adapter, key, versionRef, event) => Effect.gen(function* () {
-	const expectedVersion = yield* Ref.get(versionRef);
-	const newVersion = expectedVersion + 1;
-	const persisted = {
-		event,
-		version: newVersion,
-		timestamp: yield* Clock.currentTimeMillis
-	};
-	yield* adapter.appendEvents(key, [persisted], expectedVersion);
-	yield* Ref.set(versionRef, newVersion);
-}).pipe(Effect.tapError((error) => Effect.logWarning("Journal append failed, defecting entity", {
-	key,
-	error
-})), Effect.orDie);
-//#endregion
-export { EntityMachine };

package/v3/dist/cluster/index.d.ts

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

package/v3/dist/cluster/index.js

@@ -1,6 +0,0 @@
-import { PersistenceAdapter } from "./persistence.js";
-import { toEntity } from "./to-entity.js";
-import { EntityMachine } from "./entity-machine.js";
-import { makeEntityActorRef } from "./entity-actor-ref.js";
-import { makeInMemoryPersistenceAdapter } from "./adapters/in-memory.js";
-export { EntityMachine, PersistenceAdapter, makeEntityActorRef, makeInMemoryPersistenceAdapter, toEntity };

package/v3/dist/cluster/persistence.d.ts

@@ -1,48 +0,0 @@
-import { PersistenceError, VersionConflictError } from "../errors.js";
-import { Context, Effect, Option, Schedule } from "effect";
-
-//#region src/cluster/persistence.d.ts
-/** Namespaced key preventing cross-type collisions (e.g. Order/123 vs User/123). */
-interface PersistenceKey {
-  readonly entityType: string;
-  readonly entityId: string;
-}
-/** Stored state snapshot with version and timestamp. */
-interface Snapshot<S> {
-  readonly state: S;
-  readonly version: number;
-  readonly timestamp: number;
-}
-/** Stored event with version and timestamp. */
-interface PersistedEvent<E> {
-  readonly event: E;
-  readonly version: number;
-  readonly timestamp: number;
-}
-/** Persistence configuration for EntityMachineOptions. */
-interface EntityPersistenceConfig {
-  /** Persistence strategy. Default: "snapshot". */
-  readonly strategy?: "snapshot" | "journal";
-  /**
-   * Schedule controlling snapshot frequency.
-   * Default: save on every state change.
-   */
-  readonly snapshotSchedule?: Schedule.Schedule<any, any>;
-  /** Override entityType in the persistence key (defaults to Entity.type). */
-  readonly machineType?: string;
-}
-/** Storage backend for entity state persistence. */
-interface PersistenceAdapter {
-  /** Save a state snapshot. Fails with VersionConflictError if version is stale. */
-  readonly saveSnapshot: (key: PersistenceKey, snapshot: Snapshot<unknown>) => Effect.Effect<void, PersistenceError | VersionConflictError>;
-  /** Load the latest snapshot, or None if no snapshot exists. */
-  readonly loadSnapshot: (key: PersistenceKey) => Effect.Effect<Option.Option<Snapshot<unknown>>, PersistenceError>;
-  /** Append events to the journal. Fails with VersionConflictError if expectedVersion doesn't match. */
-  readonly appendEvents: (key: PersistenceKey, events: ReadonlyArray<PersistedEvent<unknown>>, expectedVersion: number) => Effect.Effect<void, PersistenceError | VersionConflictError>;
-  /** Load events from the journal, optionally after a given version. */
-  readonly loadEvents: (key: PersistenceKey, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<unknown>>, PersistenceError>;
-}
-/** Service tag for PersistenceAdapter — resolve from context for shared infra. */
-declare const PersistenceAdapter: Context.Tag<PersistenceAdapter, PersistenceAdapter>;
-//#endregion
-export { EntityPersistenceConfig, PersistedEvent, PersistenceAdapter, PersistenceKey, Snapshot };

package/v3/dist/cluster/persistence.js

@@ -1,14 +0,0 @@
-import { Context } from "effect";
-//#region src/cluster/persistence.ts
-/**
-* Entity persistence types and adapter interface (v3).
-*
-* Provides snapshot and event journal persistence for entity-machine
-* state across deactivation/reactivation cycles.
-*
-* @module
-*/
-/** Service tag for PersistenceAdapter — resolve from context for shared infra. */
-const PersistenceAdapter = Context.GenericTag("@effect-machine/cluster/PersistenceAdapter");
-//#endregion
-export { PersistenceAdapter };

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

@@ -1,69 +0,0 @@
-import { Machine } from "../machine.js";
-import { Schema } from "effect";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
-
-//#region src/cluster/to-entity.d.ts
-/**
- * Options for toEntity.
- */
-interface ToEntityOptions {
-  /**
-   * Entity type name (e.g., "Order", "User")
-   */
-  readonly type: string;
-}
-/**
- * Default RPC protocol for entity machines.
- *
- * - `Send` - Send event to machine (fire-and-forget), returns new state
- * - `Ask` - Send event and get domain reply (typed via Event.reply() schemas)
- * - `GetState` - Get current state
- */
-type EntityRpcs<StateSchema extends Schema.Schema.Any, EventSchema extends Schema.Schema.Any> = readonly [Rpc.Rpc<"Send", Schema.Struct<{
-  readonly event: EventSchema;
-}>, StateSchema, typeof Schema.Never>, Rpc.Rpc<"Ask", Schema.Struct<{
-  readonly event: EventSchema;
-}>, typeof Schema.Unknown, typeof Schema.Never>, Rpc.Rpc<"GetState", typeof Schema.Void, StateSchema, typeof Schema.Never>];
-/**
- * Generate an Entity definition from a machine.
- *
- * Creates an Entity with a standard RPC protocol:
- * - `Send(event)` - Process event through machine, returns new state
- * - `GetState()` - Returns current state
- *
- * Schemas are read from the machine - must use `Machine.make({ state, event, initial })`.
- *
- * @example
- * ```ts
- * const OrderState = State({
- *   Pending: { orderId: Schema.String },
- *   Shipped: { trackingId: Schema.String },
- * })
- *
- * const OrderEvent = Event({
- *   Ship: { trackingId: Schema.String },
- * })
- *
- * const orderMachine = Machine.make({
- *   state: OrderState,
- *   event: OrderEvent,
- *   initial: OrderState.Pending({ orderId: "" }),
- * }).pipe(
- *   Machine.on(OrderState.Pending, OrderEvent.Ship, ...),
- * )
- *
- * const OrderEntity = toEntity(orderMachine, { type: "Order" })
- * ```
- */
-declare const toEntity: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any>, options: ToEntityOptions) => Entity.Entity<string, Rpc.Rpc<"Send", Schema.Struct<{
-  event: Schema.Schema<E, E, never>;
-}>, Schema.Schema<S, S, never>, typeof Schema.Never, never> | Rpc.Rpc<"Ask", Schema.Struct<{
-  event: Schema.Schema<E, E, never>;
-}>, typeof Schema.Unknown, typeof Schema.Never, never> | Rpc.Rpc<"GetState", typeof Schema.Void, Schema.Schema<S, S, never>, typeof Schema.Never, never>>;
-//#endregion
-export { EntityRpcs, ToEntityOptions, toEntity };

package/v3/dist/cluster/to-entity.js

@@ -1,59 +0,0 @@
-import { MissingSchemaError } from "../errors.js";
-import { Schema } from "effect";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
-//#region src/cluster/to-entity.ts
-/**
-* Generate Entity definition from a machine.
-*
-* @module
-*/
-/**
-* Generate an Entity definition from a machine.
-*
-* Creates an Entity with a standard RPC protocol:
-* - `Send(event)` - Process event through machine, returns new state
-* - `GetState()` - Returns current state
-*
-* Schemas are read from the machine - must use `Machine.make({ state, event, initial })`.
-*
-* @example
-* ```ts
-* const OrderState = State({
-*   Pending: { orderId: Schema.String },
-*   Shipped: { trackingId: Schema.String },
-* })
-*
-* const OrderEvent = Event({
-*   Ship: { trackingId: Schema.String },
-* })
-*
-* const orderMachine = Machine.make({
-*   state: OrderState,
-*   event: OrderEvent,
-*   initial: OrderState.Pending({ orderId: "" }),
-* }).pipe(
-*   Machine.on(OrderState.Pending, OrderEvent.Ship, ...),
-* )
-*
-* const OrderEntity = toEntity(orderMachine, { type: "Order" })
-* ```
-*/
-const toEntity = (machine, options) => {
-	const stateSchema = machine.stateSchema;
-	const eventSchema = machine.eventSchema;
-	if (stateSchema === void 0 || eventSchema === void 0) throw new MissingSchemaError({ operation: "toEntity" });
-	return Entity.make(options.type, [
-		Rpc.make("Send", {
-			payload: { event: eventSchema },
-			success: stateSchema
-		}),
-		Rpc.make("Ask", {
-			payload: { event: eventSchema },
-			success: Schema.Unknown
-		}),
-		Rpc.make("GetState", { success: stateSchema })
-	]);
-};
-//#endregion
-export { toEntity };

package/v3/dist/errors.d.ts

@@ -1,95 +0,0 @@
-import { Schema } from "effect";
-
-//#region src/errors.d.ts
-declare const DuplicateActorError_base: Schema.TaggedErrorClass<DuplicateActorError, "DuplicateActorError", {
-  readonly _tag: Schema.tag<"DuplicateActorError">;
-} & {
-  actorId: typeof Schema.String;
-}>;
-/** Attempted to spawn/restore actor with ID already in use */
-declare class DuplicateActorError extends DuplicateActorError_base {}
-declare const MissingSchemaError_base: Schema.TaggedErrorClass<MissingSchemaError, "MissingSchemaError", {
-  readonly _tag: Schema.tag<"MissingSchemaError">;
-} & {
-  operation: typeof Schema.String;
-}>;
-/** Operation requires schemas attached to machine */
-declare class MissingSchemaError extends MissingSchemaError_base {}
-declare const InvalidSchemaError_base: Schema.TaggedErrorClass<InvalidSchemaError, "InvalidSchemaError", {
-  readonly _tag: Schema.tag<"InvalidSchemaError">;
-} & {
-  message: typeof Schema.String;
-}>;
-/** State/Event schema has no variants */
-declare class InvalidSchemaError extends InvalidSchemaError_base {}
-declare const MissingMatchHandlerError_base: Schema.TaggedErrorClass<MissingMatchHandlerError, "MissingMatchHandlerError", {
-  readonly _tag: Schema.tag<"MissingMatchHandlerError">;
-} & {
-  tag: typeof Schema.String;
-}>;
-/** $match called with missing handler for tag */
-declare class MissingMatchHandlerError extends MissingMatchHandlerError_base {}
-declare const SlotProvisionError_base: Schema.TaggedErrorClass<SlotProvisionError, "SlotProvisionError", {
-  readonly _tag: Schema.tag<"SlotProvisionError">;
-} & {
-  slotName: typeof Schema.String;
-  slotType: Schema.Literal<["slot"]>;
-}>;
-/** Slot handler not found at runtime (internal error) */
-declare class SlotProvisionError extends SlotProvisionError_base {}
-declare const ProvisionValidationError_base: Schema.TaggedErrorClass<ProvisionValidationError, "ProvisionValidationError", {
-  readonly _tag: Schema.tag<"ProvisionValidationError">;
-} & {
-  missing: Schema.Array$<typeof Schema.String>;
-  extra: Schema.Array$<typeof Schema.String>;
-}>;
-/** Slot provision validation failed — missing or extra handlers */
-declare class ProvisionValidationError extends ProvisionValidationError_base {}
-declare const AssertionError_base: Schema.TaggedErrorClass<AssertionError, "AssertionError", {
-  readonly _tag: Schema.tag<"AssertionError">;
-} & {
-  message: typeof Schema.String;
-}>;
-/** Assertion failed in testing utilities */
-declare class AssertionError extends AssertionError_base {}
-declare const ActorStoppedError_base: Schema.TaggedErrorClass<ActorStoppedError, "ActorStoppedError", {
-  readonly _tag: Schema.tag<"ActorStoppedError">;
-} & {
-  actorId: typeof Schema.String;
-}>;
-/** Actor was stopped while a call/ask was pending */
-declare class ActorStoppedError extends ActorStoppedError_base {}
-declare const NoReplyError_base: Schema.TaggedErrorClass<NoReplyError, "NoReplyError", {
-  readonly _tag: Schema.tag<"NoReplyError">;
-} & {
-  actorId: typeof Schema.String;
-  eventTag: typeof Schema.String;
-}>;
-/** ask() was used but the transition handler did not call reply */
-declare class NoReplyError extends NoReplyError_base {}
-declare const PersistenceError_base: Schema.TaggedErrorClass<PersistenceError, "PersistenceError", {
-  readonly _tag: Schema.tag<"PersistenceError">;
-} & {
-  message: typeof Schema.String;
-}>;
-/** Persistence adapter operation failed */
-declare class PersistenceError extends PersistenceError_base {}
-declare const SlotCodecError_base: Schema.TaggedErrorClass<SlotCodecError, "SlotCodecError", {
-  readonly _tag: Schema.tag<"SlotCodecError">;
-} & {
-  slotName: typeof Schema.String;
-  phase: Schema.Literal<["input", "output"]>;
-  message: typeof Schema.String;
-}>;
-/** Slot input/output schema validation failed */
-declare class SlotCodecError extends SlotCodecError_base {}
-declare const VersionConflictError_base: Schema.TaggedErrorClass<VersionConflictError, "VersionConflictError", {
-  readonly _tag: Schema.tag<"VersionConflictError">;
-} & {
-  expected: typeof Schema.Number;
-  actual: typeof Schema.Number;
-}>;
-/** Optimistic locking failure — stored version doesn't match expected */
-declare class VersionConflictError extends VersionConflictError_base {}
-//#endregion
-export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError };

package/v3/dist/errors.js

@@ -1,54 +0,0 @@
-import { Schema } from "effect";
-//#region src/errors.ts
-/**
-* Typed error classes for effect-machine.
-*
-* All errors extend Schema.TaggedErrorClass for:
-* - Type-safe catching via Effect.catchTag
-* - Serialization support
-* - Composable error handling
-*
-* @module
-*/
-/** Attempted to spawn/restore actor with ID already in use */
-var DuplicateActorError = class extends Schema.TaggedError()("DuplicateActorError", { actorId: Schema.String }) {};
-/** Operation requires schemas attached to machine */
-var MissingSchemaError = class extends Schema.TaggedError()("MissingSchemaError", { operation: Schema.String }) {};
-/** State/Event schema has no variants */
-var InvalidSchemaError = class extends Schema.TaggedError()("InvalidSchemaError", { message: Schema.String }) {};
-/** $match called with missing handler for tag */
-var MissingMatchHandlerError = class extends Schema.TaggedError()("MissingMatchHandlerError", { tag: Schema.String }) {};
-/** Slot handler not found at runtime (internal error) */
-var SlotProvisionError = class extends Schema.TaggedError()("SlotProvisionError", {
-	slotName: Schema.String,
-	slotType: Schema.Literal("slot")
-}) {};
-/** Slot provision validation failed — missing or extra handlers */
-var ProvisionValidationError = class extends Schema.TaggedError()("ProvisionValidationError", {
-	missing: Schema.Array(Schema.String),
-	extra: Schema.Array(Schema.String)
-}) {};
-/** Assertion failed in testing utilities */
-var AssertionError = class extends Schema.TaggedError()("AssertionError", { message: Schema.String }) {};
-/** Actor was stopped while a call/ask was pending */
-var ActorStoppedError = class extends Schema.TaggedError()("ActorStoppedError", { actorId: Schema.String }) {};
-/** ask() was used but the transition handler did not call reply */
-var NoReplyError = class extends Schema.TaggedError()("NoReplyError", {
-	actorId: Schema.String,
-	eventTag: Schema.String
-}) {};
-/** Persistence adapter operation failed */
-var PersistenceError = class extends Schema.TaggedError()("PersistenceError", { message: Schema.String }) {};
-/** Slot input/output schema validation failed */
-var SlotCodecError = class extends Schema.TaggedError()("SlotCodecError", {
-	slotName: Schema.String,
-	phase: Schema.Literal("input", "output"),
-	message: Schema.String
-}) {};
-/** Optimistic locking failure — stored version doesn't match expected */
-var VersionConflictError = class extends Schema.TaggedError()("VersionConflictError", {
-	expected: Schema.Number,
-	actual: Schema.Number
-}) {};
-//#endregion
-export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError };

package/v3/dist/index.d.ts

@@ -1,11 +0,0 @@
-import { DeferReplyResult, ReplyResult } from "./internal/utils.js";
-import { Event, MachineEventSchema, MachineStateSchema, ReplyFields, State } from "./schema.js";
-import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError } from "./errors.js";
-import { HasSlotKeys, MachineContext, ProvideSlots, Slot, SlotCall, SlotCalls, SlotFnDef, SlotHandler, SlotInvocation, SlotRequest, SlotResult, SlotsDef, SlotsSchema } from "./slot.js";
-import { ActorExit, CellPhase, DefectPhase, Supervision } from "./supervision.js";
-import { ProcessEventResult } from "./internal/transition.js";
-import { BackgroundEffect, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, SpawnEffect, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, machine_d_exports } from "./machine.js";
-import { ActorRef, ActorRefSync, ActorScope, ActorSystem, Default, SystemEvent, SystemEventListener, TransitionInfo } from "./actor.js";
-import { SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-import { AnyInspectionEvent, EffectEvent, ErrorEvent, EventReceivedEvent, InspectionEvent, Inspector, InspectorHandler, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-export { ActorExit, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type BackgroundEffect, type CellPhase, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type HasSlotKeys, type InspectionEvent, type Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineContext, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, type ProcessEventResult, type ProvideSlots, ProvisionValidationError, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, Slot, type SlotCall, type SlotCalls, SlotCodecError, type SlotFnDef, type SlotHandler, type SlotInvocation, SlotProvisionError, type SlotRequest, type SlotResult, type SlotsDef, type SlotsSchema, type SpawnEffect, type SpawnEvent, State, type StateHandlerContext, type StopEvent, Supervision, type SystemEvent, type SystemEventListener, type TaskEvent, type TaskOptions, type TestHarness, type TestHarnessOptions, type TimeoutConfig, type TracingInspectorOptions, type Transition, type TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/v3/dist/index.js

@@ -1,9 +0,0 @@
-import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError } from "./errors.js";
-import { Inspector, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-import { Slot } from "./slot.js";
-import { machine_exports } from "./machine.js";
-import { ActorExit, Supervision } from "./supervision.js";
-import { ActorScope, ActorSystem, Default } from "./actor.js";
-import { assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate } from "./testing.js";
-import { Event, State } from "./schema.js";
-export { ActorExit, ActorScope, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, Slot, SlotCodecError, SlotProvisionError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };