24. What Effect provides and what the kernel adds

The kernel is a TypeScript library over effect@4.0.5. This is kernel test T3, written directly against it: a handler that returns without resuming, and the cleanup that follows.

const Ask = operation<void, number>("Ask")

const body = Effect.scoped(Effect.gen(function* () {
  yield* Effect.acquireRelease(note("acquire"), () => note("release"))
  yield* Effect.addFinalizer((exit) => note(`finalizer sees interrupt=${Exit.hasInterrupts(exit)}`))
  const n = yield* Ask(undefined)                  // captures up to the handle below
  yield* note(`never reached ${n}`)
  return n
}))

const result = yield* handle("h", [Ask], body, {
  Ask: () => Effect.as(note("clause returns without resuming"), -100)
})

acquire
clause returns without resuming
finalizer sees interrupt=true
release
handle returned -100

Everything in that test except operation, handle, and the capture is ordinary Effect: Effect.scoped, acquireRelease, addFinalizer, the fiber, and the finalizers that run during abandonment. This chapter lists what Effect provides, what the kernel adds, and the Effect behaviors the design works around.

Provided by Effect 4, unchanged

Missing, supplied by the kernel

Effect 4.0.5 hazards the language designs around

The upstream draft index collects reproductions and proposed fixes for wake-up depth, generator cleanup and tooling, mixed-cause recovery, fairness, Layer memoization documentation, and interruption diagnostics, plus supported-prompt and segmented-stack proposals. Every entry is drafted, not filed (D59). Kernel review defects are tracked separately in experiments/KERNEL-CHANGES.md.

Scheduling, stack safety, and cancellation

Scheduling [Effect] [Rule]. A fiber runs until it parks, completes, or reaches 2048 run-loop steps, then yields through its dispatcher. Woken fibers run on the waker's JS stack (Deferred, PubSub, fiber exit, Effect.callback) or through a dispatcher task (Queue.offer, Latch.open, Semaphore.release). Effeck makes no promise about whether a woken fiber runs before or after the waker's next step; programs that need an order must synchronize explicitly. Fairness is promised only at run-loop steps. A plain JavaScript region is atomic, exactly as an Effect.sync body is.

Kotlin and Swift never run a woken coroutine on the waker's stack: Kotlin to avoid stack overflow, Swift to avoid taking over the waker's thread for an unbounded time (continuation-prior-art.md rule 12). The kernel keeps Effect's synchronous fast path and bounds its depth instead (K10a). Both choices satisfy the rule above, and Effeck keeps the bounded fast path: always scheduling would add one dispatcher hop to every wake-up, and Effect's own wake-ups already run inline. A measurement that shows waker-blocking time mattering in real programs would change this default, not the rule.

Stack safety [Effect] [Kernel] [Rule]. Heap frames make recursion depth a heap question: T6a nests 100,001 compiled calls and captures all of them in one operation. Direct JavaScript recursion is bounded by the host: about 10,150 frames on Node 26.10 and about 39,900 on Bun 1.4.1 for a one-line recursive function (F9). Plain JavaScript functions recurse on that stack, as any JavaScript does (Chapter 15). Capture and resume copy the frames between the perform site and the prompt; the cost is linear in that distance (Chapter 25). Cross-fiber wake-ups are stack-safe only when bounded (K10a); Effect's own are not (F10a).

Cancellation [Effect] [Kernel]. Interruption is Effect's: a request is recorded, delivered at once to a parked fiber and at the next step to a running one, deferred by masks, and unwinds with recovery handlers skipped. The kernel adds three things. A held continuation is abandoned through its owner as part of the same unwinding (T4). Abandonment re-raises if a masked handler swallows it (kernel-edges). And a pending interruption is reported beside every cleanup failure, never instead of one (K12a).

Division of labor