effect-machine 0.2.4 → 0.3.0

package/README.md

@@ -25,13 +25,13 @@ npm install effect-machine effect
 
 ```ts
 import { Effect, Schema } from "effect";
-import { Machine, State, Event, Slot } from "effect-machine";
+import { Machine, State, Event, Slot, type BuiltMachine } from "effect-machine";
 
 // Define state schema - states ARE schemas
 const OrderState = State({
   Pending: { orderId: Schema.String },
   Processing: { orderId: Schema.String },
-  Shipped: { trackingId: Schema.String },
+  Shipped: { orderId: Schema.String, trackingId: Schema.String },
   Cancelled: {},
 });
 
@@ -54,36 +54,36 @@ const orderMachine = Machine.make({
   effects: OrderEffects,
   initial: OrderState.Pending({ orderId: "order-1" }),
 })
-  .on(OrderState.Pending, OrderEvent.Process, ({ state }) =>
-    OrderState.Processing({ orderId: state.orderId }),
+  .on(OrderState.Pending, OrderEvent.Process, ({ state }) => OrderState.Processing.derive(state))
+  .on(OrderState.Processing, OrderEvent.Ship, ({ state, event }) =>
+    OrderState.Shipped.derive(state, { trackingId: event.trackingId }),
   )
-  .on(OrderState.Processing, OrderEvent.Ship, ({ event }) =>
-    OrderState.Shipped({ trackingId: event.trackingId }),
-  )
-  .on(OrderState.Pending, OrderEvent.Cancel, () => OrderState.Cancelled)
-  .on(OrderState.Processing, OrderEvent.Cancel, () => OrderState.Cancelled)
+  // Cancel from any state
+  .onAny(OrderEvent.Cancel, () => OrderState.Cancelled)
   // Effect runs when entering Processing, cancelled on exit
   .spawn(OrderState.Processing, ({ effects, state }) =>
     effects.notifyWarehouse({ orderId: state.orderId }),
   )
-  .provide({
-    notifyWarehouse: ({ orderId }) => Effect.log(`Warehouse notified: ${orderId}`),
-  })
   .final(OrderState.Shipped)
-  .final(OrderState.Cancelled);
+  .final(OrderState.Cancelled)
+  .build({
+    notifyWarehouse: ({ orderId }) => Effect.log(`Warehouse notified: ${orderId}`),
+  });
 
-// Run as actor (simple)
+// Run as actor (simple — no scope required)
 const program = Effect.gen(function* () {
   const actor = yield* Machine.spawn(orderMachine);
 
   yield* actor.send(OrderEvent.Process);
   yield* actor.send(OrderEvent.Ship({ trackingId: "TRACK-123" }));
 
-  const state = yield* actor.snapshot;
-  console.log(state); // Shipped { trackingId: "TRACK-123" }
+  const state = yield* actor.waitFor(OrderState.Shipped);
+  console.log(state); // Shipped { orderId: "order-1", trackingId: "TRACK-123" }
+
+  yield* actor.stop;
 });
 
-Effect.runPromise(Effect.scoped(program));
+Effect.runPromise(program);
 ```
 
 ## Core Concepts
