@@ -13,7 +13,7 @@ bun run fmt           # oxfmt
 
 ## Conventions
 
-- Files: kebab-case (`actor-system.ts`, `on-enter.ts`)
+- Files: kebab-case (`actor-system.ts`, `spawn.ts`)
 - States/Events: schema-first with `State({...})` / `Event({...})` - they ARE schemas
 - Empty structs: plain values - `State.Idle` (not callable)
 - Non-empty: `State.Loading({ url })` - constructor requiring args
@@ -35,17 +35,16 @@ const machine = Machine.make({ state, event, initial })
 
 - All builder methods mutate internal state, return `this`
 - Exception: `provide()` creates new instance (supports reusing base machine with different effects)
-- Internal fields prefixed `_` (`_transitions`, `_effectSlots`), public getters expose readonly views
+- Internal fields prefixed `_` (`_transitions`, `_spawnEffects`), public getters expose readonly views
 
 ## Gotchas
 
-- `always` transitions max 100 iterations (infinite loop protection)
 - `delay` requires `Effect.scoped` + `ActorSystemDefault` layer
 - TestClock: use `Layer.merge(ActorSystemDefault, TestContext.TestContext)`
-- `simulate`/`createTestHarness` run guard/effect slots in handlers but no onEnter/onExit/invoke
-- Actor testing needs `yieldFibers` after `send()` to let effects run
-- Same-state transitions skip exit/enter by default
-- `.reenter()` runs exit/enter even on same state tag - use to restart timers/invoke
+- `simulate`/`createTestHarness` run guard/effect slots in handlers but no spawn/background effects
+- Actor testing needs `Effect.yieldNow()` after `send()` to let effects run
+- Same-state transitions skip spawn/finalizers by default
+- `.reenter()` runs exit/enter even on same state tag - use to restart timers/spawn
 - Dynamic delay: duration fn evaluated at state entry, not registration time
 - `namespace.ts` exports Machine namespace (not `Machine.ts` - macOS case-insensitivity)
 - Branded types: `State<T>` / `Event<T>` prevent accidental swap at compile time
