effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/TxQueue.ts

@@ -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>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const items = yield* TxChunk.empty<A>()
     const stateRef = yield* TxRef.make<State<A, E>>({ _tag: "Open" })
@@ -445,7 +447,7 @@ export const bounded = <A = never, E = never>(capacity: number): Effect.Effect<T
  * @since 4.0.0
  * @category constructors
  */
-export const unbounded = <A = never, E = never>(): Effect.Effect<TxQueue<A, E>> =>
+export const unbounded = <A = never, E = never>(): Effect.Effect<TxQueue<A, E>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const items = yield* TxChunk.empty<A>()
     const stateRef = yield* TxRef.make<State<A, E>>({ _tag: "Open" })
@@ -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>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const items = yield* TxChunk.empty<A>()
     const stateRef = yield* TxRef.make<State<A, E>>({ _tag: "Open" })
@@ -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>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const items = yield* TxChunk.empty<A>()
     const stateRef = yield* TxRef.make<State<A, E>>({ _tag: "Open" })
@@ -593,7 +599,7 @@ export const offer: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, E>(value: A): (self: TxEnqueue<A, E>) => Effect.Effect<boolean>
+  <A, E>(value: A): (self: TxEnqueue<A, E>) => Effect.Effect<boolean, never, Effect.Transaction>
   // =============================================================================
   // Core Queue Operations
   // =============================================================================
@@ -620,9 +626,10 @@ export const offer: {
    * @since 4.0.0
    * @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(
+  <A, E>(self: TxEnqueue<A, E>, value: A): Effect.Effect<boolean, never, Effect.Transaction>
+} = dual(
+  2,
+  <A, E>(self: TxEnqueue<A, E>, value: A): Effect.Effect<boolean, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
       if (state._tag === "Done" || state._tag === "Closing") {
@@ -657,7 +664,7 @@ export const offer: {
       // bounded strategy - block until space is available
       return yield* Effect.retryTransaction
     })
-  ))
+)
 
 /**
  * Offers multiple items to the queue.
@@ -710,7 +717,7 @@ export const offerAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, E>(values: Iterable<A>): (self: TxEnqueue<A, E>) => Effect.Effect<Array<A>>
+  <A, E>(values: Iterable<A>): (self: TxEnqueue<A, E>) => Effect.Effect<Array<A>, never, Effect.Transaction>
   /**
    * Offers multiple items to the queue.
    *
@@ -736,24 +743,22 @@ export const offerAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, E>(self: TxEnqueue<A, E>, values: Iterable<A>): Effect.Effect<Array<A>>
+  <A, E>(self: TxEnqueue<A, E>, values: Iterable<A>): Effect.Effect<Array<A>, never, Effect.Transaction>
 } = 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)
-          }
+  <A, E>(self: TxEnqueue<A, E>, values: Iterable<A>): Effect.Effect<Array<A>, never, Effect.Transaction> =>
+    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
+    })
 )
 
 /**
@@ -784,38 +789,36 @@ export const offerAll: {
  * @since 4.0.0
  * @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)
+export const take = <A, E>(self: TxDequeue<A, E>): Effect.Effect<A, E, Effect.Transaction> =>
+  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.retryTransaction
+    }
 
-      // 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.retryTransaction
+    }
 
-      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
+  })
 
 /**
  * Tries to take an item from the queue without blocking.
@@ -840,24 +843,22 @@ export const take = <A, E>(self: TxDequeue<A, E>): Effect.Effect<A, E> =>
  * @since 4.0.0
  * @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()
-      }
+export const poll = <A, E>(self: TxDequeue<A, E>): Effect.Effect<Option.Option<A>, never, Effect.Transaction> =>
+  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)
+  })
 
 /**
  * Takes all items from the queue. Blocks if the queue is empty.
@@ -899,35 +900,33 @@ export const poll = <A, E>(self: TxDequeue<A, E>): Effect.Effect<Option.Option<A
  * @since 4.0.0
  * @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)
+export const takeAll = <A, E>(self: TxDequeue<A, E>): Effect.Effect<Arr.NonEmptyArray<A>, E, Effect.Transaction> =>
+  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.retryTransaction
+    }
 
-      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
+  })
 
 /**
  * Takes exactly N items from the queue in a single atomic transaction.
@@ -1000,7 +999,7 @@ export const takeN: {
    * @since 4.0.0
    * @category combinators
    */
