effect-machine 0.17.0 → 0.18.0

package/dist/schema.js

@@ -4,7 +4,7 @@ import { Schema } from "effect";
 /**
 * Schema-first State/Event definitions for effect-machine.
 *
-* MachineSchema provides a single source of truth that combines:
+* `State` and `Event` provide one source of truth that combines:
 * - Schema for validation/serialization
 * - Variant constructors (like Data.taggedEnum)
 * - $is and $match helpers for pattern matching
@@ -19,6 +19,9 @@ import { Schema } from "effect";
 *   Pending: { orderId: Schema.String },
 *   Shipped: { trackingId: Schema.String },
 * })
+* const OrderEvent = Event({
+*   Ship: { trackingId: Schema.String },
+* })
 *
 * // Infer type from schema
 * type OrderState = typeof OrderState.Type
@@ -32,17 +35,24 @@ import { Schema } from "effect";
 *   Shipped: (s) => `Shipped: ${s.trackingId}`,
 * })
 *
-* // Use as Schema for persistence/cluster
-* machine.pipe(Machine.persist({ stateSchema: OrderState, ... }))
+* // Use the schemas to define a machine
+* const machine = Machine.make({
+*   state: OrderState,
+*   event: OrderEvent,
+*   initial: pending,
+* })
 * ```
 *
 * @module
 */
 const ReplySchemaSymbol = Symbol.for("effect-machine/ReplySchema");
+const replySchemaRegistry = /* @__PURE__ */ new WeakMap();
+/** @internal */
+const getReplySchemas = (schema) => replySchemaRegistry.get(schema);
 /**
 * Build a schema-first definition from a record of tag -> fields
 */
-const RESERVED_DERIVE_KEYS = new Set(["_tag"]);
+const RESERVED_DERIVE_KEYS = /* @__PURE__ */ new Set(["_tag"]);
 const buildMachineSchema = (definition) => {
 	const variants = {};
 	const constructors = {};
@@ -79,20 +89,22 @@ const buildMachineSchema = (definition) => {
 		};
 	}
 	const variantArray = Object.values(variants);
-	if (variantArray.length === 0) throw new InvalidSchemaError({ message: "Schema must have at least one variant" });
-	const unionSchema = variantArray.length === 1 ? variantArray[0] : Schema.Union(variantArray);
+	if (variantArray.length === 0) throw InvalidSchemaError.make({ message: "Schema must have at least one variant" });
+	let unionSchema;
+	if (variantArray.length === 1) unionSchema = variantArray[0];
+	else unionSchema = Schema.Union(variantArray);
 	const $is = (tag) => (u) => typeof u === "object" && u !== null && "_tag" in u && u._tag === tag;
 	const $match = (valueOrCases, maybeCases) => {
 		if (maybeCases !== void 0) {
 			const value = valueOrCases;
 			const handler = maybeCases[value._tag];
-			if (handler === void 0) throw new MissingMatchHandlerError({ tag: value._tag });
+			if (handler === void 0) throw MissingMatchHandlerError.make({ tag: value._tag });
 			return handler(value);
 		}
 		const cases = valueOrCases;
 		return (value) => {
 			const handler = cases[value._tag];
-			if (handler === void 0) throw new MissingMatchHandlerError({ tag: value._tag });
+			if (handler === void 0) throw MissingMatchHandlerError.make({ tag: value._tag });
 			return handler(value);
 		};
 	};
