effect-machine 0.17.1 → 0.18.0

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

@@ -12,22 +12,19 @@ import { Effect, Option, Stream } from "effect";
 * yield* ref.send(OrderEvent.Process)
 * ```
 */
-const makeEntityActorRef = (client, entityId) => {
-	const c = client;
-	return {
-		entityId,
-		send: (event) => c.Send({ event }),
-		ask: ((event) => c.Ask({ event })),
-		snapshot: c.GetState(),
-		watch: c.WatchState(),
-		waitFor: (predicate) => Effect.gen(function* () {
-			const current = yield* c.GetState();
-			if (predicate(current)) return current;
-			const result = yield* c.WatchState().pipe(Stream.filter(predicate), Stream.take(1), Stream.runHead);
-			if (Option.isSome(result)) return result.value;
-			return yield* new ActorStoppedError({ actorId: entityId });
-		})
-	};
-};
+const makeEntityActorRef = (client, entityId) => ({
+	entityId,
+	send: (event) => client.Send({ event }),
+	ask: ((event) => client.Ask({ event })),
+	snapshot: client.GetState(),
+	watch: client.WatchState(),
+	waitFor: (predicate) => Effect.gen(function* () {
+		const current = yield* client.GetState();
+		if (predicate(current)) return current;
+		const result = yield* client.WatchState().pipe(Stream.filter(predicate), Stream.take(1), Stream.runHead);
+		if (Option.isSome(result)) return result.value;
+		return yield* ActorStoppedError.make({ actorId: entityId });
+	})
+});
 //#endregion
 export { makeEntityActorRef };

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

@@ -1,24 +1,18 @@
-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/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
-
 //#region src/cluster/entity-machine.d.ts
 /**
  * Options for EntityMachine.layer
  */
-interface EntityMachineOptions<S, E> {
+interface EntityMachineOptions<S> {
   /**
    * 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.toLayerQueue.
@@ -65,7 +59,7 @@ declare const EntityMachine: {
     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>;
+  }, R, EntityType extends string, Rpcs extends Rpc.Any>(entity: Entity.Entity<EntityType, Rpcs>, machine: Machine<S, E, R, any, any>, options?: EntityMachineOptions<S>) => Layer.Layer<never, never, R>;
 };
 //#endregion
 export { EntityMachine, EntityMachineOptions };

package/dist/cluster/entity-machine.js

@@ -1,6 +1,8 @@
-import { replay } from "../machine.js";
+import { makeInspectionHooks } from "../internal/inspection.js";
+import { Inspector } from "../inspection.js";
 import { createRuntime } from "../internal/runtime.js";
 import { ActorSystem, makeSystem } from "../actor.js";
+import { replay } from "../machine.js";
 import { PersistenceAdapter } from "./persistence.js";
 import { Clock, Effect, Option, Queue, Ref, Stream, SubscriptionRef } from "effect";
 import { Entity } from "effect/unstable/cluster";
@@ -36,23 +38,30 @@ import { Entity } from "effect/unstable/cluster";
 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 entityId = yield* Effect.serviceOption(Entity.CurrentAddress).pipe(Effect.map((opt) => {
+			if (opt._tag === "Some") return opt.value.entityId;
+			return "";
+		}));
+		const inspector = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
 		const existingSystem = yield* Effect.serviceOption(ActorSystem);
-		const system = Option.isSome(existingSystem) ? existingSystem.value : yield* makeSystem();
+		let system;
+		if (Option.isSome(existingSystem)) system = existingSystem.value;
+		else system = yield* makeSystem();
 		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;
+		let initialState = persistCtx.hydratedState;
+		if (initialState === void 0 && options?.initializeState !== void 0) initialState = options.initializeState(entityId);
+		let machineWithState = machine;
+		if (initialState !== void 0) machineWithState = machine._withInitial(initialState);
 		const versionRef = yield* Ref.make(persistCtx.initialVersion);
 		const computedInitial = initialState ?? machine.initial;
 		const stateRef = yield* SubscriptionRef.make(computedInitial);
 		const stoppedRef = yield* Ref.make(false);
 		const eventQueue = yield* Queue.unbounded();
+		let hooks = void 0;
+		if (inspector !== void 0) hooks = makeInspectionHooks(entityId, inspector);
 		const runtime = yield* createRuntime(machineWithState, system, {
 			actorId: entityId,
-			hooks: options?.hooks,
+			hooks,
 			childIdPrefix: `${entityId}/`,
 			cellResources: {
 				stateRef,
@@ -65,15 +74,19 @@ const EntityMachine = { layer: (entity, machine, options) => {
 			const { adapter: pAdapter, key } = persistCtx;
 			const strategy = persistence?.strategy ?? "snapshot";
 			const schedule = persistence?.snapshotSchedule;
-			if (strategy === "snapshot") yield* SubscriptionRef.changes(runtime.stateRef).pipe(schedule !== void 0 ? Stream.schedule(schedule) : (s) => s, Stream.runForEach((state) => Effect.gen(function* () {
-				const version = yield* Ref.get(versionRef);
-				const now = yield* Clock.currentTimeMillis;
-				yield* pAdapter.saveSnapshot(key, {
-					state,
-					version,
-					timestamp: now
-				});
-			}).pipe(Effect.catch(() => Effect.void))), Effect.forkScoped);
+			if (strategy === "snapshot") {
+				let applySchedule = (s) => s;
+				if (schedule !== void 0) applySchedule = Stream.schedule(schedule);
+				yield* SubscriptionRef.changes(runtime.stateRef).pipe(applySchedule, Stream.runForEach((state) => Effect.gen(function* () {
+					const version = yield* Ref.get(versionRef);
+					const now = yield* Clock.currentTimeMillis;
+					yield* pAdapter.saveSnapshot(key, {
+						state,
+						version,
+						timestamp: now
+					});
+				}).pipe(Effect.ignore)), Effect.forkScoped);
+			}
 			yield* Effect.addFinalizer(() => Effect.gen(function* () {
 				const state = yield* SubscriptionRef.get(runtime.stateRef);
 				const version = yield* Ref.get(versionRef);
@@ -83,14 +96,16 @@ const EntityMachine = { layer: (entity, machine, options) => {
 					version,
 					timestamp: now
 				});
-			}).pipe(Effect.catch(() => Effect.void)));
+			}).pipe(Effect.ignore));
 		}
 		return (mailbox, replier) => Effect.gen(function* () {
-			const hasPersistence = persistCtx.adapter !== void 0;
-			const journalCtx = hasPersistence && (persistence?.strategy ?? "snapshot") === "journal" ? {
-				adapter: persistCtx.adapter,
+			const adapter = persistCtx.adapter;
+			const hasPersistence = adapter !== void 0;
+			let journalCtx = void 0;
+			if (adapter !== void 0 && (persistence?.strategy ?? "snapshot") === "journal") journalCtx = {
+				adapter,
 				key: persistCtx.key
-			} : void 0;
+			};
 			while (true) {
 				const request = yield* Queue.take(mailbox);
 				switch (request.tag) {
@@ -105,7 +120,7 @@ const EntityMachine = { layer: (entity, machine, options) => {
 					}
 					case "Ask": {
 						const event = request.payload.event;
-						const reply = yield* runtime.ask(event);
+						const reply = yield* runtime.ask(event).pipe(Effect.orDie);
 						if (journalCtx !== void 0) yield* persistEvent(journalCtx.adapter, journalCtx.key, versionRef, event);
 						else if (hasPersistence) yield* Ref.update(versionRef, (v) => v + 1);
 						yield* replier.succeed(request, reply);
@@ -116,10 +131,7 @@ const EntityMachine = { layer: (entity, machine, options) => {
 						yield* replier.succeed(request, state);
 						break;
 					}
-					case "WatchState":
-						yield* replier.succeed(request, SubscriptionRef.changes(runtime.stateRef));
-						break;
-					default: break;
+					case "WatchState": yield* replier.succeed(request, SubscriptionRef.changes(runtime.stateRef));
 				}
 			}
 		});
@@ -129,7 +141,9 @@ const EntityMachine = { layer: (entity, machine, options) => {
 	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.toLayerQueue(build.pipe(Effect.orDie), Object.keys(clusterOptions).length > 0 ? clusterOptions : void 0);
+	let resolvedClusterOptions = void 0;
+	if (Object.keys(clusterOptions).length > 0) resolvedClusterOptions = clusterOptions;
+	return entity.toLayerQueue(build.pipe(Effect.orDie), resolvedClusterOptions);
 } };
 const noPersistence = {
 	adapter: void 0,
@@ -147,23 +161,32 @@ const hydratePersistence = (persistence, entityDef, entityId, machine, initializ
 	};
 	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;
+		let baseState;
+		if (Option.isSome(maybeSnapshot)) baseState = maybeSnapshot.value.state;
+		else if (initializeState !== void 0) baseState = initializeState(entityId);
+		else baseState = machine.initial;
+		let snapshotVersion = 0;
+		if (Option.isSome(maybeSnapshot)) snapshotVersion = maybeSnapshot.value.version;
 		const events = yield* adapter.loadEvents(key, snapshotVersion);
 		if (events.length > 0) {
-			const hydratedState = yield* replay(machine, events.map((e) => e.event), { from: baseState });
+			const eventValues = events.map((e) => e.event);
+			const hydratedState = yield* replay(machine, eventValues, { from: baseState });
 			const lastEvent = events[events.length - 1];
+			let initialVersion = snapshotVersion;
+			if (lastEvent !== void 0) initialVersion = lastEvent.version;
 			return {
 				adapter,
 				key,
 				hydratedState,
-				initialVersion: lastEvent !== void 0 ? lastEvent.version : snapshotVersion
+				initialVersion
 			};
 		}
+		let snapshotState = void 0;
+		if (Option.isSome(maybeSnapshot)) snapshotState = maybeSnapshot.value.state;
 		return {
 			adapter,
 			key,
-			hydratedState: Option.isSome(maybeSnapshot) ? maybeSnapshot.value.state : void 0,
+			hydratedState: snapshotState,
 			initialVersion: snapshotVersion
 		};
 	}

package/dist/cluster/index.js

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

package/dist/cluster/persistence.d.ts

@@ -1,6 +1,5 @@
 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 {

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

@@ -1,9 +1,8 @@
+import { MachineEventSchema, MachineStateSchema } from "../schema.js";
 import { Machine } from "../machine.js";
 import { Schema } from "effect";
 import { Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
-import * as _$effect_unstable_rpc_RpcSchema0 from "effect/unstable/rpc/RpcSchema";
-
 //#region src/cluster/to-entity.d.ts
 /**
  * Options for toEntity.
@@ -14,18 +13,17 @@ interface ToEntityOptions {
    */
   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.Top, EventSchema extends Schema.Top> = readonly [Rpc.Rpc<"Send", Schema.Struct<{
-  readonly event: EventSchema;
-}>, StateSchema>, Rpc.Rpc<"Ask", Schema.Struct<{
-  readonly event: EventSchema;
-}>, typeof Schema.Unknown>, Rpc.Rpc<"GetState", typeof Schema.Void, StateSchema>];
+declare const makeEntityProtocol: <StateSchema extends Schema.Top, EventSchema extends Schema.Top>(stateSchema: StateSchema, eventSchema: EventSchema) => (Rpc.Rpc<"Ask", {
+  event: EventSchema;
+} extends (infer T) ? T extends {
+  event: EventSchema;
+} ? T extends Schema.Struct.Fields ? Schema.Struct<T> : T : never : never, Schema.Unknown, Schema.Never, never, never> | Rpc.Rpc<"GetState", Schema.Void, StateSchema, Schema.Never, never, never> | Rpc.Rpc<"Send", {
+  event: EventSchema;
+} extends (infer T_1) ? T_1 extends {
+  event: EventSchema;
+} ? T_1 extends Schema.Struct.Fields ? Schema.Struct<T_1> : T_1 : never : never, StateSchema, Schema.Never, never, never> | Rpc.Rpc<"WatchState", Schema.Void, import("effect/unstable/rpc/RpcSchema").Stream<StateSchema, Schema.Never>, Schema.Never, never, never>)[];
+/** RPC protocol owned by `toEntity`. */
+type EntityRpcs<StateSchema extends Schema.Top, EventSchema extends Schema.Top> = ReturnType<typeof makeEntityProtocol<StateSchema, EventSchema>>[number];
 /**
  * Generate an Entity definition from a machine.
  *
@@ -50,8 +48,8 @@ type EntityRpcs<StateSchema extends Schema.Top, EventSchema extends Schema.Top>
  *   state: OrderState,
  *   event: OrderEvent,
  *   initial: OrderState.Pending({ orderId: "" }),
- * }).pipe(
- *   Machine.on(OrderState.Pending, OrderEvent.Ship, ...),
+ * }).on(OrderState.Pending, OrderEvent.Ship, ({ event }) =>
+ *   OrderState.Shipped({ trackingId: event.trackingId }),
  * )
  *
  * const OrderEntity = toEntity(orderMachine, { type: "Order" })
@@ -61,10 +59,10 @@ 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>;
-}>, Schema.Schema<S>, Schema.Never, never, never> | Rpc.Rpc<"Ask", Schema.Struct<{
-  event: Schema.Schema<E>;
-}>, Schema.Unknown, Schema.Never, never, never> | Rpc.Rpc<"GetState", Schema.Void, Schema.Schema<S>, Schema.Never, never, never> | Rpc.Rpc<"WatchState", Schema.Void, _$effect_unstable_rpc_RpcSchema0.Stream<Schema.Schema<S>, Schema.Never>, Schema.Never, never, never>>;
+}, R, SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>>(machine: Machine<S, E, R, SD, ED>, options: ToEntityOptions) => Entity.Entity<string, EntityRpcs<MachineStateSchema<SD> & {
+  readonly Type: S;
+}, MachineEventSchema<ED> & {
+  readonly Type: E;
+}>>;
 //#endregion
 export { EntityRpcs, ToEntityOptions, toEntity };

package/dist/cluster/to-entity.js

@@ -1,4 +1,3 @@
-import { MissingSchemaError } from "../errors.js";
 import { Schema } from "effect";
 import { Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
@@ -8,6 +7,21 @@ import { Rpc } from "effect/unstable/rpc";
 *
 * @module
 */
+const makeEntityProtocol = (stateSchema, eventSchema) => [
+	Rpc.make("Send", {
+		payload: { event: eventSchema },
+		success: stateSchema
+	}),
+	Rpc.make("Ask", {
+		payload: { event: eventSchema },
+		success: Schema.Unknown
+	}),
+	Rpc.make("GetState", { success: stateSchema }),
+	Rpc.make("WatchState", {
+		success: stateSchema,
+		stream: true
+	})
+];
 /**
 * Generate an Entity definition from a machine.
 *
@@ -32,8 +46,8 @@ import { Rpc } from "effect/unstable/rpc";
 *   state: OrderState,
 *   event: OrderEvent,
 *   initial: OrderState.Pending({ orderId: "" }),
-* }).pipe(
-*   Machine.on(OrderState.Pending, OrderEvent.Ship, ...),
+* }).on(OrderState.Pending, OrderEvent.Ship, ({ event }) =>
+*   OrderState.Shipped({ trackingId: event.trackingId }),
 * )
 *
 * const OrderEntity = toEntity(orderMachine, { type: "Order" })
@@ -42,22 +56,7 @@ import { Rpc } from "effect/unstable/rpc";
 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 }),
-		Rpc.make("WatchState", {
-			success: stateSchema,
-			stream: true
-		})
-	]);
+	return Entity.make(options.type, makeEntityProtocol(stateSchema, eventSchema));
 };
 //#endregion
 export { toEntity };

package/dist/errors.d.ts

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

package/dist/errors.js

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

package/dist/index.d.ts

@@ -1,11 +1,10 @@
 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 { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, NoReplyError, PersistenceError, VersionConflictError } from "./errors.js";
+import { ActorExit, DefectPhase, Supervision } from "./supervision.js";
+import { Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, StateHandlerContext, TaskOptions, TimeoutConfig, machine_d_exports } from "./machine.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, ActorSystemService, 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, InspectorService, SpawnEvent, StopEvent, TaskEvent, TracingInspectorOptions, TransitionEvent, collectingInspector, combineInspectors, consoleInspector, makeInspector, makeInspectorEffect, tracingInspector } from "./inspection.js";
-export { ActorExit, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystemService as 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 InspectorService as 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 };
+export { ActorExit, type ActorRef, type ActorRefSync, ActorScope, ActorStoppedError, type ActorSystemService as ActorSystem, Default as ActorSystemDefault, ActorSystem as ActorSystemService, type AnyInspectionEvent, AssertionError, type DefectPhase, type DeferReplyResult, DuplicateActorError, type Durability, type DurabilityCommit, type EffectEvent, type ErrorEvent, Event, type EventReceivedEvent, type HandlerContext, type InspectionEvent, type InspectorService as Inspector, type InspectorHandler, Inspector as InspectorService, InvalidSchemaError, type Lifecycle, machine_d_exports as Machine, type MachineEventSchema, type MachineRef, type MachineStateSchema, type Machine as MachineType, type MakeConfig, MissingMatchHandlerError, NoReplyError, PersistenceError, type ProcessEventResult, type Recovery, type RecoveryContext, type ReplyFields, type ReplyResult, type SimulationResult, 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 TransitionEvent, type TransitionInfo, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/index.js

@@ -1,9 +1,8 @@
-import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, PersistenceError, ProvisionValidationError, SlotCodecError, SlotProvisionError, VersionConflictError } from "./errors.js";
+import { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, NoReplyError, PersistenceError, VersionConflictError } from "./errors.js";
+import { Event, State } from "./schema.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 { machine_exports } from "./machine.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 };
+export { ActorExit, ActorScope, ActorStoppedError, Default as ActorSystemDefault, ActorSystem as ActorSystemService, AssertionError, DuplicateActorError, Event, Inspector as InspectorService, InvalidSchemaError, machine_exports as Machine, MissingMatchHandlerError, NoReplyError, PersistenceError, State, Supervision, VersionConflictError, assertNeverReaches, assertPath, assertReaches, collectingInspector, combineInspectors, consoleInspector, createTestHarness, makeInspector, makeInspectorEffect, simulate, tracingInspector };

package/dist/inspection.d.ts

@@ -1,5 +1,4 @@
 import { Context, Effect, Schema } from "effect";
-
 //#region src/inspection.d.ts
 /**
  * Resolve a type param: if it's a Schema, extract `.Type`; otherwise use as-is.