effect-machine 0.11.0 → 0.13.0

package/v3/dist/schema.d.ts

@@ -1,7 +1,17 @@
-import { FullEventBrand, FullStateBrand } from "./internal/brands.js";
+import { FullEventBrand, FullStateBrand, ReplyTypeBrand } from "./internal/brands.js";
 import { Schema } from "effect";
 
 //#region src/schema.d.ts
+declare const ReplySchemaSymbol: unique symbol;
+type ReplySchemaSymbol = typeof ReplySchemaSymbol;
+/**
+ * Fields annotated with a reply schema.
+ * Structurally identical to Schema.Struct.Fields at runtime,
+ * but carries the reply schema type at compile time.
+ */
+type ReplyFields<F extends Schema.Struct.Fields, RS extends Schema.Schema.Any> = F & {
+  readonly [ReplySchemaSymbol]: RS;
+};
 /**
  * Extract the TypeScript type from a TaggedStruct schema
  */
@@ -12,20 +22,23 @@ type TaggedStructType<Tag extends string, Fields extends Schema.Struct.Fields> =
 type VariantSchemas<D extends Record<string, Schema.Struct.Fields>> = { readonly [K in keyof D & string]: Schema.TaggedStruct<K, D[K]> };
 /**
  * Build union type from variant schemas.
- * Used for constraining fluent method type params.
+ * Reply-bearing variants carry ReplyTypeBrand<R> for ask() inference.
  */
-type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> }[keyof D & string];
+type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> & (D[K] extends {
+  readonly [ReplySchemaSymbol]: Schema.Schema<infer R, infer _I, infer _RR>;
+} ? ReplyTypeBrand<R> : unknown) }[keyof D & string];
 /**
- * Check if fields are empty (no required properties)
+ * Check if fields are empty (no required string properties).
+ * Symbol keys (like ReplySchemaSymbol) are metadata, not payload fields.
  */
-type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends never ? true : false;
+type IsEmptyFields<Fields extends Schema.Struct.Fields> = string & keyof Fields extends never ? true : false;
 /**
- * Constructor functions for each variant.
- * Empty structs: plain values with `_tag`: `State.Idle`
- * Non-empty structs require args: `State.Loading({ url })`
- *
- * Each variant also has a `derive` method for constructing from a source object.
+ * Resolve the reply brand for a variant's fields.
+ * If fields carry ReplySchemaSymbol, adds ReplyTypeBrand<R>.
  */
+type VariantReplyBrand<Fields extends Schema.Struct.Fields> = Fields extends {
+  readonly [ReplySchemaSymbol]: Schema.Schema<infer R, infer _I, infer _RR>;
+} ? ReplyTypeBrand<R> : unknown;
 /**
  * Constructor functions for each variant.
  * Empty structs: plain values with `_tag`: `State.Idle`
@@ -33,10 +46,11 @@ type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends n
  *
  * Each variant also has a `derive` method for constructing from a source object.
  * The source type uses `object` to accept branded state types without index signature issues.
+ * Reply-bearing variants carry ReplyTypeBrand<R> for ask() type inference.
  */
-type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & {
+type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]> & {
   readonly derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
-} : ((args: Schema.Struct.Constructor<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
+} : ((args: Schema.Struct.Constructor<D[K]>) => TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]>) & {
   readonly derive: (source: object, partial?: Partial<Schema.Struct.Constructor<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
   readonly _tag: K;
 } };
@@ -56,6 +70,11 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
    * Per-variant schemas for fine-grained operations
    */
   readonly variants: VariantSchemas<D>;
+  /**
+   * Reply schemas per variant tag. Only populated for event schemas
+   * with variants defined via `Event.reply()`.
+   */
+  readonly _replySchemas: ReadonlyMap<string, Schema.Schema.Any>;
   /**
    * Type guard: `OrderState.$is("Pending")(value)`
    */
@@ -116,26 +135,8 @@ type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema
  * ```
  */
 declare const State: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineStateSchema<D>;
-/**
- * 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" })
- * ```
- */
-declare const Event: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>;
+declare const Event: (<const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>) & {
+  reply: <F extends Schema.Struct.Fields, RS extends Schema.Schema.Any>(fields: F, replySchema: RS) => ReplyFields<F, RS>;
+};
 //#endregion
