effect 4.0.6 → 4.1.0

package/src/Match.ts

@@ -37,6 +37,31 @@ type ValueTagHandlers<I> = {
   readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any
 }
 
+// Members of `R` that a literal record can dispatch on: finite string / number
+// literals whose runtime key no other string / number member can produce.
+// Widened `string` / `number` and template literals add no keys, and a literal
+// is dropped when another member spells the same key (`1` with `"1"` or
+// `string`, `"1"` or `"NaN"` with `number`).
+type LiteralKeys<R, All = Extract<R, string | number>> = R extends string | number
+  ? {} extends Record<R, unknown> ? never
+  : R extends number ? `${R}` extends All ? never : R
+  : R extends `${infer N extends number}` ? N extends All ? never : R
+  : R extends "NaN" | "Infinity" | "-Infinity" ? number extends All ? never : R
+  : R
+  : never
+
+type LiteralHandlers<R, Ret> = [Exclude<R, LiteralKeys<R>>] extends [never] ? {
+    readonly [K in LiteralKeys<R>]: (_: K) => Ret
+  }
+  : never
+
+type PartialLiteralHandlers<R, Ret> = {
+  readonly [K in LiteralKeys<R>]?: ((_: K) => Ret) | undefined
+}
+
+// Only keys with a defined handler remove a literal from the remaining input.
+type HandledLiterals<P> = { readonly [K in keyof P]-?: undefined extends P[K] ? never : K }[keyof P]
+
 /**
  * Marker used by `Matcher` to distinguish matchers created with `Match.value`.
  *
@@ -1391,6 +1416,108 @@ export const tagsExhaustive: <
 ) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>> : Unify<A | ReturnType<P[keyof P]>> =
   internal.tagsExhaustive
 
+/**
+ * Matches string and number literal values, mapping each literal to a
+ * corresponding handler.
+ *
+ * **Details**
+ *
+ * Each handler receives the matched literal. Handled literals are removed from
+ * the remaining input, while unhandled literals and any other members (such as
+ * `null`, objects, or widened `string` / `number` types) are left for later
+ * cases. Keys must be finite string or number literals of the remaining input;
+ * unions containing both a number and its string spelling, such as
+ * `1 | "1"`, are rejected because both share the same runtime key.
+ *
+ * **Example** (Mapping literal handlers)
+ *
+ * ```ts import.meta.vitest
+ * import { Match } from "effect"
+ *
+ * type Status = "draft" | "review" | "published"
+ *
+ * const isEditable = Match.type<Status>().pipe(
+ *   Match.literals({ draft: () => true, review: () => true }),
+ *   Match.orElse(() => false)
+ * )
+ *
+ * isEditable("review") // => true
+ * isEditable("published") // => false
+ * ```
+ *
+ * @see {@link literalsExhaustive} for handling every literal and finalizing the matcher
+ *
+ * @stability unstable
+ * @category defining patterns
+ * @since 4.1.0
+ */
+export const literals: <
+  R,
+  Ret,
+  P extends
+    & PartialLiteralHandlers<R, Ret>
+    & { readonly [K in Exclude<keyof P, LiteralKeys<R>>]: never }
+>(
+  fields: Contextual<P, PartialLiteralHandlers<R, Ret>>
+) => <I, F, A, Pr>(
+  self: Matcher<I, F, R, A, Pr, Ret>
+) => Matcher<
+  I,
+  Types.AddWithout<F, Extract<R, HandledLiterals<P>>>,
+  Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, HandledLiterals<P>>>>,
+  A | ReturnType<P[keyof P] & {}>,
+  Pr,
+  Ret
+> = internal.literals
+
+/**
+ * Matches string and number literal values and requires handling of all
+ * remaining cases.
+ *
+ * **Details**
+ *
+ * This is the exhaustive variant of {@link literals}. Every remaining member
+ * must be a finite string or number literal with a corresponding handler, so a
+ * missing literal, a widened `string` / `number` type, or any other unhandled
+ * member is reported by TypeScript.
+ *
+ * **Example** (Handling all literal cases)
+ *
+ * ```ts import.meta.vitest
+ * import { Match } from "effect"
+ *
+ * type Status = "draft" | "review" | "published"
+ *
+ * const label = Match.type<Status>().pipe(
+ *   Match.literalsExhaustive({
+ *     draft: () => "Draft",
+ *     review: () => "In review",
+ *     published: () => "Live"
+ *   })
+ * )
+ *
+ * label("review") // => "In review"
+ * ```
+ *
+ * @see {@link literals} for defining literal handlers without finalizing the matcher
+ *
+ * @stability unstable
+ * @category defining patterns
+ * @since 4.1.0
+ */
+export const literalsExhaustive: <
+  R,
+  Ret,
+  P extends
+    & LiteralHandlers<R, Ret>
+    & { readonly [K in Exclude<keyof P, LiteralKeys<R>>]: never }
+>(
+  fields: Contextual<P, LiteralHandlers<R, Ret>>
+) => <I, F, A, Pr>(
+  self: Matcher<I, F, R, A, Pr, Ret>
+) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>> : Unify<A | ReturnType<P[keyof P]>> =
+  internal.literalsExhaustive
+
 /**
  * Creates a pattern that excludes a specific value while allowing all others.
  *

package/src/Metric.ts

@@ -576,7 +576,7 @@ export interface GaugeState<in Input extends number | bigint> {
  *         start: 1,
  *         factor: 2,
  *         count: 10
- *       }) // 1, 2, 4, 8, ..., 512
+ *       }) // 1, 2, 4, 8, ..., 256, Infinity
  *     }
  *   )
  *
@@ -696,8 +696,8 @@ export interface Histogram<Input> extends Metric<Input, HistogramState> {}
  *       totalRequests: state.count, // 5
  *       fastestResponse: state.min, // 50
  *       slowestResponse: state.max, // 750
- *       averageResponse: state.sum / state.count, // 268
- *       totalTime: state.sum, // 1340
+ *       averageResponse: state.sum / state.count, // 259
+ *       totalTime: state.sum, // 1295
  *       distribution: bucketAnalysis
  *       // Example distribution:
  *       // [{ range: "0-100ms", count: 2, percentage: 40.0 },

package/src/MutableList.ts

@@ -9,7 +9,6 @@
  * @stability stable
  * @since 4.0.0
  */
