effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/TxQueue.ts

@@ -5,7 +5,7 @@
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and to track changes.
  * A transaction will retry whenever a conflict is detected or whenever the transaction explicitly
- * calls `Effect.retryTransaction` and any of the accessed TxQueue values change.
+ * calls `Effect.txRetry` and any of the accessed TxQueue values change.
  *
  * @since 4.0.0
  */
@@ -403,7 +403,9 @@ const TxQueueProto = {
  * @since 4.0.0
  * @category constructors
  */
-export const bounded = <A = never, E = never>(capacity: number): Effect.Effect<TxQueue<A, E>> =>
+export const bounded = <A = never, E = never>(
+  capacity: number
+): Effect.Effect<TxQueue<A, E>> =>
   Effect.gen(function*() {
     const items = yield* TxChunk.empty<A>()
     const stateRef = yield* TxRef.make<State<A, E>>({ _tag: "Open" })
@@ -414,7 +416,7 @@ export const bounded = <A = never, E = never>(capacity: number): Effect.Effect<T
     txQueue.items = items
     txQueue.stateRef = stateRef
     return txQueue
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Creates a new unbounded `TxQueue` with unlimited capacity.
@@ -456,7 +458,7 @@ export const unbounded = <A = never, E = never>(): Effect.Effect<TxQueue<A, E>>
     txQueue.items = items
     txQueue.stateRef = stateRef
     return txQueue
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Creates a new dropping `TxQueue` with the specified capacity that drops new items when full.
@@ -485,7 +487,9 @@ export const unbounded = <A = never, E = never>(): Effect.Effect<TxQueue<A, E>>
  * @since 4.0.0
  * @category constructors
  */
-export const dropping = <A = never, E = never>(capacity: number): Effect.Effect<TxQueue<A, E>> =>
+export const dropping = <A = never, E = never>(
+  capacity: number
+): Effect.Effect<TxQueue<A, E>> =>
   Effect.gen(function*() {
     const items = yield* TxChunk.empty<A>()
     const stateRef = yield* TxRef.make<State<A, E>>({ _tag: "Open" })
@@ -496,7 +500,7 @@ export const dropping = <A = never, E = never>(capacity: number): Effect.Effect<
     txQueue.items = items
     txQueue.stateRef = stateRef
     return txQueue
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Creates a new sliding `TxQueue` with the specified capacity that evicts old items when full.
@@ -527,7 +531,9 @@ export const dropping = <A = never, E = never>(capacity: number): Effect.Effect<
  * @since 4.0.0
  * @category constructors
  */
-export const sliding = <A = never, E = never>(capacity: number): Effect.Effect<TxQueue<A, E>> =>
+export const sliding = <A = never, E = never>(
+  capacity: number
+): Effect.Effect<TxQueue<A, E>> =>
   Effect.gen(function*() {
     const items = yield* TxChunk.empty<A>()
     const stateRef = yield* TxRef.make<State<A, E>>({ _tag: "Open" })
@@ -538,7 +544,7 @@ export const sliding = <A = never, E = never>(capacity: number): Effect.Effect<T
     txQueue.items = items
     txQueue.stateRef = stateRef
     return txQueue
-  })
+  }).pipe(Effect.tx)
 
 // =============================================================================
 // Core Queue Operations
@@ -621,8 +627,9 @@ export const offer: {
    * @category combinators
    */
   <A, E>(self: TxEnqueue<A, E>, value: A): Effect.Effect<boolean>
-} = dual(2, <A, E>(self: TxEnqueue<A, E>, value: A): Effect.Effect<boolean> =>
-  Effect.atomic(
+} = dual(
+  2,
+  <A, E>(self: TxEnqueue<A, E>, value: A): Effect.Effect<boolean> =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
       if (state._tag === "Done" || state._tag === "Closing") {
@@ -655,9 +662,9 @@ export const offer: {
       }
 
       // bounded strategy - block until space is available
-      return yield* Effect.retryTransaction
-    })
-  ))
+      return yield* Effect.txRetry
+    }).pipe(Effect.tx)
+)
 
 /**
  * Offers multiple items to the queue.
@@ -740,20 +747,18 @@ export const offerAll: {
 } = dual(
   2,
   <A, E>(self: TxEnqueue<A, E>, values: Iterable<A>): Effect.Effect<Array<A>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const rejected: Array<A> = []
-
-        for (const value of values) {
-          const accepted = yield* offer(self, value)
-          if (!accepted) {
-            rejected.push(value)
-          }
+    Effect.gen(function*() {
+      const rejected: Array<A> = []
+
+      for (const value of values) {
+        const accepted = yield* offer(self, value)
+        if (!accepted) {
+          rejected.push(value)
         }
+      }
 
-        return rejected
-      })
-    )
+      return rejected
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -785,37 +790,35 @@ export const offerAll: {
  * @category combinators
  */
 export const take = <A, E>(self: TxDequeue<A, E>): Effect.Effect<A, E> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
 