@@ -102,6 +102,34 @@ MyState.Idle; // Value (no parens)
 MyState.Loading({ url: "/api" }); // Constructor
 ```
 
+### State.derive()
+
+Construct new states from existing ones — picks overlapping fields, applies overrides:
+
+```ts
+// Same-state: preserve fields, override specific ones
+.on(State.Active, Event.Update, ({ state, event }) =>
+  State.Active.derive(state, { count: event.count })
+)
+
+// Cross-state: picks only target fields from source
+.on(State.Processing, Event.Ship, ({ state, event }) =>
+  State.Shipped.derive(state, { trackingId: event.trackingId })
+)
+```
+
+### Multi-State Transitions
+
+Handle the same event from multiple states:
+
+```ts
+// Array of states — handler receives union type
+.on([State.Draft, State.Review], Event.Cancel, () => State.Cancelled)
+
+// Wildcard — fires from any state (specific .on() takes priority)
+.onAny(Event.Cancel, () => State.Cancelled)
+```
+
 ### Guards and Effects as Slots
 
 Define parameterized guards and effects, provide implementations:
@@ -126,7 +154,7 @@ machine
   )
   // Fetch runs when entering Loading, auto-cancelled if state changes
   .spawn(MyState.Loading, ({ effects, state }) => effects.fetchData({ url: state.url }))
-  .provide({
+  .build({
     canRetry: ({ max }, { state }) => state.attempts < max,
     fetchData: ({ url }, { self }) =>
       Effect.gen(function* () {
@@ -189,49 +217,62 @@ See the [primer](./primer/) for comprehensive documentation:
 
 ### Building
 
-| Method                                    | Purpose                      |
-| ----------------------------------------- | ---------------------------- |
-| `Machine.make({ state, event, initial })` | Create machine               |
-| `.on(State.X, Event.Y, handler)`          | Add transition               |
-| `.reenter(State.X, Event.Y, handler)`     | Force re-entry on same state |
-| `.spawn(State.X, handler)`                | State-scoped effect          |
-| `.task(State.X, run, { onSuccess })`      | State-scoped task            |
-| `.background(handler)`                    | Machine-lifetime effect      |
-| `.provide({ slot: impl })`                | Provide implementations      |
-| `.final(State.X)`                         | Mark final state             |
-| `.persist(config)`                        | Enable persistence           |
+| Method                                    | Purpose                                                     |
+| ----------------------------------------- | ----------------------------------------------------------- |
+| `Machine.make({ state, event, initial })` | Create machine                                              |
+| `.on(State.X, Event.Y, handler)`          | Add transition                                              |
+| `.on([State.X, State.Y], Event.Z, h)`     | Multi-state transition                                      |
+| `.onAny(Event.X, handler)`                | Wildcard transition (any state)                             |
+| `.reenter(State.X, Event.Y, handler)`     | Force re-entry on same state                                |
+| `.spawn(State.X, handler)`                | State-scoped effect                                         |
+| `.task(State.X, run, { onSuccess })`      | State-scoped task                                           |
+| `.background(handler)`                    | Machine-lifetime effect                                     |
+| `.final(State.X)`                         | Mark final state                                            |
+| `.build({ slot: impl })`                  | Provide implementations, returns `BuiltMachine` (terminal)  |
+| `.build()`                                | Finalize no-slot machine, returns `BuiltMachine` (terminal) |
+| `.persist(config)`                        | Enable persistence                                          |
+
+### State Constructors
+
+| Method                                 | Purpose                        |
+| -------------------------------------- | ------------------------------ |
+| `State.X.derive(source)`               | Pick target fields from source |
+| `State.X.derive(source, { field: v })` | Pick fields + apply overrides  |
+| `State.$is("X")(value)`                | Type guard                     |
+| `State.$match(value, { X: fn, ... })`  | Pattern matching               |
 
 ### Running
 
-| Method                       | Purpose                                  |
-| ---------------------------- | ---------------------------------------- |
-| `Machine.spawn(machine)`     | Spawn actor (simple, no registry)        |
-| `Machine.spawn(machine, id)` | Spawn actor with custom ID               |
-| `system.spawn(id, machine)`  | Spawn via ActorSystem (registry/persist) |
+| Method                       | Purpose                                                                                                 |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `Machine.spawn(machine)`     | Single actor, no registry. Caller manages lifetime via `actor.stop`. Auto-cleans up if `Scope` present. |
+| `Machine.spawn(machine, id)` | Same as above with custom ID                                                                            |
+| `system.spawn(id, machine)`  | Registry, lookup by ID, bulk ops, persistence. Cleans up on system teardown.                            |
 
 ### Testing
 
-| Function                                   | Description                |
-| ------------------------------------------ | -------------------------- |
-| `simulate(machine, events)`                | Run events, get all states |
-| `createTestHarness(machine)`               | Step-by-step testing       |
-| `assertPath(machine, events, path)`        | Assert exact path          |
-| `assertReaches(machine, events, tag)`      | Assert final state         |
-| `assertNeverReaches(machine, events, tag)` | Assert state never visited |
+| Function                                   | Description                                                      |
+| ------------------------------------------ | ---------------------------------------------------------------- |
+| `simulate(machine, events)`                | Run events, get all states (accepts `Machine` or `BuiltMachine`) |
+| `createTestHarness(machine)`               | Step-by-step testing (accepts `Machine` or `BuiltMachine`)       |
+| `assertPath(machine, events, path)`        | Assert exact path                                                |
+| `assertReaches(machine, events, tag)`      | Assert final state                                               |
+| `assertNeverReaches(machine, events, tag)` | Assert state never visited                                       |
 
 ### Actor
 
-| Method                | Description       |
-| --------------------- | ----------------- |
-| `actor.send(event)`   | Queue event       |
-| `actor.snapshot`      | Get current state |
-| `actor.matches(tag)`  | Check state tag   |
-| `actor.can(event)`    | Can handle event? |
-| `actor.changes`       | Stream of changes |
-| `actor.waitFor(fn)`   | Wait for match    |
-| `actor.awaitFinal`    | Wait final state  |
-| `actor.sendAndWait`   | Send + wait       |
-| `actor.subscribe(fn)` | Sync callback     |
+| Method                           | Description                        |
+| -------------------------------- | ---------------------------------- |
+| `actor.send(event)`              | Queue event                        |
+| `actor.sendSync(event)`          | Fire-and-forget (sync, for UI)     |
+| `actor.snapshot`                 | Get current state                  |
+| `actor.matches(tag)`             | Check state tag                    |
+| `actor.can(event)`               | Can handle event?                  |
+| `actor.changes`                  | Stream of changes                  |
+| `actor.waitFor(State.X)`         | Wait for state (constructor or fn) |
+| `actor.awaitFinal`               | Wait final state                   |
+| `actor.sendAndWait(ev, State.X)` | Send + wait for state              |
+| `actor.subscribe(fn)`            | Sync callback                      |
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-machine",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
@@ -25,7 +25,7 @@
     "fmt:check": "oxfmt --check",
     "test": "bun test",
     "test:watch": "bun test --watch",
-    "gate": "concurrently -n type,lint,fmt,test -c blue,yellow,magenta,green \"bun run typecheck\" \"bun run lint\" \"bun run fmt\" \"bun run test\"",
+    "gate": "concurrently -n type,lint,fmt,test -c blue,yellow,magenta,green \"bun run typecheck\" \"bun run lint:fix\" \"bun run fmt\" \"bun run test\"",
     "prepare": "lefthook install || true && effect-language-service patch",
     "version": "changeset version",
     "release": "changeset publish"

package/src/actor.ts

@@ -6,9 +6,11 @@
  * - ActorSystem service (spawn/stop/get actors)
  * - Actor creation and event loop
  */
+import type { Stream } from "effect";
 import {
   Cause,
   Context,
+  Deferred,
   Effect,
   Exit,
   Fiber,
@@ -17,12 +19,12 @@ import {
   Option,
   Queue,
   Ref,
+  Runtime,
   Scope,
-  Stream,
   SubscriptionRef,
 } from "effect";
 
-import type { Machine, MachineRef } from "./machine.js";
+import type { Machine, MachineRef, BuiltMachine } from "./machine.js";
 import type { Inspector } from "./inspection.js";
 import { Inspector as InspectorTag } from "./inspection.js";
 import { processEventCore, runSpawnEffects, resolveTransition } from "./internal/transition.js";
@@ -37,7 +39,7 @@ export type {
   ProcessEventResult,
 } from "./internal/transition.js";
 import type { GuardsDef, EffectsDef } from "./slot.js";
-import { DuplicateActorError, UnprovidedSlotsError } from "./errors.js";
+import { DuplicateActorError } from "./errors.js";
 import { INTERNAL_INIT_EVENT } from "./internal/utils.js";
 import type {
   ActorMetadata,
@@ -118,9 +120,13 @@ export interface ActorRef<State extends { readonly _tag: string }, Event> {
   readonly changes: Stream.Stream<State>;
 
   /**
-   * Wait for a state that matches predicate (includes current snapshot)
+   * Wait for a state that matches predicate or state variant (includes current snapshot).
+   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
    */
-  readonly waitFor: (predicate: (state: State) => boolean) => Effect.Effect<State>;
+  readonly waitFor: {
+    (predicate: (state: State) => boolean): Effect.Effect<State>;
+    (state: { readonly _tag: State["_tag"] }): Effect.Effect<State>;
+  };
 
   /**
    * Wait for a final state (includes current snapshot)
@@ -128,12 +134,21 @@ export interface ActorRef<State extends { readonly _tag: string }, Event> {
   readonly awaitFinal: Effect.Effect<State>;
 
   /**
-   * Send event and wait for predicate or final state
+   * Send event and wait for predicate, state variant, or final state.
+   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
+   */
+  readonly sendAndWait: {
+    (event: Event, predicate: (state: State) => boolean): Effect.Effect<State>;
+    (event: Event, state: { readonly _tag: State["_tag"] }): Effect.Effect<State>;
+    (event: Event): Effect.Effect<State>;
+  };
+
+  /**
+   * Send event synchronously (fire-and-forget).
+   * No-op on stopped actors. Use when you need to send from sync contexts
+   * (e.g. framework hooks, event handlers).
    */
-  readonly sendAndWait: (
-    event: Event,
-    predicate?: (state: State) => boolean,
-  ) => Effect.Effect<State>;
+  readonly sendSync: (event: Event) => void;
 
   /**
    * Subscribe to state changes (sync callback)
@@ -159,14 +174,13 @@ export interface ActorSystem {
    * For regular machines, returns ActorRef.
    * For persistent machines (created with Machine.persist), returns PersistentActorRef.
    *
-   * Note: All effect slots must be provided via `Machine.provide` before spawning.
-   * Attempting to spawn a machine with unprovided effect slots will fail.
+   * All effect slots must be provided via `.build()` before spawning.
    *
    * @example
    * ```ts
