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

package/src/TxHashMap.ts

@@ -3,6 +3,7 @@
  */
 
 import * as Effect from "./Effect.ts"
+import type * as Filter from "./Filter.ts"
 import { format } from "./Formatter.ts"
 import { dual } from "./Function.ts"
 import * as HashMap from "./HashMap.ts"
@@ -53,7 +54,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 +237,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 +274,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 +317,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 +389,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 +421,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 +500,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 +535,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 +603,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 +634,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 +719,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 +757,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 +807,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 +842,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 +876,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 +905,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 +995,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 +1039,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 +1146,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 +1194,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 +1245,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 +1282,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 +1319,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 +1361,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 +1460,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 +1508,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 +1602,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 +1645,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 +1767,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 +1825,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 +1940,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 +1977,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 +2079,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 +2125,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 +2227,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 +2273,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 +2384,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 +2433,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 +2482,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 +2531,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 +2654,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,23 +2709,27 @@ 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)))
 )
 
 /**
- * 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.
+ * Combines filtering and mapping in a single operation. Applies a filter to each
+ * entry, keeping only successful results and transforming them.
  *
  * **Return behavior**: This function returns a new TxHashMap reference containing
- * only the transformed entries that returned Some values. The original TxHashMap is not modified.
+ * only the transformed entries that succeeded. The original TxHashMap is not modified.
  *
  * @example
  * ```ts
- * import { Effect, Option, TxHashMap } from "effect"
+ * import { Effect, Option, Result, TxHashMap } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a mixed data map
@@ -2716,10 +2744,10 @@ export const reduce: {
  *   const activeAdminAges = yield* TxHashMap.filterMap(
  *     userData,
  *     (user, username) => {
- *       if (!user.active || user.role !== "admin") return Option.none()
+ *       if (!user.active || user.role !== "admin") return Result.failVoid
  *       const age = parseInt(user.age)
- *       if (isNaN(age)) return Option.none()
- *       return Option.some({
+ *       if (isNaN(age)) return Result.failVoid
+ *       return Result.succeed({
  *         username,
  *         age,
  *         seniority: age > 27 ? "senior" : "junior"
@@ -2737,7 +2765,7 @@ export const reduce: {
  *   const validAges = yield* userData.pipe(
  *     TxHashMap.filterMap((user) => {
  *       const age = parseInt(user.age)
- *       return isNaN(age) ? Option.none() : Option.some(age)
+ *       return isNaN(age) ? Result.failVoid : Result.succeed(age)
  *     })
  *   )
  *
@@ -2751,15 +2779,15 @@ export const reduce: {
  */
 export const filterMap: {
   /**
-   * 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.
+   * Combines filtering and mapping in a single operation. Applies a filter to each
+   * entry, keeping only successful results and transforming them.
    *
    * **Return behavior**: This function returns a new TxHashMap reference containing
-   * only the transformed entries that returned Some values. The original TxHashMap is not modified.
+   * only the transformed entries that succeeded. The original TxHashMap is not modified.
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, Option, Result, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   // Create a mixed data map
@@ -2774,10 +2802,10 @@ export const filterMap: {
    *   const activeAdminAges = yield* TxHashMap.filterMap(
    *     userData,
    *     (user, username) => {
-   *       if (!user.active || user.role !== "admin") return Option.none()
+   *       if (!user.active || user.role !== "admin") return Result.failVoid
    *       const age = parseInt(user.age)
-   *       if (isNaN(age)) return Option.none()
-   *       return Option.some({
+   *       if (isNaN(age)) return Result.failVoid
+   *       return Result.succeed({
    *         username,
    *         age,
    *         seniority: age > 27 ? "senior" : "junior"
@@ -2795,7 +2823,7 @@ export const filterMap: {
    *   const validAges = yield* userData.pipe(
    *     TxHashMap.filterMap((user) => {
    *       const age = parseInt(user.age)
-   *       return isNaN(age) ? Option.none() : Option.some(age)
+   *       return isNaN(age) ? Result.failVoid : Result.succeed(age)
    *     })
    *   )
    *
@@ -2807,17 +2835,17 @@ 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>>
+  <V, K, A, X>(f: Filter.Filter<V, A, X, [key: K]>): (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.
+   * Combines filtering and mapping in a single operation. Applies a filter to each
+   * entry, keeping only successful results and transforming them.
    *
    * **Return behavior**: This function returns a new TxHashMap reference containing
-   * only the transformed entries that returned Some values. The original TxHashMap is not modified.
+   * only the transformed entries that succeeded. The original TxHashMap is not modified.
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, Option, Result, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   // Create a mixed data map
@@ -2832,10 +2860,10 @@ export const filterMap: {
    *   const activeAdminAges = yield* TxHashMap.filterMap(
    *     userData,
    *     (user, username) => {
-   *       if (!user.active || user.role !== "admin") return Option.none()
+   *       if (!user.active || user.role !== "admin") return Result.failVoid
    *       const age = parseInt(user.age)
-   *       if (isNaN(age)) return Option.none()
-   *       return Option.some({
+   *       if (isNaN(age)) return Result.failVoid
+   *       return Result.succeed({
    *         username,
    *         age,
    *         seniority: age > 27 ? "senior" : "junior"
@@ -2853,7 +2881,7 @@ export const filterMap: {
    *   const validAges = yield* userData.pipe(
    *     TxHashMap.filterMap((user) => {
    *       const age = parseInt(user.age)
-   *       return isNaN(age) ? Option.none() : Option.some(age)
+   *       return isNaN(age) ? Result.failVoid : Result.succeed(age)
    *     })
    *   )
    *
@@ -2865,17 +2893,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, X>(self: TxHashMap<K, V>, f: Filter.Filter<V, A, X, [key: K]>): 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, X>(
+    self: TxHashMap<K, V>,
+    f: Filter.Filter<V, A, X, [key: K]>
+  ): 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 +2988,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 +3029,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 +3124,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 +3167,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 +3258,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 +3299,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 +3390,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 +3431,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 +3524,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 +3566,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 +3683,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 +3739,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 +3909,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 +3952,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 +3992,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 })