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

package/src/Pool.ts

@@ -16,9 +16,10 @@ import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import type * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
-import { dual, identity } from "./Function.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 * as Latch from "./Latch.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Queue from "./Queue.ts"
@@ -28,6 +29,14 @@ import * as Semaphore from "./Semaphore.ts"
 
 const TypeId = "~effect/Pool"
 
+const Acquire = Symbol()
+const AcquireContext = Symbol()
+
+interface PoolImpl<A, E> extends Pool<A, E> {
+  readonly [Acquire]: Effect.Effect<A, E, Scope.Scope>
+  readonly [AcquireContext]: Context.Context<Scope.Scope>
+}
+
 /**
  * A `Pool<A, E>` is a pool of items of type `A`, each of which may be
  * associated with the acquisition and release of resources. An attempt to get
@@ -76,6 +85,7 @@ export interface Pool<in out A, in out E = never> extends Pipeable {
 export interface Config<A, E> {
   readonly acquire: Effect.Effect<A, E, Scope.Scope>
   readonly concurrency: number
+  readonly isFixed: boolean
   readonly minSize: number
   readonly maxSize: number
   readonly strategy: Strategy<A, E>
@@ -93,10 +103,8 @@ export interface Config<A, E> {
  *
  * **Details**
  *
- * This state tracks the pool scope, active and available items, invalidated
- * items, semaphores, waiters, and shutdown status. It is exposed for
- * inspection and implementation support; user code should prefer the
- * high-level pool operations.
+ * This state is exposed for inspection and implementation support. User code
+ * should prefer the high-level pool operations.
  *
  * @see {@link Pool} for the pool value exposing this state
  * @see {@link PoolItem} for the entries stored in the runtime item sets
@@ -109,13 +117,13 @@ export interface Config<A, E> {
 export interface State<A, E> {
   readonly scope: Scope.Scope
   isShuttingDown: boolean
-  readonly semaphore: Semaphore.Semaphore
+  usage: number
   readonly resizeSemaphore: Semaphore.Semaphore
   readonly items: Set<PoolItem<A, E>>
-  readonly available: Set<PoolItem<A, E>>
-  readonly availableLatch: Latch.Latch
+  availableHead: PoolItem<A, E> | undefined
+  availableTail: PoolItem<A, E> | undefined
   readonly invalidated: Set<PoolItem<A, E>>
-  waiters: number
+  readonly waiters: Set<() => void>
 }
 
 /**
@@ -144,6 +152,10 @@ export interface PoolItem<A, E> {
   finalizer: Effect.Effect<void>
   refCount: number
   disableReclaim: boolean
+  isAvailable: boolean
+  availablePrevious: PoolItem<A, E> | undefined
+  availableNext: PoolItem<A, E> | undefined
+  release: (exit: Exit.Exit<any, any>) => Effect.Effect<void>
 }
 
 /**
@@ -223,7 +235,7 @@ export const make = <A, E, R>(options: {
   readonly concurrency?: number | undefined
   readonly targetUtilization?: number | undefined
 }): Effect.Effect<Pool<A, E>, never, R | Scope.Scope> =>
-  makeWithStrategy({ ...options, min: options.size, max: options.size, strategy: strategyNoop() })
+  makeWithStrategy({ ...options, min: options.size, max: options.size, strategy: strategyNoop })
 
 /**
  * Creates a scoped pool with minimum and maximum sizes and a time-to-live
@@ -340,6 +352,7 @@ export const makeWithStrategy = <A, E, R>(options: {
     const config: Config<A, E> = {
       acquire,
       concurrency,
+      isFixed: options.min === options.max,
       minSize: options.min,
       maxSize: options.max,
       strategy: options.strategy,
@@ -348,16 +361,18 @@ export const makeWithStrategy = <A, E, R>(options: {
     const state: State<A, E> = {
       scope,
       isShuttingDown: false,
-      semaphore: Semaphore.makeUnsafe(concurrency * options.max),
+      usage: 0,
       resizeSemaphore: Semaphore.makeUnsafe(1),
       items: new Set(),
-      available: new Set(),
-      availableLatch: Latch.makeUnsafe(false),
+      availableHead: undefined,
+      availableTail: undefined,
       invalidated: new Set(),
-      waiters: 0
+      waiters: new Set()
     }
-    const self: Pool<A, E> = {
+    const self: PoolImpl<A, E> = {
       [TypeId]: TypeId,
+      [Acquire]: options.acquire as Effect.Effect<A, E, Scope.Scope>,
+      [AcquireContext]: services as Context.Context<Scope.Scope>,
       config,
       state,
       pipe() {
@@ -365,14 +380,18 @@ export const makeWithStrategy = <A, E, R>(options: {
       }
     }
     yield* Scope.addFinalizer(scope, shutdown(self))
-    yield* Effect.tap(
-      Effect.forkDetach(restore(resize(self))),
-      (fiber) => Scope.addFinalizer(scope, Fiber.interrupt(fiber))
-    )
-    yield* Effect.tap(
-      Effect.forkDetach(restore(options.strategy.run(self))),
-      (fiber) => Scope.addFinalizer(scope, Fiber.interrupt(fiber))
-    )
+    if (config.minSize > 0) {
+      yield* Effect.tap(
+        Effect.forkDetach(restore(resize(self)), { startImmediately: true }),
+        (fiber) => Scope.addFinalizer(scope, Fiber.interrupt(fiber))
+      )
+    }
+    if (options.strategy !== strategyNoop) {
+      yield* Effect.tap(
+        Effect.forkDetach(restore(options.strategy.run(self))),
+        (fiber) => Scope.addFinalizer(scope, Fiber.interrupt(fiber))
+      )
+    }
     return self
   }))
 
@@ -388,13 +407,17 @@ const shutdown = Effect.fnUntraced(function*<A, E>(self: Pool<A, E>) {
       yield* semaphore.take(1)
     } else {
       self.state.items.delete(item)
-      self.state.available.delete(item)
+      removeAvailable(self, item)
       self.state.invalidated.delete(item)
       yield* item.finalizer
     }
   }
   yield* semaphore.releaseAll
-  self.state.availableLatch.openUnsafe()
+  if (self.state.waiters.size > 0) {
+    const waiters = Array.from(self.state.waiters)
+    self.state.waiters.clear()
+    for (const notify of waiters) notify()
+  }
   yield* semaphore.take(size)
 })
 
@@ -421,73 +444,345 @@ const shutdown = Effect.fnUntraced(function*<A, E>(self: Pool<A, E>) {
  * @since 2.0.0
  */
 export const get = <A, E>(self: Pool<A, E>): Effect.Effect<A, E, Scope.Scope> =>
