move into internal timeout module

src/Scheduler.ts

@@ -8,6 +8,7 @@ import type { Effect } from "@effect/io/Effect"
 import type { RuntimeFiber } from "@effect/io/Fiber"
 import type { FiberRef } from "@effect/io/FiberRef"
 import * as core from "@effect/io/internal/core"
+import * as timeout from "@effect/io/internal/timeout"
 
 /**
  * @since 1.0.0
@@ -106,7 +107,7 @@ export class MixedScheduler implements Scheduler {
    */
   private starve(depth = 0) {
     if (depth >= this.maxNextTickBeforeTimer) {
-      core.setTimeout(() => this.starveInternal(0), 0)
+      timeout.set(() => this.starveInternal(0), 0)
     } else {
       Promise.resolve(void 0).then(() => this.starveInternal(depth + 1))
     }
@@ -336,14 +337,14 @@ export const makeBatched = (
  * @category constructors
  */
 export const timer = (ms: number, shouldYield: Scheduler["shouldYield"] = defaultShouldYield) =>
-  make((task) => core.setTimeout(task, ms), shouldYield)
+  make((task) => timeout.set(task, ms), shouldYield)
 
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const timerBatched = (ms: number, shouldYield: Scheduler["shouldYield"] = defaultShouldYield) =>
-  makeBatched((task) => core.setTimeout(task, ms), shouldYield)
+  makeBatched((task) => timeout.set(task, ms), shouldYield)
 
 /** @internal */
 export const currentScheduler: FiberRef<Scheduler> = globalValue(

src/internal/clock.ts

@@ -5,6 +5,7 @@ import { constFalse } from "@effect/data/Function"
 import type * as Clock from "@effect/io/Clock"
 import type * as Effect from "@effect/io/Effect"
 import * as core from "@effect/io/internal/core"
+import * as timeout from "@effect/io/internal/timeout"
 
 /** @internal */
 const ClockSymbolKey = "@effect/io/Clock"
@@ -28,12 +29,12 @@ export const globalClockScheduler: Clock.ClockScheduler = {
       return constFalse
     }
     let completed = false
-    const handle = core.setTimeout(() => {
+    const handle = timeout.set(() => {
       completed = true
       task()
     }, millis)
     return () => {
-      core.clearTimeout(handle)
+      timeout.clear(handle)
       return !completed
     }
   }

src/internal/core.ts

@@ -2729,33 +2729,3 @@ const deferredInterruptJoiner = <E, A>(
       )
     }
   })
-
-// -----------------------------------------------------------------------------
-// Timeout
-// -----------------------------------------------------------------------------
-
-/**
- * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
- *
- * @see https://github.com/oven-sh/bun/issues/3333
- */
-
-/** @internal */
-const isBun = !!((process as any)?.isBun)
-
-/** @internal */
-const clearTimeout_: (id: NodeJS.Timeout) => void = isBun ? clearInterval : clearTimeout
-
-/** @internal */
-const setTimeout_: (fn: () => void, ms: number) => NodeJS.Timeout = isBun ?
-  (fn: () => void, ms: number) => {
-    const id = setInterval(() => {
-      fn()
-      clearInterval(id)
-    }, ms)
-
-    return id
-  } :
-  setTimeout
-
-export { clearTimeout_ as clearTimeout, setTimeout_ as setTimeout }

src/internal/timeout.ts

@@ -1,4 +1,23 @@
-import * as core from "@effect/io/internal/core"
+/**
+ * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
+ *
+ * @see https://github.com/oven-sh/bun/issues/3333
+ */
 
-export const set = core.setTimeout
-export const clear = core.clearTimeout
+/** @internal */
+const isBun = !!((process as any)?.isBun)
+
+/** @internal */
+export const clear: (id: NodeJS.Timeout) => void = isBun ? clearInterval : clearTimeout
+
+/** @internal */
+export const set: (fn: () => void, ms: number) => NodeJS.Timeout = isBun ?
+  (fn: () => void, ms: number) => {
+    const id = setInterval(() => {
+      fn()
+      clearInterval(id)
+    }, ms)
+
+    return id
+  } :
+  setTimeout

test/Effect/promise.ts

@@ -1,5 +1,5 @@
 import * as Effect from "@effect/io/Effect"
-import { setTimeout } from "@effect/io/test/utils/timeout"
+import * as timeout from "@effect/io/internal/timeout"
 
 describe.concurrent("Effect", () => {
   it("promise - success with AbortSignal", async () => {
@@ -9,7 +9,7 @@ describe.concurrent("Effect", () => {
         aborted = true
       })
       return new Promise((resolve) => {
-        setTimeout(() => {
+        timeout.set(() => {
           resolve()
         }, 100)
       })

test/Effect/query.ts

@@ -8,6 +8,7 @@ import * as Exit from "@effect/io/Exit"
 import * as Fiber from "@effect/io/Fiber"
 import * as FiberRef from "@effect/io/FiberRef"
 import * as TestClock from "@effect/io/internal/testing/testClock"
+import * as timeout from "@effect/io/internal/timeout"
 import * as Layer from "@effect/io/Layer"
 import * as Request from "@effect/io/Request"
 import * as Resolver from "@effect/io/RequestResolver"
@@ -49,7 +50,7 @@ export const GetNameById = Request.tagged<GetNameById>("GetNameById")
 
 const delay = <R, E, A>(self: Effect.Effect<R, E, A>) =>
   Effect.zipRight(
-    Effect.promise(() => new Promise((r) => setTimeout(() => r(0), 0))),
+    Effect.promise(() => new Promise((r) => timeout.set(() => r(0), 0))),
     self
   )
 

test/Effect/scheduler.ts

@@ -1,7 +1,7 @@
 import * as Effect from "@effect/io/Effect"
+import * as timeout from "@effect/io/internal/timeout"
 import * as Scheduler from "@effect/io/Scheduler"
 import * as it from "@effect/io/test/utils/extend"
-import { setTimeout } from "@effect/io/test/utils/timeout"
 import { assert, describe } from "vitest"
 
 describe.concurrent("Effect", () => {
@@ -15,21 +15,21 @@ describe.concurrent("Effect", () => {
           0,
           Scheduler.makeBatched((runBatch) => {
             ps000.push(0)
-            setTimeout(runBatch, 0)
+            timeout.set(runBatch, 0)
           })
         ],
         [
           100,
           Scheduler.makeBatched((runBatch) => {
             ps100.push(100)
-            setTimeout(runBatch, 0)
+            timeout.set(runBatch, 0)
           })
         ],
         [
           200,
           Scheduler.makeBatched((runBatch) => {
             ps200.push(200)
-            setTimeout(runBatch, 0)
+            timeout.set(runBatch, 0)
           })
         ],
         [

test/Effect/tryPromise.ts

@@ -1,12 +1,12 @@
 import * as Either from "@effect/data/Either"
 import * as Effect from "@effect/io/Effect"
-import { setTimeout } from "@effect/io/test/utils/timeout"
+import * as timeout from "@effect/io/internal/timeout"
 
 describe.concurrent("Effect", () => {
   it("tryPromise - success, no catch, no AbortSignal", async () => {
     const effect = Effect.tryPromise<number>(() =>
       new Promise((resolve) => {
-        setTimeout(() => {
+        timeout.set(() => {
           resolve(1)
         }, 100)
       })
@@ -18,7 +18,7 @@ describe.concurrent("Effect", () => {
   it("tryPromise - failure, no catch, no AbortSignal", async () => {
     const effect = Effect.tryPromise<void>(() =>
       new Promise((_resolve, reject) => {
-        setTimeout(() => {
+        timeout.set(() => {
           reject("error")
         }, 100)
       })
@@ -31,7 +31,7 @@ describe.concurrent("Effect", () => {
     const effect = Effect.tryPromise({
       try: () =>
         new Promise((_resolve, reject) => {
-          setTimeout(() => {
+          timeout.set(() => {
             reject("error")
           }, 100)
         }),
@@ -48,7 +48,7 @@ describe.concurrent("Effect", () => {
         aborted = true
       })
       return new Promise((resolve) => {
-        setTimeout(() => {
+        timeout.set(() => {
           resolve()
         }, 100)
       })
@@ -69,7 +69,7 @@ describe.concurrent("Effect", () => {
           aborted = true
         })
         return new Promise((resolve) => {
-          setTimeout(() => {
+          timeout.set(() => {
             resolve()
           }, 100)
         })