effect-machine 0.12.0 → 0.14.0

package/dist/slot.d.ts

@@ -4,42 +4,120 @@ import { Effect, Schema, ServiceMap } from "effect";
 //#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
 type Fields = Record<string, Schema.Top>;
-/** Extract the encoded type from schema fields (used for parameters) */
+/** Extract the 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>;
+ * Definition of a single slot function.
+ * Created via `Slot.fn(params, returnSchema?)`.
+ *
+ * Carries both type-level information and materialized schemas
+ * for runtime validation and serialization.
+ */
+interface SlotFnDef<F extends Fields = Fields, Return = void> {
+  readonly _tag: "SlotFnDef";
+  readonly fields: F;
+  /** Return schema — undefined means void */
+  readonly returnSchema: Schema.Schema<Return> | undefined;
+  /** Materialized input schema (Schema.Struct of fields, or Schema.Void for empty) */
+  readonly inputSchema: Schema.Codec<FieldsToParams<F>>;
+  /** Materialized output schema (returnSchema or Schema.Void) */
+  readonly outputSchema: Schema.Codec<Return>;
 }
 /**
- * An effect slot - callable function that returns Effect<void>.
+ * Define a single slot function with parameter schema and optional return schema.
+ *
+ * @example
+ * ```ts
+ * // Guard-like: returns boolean
+ * Slot.fn({ max: Schema.Number }, Schema.Boolean)
+ *
+ * // Effect-like: returns void (default)
+ * Slot.fn({ url: Schema.String })
+ *
+ * // No params, returns boolean
+ * Slot.fn({}, Schema.Boolean)
+ * ```
  */
-interface EffectSlot<Name extends string, Params> {
-  readonly _tag: "EffectSlot";
-  readonly name: Name;
-  (params: Params): Effect.Effect<void>;
-}
+declare const fn: {
+  <F extends Fields, Return>(fields: F, returnSchema: Schema.Schema<Return>): SlotFnDef<F, Return>;
+  <F extends Fields>(fields: F): SlotFnDef<F, void>;
+};
+/**
+ * Record of slot definitions. Keys are slot names, values are SlotFnDef.
+ */
+type SlotsDef = Record<string, SlotFnDef<Fields, unknown>>;
 /**
- * Guard definition - name to schema fields mapping
+ * Slots schema — returned by `Slot.define()`. Passed to `Machine.make({ slots })`.
  */
-type GuardsDef = Record<string, Fields>;
+interface SlotsSchema<D extends SlotsDef> {
+  readonly _tag: "SlotsSchema";
+  readonly definitions: D;
+  /** Schema for slot requests `{ _tag: "SlotRequest", name, params }`. For RPC request payloads. */
+  readonly requestSchema: Schema.Codec<SlotRequest<D>>;
+  /** Schema for slot results `{ _tag: "SlotResult", name, result }`. For RPC response payloads. */
+  readonly resultSchema: Schema.Codec<SlotResult<D>>;
+  /** Schema for slot invocations `{ _tag: "SlotInvocation", name, params, result }`. For persistence/logging. */
+  readonly invocationSchema: Schema.Codec<SlotInvocation<D>>;
+  /** Create callable slot proxies (used by Machine internally) */
+  readonly _createSlots: (resolve: <N extends keyof D & string>(name: N, params: SlotParams<D[N]>) => Effect.Effect<SlotReturn<D[N]>>) => SlotCalls<D>;
+}
 /**
- * Effect definition - name to schema fields mapping
+ * A serialized slot request — captures name and params (no result).
+ * Used for RPC request payloads.
+ */
+type SlotRequest<D extends SlotsDef> = { readonly [K in keyof D & string]: {
+  readonly _tag: "SlotRequest";
+  readonly name: K;
+  readonly params: SlotParams<D[K]>;
+} }[keyof D & string];
+/**
+ * A serialized slot result — captures name and result (no params).
+ * Used for RPC response payloads.
+ */
+type SlotResult<D extends SlotsDef> = { readonly [K in keyof D & string]: {
+  readonly _tag: "SlotResult";
+  readonly name: K;
+  readonly result: SlotReturn<D[K]>;
+} }[keyof D & string];
+/**
+ * A serialized slot invocation — captures name, params, and result.
+ * Used for persistence, logging, and audit trails.
+ */
+type SlotInvocation<D extends SlotsDef> = { readonly [K in keyof D & string]: {
+  readonly _tag: "SlotInvocation";
+  readonly name: K;
+  readonly params: SlotParams<D[K]>;
+  readonly result: SlotReturn<D[K]>;
+} }[keyof D & string];
+/** Extract params type from a SlotFnDef */
+type SlotParams<D extends SlotFnDef<Fields, unknown>> = D extends SlotFnDef<infer F, unknown> ? FieldsToParams<F> : never;
+/** Extract return type from a SlotFnDef */
+type SlotReturn<D extends SlotFnDef<Fields, unknown>> = D extends SlotFnDef<Fields, infer R> ? R : never;
+/**
+ * A callable slot — function that takes params and returns Effect<Return>.
+ */
+interface SlotCall<Name extends string, Params, Return> {
+  readonly _tag: "Slot";
+  readonly name: Name;
+  (params: Params): Effect.Effect<Return>;
+}
+/**
+ * Convert slot definitions to callable slot proxies.
  */
