effect 4.0.0 → 4.0.1

package/src/Effect.ts

@@ -13909,6 +13909,11 @@ export const onExitFilter: {
  * evaluations of the same effect will return the cached result without
  * re-executing the logic.
  *
+ * Concurrent callers share the pending computation, which is interrupted only
+ * once every caller waiting on it has been interrupted. Interrupted
+ * computations are never cached, so the next evaluation starts a fresh
+ * computation.
+ *
  * **Example** (Memoizing an effect until invalidated)
  *
  * ```ts import.meta.vitest
@@ -13970,11 +13975,12 @@ export const cached: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E, R>>
  * `Duration.Input`. The function runs once after each fresh computation,
  * including failures, so successes and failures can have different TTLs. It
  * does not run when the cache is created or when a cached result is reused.
- * The callback also receives interruption exits, which are cached for the
- * returned duration.
+ * Interrupted computations are never cached and do not call the function.
  *
  * The TTL starts when the computation completes. Concurrent callers share the
- * pending computation. A zero TTL expires immediately, and an infinite TTL
+ * pending computation, which is interrupted only once every caller waiting on
+ * it has been interrupted. The next evaluation then starts a fresh
+ * computation. A zero TTL expires immediately, and an infinite TTL
  * keeps the result indefinitely.
  *
  * **Example** (Memoizing an effect with TTL)
@@ -14054,11 +14060,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14138,11 +14145,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14222,11 +14230,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14306,11 +14315,12 @@ export const cachedWithTTL: {
    * `Duration.Input`. The function runs once after each fresh computation,
    * including failures, so successes and failures can have different TTLs. It
    * does not run when the cache is created or when a cached result is reused.
-   * The callback also receives interruption exits, which are cached for the
-   * returned duration.
+   * Interrupted computations are never cached and do not call the function.
    *
    * The TTL starts when the computation completes. Concurrent callers share the
-   * pending computation. A zero TTL expires immediately, and an infinite TTL
+   * pending computation, which is interrupted only once every caller waiting on
+   * it has been interrupted. The next evaluation then starts a fresh
+   * computation. A zero TTL expires immediately, and an infinite TTL
    * keeps the result indefinitely.
    *
    * **Example** (Memoizing an effect with TTL)
@@ -14371,8 +14381,8 @@ export const cachedWithTTL: {
 } = internal.cachedWithTTL
 
 /**
- * Creates a cached effect result for a specified duration and allows manual
- * invalidation before expiration.
+ * Creates a cached effect result for a fixed duration or a duration computed
+ * from its `Exit` and allows manual invalidation before expiration.
  *
  * **When to use**
  *
@@ -14430,8 +14440,67 @@ export const cachedWithTTL: {
  */
 export const cachedInvalidateWithTTL: {
   /**
-   * Creates a cached effect result for a specified duration and allows manual
-   * invalidation before expiration.
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
+   *
+   * **When to use**
+   *
+   * Use when an effect result should be cached for a bounded time and callers
+   * also need a manual invalidation effect to force recomputation before
+   * expiration.
+   *
+   * **Details**
+   *
+   * This function behaves similarly to {@link cachedWithTTL} by caching the
+   * result of an effect for a specified period of time. However, it introduces an
+   * additional feature: it provides an effect that allows you to manually
+   * invalidate the cached result before it naturally expires.
+   *
+   * This gives you more control over the cache, allowing you to refresh the
+   * result when needed, even if the original cache has not yet expired.
+   *
+   * Once the cache is invalidated, the next time the effect is evaluated, the
+   * result will be recomputed, and the cache will be refreshed.
+   *
+   * **Example** (Memoizing with TTL and invalidation)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect } from "effect"
+   * const output: Array<unknown> = []
+   * const record = (value: unknown) => Effect.sync(() => { output.push(value) })
+   *
+   * let i = 1
+   * const expensiveTask = Effect.sync(() => {
+   *   void output.push("expensive task...")
+   *   return `result ${i++}`
+   * })
+   *
+   * const program = Effect.gen(function*() {
+   *   const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL(
+   *     expensiveTask,
+   *     "1 hour"
+   *   )
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* invalidate
+   *   yield* cached.pipe(Effect.andThen(record))
+   * })
+   *
+   * Effect.runSync(program)
+   * output // => ["expensive task...", "result 1", "result 1", "expensive task...", "result 2"]
+   * ```
+   *
+   * @see {@link cached} for a similar function that caches the result
+   * indefinitely.
+   * @see {@link cachedWithTTL} for a similar function that caches the result for
+   * a specified duration but does not include an effect for manual invalidation.
+   * @category caching
+   * @since 2.0.0
+   */
+  <A, E>(timeToLive: (exit: Exit.Exit<A, E>) => Duration.Input): <R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
+  /**
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
    *
    * **When to use**
    *
@@ -14489,8 +14558,67 @@ export const cachedInvalidateWithTTL: {
    */
   (timeToLive: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
   /**
-   * Creates a cached effect result for a specified duration and allows manual
-   * invalidation before expiration.
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
+   *
+   * **When to use**
+   *
+   * Use when an effect result should be cached for a bounded time and callers
+   * also need a manual invalidation effect to force recomputation before
+   * expiration.
+   *
+   * **Details**
+   *
+   * This function behaves similarly to {@link cachedWithTTL} by caching the
+   * result of an effect for a specified period of time. However, it introduces an
+   * additional feature: it provides an effect that allows you to manually
+   * invalidate the cached result before it naturally expires.
+   *
+   * This gives you more control over the cache, allowing you to refresh the
+   * result when needed, even if the original cache has not yet expired.
+   *
+   * Once the cache is invalidated, the next time the effect is evaluated, the
+   * result will be recomputed, and the cache will be refreshed.
+   *
+   * **Example** (Memoizing with TTL and invalidation)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect } from "effect"
+   * const output: Array<unknown> = []
+   * const record = (value: unknown) => Effect.sync(() => { output.push(value) })
+   *
+   * let i = 1
+   * const expensiveTask = Effect.sync(() => {
+   *   void output.push("expensive task...")
+   *   return `result ${i++}`
+   * })
+   *
+   * const program = Effect.gen(function*() {
+   *   const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL(
+   *     expensiveTask,
+   *     "1 hour"
+   *   )
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* cached.pipe(Effect.andThen(record))
+   *   yield* invalidate
+   *   yield* cached.pipe(Effect.andThen(record))
+   * })
+   *
+   * Effect.runSync(program)
+   * output // => ["expensive task...", "result 1", "result 1", "expensive task...", "result 2"]
+   * ```
+   *
+   * @see {@link cached} for a similar function that caches the result
+   * indefinitely.
+   * @see {@link cachedWithTTL} for a similar function that caches the result for
+   * a specified duration but does not include an effect for manual invalidation.
+   * @category caching
+   * @since 2.0.0
+   */
+  <A, E>(timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)): <R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
+  /**
+   * Creates a cached effect result for a fixed duration or a duration computed
+   * from its `Exit` and allows manual invalidation before expiration.
    *
    * **When to use**
    *
@@ -14546,7 +14674,10 @@ export const cachedInvalidateWithTTL: {
    * @category caching
    * @since 2.0.0
    */
-  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.Input): Effect<[Effect<A, E, R>, Effect<void>]>
+  <A, E, R>(
+    self: Effect<A, E, R>,
+    timeToLive: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
+  ): Effect<[Effect<A, E, R>, Effect<void>]>
 } = internal.cachedInvalidateWithTTL
 
 // -----------------------------------------------------------------------------