-import * as Arr from "./Array.ts"
 import * as Count from "./internal/count.ts"
 
 /**
@@ -259,7 +258,8 @@ export const prepend = <A>(self: MutableList<A>, message: A): void => {
 /**
  * Prepends all elements from an iterable to the beginning of the MutableList.
  * The elements are added in order, so the first element in the iterable becomes
- * the new head of the list.
+ * the new head of the list. The elements are copied, so the input can be reused
+ * afterward. Use `prependAllUnsafe` to transfer ownership of an array instead.
  *
  * **Example** (Prepending multiple elements)
  *
@@ -279,7 +279,7 @@ export const prepend = <A>(self: MutableList<A>, message: A): void => {
  * @since 4.0.0
  */
 export const prependAll = <A>(self: MutableList<A>, messages: Iterable<A>): void =>
-  prependAllUnsafe(self, Arr.fromIterable(messages), !Array.isArray(messages))
+  prependAllUnsafe(self, Array.from(messages), true)
 
 /**
  * Prepends all elements from a ReadonlyArray to the beginning of the MutableList.
@@ -328,7 +328,9 @@ export const prependAllUnsafe = <A>(self: MutableList<A>, messages: ReadonlyArra
 
 /**
  * Appends all elements from an iterable to the end of the MutableList.
- * Returns the number of elements added.
+ * Returns the number of elements added. The elements are copied, so the input
+ * can be reused afterward. Use `appendAllUnsafe` to transfer ownership of an
+ * array instead.
  *
  * **Example** (Appending multiple elements)
  *
@@ -349,7 +351,7 @@ export const prependAllUnsafe = <A>(self: MutableList<A>, messages: ReadonlyArra
  * @since 4.0.0
  */
 export const appendAll = <A>(self: MutableList<A>, messages: Iterable<A>): number =>
-  appendAllUnsafe(self, Arr.fromIterable(messages), !Array.isArray(messages))
+  appendAllUnsafe(self, Array.from(messages), true)
 
 /**
  * Appends all elements from a ReadonlyArray to the end of the MutableList.

package/src/MutableRef.ts

@@ -12,6 +12,7 @@
  */
 import * as Equal from "./Equal.ts"
 import * as Dual from "./Function.ts"
+import * as Hash from "./Hash.ts"
 import { type Inspectable, toJson } from "./Inspectable.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -74,9 +75,15 @@ export interface MutableRef<out T> extends Pipeable, Inspectable {
   current: T
 }
 
