effect 4.0.0-beta.41 → 4.0.0-beta.42

package/src/Effect.ts

@@ -22604,107 +22604,56 @@ export class Transaction extends ServiceMap.Service<
   }
 >()("effect/Effect/Transaction") {}
 
-/**
- * Accesses the current transaction state within an active transaction.
- *
- * This function requires `Transaction` in the context and does NOT create or strip
- * transaction boundaries. Use it to interact with the transaction journal (e.g. in
- * `TxRef` internals). To define a transaction boundary, use {@link transaction}.
- *
- * @example
- * ```ts
- * import { Effect, TxRef } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   const ref = yield* Effect.transaction(TxRef.make(0))
- *
- *   yield* Effect.transaction(Effect.gen(function*() {
- *     yield* TxRef.set(ref, 42)
- *     return yield* TxRef.get(ref)
- *   }))
- * })
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export const withTxState = <A, E, R>(
-  f: (state: Transaction["Service"]) => Effect<A, E, R>
-): Effect<A, E, R | Transaction> =>
-  flatMap(
-    Transaction.asEffect(),
-    (state) => internalCall(() => f(state))
-  )
-
 /**
  * Defines a transaction boundary. Transactions are "all or nothing" with respect to changes
  * made to transactional values (i.e. TxRef) that occur within the transaction body.
  *
+ * If called inside an active transaction, `tx` composes with the current transaction and reuses
+ * its journal and retry state instead of creating a nested boundary.
+ *
  * In Effect transactions are optimistic with retry, that means transactions are retried when:
  *
- * - the body of the transaction explicitely calls to `Effect.retryTransaction` and any of the
+ * - the body of the transaction explicitely calls to `Effect.txRetry` and any of the
  *   accessed transactional values changes.
  *
  * - any of the accessed transactional values change during the execution of the transaction
  *   due to a different transaction committing before the current.
  *
- * Each call to `transaction` always creates a new isolated transaction boundary with its own
- * journal and retry logic.
+ * The outermost `tx` call creates the transaction boundary and commits or rolls back the full
+ * composed transaction.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   const ref1 = yield* Effect.transaction(TxRef.make(0))
- *   const ref2 = yield* Effect.transaction(TxRef.make(0))
+ *   const ref1 = yield* TxRef.make(0)
+ *   const ref2 = yield* TxRef.make(0)
  *
- *   // All operations within transaction block succeed or fail together
- *   yield* Effect.transaction(Effect.gen(function*() {
+ *   // Nested tx calls compose into the same transaction
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     yield* TxRef.set(ref1, 10)
- *     yield* TxRef.set(ref2, 20)
+ *     yield* Effect.tx(TxRef.set(ref2, 20))
  *     const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))
  *     console.log(`Transaction sum: ${sum}`)
  *   }))
  *
- *   console.log(`Final ref1: ${yield* Effect.transaction(TxRef.get(ref1))}`) // 10
- *   console.log(`Final ref2: ${yield* Effect.transaction(TxRef.get(ref2))}`) // 20
+ *   console.log(`Final ref1: ${yield* TxRef.get(ref1)}`) // 10
+ *   console.log(`Final ref2: ${yield* TxRef.get(ref2)}`) // 20
  * })
  * ```
  *
  * @since 4.0.0
  * @category Transactions
  */
