FiberHandle.clear looks racy ?

[tensor2077]

What version of Effect is running?

3.19.11

What steps can reproduce the bug?

See:

effect/packages/effect/src/FiberHandle.ts

Lines 317 to 321 in fb78c40

	restore(Fiber.interruptAs(self.state.fiber, FiberId.combine(fiber.id(), internalFiberId))),
	Effect.sync(() => {
	if (self.state._tag === "Open") {
	self.state.fiber = undefined
	}

export const clear = <A, E>(self: FiberHandle<A, E>): Effect.Effect<void> =>
  Effect.uninterruptibleMask((restore) =>
    Effect.withFiberRuntime((fiber) => {
      if (self.state._tag === "Closed" || self.state.fiber === undefined) {
        return Effect.void
      }

      return Effect.zipRight(
        // This can suspend while waiting for the target fiber to actually terminate,
        // which opens a window for another fiber to call FiberHandle.run/set.
        restore(Fiber.interruptAs(self.state.fiber, FiberId.combine(fiber.id(), internalFiberId))),
        Effect.sync(() => {
          // If another fiber stored a new fiber into the handle while we were waiting above,
          // this unconditional write can wipe out the newer reference.
          if (self.state._tag === "Open") {
            self.state.fiber = undefined
          }
        })
      )
    })
  )

clear interrupts the fiber currently stored in the handle and then waits for it to finish. While it’s waiting, another fiber can call FiberHandle.run / set and put a new fiber into the handle. When clear continues, it blindly does state.fiber = undefined, which can wipe out the newer fiber reference.

So the handle can appear empty (e.g. unsafeGet returns None / get fails) even though the newer fiber is still running, meaning the handle has lost the reference and can no longer cancel/manage that fiber.

perhaps a fix like this:

export const clear = <A, E>(self: FiberHandle<A, E>): Effect.Effect<void> =>
  Effect.uninterruptibleMask((restore) =>
    Effect.withFiberRuntime((runtimeFiber) => {
      if (self.state._tag === "Closed" || self.state.fiber === undefined) {
        return Effect.void
      }

      const target = self.state.fiber

      return Effect.zipRight(
        restore(Fiber.interruptAs(target, FiberId.combine(runtimeFiber.id(), internalFiberId))),
        Effect.sync(() => {
          if (self.state._tag === "Open" && self.state.fiber === target) {
            self.state.fiber = undefined
          }
        })
      )
    })
  )

What is the expected behavior?

No response

What do you see instead?

No response

Additional information

No response

[tensor2077]

reproduce example

import { Effect, FiberHandle, Fiber, Option, Duration } from "effect"

const program = Effect.gen(function* () {
  const handle = yield* FiberHandle.make()

  // Old fiber: even after being interrupted, it will not finish immediately.
  // We use an uninterruptible sleep to keep it alive long enough to create a
  // "waiting window" inside FiberHandle.clear (while it is awaiting interruptAs).
  yield* FiberHandle.run(
    handle,
    Effect.log("old: started").pipe(
      Effect.zipRight(Effect.uninterruptible(Effect.sleep(Duration.millis(200)))),
      Effect.zipRight(Effect.log("old: done"))
    )
  )

  // Fiber1: start `clear(handle)` in the background, but DO NOT await it yet.
  // This is the key: `clear` may suspend while waiting for the old fiber to terminate.
  const clearFiber = yield* Effect.fork(
    Effect.log("clear: begin").pipe(
      Effect.zipRight(FiberHandle.clear(handle)),
      Effect.zipRight(Effect.log("clear: done"))
    )
  )
  yield* Effect.log("main: clear forked (not awaited)")

  // Ensure Fiber2 happens after `clear` has started, but before it has finished.
  yield* Effect.sleep(Duration.millis(50))

  // Fiber2: store a new fiber that never completes by itself.
  // If the race is present, `clear` may later set `handle.state.fiber = undefined`
  // and wipe out this new reference.
  const newFiber = yield* FiberHandle.run(handle, Effect.never)
  yield* Effect.log("main: new fiber stored")

  // Now wait for `clear` to finish, then check whether it wiped the handle's fiber reference.
  yield* Fiber.join(clearFiber)

  const has = Option.isSome(FiberHandle.unsafeGet(handle))
  yield* Effect.log(`main: after clear, handle has fiber? ${has}`)

  // `Fiber.poll` is non-blocking: it returns Some(exit) if the fiber is done, otherwise None.
  // If `has` is false but `newFiber` is not done, it means the handle "lost" the new fiber reference
  // while the fiber is still running.
  const polled = yield* Fiber.poll(newFiber)
  yield* Effect.log(`main: new fiber done? ${Option.isSome(polled)}`)

  // Cleanup (avoid leaking a never-ending fiber in the playground)
  yield* Fiber.interrupt(newFiber)
  yield* Effect.log("main: cleanup done")
}).pipe(Effect.scoped)

Effect.runPromise(program)

The log is

timestamp=2025-12-16T05:14:09.377Z level=INFO fiber=#0 message="main: clear forked (not awaited)"
timestamp=2025-12-16T05:14:09.379Z level=INFO fiber=#1 message="old: started"
timestamp=2025-12-16T05:14:09.379Z level=INFO fiber=#2 message="clear: begin"
timestamp=2025-12-16T05:14:09.429Z level=INFO fiber=#0 message="main: new fiber stored"
timestamp=2025-12-16T05:14:09.580Z level=INFO fiber=#2 message="clear: done"


timestamp=2025-12-16T05:14:09.581Z level=INFO fiber=#0 message="main: after clear, handle has fiber? false" // This doesn't seem like expected behavior
timestamp=2025-12-16T05:14:09.581Z level=INFO fiber=#0 message="main: new fiber done? false"
timestamp=2025-12-16T05:14:09.581Z level=INFO fiber=#0 message="main: cleanup done"