effect-machine 0.6.0 → 0.7.1

package/dist/actor.d.ts

@@ -5,7 +5,7 @@ import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventC
 import { PersistentActorRef } from "./persistence/persistent-actor.js";
 import { ActorMetadata, PersistenceAdapterTag, PersistenceError, RestoreResult, VersionConflictError } from "./persistence/adapter.js";
 import { BuiltMachine, Machine, MachineRef } from "./machine.js";
-import { Context, Effect, Layer, Option, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
+import { Effect, Layer, Option, Queue, Ref, Scope, ServiceMap, Stream, SubscriptionRef } from "effect";
 import * as effect_Tracer0 from "effect/Tracer";
 
 //#region src/actor.d.ts
@@ -261,7 +261,7 @@ interface ActorSystem {
 /**
  * ActorSystem service tag
  */
-declare const ActorSystem: Context.Tag<ActorSystem, ActorSystem>;
+declare const ActorSystem: ServiceMap.Service<ActorSystem, ActorSystem>;
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;
 /**

package/dist/actor.js

@@ -6,7 +6,7 @@ import { processEventCore, resolveTransition, runSpawnEffects } from "./internal
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { PersistenceAdapterTag, PersistenceError } from "./persistence/adapter.js";
 import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
-import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Runtime, Scope, Stream, SubscriptionRef } from "effect";
+import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Scope, Semaphore, ServiceMap, Stream, SubscriptionRef } from "effect";
 
 //#region src/actor.ts
 /**
@@ -20,7 +20,7 @@ import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, O
 /**
 * ActorSystem service tag
 */
-const ActorSystem = Context.GenericTag("@effect/machine/ActorSystem");
+const ActorSystem = ServiceMap.Service("@effect/machine/ActorSystem");
 /**
 * Notify all listeners of state change.
 */
@@ -49,10 +49,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 		const current = yield* SubscriptionRef.get(stateRef);
 		if (predicate(current)) return current;
 		const done = yield* Deferred.make();
-		const rt = yield* Effect.runtime();
-		const runFork = Runtime.runFork(rt);
 		const listener = (state) => {
-			if (predicate(state)) runFork(Deferred.succeed(done, state));
+			if (predicate(state)) Effect.runFork(Deferred.succeed(done, state));
 		};
 		listeners.add(listener);
 		const afterSubscribe = yield* SubscriptionRef.get(stateRef);
@@ -84,7 +82,7 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 		canSync: (event) => {
 			return resolveTransition(machine, Effect.runSync(SubscriptionRef.get(stateRef)), event) !== void 0;
 		},
-		changes: stateRef.changes,
+		changes: SubscriptionRef.changes(stateRef),
 		waitFor,
 		awaitFinal,
 		sendAndWait,
@@ -153,7 +151,7 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	};
 	const { effects: effectSlots } = machine._slots;
 	for (const bg of machine.backgroundEffects) {
-		const fiber = yield* Effect.forkDaemon(bg.handler({
+		const fiber = yield* Effect.forkDetach(bg.handler({
 			state: machine.initial,
 			event: initEvent,
 			self,
@@ -177,7 +175,7 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
 		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap);
 	}
-	const loopFiber = yield* Effect.forkDaemon(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system));
+	const loopFiber = yield* Effect.forkDetach(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system));
 	return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
 		const finalState = yield* SubscriptionRef.get(stateRef);
 		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
@@ -303,10 +301,10 @@ const notifySystemListeners = (listeners, event) => {
 };
 const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 	const actorsMap = MutableHashMap.empty();
-	const withSpawnGate = (yield* Effect.makeSemaphore(1)).withPermits(1);
+	const withSpawnGate = (yield* Semaphore.make(1)).withPermits(1);
 	const eventPubSub = yield* PubSub.unbounded();
 	const eventListeners = /* @__PURE__ */ new Set();
-	const emitSystemEvent = (event) => Effect.sync(() => notifySystemListeners(eventListeners, event)).pipe(Effect.andThen(PubSub.publish(eventPubSub, event)), Effect.catchAllCause(() => Effect.void), Effect.asVoid);
+	const emitSystemEvent = (event) => Effect.sync(() => notifySystemListeners(eventListeners, event)).pipe(Effect.andThen(PubSub.publish(eventPubSub, event)), Effect.catchCause(() => Effect.void), Effect.asVoid);
 	yield* Effect.addFinalizer(() => {
 		const stops = [];
 		MutableHashMap.forEach(actorsMap, (actor) => {
@@ -390,12 +388,12 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		const failed = [];
 		for (const id of ids) {
 			if (MutableHashMap.has(actorsMap, id)) continue;
-			const result = yield* Effect.either(restore(id, persistentMachine));
-			if (result._tag === "Left") failed.push({
+			const result = yield* Effect.result(restore(id, persistentMachine));
+			if (result._tag === "Failure") failed.push({
 				id,
-				error: result.left
+				error: result.failure
 			});
-			else if (Option.isSome(result.right)) restored.push(result.right.value);
+			else if (Option.isSome(result.success)) restored.push(result.success.value);
 			else failed.push({
 				id,
 				error: new PersistenceError({
@@ -453,7 +451,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 /**
 * Default ActorSystem layer
 */
-const Default = Layer.scoped(ActorSystem, make());
+const Default = Layer.effect(ActorSystem, make());
 
 //#endregion
 export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };

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

@@ -3,8 +3,8 @@ import { ProcessEventHooks } from "../internal/transition.js";
 import { Machine } from "../machine.js";
 import "../actor.js";
 import { Layer } from "effect";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
+import { Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
 
 //#region src/cluster/entity-machine.d.ts
 /**

package/dist/cluster/entity-machine.js

@@ -1,7 +1,7 @@
 import { processEventCore, runSpawnEffects } from "../internal/transition.js";
 import { ActorSystem } from "../actor.js";
 import { Effect, Option, Queue, Ref, Scope } from "effect";
-import { Entity } from "@effect/cluster";
+import { Entity } from "effect/unstable/cluster";
 
 //#region src/cluster/entity-machine.ts
 /**

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

@@ -1,7 +1,7 @@
 import { Machine } from "../machine.js";
 import { Schema } from "effect";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
+import { Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
 
 //#region src/cluster/to-entity.d.ts
 /**
@@ -19,7 +19,7 @@ interface ToEntityOptions {
  * - `Send` - Send event to machine, returns new state
  * - `GetState` - Get current state
  */
-type EntityRpcs<StateSchema extends Schema.Schema.Any, EventSchema extends Schema.Schema.Any> = readonly [Rpc.Rpc<"Send", Schema.Struct<{
+type EntityRpcs<StateSchema extends Schema.Top, EventSchema extends Schema.Top> = readonly [Rpc.Rpc<"Send", Schema.Struct<{
   readonly event: EventSchema;
 }>, StateSchema, typeof Schema.Never, never>, Rpc.Rpc<"GetState", typeof Schema.Void, StateSchema, typeof Schema.Never, never>];
 /**
@@ -58,7 +58,7 @@ declare const toEntity: <S extends {
 }, E extends {
   readonly _tag: string;
 }, R>(machine: Machine<S, E, R, any, any, any, any>, options: ToEntityOptions) => Entity.Entity<string, Rpc.Rpc<"Send", Schema.Struct<{
-  event: Schema.Schema<E, unknown, never>;
-}>, Schema.Schema<S, unknown, never>, typeof Schema.Never, never> | Rpc.Rpc<"GetState", typeof Schema.Void, Schema.Schema<S, unknown, never>, typeof Schema.Never, never>>;
+  event: Schema.Schema<E>;
+}>, Schema.Schema<S>, Schema.Never, never, never> | Rpc.Rpc<"GetState", Schema.Void, Schema.Schema<S>, Schema.Never, never, never>>;
 //#endregion
 export { EntityRpcs, ToEntityOptions, toEntity };

package/dist/cluster/to-entity.js

@@ -1,6 +1,6 @@
 import { MissingSchemaError } from "../errors.js";
-import { Entity } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
+import { Entity } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
 
 //#region src/cluster/to-entity.ts
 /**

package/dist/errors.d.ts

@@ -1,60 +1,45 @@
 import { Schema } from "effect";
+import * as effect_Cause0 from "effect/Cause";
 
 //#region src/errors.d.ts
-declare const DuplicateActorError_base: Schema.TaggedErrorClass<DuplicateActorError, "DuplicateActorError", {
-  readonly _tag: Schema.tag<"DuplicateActorError">;
-} & {
-  actorId: typeof Schema.String;
-}>;
+declare const DuplicateActorError_base: Schema.ErrorClass<DuplicateActorError, Schema.TaggedStruct<"DuplicateActorError", {
+  readonly actorId: Schema.String;
+}>, effect_Cause0.YieldableError>;
 /** Attempted to spawn/restore actor with ID already in use */
 declare class DuplicateActorError extends DuplicateActorError_base {}
-declare const UnprovidedSlotsError_base: Schema.TaggedErrorClass<UnprovidedSlotsError, "UnprovidedSlotsError", {
-  readonly _tag: Schema.tag<"UnprovidedSlotsError">;
-} & {
-  slots: Schema.Array$<typeof Schema.String>;
-}>;
+declare const UnprovidedSlotsError_base: Schema.ErrorClass<UnprovidedSlotsError, Schema.TaggedStruct<"UnprovidedSlotsError", {
+  readonly slots: Schema.$Array<Schema.String>;
+}>, effect_Cause0.YieldableError>;
 /** Machine has unprovided effect slots */
 declare class UnprovidedSlotsError extends UnprovidedSlotsError_base {}
-declare const MissingSchemaError_base: Schema.TaggedErrorClass<MissingSchemaError, "MissingSchemaError", {
-  readonly _tag: Schema.tag<"MissingSchemaError">;
-} & {
-  operation: typeof Schema.String;
-}>;
+declare const MissingSchemaError_base: Schema.ErrorClass<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.TaggedErrorClass<InvalidSchemaError, "InvalidSchemaError", {
-  readonly _tag: Schema.tag<"InvalidSchemaError">;
-}>;
+declare const InvalidSchemaError_base: Schema.ErrorClass<InvalidSchemaError, Schema.TaggedStruct<"InvalidSchemaError", {}>, effect_Cause0.YieldableError>;
 /** 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;
-}>;
+declare const MissingMatchHandlerError_base: Schema.ErrorClass<MissingMatchHandlerError, Schema.TaggedStruct<"MissingMatchHandlerError", {
+  readonly tag: Schema.String;
+}>, effect_Cause0.YieldableError>;
 /** $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<["guard", "effect"]>;
-}>;
+declare const SlotProvisionError_base: Schema.ErrorClass<SlotProvisionError, Schema.TaggedStruct<"SlotProvisionError", {
+  readonly slotName: Schema.String;
+  readonly slotType: Schema.Literals<readonly ["guard", "effect"]>;
+}>, effect_Cause0.YieldableError>;
 /** 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>;
-}>;
+declare const ProvisionValidationError_base: Schema.ErrorClass<ProvisionValidationError, Schema.TaggedStruct<"ProvisionValidationError", {
+  readonly missing: Schema.$Array<Schema.String>;
+  readonly extra: Schema.$Array<Schema.String>;
+}>, effect_Cause0.YieldableError>;
 /** Machine.build() 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;
-}>;
+declare const AssertionError_base: Schema.ErrorClass<AssertionError, Schema.TaggedStruct<"AssertionError", {
+  readonly message: Schema.String;
+}>, effect_Cause0.YieldableError>;
 /** Assertion failed in testing utilities */
 declare class AssertionError extends AssertionError_base {}
 //#endregion

package/dist/errors.js

@@ -4,7 +4,7 @@ import { Schema } from "effect";
 /**
 * Typed error classes for effect-machine.
 *
-* All errors extend Schema.TaggedError for:
+* All errors extend Schema.TaggedErrorClassClass for:
 * - Type-safe catching via Effect.catchTag
 * - Serialization support
 * - Composable error handling
@@ -12,27 +12,27 @@ import { Schema } from "effect";
 * @module
 */
 /** Attempted to spawn/restore actor with ID already in use */
-var DuplicateActorError = class extends Schema.TaggedError()("DuplicateActorError", { actorId: Schema.String }) {};
+var DuplicateActorError = class extends Schema.TaggedErrorClass()("DuplicateActorError", { actorId: Schema.String }) {};
 /** Machine has unprovided effect slots */
-var UnprovidedSlotsError = class extends Schema.TaggedError()("UnprovidedSlotsError", { slots: Schema.Array(Schema.String) }) {};
+var UnprovidedSlotsError = class extends Schema.TaggedErrorClass()("UnprovidedSlotsError", { slots: Schema.Array(Schema.String) }) {};
 /** Operation requires schemas attached to machine */
-var MissingSchemaError = class extends Schema.TaggedError()("MissingSchemaError", { operation: Schema.String }) {};
+var MissingSchemaError = class extends Schema.TaggedErrorClass()("MissingSchemaError", { operation: Schema.String }) {};
 /** State/Event schema has no variants */
-var InvalidSchemaError = class extends Schema.TaggedError()("InvalidSchemaError", {}) {};
+var InvalidSchemaError = class extends Schema.TaggedErrorClass()("InvalidSchemaError", {}) {};
 /** $match called with missing handler for tag */
-var MissingMatchHandlerError = class extends Schema.TaggedError()("MissingMatchHandlerError", { tag: Schema.String }) {};
+var MissingMatchHandlerError = class extends Schema.TaggedErrorClass()("MissingMatchHandlerError", { tag: Schema.String }) {};
 /** Slot handler not found at runtime (internal error) */
-var SlotProvisionError = class extends Schema.TaggedError()("SlotProvisionError", {
+var SlotProvisionError = class extends Schema.TaggedErrorClass()("SlotProvisionError", {
 	slotName: Schema.String,
-	slotType: Schema.Literal("guard", "effect")
+	slotType: Schema.Literals(["guard", "effect"])
 }) {};
 /** Machine.build() validation failed - missing or extra handlers */
-var ProvisionValidationError = class extends Schema.TaggedError()("ProvisionValidationError", {
+var ProvisionValidationError = class extends Schema.TaggedErrorClass()("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 }) {};
+var AssertionError = class extends Schema.TaggedErrorClass()("AssertionError", { message: Schema.String }) {};
 
 //#endregion
 export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };

package/dist/inspection.d.ts

@@ -1,10 +1,10 @@
-import { Context, Schema } from "effect";
+import { Schema, ServiceMap } from "effect";
 
 //#region src/inspection.d.ts
 /**
  * Resolve a type param: if it's a Schema, extract `.Type`; otherwise use as-is.
  */
-type ResolveType<T> = T extends Schema.Schema<infer A, infer _I, infer _R> ? A : T;
+type ResolveType<T> = T extends Schema.Schema<infer A> ? A : T;
 /**
  * Event emitted when an actor is spawned
  */
@@ -91,7 +91,7 @@ interface Inspector<S, E> {
  * Inspector service tag - optional service for machine introspection
  * Uses `any` types to allow variance flexibility when providing the service
  */
-declare const Inspector: Context.Tag<Inspector<any, any>, Inspector<any, any>>;
+declare const Inspector: ServiceMap.Service<Inspector<any, any>, Inspector<any, any>>;
 /**
  * Create an inspector from a callback function.
  *

package/dist/inspection.js

@@ -1,11 +1,11 @@
-import { Context } from "effect";
+import { ServiceMap } from "effect";
 
 //#region src/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");
+const Inspector = ServiceMap.Service("@effect/machine/Inspector");
 /**
 * Create an inspector from a callback function.
 *

package/dist/internal/brands.d.ts

@@ -1,10 +1,8 @@
 import { Brand } from "effect";
 
 //#region src/internal/brands.d.ts
-declare const StateTypeId: unique symbol;
-declare const EventTypeId: unique symbol;
-type StateTypeId = typeof StateTypeId;
-type EventTypeId = typeof EventTypeId;
+type StateTypeId = "effect-machine/StateTypeId";
+type EventTypeId = "effect-machine/EventTypeId";
 interface StateBrand extends Brand.Brand<StateTypeId> {}
 interface EventBrand extends Brand.Brand<EventTypeId> {}
 type BrandedState = {
@@ -13,8 +11,7 @@ type BrandedState = {
 type BrandedEvent = {
   readonly _tag: string;
 } & EventBrand;
-declare const SchemaIdTypeId: unique symbol;
-type SchemaIdTypeId = typeof SchemaIdTypeId;
+type SchemaIdTypeId = "effect-machine/SchemaIdTypeId";
 /**
  * Brand that captures the schema definition type D.
  * Two schemas with identical definition shapes will have compatible brands.

package/dist/internal/inspection.js

@@ -8,7 +8,11 @@ import { Clock, Effect } from "effect";
 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);
+	yield* Effect.sync(() => {
+		try {
+			inspector.onInspect(makeEvent(timestamp));
+		} catch {}
+	});
 });
 
 //#endregion

package/dist/internal/transition.d.ts

@@ -102,7 +102,7 @@ declare const processEventCore: <S extends {
 }, E extends {
   readonly _tag: string;
 }, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
-  current: Scope.CloseableScope;
+  current: Scope.Closeable;
 }, system: ActorSystem, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
   newState: S;
   previousState: S;
@@ -119,7 +119,7 @@ declare const runSpawnEffects: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.CloseableScope, system: ActorSystem, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.Closeable, system: ActorSystem, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
 /**
  * Resolve which transition should fire for a given state and event.
  * Uses indexed O(1) lookup. First matching transition wins.

package/dist/internal/transition.js

@@ -77,8 +77,8 @@ const executeTransition = Effect.fn("effect-machine.executeTransition")(function
 * @internal
 */
 const processEventCore = Effect.fn("effect-machine.processEventCore")(function* (machine, currentState, event, self, stateScopeRef, system, hooks) {
-	const result = yield* executeTransition(machine, currentState, event, self, system).pipe(Effect.catchAllCause((cause) => {
-		if (Cause.isInterruptedOnly(cause)) return Effect.interrupt;
+	const result = yield* executeTransition(machine, currentState, event, self, system).pipe(Effect.catchCause((cause) => {
+		if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
 		const onError = hooks?.onError;
 		if (onError === void 0) return Effect.failCause(cause).pipe(Effect.orDie);
 		return onError({
@@ -86,7 +86,7 @@ const processEventCore = Effect.fn("effect-machine.processEventCore")(function*
 			state: currentState,
 			event,
 			cause
-		}).pipe(Effect.zipRight(Effect.failCause(cause).pipe(Effect.orDie)));
+		}).pipe(Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
 	}));
 	if (!result.transitioned) return {
 		newState: currentState,
@@ -134,15 +134,15 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 			self,
 			effects: effectSlots,
 			system
-		}).pipe(Effect.provideService(machine.Context, ctx), Effect.catchAllCause((cause) => {
-			if (Cause.isInterruptedOnly(cause)) return Effect.interrupt;
+		}).pipe(Effect.provideService(machine.Context, ctx), Effect.catchCause((cause) => {
+			if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
 			if (reportError === void 0) return Effect.failCause(cause).pipe(Effect.orDie);
 			return reportError({
 				phase: "spawn",
 				state,
 				event,
 				cause
-			}).pipe(Effect.zipRight(Effect.failCause(cause).pipe(Effect.orDie)));
+			}).pipe(Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
 		}));
 		yield* Effect.forkScoped(effect).pipe(Effect.provideService(Scope.Scope, stateScope));
 	}

package/dist/internal/utils.js

@@ -2,6 +2,10 @@ import { Effect, Stream } from "effect";
 
 //#region src/internal/utils.ts
 /**
+* Internal utilities for effect-machine.
+* @internal
+*/
+/**
 * Internal event tags used for lifecycle effect contexts.
 * Prefixed with $ to distinguish from user events.
 * @internal
@@ -25,7 +29,7 @@ const getTag = (constructorOrValue) => {
 	}
 };
 /** Check if a value is an Effect */
-const isEffect = (value) => typeof value === "object" && value !== null && Effect.EffectTypeId in value;
+const isEffect = Effect.isEffect;
 /**
 * Stub ActorSystem that dies on any method call.
 * Used in contexts where spawning/system access isn't supported

package/dist/machine.d.ts

@@ -7,7 +7,7 @@ import { DuplicateActorError } from "./errors.js";
 import { findTransitions } from "./internal/transition.js";
 import "./persistence/index.js";
 import { ActorRef, ActorSystem } from "./actor.js";
-import { Cause, Context, Effect, Schedule, Schema, Scope } from "effect";
+import { Cause, Effect, Schedule, Schema, Scope, ServiceMap } from "effect";
 
 //#region src/machine.d.ts
 declare namespace machine_d_exports {
@@ -159,13 +159,13 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
     guards: GuardSlots<GD>;
     effects: EffectSlots<EFD>;
   };
-  readonly stateSchema?: Schema.Schema<State, unknown, never>;
-  readonly eventSchema?: Schema.Schema<Event, unknown, never>;
+  readonly stateSchema?: Schema.Schema<State>;
+  readonly eventSchema?: Schema.Schema<Event>;
   /**
    * Context tag for accessing machine state/event/self in slot handlers.
    * Uses shared module-level tag for all machines.
    */
-  readonly Context: Context.Tag<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
+  readonly Context: ServiceMap.Service<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
   get transitions(): ReadonlyArray<Transition<State, Event, GD, EFD, R>>;
   get spawnEffects(): ReadonlyArray<SpawnEffect<State, Event, EFD, R>>;
   get backgroundEffects(): ReadonlyArray<BackgroundEffect<State, Event, EFD, R>>;
@@ -173,7 +173,7 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
   get guardsSchema(): GuardsSchema<GD> | undefined;
   get effectsSchema(): EffectsSchema<EFD> | undefined;
   /** @internal */
-  constructor(initial: State, stateSchema?: Schema.Schema<State, unknown, never>, eventSchema?: Schema.Schema<Event, unknown, never>, guardsSchema?: GuardsSchema<GD>, effectsSchema?: EffectsSchema<EFD>);
+  constructor(initial: State, stateSchema?: Schema.Schema<State>, eventSchema?: Schema.Schema<Event>, guardsSchema?: GuardsSchema<GD>, effectsSchema?: EffectsSchema<EFD>);
   /** Register transition for a single state */
   on<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, GD, EFD, never>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /** Register transition for multiple states (handler receives union of state types) */

package/dist/machine.js

@@ -98,7 +98,9 @@ var Machine = class Machine {
 		this.stateSchema = stateSchema;
 		this.eventSchema = eventSchema;
 		this._slots = {
-			guards: this._guardsSchema !== void 0 ? this._guardsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOptional(this.Context).pipe(Effect.orDie), (ctx) => {
+			guards: this._guardsSchema !== void 0 ? this._guardsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOption(this.Context), (maybeCtx) => {
+				if (Option.isNone(maybeCtx)) return Effect.die("MachineContext not available");
+				const ctx = maybeCtx.value;
 				const handler = this._guardHandlers.get(name);
 				if (handler === void 0) return Effect.die(new SlotProvisionError({
 					slotName: name,
@@ -107,7 +109,9 @@ var Machine = class Machine {
 				const result = handler(params, ctx);
 				return typeof result === "boolean" ? Effect.succeed(result) : result;
 			})) : {},
-			effects: this._effectsSchema !== void 0 ? this._effectsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOptional(this.Context).pipe(Effect.orDie), (ctx) => {
+			effects: this._effectsSchema !== void 0 ? this._effectsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOption(this.Context), (maybeCtx) => {
+				if (Option.isNone(maybeCtx)) return Effect.die("MachineContext not available");
+				const ctx = maybeCtx.value;
 				const handler = this._effectHandlers.get(name);
 				if (handler === void 0) return Effect.die(new SlotProvisionError({
 					slotName: name,
@@ -194,14 +198,14 @@ var Machine = class Machine {
 			const exit = yield* Effect.exit(run(ctx));
 			if (Exit.isSuccess(exit)) {
 				yield* ctx.self.send(options.onSuccess(exit.value, ctx));
-				yield* Effect.yieldNow();
+				yield* Effect.yieldNow;
 				return;
 			}
 			const cause = exit.cause;
-			if (Cause.isInterruptedOnly(cause)) return;
+			if (Cause.hasInterruptsOnly(cause)) return;
 			if (options.onFailure !== void 0) {
 				yield* ctx.self.send(options.onFailure(cause, ctx));
-				yield* Effect.yieldNow();
+				yield* Effect.yieldNow;
 				return;
 			}
 			return yield* Effect.failCause(cause).pipe(Effect.orDie);

package/dist/persistence/adapter.d.ts

@@ -1,6 +1,7 @@
 import { DuplicateActorError } from "../errors.js";
 import { PersistentActorRef } from "./persistent-actor.js";
-import { Context, Effect, Option, Schema } from "effect";
+import { Effect, Option, Schema, ServiceMap } from "effect";
+import * as effect_Cause0 from "effect/Cause";
 
 //#region src/persistence/adapter.d.ts
 /**
@@ -64,20 +65,20 @@ 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>;
+  readonly saveSnapshot: <S>(id: string, snapshot: Snapshot<S>, schema: Schema.Codec<S, unknown, never, 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>;
+  readonly loadSnapshot: <S>(id: string, schema: Schema.Codec<S, unknown, never, 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>;
+  readonly appendEvent: <E>(id: string, event: PersistedEvent<E>, schema: Schema.Codec<E, unknown, never, 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>;
+  readonly loadEvents: <E>(id: string, schema: Schema.Codec<E, unknown, never, never>, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<E>>, PersistenceError>;
   /**
    * Delete all persisted data for an actor (snapshot + events).
    */
@@ -106,30 +107,26 @@ interface PersistenceAdapter {
    */
   readonly loadMetadata?: (id: string) => Effect.Effect<Option.Option<ActorMetadata>, PersistenceError>;
 }
-declare const PersistenceError_base: Schema.TaggedErrorClass<PersistenceError, "PersistenceError", {
-  readonly _tag: Schema.tag<"PersistenceError">;
-} & {
-  operation: typeof Schema.String;
-  actorId: typeof Schema.String;
-  cause: Schema.optional<typeof Schema.Unknown>;
-  message: Schema.optional<typeof Schema.String>;
-}>;
+declare const PersistenceError_base: Schema.ErrorClass<PersistenceError, Schema.TaggedStruct<"PersistenceError", {
+  readonly operation: Schema.String;
+  readonly actorId: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+  readonly message: Schema.optional<Schema.String>;
+}>, effect_Cause0.YieldableError>;
 /**
  * Error type for persistence operations
  */
 declare class PersistenceError extends PersistenceError_base {}
-declare const VersionConflictError_base: Schema.TaggedErrorClass<VersionConflictError, "VersionConflictError", {
-  readonly _tag: Schema.tag<"VersionConflictError">;
-} & {
-  actorId: typeof Schema.String;
-  expectedVersion: typeof Schema.Number;
-  actualVersion: typeof Schema.Number;
-}>;
+declare const VersionConflictError_base: Schema.ErrorClass<VersionConflictError, Schema.TaggedStruct<"VersionConflictError", {
+  readonly actorId: Schema.String;
+  readonly expectedVersion: Schema.Number;
+  readonly actualVersion: Schema.Number;
+}>, effect_Cause0.YieldableError>;
 /**
  * Version conflict error — snapshot version doesn't match expected
  */
 declare class VersionConflictError extends VersionConflictError_base {}
-declare const PersistenceAdapterTag_base: Context.TagClass<PersistenceAdapterTag, "effect-machine/src/persistence/adapter/PersistenceAdapterTag", PersistenceAdapter>;
+declare const PersistenceAdapterTag_base: ServiceMap.ServiceClass<PersistenceAdapterTag, "effect-machine/src/persistence/adapter/PersistenceAdapterTag", PersistenceAdapter>;
 /**
  * PersistenceAdapter service tag
  */