-  (n: number): <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Array<A>, E>
+  (n: number): <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Array<A>, E, Effect.Transaction>
   /**
    * Takes exactly N items from the queue in a single atomic transaction.
    *
@@ -1036,64 +1035,62 @@ export const takeN: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, E>(self: TxDequeue<A, E>, n: number): Effect.Effect<Array<A>, E>
+  <A, E>(self: TxDequeue<A, E>, n: number): Effect.Effect<Array<A>, E, Effect.Transaction>
 } = 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)
-
-        // Check if queue is done - forward the cause directly
-        if (state._tag === "Done") {
-          return yield* Effect.failCause(state.cause)
-        }
+  <A, E>(self: TxDequeue<A, E>, n: number): Effect.Effect<Array<A>, E, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const state = yield* TxRef.get(self.stateRef)
 
-        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
-          }
+      // Check if queue is done - forward the cause directly
+      if (state._tag === "Done") {
+        return yield* Effect.failCause(state.cause)
+      }
 
-          // Queue is still open but not enough items - retry transaction
-          return yield* Effect.retryTransaction
-        }
+      const currentSize = yield* size(self)
+
+      // 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.retryTransaction
+      }
+
+      // 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)
+    })
 )
 
 /**
@@ -1153,7 +1150,7 @@ export const takeBetween: {
    * @since 4.0.0
    * @category taking
    */
-  (min: number, max: number): <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Array<A>, E>
+  (min: number, max: number): <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Array<A>, E, Effect.Transaction>
   /**
    * Takes a variable number of items between a specified minimum and maximum from the queue.
    * Waits for at least the minimum number of items to be available.
@@ -1182,60 +1179,58 @@ export const takeBetween: {
    * @since 4.0.0
    * @category taking
    */
-  <A, E>(self: TxDequeue<A, E>, min: number, max: number): Effect.Effect<Array<A>, E>
+  <A, E>(self: TxDequeue<A, E>, min: number, max: number): Effect.Effect<Array<A>, E, Effect.Transaction>
 } = 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)
-
-        // Check if queue is done - forward the cause directly
-        if (state._tag === "Done") {
-          return yield* Effect.failCause(state.cause)
-        }
+  <A, E>(self: TxDequeue<A, E>, min: number, max: number): Effect.Effect<Array<A>, E, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const state = yield* TxRef.get(self.stateRef)
 
-        // Validate parameters
-        if (min <= 0 || max <= 0 || min > max) {
-          return []
-        }
+      // Check if queue is done - forward the cause directly
+      if (state._tag === "Done") {
+        return yield* Effect.failCause(state.cause)
+      }
 
-        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())
+      // 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 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.retryTransaction
+      }
+
+      // 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 })
-        }
+      // 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)
+    })
 )
 
 /**
@@ -1273,23 +1268,21 @@ export const takeBetween: {
  * @since 4.0.0
  * @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)
-      }
+export const peek = <A, E>(self: TxDequeue<A, E>): Effect.Effect<A, E, Effect.Transaction> =>
+  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.retryTransaction
+    }
 
-      return head.value
-    })
-  )
+    return head.value
+  })
 
 /**
  * Gets the current size of the queue.
@@ -1310,7 +1303,7 @@ export const peek = <A, E>(self: TxDequeue<A, E>): Effect.Effect<A, E> =>
  * @since 4.0.0
  * @category combinators
  */
-export const size = (self: TxQueueState): Effect.Effect<number> => TxChunk.size(self.items)
+export const size = (self: TxQueueState): Effect.Effect<number, never, Effect.Transaction> => TxChunk.size(self.items)
 
 /**
  * Checks if the queue is empty.
@@ -1334,7 +1327,8 @@ export const size = (self: TxQueueState): Effect.Effect<number> => TxChunk.size(
  * @since 4.0.0
  * @category combinators
  */
-export const isEmpty = (self: TxQueueState): Effect.Effect<boolean> => TxChunk.isEmpty(self.items)
+export const isEmpty = (self: TxQueueState): Effect.Effect<boolean, never, Effect.Transaction> =>
+  TxChunk.isEmpty(self.items)
 
 /**
  * Checks if the queue is at capacity.
@@ -1358,7 +1352,7 @@ export const isEmpty = (self: TxQueueState): Effect.Effect<boolean> => TxChunk.i
  * @since 4.0.0
  * @category combinators
  */