-const MutableRefProto: Omit<MutableRef<unknown>, "current"> = {
+const MutableRefProto: Omit<MutableRef<unknown>, "current"> & Equal.Equal = {
   [TypeId]: TypeId,
   ...PipeInspectableProto,
+  [Equal.symbol](that: unknown): boolean {
+    return this === that
+  },
+  [Hash.symbol](): number {
+    return Hash.random(this)
+  },
   toJSON<A>(this: MutableRef<A>) {
     return {
       _id: "MutableRef",

package/src/PartitionedSemaphore.ts

@@ -59,7 +59,8 @@ export type PartitionedTypeId = "~effect/PartitionedSemaphore"
  *
  * **Details**
  *
- * Waiting permits are distributed across partitions in round-robin order.
+ * Waiters are served across partitions in round-robin order, completing each
+ * waiter's permit request before moving to the next partition.
  *
  * @stability unstable
  * @category models
@@ -150,6 +151,7 @@ export const makeUnsafe = <K = unknown>(options: {
   let iterator = partitions[Symbol.iterator]()
   let releasing = false
   let pendingPermits = 0
+  let partial: Waiter | undefined
 
   const releaseUnsafe = (permits: number): number => {
     if (permits > 0) {
@@ -162,26 +164,32 @@ export const makeUnsafe = <K = unknown>(options: {
       releasing = true
       try {
         while (pendingPermits > 0 && waitingPermits > 0) {
-          let state = iterator.next()
-          if (state.done) {
-            iterator = partitions[Symbol.iterator]()
-            state = iterator.next()
+          let waiter = partial
+          if (waiter === undefined) {
+            let state = iterator.next()
             if (state.done) {
-              break
+              iterator = partitions[Symbol.iterator]()
+              state = iterator.next()
+              if (state.done) {
+                break
+              }
             }
-          }
 
-          const waiter = state.value[1].values().next().value
-          if (waiter === undefined) {
-            continue
+            waiter = state.value[1].values().next().value
+            if (waiter === undefined) {
+              continue
+            }
           }
 
-          waiter.permits -= 1
-          waitingPermits -= 1
-          pendingPermits -= 1
+          const granted = Math.min(waiter.permits, pendingPermits)
+          waiter.permits -= granted
+          waitingPermits -= granted
+          pendingPermits -= granted
 
           if (waiter.permits === 0) {
             waiter.resume()
+          } else {
+            partial = waiter
           }
         }
       } finally {
@@ -249,6 +257,9 @@ export const makeUnsafe = <K = unknown>(options: {
         }
 
         const cleanup = () => {
+          if (partial === entry) {
+            partial = undefined
+          }
           if (waiters.delete(entry) && waiters.size === 0) {
             MutableHashMap.remove(partitions, key)
           }

package/src/Pool.ts

@@ -10,7 +10,6 @@
  * @stability stable
  * @since 2.0.0
  */
-import type * as Cause from "./Cause.ts"
 import { Clock } from "./Clock.ts"
 import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
@@ -23,7 +22,6 @@ import * as internal from "./internal/effect.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Queue from "./Queue.ts"
-import { UnhandledLogLevel } from "./References.ts"
 import * as Scope from "./Scope.ts"
 import * as Semaphore from "./Semaphore.ts"
 
@@ -96,6 +94,29 @@ export interface Config<A, E> {
   readonly targetUtilization: number
 }
 
+/**
+ * A point-in-time count of a pool's items and waiting borrowers.
+ *
+ * **Details**
+ *
+ * `idle` and `used` count acquired items, not borrowers, so an item shared by
+ * several borrowers counts once. `pending` counts borrowers waiting for an
+ * item. `min` and `max` are the configured size bounds.
+ *
+ * @see {@link stats} for reading a snapshot
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface Stats {
+  readonly idle: number
+  readonly used: number
+  readonly pending: number
+  readonly min: number
+  readonly max: number
+}
+
 /**
  * Mutable runtime state maintained by a `Pool`.
  *
@@ -463,7 +484,7 @@ export const get = <A, E>(self: Pool<A, E>): Effect.Effect<A, E, Scope.Scope> =>
   core.withFiber((fiber) => {
     const state = self.state
     if (state.isShuttingDown) return internal.interrupt
-    if (state.availableHead?.exit._tag === "Success") {
+    if (state.waiters.size === 0 && state.availableHead?.exit._tag === "Success") {
       state.usage++
       if (self.config.isFixed || targetSize(self) <= activeSize(self)) {
         return leaseItem(self, state.availableHead, fiber)
@@ -570,7 +591,7 @@ export const use: {
   core.withFiber((fiber) => {
     const state = self.state
     if (state.isShuttingDown) return internal.interrupt
-    if (state.availableHead?.exit._tag === "Success") {
+    if (state.waiters.size === 0 && state.availableHead?.exit._tag === "Success") {
       state.usage++
       if (self.config.isFixed || targetSize(self) <= activeSize(self)) {
         return useItem(self, state.availableHead, f, fiber)
@@ -611,12 +632,18 @@ const getSlowWith = <A, E, X, R>(
   internal.uninterruptibleMask((restore) => {
     const state = self.state
     state.usage++
+    const waiter = makeWaiter<A, E>()
     const wait: Effect.Effect<X, any, R> = internal.flatMap(
       internal.onError(
-        restore(waitForItem(self)),
+        restore(waitForItem(self, waiter)),
         () =>
-          internal.sync(() => {
+          core.withFiber((fiber) => {
             state.usage--
+            // Only a woken waiter is still registered here: one cancelled while
+            // asleep already left. It passes its wake on, so the capacity it was
+            // woken for is not stranded.
+            if (state.waiters.delete(waiter)) wakeWaiters(self, fiber, 1)
+            return internal.void
           })
       ),
       () => loop
@@ -626,6 +653,12 @@ const getSlowWith = <A, E, X, R>(
         state.usage--
         return internal.interrupt
       }
+      // A borrower that has not waited yet queues behind the borrowers already
+      // waiting. Waiters keep their place until they take an item, so this
+      // also holds while a woken waiter has yet to run.
+      if (state.waiters.size > 0 && !state.waiters.has(waiter)) {
+        return wait
+      }
       // Replace failed slots only when the pool cannot grow.
       const item = firstHealthyAvailable(self) ??
         (targetSize(self) <= activeSize(self) ? state.availableHead : undefined)
@@ -636,6 +669,7 @@ const getSlowWith = <A, E, X, R>(
         removeFailedItem(self, item)
         return loop
       }
+      state.waiters.delete(waiter)
       return lease(self, item, fiber, restore)
     })
     const loop: Effect.Effect<X, any, R> = internal.suspend(() => {
@@ -718,19 +752,49 @@ const firstHealthyAvailable = <A, E>(self: Pool<A, E>): PoolItem<A, E> | undefin
   return item
 }
 
-const waitForItem = <A, E>(self: Pool<A, E>): Effect.Effect<void, E> =>
+/**
+ * A borrower's entry in `State.waiters`. It stays registered from the first
+ * wait until the borrower takes an item or leaves, so the borrower keeps its
+ * place in the queue across wakes.
+ *
+ * `resume` is set while the borrower is asleep. A registered waiter without
+ * one has been woken and has yet to take an item, wait again or leave.
+ */
+interface Waiter<A, E> {
+  (failure?: Exit.Failure<A, E>): void
+  resume: ((effect: Effect.Effect<void, E>) => void) | undefined
+}
+
+const makeWaiter = <A, E>(): Waiter<A, E> => {
+  const waiter = ((failure?: Exit.Failure<A, E>) => {
+    const resume = waiter.resume
+    if (resume === undefined) return
+    waiter.resume = undefined
+    resume(failure ?? internal.void)
+  }) as Waiter<A, E>
+  waiter.resume = undefined
+  return waiter
+}
+
+const waitForItem = <A, E>(self: Pool<A, E>, waiter: Waiter<A, E>): Effect.Effect<void, E> =>
   internal.callback((resume) => {
     const state = self.state
-    if (firstHealthyAvailable(self) !== undefined || state.isShuttingDown) {
+    if (
+      state.isShuttingDown ||
+      (state.waiters.size === 0 && firstHealthyAvailable(self) !== undefined)
+    ) {
       return resume(internal.void)
     }
-    const observer = (failure?: Exit.Failure<A, E>) => {
-      state.waiters.delete(observer)
-      resume(failure ?? internal.void)
-    }
-    state.waiters.add(observer)
+    waiter.resume = resume
+    // Re-adding a registered waiter keeps its position.
+    state.waiters.add(waiter)
     return internal.sync(() => {
-      state.waiters.delete(observer)
+      // Cancelled while asleep: leave at once, so no wake or failure is spent
+      // on it. Cancelled after a wake: stay until the wake is passed on.
+      if (waiter.resume !== undefined) {
+        waiter.resume = undefined
+        state.waiters.delete(waiter)
+      }
     })
   })
 
@@ -738,23 +802,36 @@ const wakeWaiters = <A, E>(self: Pool<A, E>, fiber: Fiber.Fiber<unknown, unknown
   const waiters = self.state.waiters
   if (waiters.size === 0) return
   fiber.currentDispatcher.scheduleTask(() => {
+    // Walk the live set, so a waiter that leaves during the walk does not use
+    // up a wake. Skip waiters already woken, and stop once nothing is left to
+    // take.
     let remaining = count
-    const toWake: Array<(failure?: Exit.Failure<A, E>) => void> = []
     for (const notify of waiters) {
-      if (remaining-- <= 0) break
-      toWake.push(notify)
-    }
-    for (let i = 0; i < toWake.length; i++) {
-      toWake[i]()
+      if (remaining <= 0 || self.state.availableHead === undefined) break
+      if ((notify as Waiter<A, E>).resume === undefined) continue
+      remaining--
+      notify()
     }
   }, 0)
 }
 
-const wakeAll = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
-  core.withFiber((fiber) => {
-    wakeWaiters(self, fiber, Number.POSITIVE_INFINITY)
-    return internal.void
-  })
+const firstSleepingWaiter = <A, E>(self: Pool<A, E>) => {
+  for (const notify of self.state.waiters) {
+    if ((notify as Waiter<A, E>).resume !== undefined) return notify
+  }
+  return undefined
+}
+
+// Wakes every waiter so it can retry after a failed acquisition. A waiter that
+// could not start a resize while another was running depends on this. Waking
+// a waiter that is already awake is a no-op.
+const wakeAll = <A, E>(self: Pool<A, E>, fiber: Fiber.Fiber<unknown, unknown>) => {
+  const waiters = self.state.waiters
+  if (waiters.size === 0) return
+  fiber.currentDispatcher.scheduleTask(() => {
+    for (const notify of Array.from(waiters)) notify()
+  }, 0)
+}
 
 // Reservations prevent reuse without extending the lifetime of borrowed items.
 const reservations = new WeakMap<PoolItem<unknown, unknown>, number>()
@@ -970,6 +1047,52 @@ export const reserve: {
     ))
 )
 
+/**
+ * Returns a snapshot of how many items are idle or in use and how many
+ * borrowers are waiting.
+ *
+ * **When to use**
+ *
+ * Use to sample pool occupancy for metrics, such as connection counts for a
+ * database driver.
+ *
+ * **Details**
+ *
+ * - Only successfully acquired items are counted. Items still being acquired
+ *   and failed acquisitions are not.
+ * - An item is used while it has a borrower or a reservation, otherwise idle.
+ * - An invalidated item counts as used until its last borrower returns it.
+ *
+ * **Gotchas**
+ *
+ * The replacement for an invalidated item is acquired while the old one is
+ * still borrowed, so `idle + used` can briefly exceed `max`. A borrower that
+ * has been woken but has not yet taken its item is not counted as pending.
+ *
+ * @see {@link Stats} for the snapshot fields
+ *
+ * @stability unstable
+ * @category getters
+ * @since 4.0.0
+ */
+export const stats = <A, E>(self: Pool<A, E>): Effect.Effect<Stats> =>
+  Effect.sync(() => {
+    let idle = 0
+    let used = 0
+    for (const item of self.state.items) {
+      if (item.exit._tag !== "Success") continue
+      if (item.refCount > 0 || reservations.has(item)) used++
+      else idle++
+    }
+    return {
+      idle,
+      used,
+      pending: self.state.waiters.size,
+      min: self.config.minSize,
+      max: self.config.maxSize
+    }
+  })
+
 const invalidatePoolItem = <A, E>(self: Pool<A, E>, poolItem: PoolItem<A, E>): Effect.Effect<void> =>
   Effect.suspend(() => {
     if (!self.state.items.has(poolItem)) {
@@ -1005,22 +1128,38 @@ const resizeLoop = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
       return Effect.void
     }
     const toAcquire = target - active
-    const acquireOne = self.config.strategy === strategyNoop
-      ? allocate(self)
-      : Effect.flatMap(
-        self.config.strategy.reclaim(self),
-        (item) => item ? Effect.succeed(item) : allocate(self)
-      )
+    // Wake waiters as each item arrives. Waiting for the whole batch would
+    // leave acquired items idle behind a slow acquisition, with every borrower
+    // queued behind the waiters.
+    const acquireOne = Effect.tap(
+      self.config.strategy === strategyNoop
+        ? allocate(self)
+        : Effect.flatMap(
+          self.config.strategy.reclaim(self),
+          (item) =>
+            item
+              ? Effect.sync(() => {
+                // A reclaimed item rejoins circulation like a released one.
+                if (self.state.items.has(item) && !self.state.invalidated.has(item)) addAvailableFront(self, item)
+                return item
+              })
+              : allocate(self)
+        ),
+      (item) =>
+        core.withFiber((fiber) => {
+          // A failed acquisition wakes everyone so they can retry it. A new
+          // item can only serve as many waiters as it has slots.
+          if (item.exit._tag === "Failure") wakeAll(self, fiber)
+          else wakeWaiters(self, fiber, self.config.concurrency)
+          return internal.void
+        })
+    )
     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))
+        ? Effect.asVoid(acquireOne)
+        : Effect.flatMap(acquireOne, (item) => item.exit._tag === "Failure" ? Effect.void : resizeLoop(self))
     }
-    const acquired = acquireOne.pipe(
-      Effect.replicateEffect(toAcquire, { concurrency: toAcquire }),
-      Effect.tap(wakeAll(self))
-    )
+    const acquired = Effect.replicateEffect(acquireOne, toAcquire, { concurrency: toAcquire })
     return self.config.isFixed
       ? Effect.asVoid(acquired)
       : Effect.flatMap(
@@ -1039,7 +1178,10 @@ const allocate = <A, E>(self: Pool<A, E>): Effect.Effect<PoolItem<A, E>> =>
       const use = Effect.flatMap(Effect.exit(impl[Acquire]), (exit) => {
         const item: PoolItem<A, E> = {
           exit,
-          finalizer: Effect.catchCause(Scope.close(scope, exit), reportUnhandledError),
+          finalizer: Effect.ignoreCause(Scope.close(scope, exit), {
+            log: "Unhandled",
+            message: "Unhandled error in pool finalizer"
+          }),
           refCount: 0,
           idleSince: impl[PoolClock].currentTimeMillisUnsafe(),
           disableReclaim: false,
@@ -1059,7 +1201,7 @@ const allocate = <A, E>(self: Pool<A, E>): Effect.Effect<PoolItem<A, E>> =>
           return self.config.strategy === strategyNoop ? Effect.succeed(item) : Effect.as(onAcquire, item)
         }
         // Deliver a waiting borrower its own failure; otherwise retain the slot.
-        const waiter = firstHealthyAvailable(self) === undefined ? self.state.waiters.values().next().value : undefined
+        const waiter = firstHealthyAvailable(self) === undefined ? firstSleepingWaiter(self) : undefined
         if (waiter !== undefined) {
           waiter(exit)
         } else {
@@ -1163,15 +1305,3 @@ const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input)
     reclaim: (_) => Effect.undefined
   })
 })
-
-const reportUnhandledError = <E>(cause: Cause.Cause<E>) =>
-  Effect.withFiber<void>((fiber) => {
-    const unhandledLogLevel = fiber.getRef(UnhandledLogLevel)
-    if (unhandledLogLevel) {
-      return Effect.logWithLevel(unhandledLogLevel)(
-        "Unhandled error in pool finalizer",
-        cause
-      )
-    }
-    return Effect.void
-  })

package/src/PubSub.ts

@@ -3129,14 +3129,13 @@ export class BackPressureStrategy<in out A> implements PubSub.Strategy<A> {
       if (publisher === MutableList.Empty) {
         keepPolling = false
       } else {
-        const [value, deferred] = publisher
+        const [value, deferred, last] = publisher
         const published = pubsub.publish(value)
-        if (published && publisher[2]) {
-          Deferred.doneUnsafe(deferred, Exit.succeed(true))
-        } else if (!published) {
-          MutableList.prepend(this.publishers, publisher)
-        }
+        if (!published) MutableList.prepend(this.publishers, publisher)
         this.completeSubscribersUnsafe(pubsub, subscribers)
+        // Resuming the publisher can synchronously end the PubSub, so notify
+        // waiting subscribers first.
+        if (published && last) Deferred.doneUnsafe(deferred, Exit.succeed(true))
       }
     }
   }