-  Effect.suspend(() => {
-    if (self.state.isShuttingDown) {
-      return Effect.interrupt
+  core.withFiber((fiber) => {
+    const state = self.state
+    if (state.isShuttingDown) return internal.interrupt
+    if (state.availableHead !== undefined) {
+      state.usage++
+      if (self.config.isFixed || targetSize(self) <= activeSize(self)) {
+        return leaseItem(self, state.availableHead, fiber)
+      }
+      state.usage--
     }
-    return Effect.flatMap(getPoolItem(self), (item) => item.exit)
+    return getSlowWith(self, leaseItemWith)
   })
 
-const getPoolItem = <A, E>(self: Pool<A, E>): Effect.Effect<PoolItem<A, E>, never, Scope.Scope> =>
-  Effect.uninterruptibleMask((restore) =>
-    restore(self.state.semaphore.take(1)).pipe(
-      Effect.flatMap(() => Effect.scope),
-      Effect.flatMap((scope) =>
-        getPoolItemInner(self).pipe(
-          Effect.ensuring(Effect.sync(() => self.state.waiters--)),
-          Effect.tap((item) => {
-            if (item.exit._tag === "Failure") {
-              self.state.items.delete(item)
-              self.state.invalidated.delete(item)
-              self.state.available.delete(item)
-              return self.state.semaphore.release(1)
-            }
-            item.refCount++
-            self.state.available.delete(item)
-            if (item.refCount < self.config.concurrency) {
-              self.state.available.add(item)
-            }
-            return Scope.addFinalizerExit(scope, () =>
-              Effect.flatMap(
-                Effect.suspend(() => {
-                  item.refCount--
-                  if (self.state.invalidated.has(item)) {
-                    return invalidatePoolItem(self, item)
-                  }
-                  self.state.available.add(item)
-                  return Effect.void
-                }),
-                () => self.state.semaphore.release(1)
-              ))
-          }),
-          Effect.onInterrupt(() => self.state.semaphore.release(1))
-        )
-      )
-    )
-  )
+/**
+ * Borrows an item while an effect runs and returns it when the effect exits.
+ *
+ * **When to use**
+ *
+ * Use when an item is needed by one effect. Unlike `Effect.scoped` with
+ * {@link get}, this avoids allocating a scope and registering a finalizer.
+ *
+ * **Example** (Running a single operation with a pooled item)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Pool } from "effect"
+ *
+ * const program = Effect.scoped(
+ *   Effect.flatMap(
+ *     Pool.make({ acquire: Effect.succeed("resource"), size: 2 }),
+ *     (pool) => Pool.use(pool, (item) => Effect.succeed(item.length))
+ *   )
+ * )
+ *
+ * await Effect.runPromise(program) // => 8
+ * ```
+ *
+ * @see {@link get} for borrowing an item for the lifetime of a scope
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const use: {
+  /**
+   * Borrows an item while an effect runs and returns it when the effect exits.
+   *
+   * **When to use**
+   *
+   * Use when an item is needed by one effect. Unlike `Effect.scoped` with
+   * {@link get}, this avoids allocating a scope and registering a finalizer.
+   *
+   * **Example** (Running a single operation with a pooled item)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect, Pool } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.flatMap(
+   *     Pool.make({ acquire: Effect.succeed("resource"), size: 2 }),
+   *     (pool) => Pool.use(pool, (item) => Effect.succeed(item.length))
+   *   )
+   * )
+   *
+   * await Effect.runPromise(program) // => 8
+   * ```
+   *
+   * @see {@link get} for borrowing an item for the lifetime of a scope
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  <A, B, E2, R2>(f: (item: A) => Effect.Effect<B, E2, R2>): <E>(self: Pool<A, E>) => Effect.Effect<B, E | E2, R2>
+  /**
+   * Borrows an item while an effect runs and returns it when the effect exits.
+   *
+   * **When to use**
+   *
+   * Use when an item is needed by one effect. Unlike `Effect.scoped` with
+   * {@link get}, this avoids allocating a scope and registering a finalizer.
+   *
+   * **Example** (Running a single operation with a pooled item)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect, Pool } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.flatMap(
+   *     Pool.make({ acquire: Effect.succeed("resource"), size: 2 }),
+   *     (pool) => Pool.use(pool, (item) => Effect.succeed(item.length))
+   *   )
+   * )
+   *
+   * await Effect.runPromise(program) // => 8
+   * ```
+   *
+   * @see {@link get} for borrowing an item for the lifetime of a scope
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  <A, E, B, E2, R2>(self: Pool<A, E>, f: (item: A) => Effect.Effect<B, E2, R2>): Effect.Effect<B, E | E2, R2>
+} = dual(2, <A, E, B, E2, R2>(
+  self: Pool<A, E>,
+  f: (item: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<B, E | E2, R2> =>
+  internal.suspend(() => {
+    const state = self.state
+    if (state.isShuttingDown) return internal.interrupt
+    if (state.availableHead !== undefined) {
+      state.usage++
+      if (self.config.isFixed || targetSize(self) <= activeSize(self)) {
+        return useItem(self, state.availableHead, f)
+      }
+      state.usage--
+    }
+    return getSlowWith(self, (self, item, _fiber, restore) => useItem(self, item, f, restore))
+  }))
 
-const getPoolItemInner = Effect.fnUntraced(function*<A, E>(
-  self: Pool<A, E>
-) {
-  self.state.waiters++
-  if (self.state.isShuttingDown) {
-    return yield* Effect.interrupt
-  } else if (targetSize(self) > activeSize(self)) {
-    while (true) {
-      yield* self.state.resizeSemaphore.withPermitsIfAvailable(1)(
-        Effect.forkIn(Effect.interruptible(resize(self)), self.state.scope)
-      )
-      if (self.state.isShuttingDown) {
-        return yield* Effect.interrupt
-      } else if (self.state.available.size > 0) {
-        return Iterable.headUnsafe(self.state.available)
+const useItem = <A, E, B, E2, R2>(
+  self: Pool<A, E>,
+  item: PoolItem<A, E>,
+  f: (item: A) => Effect.Effect<B, E2, R2>,
+  restore?: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX>
+): Effect.Effect<B, E | E2, R2> => {
+  if (!leaseItemBookkeeping(self, item)) {
+    return item.exit as Exit.Exit<never, E>
+  }
+  let body: Effect.Effect<B, E2, R2>
+  try {
+    body = f((item.exit as Exit.Success<A, E>).value)
+  } catch (defect) {
+    return internal.flatMap(item.release(item.exit), () => core.exitDie(defect))
+  }
+  return internal.onExitPrimitive(restore !== undefined ? restore(body) : body, item.release)
+}
+
+const getSlowWith = <A, E, X, R>(
+  self: Pool<A, E>,
+  lease: (
+    self: Pool<A, E>,
+    item: PoolItem<A, E>,
+    fiber: Fiber.Fiber<unknown, unknown>,
+    restore: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX>
+  ) => Effect.Effect<X, any, R>
+): Effect.Effect<X, any, R> =>
+  internal.uninterruptibleMask((restore) => {
+    const state = self.state
+    state.usage++
+    const wait: Effect.Effect<X, any, R> = internal.flatMap(
+      internal.onInterrupt(
+        restore(waitForItem(self)),
+        () =>
+          internal.sync(() => {
+            state.usage--
+          })
+      ),
+      () => loop
+    )
+    const step: Effect.Effect<X, any, R> = core.withFiber((fiber) => {
+      if (state.isShuttingDown) {
+        state.usage--
+        return internal.interrupt
+      }
+      if (state.availableHead !== undefined) {
+        return lease(self, state.availableHead, fiber, restore)
+      }
+      return wait
+    })
+    const loop: Effect.Effect<X, any, R> = internal.suspend(() => {
+      if (state.isShuttingDown) {
+        state.usage--
+        return internal.interrupt
       }
-      self.state.availableLatch.closeUnsafe()
-      yield* self.state.availableLatch.await
+      return targetSize(self) > activeSize(self)
+        ? internal.flatMap(
+          state.resizeSemaphore.withPermitsIfAvailable(1)(
+            Effect.forkIn(Effect.interruptible(resize(self)), state.scope)
+          ),
+          () => step
+        )
+        : step
+    })
+    return loop
+  })
+
+const leaseItemBookkeeping = <A, E>(self: Pool<A, E>, item: PoolItem<A, E>): boolean => {
+  const state = self.state
+  if (item.exit._tag === "Failure") {
+    state.usage--
+    state.items.delete(item)
+    state.invalidated.delete(item)
+    removeAvailable(self, item)
+    return false
+  }
+  item.refCount++
+  if (item.refCount >= self.config.concurrency) {
+    removeAvailable(self, item)
+  }
+  return true
+}
+
+const leaseItem = <A, E>(
+  self: Pool<A, E>,
+  item: PoolItem<A, E>,
+  fiber: Fiber.Fiber<unknown, unknown>
+): Effect.Effect<A, E> => {
+  if (!leaseItemBookkeeping(self, item)) {
+    return item.exit
+  }
+  const scope = Context.getUnsafe(fiber.context, Scope.Scope)
+  if (scope.state._tag === "Closed") {
+    return internal.flatMap(item.release(item.exit), () => item.exit)
+  }
+  internal.scopeAddFinalizerUnsafe(scope, {}, item.release)
+  return item.exit
+}
+
+const leaseItemWith = <A, E>(
+  self: Pool<A, E>,
+  item: PoolItem<A, E>,
+  fiber: Fiber.Fiber<unknown, unknown>
+): Effect.Effect<A, E, Scope.Scope> => leaseItem(self, item, fiber)
+
+const releaseItem = <A, E>(self: Pool<A, E>, item: PoolItem<A, E>): Effect.Effect<void> =>
+  core.withFiber((fiber) => {
+    const state = self.state
+    item.refCount--
+    state.usage--
+    if (state.invalidated.has(item)) {
+      return invalidatePoolItem(self, item)
+    }
+    // Every release frees one slot, so it can admit one waiter. Reacting only
+    // to the saturated-to-unsaturated transition strands the rest: several
+    // leases returning at once would wake a single waiter and leave the others
+    // asleep against an item that has capacity for them. `addAvailable` is
+    // idempotent, so re-adding an available item is free.
+    if (item.refCount < self.config.concurrency) {
+      addAvailableFront(self, item)
+      wakeWaiters(self, fiber, 1)
+    }
+    return internal.void
+  })
+
+const waitForItem = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
+  internal.callback((resume) => {
+    const state = self.state
+    if (state.availableHead !== undefined || state.isShuttingDown) {
+      return resume(internal.void)
     }
+    const observer = () => {
+      state.waiters.delete(observer)
+      resume(internal.void)
+    }
+    state.waiters.add(observer)
+    return internal.sync(() => {
+      state.waiters.delete(observer)
+    })
+  })
+
+const wakeWaiters = <A, E>(self: Pool<A, E>, fiber: Fiber.Fiber<unknown, unknown>, count: number) => {
+  const waiters = self.state.waiters
+  if (waiters.size === 0) return
+  fiber.currentDispatcher.scheduleTask(() => {
+    let remaining = count
+    const toWake: Array<() => void> = []
+    for (const notify of waiters) {
+      if (remaining-- <= 0) break
+      toWake.push(notify)
+    }
+    for (let i = 0; i < toWake.length; i++) {
+      toWake[i]()
+    }
+  }, 0)
+}
+
+const wakeAll = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
+  core.withFiber((fiber) => {
+    wakeWaiters(self, fiber, Number.POSITIVE_INFINITY)
+    return internal.void
+  })
+
+// Reservations prevent reuse without extending the lifetime of borrowed items.
+const reservations = new WeakMap<PoolItem<unknown, unknown>, number>()
+
+/** Adds a freshly acquired item, which has no use behind it, at the back. */
+const addAvailable = <A, E>(self: Pool<A, E>, item: PoolItem<A, E>): void => {
+  if (item.isAvailable || reservations.has(item)) return
+  item.isAvailable = true
+  item.availablePrevious = self.state.availableTail
+  item.availableNext = undefined
+  if (self.state.availableTail !== undefined) {
+    self.state.availableTail.availableNext = item
+  } else {
+    self.state.availableHead = item
   }
-  return Iterable.headUnsafe(self.state.available)
-})
+  self.state.availableTail = item
+}
+
+/**
+ * Returns a released item at the front, so the next borrow gets the one used
+ * most recently. Borrowers take from the front, so the list runs warmest
+ * first.
+ *
+ * Sending it to the back instead spreads a sequence of borrows evenly over
+ * every item the pool has open. For a pool of connections that means none of
+ * them is ever the hot one - each borrow lands on a peer that has been sitting
+ * idle, losing whatever warmth it had - and it means `timeToLive` never
+ * reclaims anything, because a pool that grew for one burst keeps every item
+ * equally fresh forever. Under saturation the two orders agree, since every
+ * item is checked out either way.
+ */
+const addAvailableFront = <A, E>(self: Pool<A, E>, item: PoolItem<A, E>): void => {
+  if (item.isAvailable || reservations.has(item)) return
+  item.isAvailable = true
+  item.availablePrevious = undefined
+  item.availableNext = self.state.availableHead
+  if (self.state.availableHead !== undefined) {
+    self.state.availableHead.availablePrevious = item
+  } else {
+    self.state.availableTail = item
+  }
+  self.state.availableHead = item
+}
+
+const removeAvailable = <A, E>(self: Pool<A, E>, item: PoolItem<A, E>): void => {
+  if (!item.isAvailable) return
+  item.isAvailable = false
+  if (item.availablePrevious !== undefined) {
+    item.availablePrevious.availableNext = item.availableNext
+  } else {
+    self.state.availableHead = item.availableNext
+  }
+  if (item.availableNext !== undefined) {
+    item.availableNext.availablePrevious = item.availablePrevious
+  } else {
+    self.state.availableTail = item.availablePrevious
+  }
+  item.availablePrevious = undefined
+  item.availableNext = undefined
+}
 
 /**
  * Invalidates the specified item so the pool can remove it and reallocate the
@@ -528,7 +823,7 @@ export const invalidate: {
    * @category combinators
    * @since 2.0.0
    */
-  <A>(item: A): <E>(self: Pool<A, E>) => Effect.Effect<void, never, Scope.Scope>
+  <A>(item: A): <E>(self: Pool<A, E>) => Effect.Effect<void>
   /**
    * Invalidates the specified item so the pool can remove it and reallocate the
    * item, lazily if needed.
@@ -548,8 +843,8 @@ export const invalidate: {
    * @category combinators
    * @since 2.0.0
    */
-  <A, E>(self: Pool<A, E>, item: A): Effect.Effect<void, never, Scope.Scope>
-} = dual(2, <A, E>(self: Pool<A, E>, item: A): Effect.Effect<void, never, Scope.Scope> =>
+  <A, E>(self: Pool<A, E>, item: A): Effect.Effect<void>
+} = dual(2, <A, E>(self: Pool<A, E>, item: A): Effect.Effect<void> =>
   Effect.suspend(() => {
     if (self.state.isShuttingDown) return Effect.void
     for (const poolItem of self.state.items) {
@@ -561,22 +856,104 @@ export const invalidate: {
     return Effect.void
   }))
 
+/**
+ * Reserves a leased item for exclusive use until the scope closes. This
+ * removes the item's remaining capacity from the pool but does not wait
+ * for existing leases to finish. It has no effect when per-item concurrency is
+ * `1` or the pool does not contain the item.
+ *
+ * @see {@link get} for acquiring an item
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const reserve: {
+  /**
+   * Reserves a leased item for exclusive use until the scope closes. This
+   * removes the item's remaining capacity from the pool but does not wait
+   * for existing leases to finish. It has no effect when per-item concurrency is
+   * `1` or the pool does not contain the item.
+   *
+   * @see {@link get} for acquiring an item
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  <A>(item: A): <E>(self: Pool<A, E>) => Effect.Effect<void, never, Scope.Scope>
+  /**
+   * Reserves a leased item for exclusive use until the scope closes. This
+   * removes the item's remaining capacity from the pool but does not wait
+   * for existing leases to finish. It has no effect when per-item concurrency is
+   * `1` or the pool does not contain the item.
+   *
+   * @see {@link get} for acquiring an item
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  <A, E>(self: Pool<A, E>, item: A): Effect.Effect<void, never, Scope.Scope>
+} = dual(
+  2,
+  <A, E>(self: Pool<A, E>, item: A): Effect.Effect<void, never, Scope.Scope> =>
+    Effect.asVoid(Effect.acquireRelease(
+      Effect.sync(() => {
+        if (self.config.concurrency === 1) return undefined
+        for (const poolItem of self.state.items) {
+          if (poolItem.exit._tag !== "Success" || poolItem.exit.value !== item) continue
+          const existing = reservations.get(poolItem)
+          if (existing === undefined) self.state.usage += self.config.concurrency - 1
+          reservations.set(poolItem, (existing ?? 0) + 1)
+          removeAvailable(self, poolItem)
+          return poolItem
+        }
+        return undefined
+      }),
+      (poolItem) =>
+        core.withFiber((fiber) => {
+          if (poolItem === undefined) return internal.void
+          const remaining = (reservations.get(poolItem) ?? 1) - 1
+          if (remaining > 0) {
+            reservations.set(poolItem, remaining)
+            return internal.void
+          }
+          reservations.delete(poolItem)
+          self.state.usage -= self.config.concurrency - 1
+          if (
+            !self.state.isShuttingDown &&
+            self.state.items.has(poolItem) &&
+            !self.state.invalidated.has(poolItem) &&
+            poolItem.refCount < self.config.concurrency
+          ) {
+            addAvailableFront(self, poolItem)
+            wakeWaiters(self, fiber, self.config.concurrency - poolItem.refCount)
+          }
+          return internal.void
+        })
+    ))
+)
+
 const invalidatePoolItem = <A, E>(self: Pool<A, E>, poolItem: PoolItem<A, E>): Effect.Effect<void> =>
   Effect.suspend(() => {
     if (!self.state.items.has(poolItem)) {
       return Effect.void
     } else if (poolItem.refCount === 0) {
       self.state.items.delete(poolItem)
-      self.state.available.delete(poolItem)
+      removeAvailable(self, poolItem)
       self.state.invalidated.delete(poolItem)
       return Effect.asVoid(Effect.flatMap(
         poolItem.finalizer,
-        () => Effect.forkIn(Effect.interruptible(resize(self)), self.state.scope)
+        () => Effect.forkIn(Effect.interruptible(resize(self)), self.state.scope, { startImmediately: true })
       ))
     }
     self.state.invalidated.add(poolItem)
-    self.state.available.delete(poolItem)
-    return Effect.void
+    removeAvailable(self, poolItem)
+    // An invalidated item stops counting towards the pool's active size, so the
+    // pool is now below target and has to top itself back up. Waiting for the
+    // last lease to be returned would strand anybody already queued: the item
+    // they are waiting for is never coming back.
+    return Effect.asVoid(
+      Effect.forkIn(Effect.interruptible(resize(self)), self.state.scope, { startImmediately: true })
+    )
   })
 
 const resize = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
@@ -590,52 +967,76 @@ const resizeLoop = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
       return Effect.void
     }
     const toAcquire = target - active
-    return self.config.strategy.reclaim(self).pipe(
-      Effect.flatMap((item) => item ? Effect.succeed(item) : allocate(self)),
+    const acquireOne = self.config.strategy === strategyNoop
+      ? allocate(self)
+      : Effect.flatMap(
+        self.config.strategy.reclaim(self),
+        (item) => item ? Effect.succeed(item) : allocate(self)
+      )
+    if (toAcquire === 1) {
+      const acquired = Effect.tap(acquireOne, wakeAll(self))
+      return self.config.isFixed
+        ? Effect.asVoid(acquired)
+        : Effect.flatMap(acquired, (item) => item.exit._tag === "Failure" ? Effect.void : resizeLoop(self))
+    }
+    const acquired = acquireOne.pipe(
       Effect.replicateEffect(toAcquire, { concurrency: toAcquire }),
-      Effect.tap(self.state.availableLatch.open),
-      Effect.flatMap((items) => items.some((_) => _.exit._tag === "Failure") ? Effect.void : resizeLoop(self))
+      Effect.tap(wakeAll(self))
     )
+    return self.config.isFixed
+      ? Effect.asVoid(acquired)
+      : Effect.flatMap(
+        acquired,
+        (items) => items.some((_) => _.exit._tag === "Failure") ? Effect.void : resizeLoop(self)
+      )
   })
 
 const allocate = <A, E>(self: Pool<A, E>): Effect.Effect<PoolItem<A, E>> =>
-  Effect.acquireUseRelease(
-    Scope.make(),
-    (scope) =>
-      self.config.acquire.pipe(
-        Scope.provide(scope),
-        Effect.exit,
-        Effect.flatMap((exit) => {
-          const item: PoolItem<A, E> = {
-            exit,
-            finalizer: Effect.catchCause(Scope.close(scope, exit), reportUnhandledError),
-            refCount: 0,
-            disableReclaim: false
-          }
-          self.state.items.add(item)
-          self.state.available.add(item)
-          return Effect.as(
-            exit._tag === "Success"
-              ? self.config.strategy.onAcquire(item)
-              : Effect.flatMap(item.finalizer, () => self.config.strategy.onAcquire(item)),
-            item
-          )
-        })
-      ),
-    (scope, exit) => exit._tag === "Failure" ? Scope.close(scope, exit) : Effect.void
+  internal.uninterruptibleMask((restore) =>
+    core.withFiber((fiber) => {
+      const impl = self as PoolImpl<A, E>
+      const scope = internal.scopeMakeUnsafe()
+      const previousContext = fiber.context
+      fiber.setContext(Context.add(impl[AcquireContext], Scope.Scope, scope))
+      const use = Effect.flatMap(Effect.exit(impl[Acquire]), (exit) => {
+        const item: PoolItem<A, E> = {
+          exit,
+          finalizer: Effect.catchCause(Scope.close(scope, exit), reportUnhandledError),
+          refCount: 0,
+          disableReclaim: false,
+          isAvailable: false,
+          availablePrevious: undefined,
+          availableNext: undefined,
+          release: undefined as any
+        }
+        item.release = constant(releaseItem(self, item))
+        self.state.items.add(item)
+        addAvailable(self, item)
+        if (self.config.strategy === strategyNoop) {
+          return exit._tag === "Success" ? Effect.succeed(item) : Effect.as(item.finalizer, item)
+        }
+        return Effect.as(
+          exit._tag === "Success"
+            ? self.config.strategy.onAcquire(item)
+            : Effect.flatMap(item.finalizer, () => self.config.strategy.onAcquire(item)),
+          item
+        )
+      })
+      return internal.onExitPrimitive(
+        restore(use) as Effect.Effect<PoolItem<A, E>>,
+        (exit) => {
+          fiber.setContext(previousContext)
+          return exit._tag === "Failure" ? internal.scopeCloseUnsafe(scope, exit) : undefined
+        },
+        true
+      )
+    })
   )
 
-const currentUsage = <A, E>(self: Pool<A, E>) => {
-  let count = self.state.waiters
-  for (const item of self.state.items) {
-    count += item.refCount
-  }
-  return count
-}
-
 const targetSize = <A, E>(self: Pool<A, E>) => {
   if (self.state.isShuttingDown) return 0
-  const utilization = currentUsage(self) / self.config.targetUtilization
+  if (self.config.isFixed) return self.config.minSize
+  const utilization = self.state.usage / self.config.targetUtilization
   const target = Math.ceil(utilization / self.config.concurrency)
   return Math.min(Math.max(self.config.minSize, target), self.config.maxSize)
 }
@@ -648,11 +1049,11 @@ const activeSize = <A, E>(self: Pool<A, E>) => {
 // Strategy
 // -----------------------------------------------------------------------------
 
-const strategyNoop = <A, E>(): Strategy<A, E> => ({
+const strategyNoop: Strategy<any, any> = {
   run: (_) => Effect.void,
   onAcquire: (_) => Effect.void,
   reclaim: (_) => Effect.undefined
-})
+}
 
 const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const clock = yield* Clock
@@ -711,14 +1112,14 @@ const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input)
           return Effect.undefined
         }
         const item = Iterable.head(
-          Iterable.filter(pool.state.invalidated, (item) => !item.disableReclaim)
+          Iterable.filter(pool.state.invalidated, (item) => !item.disableReclaim && !reservations.has(item))
         )
         if (item._tag === "None") {
           return Effect.undefined
         }
         pool.state.invalidated.delete(item.value)
         if (item.value.refCount < pool.config.concurrency) {
-          pool.state.available.add(item.value)
+          addAvailable(pool, item.value)
         }
         return Effect.as(Queue.offer(queue, item.value), item.value)
       })