effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/TxHashMap.ts

@@ -11,6 +11,8 @@ import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
+import type { Result } from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
 const TypeId = "~effect/transactions/TxHashMap"
@@ -41,7 +43,7 @@ const TxHashMapProto = {
  *
  * @example
  * ```ts
- * import { Effect, Option, TxHashMap } from "effect"
+ * import { Effect, TxHashMap } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a transactional hash map
@@ -53,10 +55,10 @@ 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)) {
+ *       if (currentUser._tag === "Some") {
  *         yield* TxHashMap.set(txMap, "user1", currentUser.value + "_updated")
  *         yield* TxHashMap.remove(txMap, "user2")
  *       }
@@ -236,7 +238,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 +275,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 +318,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)
@@ -343,7 +349,7 @@ export const fromIterable = <K, V>(entries: Iterable<readonly [K, V]>): Effect.E
  *
  *   // Use with pipe syntax for type-safe access
  *   const bobRole = yield* TxHashMap.get(userMap, "bob")
- *   if (Option.isSome(bobRole)) {
+ *   if (bobRole._tag === "Some") {
  *     console.log(bobRole.value.role) // "user"
  *   }
  * })
@@ -375,7 +381,7 @@ export const get: {
    *
    *   // Use with pipe syntax for type-safe access
    *   const bobRole = yield* TxHashMap.get(userMap, "bob")
-   *   if (Option.isSome(bobRole)) {
+   *   if (bobRole._tag === "Some") {
    *     console.log(bobRole.value.role) // "user"
    *   }
    * })
@@ -384,7 +390,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.
    *
@@ -407,7 +413,7 @@ export const get: {
    *
    *   // Use with pipe syntax for type-safe access
    *   const bobRole = yield* TxHashMap.get(userMap, "bob")
-   *   if (Option.isSome(bobRole)) {
+   *   if (bobRole._tag === "Some") {
    *     console.log(bobRole.value.role) // "user"
    *   }
    * })
@@ -416,10 +422,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 +501,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 +536,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 +604,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 +635,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 +720,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 +758,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 +808,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 +843,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 +877,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 +906,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 +996,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 +1040,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()
+    })
 )
 
 /**
@@ -1062,7 +1069,7 @@ export const modify: {
  *
  * @example
  * ```ts
- * import { Effect, Option, TxHashMap } from "effect"
+ * import { Effect, TxHashMap } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const storage = yield* TxHashMap.make<string, string | number>([
@@ -1070,26 +1077,32 @@ export const modify: {
  *     "content1"
  *   ], ["access_count", 0])
  *
- *   // Increment counter or initialize to 1
- *   const updateFn = (opt: Option.Option<string | number>) =>
- *     Option.isSome(opt) && typeof opt.value === "number"
- *       ? Option.some(opt.value + 1)
- *       : Option.some(1)
- *
  *   // Increment existing counter
- *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+ *   yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
+ *     current._tag === "Some" && typeof current.value === "number"
+ *       ? { ...current, value: current.value + 1 }
+ *       : current
+ *   )
  *   const count1 = yield* TxHashMap.get(storage, "access_count")
  *   console.log(count1) // Option.some(1)
  *
  *   // Increment existing counter again
- *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+ *   yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
+ *     current._tag === "Some" && typeof current.value === "number"
+ *       ? { ...current, value: current.value + 1 }
+ *       : current
+ *   )
  *   const count2 = yield* TxHashMap.get(storage, "access_count")
  *   console.log(count2) // Option.some(2)
  *