@@ -106,21 +105,34 @@ const machine = Machine.make({
 - Provide signature: `(params, ctx) => ...` where ctx = `{ state, event, self }`
 - Guard logic in handler body - no more `guard:` option on `.on()`
 
-## Invoke Slots
+## State Effects with spawn
 
-State-scoped or root-level effects (string names, not parameterized):
+Use `.spawn()` for state-scoped effects. Use `Effect.addFinalizer` for cleanup:
 
 ```ts
-machine
-  .invoke(State.Loading, "fetchData")   // state-scoped
-  .invoke("background")                  // root-level (machine lifetime)
-  .invoke(State.X, ["a", "b"])          // parallel state invokes
-  .invoke(["a", "b"])                    // parallel root invokes
-  .provide({ fetchData: ({ state, self }) => ... })
+machine.spawn(State.Loading, ({ state, self }) =>
+  Effect.gen(function* () {
+    // Cleanup via finalizer
+    yield* Effect.addFinalizer(() => Effect.log("Leaving Loading"));
+
+    // Main work - auto-cancelled when exiting Loading
+    const data = yield* Http.get(state.url);
+    yield* self.send(Event.Loaded({ data }));
+  }),
+);
 ```
 
-- Spawning machine with unprovided slots -> runtime error
-- `simulate()` works without providing invoke effects (pure transitions only)
+Use `.background()` for machine-lifetime effects:
+
+```ts
+machine.background("heartbeat", ({ self }) =>
+  Effect.forever(Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping)))),
+);
+```
+
+- Spawn effects are forked into state scope - cancelled on state exit
+- Background effects are forked into machine scope - cancelled on stop/final
+- `simulate()` works without providing spawn/background effects (pure transitions only)
 
 ## Effect Language Service
 
 
@@ -14,8 +14,6 @@ src/
 ├── testing.ts            # Test utilities (simulate, harness, assertions)
 ├── inspection.ts         # Inspector service for debugging
 ├── errors.ts             # TaggedError classes
-├── combinators/
-│   └── assign.ts         # Partial state update helper (assign function)
 ├── persistence/
 │   ├── adapter.ts        # PersistenceAdapter interface + tags
 │   ├── persistent-machine.ts  # Machine.persist combinator
@@ -26,7 +24,7 @@ src/
 │   └── entity-machine.ts # toEntity - generates Entity from machine
 └── internal/
     ├── loop.ts           # Event loop, transition resolver, lifecycle effects
-    ├── transition-index.ts # O(1) lookup for transitions and effects
+    ├── transition-index.ts # O(1) lookup for transitions
     ├── fiber-storage.ts  # Per-actor WeakMap fiber storage utility
     ├── brands.ts         # StateBrand/EventBrand + BrandedState/BrandedEvent
     ├── is-effect.ts      # Shared isEffect type guard
@@ -42,16 +40,13 @@ test/
 ├── transition-index.test.ts # O(1) transition lookup tests
 ├── inspection.test.ts    # Inspector tests
 ├── features/             # Feature-specific tests
-│   ├── always.test.ts
 │   ├── any.test.ts
-│   ├── assign.test.ts
 │   ├── delay.test.ts
 │   ├── dynamic-delay.test.ts
 │   ├── effects.test.ts
 │   ├── force.test.ts
 │   ├── from.test.ts
 │   ├── guards.test.ts
-│   ├── invoke.test.ts    # Root/parallel invokes
 │   └── same-state.test.ts
 ├── patterns/             # Real-world pattern tests
 │   ├── payment-flow.test.ts
@@ -70,8 +65,8 @@ test/
 | `machine-schema.ts`                 | Schema-first `State`/`Event` - single source of truth       |
 | `slot.ts`                           | `Slot.Guards`/`Slot.Effects` - parameterized slot factories |
 | `namespace.ts`                      | Machine namespace export (named for macOS compat)           |
-| `internal/loop.ts`                  | Event processing, `resolveTransition`, lifecycle effects    |
-| `internal/transition-index.ts`      | O(1) lookup for transitions, always, onEnter, onExit        |
+| `internal/loop.ts`                  | Event processing, `resolveTransition`, spawn effect forking |
+| `internal/transition-index.ts`      | O(1) lookup for transitions                                 |
 | `internal/brands.ts`                | Branded types: `StateBrand`, `BrandedState`, etc.           |
 | `internal/fiber-storage.ts`         | `createFiberStorage()` - per-actor WeakMap utility          |
 | `persistence/persistent-machine.ts` | `Machine.persist` - schemas from machine                    |
@@ -99,14 +94,13 @@ get transitions(): ReadonlyArray<Transition<...>> { return this._transitions; }
 ## Event Flow
 
 ```
-Event → resolveTransition → onExit → handler (w/ guards/effects) → applyAlways → onEnter → update state
+Event → resolveTransition → handler (w/ guards/effects) → update state → spawn effects
 ```
 
 - Handler receives `{ state, event, guards, effects }` context
 - Guards checked inside handler via `yield* guards.xxx(params)`
-- Same-state transitions skip onExit/onEnter by default
-- `.reenter()`: force onExit/onEnter even for same state tag
-- `applyAlways`: loops until no match or final state (max 100 iterations)
+- Same-state transitions skip spawn/finalizer by default
+- `.reenter()`: force spawn/finalizer even for same state tag
 - Final states stop the actor
 
 ## Schema-First Pattern
@@ -178,7 +172,7 @@ const MyEffects = Slot.Effects({
 
 ## Fiber Storage Pattern
 
-`delay` and `provide` (for invoke) use shared utility from `internal/fiber-storage.ts`:
+`delay` and `spawn` use shared utility from `internal/fiber-storage.ts`:
 
 ```ts
 import { createFiberStorage } from "../internal/fiber-storage.js";
@@ -193,35 +187,40 @@ getFiberMap(self).set(instanceKey, fiber);
 `internal/transition-index.ts` provides O(1) lookup via lazy-built WeakMap cache:
 
 - `findTransitions(machine, stateTag, eventTag)` - event transitions
-- `findAlwaysTransitions(machine, stateTag)` - always transitions
-- `findOnEnterEffects(machine, stateTag)` - entry effects
-- `findOnExitEffects(machine, stateTag)` - exit effects
 
 Index built on first access, cached per machine instance.
 
-## Invoke Slots Pattern
+## spawn Pattern
 
 ```ts
 machine
-  .invoke(State.Loading, "fetchData")   // state-scoped invoke
-  .invoke("background")                  // root-level (machine lifetime)
-  .invoke(State.X, ["a", "b"])          // parallel state invokes
-  .invoke(["a", "b"])                    // parallel root invokes
-  .provide({ fetchData: ... })          // wires handler, returns NEW machine
+  .spawn(State.Loading, ({ state, self }) =>
+    Effect.gen(function* () {
+      // Cleanup via finalizer
+      yield* Effect.addFinalizer(() => Effect.log("Leaving"));
+
+      // Main work - auto-cancelled on exit
+      const data = yield* fetchData(state.url);
+      yield* self.send(Event.Resolve({ data }));
+    }),
+  )
+  .background("heartbeat", ({ self }) =>
+    Effect.forever(Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping)))),
+  );
 ```
 
-- `provide()` creates new machine (original reusable with different handlers)
-- Spawning validates all slots have handlers (runtime check)
-- `simulate()` ignores invoke effects - works with unprovided machines
-- Root invokes start on spawn, interrupted on stop or final state
+- `spawn` forks into state scope - cancelled on state exit
+- `background` forks into machine scope - cancelled on stop/final
+- Use `Effect.addFinalizer` for cleanup logic
+- `simulate()` ignores spawn/background effects - works without real actor
 
 ## Testing
 
-| Function              | Guard/Effect Slots | Invoke Effects | Always | Observer |
-| --------------------- | ------------------ | -------------- | ------ | -------- |
-| `simulate`            | Yes                | No             | Yes    | No       |
-| `createTestHarness`   | Yes                | No             | Yes    | Yes      |
-| Actor + `yieldFibers` | Yes                | Yes            | Yes    | No       |
+| Function            | Guard/Effect Slots | Spawn Effects | Observer |
+| ------------------- | ------------------ | ------------- | -------- |
+| `simulate`          | Yes                | No            | No       |
+| `createTestHarness` | Yes                | No            | Yes      |
+| Actor + yieldNow    | Yes                | Yes           | No       |
 
 Use `Layer.merge(ActorSystemDefault, TestContext.TestContext)` for TestClock.
 
 
@@ -5,10 +5,9 @@ Type-safe state machines for Effect. XState-inspired API with full Effect integr
 ## Features
 
 - **Schema-first** - `State` and `Event` ARE schemas. Single source of truth for types and serialization
-- **Fluent builder** - Chain `.on()`, `.always()`, `.delay()` etc. with full type inference
+- **Fluent builder** - Chain `.on()`, `.spawn()`, `.delay()` etc. with full type inference
 - **Type-safe transitions** - types inferred from schemas, no manual type params needed
 - **Guard composition** - `Guard.and`, `Guard.or`, `Guard.not`
-- **Eventless transitions** - `always` for computed state changes
 - **Delayed transitions** - `delay` with TestClock support
 - **Actor model** - spawn machines as actors with lifecycle management
 - **Persistence** - snapshot and event sourcing with pluggable adapters
@@ -70,41 +69,40 @@ Effect.runPromise(
 );
 ```
 
-## Effect Slots
+## State Effects with spawn
 
-Effects (`invoke`, `onEnter`, `onExit`) use named slots. Provide handlers via `.provide()`:
+Use `.spawn()` for state-scoped effects. Use `Effect.addFinalizer` for cleanup:
 
 ```typescript
-// Define machine with effect slots
-const baseMachine = Machine.make({
+const machine = Machine.make({
   state: MyState,
   event: MyEvent,
   initial: MyState.Idle,
 })
   .on(MyState.Idle, MyEvent.Fetch, ({ event }) => MyState.Loading({ url: event.url }))
   .on(MyState.Loading, MyEvent.Resolve, ({ event }) => MyState.Success({ data: event.data }))
-  .invoke(MyState.Loading, "fetchData")
-  .onEnter(MyState.Success, "notifyUser")
-  .final(MyState.Success);
-
-// Production: provide real implementations
-const machine = baseMachine.provide({
-  fetchData: ({ state, self }) =>
+  .spawn(MyState.Loading, ({ state, self }) =>
     Effect.gen(function* () {
+      // Cleanup runs when state exits
+      yield* Effect.addFinalizer(() => Effect.log("Leaving Loading"));
+
+      // Main work - auto-cancelled on state exit
       const data = yield* fetchFromApi(state.url);
       yield* self.send(MyEvent.Resolve({ data }));
     }),
-  notifyUser: ({ state }) => Effect.log(`Success: ${state.data}`),
-});
+  )
+  .final(MyState.Success);
+```
 
-// Test: provide mock implementations
-const testMachine = baseMachine.provide({
-  fetchData: ({ self }) => self.send(MyEvent.Resolve({ data: "mock" })),
-  notifyUser: () => Effect.void,
-});
+Use `.background()` for machine-lifetime effects:
+
+```typescript
+machine.background("heartbeat", ({ self }) =>
+  Effect.forever(Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(MyEvent.Ping)))),
+);
 ```
 
-`simulate()` works without providing effects (pure transitions only).
+`simulate()` works without spawn/background effects (pure transitions only).
 
 ## Persistence
 
@@ -149,61 +147,50 @@ See the [primer](./primer/) for comprehensive documentation:
 
 ### Fluent Methods
 
-| Method       | Description                                      |
-| ------------ | ------------------------------------------------ |
-| `.on()`      | Add state/event transition                       |
-| `.reenter()` | Transition with forced reentry (runs exit/enter) |
-| `.always()`  | Eventless transitions with guard cascade         |
-| `.delay()`   | Schedule event after duration                    |
-| `.invoke()`  | Register invoke slot (state-scoped or root)      |
-| `.onEnter()` | Register entry effect slot                       |
-| `.onExit()`  | Register exit effect slot                        |
-| `.provide()` | Wire effect handlers to named slots              |
-| `.final()`   | Mark state as final                              |
-| `.persist()` | Add persistence (schemas from machine)           |
-
-### Helpers
-
-| Export           | Description                      |
-| ---------------- | -------------------------------- |
-| `Machine.assign` | Helper for partial state updates |
+| Method          | Description                                      |
+| --------------- | ------------------------------------------------ |
+| `.on()`         | Add state/event transition                       |
+| `.reenter()`    | Transition with forced reentry (runs exit/enter) |
+| `.delay()`      | Schedule event after duration                    |
+| `.spawn()`      | State-scoped effect (cancelled on exit)          |
+| `.background()` | Machine-lifetime effect                          |
+| `.provide()`    | Wire handlers to guard/effect slots              |
+| `.final()`      | Mark state as final                              |
+| `.persist()`    | Add persistence (schemas from machine)           |
 
 ### Guards
 
-| Export       | Description                        |
-| ------------ | ---------------------------------- |
-| `Guard.make` | Create named guard slot            |
-| `Guard.and`  | Combine guards with AND (parallel) |
-| `Guard.or`   | Combine guards with OR (parallel)  |
-| `Guard.not`  | Negate a guard                     |
+| Export        | Description                        |
+| ------------- | ---------------------------------- |
+| `Slot.Guards` | Define guard slots with params     |
+| `Guard.and`   | Combine guards with AND (parallel) |
+| `Guard.or`    | Combine guards with OR (parallel)  |
+| `Guard.not`   | Negate a guard                     |
 
-Guards are **slots-only** - declare with name, provide implementation via `.provide()`:
+Guards are **slots-only** - declare with schema params, provide implementation via `.provide()`:
 
 ```typescript
-// Declare guard slot
-const canRetry = Guard.make("canRetry");
-
-// Composition with string shorthand
-Guard.and("isAdmin", "isActive");
-Guard.or("isOwner", "isAdmin");
-Guard.and(Guard.or("isAdmin", "isMod"), "isActive"); // nested
-
-// Use in transition
-machine.on(State.Idle, Event.Start, () => State.Running, {
-  guard: canRetry,
+const MyGuards = Slot.Guards({
+  canRetry: { max: Schema.Number },
 });
 
-// Provide implementation (sync boolean or async Effect<boolean>)
-const provided = machine.provide({
-  canRetry: ({ state }) => state.retries < 3, // sync
-  hasPermission: (
-    { state }, // async
-  ) =>
+const machine = Machine.make({
+  state: MyState,
+  event: MyEvent,
+  guards: MyGuards,
+  initial: MyState.Idle,
+})
+  .on(MyState.Error, MyEvent.Retry, ({ state, guards }) =>
     Effect.gen(function* () {
-      const auth = yield* AuthService;
-      return yield* auth.check(state.userId);
+      if (yield* guards.canRetry({ max: 3 })) {
+        return MyState.Retrying;
+      }
+      return MyState.Failed;
     }),
-});
+  )
+  .provide({
+    canRetry: ({ max }, { state }) => state.attempts < max,
+  });
 ```
 
 ### Testing
@@ -213,7 +200,6 @@ const provided = machine.provide({
 | `simulate`          | Run events and get all states |
 | `createTestHarness` | Step-by-step testing          |
 | `assertReaches`     | Assert machine reaches state  |
-| `yieldFibers`       | Yield to background fibers    |
 
 ### Actors