package/src/HashRing.ts

@@ -179,12 +179,9 @@ export const addMany: {
         if (entry[1] === weight) continue
         toRemove ??= new Set()
         toRemove.add(key)
-        self.totalWeightCache -= entry[1]
-        self.totalWeightCache += weight
         entry[1] = weight
       } else {
         self.nodes.set(key, [node, weight])
-        self.totalWeightCache += weight
       }
       keys.push(key)
     }
@@ -192,6 +189,7 @@ export const addMany: {
       self.ring = self.ring.filter(([, n]) => !toRemove.has(n))
     }
     addNodesToRing(self, keys, Math.round(weight * self.baseWeight))
+    updateTotalWeight(self)
     return self
   }
 )
@@ -206,7 +204,18 @@ function addNodesToRing<A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, keys
       ])
     }
   }
-  self.ring.sort((a, b) => a[0] - b[0])
+  // Break hash ties by node key to avoid insertion-order dependence.
+  self.ring.sort((a, b) => a[0] - b[0] || (a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0))
+}
+
+// Sum in key order to avoid history-dependent floating-point rounding.
+function updateTotalWeight<A extends PrimaryKey.PrimaryKey>(self: HashRing<A>) {
+  const keys = Array.from(self.nodes.keys()).sort()
+  let total = 0
+  for (let i = 0; i < keys.length; i++) {
+    total += self.nodes.get(keys[i])![1]
+  }
+  self.totalWeightCache = total
 }
 
 /**
@@ -380,7 +389,7 @@ export const remove: {
   if (entry) {
     self.nodes.delete(key)
     self.ring = self.ring.filter(([, n]) => n !== key)
-    self.totalWeightCache -= entry[1]
+    updateTotalWeight(self)
   }
   return self
 })

package/src/Pool.ts

@@ -19,7 +19,6 @@ import * as Fiber from "./Fiber.ts"
 import { constant, dual, identity } from "./Function.ts"
 import * as core from "./internal/core.ts"
 import * as internal from "./internal/effect.ts"
-import * as Iterable from "./Iterable.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Queue from "./Queue.ts"
@@ -31,10 +30,12 @@ const TypeId = "~effect/Pool"
 
 const Acquire = Symbol()
 const AcquireContext = Symbol()
+const PoolClock = Symbol()
 
 interface PoolImpl<A, E> extends Pool<A, E> {
   readonly [Acquire]: Effect.Effect<A, E, Scope.Scope>
   readonly [AcquireContext]: Context.Context<Scope.Scope>
+  readonly [PoolClock]: Clock
 }
 
 /**
@@ -119,7 +120,6 @@ export interface State<A, E> {
   isShuttingDown: boolean
   usage: number
   readonly resizeSemaphore: Semaphore.Semaphore
-  // Insertion order determines usage-TTL retirement order; reclaimed items move to the back.
   readonly items: Set<PoolItem<A, E>>
   availableHead: PoolItem<A, E> | undefined
   availableTail: PoolItem<A, E> | undefined
@@ -139,8 +139,8 @@ export interface State<A, E> {
  * **Details**
  *
  * Each item stores the acquisition `Exit`, its finalizer, the current
- * reference count, and whether automatic reclaiming has been disabled because
- * the item was invalidated.
+ * reference count, when it last became idle, and whether automatic reclaiming
+ * has been disabled because the item was invalidated.
  *
  * @see {@link Strategy} for the custom strategy callbacks that receive and return pool items
  * @see {@link State} for the runtime sets that store active, available, and invalidated pool items
@@ -152,6 +152,8 @@ export interface PoolItem<A, E> {
   readonly exit: Exit.Exit<A, E>
   finalizer: Effect.Effect<void>
   refCount: number
+  /** Clock time at which the item was acquired or its last borrower released it. */
+  idleSince: number
   disableReclaim: boolean
   isAvailable: boolean
   availablePrevious: PoolItem<A, E> | undefined
