build ManagedRuntime synchronously if possible

Author: tim-smart

.changeset/four-yaks-exist.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+simplify fiber.await internals

.changeset/gentle-stars-stop.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+build ManagedRuntime synchronously if possible

packages/effect/src/internal/fiberRuntime.ts

@@ -451,22 +451,12 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
   get await(): Effect.Effect<Exit.Exit<A, E>> {
     return core.async((resume) => {
       const cb = (exit: Exit.Exit<A, E>) => resume(core.succeed(exit))
-      this.tell(
-        FiberMessage.stateful((fiber, _) => {
-          if (fiber._exitValue !== null) {
-            cb(this._exitValue!)
-          } else {
-            fiber.addObserver(cb)
-          }
-        })
-      )
-      return core.sync(() =>
-        this.tell(
-          FiberMessage.stateful((fiber, _) => {
-            fiber.removeObserver(cb)
-          })
-        )
-      )
+      if (this._exitValue !== null) {
+        cb(this._exitValue!)
+        return
+      }
+      this.addObserver(cb)
+      return core.sync(() => this.removeObserver(cb))
     }, this.id())
   }
 

packages/effect/src/internal/managedRuntime.ts

@@ -7,6 +7,7 @@ import type * as M from "../ManagedRuntime.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
+import * as Scheduler from "../Scheduler.js"
 import * as Scope from "../Scope.js"
 import type { Mutable } from "../Types.js"
 import * as core from "./core.js"
@@ -57,8 +58,9 @@ export const make = <R, ER>(
   memoMap = memoMap ?? internalLayer.unsafeMakeMemoMap()
   const scope = internalRuntime.unsafeRunSyncEffect(fiberRuntime.scopeMake())
   let buildFiber: Fiber.RuntimeFiber<Runtime.Runtime<R>, ER> | undefined
-  const runtimeEffect = core.withFiberRuntime<Runtime.Runtime<R>, ER>((fiber) => {
+  const runtimeEffect = core.suspend(() => {
     if (!buildFiber) {
+      const scheduler = new Scheduler.SyncScheduler()
       buildFiber = internalRuntime.unsafeForkEffect(
         core.tap(
           Scope.extend(
@@ -69,8 +71,9 @@ export const make = <R, ER>(
             self.cachedRuntime = rt
           }
         ),
-        { scope, scheduler: fiber.currentScheduler }
+        { scope, scheduler }
       )
+      scheduler.flush()
     }
     return core.flatten(buildFiber.await)
   })

packages/effect/test/ManagedRuntime.test.ts

@@ -76,4 +76,10 @@ describe("ManagedRuntime", () => {
     const result = Context.get(runtime.context, tag)
     strictEqual(result, "test")
   })
+
+  it("is built synchronously with runFork", () => {
+    const runtime = ManagedRuntime.make(Layer.empty)
+    runtime.runFork(Effect.void)
+    runtime.runSync(Effect.void)
+  })
 })