-export { Event, MachineEventSchema, MachineStateSchema, State, VariantsUnion };
+export { Event, MachineEventSchema, MachineStateSchema, ReplyFields, ReplySchemaSymbol, State, VariantsUnion };

package/v3/dist/schema.js

@@ -38,15 +38,21 @@ import { Schema } from "effect";
 *
 * @module
 */
+const ReplySchemaSymbol = Symbol.for("effect-machine/ReplySchema");
 /**
 * Build a schema-first definition from a record of tag -> fields
 */
 const buildMachineSchema = (definition) => {
 	const variants = {};
 	const constructors = {};
+	const replySchemas = /* @__PURE__ */ new Map();
 	for (const tag of Object.keys(definition)) {
 		const fields = definition[tag];
 		if (fields === void 0) continue;
+		if (ReplySchemaSymbol in fields) {
+			const rs = fields[ReplySchemaSymbol];
+			if (rs !== void 0) replySchemas.set(tag, rs);
+		}
 		variants[tag] = Schema.TaggedStruct(tag, fields);
 		const fieldNames = new Set(Object.keys(fields));
 		if (fieldNames.size > 0) {
@@ -93,6 +99,7 @@ const buildMachineSchema = (definition) => {
 		variants,
 		constructors,
 		_definition: definition,
+		_replySchemas: replySchemas,
 		$is,
 		$match
 	};
@@ -102,10 +109,11 @@ const buildMachineSchema = (definition) => {
 * Builds the schema object with variants, constructors, $is, and $match.
 */
 const createMachineSchema = (definition) => {
-	const { schema, variants, constructors, _definition, $is, $match } = buildMachineSchema(definition);
+	const { schema, variants, constructors, _definition, _replySchemas, $is, $match } = buildMachineSchema(definition);
 	return Object.assign(Object.create(schema), {
 		variants,
 		_definition,
+		_replySchemas,
 		$is,
 		$match,
 		...constructors
@@ -148,11 +156,15 @@ const State = (definition) => createMachineSchema(definition);
 * accidental use of constructors from different event schemas
 * (unless they have identical definitions).
 *
+* Use `Event.reply(fields, replySchema)` to define events that support
+* typed `ask()` replies.
+*
 * @example
 * ```ts
-* const OrderEvent = MachineSchema.Event({
+* const OrderEvent = Event({
 *   Ship: { trackingId: Schema.String },
 *   Cancel: {},
+*   GetTotal: Event.reply({}, Schema.Number),
 * })
 *
 * type OrderEvent = typeof OrderEvent.Type
@@ -161,6 +173,20 @@ const State = (definition) => createMachineSchema(definition);
 * const e = OrderEvent.Ship({ trackingId: "abc" })
 * ```
 */
-const Event = (definition) => createMachineSchema(definition);
+const EventImpl = (definition) => createMachineSchema(definition);
+/**
+* Annotate event fields with a reply schema.
+* Events defined with `Event.reply(fields, replySchema)` enable typed `ask()`.
+*/
+const replyFieldsFn = (fields, replySchema) => {
+	const annotated = { ...fields };
+	Object.defineProperty(annotated, ReplySchemaSymbol, {
+		value: replySchema,
+		enumerable: false,
+		writable: false
+	});
+	return annotated;
+};
+const Event = Object.assign(EventImpl, { reply: replyFieldsFn });
 //#endregion
 export { Event, State };

package/v3/dist/supervision.d.ts

@@ -0,0 +1,97 @@
+import { Cause, Duration, Schedule } from "effect";
+
+//#region src/supervision.d.ts
+/**
+ * Where in the actor lifecycle a defect occurred.
+ *
+ * - `transition` — during event handler execution
+ * - `spawn` — during state spawn effect execution
+ * - `background` — in a background effect fiber
+ * - `initial-spawn` — during initial state spawn effects (before event loop)
+ */
+type DefectPhase = "transition" | "spawn" | "background" | "initial-spawn";
+/**
+ * Terminal exit reason for an actor generation.
+ *
+ * - `Final` — machine reached a final state normally
+ * - `Stopped` — explicit `actor.stop` or `actor.drain`
+ * - `Defect` — unhandled error in the runtime
+ */
+type ActorExit<S> = {
+  readonly _tag: "Final";
+  readonly state: S;
+} | {
+  readonly _tag: "Stopped";
+} | {
+  readonly _tag: "Defect";
+  readonly cause: Cause.Cause<unknown>;
+  readonly phase: DefectPhase;
+};
+/** Constructors for ActorExit */
+declare const ActorExit: {
+  readonly Final: <S>(state: S) => ActorExit<S>;
+  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.
+   *
+   * `schedule` controls restart timing and budget — schedule exhaustion means terminal stop.
+   * `shouldRestart` optionally classifies defects — return `false` to stop immediately
+   * without consuming the schedule.
+   */
+  interface Policy {
+    /** Schedule that controls restart timing. Exhaustion = terminal stop. */
+    readonly schedule: Schedule.Schedule<unknown>;
+    /**
+     * Optional classifier: given a defect exit, decide whether to restart or stop immediately.
+     * Default: always restart (let schedule handle budget).
+     */
+    readonly shouldRestart?: (exit: Extract<ActorExit<unknown>, {
+      readonly _tag: "Defect";
+    }>) => boolean;
+  }
+  /** No supervision — crashes are terminal. */
+  const none: Policy;
+  /**
+   * Restart on defect with max restarts within a window, optional backoff.
+   *
+   * @example
+   * ```ts
+   * Supervision.restart() // unlimited restarts, no backoff
+   * Supervision.restart({ maxRestarts: 3 }) // 3 restarts then terminal
+   * Supervision.restart({ maxRestarts: 3, within: "1 minute" }) // 3 within 1 min
+   * Supervision.restart({ backoff: Schedule.exponential("100 millis") })
+   * ```
+   */
+  const restart: (options?: {
+    readonly maxRestarts?: number;
+    readonly within?: Duration.DurationInput;
+    readonly backoff?: Schedule.Schedule<unknown>;
+  }) => Policy;
+}
+//#endregion
+export { ActorExit, CellPhase, DefectPhase, Supervision };

package/v3/dist/supervision.js

@@ -0,0 +1,42 @@
+import { Schedule } from "effect";
+//#region src/supervision.ts
+/**
+* Supervision types for actor lifecycle management.
+*
+* Core concepts:
+* - `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
+*/
+/** Constructors for ActorExit */
+const ActorExit = {
+	Final: (state) => ({
+		_tag: "Final",
+		state
+	}),
+	Stopped: { _tag: "Stopped" },
+	Defect: (cause, phase) => ({
+		_tag: "Defect",
+		cause,
+		phase
+	})
+};
+let Supervision;
+(function(_Supervision) {
+	_Supervision.none = { schedule: Schedule.recurs(0) };
+	_Supervision.restart = (options) => {
+		let schedule = Schedule.forever;
+		if (options?.maxRestarts !== void 0) {
+			const recurs = Schedule.recurs(options.maxRestarts);
+			if (options.within !== void 0) schedule = Schedule.intersect(recurs, Schedule.windowed(options.within));
+			else schedule = recurs;
+		}
+		if (options?.backoff !== void 0) schedule = Schedule.intersect(schedule, options.backoff);
+		return { schedule };
+	};
+})(Supervision || (Supervision = {}));
+//#endregion
+export { ActorExit, Supervision };

package/v3/dist/testing.d.ts

@@ -1,11 +1,10 @@
-import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
 import { AssertionError } from "./errors.js";
-import { BuiltMachine, Machine, MachineRef } from "./machine.js";
+import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
+import { Machine, MachineRef } from "./machine.js";
 import { Effect, SubscriptionRef } from "effect";
 
 //#region src/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>;
+type MachineInput<S, E, R, GD extends GuardsDef, EFD extends EffectsDef> = Machine<S, E, R, any, any, GD, EFD>;
 /**
  * Result of simulating events through a machine
  */
@@ -37,7 +36,9 @@ 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<{
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], options?: {
+  slots?: Record<string, any>;
+} | undefined) => Effect.Effect<{
   states: S[];
   finalState: S;
 }, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
@@ -48,7 +49,9 @@ 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<S, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
+}, 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, options?: {
+  slots?: Record<string, any>;
+} | undefined) => Effect.Effect<S, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Assert that a machine follows a specific path of state tags
  *
@@ -65,7 +68,9 @@ 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<{
+}, 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[], options?: {
+  slots?: Record<string, any>;
+} | undefined) => Effect.Effect<{
   states: S[];
   finalState: S;
 }, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
@@ -86,7 +91,9 @@ 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<{
+}, 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, options?: {
+  slots?: Record<string, any>;
+} | undefined) => Effect.Effect<{
   states: S[];
   finalState: S;
 }, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
@@ -133,7 +140,9 @@ 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<{
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, options?: (TestHarnessOptions<S, E> & {
+  slots?: Record<string, any>;
+}) | undefined) => Effect.Effect<{
   state: SubscriptionRef.SubscriptionRef<S>;
   send: (event: E) => Effect.Effect<S, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
   getState: Effect.Effect<S, never, never>;

package/v3/dist/testing.js

@@ -1,9 +1,18 @@
 import { stubSystem } from "./internal/utils.js";
 import { AssertionError } from "./errors.js";
-import { BuiltMachine } from "./machine.js";
 import { executeTransition, shouldPostpone } from "./internal/transition.js";
+import { materializeMachine } from "./machine.js";
 import { Effect, SubscriptionRef } from "effect";
 //#region src/testing.ts
+/** Create a dummy MachineRef for testing utilities (no real send/spawn). */
+const makeDummySelf = (label) => {
+	const dummySend = Effect.fn(`effect-machine.testing.${label}.send`)((_event) => Effect.void);
+	return {
+		send: dummySend,
+		cast: dummySend,
+		spawn: () => Effect.die(`spawn not supported in ${label}`)
+	};
+};
 /**
 * Simulate a sequence of events through a machine without running an actor.
 * Useful for testing state transitions in isolation.
@@ -24,14 +33,9 @@ import { Effect, SubscriptionRef } from "effect";
 * 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 dummySend = Effect.fn("effect-machine.testing.simulate.send")((_event) => Effect.void);
-	const dummySelf = {
-		send: dummySend,
-		cast: dummySend,
-		spawn: () => Effect.die("spawn not supported in simulation")
-	};
+const simulate = Effect.fn("effect-machine.simulate")(function* (input, events, options) {
+	const machine = materializeMachine(input, options?.slots);
+	const dummySelf = makeDummySelf("simulate");
 	let currentState = machine.initial;
 	const states = [currentState];
 	const hasPostponeRules = machine.postponeRules.length > 0;
@@ -73,8 +77,8 @@ const simulate = Effect.fn("effect-machine.simulate")(function* (input, events)
 /**
 * 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);
+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(" -> ")}` });
 	return result.finalState;
 });
@@ -90,8 +94,8 @@ const assertReaches = Effect.fn("effect-machine.assertReaches")(function* (input
 * )
 * ```
 */
-const assertPath = Effect.fn("effect-machine.assertPath")(function* (input, events, expectedPath) {
-	const result = yield* simulate(input, events);
+const assertPath = Effect.fn("effect-machine.assertPath")(function* (input, events, expectedPath, options) {
+	const result = yield* simulate(input, events, options);
 	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(" -> ")}` });
@@ -110,8 +114,8 @@ const assertPath = Effect.fn("effect-machine.assertPath")(function* (input, even
 * )
 * ```
 */
-const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(function* (input, events, forbiddenTag) {
-	const result = yield* simulate(input, events);
+const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(function* (input, events, forbiddenTag, options) {
+	const result = yield* simulate(input, events, options);
 	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;
@@ -138,13 +142,8 @@ const assertNeverReaches = Effect.fn("effect-machine.assertNeverReaches")(functi
 * ```
 */
 const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function* (input, options) {
-	const machine = input instanceof BuiltMachine ? input._inner : input;
-	const dummySend = Effect.fn("effect-machine.testing.harness.send")((_event) => Effect.void);
-	const dummySelf = {
-		send: dummySend,
-		cast: dummySend,
-		spawn: () => Effect.die("spawn not supported in test harness")
-	};
+	const machine = materializeMachine(input, options?.slots);
+	const dummySelf = makeDummySelf("harness");
 	const stateRef = yield* SubscriptionRef.make(machine.initial);
 	const hasPostponeRules = machine.postponeRules.length > 0;
 	const postponed = [];