-      // Check if queue is done - forward the cause directly
-      if (state._tag === "Done") {
-        return yield* Effect.failCause(state.cause)
-      }
+    // Check if queue is done - forward the cause directly
+    if (state._tag === "Done") {
+      return yield* Effect.failCause(state.cause)
+    }
 
-      // If no items available, retry transaction
-      if (yield* isEmpty(self)) {
-        return yield* Effect.retryTransaction
-      }
+    // If no items available, retry transaction
+    if (yield* isEmpty(self)) {
+      return yield* Effect.txRetry
+    }
 
-      // Take item from queue
-      const chunk = yield* TxChunk.get(self.items)
-      const head = Chunk.head(chunk)
-      if (Option.isNone(head)) {
-        return yield* Effect.retryTransaction
-      }
+    // Take item from queue
+    const chunk = yield* TxChunk.get(self.items)
+    const head = Chunk.head(chunk)
+    if (Option.isNone(head)) {
+      return yield* Effect.txRetry
+    }
 
-      yield* TxChunk.drop(self.items, 1)
+    yield* TxChunk.drop(self.items, 1)
 
-      // Check if we need to transition Closing → Done
-      if (state._tag === "Closing" && (yield* isEmpty(self))) {
-        yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
-      }
+    // Check if we need to transition Closing → Done
+    if (state._tag === "Closing" && (yield* isEmpty(self))) {
+      yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
+    }
 
-      return head.value
-    })
-  )
+    return head.value
+  }).pipe(Effect.tx)
 
 /**
  * Tries to take an item from the queue without blocking.
@@ -841,23 +844,21 @@ export const take = <A, E>(self: TxDequeue<A, E>): Effect.Effect<A, E> =>
  * @category combinators
  */
 export const poll = <A, E>(self: TxDequeue<A, E>): Effect.Effect<Option.Option<A>> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
-      if (state._tag === "Done") {
-        return Option.none()
-      }
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
+    if (state._tag === "Done") {
+      return Option.none()
+    }
 
-      const chunk = yield* TxChunk.get(self.items)
-      const head = Chunk.head(chunk)
-      if (Option.isNone(head)) {
-        return Option.none()
-      }
+    const chunk = yield* TxChunk.get(self.items)
+    const head = Chunk.head(chunk)
+    if (Option.isNone(head)) {
+      return Option.none()
+    }
 
-      yield* TxChunk.drop(self.items, 1)
-      return Option.some(head.value)
-    })
-  )
+    yield* TxChunk.drop(self.items, 1)
+    return Option.some(head.value)
+  }).pipe(Effect.tx)
 
 /**
  * Takes all items from the queue. Blocks if the queue is empty.
@@ -900,34 +901,32 @@ export const poll = <A, E>(self: TxDequeue<A, E>): Effect.Effect<Option.Option<A
  * @category combinators
  */
 export const takeAll = <A, E>(self: TxDequeue<A, E>): Effect.Effect<Arr.NonEmptyArray<A>, E> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
 
