effect-machine 0.4.0 → 0.7.0

package/dist-v3/schema.js

@@ -0,0 +1,165 @@
+import { InvalidSchemaError, MissingMatchHandlerError } from "./errors.js";
+import { Schema } from "effect";
+
+//#region src-v3/schema.ts
+/**
+* Schema-first State/Event definitions for effect-machine.
+*
+* MachineSchema provides a single source of truth that combines:
+* - Schema for validation/serialization
+* - Variant constructors (like Data.taggedEnum)
+* - $is and $match helpers for pattern matching
+* - Brand integration for compile-time safety
+*
+* @example
+* ```ts
+* import { State, Event, Machine } from "effect-machine"
+*
+* // Define schema-first state
+* const OrderState = State({
+*   Pending: { orderId: Schema.String },
+*   Shipped: { trackingId: Schema.String },
+* })
+*
+* // Infer type from schema
+* type OrderState = typeof OrderState.Type
+*
+* // Use constructors
+* const pending = OrderState.Pending({ orderId: "123" })
+*
+* // Pattern match
+* OrderState.$match(state, {
+*   Pending: (s) => `Order ${s.orderId} pending`,
+*   Shipped: (s) => `Shipped: ${s.trackingId}`,
+* })
+*
+* // Use as Schema for persistence/cluster
+* machine.pipe(Machine.persist({ stateSchema: OrderState, ... }))
+* ```
+*
+* @module
+*/
+/**
+* Build a schema-first definition from a record of tag -> fields
+*/
+const buildMachineSchema = (definition) => {
+	const variants = {};
+	const constructors = {};
+	for (const tag of Object.keys(definition)) {
+		const fields = definition[tag];
+		if (fields === void 0) continue;
+		variants[tag] = Schema.TaggedStruct(tag, fields);
+		const fieldNames = new Set(Object.keys(fields));
+		if (fieldNames.size > 0) {
+			const constructor = (args) => ({
+				...args,
+				_tag: tag
+			});
+			constructor._tag = tag;
+			constructor.derive = (source, partial) => {
+				const result = { _tag: tag };
+				for (const key of fieldNames) if (key in source) result[key] = source[key];
+				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) result[key] = value;
+				return result;
+			};
+			constructors[tag] = constructor;
+		} else constructors[tag] = {
+			_tag: tag,
+			derive: () => ({ _tag: tag })
+		};
+	}
+	const variantArray = Object.values(variants);
+	if (variantArray.length === 0) throw new InvalidSchemaError();
+	const unionSchema = variantArray.length === 1 ? variantArray[0] : 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 });
+			return handler(value);
+		}
+		const cases = valueOrCases;
+		return (value) => {
+			const handler = cases[value._tag];
+			if (handler === void 0) throw new MissingMatchHandlerError({ tag: value._tag });
+			return handler(value);
+		};
+	};
+	return {
+		schema: unionSchema,
+		variants,
+		constructors,
+		_definition: definition,
+		$is,
+		$match
+	};
+};
+/**
+* Internal helper to create a machine schema (shared by State and Event).
+* Builds the schema object with variants, constructors, $is, and $match.
+*/
+const createMachineSchema = (definition) => {
+	const { schema, variants, constructors, _definition, $is, $match } = buildMachineSchema(definition);
+	return Object.assign(Object.create(schema), {
+		variants,
+		_definition,
+		$is,
+		$match,
+		...constructors
+	});
+};
+/**
+* Create a schema-first State definition.
+*
+* The schema's definition type D creates a unique brand, preventing
+* accidental use of constructors from different state schemas
+* (unless they have identical definitions).
+*
+* @example
+* ```ts
+* const OrderState = MachineSchema.State({
+*   Pending: { orderId: Schema.String },
+*   Shipped: { trackingId: Schema.String },
+* })
+*
+* type OrderState = typeof OrderState.Type
+*
+* // Construct
+* const s = OrderState.Pending({ orderId: "123" })
+*
+* // Pattern match
+* OrderState.$match(s, {
+*   Pending: (v) => v.orderId,
+*   Shipped: (v) => v.trackingId,
+* })
+*
+* // Validate
+* Schema.decodeUnknownSync(OrderState)(rawJson)
+* ```
+*/
+const State = (definition) => createMachineSchema(definition);
+/**
+* Create a schema-first Event definition.
+*
+* The schema's definition type D creates a unique brand, preventing
+* accidental use of constructors from different event schemas
+* (unless they have identical definitions).
+*
+* @example
+* ```ts
+* const OrderEvent = MachineSchema.Event({
+*   Ship: { trackingId: Schema.String },
+*   Cancel: {},
+* })
+*
+* type OrderEvent = typeof OrderEvent.Type
+*
+* // Construct
+* const e = OrderEvent.Ship({ trackingId: "abc" })
+* ```
+*/
+const Event = (definition) => createMachineSchema(definition);
+
+//#endregion
+export { Event, State };

