diff --git a/packages/effect/test/Cache.test.ts b/packages/effect/test/Cache.test.ts
index d976cada745..fc18ce733d5 100644
--- a/packages/effect/test/Cache.test.ts
+++ b/packages/effect/test/Cache.test.ts
@@ -1,7 +1,6 @@
 import { describe, it } from "@effect/vitest"
-import { Cache, Effect } from "effect"
+import { Cache, Effect, TestClock } from "effect"
 import { strictEqual } from "effect/test/util"
-import * as TestClock from "effect/TestClock"
 
 describe("Cache", () => {
   it.effect("should not increment cache hits on expired entries", () =>
diff --git a/packages/effect/test/Cause.test.ts b/packages/effect/test/Cause.test.ts
index 6393bc23edf..54782236d7e 100644
--- a/packages/effect/test/Cause.test.ts
+++ b/packages/effect/test/Cause.test.ts
@@ -1,9 +1,20 @@
 import { describe, it } from "@effect/vitest"
-import { Array as Arr, Cause, Effect, Equal, FastCheck as fc, FiberId, Hash, Option, Predicate } from "effect"
-import { NodeInspectSymbol } from "effect/Inspectable"
+import {
+  Array as Arr,
+  Cause,
+  Effect,
+  Equal,
+  FastCheck as fc,
+  FiberId,
+  Hash,
+  Inspectable,
+  Option,
+  Predicate
+} from "effect"
 import * as internal from "effect/internal/cause"
 import {
   assertFalse,
+  assertIncludes,
   assertLeft,
   assertNone,
   assertRight,
@@ -26,13 +37,13 @@ describe("Cause", () => {
     it("correctly implements toString() and the NodeInspectSymbol", () => {
       // Referenced line to be included in the string output
       const ex = new Cause.InterruptedException("my message")
-      assertTrue(ex.toString().includes("InterruptedException: my message"))
+      assertIncludes(ex.toString(), "InterruptedException: my message")
 
       // In Node.js environments, ensure the 'inspect' method includes line information
       if (typeof window === "undefined") {
         // eslint-disable-next-line @typescript-eslint/no-var-requires
         const { inspect } = require("node:util")
-        assertTrue(inspect(ex).includes("Cause.test.ts:28")) // <= reference to the line above
+        assertIncludes(inspect(ex), "Cause.test.ts:39") // <= reference to the line above
       }
     })
   })
@@ -98,7 +109,7 @@ describe("Cause", () => {
     describe("toJSON / [NodeInspectSymbol]", () => {
       const expectJSON = (cause: Cause.Cause<unknown>, expected: unknown) => {
         deepStrictEqual(cause.toJSON(), expected)
-        deepStrictEqual(cause[NodeInspectSymbol](), expected)
+        deepStrictEqual(cause[Inspectable.NodeInspectSymbol](), expected)
       }
 
       it("Empty", () => {
@@ -213,12 +224,12 @@ describe("Cause", () => {
 
       it("Fail", () => {
         strictEqual(String(Cause.fail("my failure")), `Error: my failure`)
-        assertTrue(String(Cause.fail(new Error("my failure"))).includes(`Error: my failure`))
+        assertIncludes(String(Cause.fail(new Error("my failure"))), "Error: my failure")
       })
 
       it("Die", () => {
         strictEqual(String(Cause.die("die message")), `Error: die message`)
-        assertTrue(String(Cause.die(new Error("die message"))).includes(`Error: die message`))
+        assertIncludes(String(Cause.die(new Error("die message"))), "Error: die message")
       })
 
       it("Interrupt", () => {
@@ -236,8 +247,8 @@ describe("Cause", () => {
           `Error: failure 1\nError: failure 2`
         )
         const actual = String(Cause.sequential(Cause.fail(new Error("failure 1")), Cause.fail(new Error("failure 2"))))
-        assertTrue(actual.includes("Error: failure 1"))
-        assertTrue(actual.includes("Error: failure 2"))
+        assertIncludes(actual, "Error: failure 1")
+        assertIncludes(actual, "Error: failure 2")
       })
 
       it("Parallel", () => {
@@ -248,8 +259,8 @@ describe("Cause", () => {
         const actual = String(
           String(Cause.parallel(Cause.fail(new Error("failure 1")), Cause.fail(new Error("failure 2"))))
         )
-        assertTrue(actual.includes("Error: failure 1"))
-        assertTrue(actual.includes("Error: failure 2"))
+        assertIncludes(actual, "Error: failure 1")
+        assertIncludes(actual, "Error: failure 2")
       })
     })
 
diff --git a/packages/effect/test/Chunk.test.ts b/packages/effect/test/Chunk.test.ts
index 4bfb55a1a1c..01631b4c8b5 100644
--- a/packages/effect/test/Chunk.test.ts
+++ b/packages/effect/test/Chunk.test.ts
@@ -1,12 +1,12 @@
 import { describe, it } from "@effect/vitest"
 import {
-  Array as RA,
+  Array as Arr,
   Chunk,
   Either,
   Equal,
   FastCheck as fc,
   identity,
-  Number as N,
+  Number as Num,
   Option,
   Order,
   pipe,
@@ -181,7 +181,7 @@ describe("Chunk", () => {
 
       it("gives back a readonly array", () => {
         doesNotThrow(() => Chunk.toReadonlyArray(chunk))
-        deepStrictEqual(Chunk.toReadonlyArray(chunk), RA.reverse(RA.range(0, len - 1)))
+        deepStrictEqual(Chunk.toReadonlyArray(chunk), Arr.reverse(Arr.range(0, len - 1)))
       })
     })
 
@@ -855,7 +855,7 @@ describe("Chunk", () => {
   })
 
   it("getEquivalence", () => {
-    const equivalence = Chunk.getEquivalence(N.Equivalence)
+    const equivalence = Chunk.getEquivalence(Num.Equivalence)
     assertTrue(equivalence(Chunk.empty(), Chunk.empty()))
     assertTrue(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2, 3)))
     assertFalse(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2)))
diff --git a/packages/effect/test/Effect/cause-rendering.test.ts b/packages/effect/test/Effect/cause-rendering.test.ts
index 07c2f08505a..85ac42ed9e1 100644
--- a/packages/effect/test/Effect/cause-rendering.test.ts
+++ b/packages/effect/test/Effect/cause-rendering.test.ts
@@ -37,8 +37,8 @@ describe("Effect", () => {
       ).pipe(Effect.catchTag("E2", (e) => Effect.die(e)))
       const cause = yield* (Effect.flip(Effect.sandbox(effect)))
       const rendered = Cause.pretty(cause)
-      assertTrue(rendered.includes("spanA"))
-      assertTrue(rendered.includes("spanB"))
+      assertIncludes(rendered, "spanA")
+      assertIncludes(rendered, "spanB")
       const obj = Option.getOrThrow(Cause.failureOption(cause))
       assertTrue(obj instanceof E1)
       assertFalse(err === obj)
@@ -62,8 +62,8 @@ describe("Effect", () => {
       ).pipe(Effect.catchAll((e) => Effect.fail(e)))
       const cause = yield* (Effect.flip(Effect.sandbox(effect)))
       const rendered = Cause.pretty(cause)
-      assertTrue(rendered.includes("spanA"))
-      assertTrue(rendered.includes("spanB"))
+      assertIncludes(rendered, "spanA")
+      assertIncludes(rendered, "spanB")
     }))
   it.effect("catchTags should not invalidate traces", () =>
     Effect.gen(function*() {
@@ -83,8 +83,8 @@ describe("Effect", () => {
       ).pipe(Effect.catchTags({ E2: (e) => Effect.die(e) }))
       const cause = yield* (Effect.flip(Effect.sandbox(effect)))
       const rendered = Cause.pretty(cause)
-      assertTrue(rendered.includes("spanA"))
-      assertTrue(rendered.includes("spanB"))
+      assertIncludes(rendered, "spanA")
+      assertIncludes(rendered, "spanB")
     }))
   it.effect("shows line where error was created", () =>
     Effect.gen(function*() {
@@ -96,7 +96,7 @@ describe("Effect", () => {
         Effect.flip
       )
       const pretty = Cause.pretty(cause)
-      assertTrue(pretty.includes("cause-rendering.test.ts"))
+      assertIncludes(pretty, "cause-rendering.test.ts")
     }))
 
   it.effect("functionWithSpan PrettyError stack", () =>
@@ -129,7 +129,7 @@ describe("Effect", () => {
         Effect.flip
       )
       const prettyErrors = Cause.prettyErrors(cause)
-      assertTrue(prettyErrors[0].stack?.includes("at fn-0 "))
+      assertIncludes(prettyErrors[0].stack, "at fn-0 ")
     }))
 
   // ENABLE TO TEST EXPECT OUTPUT
@@ -159,7 +159,7 @@ message
         Effect.flip
       )
       const pretty = Cause.pretty(cause, { renderErrorCause: true })
-      assertTrue(pretty.includes("[cause]: Error: child"))
+      assertIncludes(pretty, "[cause]: Error: child")
     }))
 
   it.effect("pretty nested cause", () =>
@@ -171,7 +171,7 @@ message
         Effect.flip
       )
       const pretty = Cause.pretty(cause, { renderErrorCause: true })
-      assertTrue(pretty.includes("[cause]: Error: child"))
-      assertTrue(pretty.includes("[cause]: Error: child2"))
+      assertIncludes(pretty, "[cause]: Error: child")
+      assertIncludes(pretty, "[cause]: Error: child2")
     }))
 })
diff --git a/packages/effect/test/Effect/error.test.ts b/packages/effect/test/Effect/error.test.ts
index d384cf4c0a6..1de56a8d528 100644
--- a/packages/effect/test/Effect/error.test.ts
+++ b/packages/effect/test/Effect/error.test.ts
@@ -9,11 +9,11 @@ describe("Effect", () => {
     Effect.gen(function*() {
       const cause = yield* (Effect.flip(Effect.sandbox(Effect.withSpan("A")(new TestError()))))
       const log = Cause.pretty(cause)
-      assertTrue(log.includes("TestError"))
+      assertIncludes(log, "TestError")
       if (typeof window === "undefined") {
         assertIncludes(log.replaceAll("\\", "/"), "test/Effect/error.test.ts:10:77")
       }
-      assertTrue(log.includes("at A"))
+      assertIncludes(log, "at A")
     }))
 
   it.effect("tryPromise", () =>
@@ -86,7 +86,7 @@ describe("Effect", () => {
       class MessageError extends Data.TaggedError("MessageError")<{
         cause: unknown
       }> {}
-      assertTrue(inspect(new MessageError({ cause: new Error("boom") })).includes("[cause]: Error: boom"))
+      assertIncludes(inspect(new MessageError({ cause: new Error("boom") })), "[cause]: Error: boom")
     })
   }
 
diff --git a/packages/effect/test/Fiber.test.ts b/packages/effect/test/Fiber.test.ts
index 9ec4ad18281..6676997d853 100644
--- a/packages/effect/test/Fiber.test.ts
+++ b/packages/effect/test/Fiber.test.ts
@@ -1,17 +1,20 @@
 import { describe, it } from "@effect/vitest"
-import * as Array from "effect/Array"
-import * as Chunk from "effect/Chunk"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as Fiber from "effect/Fiber"
-import * as FiberId from "effect/FiberId"
-import * as FiberRef from "effect/FiberRef"
-import * as FiberStatus from "effect/FiberStatus"
-import { constVoid, pipe } from "effect/Function"
-import * as HashSet from "effect/HashSet"
-import * as Queue from "effect/Queue"
-import * as Ref from "effect/Ref"
+import {
+  Array,
+  Chunk,
+  Deferred,
+  Effect,
+  Exit,
+  Fiber,
+  FiberId,
+  FiberRef,
+  FiberStatus,
+  Function as Fun,
+  HashSet,
+  pipe,
+  Queue,
+  Ref
+} from "effect"
 import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 import { withLatch } from "effect/test/utils/latch"
 
@@ -29,7 +32,7 @@ describe("Fiber", () => {
         Effect.flatMap((status) =>
           FiberStatus.isSuspended(status)
             ? Effect.succeed(status.blockingOn)
-            : Effect.failSync(constVoid)
+            : Effect.failSync(Fun.constVoid)
         ),
         Effect.eventually
       )
@@ -53,7 +56,7 @@ describe("Fiber", () => {
       const child = yield* withLatch((release) =>
         FiberRef.set(fiberRef, update).pipe(Effect.zipRight(release), Effect.fork)
       )
-      yield* pipe(child, Fiber.map(constVoid), Fiber.inheritAll)
+      yield* pipe(child, Fiber.map(Fun.constVoid), Fiber.inheritAll)
       const result = yield* FiberRef.get(fiberRef)
       strictEqual(result, update)
     }))
diff --git a/packages/effect/test/FiberRef.test.ts b/packages/effect/test/FiberRef.test.ts
index e7d3af432ad..96c16f5936f 100644
--- a/packages/effect/test/FiberRef.test.ts
+++ b/packages/effect/test/FiberRef.test.ts
@@ -1,15 +1,19 @@
 import { describe, it } from "@effect/vitest"
-import * as Chunk from "effect/Chunk"
-import * as Clock from "effect/Clock"
-import * as Deferred from "effect/Deferred"
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
-import * as FiberRef from "effect/FiberRef"
-import { constant, constTrue, identity, pipe } from "effect/Function"
-import * as Option from "effect/Option"
-import * as Runtime from "effect/Runtime"
-import { assertTrue, strictEqual } from "effect/test/util"
+import {
+  Chunk,
+  Clock,
+  Deferred,
+  Duration,
+  Effect,
+  Fiber,
+  FiberRef,
+  Function as Fun,
+  identity,
+  Option,
+  pipe,
+  Runtime
+} from "effect"
+import { assertIncludes, assertTrue, strictEqual } from "effect/test/util"
 
 const initial = "initial"
 const update = "update"
@@ -228,13 +232,13 @@ describe("FiberRef", () => {
         Effect.orElse(() => Effect.void)
       )
       const result = yield* FiberRef.get(fiberRef)
-      assertTrue(result.includes(initial))
+      assertIncludes(result, initial)
     }))
   it.scoped("the value of all fibers in inherited when running many effects with collectAllPar", () =>
     Effect.gen(function*() {
       const n = 1000
       const fiberRef = yield* FiberRef.make(0, {
-        fork: constant(0),
+        fork: Fun.constant(0),
         join: (a, b) => a + b
       })
       yield* Effect.all(Array.from({ length: n }, () => FiberRef.update(fiberRef, (n) => n + 1)), {
@@ -335,7 +339,7 @@ describe("FiberRef", () => {
     }))
   it.scoped("fork patch is applied when a fiber is unsafely run", () =>
     Effect.gen(function*() {
-      const fiberRef = yield* FiberRef.make<boolean>(true, { fork: constTrue })
+      const fiberRef = yield* FiberRef.make<boolean>(true, { fork: Fun.constTrue })
       const deferred = yield* Deferred.make<boolean>()
       const runtime: Runtime.Runtime<never> = yield* Effect.runtime<never>().pipe(Effect.locally(fiberRef, false))
       yield* Effect.sync(() => FiberRef.get(fiberRef).pipe(Effect.intoDeferred(deferred), Runtime.runCallback(runtime)))
@@ -344,7 +348,7 @@ describe("FiberRef", () => {
     }))
   it.scoped("fork patch is applied when a fiber is unsafely forked", () =>
     Effect.gen(function*() {
-      const fiberRef = yield* FiberRef.make<boolean>(true, { fork: constTrue })
+      const fiberRef = yield* FiberRef.make<boolean>(true, { fork: Fun.constTrue })
       const deferred = yield* Deferred.make<boolean>()
       const runtime: Runtime.Runtime<never> = yield* Effect.locally(Effect.runtime<never>(), fiberRef, false)
       const fiber = yield* Effect.sync(() =>
diff --git a/packages/effect/test/FiberRefs.test.ts b/packages/effect/test/FiberRefs.test.ts
index 7de54570898..a8786b510c2 100644
--- a/packages/effect/test/FiberRefs.test.ts
+++ b/packages/effect/test/FiberRefs.test.ts
@@ -1,16 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as Fiber from "effect/Fiber"
-import * as FiberId from "effect/FiberId"
-import * as FiberRef from "effect/FiberRef"
-import * as FiberRefs from "effect/FiberRefs"
-import { pipe } from "effect/Function"
-import * as HashMap from "effect/HashMap"
-import * as Option from "effect/Option"
-import * as Queue from "effect/Queue"
-import * as Scope from "effect/Scope"
+import { Cause, Effect, Exit, Fiber, FiberId, FiberRef, FiberRefs, HashMap, Option, pipe, Queue, Scope } from "effect"
 import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
 describe("FiberRefs", () => {
diff --git a/packages/effect/test/GlobalValue.test.ts b/packages/effect/test/GlobalValue.test.ts
index 4158c14453e..138d20949f1 100644
--- a/packages/effect/test/GlobalValue.test.ts
+++ b/packages/effect/test/GlobalValue.test.ts
@@ -1,5 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as G from "effect/GlobalValue"
+import { GlobalValue as G } from "effect"
 import { strictEqual } from "effect/test/util"
 
 const a = G.globalValue("id", () => ({}))
diff --git a/packages/effect/test/Hash.test.ts b/packages/effect/test/Hash.test.ts
index a0161429115..5ef36d73194 100644
--- a/packages/effect/test/Hash.test.ts
+++ b/packages/effect/test/Hash.test.ts
@@ -1,11 +1,6 @@
 import { describe, it } from "@effect/vitest"
-import * as Equal from "effect/Equal"
-import { absurd, identity } from "effect/Function"
-import * as Hash from "effect/Hash"
-import * as HashSet from "effect/HashSet"
-import * as Option from "effect/Option"
+import { absurd, Equal, Hash, HashSet, identity, Option, Utils } from "effect"
 import { assertFalse, assertTrue, strictEqual } from "effect/test/util"
-import * as Utils from "effect/Utils"
 
 describe("Hash", () => {
   it("structural", () => {
diff --git a/packages/effect/test/HashMap.test.ts b/packages/effect/test/HashMap.test.ts
index 2e299736ba7..f3b2c0936f3 100644
--- a/packages/effect/test/HashMap.test.ts
+++ b/packages/effect/test/HashMap.test.ts
@@ -1,9 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as Equal from "effect/Equal"
-import { pipe } from "effect/Function"
-import * as Hash from "effect/Hash"
-import * as HM from "effect/HashMap"
-import * as Option from "effect/Option"
+import { Equal, Hash, HashMap as HM, Option, pipe } from "effect"
 import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual, throws } from "effect/test/util"
 
 class Key implements Equal.Equal {
diff --git a/packages/effect/test/HashSet.test.ts b/packages/effect/test/HashSet.test.ts
index d44425f4d31..b322028676b 100644
--- a/packages/effect/test/HashSet.test.ts
+++ b/packages/effect/test/HashSet.test.ts
@@ -1,8 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as Equal from "effect/Equal"
-import { pipe } from "effect/Function"
-import * as Hash from "effect/Hash"
-import * as HashSet from "effect/HashSet"
+import { Equal, Hash, HashSet, pipe } from "effect"
 import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
 class Value implements Equal.Equal {
diff --git a/packages/effect/test/Inspectable.test.ts b/packages/effect/test/Inspectable.test.ts
index 64106d40227..4c5f98ff103 100644
--- a/packages/effect/test/Inspectable.test.ts
+++ b/packages/effect/test/Inspectable.test.ts
@@ -1,5 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as Inspectable from "effect/Inspectable"
+import { Inspectable } from "effect"
 import { strictEqual } from "effect/test/util"
 
 describe("Inspectable", () => {
diff --git a/packages/effect/test/Iterable.test.ts b/packages/effect/test/Iterable.test.ts
index 452ecaaddd4..23309042d5c 100644
--- a/packages/effect/test/Iterable.test.ts
+++ b/packages/effect/test/Iterable.test.ts
@@ -1,8 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import { pipe } from "effect/Function"
-import * as Iter from "effect/Iterable"
-import * as Number from "effect/Number"
-import * as O from "effect/Option"
+import { Iterable as Iter, Number, Option, pipe } from "effect"
 import type { Predicate } from "effect/Predicate"
 import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
@@ -125,25 +122,25 @@ describe("Iterable", () => {
       })
 
       it("Option-returning overloads", () => {
-        assertNone(pipe([], Iter.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())))
+        assertNone(pipe([], Iter.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())))
         assertSome(
-          pipe([1, 2, 3], Iter.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe([1, 2, 3], Iter.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [2, 1]
         )
         assertSome(
-          pipe([1, 2, 3, 4], Iter.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe([1, 2, 3, 4], Iter.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [2, 1]
         )
 
         assertNone(
-          pipe(new Set<number>(), Iter.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none()))
+          pipe(new Set<number>(), Iter.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
         )
         assertSome(
-          pipe(new Set([1, 2, 3]), Iter.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe(new Set([1, 2, 3]), Iter.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [2, 1]
         )
         assertSome(
-          pipe(new Set([1, 2, 3, 4]), Iter.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe(new Set([1, 2, 3, 4]), Iter.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [2, 1]
         )
       })
@@ -161,25 +158,25 @@ describe("Iterable", () => {
       })
 
       it("Option-returning overloads", () => {
-        assertNone(pipe([], Iter.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())))
+        assertNone(pipe([], Iter.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())))
         assertSome(
-          pipe([1, 2, 3], Iter.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe([1, 2, 3], Iter.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [2, 1]
         )
         assertSome(
-          pipe([1, 2, 3, 4], Iter.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe([1, 2, 3, 4], Iter.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [4, 3]
         )
 
         assertNone(
-          pipe(new Set<number>(), Iter.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none()))
+          pipe(new Set<number>(), Iter.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
         )
         assertSome(
-          pipe(new Set([1, 2, 3]), Iter.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe(new Set([1, 2, 3]), Iter.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [2, 1]
         )
         assertSome(
-          pipe(new Set([1, 2, 3, 4]), Iter.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
+          pipe(new Set([1, 2, 3, 4]), Iter.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
           [4, 3]
         )
       })
@@ -267,7 +264,7 @@ describe("Iterable", () => {
   })
 
   it("unfold", () => {
-    const as = Iter.unfold(5, (n) => (n > 0 ? O.some([n, n - 1]) : O.none()))
+    const as = Iter.unfold(5, (n) => (n > 0 ? Option.some([n, n - 1]) : Option.none()))
     deepStrictEqual(toArray(as), [5, 4, 3, 2, 1])
   })
 
@@ -294,12 +291,12 @@ describe("Iterable", () => {
 
   it("getSomes", () => {
     deepStrictEqual(toArray(Iter.getSomes([])), [])
-    deepStrictEqual(toArray(Iter.getSomes([O.some(1), O.some(2), O.some(3)])), [
+    deepStrictEqual(toArray(Iter.getSomes([Option.some(1), Option.some(2), Option.some(3)])), [
       1,
       2,
       3
     ])
-    deepStrictEqual(toArray(Iter.getSomes([O.some(1), O.none(), O.some(3)])), [
+    deepStrictEqual(toArray(Iter.getSomes([Option.some(1), Option.none(), Option.some(3)])), [
       1,
       3
     ])
@@ -307,20 +304,23 @@ describe("Iterable", () => {
 
   it("filter", () => {
     deepStrictEqual(toArray(Iter.filter([1, 2, 3], (n) => n % 2 === 1)), [1, 3])
-    deepStrictEqual(toArray(Iter.filter([O.some(3), O.some(2), O.some(1)], O.isSome)), [
-      O.some(3),
-      O.some(2),
-      O.some(1)
+    deepStrictEqual(toArray(Iter.filter([Option.some(3), Option.some(2), Option.some(1)], Option.isSome)), [
+      Option.some(3),
+      Option.some(2),
+      Option.some(1)
+    ])
+    deepStrictEqual(toArray(Iter.filter([Option.some(3), Option.none(), Option.some(1)], Option.isSome)), [
+      Option.some(3),
+      Option.some(1)
     ])
-    deepStrictEqual(toArray(Iter.filter([O.some(3), O.none(), O.some(1)], O.isSome)), [O.some(3), O.some(1)])
     deepStrictEqual(toArray(Iter.filter(["a", "b", "c"], (_, i) => i % 2 === 0)), ["a", "c"])
   })
 
   it("filterMap", () => {
-    const f = (n: number) => (n % 2 === 0 ? O.none() : O.some(n))
+    const f = (n: number) => (n % 2 === 0 ? Option.none() : Option.some(n))
     deepStrictEqual(pipe([1, 2, 3], Iter.filterMap(f), toArray), [1, 3])
     deepStrictEqual(pipe([], Iter.filterMap(f), toArray), [])
-    const g = (n: number, i: number) => ((i + n) % 2 === 0 ? O.none() : O.some(n))
+    const g = (n: number, i: number) => ((i + n) % 2 === 0 ? Option.none() : Option.some(n))
     deepStrictEqual(pipe([1, 2, 4], Iter.filterMap(g), toArray), [1, 2])
     deepStrictEqual(pipe([], Iter.filterMap(g), toArray), [])
   })
diff --git a/packages/effect/test/KeyedPool.test.ts b/packages/effect/test/KeyedPool.test.ts
index 55c8c17a2a3..469ca6c906c 100644
--- a/packages/effect/test/KeyedPool.test.ts
+++ b/packages/effect/test/KeyedPool.test.ts
@@ -1,12 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as Array from "effect/Array"
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
-import { pipe } from "effect/Function"
-import * as KeyedPool from "effect/KeyedPool"
-import * as Random from "effect/Random"
-import * as Ref from "effect/Ref"
+import { Array, Duration, Effect, Fiber, KeyedPool, pipe, Random, Ref } from "effect"
 import { strictEqual } from "effect/test/util"
 import * as TestClock from "effect/TestClock"
 
diff --git a/packages/effect/test/Layer.test.ts b/packages/effect/test/Layer.test.ts
index 74174632bfe..900d171c310 100644
--- a/packages/effect/test/Layer.test.ts
+++ b/packages/effect/test/Layer.test.ts
@@ -1,25 +1,28 @@
 import { describe, it } from "@effect/vitest"
-import * as Chunk from "effect/Chunk"
-import * as Context from "effect/Context"
-import * as Deferred from "effect/Deferred"
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as Fiber from "effect/Fiber"
-import * as FiberRef from "effect/FiberRef"
-import { identity, pipe } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Ref from "effect/Ref"
-import * as Schedule from "effect/Schedule"
-import * as Scope from "effect/Scope"
+import {
+  Chunk,
+  Context,
+  Deferred,
+  Duration,
+  Effect,
+  Exit,
+  Fiber,
+  FiberRef,
+  identity,
+  Layer,
+  pipe,
+  Ref,
+  Schedule,
+  Scope
+} from "effect"
 import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
-export const acquire1 = "Acquiring Module 1"
-export const acquire2 = "Acquiring Module 2"
-export const acquire3 = "Acquiring Module 3"
-export const release1 = "Releasing Module 1"
-export const release2 = "Releasing Module 2"
-export const release3 = "Releasing Module 3"
+const acquire1 = "Acquiring Module 1"
+const acquire2 = "Acquiring Module 2"
+const acquire3 = "Acquiring Module 3"
+const release1 = "Releasing Module 1"
+const release2 = "Releasing Module 2"
+const release3 = "Releasing Module 3"
 
 describe("Layer", () => {
   it.effect("layers can be acquired in parallel", () =>
diff --git a/packages/effect/test/List.test.ts b/packages/effect/test/List.test.ts
index a350fbb5657..dce0929314b 100644
--- a/packages/effect/test/List.test.ts
+++ b/packages/effect/test/List.test.ts
@@ -1,11 +1,6 @@
 import { describe, it } from "@effect/vitest"
-import * as Array from "effect/Array"
-import * as Chunk from "effect/Chunk"
-import * as Duration from "effect/Duration"
-import * as Either from "effect/Either"
+import { Array, Chunk, Duration, Either, List, Option } from "effect"
 import { equals, symbol } from "effect/Equal"
-import * as List from "effect/List"
-import * as Option from "effect/Option"
 import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual, throws } from "effect/test/util"
 
 const testStructuralSharing = <A>(a: List.List<A>, b: List.List<A>, n = 0): number | undefined => {
diff --git a/packages/effect/test/LogLevel.test.ts b/packages/effect/test/LogLevel.test.ts
index d5819170da3..2bc71a85090 100644
--- a/packages/effect/test/LogLevel.test.ts
+++ b/packages/effect/test/LogLevel.test.ts
@@ -1,5 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as LogLevel from "effect/LogLevel"
+import { LogLevel } from "effect"
 import { strictEqual } from "effect/test/util"
 
 describe("LogLevel", () => {
diff --git a/packages/effect/test/ManagedRuntime.test.ts b/packages/effect/test/ManagedRuntime.test.ts
index ad4e3a91f22..745d248724b 100644
--- a/packages/effect/test/ManagedRuntime.test.ts
+++ b/packages/effect/test/ManagedRuntime.test.ts
@@ -1,9 +1,5 @@
 import { describe, it, test } from "@effect/vitest"
-import { FiberRefs, List, ManagedRuntime } from "effect"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as FiberRef from "effect/FiberRef"
-import * as Layer from "effect/Layer"
+import { Context, Effect, FiberRef, FiberRefs, Layer, List, ManagedRuntime } from "effect"
 import { deepStrictEqual, strictEqual } from "effect/test/util"
 
 describe("ManagedRuntime", () => {
diff --git a/packages/effect/test/Match.test.ts b/packages/effect/test/Match.test.ts
index 0560e1b9ab2..6f1689dd5bb 100644
--- a/packages/effect/test/Match.test.ts
+++ b/packages/effect/test/Match.test.ts
@@ -1,9 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import * as E from "effect/Either"
-import { pipe } from "effect/Function"
-import * as M from "effect/Match"
-import * as O from "effect/Option"
-import * as Predicate from "effect/Predicate"
+import { Either, Match as M, Option, pipe, Predicate } from "effect"
 import { assertFalse, assertLeft, assertRight, assertSome, assertTrue, strictEqual } from "effect/test/util"
 import { assertType } from "effect/test/utils/types"
 
@@ -22,8 +18,8 @@ describe("Match", () => {
   it("exhaustive-literal", () => {
     const match = pipe(
       M.type<{ _tag: "A"; a: number } | { _tag: "B"; b: number }>(),
-      M.when({ _tag: "A" }, (_) => E.right(_.a)),
-      M.when({ _tag: "B" }, (_) => E.right(_.b)),
+      M.when({ _tag: "A" }, (_) => Either.right(_.a)),
+      M.when({ _tag: "B" }, (_) => Either.right(_.b)),
       M.exhaustive
     )
     assertRight(match({ _tag: "A", a: 0 }), 0)
@@ -35,13 +31,13 @@ describe("Match", () => {
       M.type<{ _tag: "A"; a: number | string } | { _tag: "B"; b: number }>(),
       M.when({ _tag: M.is("A", "B"), a: M.number }, (_) => {
         assertType<{ _tag: "A"; a: number }>()(_) satisfies true
-        return E.right(_._tag)
+        return Either.right(_._tag)
       }),
       M.when({ _tag: M.string, a: M.string }, (_) => {
         assertType<{ _tag: "A"; a: string }>()(_) satisfies true
-        return E.right(_._tag)
+        return Either.right(_._tag)
       }),
-      M.when({ b: M.number }, (_) => E.left(_._tag)),
+      M.when({ b: M.number }, (_) => Either.left(_._tag)),
       M.orElse((_) => {
         throw "absurd"
       })
@@ -64,7 +60,7 @@ describe("Match", () => {
 
   it("inline", () => {
     const result = pipe(
-      M.value(E.right(0)),
+      M.value(Either.right(0)),
       M.tag("Right", (_) => _.right),
       M.tag("Left", (_) => _.left),
       M.exhaustive
@@ -74,7 +70,7 @@ describe("Match", () => {
 
   it("piped", () => {
     const result = pipe(
-      E.right(0),
+      Either.right(0),
       M.value,
       M.when({ _tag: "Right" }, (_) => _.right),
       M.option
@@ -108,7 +104,7 @@ describe("Match", () => {
 
   it("piped", () => {
     const result = pipe(
-      E.right(0),
+      Either.right(0),
       M.value,
       M.when({ _tag: "Right" }, (_) => _.right),
       M.option
@@ -190,7 +186,7 @@ describe("Match", () => {
 
   it("discriminator multiple", () => {
     const result = pipe(
-      M.value(E.right(0)),
+      M.value(Either.right(0)),
       M.discriminator("_tag")("Right", "Left", (_) => "match"),
       M.exhaustive
     )
@@ -233,13 +229,13 @@ describe("Match", () => {
 
   it("nested Option", () => {
     const match = pipe(
-      M.type<{ user: O.Option<{ readonly name: string }> }>(),
+      M.type<{ user: Option.Option<{ readonly name: string }> }>(),
       M.when({ user: { _tag: "Some" } }, (_) => _.user.value.name),
       M.orElse((_) => "fail")
     )
 
-    strictEqual(match({ user: O.some({ name: "a" }) }), "a")
-    strictEqual(match({ user: O.none() }), "fail")
+    strictEqual(match({ user: Option.some({ name: "a" }) }), "a")
+    strictEqual(match({ user: Option.none() }), "fail")
   })
 
   it("predicate", () => {
@@ -321,8 +317,8 @@ describe("Match", () => {
   it("unify", () => {
     const match = pipe(
       M.type<{ readonly _tag: "A" } | { readonly _tag: "B" }>(),
-      M.tag("A", () => E.right("a") as E.Either<string, number>),
-      M.tag("B", () => E.right(123) as E.Either<number, string>),
+      M.tag("A", () => Either.right("a") as Either.Either<string, number>),
+      M.tag("B", () => Either.right(123) as Either.Either<number, string>),
       M.exhaustive
     )
 
@@ -412,14 +408,14 @@ describe("Match", () => {
       | { readonly _tag: "C" }
 
     const match = pipe(
-      M.type<{ readonly abc: O.Option<ABC> }>(),
+      M.type<{ readonly abc: Option.Option<ABC> }>(),
       M.when({ abc: { value: { _tag: "A" } } }, (_) => _.abc.value._tag),
       M.orElse((_) => "no match")
     )
 
-    strictEqual(match({ abc: O.some({ _tag: "A" }) }), "A")
-    strictEqual(match({ abc: O.some({ _tag: "B" }) }), "no match")
-    strictEqual(match({ abc: O.none() }), "no match")
+    strictEqual(match({ abc: Option.some({ _tag: "A" }) }), "A")
+    strictEqual(match({ abc: Option.some({ _tag: "B" }) }), "no match")
+    strictEqual(match({ abc: Option.none() }), "no match")
   })
 
   it("getters", () => {
@@ -756,7 +752,7 @@ describe("Match", () => {
     )
 
     assertType<
-      E.Either<string, { a: number; b: string }>
+      Either.Either<string, { a: number; b: string }>
     >()(match({ a, b })) satisfies true
   })
 
diff --git a/packages/effect/test/Micro.test.ts b/packages/effect/test/Micro.test.ts
index 5e1e9a7c4ae..26dd4e2861d 100644
--- a/packages/effect/test/Micro.test.ts
+++ b/packages/effect/test/Micro.test.ts
@@ -1,6 +1,6 @@
 import { describe, it } from "@effect/vitest"
 import { Cause, Context, Effect, Either, Exit, Fiber, Micro, Option, pipe } from "effect"
-import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { assertFalse, assertIncludes, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
 class ATag extends Context.Tag("ATag")<ATag, "A">() {}
 class TestError extends Micro.TaggedError("TestError") {}
@@ -12,7 +12,7 @@ describe.concurrent("Micro", () => {
         // Referenced line to be included in the string output
         const error = yield* new TestError().pipe(Micro.flip)
         deepStrictEqual(error, new TestError())
-        assertTrue(error.stack?.includes("Micro.test.ts:13")) // <= reference to the line above
+        assertIncludes(error.stack, "Micro.test.ts:13") // <= reference to the line above
       }))
 
     it.effect("withTrace", () =>
@@ -23,8 +23,8 @@ describe.concurrent("Micro", () => {
           Micro.sandbox,
           Micro.flip
         )
-        assertTrue(error.stack?.includes("at test trace"))
-        assertTrue(error.stack?.includes("Micro.test.ts:22")) // <= reference to the line above
+        assertIncludes(error.stack, "at test trace")
+        assertIncludes(error.stack, "Micro.test.ts:22") // <= reference to the line above
       }))
   })
 
@@ -569,8 +569,8 @@ describe.concurrent("Micro", () => {
         )
         strictEqual(failure.name, "MicroCause.Die")
         strictEqual(failure.message, JSON.stringify({ some: "error" }))
-        assertTrue(failure.stack?.includes(`MicroCause.Die: ${JSON.stringify({ some: "error" })}`))
-        assertTrue(failure.stack?.includes("at test trace ("))
+        assertIncludes(failure.stack, `MicroCause.Die: ${JSON.stringify({ some: "error" })}`)
+        assertIncludes(failure.stack, "at test trace (")
       }))
 
     it.effect("renders non-errors", () =>
@@ -582,8 +582,8 @@ describe.concurrent("Micro", () => {
         )
         strictEqual(failure.name, "MicroCause.Fail")
         strictEqual(failure.message, JSON.stringify({ some: "error" }))
-        assertTrue(failure.stack?.includes(`MicroCause.Fail: ${JSON.stringify({ some: "error" })}`))
-        assertTrue(failure.stack?.includes("at test trace ("))
+        assertIncludes(failure.stack, `MicroCause.Fail: ${JSON.stringify({ some: "error" })}`)
+        assertIncludes(failure.stack, "at test trace (")
       }))
 
     it.effect("renders errors", () =>
@@ -595,8 +595,8 @@ describe.concurrent("Micro", () => {
         )
         strictEqual(failure.name, "(MicroCause.Fail) Error")
         strictEqual(failure.message, "boom")
-        assertTrue(failure.stack?.includes(`(MicroCause.Fail) Error: boom`))
-        assertTrue(failure.stack?.includes("at test trace ("))
+        assertIncludes(failure.stack, `(MicroCause.Fail) Error: boom`)
+        assertIncludes(failure.stack, "at test trace (")
       }))
   })
 
diff --git a/packages/effect/test/Predicate.test.ts b/packages/effect/test/Predicate.test.ts
index 126f2e25cac..55c69a67baf 100644
--- a/packages/effect/test/Predicate.test.ts
+++ b/packages/effect/test/Predicate.test.ts
@@ -1,12 +1,11 @@
 import { describe, it } from "@effect/vitest"
-import { constFalse, constTrue, pipe } from "effect/Function"
-import * as _ from "effect/Predicate"
+import { Function as Fun, pipe, Predicate } from "effect"
 import { assertFalse, assertTrue } from "effect/test/util"
 
-const isPositive: _.Predicate<number> = (n) => n > 0
-const isNegative: _.Predicate<number> = (n) => n < 0
-const isLessThan2: _.Predicate<number> = (n) => n < 2
-const isString: _.Refinement<unknown, string> = (u: unknown): u is string => typeof u === "string"
+const isPositive: Predicate.Predicate<number> = (n) => n > 0
+const isNegative: Predicate.Predicate<number> = (n) => n < 0
+const isLessThan2: Predicate.Predicate<number> = (n) => n < 2
+const isString: Predicate.Refinement<unknown, string> = (u: unknown): u is string => typeof u === "string"
 
 interface NonEmptyStringBrand {
   readonly NonEmptyString: unique symbol
@@ -14,11 +13,11 @@ interface NonEmptyStringBrand {
 
 type NonEmptyString = string & NonEmptyStringBrand
 
-const isNonEmptyString: _.Refinement<string, NonEmptyString> = (s): s is NonEmptyString => s.length > 0
+const isNonEmptyString: Predicate.Refinement<string, NonEmptyString> = (s): s is NonEmptyString => s.length > 0
 
 describe("Predicate", () => {
   it("compose", () => {
-    const refinement = pipe(isString, _.compose(isNonEmptyString))
+    const refinement = pipe(isString, Predicate.compose(isNonEmptyString))
     assertTrue(refinement("a"))
     assertFalse(refinement(null))
     assertFalse(refinement(""))
@@ -30,7 +29,7 @@ describe("Predicate", () => {
     }
     const predicate = pipe(
       isPositive,
-      _.mapInput((a: A) => a.a)
+      Predicate.mapInput((a: A) => a.a)
     )
     assertFalse(predicate({ a: -1 }))
     assertFalse(predicate({ a: 0 }))
@@ -38,7 +37,7 @@ describe("Predicate", () => {
   })
 
   it("product", () => {
-    const product = _.product
+    const product = Predicate.product
     const p = product(isPositive, isNegative)
     assertTrue(p([1, -1]))
     assertFalse(p([1, 1]))
@@ -47,7 +46,7 @@ describe("Predicate", () => {
   })
 
   it("productMany", () => {
-    const productMany = _.productMany
+    const productMany = Predicate.productMany
     const p = productMany(isPositive, [isNegative])
     assertTrue(p([1, -1]))
     assertFalse(p([1, 1]))
@@ -56,7 +55,7 @@ describe("Predicate", () => {
   })
 
   it("tuple", () => {
-    const p = _.tuple(isPositive, isNegative)
+    const p = Predicate.tuple(isPositive, isNegative)
     assertTrue(p([1, -1]))
     assertFalse(p([1, 1]))
     assertFalse(p([-1, -1]))
@@ -64,7 +63,7 @@ describe("Predicate", () => {
   })
 
   it("struct", () => {
-    const p = _.struct({ a: isPositive, b: isNegative })
+    const p = Predicate.struct({ a: isPositive, b: isNegative })
     assertTrue(p({ a: 1, b: -1 }))
     assertFalse(p({ a: 1, b: 1 }))
     assertFalse(p({ a: -1, b: -1 }))
@@ -72,7 +71,7 @@ describe("Predicate", () => {
   })
 
   it("all", () => {
-    const p = _.all([isPositive, isNegative])
+    const p = Predicate.all([isPositive, isNegative])
     assertTrue(p([1]))
     assertTrue(p([1, -1]))
     assertFalse(p([1, 1]))
@@ -81,263 +80,263 @@ describe("Predicate", () => {
   })
 
   it("not", () => {
-    const p = _.not(isPositive)
+    const p = Predicate.not(isPositive)
     assertFalse(p(1))
     assertTrue(p(0))
     assertTrue(p(-1))
   })
 
   it("or", () => {
-    const p = pipe(isPositive, _.or(isNegative))
+    const p = pipe(isPositive, Predicate.or(isNegative))
     assertTrue(p(-1))
     assertTrue(p(1))
     assertFalse(p(0))
   })
 
   it("and", () => {
-    const p = pipe(isPositive, _.and(isLessThan2))
+    const p = pipe(isPositive, Predicate.and(isLessThan2))
     assertTrue(p(1))
     assertFalse(p(-1))
     assertFalse(p(3))
   })
 
   it("xor", () => {
-    assertFalse(pipe(constTrue, _.xor(constTrue))(null)) // true xor true = false
-    assertTrue(pipe(constTrue, _.xor(constFalse))(null)) // true xor false = true
-    assertTrue(pipe(constFalse, _.xor(constTrue))(null)) // false xor true = true
-    assertFalse(pipe(constFalse, _.xor(constFalse))(null)) // false xor false = false
+    assertFalse(pipe(Fun.constTrue, Predicate.xor(Fun.constTrue))(null)) // true xor true = false
+    assertTrue(pipe(Fun.constTrue, Predicate.xor(Fun.constFalse))(null)) // true xor false = true
+    assertTrue(pipe(Fun.constFalse, Predicate.xor(Fun.constTrue))(null)) // false xor true = true
+    assertFalse(pipe(Fun.constFalse, Predicate.xor(Fun.constFalse))(null)) // false xor false = false
   })
 
   it("eqv", () => {
-    assertTrue(pipe(constTrue, _.eqv(constTrue))(null)) // true eqv true = true
-    assertFalse(pipe(constTrue, _.eqv(constFalse))(null)) // true eqv false = false
-    assertFalse(pipe(constFalse, _.eqv(constTrue))(null)) // false eqv true = false
-    assertTrue(pipe(constFalse, _.eqv(constFalse))(null)) // false eqv false = true
+    assertTrue(pipe(Fun.constTrue, Predicate.eqv(Fun.constTrue))(null)) // true eqv true = true
+    assertFalse(pipe(Fun.constTrue, Predicate.eqv(Fun.constFalse))(null)) // true eqv false = false
+    assertFalse(pipe(Fun.constFalse, Predicate.eqv(Fun.constTrue))(null)) // false eqv true = false
+    assertTrue(pipe(Fun.constFalse, Predicate.eqv(Fun.constFalse))(null)) // false eqv false = true
   })
 
   it("implies", () => {
-    assertTrue(pipe(constTrue, _.implies(constTrue))(null)) // true implies true = true
-    assertFalse(pipe(constTrue, _.implies(constFalse))(null)) // true implies false = false
-    assertTrue(pipe(constFalse, _.implies(constTrue))(null)) // false implies true = true
-    assertTrue(pipe(constFalse, _.implies(constFalse))(null)) // false implies false = true
+    assertTrue(pipe(Fun.constTrue, Predicate.implies(Fun.constTrue))(null)) // true implies true = true
+    assertFalse(pipe(Fun.constTrue, Predicate.implies(Fun.constFalse))(null)) // true implies false = false
+    assertTrue(pipe(Fun.constFalse, Predicate.implies(Fun.constTrue))(null)) // false implies true = true
+    assertTrue(pipe(Fun.constFalse, Predicate.implies(Fun.constFalse))(null)) // false implies false = true
   })
 
   it("nor", () => {
-    assertFalse(pipe(constTrue, _.nor(constTrue))(null)) // true nor true = false
-    assertFalse(pipe(constTrue, _.nor(constFalse))(null)) // true nor false = false
-    assertFalse(pipe(constFalse, _.nor(constTrue))(null)) // false nor true = false
-    assertTrue(pipe(constFalse, _.nor(constFalse))(null)) // false nor false = true
+    assertFalse(pipe(Fun.constTrue, Predicate.nor(Fun.constTrue))(null)) // true nor true = false
+    assertFalse(pipe(Fun.constTrue, Predicate.nor(Fun.constFalse))(null)) // true nor false = false
+    assertFalse(pipe(Fun.constFalse, Predicate.nor(Fun.constTrue))(null)) // false nor true = false
+    assertTrue(pipe(Fun.constFalse, Predicate.nor(Fun.constFalse))(null)) // false nor false = true
   })
 
   it("nand", () => {
-    assertFalse(pipe(constTrue, _.nand(constTrue))(null)) // true nand true = false
-    assertTrue(pipe(constTrue, _.nand(constFalse))(null)) // true nand false = true
-    assertTrue(pipe(constFalse, _.nand(constTrue))(null)) // false nand true = true
-    assertTrue(pipe(constFalse, _.nand(constFalse))(null)) // false nand false = true
+    assertFalse(pipe(Fun.constTrue, Predicate.nand(Fun.constTrue))(null)) // true nand true = false
+    assertTrue(pipe(Fun.constTrue, Predicate.nand(Fun.constFalse))(null)) // true nand false = true
+    assertTrue(pipe(Fun.constFalse, Predicate.nand(Fun.constTrue))(null)) // false nand true = true
+    assertTrue(pipe(Fun.constFalse, Predicate.nand(Fun.constFalse))(null)) // false nand false = true
   })
 
   it("some", () => {
-    const predicate = _.some([isPositive, isNegative])
+    const predicate = Predicate.some([isPositive, isNegative])
     assertFalse(predicate(0))
     assertTrue(predicate(-1))
     assertTrue(predicate(1))
   })
 
   it("every", () => {
-    const predicate = _.every([isPositive, isLessThan2])
+    const predicate = Predicate.every([isPositive, isLessThan2])
     assertFalse(predicate(0))
     assertFalse(predicate(-2))
     assertTrue(predicate(1))
   })
 
   it("isTruthy", () => {
-    assertTrue(_.isTruthy(true))
-    assertFalse(_.isTruthy(false))
-    assertTrue(_.isTruthy("a"))
-    assertFalse(_.isTruthy(""))
-    assertTrue(_.isTruthy(1))
-    assertFalse(_.isTruthy(0))
-    assertTrue(_.isTruthy(1n))
-    assertFalse(_.isTruthy(0n))
+    assertTrue(Predicate.isTruthy(true))
+    assertFalse(Predicate.isTruthy(false))
+    assertTrue(Predicate.isTruthy("a"))
+    assertFalse(Predicate.isTruthy(""))
+    assertTrue(Predicate.isTruthy(1))
+    assertFalse(Predicate.isTruthy(0))
+    assertTrue(Predicate.isTruthy(1n))
+    assertFalse(Predicate.isTruthy(0n))
   })
 
   it("isFunction", () => {
-    assertTrue(_.isFunction(_.isFunction))
-    assertFalse(_.isFunction("function"))
+    assertTrue(Predicate.isFunction(Predicate.isFunction))
+    assertFalse(Predicate.isFunction("function"))
   })
 
   it("isUndefined", () => {
-    assertTrue(_.isUndefined(undefined))
-    assertFalse(_.isUndefined(null))
-    assertFalse(_.isUndefined("undefined"))
+    assertTrue(Predicate.isUndefined(undefined))
+    assertFalse(Predicate.isUndefined(null))
+    assertFalse(Predicate.isUndefined("undefined"))
   })
 
   it("isNotUndefined", () => {
-    assertFalse(_.isNotUndefined(undefined))
-    assertTrue(_.isNotUndefined(null))
-    assertTrue(_.isNotUndefined("undefined"))
+    assertFalse(Predicate.isNotUndefined(undefined))
+    assertTrue(Predicate.isNotUndefined(null))
+    assertTrue(Predicate.isNotUndefined("undefined"))
   })
 
   it("isNull", () => {
-    assertTrue(_.isNull(null))
-    assertFalse(_.isNull(undefined))
-    assertFalse(_.isNull("null"))
+    assertTrue(Predicate.isNull(null))
+    assertFalse(Predicate.isNull(undefined))
+    assertFalse(Predicate.isNull("null"))
   })
 
   it("isNotNull", () => {
-    assertFalse(_.isNotNull(null))
-    assertTrue(_.isNotNull(undefined))
-    assertTrue(_.isNotNull("null"))
+    assertFalse(Predicate.isNotNull(null))
+    assertTrue(Predicate.isNotNull(undefined))
+    assertTrue(Predicate.isNotNull("null"))
   })
 
   it("isNever", () => {
-    assertFalse(_.isNever(null))
-    assertFalse(_.isNever(undefined))
-    assertFalse(_.isNever({}))
-    assertFalse(_.isNever([]))
+    assertFalse(Predicate.isNever(null))
+    assertFalse(Predicate.isNever(undefined))
+    assertFalse(Predicate.isNever({}))
+    assertFalse(Predicate.isNever([]))
   })
 
   it("isUnknown", () => {
-    assertTrue(_.isUnknown(null))
-    assertTrue(_.isUnknown(undefined))
-    assertTrue(_.isUnknown({}))
-    assertTrue(_.isUnknown([]))
+    assertTrue(Predicate.isUnknown(null))
+    assertTrue(Predicate.isUnknown(undefined))
+    assertTrue(Predicate.isUnknown({}))
+    assertTrue(Predicate.isUnknown([]))
   })
 
   it("isObject", () => {
-    assertTrue(_.isObject({}))
-    assertTrue(_.isObject([]))
-    assertTrue(_.isObject(() => 1))
-    assertFalse(_.isObject(null))
-    assertFalse(_.isObject(undefined))
-    assertFalse(_.isObject("a"))
-    assertFalse(_.isObject(1))
-    assertFalse(_.isObject(true))
-    assertFalse(_.isObject(1n))
-    assertFalse(_.isObject(Symbol.for("a")))
+    assertTrue(Predicate.isObject({}))
+    assertTrue(Predicate.isObject([]))
+    assertTrue(Predicate.isObject(() => 1))
+    assertFalse(Predicate.isObject(null))
+    assertFalse(Predicate.isObject(undefined))
+    assertFalse(Predicate.isObject("a"))
+    assertFalse(Predicate.isObject(1))
+    assertFalse(Predicate.isObject(true))
+    assertFalse(Predicate.isObject(1n))
+    assertFalse(Predicate.isObject(Symbol.for("a")))
   })
 
   it("isSet", () => {
-    assertTrue(_.isSet(new Set([1, 2])))
-    assertTrue(_.isSet(new Set()))
-    assertFalse(_.isSet({}))
-    assertFalse(_.isSet(null))
-    assertFalse(_.isSet(undefined))
+    assertTrue(Predicate.isSet(new Set([1, 2])))
+    assertTrue(Predicate.isSet(new Set()))
+    assertFalse(Predicate.isSet({}))
+    assertFalse(Predicate.isSet(null))
+    assertFalse(Predicate.isSet(undefined))
   })
 
   it("isMap", () => {
-    assertTrue(_.isMap(new Map()))
-    assertFalse(_.isMap({}))
-    assertFalse(_.isMap(null))
-    assertFalse(_.isMap(undefined))
+    assertTrue(Predicate.isMap(new Map()))
+    assertFalse(Predicate.isMap({}))
+    assertFalse(Predicate.isMap(null))
+    assertFalse(Predicate.isMap(undefined))
   })
 
   it("hasProperty", () => {
     const a = Symbol.for("effect/test/a")
 
-    assertTrue(_.hasProperty({ a: 1 }, "a"))
-    assertTrue(_.hasProperty("a")({ a: 1 }))
-    assertTrue(_.hasProperty({ [a]: 1 }, a))
-    assertTrue(_.hasProperty(a)({ [a]: 1 }))
+    assertTrue(Predicate.hasProperty({ a: 1 }, "a"))
+    assertTrue(Predicate.hasProperty("a")({ a: 1 }))
+    assertTrue(Predicate.hasProperty({ [a]: 1 }, a))
+    assertTrue(Predicate.hasProperty(a)({ [a]: 1 }))
 
-    assertFalse(_.hasProperty({}, "a"))
-    assertFalse(_.hasProperty(null, "a"))
-    assertFalse(_.hasProperty(undefined, "a"))
-    assertFalse(_.hasProperty({}, "a"))
-    assertFalse(_.hasProperty(() => {}, "a"))
+    assertFalse(Predicate.hasProperty({}, "a"))
+    assertFalse(Predicate.hasProperty(null, "a"))
+    assertFalse(Predicate.hasProperty(undefined, "a"))
+    assertFalse(Predicate.hasProperty({}, "a"))
+    assertFalse(Predicate.hasProperty(() => {}, "a"))
 
-    assertFalse(_.hasProperty({}, a))
-    assertFalse(_.hasProperty(null, a))
-    assertFalse(_.hasProperty(undefined, a))
-    assertFalse(_.hasProperty({}, a))
-    assertFalse(_.hasProperty(() => {}, a))
+    assertFalse(Predicate.hasProperty({}, a))
+    assertFalse(Predicate.hasProperty(null, a))
+    assertFalse(Predicate.hasProperty(undefined, a))
+    assertFalse(Predicate.hasProperty({}, a))
+    assertFalse(Predicate.hasProperty(() => {}, a))
   })
 
   it("isTagged", () => {
-    assertFalse(_.isTagged(1, "a"))
-    assertFalse(_.isTagged("", "a"))
-    assertFalse(_.isTagged({}, "a"))
-    assertFalse(_.isTagged("a")({}))
-    assertFalse(_.isTagged({ a: "a" }, "a"))
-    assertTrue(_.isTagged({ _tag: "a" }, "a"))
-    assertTrue(_.isTagged("a")({ _tag: "a" }))
+    assertFalse(Predicate.isTagged(1, "a"))
+    assertFalse(Predicate.isTagged("", "a"))
+    assertFalse(Predicate.isTagged({}, "a"))
+    assertFalse(Predicate.isTagged("a")({}))
+    assertFalse(Predicate.isTagged({ a: "a" }, "a"))
+    assertTrue(Predicate.isTagged({ _tag: "a" }, "a"))
+    assertTrue(Predicate.isTagged("a")({ _tag: "a" }))
   })
 
   it("isNullable", () => {
-    assertTrue(_.isNullable(null))
-    assertTrue(_.isNullable(undefined))
-    assertFalse(_.isNullable({}))
-    assertFalse(_.isNullable([]))
+    assertTrue(Predicate.isNullable(null))
+    assertTrue(Predicate.isNullable(undefined))
+    assertFalse(Predicate.isNullable({}))
+    assertFalse(Predicate.isNullable([]))
   })
 
   it("isNotNullable", () => {
-    assertTrue(_.isNotNullable({}))
-    assertTrue(_.isNotNullable([]))
-    assertFalse(_.isNotNullable(null))
-    assertFalse(_.isNotNullable(undefined))
+    assertTrue(Predicate.isNotNullable({}))
+    assertTrue(Predicate.isNotNullable([]))
+    assertFalse(Predicate.isNotNullable(null))
+    assertFalse(Predicate.isNotNullable(undefined))
   })
 
   it("isError", () => {
-    assertTrue(_.isError(new Error()))
-    assertFalse(_.isError(null))
-    assertFalse(_.isError({}))
+    assertTrue(Predicate.isError(new Error()))
+    assertFalse(Predicate.isError(null))
+    assertFalse(Predicate.isError({}))
   })
 
   it("isUint8Array", () => {
-    assertTrue(_.isUint8Array(new Uint8Array()))
-    assertFalse(_.isUint8Array(null))
-    assertFalse(_.isUint8Array({}))
+    assertTrue(Predicate.isUint8Array(new Uint8Array()))
+    assertFalse(Predicate.isUint8Array(null))
+    assertFalse(Predicate.isUint8Array({}))
   })
 
   it("isDate", () => {
-    assertTrue(_.isDate(new Date()))
-    assertFalse(_.isDate(null))
-    assertFalse(_.isDate({}))
+    assertTrue(Predicate.isDate(new Date()))
+    assertFalse(Predicate.isDate(null))
+    assertFalse(Predicate.isDate({}))
   })
 
   it("isIterable", () => {
-    assertTrue(_.isIterable([]))
-    assertTrue(_.isIterable(new Set()))
-    assertFalse(_.isIterable(null))
-    assertFalse(_.isIterable({}))
+    assertTrue(Predicate.isIterable([]))
+    assertTrue(Predicate.isIterable(new Set()))
+    assertFalse(Predicate.isIterable(null))
+    assertFalse(Predicate.isIterable({}))
   })
 
   it("isRecord", () => {
-    assertTrue(_.isRecord({}))
-    assertTrue(_.isRecord({ a: 1 }))
+    assertTrue(Predicate.isRecord({}))
+    assertTrue(Predicate.isRecord({ a: 1 }))
 
-    assertFalse(_.isRecord([]))
-    assertFalse(_.isRecord([1, 2, 3]))
-    assertFalse(_.isRecord(null))
-    assertFalse(_.isRecord(undefined))
-    assertFalse(_.isRecord(() => null))
+    assertFalse(Predicate.isRecord([]))
+    assertFalse(Predicate.isRecord([1, 2, 3]))
+    assertFalse(Predicate.isRecord(null))
+    assertFalse(Predicate.isRecord(undefined))
+    assertFalse(Predicate.isRecord(() => null))
   })
 
   it("isReadonlyRecord", () => {
-    assertTrue(_.isReadonlyRecord({}))
-    assertTrue(_.isReadonlyRecord({ a: 1 }))
+    assertTrue(Predicate.isReadonlyRecord({}))
+    assertTrue(Predicate.isReadonlyRecord({ a: 1 }))
 
-    assertFalse(_.isReadonlyRecord([]))
-    assertFalse(_.isReadonlyRecord([1, 2, 3]))
-    assertFalse(_.isReadonlyRecord(null))
-    assertFalse(_.isReadonlyRecord(undefined))
+    assertFalse(Predicate.isReadonlyRecord([]))
+    assertFalse(Predicate.isReadonlyRecord([1, 2, 3]))
+    assertFalse(Predicate.isReadonlyRecord(null))
+    assertFalse(Predicate.isReadonlyRecord(undefined))
   })
 
   it("isTupleOf", () => {
-    assertTrue(_.isTupleOf([1, 2, 3], 3))
-    assertFalse(_.isTupleOf([1, 2, 3], 4))
-    assertFalse(_.isTupleOf([1, 2, 3], 2))
+    assertTrue(Predicate.isTupleOf([1, 2, 3], 3))
+    assertFalse(Predicate.isTupleOf([1, 2, 3], 4))
+    assertFalse(Predicate.isTupleOf([1, 2, 3], 2))
   })
 
   it("isTupleOfAtLeast", () => {
-    assertTrue(_.isTupleOfAtLeast([1, 2, 3], 3))
-    assertTrue(_.isTupleOfAtLeast([1, 2, 3], 2))
-    assertFalse(_.isTupleOfAtLeast([1, 2, 3], 4))
+    assertTrue(Predicate.isTupleOfAtLeast([1, 2, 3], 3))
+    assertTrue(Predicate.isTupleOfAtLeast([1, 2, 3], 2))
+    assertFalse(Predicate.isTupleOfAtLeast([1, 2, 3], 4))
   })
 
   it("isRegExp", () => {
-    assertTrue(_.isRegExp(/a/))
-    assertFalse(_.isRegExp(null))
-    assertFalse(_.isRegExp("a"))
+    assertTrue(Predicate.isRegExp(/a/))
+    assertFalse(Predicate.isRegExp(null))
+    assertFalse(Predicate.isRegExp("a"))
   })
 })
diff --git a/packages/effect/test/Record.test.ts b/packages/effect/test/Record.test.ts
index e625ddea6a4..39078b51d7d 100644
--- a/packages/effect/test/Record.test.ts
+++ b/packages/effect/test/Record.test.ts
@@ -1,5 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import { Either, Number as N, Option, pipe, Record as R } from "effect"
+import { Either, Number as Num, Option, pipe, Record } from "effect"
 import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual } from "effect/test/util"
 
 const symA = Symbol.for("a")
@@ -12,17 +12,17 @@ const symbolRecord: Record<symbol, number> = { [symA]: 1, [symB]: 2 }
 describe("Record", () => {
   describe("string | symbol APIs", () => {
     it("empty", () => {
-      deepStrictEqual(R.empty(), {})
+      deepStrictEqual(Record.empty(), {})
     })
 
     it("fromIterableWith", () => {
-      deepStrictEqual(R.fromIterableWith([1, 2, 3, 4], (a) => [a === 3 ? "a" : String(a), a * 2]), {
+      deepStrictEqual(Record.fromIterableWith([1, 2, 3, 4], (a) => [a === 3 ? "a" : String(a), a * 2]), {
         "1": 2,
         "2": 4,
         a: 6,
         "4": 8
       })
-      deepStrictEqual(R.fromIterableWith([1, 2, 3, 4], (a) => [a === 3 ? symA : String(a), a * 2]), {
+      deepStrictEqual(Record.fromIterableWith([1, 2, 3, 4], (a) => [a === 3 ? symA : String(a), a * 2]), {
         "1": 2,
         "2": 4,
         [symA]: 6,
@@ -35,22 +35,22 @@ describe("Record", () => {
         { id: "2", name: "name2" },
         { id: "1", name: "name1" }
       ]
-      deepStrictEqual(R.fromIterableBy(users, (user) => user.id), {
+      deepStrictEqual(Record.fromIterableBy(users, (user) => user.id), {
         "2": { id: "2", name: "name2" },
         "1": { id: "1", name: "name1" }
       })
 
-      deepStrictEqual(R.fromIterableBy(["a", symA], (s) => s), { a: "a", [symA]: symA })
+      deepStrictEqual(Record.fromIterableBy(["a", symA], (s) => s), { a: "a", [symA]: symA })
     })
 
     it("fromEntries", () => {
-      deepStrictEqual(R.fromEntries([["1", 2], ["2", 4], ["3", 6], ["4", 8]]), {
+      deepStrictEqual(Record.fromEntries([["1", 2], ["2", 4], ["3", 6], ["4", 8]]), {
         "1": 2,
         "2": 4,
         "3": 6,
         "4": 8
       })
-      deepStrictEqual(R.fromEntries([["1", 2], ["2", 4], ["3", 6], ["4", 8], [symA, 10], [symB, 12]]), {
+      deepStrictEqual(Record.fromEntries([["1", 2], ["2", 4], ["3", 6], ["4", 8], [symA, 10], [symB, 12]]), {
         "1": 2,
         "2": 4,
         "3": 6,
@@ -61,247 +61,247 @@ describe("Record", () => {
     })
 
     it("has", () => {
-      assertTrue(R.has(stringRecord, "a"))
-      assertFalse(R.has(stringRecord, "c"))
+      assertTrue(Record.has(stringRecord, "a"))
+      assertFalse(Record.has(stringRecord, "c"))
 
-      assertTrue(R.has(symbolRecord, symA))
-      assertFalse(R.has(symbolRecord, symC))
+      assertTrue(Record.has(symbolRecord, symA))
+      assertFalse(Record.has(symbolRecord, symC))
     })
 
     it("get", () => {
-      assertNone(pipe(R.empty<string>(), R.get("a")))
-      assertSome(pipe(stringRecord, R.get("a")), 1)
+      assertNone(pipe(Record.empty<string>(), Record.get("a")))
+      assertSome(pipe(stringRecord, Record.get("a")), 1)
 
-      assertNone(pipe(R.empty<symbol>(), R.get(symA)))
-      assertSome(pipe(symbolRecord, R.get(symA)), 1)
+      assertNone(pipe(Record.empty<symbol>(), Record.get(symA)))
+      assertSome(pipe(symbolRecord, Record.get(symA)), 1)
     })
 
     it("modify", () => {
-      deepStrictEqual(pipe(R.empty<string>(), R.modify("a", (n: number) => n + 1)), {})
-      deepStrictEqual(pipe(stringRecord, R.modify("a", (n: number) => n + 1)), { a: 2, [symA]: null })
-      deepStrictEqual(pipe(stringRecord, R.modify("a", (n: number) => String(n))), { a: "1", [symA]: null })
+      deepStrictEqual(pipe(Record.empty<string>(), Record.modify("a", (n: number) => n + 1)), {})
+      deepStrictEqual(pipe(stringRecord, Record.modify("a", (n: number) => n + 1)), { a: 2, [symA]: null })
+      deepStrictEqual(pipe(stringRecord, Record.modify("a", (n: number) => String(n))), { a: "1", [symA]: null })
 
-      deepStrictEqual(pipe(R.empty<symbol>(), R.modify(symA, (n: number) => n + 1)), {})
-      deepStrictEqual(pipe(symbolRecord, R.modify(symA, (n: number) => n + 1)), {
+      deepStrictEqual(pipe(Record.empty<symbol>(), Record.modify(symA, (n: number) => n + 1)), {})
+      deepStrictEqual(pipe(symbolRecord, Record.modify(symA, (n: number) => n + 1)), {
         [symA]: 2,
         [symB]: 2
       })
-      deepStrictEqual(pipe(symbolRecord, R.modify(symA, (n: number) => String(n))), { [symA]: "1", [symB]: 2 })
+      deepStrictEqual(pipe(symbolRecord, Record.modify(symA, (n: number) => String(n))), { [symA]: "1", [symB]: 2 })
     })
 
     it("modifyOption", () => {
-      assertNone(pipe(R.empty<string>(), R.modifyOption("a", (n) => n + 1)))
-      assertSome(pipe(stringRecord, R.modifyOption("a", (n: number) => n + 1)), { a: 2, [symA]: null })
-      assertSome(pipe(stringRecord, R.modifyOption("a", (n: number) => String(n))), { a: "1", [symA]: null })
+      assertNone(pipe(Record.empty<string>(), Record.modifyOption("a", (n) => n + 1)))
+      assertSome(pipe(stringRecord, Record.modifyOption("a", (n: number) => n + 1)), { a: 2, [symA]: null })
+      assertSome(pipe(stringRecord, Record.modifyOption("a", (n: number) => String(n))), { a: "1", [symA]: null })
 
-      assertNone(pipe(R.empty<symbol>(), R.modifyOption(symA, (n) => n + 1)))
-      assertSome(pipe(symbolRecord, R.modifyOption(symA, (n: number) => n + 1)), { [symA]: 2, [symB]: 2 })
+      assertNone(pipe(Record.empty<symbol>(), Record.modifyOption(symA, (n) => n + 1)))
+      assertSome(pipe(symbolRecord, Record.modifyOption(symA, (n: number) => n + 1)), { [symA]: 2, [symB]: 2 })
       assertSome(
-        pipe(symbolRecord, R.modifyOption(symA, (n: number) => String(n))),
+        pipe(symbolRecord, Record.modifyOption(symA, (n: number) => String(n))),
         { [symA]: "1", [symB]: 2 }
       )
     })
 
     it("replaceOption", () => {
-      assertNone(pipe(R.empty<string>(), R.replaceOption("a", 2)))
-      assertSome(pipe(stringRecord, R.replaceOption("a", 2)), { a: 2, [symA]: null })
-      assertSome(pipe(stringRecord, R.replaceOption("a", true)), { a: true, [symA]: null })
+      assertNone(pipe(Record.empty<string>(), Record.replaceOption("a", 2)))
+      assertSome(pipe(stringRecord, Record.replaceOption("a", 2)), { a: 2, [symA]: null })
+      assertSome(pipe(stringRecord, Record.replaceOption("a", true)), { a: true, [symA]: null })
 
-      assertNone(pipe(R.empty<symbol>(), R.replaceOption(symA, 2)))
-      assertSome(pipe(symbolRecord, R.replaceOption(symA, 2)), { [symA]: 2, [symB]: 2 })
-      assertSome(pipe(symbolRecord, R.replaceOption(symA, true)), { [symA]: true, [symB]: 2 })
+      assertNone(pipe(Record.empty<symbol>(), Record.replaceOption(symA, 2)))
+      assertSome(pipe(symbolRecord, Record.replaceOption(symA, 2)), { [symA]: 2, [symB]: 2 })
+      assertSome(pipe(symbolRecord, Record.replaceOption(symA, true)), { [symA]: true, [symB]: 2 })
     })
 
     it("remove", () => {
-      deepStrictEqual(R.remove(stringRecord, "a"), { [symA]: null })
-      deepStrictEqual(R.remove(stringRecord, "c"), stringRecord)
+      deepStrictEqual(Record.remove(stringRecord, "a"), { [symA]: null })
+      deepStrictEqual(Record.remove(stringRecord, "c"), stringRecord)
 
-      deepStrictEqual(R.remove(symbolRecord, symA), { [symB]: 2 })
-      deepStrictEqual(R.remove(symbolRecord, symC), symbolRecord)
+      deepStrictEqual(Record.remove(symbolRecord, symA), { [symB]: 2 })
+      deepStrictEqual(Record.remove(symbolRecord, symC), symbolRecord)
     })
 
     describe("pop", () => {
       it("should return the value associated with the given key, if the key is present in the record", () => {
-        const result1 = R.pop(stringRecord, "a")
+        const result1 = Record.pop(stringRecord, "a")
         assertSome(result1, [1, { [symA]: null }])
 
-        const result2 = R.pop(symbolRecord, symA)
+        const result2 = Record.pop(symbolRecord, symA)
         assertSome(result2, [1, { [symB]: 2 }])
       })
 
       it("should return none if the key is not present in the record", () => {
-        const result1 = R.pop(stringRecord, "c")
+        const result1 = Record.pop(stringRecord, "c")
         assertNone(result1)
 
-        const result2 = R.pop(symbolRecord, symC)
+        const result2 = Record.pop(symbolRecord, symC)
         assertNone(result2)
       })
     })
 
     describe("set", () => {
       it("should replace an existing value", () => {
-        deepStrictEqual(R.set(stringRecord, "a", 2), { a: 2, [symA]: null })
+        deepStrictEqual(Record.set(stringRecord, "a", 2), { a: 2, [symA]: null })
 
-        deepStrictEqual(R.set(symbolRecord, symA, 2), { [symA]: 2, [symB]: 2 })
+        deepStrictEqual(Record.set(symbolRecord, symA, 2), { [symA]: 2, [symB]: 2 })
       })
 
       it("should add the key / value pair", () => {
-        deepStrictEqual(R.set(stringRecord, "c", 3), { a: 1, [symA]: null, c: 3 })
+        deepStrictEqual(Record.set(stringRecord, "c", 3), { a: 1, [symA]: null, c: 3 })
 
-        deepStrictEqual(R.set(symbolRecord, symC, 3), { [symA]: 1, [symB]: 2, [symC]: 3 })
+        deepStrictEqual(Record.set(symbolRecord, symC, 3), { [symA]: 1, [symB]: 2, [symC]: 3 })
       })
     })
 
     it("replace", () => {
-      deepStrictEqual(R.replace(stringRecord, "c", 3), stringRecord)
-      deepStrictEqual(R.replace(stringRecord, "a", 2), { a: 2, [symA]: null })
+      deepStrictEqual(Record.replace(stringRecord, "c", 3), stringRecord)
+      deepStrictEqual(Record.replace(stringRecord, "a", 2), { a: 2, [symA]: null })
 
-      deepStrictEqual(R.replace(symbolRecord, symC, 3), symbolRecord)
-      deepStrictEqual(R.replace(symbolRecord, symA, 2), { [symA]: 2, [symB]: 2 })
+      deepStrictEqual(Record.replace(symbolRecord, symC, 3), symbolRecord)
+      deepStrictEqual(Record.replace(symbolRecord, symA, 2), { [symA]: 2, [symB]: 2 })
     })
 
     it("singleton", () => {
-      deepStrictEqual(R.singleton("a", 1), { a: 1 })
+      deepStrictEqual(Record.singleton("a", 1), { a: 1 })
 
-      deepStrictEqual(R.singleton(symA, 1), { [symA]: 1 })
+      deepStrictEqual(Record.singleton(symA, 1), { [symA]: 1 })
     })
   })
 
   describe("string only APIs", () => {
     it("map", () => {
-      deepStrictEqual(pipe(stringRecord, R.map((n) => n * 2)), { a: 2, [symA]: null })
-      deepStrictEqual(pipe(stringRecord, R.map((n, k) => `${k}-${n}`)), { a: "a-1", [symA]: null })
+      deepStrictEqual(pipe(stringRecord, Record.map((n) => n * 2)), { a: 2, [symA]: null })
+      deepStrictEqual(pipe(stringRecord, Record.map((n, k) => `${k}-${n}`)), { a: "a-1", [symA]: null })
     })
 
     it("collect", () => {
       const x = { a: 1, b: 2, c: 3, [symA]: null }
-      deepStrictEqual(R.collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]])
+      deepStrictEqual(Record.collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]])
     })
 
     it("toEntries", () => {
       const x = { a: 1, b: 2, c: 3, [symA]: null }
-      deepStrictEqual(R.toEntries(x), [["a", 1], ["b", 2], ["c", 3]])
+      deepStrictEqual(Record.toEntries(x), [["a", 1], ["b", 2], ["c", 3]])
     })
 
     it("filterMap", () => {
       const x: Record<string, number> = { a: 1, b: 2, c: 3, [symA]: null }
-      const filtered = R.filterMap(x, (value, key) => (value > 2 ? Option.some(key) : Option.none()))
+      const filtered = Record.filterMap(x, (value, key) => (value > 2 ? Option.some(key) : Option.none()))
       deepStrictEqual(filtered, { c: "c" })
     })
 
     it("getSomes", () => {
       const x = { a: Option.some(1), b: Option.none(), c: Option.some(2), [symA]: null }
-      deepStrictEqual(R.getSomes(x), { a: 1, c: 2 })
+      deepStrictEqual(Record.getSomes(x), { a: 1, c: 2 })
     })
 
     it("filter", () => {
       const x: Record<string, number> = { a: 1, b: 2, c: 3, d: 4, [symA]: null }
-      deepStrictEqual(R.filter(x, (value) => value > 2), { c: 3, d: 4 })
+      deepStrictEqual(Record.filter(x, (value) => value > 2), { c: 3, d: 4 })
     })
 
     it("partitionMap", () => {
       const f = (n: number) => (n > 2 ? Either.right(n + 1) : Either.left(n - 1))
-      deepStrictEqual(R.partitionMap({}, f), [{}, {}])
-      deepStrictEqual(R.partitionMap({ a: 1, b: 3, [symA]: null }, f), [{ a: 0 }, { b: 4 }])
+      deepStrictEqual(Record.partitionMap({}, f), [{}, {}])
+      deepStrictEqual(Record.partitionMap({ a: 1, b: 3, [symA]: null }, f), [{ a: 0 }, { b: 4 }])
     })
 
     it("partition", () => {
       const f = (n: number) => n > 2
-      deepStrictEqual(R.partition({}, f), [{}, {}])
-      deepStrictEqual(R.partition({ a: 1, b: 3, [symA]: null }, f), [{ a: 1 }, { b: 3 }])
+      deepStrictEqual(Record.partition({}, f), [{}, {}])
+      deepStrictEqual(Record.partition({ a: 1, b: 3, [symA]: null }, f), [{ a: 1 }, { b: 3 }])
     })
 
     it("separate", () => {
       deepStrictEqual(
-        R.separate({ a: Either.left("e"), b: Either.right(1), [symA]: null }),
+        Record.separate({ a: Either.left("e"), b: Either.right(1), [symA]: null }),
         [{ a: "e" }, { b: 1 }]
       )
       // should ignore non own properties
-      const o: R.ReadonlyRecord<"a", Either.Either<number, string>> = Object.create({ a: 1 })
-      deepStrictEqual(pipe(o, R.separate), [{}, {}])
+      const o: Record.ReadonlyRecord<"a", Either.Either<number, string>> = Object.create({ a: 1 })
+      deepStrictEqual(pipe(o, Record.separate), [{}, {}])
     })
 
     it("isEmptyRecord", () => {
-      deepStrictEqual(R.isEmptyRecord({}), true)
-      deepStrictEqual(R.isEmptyRecord({ [symA]: null }), true)
-      deepStrictEqual(R.isEmptyRecord({ a: 3 }), false)
+      deepStrictEqual(Record.isEmptyRecord({}), true)
+      deepStrictEqual(Record.isEmptyRecord({ [symA]: null }), true)
+      deepStrictEqual(Record.isEmptyRecord({ a: 3 }), false)
     })
 
     it("isEmptyReadonlyRecord", () => {
-      deepStrictEqual(R.isEmptyReadonlyRecord({}), true)
-      deepStrictEqual(R.isEmptyReadonlyRecord({ [symA]: null }), true)
-      deepStrictEqual(R.isEmptyReadonlyRecord({ a: 3 }), false)
+      deepStrictEqual(Record.isEmptyReadonlyRecord({}), true)
+      deepStrictEqual(Record.isEmptyReadonlyRecord({ [symA]: null }), true)
+      deepStrictEqual(Record.isEmptyReadonlyRecord({ a: 3 }), false)
     })
 
     it("size", () => {
-      deepStrictEqual(R.size({ a: "a", b: 1, c: true, [symA]: null }), 3)
+      deepStrictEqual(Record.size({ a: "a", b: 1, c: true, [symA]: null }), 3)
     })
 
     it("keys", () => {
-      deepStrictEqual(R.keys({ a: 1, b: 2, [symA]: null }), ["a", "b"])
+      deepStrictEqual(Record.keys({ a: 1, b: 2, [symA]: null }), ["a", "b"])
     })
 
     it("values", () => {
-      deepStrictEqual(R.values({ a: 1, b: 2, [symA]: null }), [1, 2])
+      deepStrictEqual(Record.values({ a: 1, b: 2, [symA]: null }), [1, 2])
     })
 
     it("isSubrecord", () => {
-      assertTrue(R.isSubrecord(R.empty(), {}))
-      assertTrue(R.isSubrecord(R.empty<string>(), { a: 1 }))
-      assertTrue(R.isSubrecord({ a: 1 }, { a: 1 }))
-      assertTrue(R.isSubrecord(stringRecord, { a: 1 }))
-      assertTrue(R.isSubrecord({ a: 1 }, stringRecord))
-      assertTrue(R.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }))
-      assertTrue(R.isSubrecord({ b: 2, a: 1 }, { a: 1, b: 2 }))
-      assertFalse(R.isSubrecord({ a: 1 }, { a: 2 }))
-      assertFalse(R.isSubrecord({ b: 2 } as Record<string, number>, { a: 1 }))
+      assertTrue(Record.isSubrecord(Record.empty(), {}))
+      assertTrue(Record.isSubrecord(Record.empty<string>(), { a: 1 }))
+      assertTrue(Record.isSubrecord({ a: 1 }, { a: 1 }))
+      assertTrue(Record.isSubrecord(stringRecord, { a: 1 }))
+      assertTrue(Record.isSubrecord({ a: 1 }, stringRecord))
+      assertTrue(Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }))
+      assertTrue(Record.isSubrecord({ b: 2, a: 1 }, { a: 1, b: 2 }))
+      assertFalse(Record.isSubrecord({ a: 1 }, { a: 2 }))
+      assertFalse(Record.isSubrecord({ b: 2 } as Record<string, number>, { a: 1 }))
     })
 
     it("reduce", () => {
       // data-first
       deepStrictEqual(
-        R.reduce({ k1: "a", k2: "b", [symA]: null }, "-", (accumulator, value, key) => accumulator + key + value),
+        Record.reduce({ k1: "a", k2: "b", [symA]: null }, "-", (accumulator, value, key) => accumulator + key + value),
         "-k1ak2b"
       )
       // data-last
       deepStrictEqual(
         pipe(
           { k1: "a", k2: "b", [symA]: null },
-          R.reduce("-", (accumulator, value, key) => accumulator + key + value)
+          Record.reduce("-", (accumulator, value, key) => accumulator + key + value)
         ),
         "-k1ak2b"
       )
     })
 
     it("every", () => {
-      assertTrue(R.every((n: number) => n <= 2)({ a: 1, b: 2, [symA]: null }))
-      assertFalse(R.every((n: number) => n <= 1)({ a: 1, b: 2, [symA]: null }))
+      assertTrue(Record.every((n: number) => n <= 2)({ a: 1, b: 2, [symA]: null }))
+      assertFalse(Record.every((n: number) => n <= 1)({ a: 1, b: 2, [symA]: null }))
     })
 
     it("some", () => {
-      assertTrue(R.some((n: number) => n <= 1)({ a: 1, b: 2, [symA]: null }))
-      assertFalse(R.some((n: number) => n <= 0)({ a: 1, b: 2, [symA]: null }))
+      assertTrue(Record.some((n: number) => n <= 1)({ a: 1, b: 2, [symA]: null }))
+      assertFalse(Record.some((n: number) => n <= 0)({ a: 1, b: 2, [symA]: null }))
     })
 
     it("union", () => {
       const combine = (s1: string, s2: string) => s1 + s2
-      const x: R.ReadonlyRecord<string, string> = {
+      const x: Record.ReadonlyRecord<string, string> = {
         a: "a1",
         b: "b1",
         c: "c1",
         [symA]: null
       }
-      const y: R.ReadonlyRecord<string, string> = {
+      const y: Record.ReadonlyRecord<string, string> = {
         b: "b2",
         c: "c2",
         d: "d2",
         [symA]: null
       }
-      deepStrictEqual(R.union(x, {}, combine), x)
-      deepStrictEqual(R.union({}, x, combine), x)
-      deepStrictEqual(R.union(x, {}, combine), x)
-      deepStrictEqual(R.union({}, x, combine), x)
-      deepStrictEqual(R.union(x, y, combine), {
+      deepStrictEqual(Record.union(x, {}, combine), x)
+      deepStrictEqual(Record.union({}, x, combine), x)
+      deepStrictEqual(Record.union(x, {}, combine), x)
+      deepStrictEqual(Record.union({}, x, combine), x)
+      deepStrictEqual(Record.union(x, y, combine), {
         a: "a1",
         b: "b1b2",
         c: "c1c2",
@@ -311,67 +311,67 @@ describe("Record", () => {
 
     it("intersection", () => {
       const combine = (s1: string, s2: string) => s1 + s2
-      const x: R.ReadonlyRecord<string, string> = {
+      const x: Record.ReadonlyRecord<string, string> = {
         a: "a1",
         b: "b1",
         c: "c1",
         [symA]: null
       }
-      const y: R.ReadonlyRecord<string, string> = {
+      const y: Record.ReadonlyRecord<string, string> = {
         b: "b2",
         c: "c2",
         d: "d2",
         [symA]: null
       }
-      deepStrictEqual(R.intersection(x, {}, combine), {})
-      deepStrictEqual(R.intersection({}, y, combine), {})
-      deepStrictEqual(R.intersection(x, y, combine), {
+      deepStrictEqual(Record.intersection(x, {}, combine), {})
+      deepStrictEqual(Record.intersection({}, y, combine), {})
+      deepStrictEqual(Record.intersection(x, y, combine), {
         b: "b1b2",
         c: "c1c2"
       })
     })
 
     it("difference", () => {
-      const x: R.ReadonlyRecord<string, string> = {
+      const x: Record.ReadonlyRecord<string, string> = {
         a: "a1",
         b: "b1",
         c: "c1",
         [symA]: null
       }
-      const y: R.ReadonlyRecord<string, string> = {
+      const y: Record.ReadonlyRecord<string, string> = {
         b: "b2",
         c: "c2",
         d: "d2",
         [symA]: null
       }
-      deepStrictEqual(R.difference({}, x), x)
-      deepStrictEqual(R.difference(x, {}), x)
-      deepStrictEqual(R.difference({}, x), x)
-      deepStrictEqual(R.difference(x, {}), x)
-      deepStrictEqual(R.difference(x, y), {
+      deepStrictEqual(Record.difference({}, x), x)
+      deepStrictEqual(Record.difference(x, {}), x)
+      deepStrictEqual(Record.difference({}, x), x)
+      deepStrictEqual(Record.difference(x, {}), x)
+      deepStrictEqual(Record.difference(x, y), {
         a: "a1",
         d: "d2"
       })
     })
 
     it("getEquivalence", () => {
-      deepStrictEqual(R.getEquivalence(N.Equivalence)({ a: 1 }, { a: 1 }), true)
-      deepStrictEqual(R.getEquivalence(N.Equivalence)({ a: 1 }, stringRecord), true)
-      deepStrictEqual(R.getEquivalence(N.Equivalence)({ a: 1 }, { a: 2 }), false)
-      deepStrictEqual(R.getEquivalence(N.Equivalence)({ a: 1 }, { b: 1 }), false)
+      deepStrictEqual(Record.getEquivalence(Num.Equivalence)({ a: 1 }, { a: 1 }), true)
+      deepStrictEqual(Record.getEquivalence(Num.Equivalence)({ a: 1 }, stringRecord), true)
+      deepStrictEqual(Record.getEquivalence(Num.Equivalence)({ a: 1 }, { a: 2 }), false)
+      deepStrictEqual(Record.getEquivalence(Num.Equivalence)({ a: 1 }, { b: 1 }), false)
       const noPrototype = Object.create(null)
-      deepStrictEqual(R.getEquivalence(N.Equivalence)(noPrototype, { b: 1 }), false)
+      deepStrictEqual(Record.getEquivalence(Num.Equivalence)(noPrototype, { b: 1 }), false)
     })
 
     it("mapKeys", () => {
-      deepStrictEqual(pipe({ a: 1, b: 2, [symA]: null }, R.mapKeys((key) => key.toUpperCase())), {
+      deepStrictEqual(pipe({ a: 1, b: 2, [symA]: null }, Record.mapKeys((key) => key.toUpperCase())), {
         A: 1,
         B: 2
       })
     })
 
     it("mapEntries", () => {
-      deepStrictEqual(pipe(stringRecord, R.mapEntries((a, key) => [key.toUpperCase(), a + 1])), { A: 2 })
+      deepStrictEqual(pipe(stringRecord, Record.mapEntries((a, key) => [key.toUpperCase(), a + 1])), { A: 2 })
     })
   })
 })
diff --git a/packages/effect/test/Schema/Schema/Class/TaggedError.test.ts b/packages/effect/test/Schema/Schema/Class/TaggedError.test.ts
index f34281652ca..6eddcce9edc 100644
--- a/packages/effect/test/Schema/Schema/Class/TaggedError.test.ts
+++ b/packages/effect/test/Schema/Schema/Class/TaggedError.test.ts
@@ -2,7 +2,7 @@ import { describe, it } from "@effect/vitest"
 import { Cause, Effect, Inspectable, Schema } from "effect"
 import * as S from "effect/Schema"
 import * as Util from "effect/test/Schema/TestUtils"
-import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { assertIncludes, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
 describe("TaggedError", () => {
   it("should expose the fields and the tag", () => {
@@ -51,7 +51,7 @@ describe("TaggedError", () => {
     let err = new MyError({ id: 1 })
 
     strictEqual(String(err), `MyError: { "id": 1 }`)
-    assertTrue(err.stack?.includes("TaggedError.test.ts:"))
+    assertIncludes(err.stack, "TaggedError.test.ts:")
     strictEqual(err._tag, "MyError")
     strictEqual(err.id, 1)
 
@@ -75,8 +75,8 @@ describe("TaggedError", () => {
 
     const err = new MyError({ id: 1 })
 
-    assertTrue(String(err).includes(`MyError: bad id: 1`))
-    assertTrue(err.stack?.includes("TaggedError.test.ts:"))
+    assertIncludes(String(err), `MyError: bad id: 1`)
+    assertIncludes(err.stack, "TaggedError.test.ts:")
     strictEqual(err._tag, "MyError")
     strictEqual(err.id, 1)
   })
@@ -90,8 +90,8 @@ describe("TaggedError", () => {
 
     const err = new MyError({ id: 1, message: "boom" })
 
-    assertTrue(String(err).includes(`MyError: boom`))
-    assertTrue(err.stack?.includes("TaggedError.test.ts:"))
+    assertIncludes(String(err), `MyError: boom`)
+    assertIncludes(err.stack, "TaggedError.test.ts:")
     strictEqual(err._tag, "MyError")
     strictEqual(err.id, 1)
   })
@@ -116,7 +116,7 @@ describe("TaggedError", () => {
     }) {}
 
     const err = new MyError({ cause: new Error("child") })
-    assertTrue(Cause.pretty(Cause.fail(err), { renderErrorCause: true }).includes("[cause]: Error: child"))
+    assertIncludes(Cause.pretty(Cause.fail(err), { renderErrorCause: true }), "[cause]: Error: child")
     // ensure node renders the error directly
     deepStrictEqual(err[Inspectable.NodeInspectSymbol](), err)
   })
diff --git a/packages/effect/test/Schema/Schema/decodeUnknownSync.test.ts b/packages/effect/test/Schema/Schema/decodeUnknownSync.test.ts
index 966231fd395..e9d3a23d8e1 100644
--- a/packages/effect/test/Schema/Schema/decodeUnknownSync.test.ts
+++ b/packages/effect/test/Schema/Schema/decodeUnknownSync.test.ts
@@ -2,7 +2,7 @@ import { describe, it } from "@effect/vitest"
 import * as ParseResult from "effect/ParseResult"
 import * as S from "effect/Schema"
 import * as Util from "effect/test/Schema/TestUtils"
-import { assertTrue } from "effect/test/util"
+import { assertIncludes, assertTrue } from "effect/test/util"
 
 describe("decodeUnknownSync", () => {
   it("the returned error should be a ParseError", () => {
@@ -26,7 +26,7 @@ describe("decodeUnknownSync", () => {
       S.decodeUnknownSync(Util.DependencyString as any)("a")
       throw new Error("unexpected success")
     } catch (e: any) {
-      assertTrue((e.message as string).includes("Service not found: Name"))
+      assertIncludes(e.message, "Service not found: Name")
     }
   })
 })
diff --git a/packages/effect/test/SortedMap.test.ts b/packages/effect/test/SortedMap.test.ts
index 9d827cfecaa..1bce2e658fa 100644
--- a/packages/effect/test/SortedMap.test.ts
+++ b/packages/effect/test/SortedMap.test.ts
@@ -1,5 +1,5 @@
 import { describe, it } from "@effect/vitest"
-import { Equal, Hash, Number as N, pipe, SortedMap as SM } from "effect"
+import { Equal, Hash, Number as Num, pipe, SortedMap as SM } from "effect"
 import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
 class Key implements Equal.Equal {
@@ -117,7 +117,7 @@ describe("SortedMap", () => {
 
   it("headOption", () => {
     const map1 = makeSortedMap([0, 10], [1, 20], [2, 30])
-    const map2 = SM.empty<number, number>(N.Order)
+    const map2 = SM.empty<number, number>(Num.Order)
 
     assertSome(SM.headOption(map1), [key(0), value(10)])
     assertNone(SM.headOption(map2))
@@ -125,7 +125,7 @@ describe("SortedMap", () => {
 
   it("lastOption", () => {
     const map1 = makeSortedMap([0, 10], [1, 20], [2, 30])
-    const map2 = SM.empty<number, number>(N.Order)
+    const map2 = SM.empty<number, number>(Num.Order)
 
     assertSome(SM.lastOption(map1), [key(2), value(30)])
     assertNone(SM.lastOption(map2))
@@ -133,7 +133,7 @@ describe("SortedMap", () => {
 
   it("isEmpty", () => {
     const map1 = makeSortedMap([0, 10], [1, 20], [2, 30])
-    const map2 = SM.empty<number, number>(N.Order)
+    const map2 = SM.empty<number, number>(Num.Order)
 
     assertFalse(SM.isEmpty(map1))
     assertTrue(SM.isEmpty(map2))
@@ -141,7 +141,7 @@ describe("SortedMap", () => {
 
   it("isNonEmpty", () => {
     const map1 = makeSortedMap([0, 10], [1, 20], [2, 30])
-    const map2 = SM.empty<number, number>(N.Order)
+    const map2 = SM.empty<number, number>(Num.Order)
 
     assertTrue(SM.isNonEmpty(map1))
     assertFalse(SM.isNonEmpty(map2))
diff --git a/packages/effect/test/String.test.ts b/packages/effect/test/String.test.ts
index 66a578f4219..c311c9b260c 100644
--- a/packages/effect/test/String.test.ts
+++ b/packages/effect/test/String.test.ts
@@ -1,26 +1,26 @@
 import { describe, it } from "@effect/vitest"
-import { Order, pipe, String as S } from "effect"
+import { Order, pipe, String as Str } from "effect"
 import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
 
 describe("String", () => {
   it("isString", () => {
-    assertTrue(S.isString("a"))
-    assertFalse(S.isString(1))
-    assertFalse(S.isString(true))
+    assertTrue(Str.isString("a"))
+    assertFalse(Str.isString(1))
+    assertFalse(Str.isString(true))
   })
 
   it("empty", () => {
-    strictEqual(S.empty, "")
+    strictEqual(Str.empty, "")
   })
 
   it("Equivalence", () => {
-    assertTrue(S.Equivalence("a", "a"))
-    assertFalse(S.Equivalence("a", "b"))
+    assertTrue(Str.Equivalence("a", "a"))
+    assertFalse(Str.Equivalence("a", "b"))
   })
 
   it("Order", () => {
-    const lessThan = Order.lessThan(S.Order)
-    const lessThanOrEqualTo = Order.lessThanOrEqualTo(S.Order)
+    const lessThan = Order.lessThan(Str.Order)
+    const lessThanOrEqualTo = Order.lessThanOrEqualTo(Str.Order)
     assertTrue(pipe("a", lessThan("b")))
     assertFalse(pipe("a", lessThan("a")))
     assertTrue(pipe("a", lessThanOrEqualTo("a")))
@@ -29,219 +29,219 @@ describe("String", () => {
   })
 
   it("concat", () => {
-    strictEqual(pipe("a", S.concat("b")), "ab")
+    strictEqual(pipe("a", Str.concat("b")), "ab")
   })
 
   it("isEmpty", () => {
-    assertTrue(S.isEmpty(""))
-    assertFalse(S.isEmpty("a"))
+    assertTrue(Str.isEmpty(""))
+    assertFalse(Str.isEmpty("a"))
   })
 
   it("isNonEmpty", () => {
-    assertFalse(S.isNonEmpty(""))
-    assertTrue(S.isNonEmpty("a"))
+    assertFalse(Str.isNonEmpty(""))
+    assertTrue(Str.isNonEmpty("a"))
   })
 
   it("length", () => {
-    strictEqual(S.length(""), 0)
-    strictEqual(S.length("a"), 1)
-    strictEqual(S.length("aaa"), 3)
+    strictEqual(Str.length(""), 0)
+    strictEqual(Str.length("a"), 1)
+    strictEqual(Str.length("aaa"), 3)
   })
 
   it("toUpperCase", () => {
-    strictEqual(S.toUpperCase("a"), "A")
+    strictEqual(Str.toUpperCase("a"), "A")
   })
 
   it("toLowerCase", () => {
-    strictEqual(S.toLowerCase("A"), "a")
+    strictEqual(Str.toLowerCase("A"), "a")
   })
 
   it("capitalize", () => {
-    strictEqual(S.capitalize(""), "")
-    strictEqual(S.capitalize("abc"), "Abc")
+    strictEqual(Str.capitalize(""), "")
+    strictEqual(Str.capitalize("abc"), "Abc")
   })
 
   it("uncapitalize", () => {
-    strictEqual(S.uncapitalize(""), "")
-    strictEqual(S.uncapitalize("Abc"), "abc")
+    strictEqual(Str.uncapitalize(""), "")
+    strictEqual(Str.uncapitalize("Abc"), "abc")
   })
 
   it("replace", () => {
-    strictEqual(pipe("abc", S.replace("b", "d")), "adc")
+    strictEqual(pipe("abc", Str.replace("b", "d")), "adc")
   })
 
   it("split", () => {
-    deepStrictEqual(pipe("abc", S.split("")), ["a", "b", "c"])
-    deepStrictEqual(pipe("", S.split("")), [""])
+    deepStrictEqual(pipe("abc", Str.split("")), ["a", "b", "c"])
+    deepStrictEqual(pipe("", Str.split("")), [""])
   })
 
   it("trim", () => {
-    strictEqual(pipe(" a ", S.trim), "a")
+    strictEqual(pipe(" a ", Str.trim), "a")
   })
 
   it("trimStart", () => {
-    strictEqual(pipe(" a ", S.trimStart), "a ")
+    strictEqual(pipe(" a ", Str.trimStart), "a ")
   })
 
   it("trimEnd", () => {
-    strictEqual(pipe(" a ", S.trimEnd), " a")
+    strictEqual(pipe(" a ", Str.trimEnd), " a")
   })
 
   it("includes", () => {
-    assertTrue(pipe("abc", S.includes("b")))
-    assertFalse(pipe("abc", S.includes("d")))
-    assertTrue(pipe("abc", S.includes("b", 1)))
-    assertFalse(pipe("abc", S.includes("a", 1)))
+    assertTrue(pipe("abc", Str.includes("b")))
+    assertFalse(pipe("abc", Str.includes("d")))
+    assertTrue(pipe("abc", Str.includes("b", 1)))
+    assertFalse(pipe("abc", Str.includes("a", 1)))
   })
 
   it("startsWith", () => {
-    assertTrue(pipe("abc", S.startsWith("a")))
-    assertFalse(pipe("bc", S.startsWith("a")))
-    assertTrue(pipe("abc", S.startsWith("b", 1)))
-    assertFalse(pipe("bc", S.startsWith("a", 1)))
+    assertTrue(pipe("abc", Str.startsWith("a")))
+    assertFalse(pipe("bc", Str.startsWith("a")))
+    assertTrue(pipe("abc", Str.startsWith("b", 1)))
+    assertFalse(pipe("bc", Str.startsWith("a", 1)))
   })
 
   it("endsWith", () => {
-    assertTrue(pipe("abc", S.endsWith("c")))
-    assertFalse(pipe("ab", S.endsWith("c")))
-    assertTrue(pipe("abc", S.endsWith("b", 2)))
-    assertFalse(pipe("abc", S.endsWith("c", 2)))
+    assertTrue(pipe("abc", Str.endsWith("c")))
+    assertFalse(pipe("ab", Str.endsWith("c")))
+    assertTrue(pipe("abc", Str.endsWith("b", 2)))
+    assertFalse(pipe("abc", Str.endsWith("c", 2)))
   })
 
   it("slice", () => {
-    deepStrictEqual(pipe("abcd", S.slice(1, 3)), "bc")
+    deepStrictEqual(pipe("abcd", Str.slice(1, 3)), "bc")
   })
 
   it("charCodeAt", () => {
-    assertSome(pipe("abc", S.charCodeAt(1)), 98)
-    assertNone(pipe("abc", S.charCodeAt(4)))
+    assertSome(pipe("abc", Str.charCodeAt(1)), 98)
+    assertNone(pipe("abc", Str.charCodeAt(4)))
   })
 
   it("substring", () => {
-    strictEqual(pipe("abcd", S.substring(1)), "bcd")
-    strictEqual(pipe("abcd", S.substring(1, 3)), "bc")
+    strictEqual(pipe("abcd", Str.substring(1)), "bcd")
+    strictEqual(pipe("abcd", Str.substring(1, 3)), "bc")
   })
 
   it("at", () => {
-    assertSome(pipe("abc", S.at(1)), "b")
-    assertNone(pipe("abc", S.at(4)))
+    assertSome(pipe("abc", Str.at(1)), "b")
+    assertNone(pipe("abc", Str.at(4)))
   })
 
   it("charAt", () => {
-    assertSome(pipe("abc", S.charAt(1)), "b")
-    assertNone(pipe("abc", S.charAt(4)))
+    assertSome(pipe("abc", Str.charAt(1)), "b")
+    assertNone(pipe("abc", Str.charAt(4)))
   })
 
   it("codePointAt", () => {
-    assertSome(pipe("abc", S.codePointAt(1)), 98)
-    assertNone(pipe("abc", S.codePointAt(4)))
+    assertSome(pipe("abc", Str.codePointAt(1)), 98)
+    assertNone(pipe("abc", Str.codePointAt(4)))
   })
 
   it("indexOf", () => {
-    assertSome(pipe("abbbc", S.indexOf("b")), 1)
-    assertNone(pipe("abbbc", S.indexOf("d")))
+    assertSome(pipe("abbbc", Str.indexOf("b")), 1)
+    assertNone(pipe("abbbc", Str.indexOf("d")))
   })
 
   it("lastIndexOf", () => {
-    assertSome(pipe("abbbc", S.lastIndexOf("b")), 3)
-    assertNone(pipe("abbbc", S.lastIndexOf("d")))
+    assertSome(pipe("abbbc", Str.lastIndexOf("b")), 3)
+    assertNone(pipe("abbbc", Str.lastIndexOf("d")))
   })
 
   it("localeCompare", () => {
-    strictEqual(pipe("a", S.localeCompare("b")), -1)
-    strictEqual(pipe("b", S.localeCompare("a")), 1)
-    strictEqual(pipe("a", S.localeCompare("a")), 0)
+    strictEqual(pipe("a", Str.localeCompare("b")), -1)
+    strictEqual(pipe("b", Str.localeCompare("a")), 1)
+    strictEqual(pipe("a", Str.localeCompare("a")), 0)
   })
 
   it("match", () => {
-    assertSome(pipe("a", S.match(/a/)), "a".match(/a/))
-    assertNone(pipe("a", S.match(/b/)))
+    assertSome(pipe("a", Str.match(/a/)), "a".match(/a/))
+    assertNone(pipe("a", Str.match(/b/)))
   })
 
   it("matchAll", () => {
-    strictEqual(Array.from(pipe("apple, banana", S.matchAll(/a[pn]/g))).length, 3)
-    strictEqual(Array.from(pipe("apple, banana", S.matchAll(/c/g))).length, 0)
+    strictEqual(Array.from(pipe("apple, banana", Str.matchAll(/a[pn]/g))).length, 3)
+    strictEqual(Array.from(pipe("apple, banana", Str.matchAll(/c/g))).length, 0)
   })
 
   it("normalize", () => {
     const str = "\u1E9B\u0323"
-    strictEqual(pipe(str, S.normalize()), "\u1E9B\u0323")
-    strictEqual(pipe(str, S.normalize("NFC")), "\u1E9B\u0323")
-    strictEqual(pipe(str, S.normalize("NFD")), "\u017F\u0323\u0307")
-    strictEqual(pipe(str, S.normalize("NFKC")), "\u1E69")
-    strictEqual(pipe(str, S.normalize("NFKD")), "\u0073\u0323\u0307")
+    strictEqual(pipe(str, Str.normalize()), "\u1E9B\u0323")
+    strictEqual(pipe(str, Str.normalize("NFC")), "\u1E9B\u0323")
+    strictEqual(pipe(str, Str.normalize("NFD")), "\u017F\u0323\u0307")
+    strictEqual(pipe(str, Str.normalize("NFKC")), "\u1E69")
+    strictEqual(pipe(str, Str.normalize("NFKD")), "\u0073\u0323\u0307")
   })
 
   it("padEnd", () => {
-    strictEqual(pipe("a", S.padEnd(5)), "a    ")
-    strictEqual(pipe("a", S.padEnd(5, "_")), "a____")
+    strictEqual(pipe("a", Str.padEnd(5)), "a    ")
+    strictEqual(pipe("a", Str.padEnd(5, "_")), "a____")
   })
 
   it("padStart", () => {
-    strictEqual(pipe("a", S.padStart(5)), "    a")
-    strictEqual(pipe("a", S.padStart(5, "_")), "____a")
+    strictEqual(pipe("a", Str.padStart(5)), "    a")
+    strictEqual(pipe("a", Str.padStart(5, "_")), "____a")
   })
 
   it("repeat", () => {
-    strictEqual(pipe("a", S.repeat(3)), "aaa")
+    strictEqual(pipe("a", Str.repeat(3)), "aaa")
   })
 
   it("replaceAll", () => {
-    strictEqual(pipe("ababb", S.replaceAll("b", "c")), "acacc")
-    strictEqual(pipe("ababb", S.replaceAll(/ba/g, "cc")), "accbb")
+    strictEqual(pipe("ababb", Str.replaceAll("b", "c")), "acacc")
+    strictEqual(pipe("ababb", Str.replaceAll(/ba/g, "cc")), "accbb")
   })
 
   it("search", () => {
-    assertSome(pipe("ababb", S.search("b")), 1)
-    assertSome(pipe("ababb", S.search(/abb/)), 2)
-    assertNone(pipe("ababb", S.search(/c/)))
+    assertSome(pipe("ababb", Str.search("b")), 1)
+    assertSome(pipe("ababb", Str.search(/abb/)), 2)
+    assertNone(pipe("ababb", Str.search(/c/)))
   })
 
   it("toLocaleLowerCase", () => {
     const locales = ["tr", "TR", "tr-TR", "tr-u-co-search", "tr-x-turkish"]
-    strictEqual(pipe("\u0130", S.toLocaleLowerCase(locales)), "i")
+    strictEqual(pipe("\u0130", Str.toLocaleLowerCase(locales)), "i")
   })
 
   it("toLocaleUpperCase", () => {
     const locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"]
-    strictEqual(pipe("i\u0307", S.toLocaleUpperCase(locales)), "I")
+    strictEqual(pipe("i\u0307", Str.toLocaleUpperCase(locales)), "I")
   })
 
   describe("takeLeft", () => {
     it("should take the specified number of characters from the left side of a string", () => {
-      strictEqual(S.takeLeft("Hello, World!", 7), "Hello, ")
+      strictEqual(Str.takeLeft("Hello, World!", 7), "Hello, ")
     })
 
     it("should return the string for `n` larger than the string length", () => {
       const string = "Hello, World!"
-      strictEqual(S.takeLeft(string, 100), string)
+      strictEqual(Str.takeLeft(string, 100), string)
     })
 
     it("should return the empty string for a negative `n`", () => {
-      strictEqual(S.takeLeft("Hello, World!", -1), "")
+      strictEqual(Str.takeLeft("Hello, World!", -1), "")
     })
 
     it("should round down if `n` is a float", () => {
-      strictEqual(S.takeLeft("Hello, World!", 5.5), "Hello")
+      strictEqual(Str.takeLeft("Hello, World!", 5.5), "Hello")
     })
   })
 
   describe("takeRight", () => {
     it("should take the specified number of characters from the right side of a string", () => {
-      strictEqual(S.takeRight("Hello, World!", 7), " World!")
+      strictEqual(Str.takeRight("Hello, World!", 7), " World!")
     })
 
     it("should return the string for `n` larger than the string length", () => {
       const string = "Hello, World!"
-      strictEqual(S.takeRight(string, 100), string)
+      strictEqual(Str.takeRight(string, 100), string)
     })
 
     it("should return the empty string for a negative `n`", () => {
-      strictEqual(S.takeRight("Hello, World!", -1), "")
+      strictEqual(Str.takeRight("Hello, World!", -1), "")
     })
 
     it("should round down if `n` is a float", () => {
-      strictEqual(S.takeRight("Hello, World!", 6.5), "World!")
+      strictEqual(Str.takeRight("Hello, World!", 6.5), "World!")
     })
   })
 
@@ -251,13 +251,13 @@ describe("String", () => {
     |Hello,
     |World!
     |`
-      const result = S.stripMargin(string)
+      const result = Str.stripMargin(string)
       strictEqual(result, "\nHello,\nWorld!\n")
     })
 
     it("should strip a leading prefix from each line using a margin character", () => {
       const string = "\n$\n    $Hello,\r\n    $World!\n $"
-      const result = S.stripMarginWith(string, "$")
+      const result = Str.stripMarginWith(string, "$")
       strictEqual(result, "\n\nHello,\r\nWorld!\n")
     })
   })
@@ -265,7 +265,7 @@ describe("String", () => {
   describe("linesWithSeparators", () => {
     it("should split a string into lines with separators", () => {
       const string = "\n$\n    $Hello,\r\n    $World!\n $"
-      const result = S.linesWithSeparators(string)
+      const result = Str.linesWithSeparators(string)
       deepStrictEqual(Array.from(result), ["\n", "$\n", "    $Hello,\r\n", "    $World!\n", " $"])
     })
   })
@@ -273,7 +273,7 @@ describe("String", () => {
   describe("linesIterator", () => {
     it("should split a string into lines", () => {
       const string = "\n$\n    $Hello,\r\n    $World!\n $"
-      const result = S.linesIterator(string)
+      const result = Str.linesIterator(string)
       deepStrictEqual(Array.from(result), ["", "$", "    $Hello,", "    $World!", " $"])
     })
   })
diff --git a/packages/effect/test/Symbol.test.ts b/packages/effect/test/Symbol.test.ts
index 066757a20d7..321efa2a52d 100644
--- a/packages/effect/test/Symbol.test.ts
+++ b/packages/effect/test/Symbol.test.ts
@@ -1,18 +1,18 @@
 import { describe, it } from "@effect/vitest"
-import * as S from "effect/Symbol"
+import { Symbol as Sym } from "effect"
 import { assertFalse, assertTrue } from "effect/test/util"
 
 describe("Symbol", () => {
   it("isSymbol", () => {
-    assertTrue(S.isSymbol(Symbol.for("effect/test/a")))
-    assertFalse(S.isSymbol(1n))
-    assertFalse(S.isSymbol(1))
-    assertFalse(S.isSymbol("a"))
-    assertFalse(S.isSymbol(true))
+    assertTrue(Sym.isSymbol(Symbol.for("effect/test/a")))
+    assertFalse(Sym.isSymbol(1n))
+    assertFalse(Sym.isSymbol(1))
+    assertFalse(Sym.isSymbol("a"))
+    assertFalse(Sym.isSymbol(true))
   })
 
   it("Equivalence", () => {
-    const eq = S.Equivalence
+    const eq = Sym.Equivalence
     assertTrue(eq(Symbol.for("effect/test/a"), Symbol.for("effect/test/a")))
     assertFalse(eq(Symbol.for("effect/test/a"), Symbol.for("effect/test/b")))
   })
diff --git a/packages/platform/test/Headers.test.ts b/packages/platform/test/Headers.test.ts
index 00f0286c7a8..d59029eb474 100644
--- a/packages/platform/test/Headers.test.ts
+++ b/packages/platform/test/Headers.test.ts
@@ -1,7 +1,7 @@
 import * as Headers from "@effect/platform/Headers"
 import { describe, it } from "@effect/vitest"
 import { Effect, FiberId, FiberRef, FiberRefs, HashSet, Inspectable, Logger, Redacted } from "effect"
-import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { assertFalse, assertIncludes, deepStrictEqual, strictEqual } from "effect/test/util"
 
 describe("Headers", () => {
   describe("Redactable", () => {
@@ -72,7 +72,7 @@ describe("Headers", () => {
         yield* Effect.log(headers).pipe(
           Effect.annotateLogs({ headers })
         )
-        assertTrue(messages[0].includes("application/json"))
+        assertIncludes(messages[0], "application/json")
         assertFalse(messages[0].includes("some-token"))
         assertFalse(messages[0].includes("some-key"))
       }))
diff --git a/packages/platform/test/HttpClient.test.ts b/packages/platform/test/HttpClient.test.ts
index 4dc64036626..6bd54a63547 100644
--- a/packages/platform/test/HttpClient.test.ts
+++ b/packages/platform/test/HttpClient.test.ts
@@ -23,7 +23,7 @@ import {
   Stream,
   Struct
 } from "effect"
-import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { assertIncludes, deepStrictEqual, strictEqual } from "effect/test/util"
 
 const Todo = Schema.Struct({
   userId: Schema.Number,
@@ -69,7 +69,7 @@ describe("HttpClient", () => {
         Effect.flatMap((_) => _.text),
         Effect.scoped
       )
-      assertTrue(response.includes("Google"))
+      assertIncludes(response, "Google")
     }).pipe(Effect.provide(FetchHttpClient.layer), Effect.runPromise))
 
   it("google withCookiesRef", () =>
@@ -105,7 +105,7 @@ describe("HttpClient", () => {
         Stream.unwrapScoped,
         Stream.runFold("", (a, b) => a + new TextDecoder().decode(b))
       )
-      assertTrue(response.includes("Google"))
+      assertIncludes(response, "Google")
     }).pipe(Effect.provide(FetchHttpClient.layer), Effect.runPromise))
 
   it("jsonplaceholder", () =>