effect 4.0.0-beta.16 → 4.0.0-beta.18

package/src/TxHashMap.ts

@@ -53,7 +53,7 @@ const TxHashMapProto = {
  *   console.log(user) // Option.some("Alice")
  *
  *   // Multi-step atomic operations
- *   yield* Effect.atomic(
+ *   yield* Effect.transaction(
  *     Effect.gen(function*() {
  *       const currentUser = yield* TxHashMap.get(txMap, "user1")
  *       if (Option.isSome(currentUser)) {
@@ -236,7 +236,7 @@ export declare namespace TxHashMap {
  * @since 2.0.0
  * @category constructors
  */
-export const empty = <K, V>(): Effect.Effect<TxHashMap<K, V>> =>
+export const empty = <K, V>(): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const ref = yield* TxRef.make(HashMap.empty<K, V>())
     return Object.assign(Object.create(TxHashMapProto), { ref })
@@ -273,7 +273,9 @@ export const empty = <K, V>(): Effect.Effect<TxHashMap<K, V>> =>
  * @since 2.0.0
  * @category constructors
  */
-export const make = <K, V>(...entries: Array<readonly [K, V]>): Effect.Effect<TxHashMap<K, V>> =>
+export const make = <K, V>(
+  ...entries: Array<readonly [K, V]>
+): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const hashMap = HashMap.make(...entries)
     const ref = yield* TxRef.make(hashMap)
@@ -314,7 +316,9 @@ export const make = <K, V>(...entries: Array<readonly [K, V]>): Effect.Effect<Tx
  * @since 2.0.0
  * @category constructors
  */
-export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): Effect.Effect<TxHashMap<K, V>> =>
+export const fromIterable = <K, V>(
+  entries: Iterable<readonly [K, V]>
+): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const hashMap = HashMap.fromIterable(entries)
     const ref = yield* TxRef.make(hashMap)
@@ -384,7 +388,7 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
+  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>, never, Effect.Transaction>
   /**
    * Safely lookup the value for the specified key in the TxHashMap.
    *
@@ -416,10 +420,10 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>, never, Effect.Transaction>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>> =>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<Option.Option<V>, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const map = yield* TxRef.get(self.ref)
       return HashMap.get(map, key)
@@ -495,7 +499,7 @@ export const set: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(key: K, value: V): (self: TxHashMap<K, V>) => Effect.Effect<void>
+  <K, V>(key: K, value: V): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Sets the value for the specified key in the TxHashMap.
    *
@@ -530,10 +534,10 @@ export const set: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void>
+  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   3,
-  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void> =>
+  <K, V>(self: TxHashMap<K, V>, key: K, value: V): Effect.Effect<void, never, Effect.Transaction> =>
     TxRef.update(self.ref, (map) => HashMap.set(map, key, value))
 )
 
@@ -598,7 +602,7 @@ export const has: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
+  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Checks if the specified key exists in the TxHashMap.
    *
@@ -629,10 +633,10 @@ export const has: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean> =>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const map = yield* TxRef.get(self.ref)
       return HashMap.has(map, key)
@@ -714,7 +718,7 @@ export const remove: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
+  <K1 extends K, K>(key: K1): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Removes the specified key from the TxHashMap.
    *
@@ -752,20 +756,18 @@ export const remove: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const existed = HashMap.has(currentMap, key)
-        if (existed) {
-          yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
-        }
-        return existed
-      })
-    )
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1): Effect.Effect<boolean, never, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const existed = HashMap.has(currentMap, key)
+      if (existed) {
+        yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
+      }
+      return existed
+    })
 )
 
 /**
@@ -804,7 +806,8 @@ export const remove: {
  * @since 2.0.0
  * @category combinators
  */
-export const clear = <K, V>(self: TxHashMap<K, V>): Effect.Effect<void> => TxRef.set(self.ref, HashMap.empty<K, V>())
+export const clear = <K, V>(self: TxHashMap<K, V>): Effect.Effect<void, never, Effect.Transaction> =>
+  TxRef.set(self.ref, HashMap.empty<K, V>())
 
 /**
  * Returns the number of entries in the TxHashMap.
@@ -838,7 +841,7 @@ export const clear = <K, V>(self: TxHashMap<K, V>): Effect.Effect<void> => TxRef
  * @since 2.0.0
  * @category combinators
  */
-export const size = <K, V>(self: TxHashMap<K, V>): Effect.Effect<number> =>
+export const size = <K, V>(self: TxHashMap<K, V>): Effect.Effect<number, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.size(map)
@@ -872,7 +875,7 @@ export const size = <K, V>(self: TxHashMap<K, V>): Effect.Effect<number> =>
  * @since 2.0.0
  * @category combinators
  */
-export const isEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean> =>
+export const isEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.isEmpty(map)
@@ -901,7 +904,7 @@ export const isEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean> =>
  * @since 2.0.0
  * @category combinators
  */
-export const isNonEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean> =>
+export const isNonEmpty = <K, V>(self: TxHashMap<K, V>): Effect.Effect<boolean, never, Effect.Transaction> =>
   Effect.map(isEmpty(self), (empty) => !empty)
 
 /**
@@ -991,7 +994,7 @@ export const modify: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(key: K, f: (value: V) => V): (self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
+  <K, V>(key: K, f: (value: V) => V): (self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>, never, Effect.Transaction>
   /**
    * Updates the value for the specified key if it exists.
    *
@@ -1035,22 +1038,24 @@ export const modify: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: V) => V): Effect.Effect<Option.Option<V>>
+  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: V) => V): Effect.Effect<Option.Option<V>, never, Effect.Transaction>
 } = dual(
   3,
-  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: V) => V): Effect.Effect<Option.Option<V>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const currentValue = HashMap.get(currentMap, key)
-        if (Option.isSome(currentValue)) {
-          const newValue = f(currentValue.value)
-          yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue))
-          return currentValue
-        }
-        return Option.none()
-      })
-    )
+  <K, V>(
+    self: TxHashMap<K, V>,
+    key: K,
+    f: (value: V) => V
+  ): Effect.Effect<Option.Option<V>, never, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const currentValue = HashMap.get(currentMap, key)
+      if (Option.isSome(currentValue)) {
+        const newValue = f(currentValue.value)
+        yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue))
+        return currentValue
+      }
+      return Option.none()
+    })
 )
 
 /**
@@ -1140,7 +1145,7 @@ export const modifyAt: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: TxHashMap<K, V>) => Effect.Effect<void>
+  <K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Updates the value for the specified key using an Option-based update function.
    *
@@ -1188,23 +1193,25 @@ export const modifyAt: {
     self: TxHashMap<K, V>,
     key: K,
     f: (value: Option.Option<V>) => Option.Option<V>
-  ): Effect.Effect<void>
+  ): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   3,
-  <K, V>(self: TxHashMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): Effect.Effect<void> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const currentValue = HashMap.get(currentMap, key)
-        const newValue = f(currentValue)
+  <K, V>(
+    self: TxHashMap<K, V>,
+    key: K,
+    f: (value: Option.Option<V>) => Option.Option<V>
+  ): Effect.Effect<void, never, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const currentValue = HashMap.get(currentMap, key)
+      const newValue = f(currentValue)
 
-        if (Option.isSome(newValue)) {
-          yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue.value))
-        } else if (Option.isSome(currentValue)) {
-          yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
-        }
-      })
-    )
+      if (Option.isSome(newValue)) {
+        yield* TxRef.set(self.ref, HashMap.set(currentMap, key, newValue.value))
+      } else if (Option.isSome(currentValue)) {
+        yield* TxRef.set(self.ref, HashMap.remove(currentMap, key))
+      }
+    })
 )
 
 /**
@@ -1237,7 +1244,7 @@ export const modifyAt: {
  * @since 2.0.0
  * @category combinators
  */
-export const keys = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<K>> =>
+export const keys = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<K>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return Array.from(HashMap.keys(map))
@@ -1274,7 +1281,7 @@ export const keys = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<K>> =>
  * @since 2.0.0
  * @category combinators
  */
-export const values = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>> =>
+export const values = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.toValues(map)
@@ -1311,7 +1318,9 @@ export const values = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>> =>
  * @since 2.0.0
  * @category combinators
  */
-export const entries = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<readonly [K, V]>> =>
+export const entries = <K, V>(
+  self: TxHashMap<K, V>
+): Effect.Effect<Array<readonly [K, V]>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const map = yield* TxRef.get(self.ref)
     return HashMap.toEntries(map)
@@ -1351,7 +1360,9 @@ export const entries = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<readon
  * @since 2.0.0
  * @category combinators
  */
-export const snapshot = <K, V>(self: TxHashMap<K, V>): Effect.Effect<HashMap.HashMap<K, V>> => TxRef.get(self.ref)
+export const snapshot = <K, V>(
+  self: TxHashMap<K, V>
+): Effect.Effect<HashMap.HashMap<K, V>, never, Effect.Transaction> => TxRef.get(self.ref)
 
 /**
  * Merges another HashMap into this TxHashMap. If both maps contain the same key,
@@ -1448,7 +1459,7 @@ export const union: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(other: HashMap.HashMap<K1, V1>): (self: TxHashMap<K, V>) => Effect.Effect<void>
+  <K1 extends K, K, V1 extends V, V>(other: HashMap.HashMap<K1, V1>): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Merges another HashMap into this TxHashMap. If both maps contain the same key,
    * the value from the other map will be used.
@@ -1496,11 +1507,13 @@ export const union: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, other: HashMap.HashMap<K1, V1>): Effect.Effect<void>
+  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, other: HashMap.HashMap<K1, V1>): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, other: HashMap.HashMap<K1, V1>): Effect.Effect<void> =>
-    TxRef.update(self.ref, (map) => HashMap.union(map, other))
+  <K1 extends K, K, V1 extends V, V>(
+    self: TxHashMap<K, V>,
+    other: HashMap.HashMap<K1, V1>
+  ): Effect.Effect<void, never, Effect.Transaction> => TxRef.update(self.ref, (map) => HashMap.union(map, other))
 )
 
 /**
@@ -1588,7 +1601,7 @@ export const removeMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(keys: Iterable<K1>): <V>(self: TxHashMap<K, V>) => Effect.Effect<void>
+  <K1 extends K, K>(keys: Iterable<K1>): <V>(self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Removes multiple keys from the TxHashMap.
    *
@@ -1631,10 +1644,10 @@ export const removeMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void> =>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, keys: Iterable<K1>): Effect.Effect<void, never, Effect.Transaction> =>
     TxRef.update(self.ref, (map) => HashMap.removeMany(map, keys))
 )
 
@@ -1753,7 +1766,7 @@ export const setMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(entries: Iterable<readonly [K1, V1]>): (self: TxHashMap<K, V>) => Effect.Effect<void>
+  <K1 extends K, K, V1 extends V, V>(entries: Iterable<readonly [K1, V1]>): (self: TxHashMap<K, V>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Sets multiple key-value pairs in the TxHashMap.
    *
@@ -1811,13 +1824,13 @@ export const setMany: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, entries: Iterable<readonly [K1, V1]>): Effect.Effect<void>
+  <K1 extends K, K, V1 extends V, V>(self: TxHashMap<K, V>, entries: Iterable<readonly [K1, V1]>): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
   <K1 extends K, K, V1 extends V, V>(
     self: TxHashMap<K, V>,
     entries: Iterable<readonly [K1, V1]>
-  ): Effect.Effect<void> => TxRef.update(self.ref, (map) => HashMap.setMany(map, entries))
+  ): Effect.Effect<void, never, Effect.Transaction> => TxRef.update(self.ref, (map) => HashMap.setMany(map, entries))
 )
 
 /**
@@ -1926,7 +1939,7 @@ export const getHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>>
+  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<Option.Option<V>, never, Effect.Transaction>
   /**
    * Lookup the value for the specified key in the TxHashMap using a custom hash.
    * This can provide performance benefits when the hash is precomputed.
@@ -1963,10 +1976,14 @@ export const getHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<Option.Option<V>>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<Option.Option<V>, never, Effect.Transaction>
 } = dual(
   3,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<Option.Option<V>> =>
+  <K1 extends K, K, V>(
+    self: TxHashMap<K, V>,
+    key: K1,
+    hash: number
+  ): Effect.Effect<Option.Option<V>, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.getHash(map, key, hash)))
 )
 
@@ -2061,7 +2078,7 @@ export const hasHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean>
+  <K1 extends K, K>(key: K1, hash: number): <V>(self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Checks if the specified key has an entry in the TxHashMap using a custom hash.
    * This can provide performance benefits when the hash is precomputed.
@@ -2107,10 +2124,14 @@ export const hasHash: {
    * @since 2.0.0
    * @category combinators
    */
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<boolean>
+  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   3,
-  <K1 extends K, K, V>(self: TxHashMap<K, V>, key: K1, hash: number): Effect.Effect<boolean> =>
+  <K1 extends K, K, V>(
+    self: TxHashMap<K, V>,
+    key: K1,
+    hash: number
+  ): Effect.Effect<boolean, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasHash(map, key, hash)))
 )
 
@@ -2205,7 +2226,7 @@ export const map: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(f: (value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
+  <A, V, K>(f: (value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
   /**
    * Transforms all values in the TxHashMap using the provided function, preserving keys.
    *
@@ -2251,17 +2272,18 @@ export const map: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => A): Effect.Effect<TxHashMap<K, A>>
+  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => A): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
 } = dual(
   2,
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => A): Effect.Effect<TxHashMap<K, A>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const mappedMap = HashMap.map(currentMap, f)
-        return yield* fromHashMap(mappedMap)
-      })
-    )
+  <K, V, A>(
+    self: TxHashMap<K, V>,
+    f: (value: V, key: K) => A
+  ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const mappedMap = HashMap.map(currentMap, f)
+      return yield* fromHashMap(mappedMap)
+    })
 )
 
 /**
@@ -2361,7 +2383,7 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, B extends V>(predicate: (value: V, key: K) => value is B): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, B>>
+  <K, V, B extends V>(predicate: (value: V, key: K) => value is B): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, B>, never, Effect.Transaction>
   /**
    * Filters the TxHashMap to keep only entries that satisfy the provided predicate.
    *
@@ -2410,7 +2432,7 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, V>>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction>
   /**
    * Filters the TxHashMap to keep only entries that satisfy the provided predicate.
    *
@@ -2459,7 +2481,7 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, B extends V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => value is B): Effect.Effect<TxHashMap<K, B>>
+  <K, V, B extends V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => value is B): Effect.Effect<TxHashMap<K, B>, never, Effect.Transaction>
   /**
    * Filters the TxHashMap to keep only entries that satisfy the provided predicate.
    *
@@ -2508,17 +2530,18 @@ export const filter: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<TxHashMap<K, V>>
+  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<TxHashMap<K, V>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const filteredMap = HashMap.filter(currentMap, predicate)
-        return yield* fromHashMap(filteredMap)
-      })
-    )
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const filteredMap = HashMap.filter(currentMap, predicate)
+      return yield* fromHashMap(filteredMap)
+    })
 )
 
 /**
@@ -2630,7 +2653,7 @@ export const reduce: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(zero: A, f: (accumulator: A, value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<A>
+  <A, V, K>(zero: A, f: (accumulator: A, value: V, key: K) => A): (self: TxHashMap<K, V>) => Effect.Effect<A, never, Effect.Transaction>
   /**
    * Reduces the TxHashMap entries to a single value by applying a reducer function.
    * Iterates over all key-value pairs and accumulates them into a final result.
@@ -2685,10 +2708,14 @@ export const reduce: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A>(self: TxHashMap<K, V>, zero: A, f: (accumulator: A, value: V, key: K) => A): Effect.Effect<A>
+  <K, V, A>(self: TxHashMap<K, V>, zero: A, f: (accumulator: A, value: V, key: K) => A): Effect.Effect<A, never, Effect.Transaction>
 } = dual(
   3,
-  <K, V, A>(self: TxHashMap<K, V>, zero: A, f: (accumulator: A, value: V, key: K) => A): Effect.Effect<A> =>
+  <K, V, A>(
+    self: TxHashMap<K, V>,
+    zero: A,
+    f: (accumulator: A, value: V, key: K) => A
+  ): Effect.Effect<A, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.reduce(map, zero, f)))
 )
 
@@ -2807,7 +2834,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(f: (value: V, key: K) => Option.Option<A>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
+  <A, V, K>(f: (value: V, key: K) => Option.Option<A>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
   /**
    * Combines filtering and mapping in a single operation. Applies a function that returns
    * an Option to each entry, keeping only the Some values and transforming them.
@@ -2865,17 +2892,18 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => Option.Option<A>): Effect.Effect<TxHashMap<K, A>>
+  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => Option.Option<A>): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
 } = dual(
   2,
-  <K, V, A>(self: TxHashMap<K, V>, f: (value: V, key: K) => Option.Option<A>): Effect.Effect<TxHashMap<K, A>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const filteredMap = HashMap.filterMap(currentMap, f)
-        return yield* fromHashMap(filteredMap)
-      })
-    )
+  <K, V, A>(
+    self: TxHashMap<K, V>,
+    f: (value: V, key: K) => Option.Option<A>
+  ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const filteredMap = HashMap.filterMap(currentMap, f)
+      return yield* fromHashMap(filteredMap)
+    })
 )
 
 /**
@@ -2959,7 +2987,7 @@ export const hasBy: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Checks if any entry in the TxHashMap matches the given predicate.
    *
@@ -3000,10 +3028,13 @@ export const hasBy: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
+  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean> =>
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<boolean, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.hasBy(map, predicate)))
 )
 
@@ -3092,7 +3123,7 @@ export const findFirst: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<[K, V] | undefined>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<[K, V] | undefined, never, Effect.Transaction>
   /**
    * Finds the first entry in the TxHashMap that matches the given predicate.
    * Returns the key-value pair as a tuple wrapped in an Option.
@@ -3135,10 +3166,13 @@ export const findFirst: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<[K, V] | undefined>
+  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<[K, V] | undefined, never, Effect.Transaction>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<[K, V] | undefined> =>
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<[K, V] | undefined, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.findFirst(map, predicate)))
 )
 
@@ -3223,7 +3257,7 @@ export const some: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Checks if at least one entry in the TxHashMap satisfies the given predicate.
    *
@@ -3264,10 +3298,13 @@ export const some: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
+  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean> =>
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<boolean, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.some(map, predicate)))
 )
 
@@ -3352,7 +3389,7 @@ export const every: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean>
+  <K, V>(predicate: (value: V, key: K) => boolean): (self: TxHashMap<K, V>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Checks if all entries in the TxHashMap satisfy the given predicate.
    *
@@ -3393,10 +3430,13 @@ export const every: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean>
+  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   2,
-  <K, V>(self: TxHashMap<K, V>, predicate: (value: V, key: K) => boolean): Effect.Effect<boolean> =>
+  <K, V>(
+    self: TxHashMap<K, V>,
+    predicate: (value: V, key: K) => boolean
+  ): Effect.Effect<boolean, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.every(map, predicate)))
 )
 
@@ -3483,7 +3523,7 @@ export const forEach: {
    * @since 2.0.0
    * @category combinators
    */
-  <V, K, R, E>(f: (value: V, key: K) => Effect.Effect<void, E, R>): (self: TxHashMap<K, V>) => Effect.Effect<void, E, R>
+  <V, K, R, E>(f: (value: V, key: K) => Effect.Effect<void, E, R>): (self: TxHashMap<K, V>) => Effect.Effect<void, E, R | Effect.Transaction>
   /**
    * Executes a side-effect function for each entry in the TxHashMap.
    * The function receives the value and key as parameters and can perform effects.
@@ -3525,10 +3565,13 @@ export const forEach: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, R, E>(self: TxHashMap<K, V>, f: (value: V, key: K) => Effect.Effect<void, E, R>): Effect.Effect<void, E, R>
+  <K, V, R, E>(self: TxHashMap<K, V>, f: (value: V, key: K) => Effect.Effect<void, E, R>): Effect.Effect<void, E, R | Effect.Transaction>
 } = dual(
   2,
-  <K, V, R, E>(self: TxHashMap<K, V>, f: (value: V, key: K) => Effect.Effect<void, E, R>): Effect.Effect<void, E, R> =>
+  <K, V, R, E>(
+    self: TxHashMap<K, V>,
+    f: (value: V, key: K) => Effect.Effect<void, E, R>
+  ): Effect.Effect<void, E, R | Effect.Transaction> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)
       const entries = HashMap.toEntries(currentMap)
@@ -3639,7 +3682,9 @@ export const flatMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <A, V, K>(f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>>
+  <A, V, K>(
+    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  ): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
   /**
    * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
    * then flattening the results. Useful for complex transformations that require creating new maps.
@@ -3693,131 +3738,129 @@ export const flatMap: {
    */
   <K, V, A>(
     self: TxHashMap<K, V>,
-    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>
-  ): Effect.Effect<TxHashMap<K, A>>
+    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
 } = dual(
   2,
   <K, V, A>(
     self: TxHashMap<K, V>,
-    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>>
-  ): Effect.Effect<TxHashMap<K, A>> =>
-    Effect.atomic(
-      Effect.gen(function*() {
-        const currentMap = yield* TxRef.get(self.ref)
-        const result = yield* empty</**
-         * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
-         * then flattening the results. Useful for complex transformations that require creating new maps.
-         *
-         * **Return behavior**: This function returns a new TxHashMap reference with the
-         * flattened results. The original TxHashMap is not modified.
-         *
-         * @example
-         * ```ts
-         * import { Effect, TxHashMap } from "effect"
-         *
-         * const program = Effect.gen(function*() {
-         *   // Create a department-employee map
-         *   const departments = yield* TxHashMap.make(
-         *     ["engineering", ["alice", "bob"]],
-         *     ["marketing", ["charlie", "diana"]]
-         *   )
-         *
-         *   // Expand each department into individual employee entries with metadata
-         *   const employeeDetails = yield* TxHashMap.flatMap(
-         *     departments,
-         *     (employees, department) =>
-         *       Effect.gen(function*() {
-         *         const employeeMap = yield* TxHashMap.empty<
-         *           string,
-         *           { department: string; role: string }
-         *         >()
-         *         for (let i = 0; i < employees.length; i++) {
-         *           const employee = employees[i]
-         *           const role = i === 0 ? "lead" : "member"
-         *           yield* TxHashMap.set(employeeMap, employee, { department, role })
-         *         }
-         *         return employeeMap
-         *       })
-         *   )
-         *
-         *   // Check the flattened result
-         *   const alice = yield* TxHashMap.get(employeeDetails, "alice")
-         *   console.log(alice) // Option.some({ department: "engineering", role: "lead" })
-         *
-         *   const charlie = yield* TxHashMap.get(employeeDetails, "charlie")
-         *   console.log(charlie) // Option.some({ department: "marketing", role: "lead" })
-         *
-         *   const size = yield* TxHashMap.size(employeeDetails)
-         *   console.log(size) // 4 (all employees)
-         * })
-         * ```
-         *
-         * @since 2.0.0
-         * @category combinators
-         */
-        K, /**
-         * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
-         * then flattening the results. Useful for complex transformations that require creating new maps.
-         *
-         * **Return behavior**: This function returns a new TxHashMap reference with the
-         * flattened results. The original TxHashMap is not modified.
-         *
-         * @example
-         * ```ts
-         * import { Effect, TxHashMap } from "effect"
-         *
-         * const program = Effect.gen(function*() {
-         *   // Create a department-employee map
-         *   const departments = yield* TxHashMap.make(
-         *     ["engineering", ["alice", "bob"]],
-         *     ["marketing", ["charlie", "diana"]]
-         *   )
-         *
-         *   // Expand each department into individual employee entries with metadata
-         *   const employeeDetails = yield* TxHashMap.flatMap(
-         *     departments,
-         *     (employees, department) =>
-         *       Effect.gen(function*() {
-         *         const employeeMap = yield* TxHashMap.empty<
-         *           string,
-         *           { department: string; role: string }
-         *         >()
-         *         for (let i = 0; i < employees.length; i++) {
-         *           const employee = employees[i]
-         *           const role = i === 0 ? "lead" : "member"
-         *           yield* TxHashMap.set(employeeMap, employee, { department, role })
-         *         }
-         *         return employeeMap
-         *       })
-         *   )
-         *
-         *   // Check the flattened result
-         *   const alice = yield* TxHashMap.get(employeeDetails, "alice")
-         *   console.log(alice) // Option.some({ department: "engineering", role: "lead" })
-         *
-         *   const charlie = yield* TxHashMap.get(employeeDetails, "charlie")
-         *   console.log(charlie) // Option.some({ department: "marketing", role: "lead" })
-         *
-         *   const size = yield* TxHashMap.size(employeeDetails)
-         *   console.log(size) // 4 (all employees)
-         * })
-         * ```
-         *
-         * @since 2.0.0
-         * @category combinators
-         */
-        A>()
+    f: (value: V, key: K) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
+    Effect.gen(function*() {
+      const currentMap = yield* TxRef.get(self.ref)
+      const result = yield* empty</**
+       * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
+       * then flattening the results. Useful for complex transformations that require creating new maps.
+       *
+       * **Return behavior**: This function returns a new TxHashMap reference with the
+       * flattened results. The original TxHashMap is not modified.
+       *
+       * @example
+       * ```ts
+       * import { Effect, TxHashMap } from "effect"
+       *
+       * const program = Effect.gen(function*() {
+       *   // Create a department-employee map
+       *   const departments = yield* TxHashMap.make(
+       *     ["engineering", ["alice", "bob"]],
+       *     ["marketing", ["charlie", "diana"]]
+       *   )
+       *
+       *   // Expand each department into individual employee entries with metadata
+       *   const employeeDetails = yield* TxHashMap.flatMap(
+       *     departments,
+       *     (employees, department) =>
+       *       Effect.gen(function*() {
+       *         const employeeMap = yield* TxHashMap.empty<
+       *           string,
+       *           { department: string; role: string }
+       *         >()
+       *         for (let i = 0; i < employees.length; i++) {
+       *           const employee = employees[i]
+       *           const role = i === 0 ? "lead" : "member"
+       *           yield* TxHashMap.set(employeeMap, employee, { department, role })
+       *         }
+       *         return employeeMap
+       *       })
+       *   )
+       *
+       *   // Check the flattened result
+       *   const alice = yield* TxHashMap.get(employeeDetails, "alice")
+       *   console.log(alice) // Option.some({ department: "engineering", role: "lead" })
+       *
+       *   const charlie = yield* TxHashMap.get(employeeDetails, "charlie")
+       *   console.log(charlie) // Option.some({ department: "marketing", role: "lead" })
+       *
+       *   const size = yield* TxHashMap.size(employeeDetails)
+       *   console.log(size) // 4 (all employees)
+       * })
+       * ```
+       *
+       * @since 2.0.0
+       * @category combinators
+       */
+      K, /**
+       * Transforms the TxHashMap by applying a function that returns a TxHashMap to each entry,
+       * then flattening the results. Useful for complex transformations that require creating new maps.
+       *
+       * **Return behavior**: This function returns a new TxHashMap reference with the
+       * flattened results. The original TxHashMap is not modified.
+       *
+       * @example
+       * ```ts
+       * import { Effect, TxHashMap } from "effect"
+       *
+       * const program = Effect.gen(function*() {
+       *   // Create a department-employee map
+       *   const departments = yield* TxHashMap.make(
+       *     ["engineering", ["alice", "bob"]],
+       *     ["marketing", ["charlie", "diana"]]
+       *   )
+       *
+       *   // Expand each department into individual employee entries with metadata
+       *   const employeeDetails = yield* TxHashMap.flatMap(
+       *     departments,
+       *     (employees, department) =>
+       *       Effect.gen(function*() {
+       *         const employeeMap = yield* TxHashMap.empty<
+       *           string,
+       *           { department: string; role: string }
+       *         >()
+       *         for (let i = 0; i < employees.length; i++) {
+       *           const employee = employees[i]
+       *           const role = i === 0 ? "lead" : "member"
+       *           yield* TxHashMap.set(employeeMap, employee, { department, role })
+       *         }
+       *         return employeeMap
+       *       })
+       *   )
+       *
+       *   // Check the flattened result
+       *   const alice = yield* TxHashMap.get(employeeDetails, "alice")
+       *   console.log(alice) // Option.some({ department: "engineering", role: "lead" })
+       *
+       *   const charlie = yield* TxHashMap.get(employeeDetails, "charlie")
+       *   console.log(charlie) // Option.some({ department: "marketing", role: "lead" })
+       *
+       *   const size = yield* TxHashMap.size(employeeDetails)
+       *   console.log(size) // 4 (all employees)
+       * })
+       * ```
+       *
+       * @since 2.0.0
+       * @category combinators
+       */
+      A>()
 
-        const mapEntries = HashMap.toEntries(currentMap)
-        for (const [key, value] of mapEntries) {
-          const newMap = yield* f(value, key)
-          const newEntries = yield* entries(newMap)
-          yield* setMany(result, newEntries)
-        }
+      const mapEntries = HashMap.toEntries(currentMap)
+      for (const [key, value] of mapEntries) {
+        const newMap = yield* f(value, key)
+        const newEntries = yield* entries(newMap)
+        yield* setMany(result, newEntries)
+      }
 
-        return result
-      })
-    )
+      return result
+    })
 )
 
 /**
@@ -3865,14 +3908,14 @@ export const flatMap: {
  * @since 2.0.0
  * @category combinators
  */
-export const compact = <K, A>(self: TxHashMap<K, Option.Option<A>>): Effect.Effect<TxHashMap<K, A>> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const currentMap = yield* TxRef.get(self.ref)
-      const compactedMap = HashMap.compact(currentMap)
-      return yield* fromHashMap(compactedMap)
-    })
-  )
+export const compact = <K, A>(
+  self: TxHashMap<K, Option.Option<A>>
+): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
+  Effect.gen(function*() {
+    const currentMap = yield* TxRef.get(self.ref)
+    const compactedMap = HashMap.compact(currentMap)
+    return yield* fromHashMap(compactedMap)
+  })
 
 /**
  * Returns an array of all key-value pairs in the TxHashMap.
@@ -3908,7 +3951,9 @@ export const compact = <K, A>(self: TxHashMap<K, Option.Option<A>>): Effect.Effe
  * @since 2.0.0
  * @category combinators
  */
-export const toEntries = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<readonly [K, V]>> => entries(self)
+export const toEntries = <K, V>(
+  self: TxHashMap<K, V>
+): Effect.Effect<Array<readonly [K, V]>, never, Effect.Transaction> => entries(self)
 
 /**
  * Returns an array of all values in the TxHashMap.
@@ -3946,12 +3991,13 @@ export const toEntries = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<read
  * @since 2.0.0
  * @category combinators
  */
-export const toValues = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>> => values(self)
+export const toValues = <K, V>(self: TxHashMap<K, V>): Effect.Effect<Array<V>, never, Effect.Transaction> =>
+  values(self)
 
 /**
  * Helper function to create a TxHashMap from an existing HashMap
  */
-const fromHashMap = <K, V>(hashMap: HashMap.HashMap<K, V>): Effect.Effect<TxHashMap<K, V>> =>
+const fromHashMap = <K, V>(hashMap: HashMap.HashMap<K, V>): Effect.Effect<TxHashMap<K, V>, never, Effect.Transaction> =>
   Effect.gen(function*() {
     const ref = yield* TxRef.make(hashMap)
     return Object.assign(Object.create(TxHashMapProto), { ref })