package/dist-v3/slot.d.ts

@@ -0,0 +1,130 @@
+import { ActorSystem } from "./actor.js";
+import { Effect, Schema } from "effect";
+
+//#region src-v3/slot.d.ts
+/** Schema fields definition (like Schema.Struct.Fields) */
+type Fields = Record<string, Schema.Schema.All>;
+/** Extract the encoded type from schema fields (used for parameters) */
+type FieldsToParams<F extends Fields> = keyof F extends never ? void : Schema.Schema.Type<Schema.Struct<F>>;
+/**
+ * A guard slot - callable function that returns Effect<boolean>.
+ */
+interface GuardSlot<Name extends string, Params> {
+  readonly _tag: "GuardSlot";
+  readonly name: Name;
+  (params: Params): Effect.Effect<boolean>;
+}
+/**
+ * An effect slot - callable function that returns Effect<void>.
+ */
+interface EffectSlot<Name extends string, Params> {
+  readonly _tag: "EffectSlot";
+  readonly name: Name;
+  (params: Params): Effect.Effect<void>;
+}
+/**
+ * Guard definition - name to schema fields mapping
+ */
+type GuardsDef = Record<string, Fields>;
+/**
+ * Effect definition - name to schema fields mapping
+ */
+type EffectsDef = Record<string, Fields>;
+/**
+ * Convert guard definitions to callable guard slots
+ */
+type GuardSlots<D extends GuardsDef> = { readonly [K in keyof D & string]: GuardSlot<K, FieldsToParams<D[K]>> };
+/**
+ * Convert effect definitions to callable effect slots
+ */
+type EffectSlots<D extends EffectsDef> = { readonly [K in keyof D & string]: EffectSlot<K, FieldsToParams<D[K]>> };
+/**
+ * Type for machine context - state, event, and self reference.
+ * Shared across all machines via MachineContextTag.
+ */
+interface MachineContext<State, Event, Self> {
+  readonly state: State;
+  readonly event: Event;
+  readonly self: Self;
+  readonly system: ActorSystem;
+}
+/**
+ * Shared Context tag for all machines.
+ * Single module-level tag instead of per-machine allocation.
+ * @internal
+ */
+declare const MachineContextTag: any;
+/**
+ * Guard handler implementation.
+ * Receives params and context, returns Effect<boolean>.
+ */
+type GuardHandler<Params, Ctx, R = never> = (params: Params, ctx: Ctx) => boolean | Effect.Effect<boolean, never, R>;
+/**
+ * Effect handler implementation.
+ * Receives params and context, returns Effect<void>.
+ */
+type EffectHandler<Params, Ctx, R = never> = (params: Params, ctx: Ctx) => Effect.Effect<void, never, R>;
+/**
+ * Handler types for all guards in a definition
+ */
+type GuardHandlers<D extends GuardsDef, MachineCtx, R = never> = { readonly [K in keyof D & string]: GuardHandler<FieldsToParams<D[K]>, MachineCtx, R> };
+/**
+ * Handler types for all effects in a definition
+ */
+type EffectHandlers<D extends EffectsDef, MachineCtx, R = never> = { readonly [K in keyof D & string]: EffectHandler<FieldsToParams<D[K]>, MachineCtx, R> };
+/**
+ * Guards schema - returned by Slot.Guards()
+ */
+interface GuardsSchema<D extends GuardsDef> {
+  readonly _tag: "GuardsSchema";
+  readonly definitions: D;
+  /** Create callable guard slots (used by Machine internally) */
+  readonly _createSlots: (resolve: <N extends keyof D & string>(name: N, params: FieldsToParams<D[N]>) => Effect.Effect<boolean>) => GuardSlots<D>;
+}
+/**
+ * Effects schema - returned by Slot.Effects()
+ */
+interface EffectsSchema<D extends EffectsDef> {
+  readonly _tag: "EffectsSchema";
+  readonly definitions: D;
+  /** Create callable effect slots (used by Machine internally) */
+  readonly _createSlots: (resolve: <N extends keyof D & string>(name: N, params: FieldsToParams<D[N]>) => Effect.Effect<void>) => EffectSlots<D>;
+}
+/**
+ * Create a guards schema with parameterized guard definitions.
+ *
+ * @example
+ * ```ts
+ * const MyGuards = Slot.Guards({
+ *   canRetry: { max: Schema.Number },
+ *   isValid: {},
+ * })
+ * ```
+ */
+declare const Guards: <D extends GuardsDef>(definitions: D) => GuardsSchema<D>;
+/**
+ * Create an effects schema with parameterized effect definitions.
+ *
+ * @example
+ * ```ts
+ * const MyEffects = Slot.Effects({
+ *   fetchData: { url: Schema.String },
+ *   notify: { message: Schema.String },
+ * })
+ * ```
+ */
+declare const Effects: <D extends EffectsDef>(definitions: D) => EffectsSchema<D>;
+/** Extract guard definition type from GuardsSchema */
+type GuardsDefOf<G> = G extends GuardsSchema<infer D> ? D : never;
+/** Extract effect definition type from EffectsSchema */
+type EffectsDefOf<E> = E extends EffectsSchema<infer D> ? D : never;
+/** Extract guard slots type from GuardsSchema */
+type GuardSlotsOf<G> = G extends GuardsSchema<infer D> ? GuardSlots<D> : never;
+/** Extract effect slots type from EffectsSchema */
+type EffectSlotsOf<E> = E extends EffectsSchema<infer D> ? EffectSlots<D> : never;
+declare const Slot: {
+  readonly Guards: <D extends GuardsDef>(definitions: D) => GuardsSchema<D>;
+  readonly Effects: <D extends EffectsDef>(definitions: D) => EffectsSchema<D>;
+};
+//#endregion
+export { EffectHandler, EffectHandlers, EffectSlot, EffectSlots, EffectSlotsOf, Effects, EffectsDef, EffectsDefOf, EffectsSchema, GuardHandler, GuardHandlers, GuardSlot, GuardSlots, GuardSlotsOf, Guards, GuardsDef, GuardsDefOf, GuardsSchema, MachineContext, MachineContextTag, Slot };