-export const isFull = (self: TxQueueState): Effect.Effect<boolean> =>
+export const isFull = (self: TxQueueState): Effect.Effect<boolean, never, Effect.Transaction> =>
   Effect.gen(function*() {
     if (self.capacity === Number.POSITIVE_INFINITY) {
       return false
@@ -1390,7 +1384,7 @@ export const isFull = (self: TxQueueState): Effect.Effect<boolean> =>
  * @since 4.0.0
  * @category combinators
  */
-export const interrupt = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean> =>
+export const interrupt = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean, never, Effect.Transaction> =>
   Effect.withFiber((fiber) => failCause(self, Cause.interrupt(fiber.id)))
 
 /**
@@ -1438,7 +1432,7 @@ export const fail: {
    * @since 4.0.0
    * @category combinators
    */
-  <E>(error: E): <A>(self: TxEnqueue<A, E>) => Effect.Effect<boolean>
+  <E>(error: E): <A>(self: TxEnqueue<A, E>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Fails the queue with the specified error.
    *
@@ -1461,9 +1455,10 @@ export const fail: {
    * @since 4.0.0
    * @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(
+  <A, E>(self: TxEnqueue<A, E>, error: E): Effect.Effect<boolean, never, Effect.Transaction>
+} = dual(
+  2,
+  <A, E>(self: TxEnqueue<A, E>, error: E): Effect.Effect<boolean, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
 
@@ -1477,7 +1472,7 @@ export const fail: {
 
       return true
     })
-  ))
+)
 
 /**
  * Completes the queue with the specified exit value.
@@ -1526,7 +1521,7 @@ export const failCause: {
    * @since 4.0.0
    * @category combinators
    */
-  <E>(cause: Cause.Cause<E>): <A>(self: TxEnqueue<A, E>) => Effect.Effect<boolean>
+  <E>(cause: Cause.Cause<E>): <A>(self: TxEnqueue<A, E>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Completes the queue with the specified exit value.
    *
@@ -1550,9 +1545,10 @@ export const failCause: {
    * @since 4.0.0
    * @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(
+  <A, E>(self: TxEnqueue<A, E>, cause: Cause.Cause<E>): Effect.Effect<boolean, never, Effect.Transaction>
+} = dual(
+  2,
+  <A, E>(self: TxEnqueue<A, E>, cause: Cause.Cause<E>): Effect.Effect<boolean, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const state = yield* TxRef.get(self.stateRef)
 
@@ -1570,7 +1566,7 @@ export const failCause: {
 
       return true
     })
-  ))
+)
 
 /**
  * Ends a queue by signaling completion with a Done error.
@@ -1606,7 +1602,7 @@ export const failCause: {
  * @since 4.0.0
  * @category combinators
  */
-export const end = <A, E>(self: TxEnqueue<A, E | Cause.Done>): Effect.Effect<boolean> =>
+export const end = <A, E>(self: TxEnqueue<A, E | Cause.Done>): Effect.Effect<boolean, never, Effect.Transaction> =>
   failCause(self, Cause.fail(Cause.Done()))
 
 /**
@@ -1638,22 +1634,20 @@ export const end = <A, E>(self: TxEnqueue<A, E | Cause.Done>): Effect.Effect<boo
  * @since 4.0.0
  * @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)
+export const clear = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<Array<A>, ExcludeDone<E>, Effect.Transaction> =>
+  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)
+  })
 
 /**
  * Shuts down the queue immediately by clearing all items and interrupting it (legacy compatibility).
@@ -1689,13 +1683,11 @@ export const clear = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<Array<A>, Excl
  * @since 4.0.0
  * @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)
-    })
-  )
+export const shutdown = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean, never, Effect.Transaction> =>
+  Effect.gen(function*() {
+    yield* Effect.ignore(clear(self))
+    return yield* interrupt(self)
+  })
 
 /**
  * Checks if the queue is in the open state.
@@ -1719,7 +1711,7 @@ export const shutdown = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean> =>
  * @since 4.0.0
  * @category combinators
  */
-export const isOpen = (self: TxQueueState): Effect.Effect<boolean> =>
+export const isOpen = (self: TxQueueState): Effect.Effect<boolean, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     return state._tag === "Open"
@@ -1748,7 +1740,7 @@ export const isOpen = (self: TxQueueState): Effect.Effect<boolean> =>
  * @since 4.0.0
  * @category combinators
  */
-export const isClosing = (self: TxQueueState): Effect.Effect<boolean> =>
+export const isClosing = (self: TxQueueState): Effect.Effect<boolean, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     return state._tag === "Closing"
@@ -1776,7 +1768,7 @@ export const isClosing = (self: TxQueueState): Effect.Effect<boolean> =>
  * @since 4.0.0
  * @category combinators
  */
-export const isDone = (self: TxQueueState): Effect.Effect<boolean> =>
+export const isDone = (self: TxQueueState): Effect.Effect<boolean, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const state = yield* TxRef.get(self.stateRef)
     return state._tag === "Done"
@@ -1804,7 +1796,7 @@ export const isDone = (self: TxQueueState): Effect.Effect<boolean> =>
  * @since 4.0.0
  * @category combinators
  */
-export const isShutdown = (self: TxQueueState): Effect.Effect<boolean> => isDone(self)
+export const isShutdown = (self: TxQueueState): Effect.Effect<boolean, never, Effect.Transaction> => isDone(self)
 
 /**
  * Waits for the queue to complete (either successfully or with failure).
@@ -1828,16 +1820,14 @@ export const isShutdown = (self: TxQueueState): Effect.Effect<boolean> => isDone
  * @since 4.0.0
  * @category combinators
  */
-export const awaitCompletion = (self: TxQueueState): Effect.Effect<void> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
+export const awaitCompletion = (self: TxQueueState): Effect.Effect<void, never, Effect.Transaction> =>
+  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.retryTransaction
+  })