-      // Handle done queue
-      if (state._tag === "Done") {
-        return yield* Effect.failCause(state.cause)
-      }
+    // Handle done queue
+    if (state._tag === "Done") {
+      return yield* Effect.failCause(state.cause)
+    }
 
-      // Wait if empty - same pattern as take()
-      if (yield* isEmpty(self)) {
-        return yield* Effect.retryTransaction
-      }
+    // Wait if empty - same pattern as take()
+    if (yield* isEmpty(self)) {
+      return yield* Effect.txRetry
+    }
 
-      const chunk = yield* TxChunk.get(self.items)
+    const chunk = yield* TxChunk.get(self.items)
 
-      // Take all items (guaranteed non-empty due to isEmpty check above)
-      const items = Chunk.toArray(chunk) as Arr.NonEmptyArray<A>
-      yield* TxChunk.set(self.items, Chunk.empty())
+    // Take all items (guaranteed non-empty due to isEmpty check above)
+    const items = Chunk.toArray(chunk) as Arr.NonEmptyArray<A>
+    yield* TxChunk.set(self.items, Chunk.empty())
 
-      // Check if we need to transition Closing → Done
-      if (state._tag === "Closing") {
-        yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
-      }
+    // Check if we need to transition Closing → Done
+    if (state._tag === "Closing") {
+      yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
+    }
 