package/dist-v3/slot.js

@@ -0,0 +1,99 @@
+import { Context } from "effect";
+
+//#region src-v3/slot.ts
+/**
+* Slot module - schema-based, parameterized guards and effects.
+*
+* Guards and Effects are defined with schemas for their parameters,
+* and provided implementations receive typed parameters plus machine context.
+*
+* @example
+* ```ts
+* import { Slot } from "effect-machine"
+* import { Schema } from "effect"
+*
+* const MyGuards = Slot.Guards({
+*   canRetry: { max: Schema.Number },
+*   isValid: {},  // no params
+* })
+*
+* const MyEffects = Slot.Effects({
+*   fetchData: { url: Schema.String },
+*   notify: { message: Schema.String },
+* })
+*
+* // Used in handlers:
+* .on(State.X, Event.Y, ({ guards, effects }) =>
+*   Effect.gen(function* () {
+*     if (yield* guards.canRetry({ max: 3 })) {
+*       yield* effects.fetchData({ url: "/api" })
+*       return State.Next
+*     }
+*     return state
+*   })
+* )
+* ```
+*
+* @module
+*/
+/**
+* Shared Context tag for all machines.
+* Single module-level tag instead of per-machine allocation.
+* @internal
+*/
+const MachineContextTag = Context.GenericTag("@effect-machine/Context");
+/**
+* Generic slot schema factory. Used internally by Guards() and Effects().
+* @internal
+*/
+const createSlotSchema = (tag, slotTag, definitions) => ({
+	_tag: tag,
+	definitions,
+	_createSlots: (resolve) => {
+		const slots = {};
+		for (const name of Object.keys(definitions)) {
+			const slot = (params) => resolve(name, params);
+			Object.defineProperty(slot, "_tag", {
+				value: slotTag,
+				enumerable: true
+			});
+			Object.defineProperty(slot, "name", {
+				value: name,
+				enumerable: true
+			});
+			slots[name] = slot;
+		}
+		return slots;
+	}
+});
+/**
+* Create a guards schema with parameterized guard definitions.
+*
+* @example
+* ```ts
+* const MyGuards = Slot.Guards({
+*   canRetry: { max: Schema.Number },
+*   isValid: {},
+* })
+* ```
+*/
+const Guards = (definitions) => createSlotSchema("GuardsSchema", "GuardSlot", definitions);
+/**
+* Create an effects schema with parameterized effect definitions.
+*
+* @example
+* ```ts
+* const MyEffects = Slot.Effects({
+*   fetchData: { url: Schema.String },
+*   notify: { message: Schema.String },
+* })
+* ```
+*/
+const Effects = (definitions) => createSlotSchema("EffectsSchema", "EffectSlot", definitions);
+const Slot = {
+	Guards,
+	Effects
+};
+
+//#endregion
+export { Effects, Guards, MachineContextTag, Slot };