-type EffectsDef = Record<string, Fields>;
+type SlotCalls<D extends SlotsDef> = { readonly [K in keyof D & string]: SlotCall<K, SlotParams<D[K]>, SlotReturn<D[K]>> };
 /**
- * Convert guard definitions to callable guard slots
+ * Slot handler implementation.
+ * Receives only params — use `yield* machine.Context` for machine context.
  */
-type GuardSlots<D extends GuardsDef> = { readonly [K in keyof D & string]: GuardSlot<K, FieldsToParams<D[K]>> };
+type SlotHandler<Params, Return, R = never> = (params: Params) => Return | Effect.Effect<Return, never, R>;
 /**
- * Convert effect definitions to callable effect slots
+ * Handler implementations for all slots in a definition.
  */
-type EffectSlots<D extends EffectsDef> = { readonly [K in keyof D & string]: EffectSlot<K, FieldsToParams<D[K]>> };
+type ProvideSlots<D extends SlotsDef, R = never> = { readonly [K in keyof D & string]: SlotHandler<SlotParams<D[K]>, SlotReturn<D[K]>, R> };
+/** Check if a SlotsDef has any actual keys */
+type HasSlotKeys<SD extends SlotsDef> = [keyof SD] extends [never] ? false : SD extends Record<string, never> ? false : true;
 /**
- * Type for machine context - state, event, and self reference.
+ * Type for machine context — state, event, and self reference.
  * Shared across all machines via MachineContextTag.
  */
 interface MachineContext<State, Event, Self> {
@@ -56,76 +134,24 @@ interface MachineContext<State, Event, Self> {
  */
 declare const MachineContextTag: ServiceMap.Service<MachineContext<any, any, any>, MachineContext<any, any, 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.
+ * Define a set of slots with parameter and return schemas.
  *
  * @example
  * ```ts
- * const MyEffects = Slot.Effects({
- *   fetchData: { url: Schema.String },
- *   notify: { message: Schema.String },
+ * const MySlots = Slot.define({
+ *   canRetry: Slot.fn({ max: Schema.Number }, Schema.Boolean),
+ *   fetchData: Slot.fn({ url: Schema.String }),
+ *   notify: Slot.fn({ 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 define: <D extends SlotsDef>(definitions: D) => SlotsSchema<D>;
 declare const Slot: {
-  readonly Guards: <D extends GuardsDef>(definitions: D) => GuardsSchema<D>;
-  readonly Effects: <D extends EffectsDef>(definitions: D) => EffectsSchema<D>;
+  readonly fn: {
+    <F extends Fields, Return>(fields: F, returnSchema: Schema.Schema<Return>): SlotFnDef<F, Return>;
+    <F extends Fields>(fields: F): SlotFnDef<F, void>;
+  };
+  readonly define: <D extends SlotsDef>(definitions: D) => SlotsSchema<D>;
 };
 //#endregion
-export { EffectHandler, EffectHandlers, EffectSlot, EffectSlots, EffectSlotsOf, Effects, EffectsDef, EffectsDefOf, EffectsSchema, GuardHandler, GuardHandlers, GuardSlot, GuardSlots, GuardSlotsOf, Guards, GuardsDef, GuardsDefOf, GuardsSchema, MachineContext, MachineContextTag, Slot };
+export { HasSlotKeys, MachineContext, MachineContextTag, ProvideSlots, Slot, SlotCall, SlotCalls, SlotFnDef, SlotHandler, SlotInvocation, SlotRequest, SlotResult, SlotsDef, SlotsSchema, define, fn };

package/dist/slot.js

@@ -1,31 +1,29 @@
-import { ServiceMap } from "effect";
+import { Schema, ServiceMap } from "effect";
 //#region src/slot.ts
 /**
-* Slot module - schema-based, parameterized guards and effects.
+* Slot module — unified, schema-based parameterized slots.
 *
-* Guards and Effects are defined with schemas for their parameters,
-* and provided implementations receive typed parameters plus machine context.
+* Replaces the split Guards/Effects API with a single `Slot.define` + `Slot.fn`.
+* Each slot declares its parameter schema and (optional) return schema.
+* Handlers receive only params — machine context is accessed via `yield* 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 },
+* const MySlots = Slot.define({
+*   canRetry: Slot.fn({ max: Schema.Number }, Schema.Boolean),
+*   isValid: Slot.fn({}, Schema.Boolean),
+*   fetchData: Slot.fn({ url: Schema.String }),
+*   notify: Slot.fn({ message: Schema.String }),
 * })
 *
 * // Used in handlers:
-* .on(State.X, Event.Y, ({ guards, effects }) =>
+* .on(State.X, Event.Y, ({ slots }) =>
 *   Effect.gen(function* () {
-*     if (yield* guards.canRetry({ max: 3 })) {
-*       yield* effects.fetchData({ url: "/api" })
+*     if (yield* slots.canRetry({ max: 3 })) {
+*       yield* slots.fetchData({ url: "/api" })
 *       return State.Next
 *     }
 *     return state
@@ -36,62 +34,97 @@ import { ServiceMap } from "effect";
 * @module
 */
 /**
-* Shared Context tag for all machines.
-* Single module-level tag instead of per-machine allocation.
-* @internal
-*/
-const MachineContextTag = ServiceMap.Service("@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.
+* Define a single slot function with parameter schema and optional return schema.
 *
 * @example
 * ```ts
-* const MyGuards = Slot.Guards({
-*   canRetry: { max: Schema.Number },
-*   isValid: {},
-* })
+* // Guard-like: returns boolean
+* Slot.fn({ max: Schema.Number }, Schema.Boolean)
+*
+* // Effect-like: returns void (default)
+* Slot.fn({ url: Schema.String })
+*
+* // No params, returns boolean
+* Slot.fn({}, Schema.Boolean)
 * ```
 */
-const Guards = (definitions) => createSlotSchema("GuardsSchema", "GuardSlot", definitions);
+const fn = (fields, returnSchema) => {
+	return {
+		_tag: "SlotFnDef",
+		fields,
+		returnSchema,
+		inputSchema: Object.keys(fields).length > 0 ? Schema.Struct(fields) : Schema.Void,
+		outputSchema: returnSchema ?? Schema.Void
+	};
+};
 /**
-* Create an effects schema with parameterized effect definitions.
+* Shared Context tag for all machines.
+* Single module-level tag instead of per-machine allocation.
+* @internal
+*/
+const MachineContextTag = ServiceMap.Service("@effect-machine/Context");
+/**
+* Define a set of slots with parameter and return schemas.
 *
 * @example
 * ```ts
-* const MyEffects = Slot.Effects({
-*   fetchData: { url: Schema.String },
-*   notify: { message: Schema.String },
+* const MySlots = Slot.define({
+*   canRetry: Slot.fn({ max: Schema.Number }, Schema.Boolean),
+*   fetchData: Slot.fn({ url: Schema.String }),
+*   notify: Slot.fn({ message: Schema.String }),
 * })
 * ```
 */
-const Effects = (definitions) => createSlotSchema("EffectsSchema", "EffectSlot", definitions);
+const define = (definitions) => {
+	const names = Object.keys(definitions);
+	const requestSchemas = [];
+	const resultSchemas = [];
+	const invocationSchemas = [];
+	for (const name of names) {
+		const def = definitions[name];
+		if (def === void 0) continue;
+		requestSchemas.push(Schema.TaggedStruct("SlotRequest", {
+			name: Schema.Literal(name),
+			params: def.inputSchema
+		}));
+		resultSchemas.push(Schema.TaggedStruct("SlotResult", {
+			name: Schema.Literal(name),
+			result: def.outputSchema
+		}));
+		invocationSchemas.push(Schema.TaggedStruct("SlotInvocation", {
+			name: Schema.Literal(name),
+			params: def.inputSchema,
+			result: def.outputSchema
+		}));
+	}
+	const buildUnion = (schemas) => schemas.length === 0 ? Schema.Never : Schema.Union(schemas);
+	return {
+		_tag: "SlotsSchema",
+		definitions,
+		requestSchema: buildUnion(requestSchemas),
+		resultSchema: buildUnion(resultSchemas),
+		invocationSchema: buildUnion(invocationSchemas),
+		_createSlots: (resolve) => {
+			const slots = {};
+			for (const name of names) {
+				const slot = (params) => resolve(name, params);
+				Object.defineProperty(slot, "_tag", {
+					value: "Slot",
+					enumerable: true
+				});
+				Object.defineProperty(slot, "name", {
+					value: name,
+					enumerable: true
+				});
+				slots[name] = slot;
+			}
+			return slots;
+		}
+	};
+};
 const Slot = {
-	Guards,
-	Effects
+	fn,
+	define
 };
 //#endregion
-export { Effects, Guards, MachineContextTag, Slot };
+export { MachineContextTag, Slot, define, fn };

package/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.Input;
+    readonly backoff?: Schedule.Schedule<unknown>;
+  }) => Policy;
+}
+//#endregion
+export { ActorExit, CellPhase, DefectPhase, Supervision };

package/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.both(recurs, Schedule.windowed(options.within));
+			else schedule = recurs;
+		}
+		if (options?.backoff !== void 0) schedule = Schedule.both(schedule, options.backoff);
+		return { schedule };
+	};
+})(Supervision || (Supervision = {}));
+//#endregion
+export { ActorExit, Supervision };

package/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 { MachineContext, ProvideSlots, SlotsDef } 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, SD extends SlotsDef = Record<string, never>> = Machine<S, E, R, any, any, SD>;
 /**
  * Result of simulating events through a machine
  */
@@ -16,7 +15,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 guard/effect slots
+ * Does not run onEnter/spawn/background effects, but does run slots
  * within transition handlers.
  *
  * @example
@@ -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, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, events: readonly E[], options?: {
+  slots?: ProvideSlots<SD, 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, 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, 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, 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<{
   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, 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<{
   states: S[];
   finalState: S;
 }, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
@@ -101,16 +108,18 @@ interface TestHarness<S, E, R> {
 /**
  * Options for creating a test harness
  */
-interface TestHarnessOptions<S, E> {
+interface TestHarnessOptions<S, E, SD extends SlotsDef = Record<string, never>> {
   /**
    * 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 guard/effect slots
+ * Does not run onEnter/spawn/background effects, but does run slots
  * within transition handlers.
  *
  * @example Basic usage
@@ -133,7 +142,7 @@ 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, SD extends SlotsDef = Record<string, never>>(input: MachineInput<S, E, R, SD>, options?: TestHarnessOptions<S, E, SD> | 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>;