-export const transaction = <A, E, R>(
+export const tx = <A, E, R>(
   effect: Effect<A, E, R>
-): Effect<A, E, Exclude<R, Transaction>> => transactionWith(() => effect)
-
-/**
- * Like {@link transaction} but provides access to the transaction state.
- *
- * Always creates a new isolated transaction boundary with its own journal and retry logic.
- *
- * @example
- * ```ts
- * import { Effect, TxRef } from "effect"
- *
- * const program = Effect.transactionWith((_txState) =>
- *   Effect.gen(function*() {
- *     const ref = yield* TxRef.make(0)
- *     yield* TxRef.set(ref, 42)
- *     return yield* TxRef.get(ref)
- *   })
- * )
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export const transactionWith = <A, E, R>(
-  f: (state: Transaction["Service"]) => Effect<A, E, R>
 ): Effect<A, E, Exclude<R, Transaction>> =>
   withFiber((fiber) => {
-    // Always create a new transaction state, never compose with parent
+    if (fiber.services.mapUnsafe.has(Transaction.key)) {
+      return effect as Effect<A, E, Exclude<R, Transaction>>
+    }
+    // Create transaction state only at the outermost boundary
     const state: Transaction["Service"] = { journal: new Map(), retry: false }
     let result: Exit.Exit<A, E> | undefined
     return uninterruptibleMask((restore) =>
@@ -22712,7 +22661,7 @@ export const transactionWith = <A, E, R>(
         whileLoop({
           while: () => !result,
           body: constant(
-            restore(suspend(() => f(state))).pipe(
+            restore(effect).pipe(
               provideService(Transaction, state),
               tapCause(() => {
                 if (!state.retry) return void_
@@ -22801,20 +22750,20 @@ function clearTransaction(state: Transaction["Service"]) {
  *
  * const program = Effect.gen(function*() {
  *   // create a transactional reference
- *   const ref = yield* Effect.transaction(TxRef.make(0))
+ *   const ref = yield* TxRef.make(0)
  *
  *   // forks a fiber that increases the value of `ref` every 100 millis
  *   yield* Effect.forkChild(Effect.forever(
  *     // update to transactional value
- *     Effect.transaction(TxRef.update(ref, (n) => n + 1)).pipe(Effect.delay("100 millis"))
+ *     Effect.tx(TxRef.update(ref, (n) => n + 1)).pipe(Effect.delay("100 millis"))
  *   ))
  *
  *   // the following will retry 10 times until the `ref` value is 10
- *   yield* Effect.transaction(Effect.gen(function*() {
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     const value = yield* TxRef.get(ref)
  *     if (value < 10) {
  *       yield* Effect.log(`retry due to value: ${value}`)
- *       return yield* Effect.retryTransaction
+ *       return yield* Effect.txRetry
  *     }
  *     yield* Effect.log(`transaction done with value: ${value}`)
  *   }))
@@ -22823,7 +22772,7 @@ function clearTransaction(state: Transaction["Service"]) {
  * Effect.runPromise(program).catch(console.error)
  * ```
  */
-export const retryTransaction: Effect<never, never, Transaction> = flatMap(
+export const txRetry: Effect<never, never, Transaction> = flatMap(
   Transaction.asEffect(),
   (state) => {
     state.retry = true

package/src/MutableList.ts

@@ -507,6 +507,9 @@ export const appendAll = <A>(self: MutableList<A>, messages: Iterable<A>): numbe
  * @category mutations
  */
 export const appendAllUnsafe = <A>(self: MutableList<A>, messages: ReadonlyArray<A>, mutable = false): number => {
+  if (messages.length === 0) {
+    return 0
+  }
   const chunk: MutableList.Bucket<A> = {
     array: messages as Array<A>,
     mutable,

package/src/Number.ts

@@ -957,15 +957,25 @@ export const remainder: {
    */
   (self: number, divisor: number): number
 } = dual(2, (self: number, divisor: number): number => {
-  // https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034
-  const selfDecCount = (self.toString().split(".")[1] || "").length
-  const divisorDecCount = (divisor.toString().split(".")[1] || "").length
+  const selfDecCount = decimalCount(self)
+  const divisorDecCount = decimalCount(divisor)
   const decCount = selfDecCount > divisorDecCount ? selfDecCount : divisorDecCount
   const selfInt = parseInt(self.toFixed(decCount).replace(".", ""))
   const divisorInt = parseInt(divisor.toFixed(decCount).replace(".", ""))
   return (selfInt % divisorInt) / Math.pow(10, decCount)
 })
 
+function decimalCount(n: number): number {
+  const s = n.toString()
+  const eIndex = s.indexOf("e-")
+  if (eIndex !== -1) {
+    const exp = parseInt(s.slice(eIndex + 2))
+    const mantissaDecimals = (s.slice(0, eIndex).split(".")[1] || "").length
+    return mantissaDecimals + exp
+  }
+  return (s.split(".")[1] || "").length
+}
+
 /**
  * Returns the next power of 2 from the given number.
  *

package/src/SchemaRepresentation.ts

@@ -3015,7 +3015,13 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
     }
 
     if (Array.isArray(js.allOf)) {
-      return js.allOf.reduce((acc, curr) => combine(acc, recur(curr)), out)
+      out = js.allOf.reduce((acc, curr) => combine(acc, recur(curr)), out)
+    }
+    if (Array.isArray(js.anyOf)) {
+      out = combine({ _tag: "Union", types: js.anyOf.map((type) => recur(type)), mode: "anyOf" }, out)
+    }
+    if (Array.isArray(js.oneOf)) {
+      out = combine({ _tag: "Union", types: js.oneOf.map((type) => recur(type)), mode: "oneOf" }, out)
     }
 
     return out
@@ -3054,10 +3060,6 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
       } else {
         return { _tag: "Union", types, mode: "anyOf" }
       }
-    } else if (Array.isArray(js.anyOf)) {
-      return { _tag: "Union", types: js.anyOf.map((type) => recur(type)), mode: "anyOf" }
-    } else if (Array.isArray(js.oneOf)) {
-      return { _tag: "Union", types: js.oneOf.map((type) => recur(type)), mode: "oneOf" }
     }
 
     const type = isType(js.type) ? js.type : getType(js)
@@ -3290,7 +3292,7 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
             return {
               _tag: "Union",
               types,
-              mode: "anyOf",
+              mode: a.mode,
               ...makeAnnotations(a.annotations)
             }
           }

package/src/TxChunk.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 TxChunk values change.
+ * calls `Effect.txRetry` and any of the accessed TxChunk values change.
  *
  * @since 4.0.0
  */
@@ -28,7 +28,7 @@ const TypeId = "~effect/transactions/TxChunk"
  *
  * 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 TxChunk values change.
+ * calls `Effect.txRetry` and any of the accessed TxChunk values change.
  *
  * @example
  * ```ts
@@ -48,7 +48,7 @@ const TypeId = "~effect/transactions/TxChunk"
  *   console.log(Chunk.toReadonlyArray(result)) // [1, 2, 3, 4]
  *
  *   // Multi-step atomic operation - use explicit transaction
- *   yield* Effect.transaction(
+ *   yield* Effect.tx(
  *     Effect.gen(function*() {
  *       yield* TxChunk.prepend(txChunk, 0)
  *       yield* TxChunk.append(txChunk, 5)
@@ -109,7 +109,7 @@ const TxChunkProto = {
  * })
  * ```
  */
-export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
+export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>> =>
   Effect.map(TxRef.make(initial), (ref) => makeUnsafe(ref))
 
 /**
@@ -140,7 +140,7 @@ export const make = <A>(initial: Chunk.Chunk<A>): Effect.Effect<TxChunk<A>, neve
  * })
  * ```
  */
-export const empty = <A = never>(): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
+export const empty = <A = never>(): Effect.Effect<TxChunk<A>> =>
   Effect.map(TxRef.make(Chunk.empty<A>()), (ref) => makeUnsafe(ref))
 
 /**
@@ -164,7 +164,7 @@ export const empty = <A = never>(): Effect.Effect<TxChunk<A>, never, Effect.Tran
  *   console.log(Chunk.toReadonlyArray(chunk)) // [1, 2, 3, 4, 5]
  *
  *   // Multi-step atomic modification - use explicit transaction
- *   yield* Effect.transaction(
+ *   yield* Effect.tx(
  *     Effect.gen(function*() {
  *       yield* TxChunk.append(txChunk, 6)
  *       yield* TxChunk.prepend(txChunk, 0)
@@ -176,7 +176,7 @@ export const empty = <A = never>(): Effect.Effect<TxChunk<A>, never, Effect.Tran
  * })
  * ```
  */
-export const fromIterable = <A>(iterable: Iterable<A>): Effect.Effect<TxChunk<A>, never, Effect.Transaction> =>
+export const fromIterable = <A>(iterable: Iterable<A>): Effect.Effect<TxChunk<A>> =>
   Effect.map(TxRef.make(Chunk.fromIterable(iterable)), (ref) => makeUnsafe(ref))
 
 /**
@@ -263,9 +263,7 @@ export const modify: {
    */
   <A, R>(
     f: (current: Chunk.Chunk<NoInfer<A>>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): (
-    self: TxChunk<A>
-  ) => Effect.Effect<R, never, Effect.Transaction>
+  ): (self: TxChunk<A>) => Effect.Effect<R>
   /**
    * Modifies the value of the `TxChunk` using the provided function.
    *
@@ -297,13 +295,13 @@ export const modify: {
   <A, R>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): Effect.Effect<R, never, Effect.Transaction>
+  ): Effect.Effect<R>
 } = dual(
   2,
   <A, R>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => [returnValue: R, newValue: Chunk.Chunk<A>]
-  ): Effect.Effect<R, never, Effect.Transaction> => TxRef.modify(self.ref, f)
+  ): Effect.Effect<R> => TxRef.modify(self.ref, f)
 )
 
 /**
@@ -357,7 +355,7 @@ export const update: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(f: (current: Chunk.Chunk<NoInfer<A>>) => Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(f: (current: Chunk.Chunk<NoInfer<A>>) => Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Updates the value of the `TxChunk` using the provided function.
    *
@@ -383,13 +381,13 @@ export const update: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
   <A>(
     self: TxChunk<A>,
     f: (current: Chunk.Chunk<A>) => Chunk.Chunk<A>
-  ): Effect.Effect<void, never, Effect.Transaction> => TxRef.update(self.ref, f)
+  ): Effect.Effect<void> => TxRef.update(self.ref, f)
 )
 
 /**
@@ -415,8 +413,7 @@ export const update: {
  * @since 4.0.0
  * @category combinators
  */
-export const get = <A>(self: TxChunk<A>): Effect.Effect<Chunk.Chunk<A>, never, Effect.Transaction> =>
-  TxRef.get(self.ref)
+export const get = <A>(self: TxChunk<A>): Effect.Effect<Chunk.Chunk<A>> => TxRef.get(self.ref)
 
 /**
  * Sets the value of the `TxChunk`.
@@ -469,7 +466,7 @@ export const set: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(chunk: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(chunk: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Sets the value of the `TxChunk`.
    *
@@ -495,11 +492,10 @@ export const set: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
-    TxRef.set(self.ref, chunk)
+  <A>(self: TxChunk<A>, chunk: Chunk.Chunk<A>): Effect.Effect<void> => TxRef.set(self.ref, chunk)
 )
 
 /**
@@ -551,7 +547,7 @@ export const append: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Appends an element to the end of the `TxChunk`.
    *
@@ -576,11 +572,10 @@ export const append: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.append(current, element))
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void> => update(self, (current) => Chunk.append(current, element))
 )
 
 /**
@@ -632,7 +627,7 @@ export const prepend: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(element: A): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Prepends an element to the beginning of the `TxChunk`.
    *
@@ -657,11 +652,10 @@ export const prepend: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, element: A): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.prepend(current, element))
+  <A>(self: TxChunk<A>, element: A): Effect.Effect<void> => update(self, (current) => Chunk.prepend(current, element))
 )
 
 /**
@@ -688,7 +682,7 @@ export const prepend: {
  * @since 4.0.0
  * @category combinators
  */
-export const size = <A>(self: TxChunk<A>): Effect.Effect<number, never, Effect.Transaction> =>
+export const size = <A>(self: TxChunk<A>): Effect.Effect<number> =>
   modify(self, (current) => [Chunk.size(current), current])
 
 /**
@@ -714,7 +708,7 @@ export const size = <A>(self: TxChunk<A>): Effect.Effect<number, never, Effect.T
  * @since 4.0.0
  * @category combinators
  */
-export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean> =>
   modify(self, (current) => [Chunk.isEmpty(current), current])
 
 /**
@@ -740,7 +734,7 @@ export const isEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effe
  * @since 4.0.0
  * @category combinators
  */
-export const isNonEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const isNonEmpty = <A>(self: TxChunk<A>): Effect.Effect<boolean> =>
   modify(self, (current) => [Chunk.isNonEmpty(current), current])
 
 /**
@@ -792,7 +786,7 @@ export const take: {
    * @since 4.0.0
    * @category combinators
    */
-  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Takes the first `n` elements from the `TxChunk`.
    *
@@ -817,11 +811,10 @@ export const take: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.take(current, n))
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.take(current, n))
 )
 
 /**
@@ -873,7 +866,7 @@ export const drop: {
    * @since 4.0.0
    * @category combinators
    */
-  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  (n: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Drops the first `n` elements from the `TxChunk`.
    *
@@ -898,11 +891,10 @@ export const drop: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, n: number): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.drop(current, n))
+  <A>(self: TxChunk<A>, n: number): Effect.Effect<void> => update(self, (current) => Chunk.drop(current, n))
 )
 
 /**
@@ -954,7 +946,7 @@ export const slice: {
    * @since 4.0.0
    * @category combinators
    */
-  (start: number, end: number): <A>(self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  (start: number, end: number): <A>(self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Takes a slice of the `TxChunk` from `start` to `end` (exclusive).
    *
@@ -979,10 +971,10 @@ export const slice: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void>
 } = dual(
   3,
-  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, start: number, end: number): Effect.Effect<void> =>
     update(self, (current) => Chunk.take(Chunk.drop(current, start), end - start))
 )
 
@@ -1039,7 +1031,7 @@ export const map: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(f: (a: NoInfer<A>) => A): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(f: (a: NoInfer<A>) => A): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Maps each element of the `TxChunk` using the provided function.
    * Note: This only works when the mapped type B is assignable to A.
@@ -1066,11 +1058,10 @@ export const map: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void, never, Effect.Transaction> =>
-    update(self, (current) => Chunk.map(current, f))
+  <A>(self: TxChunk<A>, f: (a: A) => A): Effect.Effect<void> => update(self, (current) => Chunk.map(current, f))
 )
 
 /**
@@ -1124,7 +1115,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B extends A>(refinement: (a: A) => a is B): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A, B extends A>(refinement: (a: A) => a is B): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1150,7 +1141,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(predicate: (a: A) => boolean): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(predicate: (a: A) => boolean): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1176,7 +1167,7 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B extends A>(self: TxChunk<A>, refinement: (a: A) => a is B): Effect.Effect<void, never, Effect.Transaction>
+  <A, B extends A>(self: TxChunk<A>, refinement: (a: A) => a is B): Effect.Effect<void>
   /**
    * Filters the `TxChunk` keeping only elements that satisfy the predicate.
    *
@@ -1202,10 +1193,10 @@ export const filter: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, predicate: (a: A) => boolean): Effect.Effect<void> =>
     update(self, (current) => Chunk.filter(current, predicate))
 )
 
@@ -1262,7 +1253,7 @@ export const appendAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Concatenates another chunk to the end of the `TxChunk`.
    *
@@ -1289,10 +1280,10 @@ export const appendAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void> =>
     update(self, (current) => Chunk.appendAll(current, other))
 )
 
@@ -1349,7 +1340,7 @@ export const prependAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(other: Chunk.Chunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Concatenates another chunk to the beginning of the `TxChunk`.
    *
@@ -1376,10 +1367,10 @@ export const prependAll: {
    * @since 4.0.0
    * @category combinators
    */
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, other: Chunk.Chunk<A>): Effect.Effect<void> =>
     update(self, (current) => Chunk.prependAll(current, other))
 )
 
@@ -1440,7 +1431,7 @@ export const concat: {
    * })
    * ```
    */
-  <A>(other: TxChunk<A>): (self: TxChunk<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(other: TxChunk<A>): (self: TxChunk<A>) => Effect.Effect<void>
   /**
    * Concatenates another `TxChunk` to the end of this `TxChunk`.
    *
@@ -1469,12 +1460,12 @@ export const concat: {
    * })
    * ```
    */
-  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxChunk<A>, other: TxChunk<A>): Effect.Effect<void> =>
     Effect.gen(function*() {
       const otherChunk = yield* get(other)
       yield* appendAll(self, otherChunk)
-    })
+    }).pipe(Effect.tx)
 )