package/dist-v3/testing.d.ts

@@ -0,0 +1,136 @@
+import { AssertionError } from "./errors.js";
+import { EffectsDef, GuardsDef } from "./slot.js";
+import { BuiltMachine, Machine } from "./machine.js";
+import { Effect, SubscriptionRef } from "effect";
+
+//#region src-v3/testing.d.ts
+/** Accept either Machine or BuiltMachine for testing utilities. */
+type MachineInput<S, E, R, GD extends GuardsDef, EFD extends EffectsDef> = Machine<S, E, R, any, any, GD, EFD> | BuiltMachine<S, E, R>;
+/**
+ * Result of simulating events through a machine
+ */
+interface SimulationResult<S> {
+  readonly states: ReadonlyArray<S>;
+  readonly finalState: 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 guard/effect slots
+ * within transition handlers.
+ *
+ * @example
+ * ```ts
+ * const result = yield* simulate(
+ *   fetcherMachine,
+ *   [
+ *     Event.Fetch({ url: "https://example.com" }),
+ *     Event._Done({ data: { foo: "bar" } })
+ *   ]
+ * )
+ *
+ * expect(result.finalState._tag).toBe("Success")
+ * expect(result.states).toHaveLength(3) // Idle -> Loading -> Success
+ * ```
+ */
+declare const simulate: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[]) => Effect.Effect<{
+  states: S[];
+  finalState: S;
+}, never, Exclude<R, unknown>>;
+/**
+ * Assert that a machine can reach a specific state given a sequence of events
+ */
+declare const assertReaches: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedTag: string) => Effect.Effect<any, unknown, unknown>;
+/**
+ * Assert that a machine follows a specific path of state tags
+ *
+ * @example
+ * ```ts
+ * yield* assertPath(
+ *   machine,
+ *   [Event.Start(), Event.Increment(), Event.Stop()],
+ *   ["Idle", "Counting", "Counting", "Done"]
+ * )
+ * ```
+ */
+declare const assertPath: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedPath: readonly string[]) => Effect.Effect<any, unknown, unknown>;
+/**
+ * Assert that a machine never reaches a specific state given a sequence of events
+ *
+ * @example
+ * ```ts
+ * // Verify error handling doesn't reach crash state
+ * yield* assertNeverReaches(
+ *   machine,
+ *   [Event.Error(), Event.Retry(), Event.Success()],
+ *   "Crashed"
+ * )
+ * ```
+ */
+declare const assertNeverReaches: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], forbiddenTag: string) => Effect.Effect<any, unknown, unknown>;
+/**
+ * Create a controllable test harness for a machine
+ */
+interface TestHarness<S, E, R> {
+  readonly state: SubscriptionRef.SubscriptionRef<S>;
+  readonly send: (event: E) => Effect.Effect<S, never, R>;
+  readonly getState: Effect.Effect<S>;
+}
+/**
+ * Options for creating a test harness
+ */
+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;
+}
+/**
+ * Create a test harness for step-by-step testing.
+ * Does not run onEnter/spawn/background effects, but does run guard/effect slots
+ * within transition handlers.
+ *
+ * @example Basic usage
+ * ```ts
+ * const harness = yield* createTestHarness(machine)
+ * yield* harness.send(Event.Start())
+ * const state = yield* harness.getState
+ * ```
+ *
+ * @example With transition observer
+ * ```ts
+ * const transitions: Array<{ from: string; event: string; to: string }> = []
+ * const harness = yield* createTestHarness(machine, {
+ *   onTransition: (from, event, to) =>
+ *     transitions.push({ from: from._tag, event: event._tag, to: to._tag })
+ * })
+ * ```
+ */
+declare const createTestHarness: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, options?: TestHarnessOptions<S, E> | undefined) => Effect.Effect<{
+  state: SubscriptionRef.SubscriptionRef<S>;
+  send: (event: E) => Effect.Effect<S, never, never>;
+  getState: Effect.Effect<S, never, never>;
+}, never, never>;
+//#endregion
+export { AssertionError, SimulationResult, TestHarness, TestHarnessOptions, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate };

package/dist-v3/testing.js

@@ -0,0 +1,138 @@
+import { stubSystem } from "./internal/utils.js";
+import { AssertionError } from "./errors.js";
+import { BuiltMachine } from "./machine.js";
+import { executeTransition } from "./internal/transition.js";
+import { Effect, SubscriptionRef } from "effect";
+
+//#region src-v3/testing.ts
+/**
+* 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 guard/effect slots
+* within transition handlers.
+*
+* @example
+* ```ts
+* const result = yield* simulate(
+*   fetcherMachine,
+*   [
+*     Event.Fetch({ url: "https://example.com" }),
+*     Event._Done({ data: { foo: "bar" } })
+*   ]
+* )
+*
+* expect(result.finalState._tag).toBe("Success")
+* expect(result.states).toHaveLength(3) // Idle -> Loading -> Success
+* ```
+*/
+const simulate = Effect.fn("effect-machine.simulate")(function* (input, events) {
+	const machine = input instanceof BuiltMachine ? input._inner : input;
+	const dummySelf = {
+		send: Effect.fn("effect-machine.testing.simulate.send")((_event) => Effect.void),
+		spawn: () => Effect.die("spawn not supported in simulation")
+	};
+	let currentState = machine.initial;
+	const states = [currentState];
+	for (const event of events) {
+		const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+		if (!result.transitioned) continue;
+		currentState = result.newState;
+		states.push(currentState);
+		if (machine.finalStates.has(currentState._tag)) break;
+	}
+	return {
+		states,
+		finalState: currentState
+	};
+});
+/**
+* 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) {
+	const result = yield* simulate(input, events);
+	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(" -> ")}` });
+	return result.finalState;
+});
+/**
+* Assert that a machine follows a specific path of state tags
+*
+* @example
+* ```ts
+* yield* assertPath(
+*   machine,
+*   [Event.Start(), Event.Increment(), Event.Stop()],
+*   ["Idle", "Counting", "Counting", "Done"]
+* )
+* ```
+*/
+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(" -> ")}` });
+	return result;
+});
+/**
+* Assert that a machine never reaches a specific state given a sequence of events
+*
+* @example
+* ```ts
+* // Verify error handling doesn't reach crash state
+* yield* assertNeverReaches(
+*   machine,
+*   [Event.Error(), Event.Retry(), Event.Success()],
+*   "Crashed"
+* )
+* ```
+*/
+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(" -> ")}` });
+	return result;
+});
+/**
+* Create a test harness for step-by-step testing.
+* Does not run onEnter/spawn/background effects, but does run guard/effect slots
+* within transition handlers.
+*
+* @example Basic usage
+* ```ts
+* const harness = yield* createTestHarness(machine)
+* yield* harness.send(Event.Start())
+* const state = yield* harness.getState
+* ```
+*
+* @example With transition observer
+* ```ts
+* const transitions: Array<{ from: string; event: string; to: string }> = []
+* const harness = yield* createTestHarness(machine, {
+*   onTransition: (from, event, to) =>
+*     transitions.push({ from: from._tag, event: event._tag, to: to._tag })
+* })
+* ```
+*/
+const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function* (input, options) {
+	const machine = input instanceof BuiltMachine ? input._inner : input;
+	const dummySelf = {
+		send: Effect.fn("effect-machine.testing.harness.send")((_event) => Effect.void),
+		spawn: () => Effect.die("spawn not supported in test harness")
+	};
+	const stateRef = yield* SubscriptionRef.make(machine.initial);
+	return {
+		state: stateRef,
+		send: Effect.fn("effect-machine.testHarness.send")(function* (event) {
+			const currentState = yield* SubscriptionRef.get(stateRef);
+			const result = yield* executeTransition(machine, currentState, event, dummySelf, stubSystem);
+			if (!result.transitioned) return currentState;
+			const newState = result.newState;
+			yield* SubscriptionRef.set(stateRef, newState);
+			if (options?.onTransition !== void 0) options.onTransition(currentState, event, newState);
+			return newState;
+		}),
+		getState: SubscriptionRef.get(stateRef)
+	};
+});
+
+//#endregion
+export { AssertionError, assertNeverReaches, assertPath, assertReaches, createTestHarness, simulate };