@@ -100,7 +112,6 @@ const buildMachineSchema = (definition) => {
 		schema: unionSchema,
 		variants,
 		constructors,
-		_definition: definition,
 		replySchemas,
 		$is,
 		$match
@@ -111,24 +122,23 @@ const buildMachineSchema = (definition) => {
 * Builds the schema object with variants, constructors, $is, and $match.
 */
 const createMachineSchema = (definition) => {
-	const { schema, variants, constructors, _definition, replySchemas, $is, $match } = buildMachineSchema(definition);
+	const { schema, variants, constructors, replySchemas, $is, $match } = buildMachineSchema(definition);
 	const withFn = (source, partial) => {
 		const ctor = constructors[source._tag];
-		if (ctor === void 0) throw new MissingMatchHandlerError({ tag: source._tag });
+		if (ctor === void 0) throw MissingMatchHandlerError.make({ tag: source._tag });
 		const fn = ctor.with;
-		if (fn === void 0) throw new MissingMatchHandlerError({ tag: source._tag });
+		if (fn === void 0) throw MissingMatchHandlerError.make({ tag: source._tag });
 		return fn(source, partial);
 	};
-	return Object.assign(Object.create(schema), {
+	const machineSchema = Object.assign(Object.create(schema), {
 		variants,
-		_definition,
-		_replySchemas: replySchemas,
-		schema,
 		$is,
 		$match,
 		with: withFn,
 		...constructors
 	});
+	replySchemaRegistry.set(machineSchema, replySchemas);
+	return machineSchema;
 };
 /**
 * Create a schema-first State definition.
@@ -139,7 +149,7 @@ const createMachineSchema = (definition) => {
 *
 * @example
 * ```ts
-* const OrderState = MachineSchema.State({
+* const OrderState = State({
 *   Pending: { orderId: Schema.String },
 *   Shipped: { trackingId: Schema.String },
 * })
@@ -203,4 +213,4 @@ const replyFieldsFn = (fields, replySchema) => {
 };
 const Event = Object.assign(EventImpl, { reply: replyFieldsFn });
 //#endregion
-export { Event, State };
+export { Event, State, getReplySchemas };

package/dist/supervision.d.ts

@@ -1,5 +1,4 @@
 import { Cause, Duration, Schedule } from "effect";
-
 //#region src/supervision.d.ts
 /**
  * Where in the actor lifecycle a defect occurred.
@@ -33,28 +32,6 @@ declare const ActorExit: {
   readonly Stopped: ActorExit<never>;
   readonly Defect: <S = never>(cause: Cause.Cause<unknown>, phase: DefectPhase) => ActorExit<S>;
 };
-/**
- * Phase state for supervised actors. Serializes concurrent stop/restart/drain.
- *
- * Transitions:
- * - `Running` → crash → `Restarting` → new runtime → `Running`
- * - `Running` → explicit stop/drain → `Stopping` → `Terminated`
- * - `Restarting` → explicit stop → `Stopping` → `Terminated`
- *
- * @internal
- */
-type CellPhase<S> = {
-  readonly _tag: "Running";
-  readonly generation: number;
-} | {
-  readonly _tag: "Restarting";
-  readonly generation: number;
-} | {
-  readonly _tag: "Stopping";
-} | {
-  readonly _tag: "Terminated";
-  readonly exit: ActorExit<S>;
-};
 declare namespace Supervision {
   /**
    * Supervision policy for actor restart behavior.
@@ -94,4 +71,4 @@ declare namespace Supervision {
   }) => Policy;
 }
 //#endregion
-export { ActorExit, CellPhase, DefectPhase, Supervision };
+export { ActorExit, DefectPhase, Supervision };

package/dist/supervision.js

@@ -7,7 +7,6 @@ import { Schedule } from "effect";
 * - `ActorExit<S>` — why an actor stopped (final, explicit stop, or defect)
 * - `DefectPhase` — where in the lifecycle a defect occurred
 * - `Supervision.Policy` — Schedule-based restart policy
-* - `CellPhase<S>` — internal phase machine for serializing stop/restart/drain
 *
 * @module
 */
@@ -31,10 +30,10 @@ let Supervision;
 		let schedule = Schedule.forever;
 		if (options?.maxRestarts !== void 0) {
 			const recurs = Schedule.recurs(options.maxRestarts);
-			if (options.within !== void 0) schedule = Schedule.both(recurs, Schedule.windowed(options.within));
+			if (options.within !== void 0) schedule = Schedule.min([recurs, Schedule.windowed(options.within)]);
 			else schedule = recurs;
 		}
-		if (options?.backoff !== void 0) schedule = Schedule.both(schedule, options.backoff);
+		if (options?.backoff !== void 0) schedule = Schedule.min([schedule, options.backoff]);
 		return { schedule };
 	};
 })(Supervision || (Supervision = {}));

package/dist/testing.d.ts

@@ -1,10 +1,8 @@
 import { AssertionError } from "./errors.js";
-import { MachineContextTag, ProvideSlots, SlotsDef } from "./slot.js";
 import { Machine } from "./machine.js";
 import { Effect, SubscriptionRef } from "effect";
-
 //#region src/testing.d.ts
-type MachineInput<S, E, R, SD extends SlotsDef = Record<string, never>> = Machine<S, E, R, any, any, SD>;
+type MachineInput<S, E, R> = Machine<S, E, R, any, any>;
 /**
  * Result of simulating events through a machine
  */
@@ -15,8 +13,7 @@ interface SimulationResult<S> {
 /**
  * Simulate a sequence of events through a machine without running an actor.
  * Useful for testing state transitions in isolation.
- * Does not run onEnter/spawn/background effects, but does run slots
- * within transition handlers.
+ * Does not run task, spawn, or background effects.
  *
  * @example
  * ```ts
@@ -36,12 +33,10 @@ declare const simulate: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, events: readonly E[], options?: {
-  slots?: ProvideSlots<SD, any>;
-} | undefined) => Effect.Effect<{
+}, R>(input: MachineInput<S, E, R>, events: readonly E[]) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, never, Exclude<R, MachineContextTag>>;
+}, never, never>;
 /**
  * Assert that a machine can reach a specific state given a sequence of events
  */
@@ -49,9 +44,7 @@ declare const assertReaches: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, events: readonly E[], expectedTag: string, options?: {
-  slots?: ProvideSlots<SD, any>;
-} | undefined) => Effect.Effect<S, AssertionError, Exclude<R, MachineContextTag>>;
+}, R>(input: MachineInput<S, E, R>, events: readonly E[], expectedTag: string) => Effect.Effect<S, AssertionError, never>;
 /**
  * Assert that a machine follows a specific path of state tags
  *
@@ -68,12 +61,10 @@ declare const assertPath: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, events: readonly E[], expectedPath: readonly string[], options?: {
-  slots?: ProvideSlots<SD, any>;
-} | undefined) => Effect.Effect<{
+}, R>(input: MachineInput<S, E, R>, events: readonly E[], expectedPath: readonly string[]) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, AssertionError, Exclude<R, MachineContextTag>>;
+}, AssertionError, never>;
 /**
  * Assert that a machine never reaches a specific state given a sequence of events
  *
@@ -91,36 +82,31 @@ declare const assertNeverReaches: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, events: readonly E[], forbiddenTag: string, options?: {
-  slots?: ProvideSlots<SD, any>;
-} | undefined) => Effect.Effect<{
+}, R>(input: MachineInput<S, E, R>, events: readonly E[], forbiddenTag: string) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, AssertionError, Exclude<R, MachineContextTag>>;
+}, AssertionError, never>;
 /**
  * Create a controllable test harness for a machine
  */
-interface TestHarness<S, E, R> {
+interface TestHarness<S, E> {
   readonly state: SubscriptionRef.SubscriptionRef<S>;
-  readonly send: (event: E) => Effect.Effect<S, never, R>;
+  readonly send: (event: E) => Effect.Effect<S>;
   readonly getState: Effect.Effect<S>;
 }
 /**
  * Options for creating a test harness
  */
-interface TestHarnessOptions<S, E, SD extends SlotsDef = Record<string, never>> {
+interface TestHarnessOptions<S, E> {
   /**
    * Called after each transition with the previous state, event, and new state.
    * Useful for logging or spying on transitions.
    */
   readonly onTransition?: (from: S, event: E, to: S) => void;
-  /** Slot handler implementations. */
-  readonly slots?: ProvideSlots<SD, any>;
 }
 /**
  * Create a test harness for step-by-step testing.
- * Does not run onEnter/spawn/background effects, but does run slots
- * within transition handlers.
+ * Does not run task, spawn, or background effects.
  *
  * @example Basic usage
  * ```ts
@@ -142,9 +128,9 @@ declare const createTestHarness: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, options?: TestHarnessOptions<S, E, SD> | undefined) => Effect.Effect<{
+}, R>(input: MachineInput<S, E, R>, options?: TestHarnessOptions<S, E> | undefined) => Effect.Effect<{
   state: SubscriptionRef.SubscriptionRef<S>;
-  send: (event: E) => Effect.Effect<S, never, Exclude<R, MachineContextTag>>;
+  send: (event: E) => Effect.Effect<S, never, never>;
   getState: Effect.Effect<S, never, never>;
 }, never, never>;
 //#endregion

package/dist/testing.js

@@ -1,23 +1,13 @@
-import { stubSystem } from "./internal/utils.js";
+import { isEffect } from "./internal/utils.js";
 import { AssertionError } from "./errors.js";
-import { executeTransition, shouldPostpone } from "./internal/transition.js";
-import { materializeMachine } from "./machine.js";
+import { makeEventAdvancement } from "./internal/event-advancement.js";
+import { executeTransition, executeTransitionImmediate, shouldPostpone } from "./internal/transition.js";
 import { Effect, SubscriptionRef } from "effect";
 //#region src/testing.ts
-const makeDummySelf = (label) => {
-	const dummySend = Effect.fn(label)((_event) => Effect.void);
-	return {
-		send: dummySend,
-		cast: dummySend,
-		spawn: () => Effect.die(`spawn not supported in ${label}`),
-		reply: () => Effect.succeed(false)
-	};
-};
 /**
 * Simulate a sequence of events through a machine without running an actor.
 * Useful for testing state transitions in isolation.
-* Does not run onEnter/spawn/background effects, but does run slots
-* within transition handlers.
+* Does not run task, spawn, or background effects.
 *
 * @example
 * ```ts
@@ -33,53 +23,58 @@ const makeDummySelf = (label) => {
 * expect(result.states).toHaveLength(3) // Idle -> Loading -> Success
 * ```
 */
-const simulate = Effect.fn("effect-machine.simulate")(function* (input, events, options) {
-	const machine = materializeMachine(input, options?.slots);
-	const dummySelf = makeDummySelf("effect-machine.testing.simulate");
-	let currentState = machine.initial;
-	const states = [currentState];
-	const hasPostponeRules = machine.postponeRules.length > 0;
-	const postponed = [];
-	for (const event of events) {
-		if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
-			postponed.push(event);
-			continue;
-		}
-		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "simulation");
-		if (!result.transitioned) continue;
-		const prevTag = currentState._tag;
-		currentState = result.newState;
-		states.push(currentState);
-		if (machine.finalStates.has(currentState._tag)) break;
-		let drainTag = prevTag;
-		while (currentState._tag !== drainTag && postponed.length > 0) {
-			drainTag = currentState._tag;
-			const drained = postponed.splice(0);
-			for (const postponedEvent of drained) {
-				if (shouldPostpone(machine, currentState._tag, postponedEvent._tag)) {
-					postponed.push(postponedEvent);
-					continue;
-				}
-				const drainResult = yield* executeTransition(machine, currentState, postponedEvent, dummySelf, stubSystem, "simulation");
-				if (drainResult.transitioned) {
-					currentState = drainResult.newState;
-					states.push(currentState);
-					if (machine.finalStates.has(currentState._tag)) break;
-				}
+const simulate = Effect.fn("effect-machine.simulate")(function* (input, events) {
+	const machine = input;
+	const states = [machine.initial];
+	if (!machine._hasPostponeRules()) {
+		let state = machine.initial;
+		for (const event of events) {
+			if (machine._isFinal(state._tag)) break;
+			const execution = executeTransitionImmediate(machine, state, event);
+			let result;
+			if (isEffect(execution)) result = yield* execution;
+			else result = execution;
+			if (result.transitioned) {
+				state = result.newState;
+				states.push(state);
 			}
 		}
+		return {
+			states,
+			finalState: state
+		};
 	}
+	const advancement = makeEventAdvancement({
+		initial: machine.initial,
+		isFinal: (state) => machine._isFinal(state._tag),
+		shouldPostpone: (state, event) => shouldPostpone(machine, state._tag, event._tag),
+		postpone: (_state, event) => Effect.succeed({
+			input: event,
+			value: void 0
+		}),
+		process: (state, event) => executeTransition(machine, state, event).pipe(Effect.map((result) => {
+			if (result.transitioned) states.push(result.newState);
+			return {
+				state: result.newState,
+				transitioned: result.transitioned,
+				stateChanged: result.transitioned && (result.newState._tag !== state._tag || result.reenter),
+				shouldStop: result.transitioned && machine._isFinal(result.newState._tag),
+				value: void 0
+			};
+		}))
+	});
+	for (const event of events) yield* advancement.advance(event);
 	return {
 		states,
-		finalState: currentState
+		finalState: advancement.state
 	};
 });
 /**
 * Assert that a machine can reach a specific state given a sequence of events
 */
-const assertReaches = Effect.fn("effect-machine.assertReaches")(function* (input, events, expectedTag, options) {
-	const result = yield* simulate(input, events, options);
-	if (result.finalState._tag !== expectedTag) return yield* new AssertionError({ message: `Expected final state "${expectedTag}" but got "${result.finalState._tag}". States visited: ${result.states.map((s) => s._tag).join(" -> ")}` });
+const assertReaches = Effect.fn("effect-machine.assertReaches")(function* (input, events, expectedTag) {
+	const result = yield* simulate(input, events);
+	if (result.finalState._tag !== expectedTag) return yield* AssertionError.make({ message: `Expected final state "${expectedTag}" but got "${result.finalState._tag}". States visited: ${result.states.map((s) => s._tag).join(" -> ")}` });
 	return result.finalState;
 });
 /**
@@ -94,11 +89,11 @@ const assertReaches = Effect.fn("effect-machine.assertReaches")(function* (input
 * )
 * ```
 */
-const assertPath = Effect.fn("effect-machine.assertPath")(function* (input, events, expectedPath, options) {
-	const result = yield* simulate(input, events, options);
+const assertPath = Effect.fn("effect-machine.assertPath")(function* (input, events, expectedPath) {
+	const result = yield* simulate(input, events);
 	const actualPath = result.states.map((s) => s._tag);
-	if (actualPath.length !== expectedPath.length) return yield* new AssertionError({ message: `Path length mismatch. Expected ${expectedPath.length} states but got ${actualPath.length}.\nExpected: ${expectedPath.join(" -> ")}\nActual:   ${actualPath.join(" -> ")}` });
-	for (let i = 0; i < expectedPath.length; i++) if (actualPath[i] !== expectedPath[i]) return yield* new AssertionError({ message: `Path mismatch at position ${i}. Expected "${expectedPath[i]}" but got "${actualPath[i]}".\nExpected: ${expectedPath.join(" -> ")}\nActual:   ${actualPath.join(" -> ")}` });
+	if (actualPath.length !== expectedPath.length) return yield* AssertionError.make({ message: `Path length mismatch. Expected ${expectedPath.length} states but got ${actualPath.length}.\nExpected: ${expectedPath.join(" -> ")}\nActual:   ${actualPath.join(" -> ")}` });
+	for (let i = 0; i < expectedPath.length; i++) if (actualPath[i] !== expectedPath[i]) return yield* AssertionError.make({ message: `Path mismatch at position ${i}. Expected "${expectedPath[i]}" but got "${actualPath[i]}".\nExpected: ${expectedPath.join(" -> ")}\nActual:   ${actualPath.join(" -> ")}` });
 	return result;
 });
 /**
@@ -114,16 +109,15 @@ const assertPath = Effect.fn("effect-machine.assertPath")(function* (input, even
 * )
 * ```
 */
-const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(function* (input, events, forbiddenTag, options) {
-	const result = yield* simulate(input, events, options);
+const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(function* (input, events, forbiddenTag) {
+	const result = yield* simulate(input, events);
 	const visitedIndex = result.states.findIndex((s) => s._tag === forbiddenTag);
-	if (visitedIndex !== -1) return yield* new AssertionError({ message: `Machine reached forbidden state "${forbiddenTag}" at position ${visitedIndex}.\nStates visited: ${result.states.map((s) => s._tag).join(" -> ")}` });
+	if (visitedIndex !== -1) return yield* AssertionError.make({ message: `Machine reached forbidden state "${forbiddenTag}" at position ${visitedIndex}.\nStates visited: ${result.states.map((s) => s._tag).join(" -> ")}` });
 	return result;
 });
 /**
 * Create a test harness for step-by-step testing.
-* Does not run onEnter/spawn/background effects, but does run slots
-* within transition handlers.
+* Does not run task, spawn, or background effects.
 *
 * @example Basic usage
 * ```ts
@@ -142,45 +136,32 @@ const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(functi
 * ```
 */
 const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function* (input, options) {
-	const machine = materializeMachine(input, options?.slots);
-	const dummySelf = makeDummySelf("effect-machine.testing.harness");
+	const machine = input;
 	const stateRef = yield* SubscriptionRef.make(machine.initial);
-	const hasPostponeRules = machine.postponeRules.length > 0;
-	const postponed = [];
+	const advancement = makeEventAdvancement({
+		initial: machine.initial,
+		isFinal: (state) => machine._isFinal(state._tag),
+		shouldPostpone: (state, event) => shouldPostpone(machine, state._tag, event._tag),
+		postpone: (state, event) => Effect.succeed({
+			input: event,
+			value: state
+		}),
+		process: (state, event) => executeTransition(machine, state, event).pipe(Effect.map((result) => ({
+			state: result.newState,
+			transitioned: result.transitioned,
+			stateChanged: result.transitioned && (result.newState._tag !== state._tag || result.reenter),
+			shouldStop: result.transitioned && machine._isFinal(result.newState._tag),
+			value: result.newState
+		}))),
+		commit: (state, event, step) => {
+			if (!step.transitioned) return Effect.void;
+			return SubscriptionRef.set(stateRef, step.state).pipe(Effect.tap(() => Effect.sync(() => options?.onTransition?.(state, event, step.state))));
+		}
+	});
 	return {
 		state: stateRef,
 		send: Effect.fn("effect-machine.testHarness.send")(function* (event) {
-			const currentState = yield* SubscriptionRef.get(stateRef);
-			if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
-				postponed.push(event);
-				return currentState;
-			}
-			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem, "test-harness");
-			if (!result.transitioned) return currentState;
-			const prevTag = currentState._tag;
-			const newState = result.newState;
-			yield* SubscriptionRef.set(stateRef, newState);
-			if (options?.onTransition !== void 0) options.onTransition(currentState, event, newState);
-			let drainTag = prevTag;
-			let currentTag = newState._tag;
-			while (currentTag !== drainTag && postponed.length > 0) {
-				drainTag = currentTag;
-				const drained = postponed.splice(0);
-				for (const postponedEvent of drained) {
-					const state = yield* SubscriptionRef.get(stateRef);
-					if (shouldPostpone(machine, state._tag, postponedEvent._tag)) {
-						postponed.push(postponedEvent);
-						continue;
-					}
-					const drainResult = yield* executeTransition(machine, state, postponedEvent, dummySelf, stubSystem, "test-harness");
-					if (drainResult.transitioned) {
-						yield* SubscriptionRef.set(stateRef, drainResult.newState);
-						currentTag = drainResult.newState._tag;
-						if (options?.onTransition !== void 0) options.onTransition(state, postponedEvent, drainResult.newState);
-					}
-				}
-			}
-			return newState;
+			return (yield* advancement.advance(event)).state;
 		}),
 		getState: SubscriptionRef.get(stateRef)
 	};

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "effect-machine",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
   },
   "files": [
-    "dist",
-    "v3/dist"
+    "dist"
   ],
   "type": "module",
   "exports": {
@@ -22,61 +21,43 @@
         "types": "./dist/cluster/index.d.ts",
         "default": "./dist/cluster/index.js"
       }
-    },
-    "./v3": {
-      "import": {
-        "types": "./v3/dist/index.d.ts",
-        "default": "./v3/dist/index.js"
-      }
-    },
-    "./v3/cluster": {
-      "import": {
-        "types": "./v3/dist/cluster/index.d.ts",
-        "default": "./v3/dist/cluster/index.js"
-      }
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "typecheck": "concurrently -n v4,v3 -c blue,magenta \"tsgo --noEmit\" \"bun run typecheck:v3\"",
-    "typecheck:v3": "tsgo --noEmit -p v3/tsconfig.json",
+    "typecheck": "tsc --noEmit",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "test": "bun test --tsconfig-override=tsconfig.json",
-    "test:v3": "cd v3 && bun test --tsconfig-override=tsconfig.json ./test/",
     "test:watch": "bun test --watch",
-    "test:all": "bun run test && bun run test:v3",
-    "gate": "concurrently -n type,lint,fmt,test,build -c blue,yellow,magenta,green,cyan \"bun run typecheck\" \"bun run lint:fix\" \"bun run fmt\" \"bun run test:all\" \"bun run build\"",
+    "bench": "bun benchmark/core.ts",
+    "gate": "concurrently -n type,lint,fmt,test,build -c blue,yellow,magenta,green,cyan \"bun run typecheck\" \"bun run lint:fix\" \"bun run fmt\" \"bun run test\" \"bun run build\"",
     "prepare": "lefthook install && effect-tsgo patch",
     "version": "changeset version",
-    "build": "concurrently -n v4,v3 -c cyan,magenta \"tsdown\" \"tsdown --config v3/tsdown.config.ts\"",
+    "build": "bun --bun tsdown",
     "release": "bun run build && changeset publish"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.6.0",
-    "@changesets/cli": "^2.30.0",
-    "@effect/cluster": "0.58.2",
-    "@effect/rpc": "0.75.1",
-    "@effect/tsgo": "0.5.2",
-    "@types/bun": "1.3.12",
-    "@typescript/native-preview": "7.0.0-dev.20260507.1",
-    "concurrently": "^9.2.1",
-    "effect": "4.0.0-beta.63",
+    "@changesets/changelog-github": "1.0.0",
+    "@changesets/cli": "3.0.1",
+    "@effect/tsgo": "0.38.0",
+    "@types/bun": "1.4.0",
+    "concurrently": "10.0.5",
+    "effect": "4.0.0-rc.112",
     "effect-bun-test": "0.3.0",
-    "effect-v3": "npm:effect@3.21.2",
-    "lefthook": "^2.1.5",
-    "oxfmt": "^0.44.0",
-    "oxlint": "^1.63.0",
-    "oxlint-tsgolint": "^0.22.1",
-    "tsdown": "^0.21.7",
-    "typescript": "^6.0.2"
+    "lefthook": "2.1.12",
+    "oxfmt": "0.65.0",
+    "oxlint": "1.80.0",
+    "oxlint-plugin-effect": "0.11.0",
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2"
   },
   "peerDependencies": {
-    "effect": ">=4.0.0-beta.63"
+    "effect": ">=4.0.0-rc.112 <5"
   },
   "peerDependenciesMeta": {
     "effect": {