@@ -257,9 +259,11 @@ export const make = <A, E, R>(options: {
  * pool implementation. A value of `1` waits until existing items are fully
  * utilized before creating more items.
  *
- * `timeToLiveStrategy` controls when excess items expire: `"creation"` measures
- * from item creation, while `"usage"` measures from pool usage. The default is
- * `"usage"`.
+ * `timeToLiveStrategy` defaults to `"usage"`, which expires idle, unreserved
+ * excess items after `timeToLive` since their last borrower released them
+ * (or acquisition if never borrowed). It checks once per `timeToLive`, so
+ * retirement can take up to twice that duration. `"creation"` measures from
+ * item creation instead.
  *
  * **Example** (Creating a connection pool)
  *
@@ -374,6 +378,7 @@ export const makeWithStrategy = <A, E, R>(options: {
       [TypeId]: TypeId,
       [Acquire]: options.acquire as Effect.Effect<A, E, Scope.Scope>,
       [AcquireContext]: services as Context.Context<Scope.Scope>,
+      [PoolClock]: yield* Clock,
       config,
       state,
       pipe() {
@@ -676,6 +681,9 @@ const releaseItem = <A, E>(self: Pool<A, E>, item: PoolItem<A, E>): Effect.Effec
     const state = self.state
     item.refCount--
     state.usage--
+    if (item.refCount === 0) {
+      item.idleSince = (self as PoolImpl<A, E>)[PoolClock].currentTimeMillisUnsafe()
+    }
     if (state.invalidated.has(item)) {
       return invalidatePoolItem(self, item)
     }
@@ -1014,6 +1022,7 @@ const allocate = <A, E>(self: Pool<A, E>): Effect.Effect<PoolItem<A, E>> =>
           exit,
           finalizer: Effect.catchCause(Scope.close(scope, exit), reportUnhandledError),
           refCount: 0,
+          idleSince: impl[PoolClock].currentTimeMillisUnsafe(),
           disableReclaim: false,
           isAvailable: false,
           availablePrevious: undefined,
@@ -1110,19 +1119,21 @@ const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Inpu
   })
 })
 
-const strategyUsageTTL = <A, E>(ttl: Duration.Input): Effect.Effect<Strategy<A, E>> =>
-  Effect.succeed<Strategy<A, E>>({
+const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
+  const clock = yield* Clock
+  const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
+  return identity<Strategy<A, E>>({
     run: (pool) => {
-      // `state.items` iterates in insertion order, so its oldest live entry is
-      // the next to retire. Using it directly means an item stops being
-      // referenced by this strategy as soon as it leaves the pool.
       const process: Effect.Effect<void> = Effect.suspend(() => {
         if (activeSize(pool) <= targetSize(pool)) return Effect.void
+        const expired = clock.currentTimeMillisUnsafe() - ttlMillis
+        let oldest: PoolItem<A, E> | undefined
         for (const item of pool.state.items) {
-          if (pool.state.invalidated.has(item)) continue
-          return Effect.flatMap(invalidatePoolItem(pool, item), () => process)
+          if (item.refCount > 0 || item.idleSince > expired) continue
+          if (pool.state.invalidated.has(item) || reservations.has(item)) continue
+          if (oldest === undefined || item.idleSince < oldest.idleSince) oldest = item
         }
-        return Effect.void
+        return oldest === undefined ? Effect.void : Effect.flatMap(invalidatePoolItem(pool, oldest), () => process)
       })
       return process.pipe(
         Effect.delay(ttl),
@@ -1130,28 +1141,9 @@ const strategyUsageTTL = <A, E>(ttl: Duration.Input): Effect.Effect<Strategy<A,
       )
     },
     onAcquire: (_) => Effect.void,
-    reclaim(pool) {
-      return Effect.suspend((): Effect.Effect<PoolItem<A, E> | undefined> => {
-        if (pool.state.invalidated.size === 0) {
-          return Effect.undefined
-        }
-        const item = Iterable.head(
-          Iterable.filter(pool.state.invalidated, (item) => !item.disableReclaim && !reservations.has(item))
-        )
-        if (item._tag === "None") {
-          return Effect.undefined
-        }
-        pool.state.invalidated.delete(item.value)
-        // Re-adding moves the reclaimed item to the back of the retirement order.
-        pool.state.items.delete(item.value)
-        pool.state.items.add(item.value)
-        if (item.value.refCount < pool.config.concurrency) {
-          addAvailable(pool, item.value)
-        }
-        return Effect.succeed(item.value)
-      })
-    }
+    reclaim: (_) => Effect.undefined
   })
+})
 
 const reportUnhandledError = <E>(cause: Cause.Cause<E>) =>
   Effect.withFiber<void>((fiber) => {

package/src/RcMap.ts

@@ -566,10 +566,16 @@ export const get: {
           context.set(key, value)
         })
         context.set(Scope.Scope.key, entry.scope)
+        const lookupContext: Context.Context<Scope.Scope> = Context.makeUnsafe(context)
         Effect.suspend(() => self.lookup(key)).pipe(
-          Effect.runForkWith(Context.makeUnsafe(context)),
+          Effect.runForkWith(lookupContext),
           Fiber.runIn(entry.scope)
-        ).addObserver((exit) => Deferred.doneUnsafe(entry.deferred, exit))
+        ).addObserver((exit) => {
+          // Interruption is abandonment, so the entry is dropped and the next
+          // get starts a fresh lookup.
+          if (Exit.hasInterrupts(exit)) removeInterrupted(self, key, entry, lookupContext)
+          Deferred.doneUnsafe(entry.deferred, exit)
+        })
       }
       const scope = Context.getUnsafe(parent.context, Scope.Scope)
       return Scope.addFinalizer(scope, entry.finalizer).pipe(
@@ -733,6 +739,24 @@ export const getOption: {
     })
 )
 