-   * // Regular machine (effects provided)
-   * const machine = Machine.provide(baseMachine, { fetchData: ... })
-   * const actor = yield* system.spawn("my-actor", machine);
+   * // Regular machine (built)
+   * const built = machine.build({ fetchData: ... })
+   * const actor = yield* system.spawn("my-actor", built);
    *
    * // Persistent machine (auto-detected)
    * const persistentActor = yield* system.spawn("my-actor", persistentMachine);
@@ -175,18 +189,11 @@ export interface ActorSystem {
    * ```
    */
   readonly spawn: {
-    // Regular machine overload
-    <
-      S extends { readonly _tag: string },
-      E extends { readonly _tag: string },
-      R,
-      GD extends GuardsDef = Record<string, never>,
-      EFD extends EffectsDef = Record<string, never>,
-    >(
+    // Regular machine overload (BuiltMachine)
+    <S extends { readonly _tag: string }, E extends { readonly _tag: string }, R>(
       id: string,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Schema fields need wide acceptance
-      machine: Machine<S, E, R, any, any, GD, EFD>,
-    ): Effect.Effect<ActorRef<S, E>, DuplicateActorError | UnprovidedSlotsError, R | Scope.Scope>;
+      machine: BuiltMachine<S, E, R>,
+    ): Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>;
 
     // Persistent machine overload
     <S extends { readonly _tag: string }, E extends { readonly _tag: string }, R>(
@@ -194,8 +201,8 @@ export interface ActorSystem {
       machine: PersistentMachine<S, E, R>,
     ): Effect.Effect<
       PersistentActorRef<S, E, R>,
-      PersistenceError | VersionConflictError | DuplicateActorError | UnprovidedSlotsError,
-      R | Scope.Scope | PersistenceAdapterTag
+      PersistenceError | VersionConflictError | DuplicateActorError,
+      R | PersistenceAdapterTag
     >;
   };
 
@@ -218,8 +225,8 @@ export interface ActorSystem {
     machine: PersistentMachine<S, E, R>,
   ) => Effect.Effect<
     Option.Option<PersistentActorRef<S, E, R>>,
-    PersistenceError | DuplicateActorError | UnprovidedSlotsError,
-    R | Scope.Scope | PersistenceAdapterTag
+    PersistenceError | DuplicateActorError,
+    R | PersistenceAdapterTag
   >;
 
   /**
@@ -267,7 +274,7 @@ export interface ActorSystem {
   >(
     ids: ReadonlyArray<string>,
     machine: PersistentMachine<S, E, R>,
-  ) => Effect.Effect<RestoreResult<S, E, R>, never, R | Scope.Scope | PersistenceAdapterTag>;
+  ) => Effect.Effect<RestoreResult<S, E, R>, never, R | PersistenceAdapterTag>;
 
   /**
    * Restore all persisted actors for a machine type.
@@ -288,11 +295,7 @@ export interface ActorSystem {
   >(
     machine: PersistentMachine<S, E, R>,
     options?: { filter?: (meta: ActorMetadata) => boolean },
-  ) => Effect.Effect<
-    RestoreResult<S, E, R>,
-    PersistenceError,
-    R | Scope.Scope | PersistenceAdapterTag
-  >;
+  ) => Effect.Effect<RestoreResult<S, E, R>, PersistenceError, R | PersistenceAdapterTag>;
 }
 
 /**
@@ -362,16 +365,41 @@ export const buildActorRefCore = <
   });
 
   const waitFor = Effect.fn("effect-machine.actor.waitFor")(function* (
-    predicate: (state: S) => boolean,
+    predicateOrState: ((state: S) => boolean) | { readonly _tag: S["_tag"] },
   ) {
-    // Use stateRef.changes directly — it emits the current value as its first
-    // element inside the SubscriptionRef semaphore, so this is atomic and
-    // race-free (no gap between "check current" and "subscribe").
-    const result = yield* stateRef.changes.pipe(Stream.filter(predicate), Stream.runHead);
-    if (Option.isSome(result)) return result.value;
-    // Unreachable: changes always emits at least the current value.
-    // Fallback to snapshot for type completeness.
-    return yield* SubscriptionRef.get(stateRef);
+    const predicate =
+      typeof predicateOrState === "function" && !("_tag" in predicateOrState)
+        ? predicateOrState
+        : (s: S) => s._tag === (predicateOrState as { readonly _tag: string })._tag;
+
+    // Check current state first — SubscriptionRef.get acquires/releases
+    // the semaphore quickly (read-only), no deadlock risk.
+    const current = yield* SubscriptionRef.get(stateRef);
+    if (predicate(current)) return current;
+
+    // Use sync listener + Deferred to avoid holding the SubscriptionRef
+    // semaphore for the duration of a stream (which causes deadlock when
+    // send triggers SubscriptionRef.set concurrently).
+    const done = yield* Deferred.make<S>();
+    const rt = yield* Effect.runtime<never>();
+    const runFork = Runtime.runFork(rt);
+    const listener = (state: S) => {
+      if (predicate(state)) {
+        runFork(Deferred.succeed(done, state));
+      }
+    };
+    listeners.add(listener);
+
+    // Re-check after subscribing to close the race window
+    const afterSubscribe = yield* SubscriptionRef.get(stateRef);
+    if (predicate(afterSubscribe)) {
+      listeners.delete(listener);
+      return afterSubscribe;
+    }
+
+    const result = yield* Deferred.await(done);
+    listeners.delete(listener);
+    return result;
   });
 
   const awaitFinal = waitFor((state) => machine.finalStates.has(state._tag)).pipe(
@@ -380,11 +408,11 @@ export const buildActorRefCore = <
 
   const sendAndWait = Effect.fn("effect-machine.actor.sendAndWait")(function* (
     event: E,
-    predicate?: (state: S) => boolean,
+    predicateOrState?: ((state: S) => boolean) | { readonly _tag: S["_tag"] },
   ) {
     yield* send(event);
-    if (predicate !== undefined) {
-      return yield* waitFor(predicate);
+    if (predicateOrState !== undefined) {
+      return yield* waitFor(predicateOrState);
     }
     return yield* awaitFinal;
   });
@@ -407,6 +435,12 @@ export const buildActorRefCore = <
     waitFor,
     awaitFinal,
     sendAndWait,
+    sendSync: (event) => {
+      const stopped = Effect.runSync(Ref.get(stoppedRef));
+      if (!stopped) {
+        Effect.runSync(Queue.offer(eventQueue, event));
+      }
+    },
     subscribe: (fn) => {
       listeners.add(fn);
       return () => {
@@ -432,11 +466,6 @@ export const createActor = Effect.fn("effect-machine.actor.spawn")(function* <
 >(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>) {
   yield* Effect.annotateCurrentSpan("effect_machine.actor.id", id);
 
-  const missing = machine._missingSlots();
-  if (missing.length > 0) {
-    return yield* new UnprovidedSlotsError({ slots: missing });
-  }
-
   // Get optional inspector from context
   const inspectorValue = Option.getOrUndefined(yield* Effect.serviceOption(InspectorTag)) as
     | Inspector<S, E>
@@ -477,7 +506,7 @@ export const createActor = Effect.fn("effect-machine.actor.spawn")(function* <
   const { effects: effectSlots } = machine._slots;
 
   for (const bg of machine.backgroundEffects) {
-    const fiber = yield* Effect.fork(
+    const fiber = yield* Effect.forkDaemon(
       bg
         .handler({ state: machine.initial, event: initEvent, self, effects: effectSlots })
         .pipe(Effect.provideService(machine.Context, ctx)),
@@ -520,10 +549,9 @@ export const createActor = Effect.fn("effect-machine.actor.spawn")(function* <
     return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, stop);
   }
 
-  // Start the event loop — use forkScoped so the event loop fiber's lifetime
-  // is tied to the provided Scope, not the calling fiber. This prevents the
-  // event loop from being interrupted when a transient caller completes.
-  const loopFiber = yield* Effect.forkScoped(
+  // Start the event loop — use forkDaemon so the event loop fiber's lifetime
+  // is detached from any parent scope/fiber. actor.stop handles cleanup.
+  const loopFiber = yield* Effect.forkDaemon(
     eventLoop(
       machine,
       stateRef,
@@ -774,7 +802,16 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
   const spawnGate = yield* Effect.makeSemaphore(1);
   const withSpawnGate = spawnGate.withPermits(1);
 
-  /** Check for duplicate ID, register actor, add cleanup finalizer */
+  // Stop all actors on system teardown
+  yield* Effect.addFinalizer(() => {
+    const stops: Effect.Effect<void>[] = [];
+    MutableHashMap.forEach(actors, (actor) => {
+      stops.push(actor.stop);
+    });
+    return Effect.all(stops, { concurrency: "unbounded" }).pipe(Effect.asVoid);
+  });
+
+  /** Check for duplicate ID, register actor, attach scope cleanup if available */
   const registerActor = Effect.fn("effect-machine.actorSystem.register")(function* <
     T extends { stop: Effect.Effect<void> },
   >(id: string, actor: T) {
@@ -788,13 +825,17 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
     // Register it - O(1)
     MutableHashMap.set(actors, id, actor as unknown as ActorRef<AnyState, unknown>);
 
-    // Register cleanup on scope finalization
-    yield* Effect.addFinalizer(
-      Effect.fn("effect-machine.actorSystem.register.finalizer")(function* () {
-        yield* actor.stop;
-        MutableHashMap.remove(actors, id);
-      }),
-    );
+    // If scope available, attach per-actor cleanup
+    const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+    if (Option.isSome(maybeScope)) {
+      yield* Scope.addFinalizer(
+        maybeScope.value,
+        Effect.gen(function* () {
+          yield* actor.stop;
+          MutableHashMap.remove(actors, id);
+        }),
+      );
+    }
 
     return actor;
   });
@@ -803,14 +844,12 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
     S extends { readonly _tag: string },
     E extends { readonly _tag: string },
     R,
-    GD extends GuardsDef = Record<string, never>,
-    EFD extends EffectsDef = Record<string, never>,
-  >(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>) {
+  >(id: string, built: BuiltMachine<S, E, R>) {
     if (MutableHashMap.has(actors, id)) {
       return yield* new DuplicateActorError({ actorId: id });
     }
     // Create and register the actor
-    const actor = yield* createActor(id, machine);
+    const actor = yield* createActor(id, built._inner);
     return yield* registerActor(id, actor);
   });
 
@@ -846,68 +885,44 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
     S extends { readonly _tag: string },
     E extends { readonly _tag: string },
     R,
-    GD extends GuardsDef = Record<string, never>,
-    EFD extends EffectsDef = Record<string, never>,
-  >(
-    id: string,
-    machine:
-      | Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>
-      | PersistentMachine<S, E, R>,
-  ) {
+  >(id: string, machine: BuiltMachine<S, E, R> | PersistentMachine<S, E, R>) {
     if (isPersistentMachine(machine)) {
       // TypeScript can't narrow union with invariant generic params
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       return yield* spawnPersistent(id, machine as PersistentMachine<S, E, R>);
     }
-    return yield* spawnRegular(
-      id,
-      machine as Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>,
-    );
+    return yield* spawnRegular(id, machine as BuiltMachine<S, E, R>);
   });
 
   // Type-safe overloaded spawn implementation
-  function spawn<
-    S extends { readonly _tag: string },
-    E extends { readonly _tag: string },
-    R,
-    GD extends GuardsDef = Record<string, never>,
-    EFD extends EffectsDef = Record<string, never>,
-  >(
+  function spawn<S extends { readonly _tag: string }, E extends { readonly _tag: string }, R>(
     id: string,
-    machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>,
-  ): Effect.Effect<ActorRef<S, E>, DuplicateActorError | UnprovidedSlotsError, R | Scope.Scope>;
+    machine: BuiltMachine<S, E, R>,
+  ): Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>;
   function spawn<S extends { readonly _tag: string }, E extends { readonly _tag: string }, R>(
     id: string,
     machine: PersistentMachine<S, E, R>,
   ): Effect.Effect<
     PersistentActorRef<S, E, R>,
-    PersistenceError | VersionConflictError | DuplicateActorError | UnprovidedSlotsError,
-    R | Scope.Scope | PersistenceAdapterTag
+    PersistenceError | VersionConflictError | DuplicateActorError,
+    R | PersistenceAdapterTag
   >;
-  function spawn<
-    S extends { readonly _tag: string },
-    E extends { readonly _tag: string },
-    R,
-    GD extends GuardsDef = Record<string, never>,
-    EFD extends EffectsDef = Record<string, never>,
-  >(
+  function spawn<S extends { readonly _tag: string }, E extends { readonly _tag: string }, R>(
     id: string,
-    machine:
-      | Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>
-      | PersistentMachine<S, E, R>,
+    machine: BuiltMachine<S, E, R> | PersistentMachine<S, E, R>,
   ):
-    | Effect.Effect<ActorRef<S, E>, DuplicateActorError | UnprovidedSlotsError, R | Scope.Scope>
+    | Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>
     | Effect.Effect<
         PersistentActorRef<S, E, R>,
-        PersistenceError | VersionConflictError | DuplicateActorError | UnprovidedSlotsError,
-        R | Scope.Scope | PersistenceAdapterTag
+        PersistenceError | VersionConflictError | DuplicateActorError,
+        R | PersistenceAdapterTag
       > {
     return withSpawnGate(spawnImpl(id, machine)) as
-      | Effect.Effect<ActorRef<S, E>, DuplicateActorError | UnprovidedSlotsError, R | Scope.Scope>
+      | Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>
       | Effect.Effect<
           PersistentActorRef<S, E, R>,
-          PersistenceError | VersionConflictError | DuplicateActorError | UnprovidedSlotsError,
-          R | Scope.Scope | PersistenceAdapterTag
+          PersistenceError | VersionConflictError | DuplicateActorError,
+          R | PersistenceAdapterTag
         >;
   }
 
@@ -961,7 +976,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
     const restored: PersistentActorRef<S, E, R>[] = [];
     const failed: {
       id: string;
-      error: PersistenceError | DuplicateActorError | UnprovidedSlotsError;
+      error: PersistenceError | DuplicateActorError;
     }[] = [];
 
     for (const id of ids) {
@@ -1032,4 +1047,4 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 /**
  * Default ActorSystem layer
  */
-export const Default = Layer.effect(ActorSystem, make());
+export const Default = Layer.scoped(ActorSystem, make());