- *   // Remove by returning None
- *   yield* TxHashMap.modifyAt(storage, "file1.txt", () => Option.none())
- *   const hasFile = yield* TxHashMap.has(storage, "file1.txt")
- *   console.log(hasFile) // false
+ *   // Update an existing string entry
+ *   yield* TxHashMap.modifyAt(storage, "file1.txt", (current) =>
+ *     current._tag === "Some" && typeof current.value === "string"
+ *       ? { ...current, value: `${current.value}.bak` }
+ *       : current
+ *   )
+ *   const backup = yield* TxHashMap.get(storage, "file1.txt")
+ *   console.log(backup) // Option.some("content1.bak")
  * })
  * ```
  *
@@ -1106,7 +1119,7 @@ export const modifyAt: {
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   const storage = yield* TxHashMap.make<string, string | number>([
@@ -1114,33 +1127,39 @@ export const modifyAt: {
    *     "content1"
    *   ], ["access_count", 0])
    *
-   *   // Increment counter or initialize to 1
-   *   const updateFn = (opt: Option.Option<string | number>) =>
-   *     Option.isSome(opt) && typeof opt.value === "number"
-   *       ? Option.some(opt.value + 1)
-   *       : Option.some(1)
-   *
    *   // Increment existing counter
-   *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+   *   yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
+   *     current._tag === "Some" && typeof current.value === "number"
+   *       ? { ...current, value: current.value + 1 }
+   *       : current
+   *   )
    *   const count1 = yield* TxHashMap.get(storage, "access_count")
    *   console.log(count1) // Option.some(1)
    *
    *   // Increment existing counter again
-   *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+   *   yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
+   *     current._tag === "Some" && typeof current.value === "number"
+   *       ? { ...current, value: current.value + 1 }
+   *       : current
+   *   )
    *   const count2 = yield* TxHashMap.get(storage, "access_count")
    *   console.log(count2) // Option.some(2)
    *
-   *   // Remove by returning None
-   *   yield* TxHashMap.modifyAt(storage, "file1.txt", () => Option.none())
-   *   const hasFile = yield* TxHashMap.has(storage, "file1.txt")
-   *   console.log(hasFile) // false
+   *   // Update an existing string entry
+   *   yield* TxHashMap.modifyAt(storage, "file1.txt", (current) =>
+   *     current._tag === "Some" && typeof current.value === "string"
+   *       ? { ...current, value: `${current.value}.bak` }
+   *       : current
+   *   )
+   *   const backup = yield* TxHashMap.get(storage, "file1.txt")
+   *   console.log(backup) // Option.some("content1.bak")
    * })
    * ```
    *
    * @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.
    *