+const removeInterrupted = <K, A, E>(
+  self: RcMap<K, A, E>,
+  key: K,
+  entry: State.Entry<A, E>,
+  context: Context.Context<Scope.Scope>
+) => {
+  if (self.state._tag === "Closed") return
+  const o = MutableHashMap.get(self.state.map, key)
+  if (o._tag === "None" || o.value !== entry) return
+  MutableHashMap.remove(self.state.map, key)
+  // Borrowers close the entry on release; an idle entry has none left.
+  if (entry.refCount > 0) return
+  closeEntry(entry).pipe(
+    Effect.runForkWith(context),
+    Fiber.runIn(self.scope)
+  )
+}
+
 const closeEntry = <A, E>(entry: State.Entry<A, E>) =>
   entry.fiber
     ? Fiber.interrupt(entry.fiber).pipe(Effect.andThen(Scope.close(entry.scope, Exit.void)))

package/src/ScopedCache.ts

@@ -317,7 +317,7 @@ export const get: {
           // Move the entry to the end of the map to keep it fresh
           MutableHashMap.remove(state.map, key)
           MutableHashMap.set(state.map, key, oentry.value)
-          return awaitEntry(oentry.value, restore)
+          return awaitEntry(self, key, oentry.value, restore)
         }
         const scope = Scope.makeUnsafe()
         const deferred = Deferred.makeUnsafe</**
@@ -380,41 +380,46 @@ export const get: {
             entry.fiber = effect.forkUnsafe(
               fiber,
               effect.onExit(effect.suspend(() => Scope.provide(self.lookup(key), scope)), (exit) => {
-                Deferred.doneUnsafe(deferred, exit)
                 if (effect.exitHasInterrupts(exit)) {
-                  if (self.state._tag === "Open") {
-                    const current = MutableHashMap.get(self.state.map, key)
-                    if (Option.isSome(current) && current.value === entry) MutableHashMap.remove(self.state.map, key)
-                  }
+                  removeEntry(self, key, entry)
+                  Deferred.doneUnsafe(deferred, exit)
                   return Scope.close(scope, exit)
                 }
-                const ttl = self.timeToLive(exit, key)
-                if (Duration.isFinite(ttl)) {
-                  entry.expiresAt = fiber.getRef(effect.ClockRef).currentTimeMillisUnsafe() + Duration.toMillis(ttl)
+                try {
+                  const ttl = self.timeToLive(exit, key)
+                  if (Duration.isFinite(ttl)) {
+                    entry.expiresAt = fiber.getRef(effect.ClockRef).currentTimeMillisUnsafe() + Duration.toMillis(ttl)
+                  }
+                } finally {
+                  Deferred.doneUnsafe(deferred, exit)
                 }
                 return effect.void
               }),
               true,
               true
             )
-            return awaitEntry(entry, restore)
+            return awaitEntry(self, key, entry, restore)
           })
         )
       })
     )
 )
 
-const awaitEntry = <A, E>(
+const awaitEntry = <Key, A, E, R>(
+  self: ScopedCache<Key, A, E, R>,
+  key: Key,
   entry: Entry<A, E>,
   restore: <X, Y, Z>(effect: Effect.Effect<X, Y, Z>) => Effect.Effect<X, Y, Z>
 ): Effect.Effect<A, E> => {
-  const fiber = entry.fiber
-  if (fiber === undefined || Deferred.isDoneUnsafe(entry.deferred)) return restore(Deferred.await(entry.deferred))
+  if (Deferred.isDoneUnsafe(entry.deferred)) return restore(Deferred.await(entry.deferred))
   entry.awaiters++
   // Install cleanup before restore so a pending interrupt cannot skip the decrement.
   return effect.onExit(restore(Deferred.await(entry.deferred)), () => {
     entry.awaiters--
-    if (entry.awaiters > 0 || Deferred.isDoneUnsafe(entry.deferred)) return effect.void
+    const fiber = entry.fiber
+    if (entry.awaiters > 0 || fiber === undefined || Deferred.isDoneUnsafe(entry.deferred)) return effect.void
+    // Detach before interruption so callers arriving during finalization start fresh.
+    removeEntry(self, key, entry)
     return effect.flatMap(effect.fiberInterrupt(fiber), () => {
       const exit = fiber.pollUnsafe()!
       return Exit.isFailure(exit) && Cause.hasDies(exit.cause) ? effect.failCause(exit.cause) : effect.void
@@ -422,6 +427,12 @@ const awaitEntry = <A, E>(
   })
 }
 
+const removeEntry = <Key, A, E, R>(self: ScopedCache<Key, A, E, R>, key: Key, entry: Entry<A, E>): void => {
+  if (self.state._tag !== "Open") return
+  const current = MutableHashMap.get(self.state.map, key)
+  if (Option.isSome(current) && current.value === entry) MutableHashMap.remove(self.state.map, key)
+}
+
 const hasExpired = <A, E>(entry: Entry<A, E>, fiber: Fiber.Fiber<unknown, unknown>): boolean => {
   if (entry.expiresAt === undefined) {
     return false
@@ -518,7 +529,7 @@ export const getOption: {
       core.withFiber((fiber) =>
         effect.flatMap(
           getImpl(self, key, fiber),
-          (entry) => entry ? effect.asSome(awaitEntry(entry, restore)) : effect.succeedNone
+          (entry) => entry ? effect.asSome(awaitEntry(self, key, entry, restore)) : effect.succeedNone
         )
       )
     )
@@ -1004,7 +1015,7 @@ export const invalidateWhen: {
           if (entry === undefined) {
             return effect.succeed(false)
           }
-          return awaitEntry(entry, restore).pipe(
+          return awaitEntry(self, key, entry, restore).pipe(
             effect.flatMap((value) => {
               if (self.state._tag === "Closed") {
                 return effect.succeed(false)