-      return items
-    })
-  )
+    return items
+  }).pipe(Effect.tx)
 
 /**
  * Takes exactly N items from the queue in a single atomic transaction.
@@ -1040,60 +1039,58 @@ export const takeN: {
 } = dual(
   2,
   <A, E>(self: TxDequeue<A, E>, n: number): Effect.Effect<Array<A>, E> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const state = yield* TxRef.get(self.stateRef)
+    Effect.gen(function*() {
+      const state = yield* TxRef.get(self.stateRef)
 
-        // Check if queue is done - forward the cause directly
-        if (state._tag === "Done") {
-          return yield* Effect.failCause(state.cause)
-        }
+      // Check if queue is done - forward the cause directly
+      if (state._tag === "Done") {
+        return yield* Effect.failCause(state.cause)
+      }
 
-        const currentSize = yield* size(self)
-
-        // Determine how many items we can/should take
-        const requestedCount = n
-        const maxPossible = Math.min(requestedCount, self.capacity)
-
-        // If we can't get the requested amount due to capacity constraints,
-        // take what the capacity allows. Otherwise, wait for the full amount.
-        const shouldWaitForFull = requestedCount <= self.capacity
-        const minimumRequired = shouldWaitForFull ? requestedCount : maxPossible
-
-        // If we don't have enough items available
-        if (currentSize < minimumRequired) {
-          // If queue is closing, transition to done and return what we have
-          if (state._tag === "Closing") {
-            if (yield* isEmpty(self)) {
-              yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
-              return []
-            }
-            // Take all remaining items when closing
-            const chunk = yield* TxChunk.get(self.items)
-            const taken = Chunk.toArray(chunk)
-            yield* TxChunk.set(self.items, Chunk.empty())
-            yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
-            return taken
-          }
+      const currentSize = yield* size(self)
 
-          // Queue is still open but not enough items - retry transaction
-          return yield* Effect.retryTransaction
-        }
+      // Determine how many items we can/should take
+      const requestedCount = n
+      const maxPossible = Math.min(requestedCount, self.capacity)
 
-        // Take the determined number of items
-        const toTake = minimumRequired
-        const chunk = yield* TxChunk.get(self.items)
-        const taken = Chunk.take(chunk, toTake)
-        yield* TxChunk.drop(self.items, toTake)
+      // If we can't get the requested amount due to capacity constraints,
+      // take what the capacity allows. Otherwise, wait for the full amount.
+      const shouldWaitForFull = requestedCount <= self.capacity
+      const minimumRequired = shouldWaitForFull ? requestedCount : maxPossible
 
-        // Check if we need to transition Closing → Done
-        if (state._tag === "Closing" && (yield* isEmpty(self))) {
+      // If we don't have enough items available
+      if (currentSize < minimumRequired) {
+        // If queue is closing, transition to done and return what we have
+        if (state._tag === "Closing") {
+          if (yield* isEmpty(self)) {
+            yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
+            return []
+          }
+          // Take all remaining items when closing
+          const chunk = yield* TxChunk.get(self.items)
+          const taken = Chunk.toArray(chunk)
+          yield* TxChunk.set(self.items, Chunk.empty())
           yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
+          return taken
         }
 
-        return Chunk.toArray(taken)
-      })
-    )
+        // Queue is still open but not enough items - retry transaction
+        return yield* Effect.txRetry
+      }
+
+      // Take the determined number of items
+      const toTake = minimumRequired
+      const chunk = yield* TxChunk.get(self.items)
+      const taken = Chunk.take(chunk, toTake)
+      yield* TxChunk.drop(self.items, toTake)
+
+      // Check if we need to transition Closing → Done
+      if (state._tag === "Closing" && (yield* isEmpty(self))) {
+        yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
+      }
+
+      return Chunk.toArray(taken)
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -1186,56 +1183,54 @@ export const takeBetween: {
 } = dual(
   3,
   <A, E>(self: TxDequeue<A, E>, min: number, max: number): Effect.Effect<Array<A>, E> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const state = yield* TxRef.get(self.stateRef)
+    Effect.gen(function*() {
+      const state = yield* TxRef.get(self.stateRef)
 
-        // Check if queue is done - forward the cause directly
-        if (state._tag === "Done") {
-          return yield* Effect.failCause(state.cause)
-        }
+      // Check if queue is done - forward the cause directly
+      if (state._tag === "Done") {
+        return yield* Effect.failCause(state.cause)
+      }
 
-        // Validate parameters
-        if (min <= 0 || max <= 0 || min > max) {
-          return []
-        }
+      // Validate parameters
+      if (min <= 0 || max <= 0 || min > max) {
+        return []
+      }
 
-        const currentSize = yield* size(self)
-
-        // If we have less than minimum required items
-        if (currentSize < min) {
-          // If queue is closing, transition to done and return what we have
-          if (state._tag === "Closing") {
-            if (yield* isEmpty(self)) {
-              yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
-              return []
-            }
-            // Take all remaining items when closing (if >= min or all available)
-            const chunk = yield* TxChunk.get(self.items)
-            const taken = Chunk.toArray(chunk)
-            yield* TxChunk.set(self.items, Chunk.empty())
+      const currentSize = yield* size(self)
+
+      // If we have less than minimum required items
+      if (currentSize < min) {
+        // If queue is closing, transition to done and return what we have
+        if (state._tag === "Closing") {
+          if (yield* isEmpty(self)) {
             yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
-            return taken
+            return []
           }
-
-          // Queue is still open but not enough items - retry transaction
-          return yield* Effect.retryTransaction
+          // Take all remaining items when closing (if >= min or all available)
+          const chunk = yield* TxChunk.get(self.items)
+          const taken = Chunk.toArray(chunk)
+          yield* TxChunk.set(self.items, Chunk.empty())
+          yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
+          return taken
         }
 
-        // We have at least the minimum, take up to the maximum
-        const toTake = Math.min(currentSize, max)
-        const chunk = yield* TxChunk.get(self.items)
-        const taken = Chunk.take(chunk, toTake)
-        yield* TxChunk.drop(self.items, toTake)
+        // Queue is still open but not enough items - retry transaction
+        return yield* Effect.txRetry
+      }
 
-        // Check if we need to transition Closing → Done
-        if (state._tag === "Closing" && (yield* isEmpty(self))) {
-          yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
-        }
+      // We have at least the minimum, take up to the maximum
+      const toTake = Math.min(currentSize, max)
+      const chunk = yield* TxChunk.get(self.items)
+      const taken = Chunk.take(chunk, toTake)
+      yield* TxChunk.drop(self.items, toTake)
+
+      // Check if we need to transition Closing → Done
+      if (state._tag === "Closing" && (yield* isEmpty(self))) {
+        yield* TxRef.set(self.stateRef, { _tag: "Done", cause: state.cause })
+      }
 
-        return Chunk.toArray(taken)
-      })
-    )
+      return Chunk.toArray(taken)
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -1274,22 +1269,20 @@ export const takeBetween: {
  * @category combinators
  */
 export const peek = <A, E>(self: TxDequeue<A, E>): Effect.Effect<A, E> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