@@ -1150,7 +1169,7 @@ export const modifyAt: {
    *
    * @example
    * ```ts
-   * import { Effect, Option, TxHashMap } from "effect"
+   * import { Effect, TxHashMap } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   const storage = yield* TxHashMap.make<string, string | number>([
@@ -1158,26 +1177,32 @@ export const modifyAt: {
    *     "content1"
    *   ], ["access_count", 0])
    *
-   *   // Increment counter or initialize to 1
-   *   const updateFn = (opt: Option.Option<string | number>) =>
-   *     Option.isSome(opt) && typeof opt.value === "number"
-   *       ? Option.some(opt.value + 1)
-   *       : Option.some(1)
-   *
    *   // Increment existing counter
-   *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+   *   yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
+   *     current._tag === "Some" && typeof current.value === "number"
+   *       ? { ...current, value: current.value + 1 }
+   *       : current
+   *   )
    *   const count1 = yield* TxHashMap.get(storage, "access_count")
    *   console.log(count1) // Option.some(1)
    *
    *   // Increment existing counter again
-   *   yield* TxHashMap.modifyAt(storage, "access_count", updateFn)
+   *   yield* TxHashMap.modifyAt(storage, "access_count", (current) =>
+   *     current._tag === "Some" && typeof current.value === "number"
+   *       ? { ...current, value: current.value + 1 }
+   *       : current
+   *   )
    *   const count2 = yield* TxHashMap.get(storage, "access_count")
    *   console.log(count2) // Option.some(2)
    *
-   *   // Remove by returning None
-   *   yield* TxHashMap.modifyAt(storage, "file1.txt", () => Option.none())
-   *   const hasFile = yield* TxHashMap.has(storage, "file1.txt")
-   *   console.log(hasFile) // false
+   *   // Update an existing string entry
+   *   yield* TxHashMap.modifyAt(storage, "file1.txt", (current) =>
+   *     current._tag === "Some" && typeof current.value === "string"
+   *       ? { ...current, value: `${current.value}.bak` }
+   *       : current
+   *   )
+   *   const backup = yield* TxHashMap.get(storage, "file1.txt")
+   *   console.log(backup) // Option.some("content1.bak")
    * })
    * ```
    *
@@ -1188,23 +1213,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))
+      }
+    })
 )
 
 /**
@@ -1227,7 +1254,7 @@ export const modifyAt: {
  *   // Useful for iteration
  *   for (const username of usernames) {
  *     const role = yield* TxHashMap.get(userRoles, username)
- *     if (Option.isSome(role)) {
+ *     if (role._tag === "Some") {
  *       console.log(`${username}: ${role.value}`)
  *     }
  *   }
@@ -1237,7 +1264,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 +1301,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 +1338,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 +1380,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 +1479,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 +1527,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 +1621,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 +1664,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 +1786,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 +1844,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))
 )
 
 /**
@@ -1850,7 +1883,7 @@ export const setMany: {
  * @category guards
  */
 export const isTxHashMap = <K, V>(value: unknown): value is TxHashMap<K, V> => {
-  return typeof value === "object" && value !== null && TypeId in value
+  return hasProperty(value, TypeId)
 }
 
 /**
@@ -1926,7 +1959,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 +1996,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 +2098,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 +2144,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 +2246,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 +2292,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 +2403,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 +2452,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 +2501,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 +2550,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 +2673,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 +2728,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 +2763,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 +2784,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 +2798,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 +2821,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 +2842,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 +2854,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: (input: V, key: K) => Result<A, X>): (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 +2879,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 +2900,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 +2912,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: (input: V, key: K) => Result<A, X>): 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: (input: V, key: K) => Result<A, X>
+  ): 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 +3007,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 +3048,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)))
 )
 
@@ -3029,8 +3080,8 @@ export const hasBy: {
  *     (task) => task.priority >= 2 && !task.completed
  *   )
  *
- *   if (highPriorityTask) {
- *     const [taskId, task] = highPriorityTask
+ *   if (highPriorityTask._tag === "Some") {
+ *     const [taskId, task] = highPriorityTask.value
  *     console.log(`Found task: ${taskId}, priority: ${task.priority}`)
  *     // "Found task: task3, priority: 2"
  *   }
@@ -3040,8 +3091,8 @@ export const hasBy: {
  *     TxHashMap.findFirst((task) => task.assignee === "alice")
  *   )
  *
- *   if (aliceTask) {
- *     console.log(`Alice's task: ${aliceTask[0]}`)
+ *   if (aliceTask._tag === "Some") {
+ *     console.log(`Alice's task: ${aliceTask.value[0]}`)
  *   }
  * })
  * ```
@@ -3072,8 +3123,8 @@ export const findFirst: {
    *     (task) => task.priority >= 2 && !task.completed
    *   )
    *
-   *   if (highPriorityTask) {
-   *     const [taskId, task] = highPriorityTask
+   *   if (highPriorityTask._tag === "Some") {
+   *     const [taskId, task] = highPriorityTask.value
    *     console.log(`Found task: ${taskId}, priority: ${task.priority}`)
    *     // "Found task: task3, priority: 2"
    *   }
@@ -3083,8 +3134,8 @@ export const findFirst: {
    *     TxHashMap.findFirst((task) => task.assignee === "alice")
    *   )
    *
-   *   if (aliceTask) {
-   *     console.log(`Alice's task: ${aliceTask[0]}`)
+   *   if (aliceTask._tag === "Some") {
+   *     console.log(`Alice's task: ${aliceTask.value[0]}`)
    *   }
    * })
    * ```
@@ -3092,7 +3143,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<Option.Option<[K, V]>, 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.
@@ -3115,8 +3166,8 @@ export const findFirst: {
    *     (task) => task.priority >= 2 && !task.completed
    *   )
    *
-   *   if (highPriorityTask) {
-   *     const [taskId, task] = highPriorityTask
+   *   if (highPriorityTask._tag === "Some") {
+   *     const [taskId, task] = highPriorityTask.value
    *     console.log(`Found task: ${taskId}, priority: ${task.priority}`)
    *     // "Found task: task3, priority: 2"
    *   }
@@ -3126,8 +3177,8 @@ export const findFirst: {
    *     TxHashMap.findFirst((task) => task.assignee === "alice")
    *   )
    *
-   *   if (aliceTask) {
-   *     console.log(`Alice's task: ${aliceTask[0]}`)
+   *   if (aliceTask._tag === "Some") {
+   *     console.log(`Alice's task: ${aliceTask.value[0]}`)
    *   }
    * })
    * ```
@@ -3135,10 +3186,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<Option.Option<[K, V]>, 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<Option.Option<[K, V]>, never, Effect.Transaction> =>
     TxRef.get(self.ref).pipe(Effect.map((map) => HashMap.findFirst(map, predicate)))
 )
 
@@ -3223,7 +3277,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 +3318,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 +3409,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 +3450,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 +3543,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 +3585,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 +3702,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 +3758,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 +3928,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 +3971,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 +4011,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 })