effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/PrimaryKey.ts

@@ -24,7 +24,7 @@ import { hasProperty } from "./Predicate.ts"
  * @category symbols
  * @since 2.0.0
  */
-export const symbol = "~effect/interfaces/PrimaryKey"
+export const symbol = "~effect/PrimaryKey"
 
 /**
  * An interface for objects that can provide a string-based primary key.

package/src/PubSub.ts

@@ -17,6 +17,7 @@ import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import type { LazyArg } from "./Function.ts"
 import { dual, identity } from "./Function.ts"
+import * as Count from "./internal/count.ts"
 import * as Latch from "./Latch.ts"
 import * as MutableList from "./MutableList.ts"
 import * as MutableRef from "./MutableRef.ts"
@@ -1461,7 +1462,9 @@ const pollForItem = <A>(self: Subscription<A>) => {
 }
 
 /**
- * Takes up to the specified number of messages from the subscription without suspending.
+ * Takes up to the specified number of messages from the subscription without
+ * suspending. Finite fractional values are rounded down, while `NaN` and
+ * non-positive values are treated as `0`.
  *
  * **Example** (Taking up to a maximum number of messages)
  *
@@ -1496,7 +1499,9 @@ const pollForItem = <A>(self: Subscription<A>) => {
  */
 export const takeUpTo: {
   /**
-   * Takes up to the specified number of messages from the subscription without suspending.
+   * Takes up to the specified number of messages from the subscription without
+   * suspending. Finite fractional values are rounded down, while `NaN` and
+   * non-positive values are treated as `0`.
    *
    * **Example** (Taking up to a maximum number of messages)
    *
@@ -1531,7 +1536,9 @@ export const takeUpTo: {
    */
   (max: number): <A>(self: Subscription<A>) => Effect.Effect<Array<A>>
   /**
-   * Takes up to the specified number of messages from the subscription without suspending.
+   * Takes up to the specified number of messages from the subscription without
+   * suspending. Finite fractional values are rounded down, while `NaN` and
+   * non-positive values are treated as `0`.
    *
    * **Example** (Taking up to a maximum number of messages)
    *
@@ -1568,6 +1575,7 @@ export const takeUpTo: {
 } = dual(2, <A>(self: Subscription<A>, max: number): Effect.Effect<Array<A>> =>
   Effect.suspend(() => {
     if (self.shutdownFlag.current) return Effect.interrupt
+    max = Count.normalize(max)
     let replay: Array<A> | undefined = undefined
     if (self.replayWindow.remaining >= max) {
       return Effect.succeed(self.replayWindow.takeN(max))
@@ -1583,8 +1591,10 @@ export const takeUpTo: {
   }))
 
 /**
- * Takes between the specified minimum and maximum number of messages from the subscription.
- * Will suspend if the minimum number is not immediately available.
+ * Takes between the specified minimum and maximum number of messages from the
+ * subscription. Finite fractional bounds are rounded down, while `NaN` and
+ * non-positive bounds are treated as `0`. Will suspend if the normalized
+ * minimum number is not immediately available.
  *
  * **Example** (Taking between a minimum and maximum)
  *
@@ -1615,8 +1625,10 @@ export const takeUpTo: {
  */
 export const takeBetween: {
   /**
-   * Takes between the specified minimum and maximum number of messages from the subscription.
-   * Will suspend if the minimum number is not immediately available.
+   * Takes between the specified minimum and maximum number of messages from the
+   * subscription. Finite fractional bounds are rounded down, while `NaN` and
+   * non-positive bounds are treated as `0`. Will suspend if the normalized
+   * minimum number is not immediately available.
    *
    * **Example** (Taking between a minimum and maximum)
    *
@@ -1647,8 +1659,10 @@ export const takeBetween: {
    */
   (min: number, max: number): <A>(self: Subscription<A>) => Effect.Effect<Array<A>>
   /**
-   * Takes between the specified minimum and maximum number of messages from the subscription.
-   * Will suspend if the minimum number is not immediately available.
+   * Takes between the specified minimum and maximum number of messages from the
+   * subscription. Finite fractional bounds are rounded down, while `NaN` and
+   * non-positive bounds are treated as `0`. Will suspend if the normalized
+   * minimum number is not immediately available.
    *
    * **Example** (Taking between a minimum and maximum)
    *
@@ -1681,7 +1695,7 @@ export const takeBetween: {
 } = dual(
   3,
   <A>(self: Subscription<A>, min: number, max: number): Effect.Effect<Array<A>> =>
-    Effect.suspend(() => takeRemainderLoop(self, min, max, []))
+    Effect.suspend(() => takeRemainderLoop(self, Count.normalize(min), Count.normalize(max), []))
 )
 
 const takeRemainderLoop = <A>(
@@ -2006,6 +2020,7 @@ class BoundedPubSubArbSubscription<in out A> implements PubSub.BackingSubscripti
   }
 
   pollUpTo(n: number): Array<A> {
+    n = Count.normalize(n)
     if (this.unsubscribed) {
       return []
     }
@@ -2202,6 +2217,7 @@ class BoundedPubSubPow2Subscription<in out A> implements PubSub.BackingSubscript
   }
 
   pollUpTo(n: number): Array<A> {
+    n = Count.normalize(n)
     if (this.unsubscribed) {
       return []
     }
@@ -2364,28 +2380,22 @@ class BoundedPubSubSingleSubscription<in out A> implements PubSub.BackingSubscri
     if (this.self.subscribers === 0) {
       this.self.value = AbsentValue as unknown as A
     }
-    this.subscriberIndex += 1
+    this.subscriberIndex = this.self.publisherIndex
     return elem
   }
 
   pollUpTo(n: number): Array<A> {
-    if (this.isEmpty() || n < 1) {
+    if (Count.normalize(n) < 1 || this.isEmpty()) {
       return []
     }
-    const a = this.self.value
-    this.self.subscribers -= 1
-    if (this.self.subscribers === 0) {
-      this.self.value = AbsentValue as unknown as A
-    }
-    this.subscriberIndex += 1
-    return [a]
+    return [this.poll() as A]
   }
 
   unsubscribe(): void {
     if (!this.unsubscribed) {
       this.unsubscribed = true
       this.self.subscriberCount -= 1
-      if (this.subscriberIndex !== this.self.publisherIndex) {
+      if (this.self.subscribers !== 0 && this.subscriberIndex !== this.self.publisherIndex) {
         this.self.subscribers -= 1
         if (this.self.subscribers === 0) {
           this.self.value = AbsentValue as unknown as A
@@ -2562,6 +2572,7 @@ class UnboundedPubSubSubscription<in out A> implements PubSub.BackingSubscriptio
   }
 
   pollUpTo(n: number): Array<A> {
+    n = Count.normalize(n)
     const builder: Array<A> = []
     let i = 0
     while (i !== n) {
@@ -3143,6 +3154,7 @@ class ReplayWindowImpl<A> implements PubSub.ReplayWindow<A> {
     return value as A
   }
   takeN(n: number): Array<A> {
+    n = Count.normalize(n)
     const len = Math.min(n, this.remaining)
     const items = new Array(len)
     for (let i = 0; i < len; i++) {

package/src/Queue.ts

@@ -16,6 +16,7 @@ import { constant, constTrue, dual, identity } from "./Function.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as core from "./internal/core.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
+import * as Count from "./internal/count.ts"
 import * as internalEffect from "./internal/effect.ts"
 import * as MutableList from "./MutableList.ts"
 import * as Option from "./Option.ts"
@@ -1348,9 +1349,10 @@ export const collect = <A, E>(self: Dequeue<A, E | Done>): Effect<Array<A>, Pull
  * **Details**
  *
  * The operation may wait until enough messages are available to satisfy the
- * queue's batching rules. If `n` is less than or equal to zero, it succeeds
- * with an empty array. If the queue completes or fails before messages can be
- * taken, the effect fails with the queue's terminal error.
+ * queue's batching rules. Finite fractional values of `n` are rounded down.
+ * If `n` is `NaN` or non-positive, it succeeds with an empty array. If the
+ * queue completes or fails before messages can be taken, the effect fails with
+ * the queue's terminal error.
  *
  * **Example** (Taking a fixed number of values)
  *
@@ -1391,9 +1393,10 @@ export const takeN = <A, E>(
  * **Details**
  *
  * The operation waits when fewer than the required minimum messages are
- * available. It returns at most `max` messages. If the queue completes or fails
- * before the minimum can be satisfied, the effect fails with the queue's
- * terminal error.
+ * available. It returns at most `max` messages. Finite fractional bounds are
+ * rounded down, while `NaN` and non-positive bounds are treated as `0`. If the
+ * queue completes or fails before the minimum can be satisfied, the effect
+ * fails with the queue's terminal error.
  *
  * **Example** (Taking a bounded batch of values)
  *
@@ -1427,10 +1430,13 @@ export const takeBetween = <A, E>(
   self: Dequeue<A, E>,
   min: number,
   max: number
-): Effect<Array<A>, E> =>
-  internalEffect.suspend(() =>
+): Effect<Array<A>, E> => {
+  min = Count.normalize(min)
+  max = Count.normalize(max)
+  return internalEffect.suspend(() =>
     takeBetweenUnsafe(self, min, max) ?? internalEffect.andThen(awaitTake(self), takeBetween(self, 1, max))
   )
+}
 
 /**
  * Takes a single message from the queue, or wait for a message to be
@@ -1612,16 +1618,89 @@ export const takeUnsafe = <A, E>(self: Dequeue<A, E>): Exit<A, E> | undefined =>
     releaseCapacity(self)
     return core.exitSucceed(message)
   } else if (self.capacity <= 0 && self.state.offers.size > 0) {
-    self.capacity = 1
-    releaseCapacity(self)
-    self.capacity = 0
-    const message = MutableList.take(self.messages)!
+    const message = takeOfferUnsafe(self.state.offers)
     releaseCapacity(self)
     return core.exitSucceed(message)
   }
   return undefined
 }
 
+/**
+ * Manually releases current queue takers synchronously.
+ *
+ * **When to use**
+ *
+ * Use when synchronous offers should release waiting consumers immediately
+ * instead of waiting for the scheduled release task.
+ *
+ * **Details**
+ *
+ * This immediately runs the queue's taker-release pass instead of waiting for
+ * its scheduled task. It does not complete the queue or resume fibers waiting
+ * on `Queue.await`.
+ *
+ * **Example** (Releasing a waiting taker synchronously)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Fiber, Queue } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const queue = yield* Queue.unbounded<number>()
+ *   const taker = yield* Queue.take(queue).pipe(Effect.forkChild)
+ *   yield* Effect.yieldNow
+ *
+ *   Queue.offerUnsafe(queue, 1)
+ *   Queue.flushUnsafe(queue)
+ *
+ *   return yield* Fiber.join(taker)
+ * })
+ *
+ * await Effect.runPromise(program) // => 1
+ * ```
+ *
+ * @category offering
+ * @since 4.0.0
+ */
+export const flushUnsafe = <A, E>(self: Enqueue<A, E>): void => releaseTakers(self)
+
+/**
+ * Manually releases current queue takers.
+ *
+ * **When to use**
+ *
+ * Use when synchronous offers should release waiting consumers through an
+ * `Effect` instead of waiting for the scheduled release task.
+ *
+ * **Details**
+ *
+ * This immediately runs the queue's taker-release pass instead of waiting for
+ * its scheduled task. It does not complete the queue or resume fibers waiting
+ * on `Queue.await`.
+ *
+ * **Example** (Releasing a waiting taker)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Fiber, Queue } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const queue = yield* Queue.unbounded<number>()
+ *   const taker = yield* Queue.take(queue).pipe(Effect.forkChild)
+ *   yield* Effect.yieldNow
+ *
+ *   Queue.offerUnsafe(queue, 1)
+ *   yield* Queue.flush(queue)
+ *
+ *   return yield* Fiber.join(taker)
+ * })
+ *
+ * await Effect.runPromise(program) // => 1
+ * ```
+ *
+ * @category offering
+ * @since 4.0.0
+ */
+export const flush = <A, E>(self: Enqueue<A, E>): Effect<void> => internalEffect.sync(() => flushUnsafe(self))
+
 const await_ = <A, E>(self: Dequeue<A, E>): Effect<void, Exclude<E, Done>> =>
   internalEffect.callback<void, Exclude<E, Done>>((resume) => {
     const awaiter = (effect: Effect<void, E>) => resume(Pull.catchDone(effect, () => internalEffect.exitVoid))
@@ -1953,7 +2032,6 @@ const exitFailDone = core.exitFail(core.Done()) as Failure<never, Done>
 const exitInterrupt = internalEffect.exitInterrupt() as Failure<never, never>
 
 const releaseTakers = <A, E>(self: Enqueue<A, E>) => {
-  self.scheduleRunning = false
   if (self.state._tag === "Done" || self.state.takers.size === 0) {
     return
   }
@@ -1971,7 +2049,10 @@ const scheduleReleaseTaker = <A, E>(self: Enqueue<A, E>) => {
     return
   }
   self.scheduleRunning = true
-  self.dispatcher.scheduleTask(() => releaseTakers(self), 0)
+  self.dispatcher.scheduleTask(() => {
+    self.scheduleRunning = false
+    releaseTakers(self)
+  }, 0)
 }
 
 const takeBetweenUnsafe = <A, E>(
@@ -1983,11 +2064,8 @@ const takeBetweenUnsafe = <A, E>(
     return self.state.exit
   } else if (max <= 0 || min <= 0) {
     return core.exitSucceed([])
-  } else if (self.capacity <= 0 && self.state.offers.size > 0) {
-    self.capacity = 1
-    releaseCapacity(self)
-    self.capacity = 0
-    const messages = [MutableList.take(self.messages)!]
+  } else if (self.capacity <= 0 && self.messages.length === 0 && self.state.offers.size > 0) {
+    const messages = [takeOfferUnsafe(self.state.offers)]
     releaseCapacity(self)
     return core.exitSucceed(messages)
   }
@@ -2034,6 +2112,22 @@ const offerRemainingArray = <A, E>(self: Enqueue<A, E>, remaining: Array<A>) =>
   })
 }
 
+// Reserve a pending message for the consumer before the producer can reenter.
+const takeOfferUnsafe = <A>(offers: Set<Queue.OfferEntry<A>>): A => {
+  const entry = offers.values().next().value!
+  if (entry._tag === "Single") {
+    offers.delete(entry)
+    entry.resume(exitTrue)
+    return entry.message
+  }
+  const message = entry.remaining[entry.offset++]
+  if (entry.offset === entry.remaining.length) {
+    offers.delete(entry)
+    entry.resume(core.exitSucceed([]))
+  }
+  return message
+}
+
 const releaseCapacity = <A, E>(self: Dequeue<A, E>): boolean => {
   if (self.state._tag === "Done") {
     return Pull.isDoneCause(self.state.exit.cause)
@@ -2047,22 +2141,22 @@ const releaseCapacity = <A, E>(self: Dequeue<A, E>): boolean => {
     }
     return false
   }
-  let n = self.capacity - self.messages.length
+  // Resuming a producer can synchronously take, offer, or shut down this queue.
   for (const entry of self.state.offers) {
-    if (n === 0) break
+    let n = self.capacity - self.messages.length
+    if (n <= 0) break
     else if (entry._tag === "Single") {
       MutableList.append(self.messages, entry.message)
-      n--
-      entry.resume(exitTrue)
       self.state.offers.delete(entry)
+      entry.resume(exitTrue)
     } else {
       for (; entry.offset < entry.remaining.length; entry.offset++) {
         if (n === 0) return false
         MutableList.append(self.messages, entry.remaining[entry.offset])
         n--
       }
-      entry.resume(core.exitSucceed([]))
       self.state.offers.delete(entry)
+      entry.resume(core.exitSucceed([]))
     }
   }
   return false
@@ -2087,10 +2181,7 @@ const takeAllUnsafe = <A, E>(self: Dequeue<A, E>) => {
     releaseCapacity(self)
     return messages
   } else if (self.state._tag !== "Done" && self.state.offers.size > 0) {
-    self.capacity = 1
-    releaseCapacity(self)
-    self.capacity = 0
-    const messages = [MutableList.take(self.messages)!]
+    const messages = [takeOfferUnsafe(self.state.offers)]
     releaseCapacity(self)
     return messages
   }

package/src/Random.ts

@@ -17,6 +17,23 @@ import * as random from "./internal/random.ts"
 import type * as NonEmptyIterable from "./NonEmptyIterable.ts"
 import * as Predicate from "./Predicate.ts"
 
+/**
+ * The service used to generate pseudo-random numbers.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export interface Random {
+  /**
+   * Generates a random safe integer.
+   */
+  nextIntUnsafe(): number
+  /**
+   * Generates a random number between 0 (inclusive) and 1 (exclusive).
+   */
+  nextDoubleUnsafe(): number
+}
+
 /**
  * Represents a service for generating pseudo-random numbers.
  *
@@ -49,12 +66,9 @@ import * as Predicate from "./Predicate.ts"
  * @category services
  * @since 2.0.0
  */
-export const Random: Context.Reference<{
-  nextIntUnsafe(): number
-  nextDoubleUnsafe(): number
-}> = random.Random
+export const Random: Context.Reference<Random> = random.Random
 
-const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effect<A> =>
+const randomWith = <A>(f: (random: Random) => A): Effect.Effect<A> =>
   Effect.withFiber((fiber) => Effect.succeed(f(fiber.getRef(Random))))
 
 /**
@@ -139,7 +153,7 @@ export const nextInt: Effect.Effect<number> = randomWith((r) => r.nextIntUnsafe(
  * @since 4.0.0
  */
 export const nextBetween = (min: number, max: number): Effect.Effect<number> =>
-  randomWith((r) => r.nextDoubleUnsafe() * (max - min) + min)
+  randomWith((r) => random.nextBetween(min, max, r.nextDoubleUnsafe()))
 
 /**
  * Generates a random integer between `min` and `max`.

package/src/RcMap.ts

@@ -21,6 +21,7 @@ import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
 import { constant, dual, flow } from "./Function.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
+import type * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import * as Scope from "./Scope.ts"
@@ -379,7 +380,7 @@ export const make: {
         self.state = { _tag: "Closed" }
         return Effect.forEach(
           map,
-          ([, entry]) => Effect.exit(Scope.close(entry.scope, Exit.void))
+          ([, entry]) => Effect.exit(closeEntry(entry))
         ).pipe(
           Effect.tap(() =>
             Effect.sync(() => {
@@ -565,7 +566,7 @@ export const get: {
           context.set(key, value)
         })
         context.set(Scope.Scope.key, entry.scope)
-        self.lookup(key).pipe(
+        Effect.suspend(() => self.lookup(key)).pipe(
           Effect.runForkWith(Context.makeUnsafe(context)),
           Fiber.runIn(entry.scope)
         ).addObserver((exit) => Deferred.doneUnsafe(entry.deferred, exit))
@@ -577,20 +578,181 @@ export const get: {
     })
 )
 
+/**
+ * Retains and returns an existing resource without invoking the map's lookup
+ * function when the key is missing.
+ *
+ * **When to use**
+ *
+ * Use when you only want to acquire a reference to a resource that is currently
+ * cached.
+ *
+ * **Details**
+ *
+ * Returns `Option.none` when the key is not currently stored or the map is
+ * closed. If an entry exists, its reference count is incremented for the current
+ * `Scope` before awaiting its result. A successful entry returns
+ * `Option.some(value)`, while an in-flight or cached failure fails with the same
+ * error as `get`.
+ *
+ * **Example** (Retaining only cached resources)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Option, RcMap } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const map = yield* RcMap.make({
+ *     lookup: (key: string) => Effect.succeed(`Resource: ${key}`),
+ *     idleTimeToLive: "1 minute"
+ *   })
+ *
+ *   const missing = yield* RcMap.getOption(map, "database")
+ *   yield* Effect.scoped(RcMap.get(map, "database"))
+ *   const cached = yield* Effect.scoped(RcMap.getOption("database")(map))
+ *
+ *   return [missing, cached] as const
+ * })
+ *
+ * await Effect.runPromise(Effect.scoped(program)) // => [Option.none(), Option.some("Resource: database")]
+ * ```
+ *
+ * @see {@link get} for acquiring a resource when the key is missing
+ * @see {@link has} for checking presence without retaining or awaiting the entry
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const getOption: {
+  /**
+   * Retains and returns an existing resource without invoking the map's lookup
+   * function when the key is missing.
+   *
+   * **When to use**
+   *
+   * Use when you only want to acquire a reference to a resource that is currently
+   * cached.
+   *
+   * **Details**
+   *
+   * Returns `Option.none` when the key is not currently stored or the map is
+   * closed. If an entry exists, its reference count is incremented for the current
+   * `Scope` before awaiting its result. A successful entry returns
+   * `Option.some(value)`, while an in-flight or cached failure fails with the same
+   * error as `get`.
+   *
+   * **Example** (Retaining only cached resources)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect, Option, RcMap } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const map = yield* RcMap.make({
+   *     lookup: (key: string) => Effect.succeed(`Resource: ${key}`),
+   *     idleTimeToLive: "1 minute"
+   *   })
+   *
+   *   const missing = yield* RcMap.getOption(map, "database")
+   *   yield* Effect.scoped(RcMap.get(map, "database"))
+   *   const cached = yield* Effect.scoped(RcMap.getOption("database")(map))
+   *
+   *   return [missing, cached] as const
+   * })
+   *
+   * await Effect.runPromise(Effect.scoped(program)) // => [Option.none(), Option.some("Resource: database")]
+   * ```
+   *
+   * @see {@link get} for acquiring a resource when the key is missing
+   * @see {@link has} for checking presence without retaining or awaiting the entry
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  <K>(key: K): <A, E>(self: RcMap<K, A, E>) => Effect.Effect<Option.Option<A>, E, Scope.Scope>
+  /**
+   * Retains and returns an existing resource without invoking the map's lookup
+   * function when the key is missing.
+   *
+   * **When to use**
+   *
+   * Use when you only want to acquire a reference to a resource that is currently
+   * cached.
+   *
+   * **Details**
+   *
+   * Returns `Option.none` when the key is not currently stored or the map is
+   * closed. If an entry exists, its reference count is incremented for the current
+   * `Scope` before awaiting its result. A successful entry returns
+   * `Option.some(value)`, while an in-flight or cached failure fails with the same
+   * error as `get`.
+   *
+   * **Example** (Retaining only cached resources)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect, Option, RcMap } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const map = yield* RcMap.make({
+   *     lookup: (key: string) => Effect.succeed(`Resource: ${key}`),
+   *     idleTimeToLive: "1 minute"
+   *   })
+   *
+   *   const missing = yield* RcMap.getOption(map, "database")
+   *   yield* Effect.scoped(RcMap.get(map, "database"))
+   *   const cached = yield* Effect.scoped(RcMap.getOption("database")(map))
+   *
+   *   return [missing, cached] as const
+   * })
+   *
+   * await Effect.runPromise(Effect.scoped(program)) // => [Option.none(), Option.some("Resource: database")]
+   * ```
+   *
+   * @see {@link get} for acquiring a resource when the key is missing
+   * @see {@link has} for checking presence without retaining or awaiting the entry
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  <K, A, E>(self: RcMap<K, A, E>, key: K): Effect.Effect<Option.Option<A>, E, Scope.Scope>
+} = dual(
+  2,
+  <K, A, E>(self: RcMap<K, A, E>, key: K): Effect.Effect<Option.Option<A>, E, Scope.Scope> =>
+    Effect.uninterruptibleMask((restore) => {
+      if (self.state._tag === "Closed") {
+        return Effect.succeedNone
+      }
+      const o = MutableHashMap.get(self.state.map, key)
+      if (o._tag === "None") {
+        return Effect.succeedNone
+      }
+      const entry = o.value
+      entry.refCount++
+      const scope = Context.getUnsafe(Fiber.getCurrent()!.context, Scope.Scope)
+      return Scope.addFinalizer(scope, entry.finalizer).pipe(
+        Effect.andThen(Effect.asSome(restore(Deferred.await(entry.deferred))))
+      )
+    })
+)
+
+const closeEntry = <A, E>(entry: State.Entry<A, E>) =>
+  entry.fiber
+    ? Fiber.interrupt(entry.fiber).pipe(Effect.andThen(Scope.close(entry.scope, Exit.void)))
+    : Scope.close(entry.scope, Exit.void)
+
 const release = <K, A, E>(self: RcMap<K, A, E>, key: K, entry: State.Entry<A, E>) =>
   Effect.withFiber((fiber) => {
     entry.refCount--
     if (entry.refCount > 0) {
       return Effect.void
-    } else if (
-      self.state._tag === "Closed"
-      || !MutableHashMap.has(self.state.map, key)
-      || Duration.isZero(entry.idleTimeToLive)
-    ) {
-      if (self.state._tag === "Open") {
-        MutableHashMap.remove(self.state.map, key)
-      }
-      return Scope.close(entry.scope, Exit.void)
+    } else if (self.state._tag === "Closed") {
+      return closeEntry(entry)
+    }
+
+    const o = MutableHashMap.get(self.state.map, key)
+    if (o._tag === "None" || o.value !== entry) {
+      return closeEntry(entry)
+    } else if (Duration.isZero(entry.idleTimeToLive)) {
+      MutableHashMap.remove(self.state.map, key)
+      return closeEntry(entry)
     } else if (!Duration.isFinite(entry.idleTimeToLive)) {
       return Effect.void
     }
@@ -604,6 +766,8 @@ const release = <K, A, E>(self: RcMap<K, A, E>, key: K, entry: State.Entry<A, E>
       const remaining = entry.expiresAt - now
       if (remaining <= 0) {
         if (self.state._tag === "Closed" || entry.refCount > 0) return Effect.void
+        const o = MutableHashMap.get(self.state.map, key)
+        if (o._tag === "None" || o.value !== entry) return Effect.void
         MutableHashMap.remove(self.state.map, key)
         return restore(Scope.close(entry.scope, Exit.void))
       }
@@ -810,8 +974,7 @@ export const invalidate: {
     const entry = o.value
     MutableHashMap.remove(self.state.map, key)
     if (entry.refCount > 0) return
-    if (entry.fiber) yield* Fiber.interrupt(entry.fiber)
-    yield* Scope.close(entry.scope, Exit.void)
+    yield* closeEntry(entry)
   }, Effect.uninterruptible)
 )