-      if (state._tag === "Done") {
-        return yield* Effect.failCause(state.cause)
-      }
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
+    if (state._tag === "Done") {
+      return yield* Effect.failCause(state.cause)
+    }
 
-      const chunk = yield* TxChunk.get(self.items)
-      const head = Chunk.head(chunk)
-      if (Option.isNone(head)) {
-        return yield* Effect.retryTransaction
-      }
+    const chunk = yield* TxChunk.get(self.items)
+    const head = Chunk.head(chunk)
+    if (Option.isNone(head)) {
+      return yield* Effect.txRetry
+    }
 
-      return head.value
-    })
-  )
+    return head.value
+  }).pipe(Effect.tx)
 
 /**
  * Gets the current size of the queue.
@@ -1359,13 +1352,9 @@ export const isEmpty = (self: TxQueueState): Effect.Effect<boolean> => TxChunk.i
  * @category combinators
  */
 export const isFull = (self: TxQueueState): Effect.Effect<boolean> =>
-  Effect.gen(function*() {
-    if (self.capacity === Number.POSITIVE_INFINITY) {
-      return false
-    }
-    const currentSize = yield* size(self)
-    return currentSize >= self.capacity
-  })
+  self.capacity === Number.POSITIVE_INFINITY
+    ? Effect.succeed(false)
+    : Effect.map(size(self), (currentSize) => currentSize >= self.capacity)
 
 /**
  * Interrupts the queue, transitioning it to a closing state.
@@ -1462,8 +1451,9 @@ export const fail: {
    * @category combinators
    */
   <A, E>(self: TxEnqueue<A, E>, error: E): Effect.Effect<boolean>
-} = dual(2, <A, E>(self: TxEnqueue<A, E>, error: E): Effect.Effect<boolean> =>
-  Effect.atomic(
+} = dual(
+  2,
+  <A, E>(self: TxEnqueue<A, E>, error: E): Effect.Effect<boolean> =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
 
@@ -1476,8 +1466,8 @@ export const fail: {
       yield* TxRef.set(self.stateRef, { _tag: "Done", cause: Cause.fail(error) })
 
       return true
-    })
-  ))
+    }).pipe(Effect.tx)
+)
 
 /**
  * Completes the queue with the specified exit value.
@@ -1551,8 +1541,9 @@ export const failCause: {
    * @category combinators
    */
   <A, E>(self: TxEnqueue<A, E>, cause: Cause.Cause<E>): Effect.Effect<boolean>
-} = dual(2, <A, E>(self: TxEnqueue<A, E>, cause: Cause.Cause<E>): Effect.Effect<boolean> =>
-  Effect.atomic(
+} = dual(
+  2,
+  <A, E>(self: TxEnqueue<A, E>, cause: Cause.Cause<E>): Effect.Effect<boolean> =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
 
@@ -1569,8 +1560,8 @@ export const failCause: {
       }
 
       return true
-    })
-  ))
+    }).pipe(Effect.tx)
+)
 
 /**
  * Ends a queue by signaling completion with a Done error.
@@ -1639,21 +1630,19 @@ export const end = <A, E>(self: TxEnqueue<A, E | Cause.Done>): Effect.Effect<boo
  * @category combinators
  */
 export const clear = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<Array<A>, ExcludeDone<E>> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
-      if (state._tag === "Done") {
-        // Return empty array only for halt causes (like Cause.Done)
-        if (isDoneCause(state.cause)) {
-          return []
-        }
-        return yield* Effect.failCause(state.cause)
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
+    if (state._tag === "Done") {
+      // Return empty array only for halt causes (like Cause.Done)
+      if (isDoneCause(state.cause)) {
+        return []
       }
-      const chunk = yield* TxChunk.get(self.items)
-      yield* TxChunk.set(self.items, Chunk.empty())
-      return Chunk.toArray(chunk)
-    })
-  )
+      return yield* Effect.failCause(state.cause)
+    }
+    const chunk = yield* TxChunk.get(self.items)
+    yield* TxChunk.set(self.items, Chunk.empty())
+    return Chunk.toArray(chunk)
+  }).pipe(Effect.tx)
 
 /**
  * Shuts down the queue immediately by clearing all items and interrupting it (legacy compatibility).
@@ -1690,12 +1679,10 @@ export const clear = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<Array<A>, Excl
  * @category combinators
  */
 export const shutdown = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      yield* Effect.ignore(clear(self))
-      return yield* interrupt(self)
-    })
-  )
+  Effect.gen(function*() {
+    yield* Effect.ignore(clear(self))
+    return yield* interrupt(self)
+  }).pipe(Effect.tx)
 
 /**
  * Checks if the queue is in the open state.
@@ -1720,10 +1707,7 @@ export const shutdown = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean> =>
  * @category combinators
  */
 export const isOpen = (self: TxQueueState): Effect.Effect<boolean> =>
-  Effect.gen(function*() {
-    const state = yield* TxRef.get(self.stateRef)
-    return state._tag === "Open"
-  })
+  Effect.map(TxRef.get(self.stateRef), (state) => state._tag === "Open")
 
 /**
  * Checks if the queue is in the closing state.
@@ -1749,10 +1733,7 @@ export const isOpen = (self: TxQueueState): Effect.Effect<boolean> =>
  * @category combinators
  */
 export const isClosing = (self: TxQueueState): Effect.Effect<boolean> =>
-  Effect.gen(function*() {
-    const state = yield* TxRef.get(self.stateRef)
-    return state._tag === "Closing"
-  })
+  Effect.map(TxRef.get(self.stateRef), (state) => state._tag === "Closing")
 
 /**
  * Checks if the queue is done (completed or failed).
@@ -1777,10 +1758,7 @@ export const isClosing = (self: TxQueueState): Effect.Effect<boolean> =>
  * @category combinators
  */
 export const isDone = (self: TxQueueState): Effect.Effect<boolean> =>
-  Effect.gen(function*() {
-    const state = yield* TxRef.get(self.stateRef)
-    return state._tag === "Done"
-  })
+  Effect.map(TxRef.get(self.stateRef), (state) => state._tag === "Done")
 
 /**
  * Checks if the queue is shutdown (legacy compatibility).
@@ -1829,15 +1807,13 @@ export const isShutdown = (self: TxQueueState): Effect.Effect<boolean> => isDone
  * @category combinators
  */
 export const awaitCompletion = (self: TxQueueState): Effect.Effect<void> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
 
-      if (state._tag === "Done") {
-        return void 0
-      }
+    if (state._tag === "Done") {
+      return void 0
+    }
 
-      // Not done yet, retry transaction
-      return yield* Effect.retryTransaction
-    })
-  )
+    // Not done yet, retry transaction
+    return yield* Effect.txRetry
+  }).pipe(Effect.tx)