@typed/fx 0.0.3 → 0.0.4

package/src/FiberRuntime/FiberRuntime.ts

@@ -10,18 +10,19 @@ import { AtomicCounter, decrement } from '@/Atomic/AtomicCounter.js'
 import * as Cause from '@/Cause/Cause.js'
 import { prettyPrint } from '@/Cause/Renderer.js'
 import { Disposable, Settable, settable } from '@/Disposable/Disposable.js'
-import * as Env from '@/Env/Env.js'
 import * as Exit from '@/Exit/Exit.js'
 import * as Fiber from '@/Fiber/Fiber.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
 import * as FiberId from '@/FiberId/FiberId.js'
 import * as FiberRef from '@/FiberRef/FiberRef.js'
+import * as Builtin from '@/FiberRef/builtins.js'
 import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
 import { Done, FiberStatus, Running, Suspended } from '@/FiberStatus/index.js'
 import { Pending, addObserver, complete, wait } from '@/Future/index.js'
 import * as Fx from '@/Fx/Fx.js'
 import { AnyInstruction } from '@/Fx/Instruction.js'
-import { closeOrWait, wait as waitForScope } from '@/Scope/Closeable.js'
+import { join } from '@/Fx/join.js'
+import { closeOrWait } from '@/Scope/Closeable.js'
 import { Semaphore, acquireFiber } from '@/Semaphore/Semaphore.js'
 import { Stack } from '@/Stack/index.js'
 import { Supervisor, isNone } from '@/Supervisor/Supervisor.js'
@@ -53,7 +54,6 @@ export class FiberRuntime<F extends Fx.AnyFx>
   protected _frames: Array<Frame> = []
 
   protected _processors: Processors = {
-    Access: this.processAccess.bind(this),
     AddTrace: this.processAddTrace.bind(this),
     Both: this.processBoth.bind(this),
     DeleteFiberRef: this.processDeleteFiberRef.bind(this),
@@ -63,6 +63,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
     Fork: this.processFork.bind(this),
     FromCause: this.processFromCause.bind(this),
     FromLazy: this.processFromLazy.bind(this),
+    GetEnv: this.processGetEnv.bind(this),
     GetFiberContext: () => this.continueWith(this.context),
     GetFiberRef: this.processGetFiberRef.bind(this),
     GetInterruptStatus: this.processGetInterruptStatus.bind(this),
@@ -80,7 +81,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
     Wait: this.processWait.bind(this),
   }
 
-  constructor(readonly fx: F, readonly context: FiberContext = FiberContext()) {
+  constructor(readonly fx: F, readonly context: FiberContext<FiberId.Live> = FiberContext()) {
     // All Fibers start Suspended
     this._status = Suspended(this.getInterruptStatus)
 
@@ -92,7 +93,15 @@ export class FiberRuntime<F extends Fx.AnyFx>
   readonly id: FiberId.Live = this.context.id
   readonly status = Fx.fromLazy(() => this._status)
   readonly trace = Fx.fromLazy(() => this.getCurrentTrace())
-  readonly exit = Fx.lazy(() => waitForScope(this.context.scope))
+  readonly exit = Fx.lazy(() => {
+    if (this._status.tag === 'Done') {
+      return Fx.now(this._status.exit)
+    }
+
+    const future = Pending<never, never, Exit.Exit<Fx.ErrorsOf<F>, Fx.OutputOf<F>>>()
+    this.addObserver(flow(Fx.now, complete(future)))
+    return wait(future)
+  })
 
   /**
    * Start running this Fiber synchronously. It can potentially exit BEFORE being able to cancel it.
@@ -123,24 +132,21 @@ export class FiberRuntime<F extends Fx.AnyFx>
 
   readonly interruptAs = (id: FiberId.FiberId): Fx.Of<Exit.Exit<Fx.ErrorsOf<F>, Fx.OutputOf<F>>> =>
     Fx.lazy(() => {
-      if (this._status.tag === 'Done') {
-        return Fx.now(this._status.exit)
-      }
-
-      const future = Pending<never, never, Exit.Exit<Fx.ErrorsOf<F>, Fx.OutputOf<F>>>()
-      this.addObserver((exit) => complete(future)(Fx.now(exit)))
-
       if (this.getInterruptStatus()) {
         // Immediately interrupt the Fiber
         this._disposable.dispose()
         this._disposable = settable()
-        this.unwindStack(Cause.interrupted(id))
+        this._current = Maybe.Just(Fx.interrupted(id).instr)
+
+        if (this._status.tag === 'Suspended') {
+          this.setTimer(() => this.loop())
+        }
       } else {
         // Record the interrupting FiberId for if/when the interrupt status becomes true again.
         this._interruptedBy.add(id)
       }
 
-      return wait(future)
+      return this.exit
     })
 
   // Start of Internals
@@ -169,7 +175,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
 
     while (Maybe.isJust(this._current)) {
       try {
-        this.run(this._current.value)
+        this.step(this._current.value)
       } catch (e) {
         this.uncaughtException(e)
       }
@@ -178,63 +184,72 @@ export class FiberRuntime<F extends Fx.AnyFx>
     this.suspended()
   }
 
-  protected run(instr: AnyInstruction) {
+  protected step(instr: AnyInstruction) {
     // Yield when too many synchronous operations have occurred
     if (decrement(this._opCountRemaining) === 0) {
-      this._opCountRemaining.set(this._opCountRemaining.id)
-      this._current = Maybe.Nothing
-
-      return this.setTimer(() => {
-        this._current = Maybe.Just(instr)
-        this.loop()
-      })
-    }
-
-    if (instr.__trace) {
-      this.pushPopFiberRef(FiberRef.CurrentTrace, Trace.Trace.custom(instr.__trace))
+      return this.yieldNow(instr)
     }
 
+    this.addCustomTrace(instr.__trace)
     this.withSupervisor((s) => s.onInstruction(this, instr))
     ;(this._processors[instr.tag] as (i: typeof instr) => void)(instr)
   }
 
-  protected processAccess(instr: Extract<AnyInstruction, { readonly tag: 'Access' }>) {
-    this._current = Maybe.Just(instr.f(this.getOrCreateCurrentEnv()).instr)
+  protected yieldNow(instr: AnyInstruction) {
+    this._opCountRemaining.set(this._opCountRemaining.initial)
+    this._current = Maybe.Nothing
+
+    return this.setTimer(() => {
+      this._current = Maybe.Just(instr)
+      this.loop()
+    })
+  }
+
+  protected addCustomTrace(trace?: string) {
+    if (trace) {
+      this.pushPopFiberRef(Builtin.CurrentTrace, Trace.Trace.custom(trace))
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  protected processGetEnv(_: Extract<AnyInstruction, { readonly tag: 'GetEnv' }>) {
+    this.withFiberRef(Builtin.CurrentEnv, (stack) => Fx.now(stack.value))
   }
 
   protected processAddTrace(instr: Extract<AnyInstruction, { readonly tag: 'AddTrace' }>) {
-    this.pushPopFiberRef(FiberRef.CurrentTrace, instr.trace)
+    this.pushPopFiberRef(Builtin.CurrentTrace, Trace.concat(instr.trace, this.getRuntimeTrace()))
     this._current = Maybe.Just(instr.fx.instr)
   }
 
   protected processBoth(instr: Extract<AnyInstruction, { readonly tag: 'Both' }>) {
-    const withConcurrency = acquireFiber(
-      this.getInternalFiberRef(FiberRef.CurrentConcurrencyLevel).value,
-    )
-    const f = new FiberRuntime(
-      withConcurrency(instr.first),
-      this.context.fork({ fiberRefs: this.context.fiberRefs }),
-    )
-    const s = new FiberRuntime(
-      withConcurrency(instr.second),
-      this.context.fork({ fiberRefs: this.context.fiberRefs }),
-    )
+    this.withFiberRef(Builtin.CurrentConcurrencyLevel, (semaphore) => {
+      const withConcurrency = acquireFiber(semaphore.value)
 
-    const [future, onExit] = bothFuture(f, s)
+      const f = new FiberRuntime(
+        withConcurrency(instr.first),
+        this.context.fork({ fiberRefs: this.context.fiberRefs }),
+      )
+      const s = new FiberRuntime(
+        withConcurrency(instr.second),
+        this.context.fork({ fiberRefs: this.context.fiberRefs }),
+      )
 
-    const inner = settable()
-    inner.add(this._disposable.add(f.addObserver((exit) => onExit(exit, 0))))
-    inner.add(this._disposable.add(s.addObserver((exit) => onExit(exit, 1))))
+      const [future, onExit] = bothFuture(f, s)
 
-    this._current = Maybe.Just(
-      pipe(
+      const inner = settable()
+
+      inner.add(f.addObserver((exit) => onExit(exit, 0)))
+      inner.add(s.addObserver((exit) => onExit(exit, 1)))
+      inner.add(this._disposable.add(inner))
+
+      f.startSync()
+      s.startSync()
+
+      return pipe(
         wait(future),
         Fx.ensuring(() => Fx.fromLazy(() => inner.dispose())),
-      ).instr,
-    )
-
-    f.startSync()
-    s.startSync()
+      )
+    })
   }
 
   protected processDeleteFiberRef(
@@ -250,36 +265,40 @@ export class FiberRuntime<F extends Fx.AnyFx>
   }
 
   protected processEither(instr: Extract<AnyInstruction, { readonly tag: 'Either' }>) {
-    const f = new FiberRuntime(
-      instr.first,
-      this.context.fork({ fiberRefs: this.context.fiberRefs }),
-    )
-    const s = new FiberRuntime(
-      instr.first,
-      this.context.fork({ fiberRefs: this.context.fiberRefs }),
-    )
+    this.withFiberRef(Builtin.CurrentConcurrencyLevel, (semaphore) => {
+      const withConcurrency = acquireFiber(semaphore.value)
+      const f = new FiberRuntime(
+        withConcurrency(instr.first),
+        this.context.fork({ fiberRefs: this.context.fiberRefs }),
+      )
+      const s = new FiberRuntime(
+        withConcurrency(instr.second),
+        this.context.fork({ fiberRefs: this.context.fiberRefs }),
+      )
 
-    const inner = settable()
-    const future = Pending<never, any, any>()
-    const onExit = (exit: Exit.Exit<Fx.ErrorsOf<F>, any>, index: 0 | 1) => {
-      complete(future)(
-        pipe(
-          Fx.fromExit(exit),
-          Fx.ensuring(() =>
-            index === 0 ? s.interruptAs(f.context.id) : f.interruptAs(s.context.id),
+      const inner = settable()
+      const future = Pending<never, any, any>()
+      const onExit = (exit: Exit.Exit<Fx.ErrorsOf<F>, any>, index: 0 | 1) => {
+        complete(future)(
+          pipe(
+            Fx.fromExit(exit),
+            Fx.ensuring(() =>
+              index === 0 ? s.interruptAs(f.context.id) : f.interruptAs(s.context.id),
+            ),
           ),
-        ),
-      )
-      inner.dispose()
-    }
+        )
+        inner.dispose()
+      }
 
-    inner.add(this._disposable.add(f.addObserver((exit) => onExit(exit, 0))))
-    inner.add(this._disposable.add(s.addObserver((exit) => onExit(exit, 1))))
+      inner.add(f.addObserver((exit) => onExit(pipe(exit, Either.map(Either.Left)), 0)))
+      inner.add(s.addObserver((exit) => onExit(pipe(exit, Either.map(Either.Right)), 1)))
+      inner.add(this._disposable.add(inner))
 
-    this._current = Maybe.Just(wait(future).instr)
+      f.startSync()
+      s.startSync()
 
-    f.startSync()
-    s.startSync()
+      return wait(future)
+    })
   }
 
   protected processFiberRefLocally(
@@ -295,22 +314,39 @@ export class FiberRuntime<F extends Fx.AnyFx>
   }
 
   protected processFork(instr: Extract<AnyInstruction, { readonly tag: 'Fork' }>) {
-    const runtime = new FiberRuntime(instr.fx, instr.context)
+    const child = new FiberRuntime(instr.fx, instr.context)
 
-    this._children.push(runtime)
-    instr.context.scope.ensuring(() =>
-      Fx.fromLazy(() => this._children.splice(this._children.indexOf(runtime), 1)),
+    this._children.push(child)
+
+    child._disposable.add(
+      Disposable(() => {
+        const i = this._children.indexOf(child)
+        if (i > -1) {
+          this._children.splice(i, 1)
+        }
+      }),
     )
 
     // All Child fibers should be started asynchronously to ensure they are capable of
     // being interrupted *before* any work has been started and could steal the thread.
-    runtime.startAsync()
+    child.startAsync()
 
-    this.continueWith(runtime)
+    this.continueWith(child)
   }
 
   protected processFromCause(instr: Extract<AnyInstruction, { readonly tag: 'FromCause' }>) {
-    this.unwindStack(instr.cause)
+    if (instr.cause.tag === 'Interrupted' && this._children.length > 0) {
+      const fiberId = instr.cause.fiberId
+      const interrupts = this._children.map((c) => c.interruptAs(fiberId))
+      this._children = []
+
+      // Cancel all Child Fibers and then continue with the Cause
+      this._current = Maybe.Just(
+        Fx.flatMap(() => Fx.fromCause(instr.cause))(Fx.fork(Fx.zipAll(interrupts))).instr,
+      )
+    } else {
+      this.unwindStack(instr.cause)
+    }
   }
 
   protected processFromLazy(instr: Extract<AnyInstruction, { readonly tag: 'FromLazy' }>) {
@@ -318,28 +354,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
   }
 
   protected processGetFiberRef(instr: Extract<AnyInstruction, { readonly tag: 'GetFiberRef' }>) {
-    const current = FiberRefs.maybeGetFiberRefValue(
-      instr.fiberRef as FiberRef.FiberRef<any, any, any>,
-    )(this.context.fiberRefs)
-
-    if (Maybe.isJust(current)) {
-      return this.continueWith(current.value)
-    }
-
-    this.pushFrame(
-      ValueFrame((a) =>
-        Fx.fromLazy(() => {
-          FiberRefs.setFiberRef(
-            instr.fiberRef as FiberRef.FiberRef<any, any, any>,
-            a,
-          )(this.context.fiberRefs)
-
-          return a
-        }),
-      ),
-    )
-
-    this._current = Maybe.Just(instr.fiberRef.initial.instr)
+    this.withFiberRef(instr.fiberRef, (s) => Fx.now(s.value))
   }
 
   protected processGetInterruptStatus(
@@ -351,6 +366,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   protected processGetTrace(_: Extract<AnyInstruction, { readonly tag: 'GetTrace' }>) {
+    this.pushPopFiberRef(Builtin.CurrentTrace, this.getRuntimeTrace())
     this.continueWith(this.getCurrentTrace())
   }
 
@@ -359,47 +375,25 @@ export class FiberRuntime<F extends Fx.AnyFx>
   }
 
   protected processMap(instr: Extract<AnyInstruction, { readonly tag: 'Map' }>) {
-    this.pushFrame(ValueFrame((a) => Fx.now(instr.f(a))))
+    this.pushFrame(ValueFrame(flow(instr.f, Fx.now)))
     this._current = Maybe.Just(instr.fx.instr)
   }
 
   protected processMatch(instr: Extract<AnyInstruction, { readonly tag: 'Match' }>) {
-    this.pushFrame(ExitFrame(Either.match(instr.onLeft as any, instr.onRight as any)))
+    this.pushFrame(ExitFrame(Either.match(instr.onLeft, instr.onRight)))
     this._current = Maybe.Just(instr.fx.instr)
   }
 
   protected processModifyFiberRef(
     instr: Extract<AnyInstruction, { readonly tag: 'ModifyFiberRef' }>,
   ) {
-    const ref = instr.fiberRef as FiberRef.FiberRef<any, any, any>
-    const current = FiberRefs.maybeGetFiberRefValue(ref)(this.context.fiberRefs)
-
-    if (Maybe.isJust(current)) {
-      const [b, a] = instr.modify(current.value)
-
-      FiberRefs.setFiberRef(ref, a)(this.context.fiberRefs)
+    this.withFiberRef(instr.fiberRef, (stack) => {
+      const [b, a] = instr.modify(stack.value)
 
-      return this.continueWith(b)
-    }
-
-    this.pushFrame(
-      ValueFrame((i) =>
-        Fx.fromLazy(() => {
-          const [b, a] = instr.modify(i)
+      FiberRefs.setFiberRef(instr.fiberRef, a)(this.context.fiberRefs)
 
-          FiberRefs.setFiberRef(ref, a)(this.context.fiberRefs)
-
-          return b
-        }),
-      ),
-    )
-
-    this._current = Maybe.Just(
-      pipe(
-        FiberRefs.maybeGetFiberRefValue(ref)(this.context.fiberRefs),
-        Maybe.match(() => instr.fiberRef.initial, Fx.now),
-      ).instr,
-    )
+      return Fx.now(b)
+    })
   }
 
   protected processNow(instr: Extract<AnyInstruction, { readonly tag: 'Now' }>) {
@@ -407,98 +401,91 @@ export class FiberRuntime<F extends Fx.AnyFx>
   }
 
   protected processProvide(instr: Extract<AnyInstruction, { readonly tag: 'Provide' }>) {
-    this.pushPopFiberRef(FiberRef.CurrentEnv, instr.env)
+    this.pushPopFiberRef(Builtin.CurrentEnv, instr.env)
     this._current = Maybe.Just(instr.fx.instr)
   }
 
   protected processProvideLayer(instr: Extract<AnyInstruction, { readonly tag: 'ProvideLayer' }>) {
-    const layers = this.getInternalFiberRef(FiberRef.Layers).value
-    const layer = instr.layer
-    const context = this.context
-
-    const unwindStack = (cause: Cause.AnyCause) =>
-      this._status.tag === 'Done'
-        ? context.scope.state.tag === 'Open'
-          ? context.scope.close(Either.Left(cause))
-          : Fx.fromLazy(() => this.reportFailure(cause))
-        : Fx.fromLazy(() => this.unwindStack(cause))
-
-    const provider = Fx.Fx(function* () {
-      const exit = yield* Fx.attempt(Fx.uninterruptable(layer.build(context.scope)))
-
-      if (Either.isRight(exit)) {
-        return exit.right
-      }
-
-      const cause = exit.left
-
-      // Expected errors are not likely to match the calling Fiber.
-      if (cause.tag === 'Expected') {
-        yield* unwindStack(cause)
-
-        return yield* Fx.never
-      }
+    this.withFiberRef(Builtin.Layers, (layers) => {
+      const layer = instr.layer
+      const context = this.context
+
+      const unwindStack = (cause: Cause.AnyCause): Fx.Of<any> =>
+        this._status.tag === 'Done'
+          ? context.scope.state.tag === 'Open'
+            ? context.scope.close(Either.Left(cause))
+            : Fx.fromLazy(() => this.reportFailure(cause))
+          : Fx.fromLazy(() => this.unwindStack(cause))
+
+      const provider = pipe(
+        Fx.uninterruptable(layer.build(context.scope)),
+        Fx.orElseCause((cause) =>
+          cause.tag === 'Expected'
+            ? pipe(
+                unwindStack(cause),
+                Fx.flatMap(() => Fx.never),
+              )
+            : Fx.fromCause(cause),
+        ),
+      )
 
-      // Unexpected errors should be fine to pass along
-      return yield* Fx.fromCause(cause)
+      return pipe(
+        instr.fx,
+        Fx.fiberRefLocally(
+          Builtin.Layers,
+          layers.value.set(layer.service, [
+            () => {
+              const fiber = new FiberRuntime(provider, this.context.fork())
+              fiber.startSync()
+              return fiber as Fiber.Live<never, any>
+            },
+            Maybe.Nothing,
+          ]),
+        ),
+      )
     })
-
-    FiberRefs.setFiberRefLocally(
-      FiberRef.Layers,
-      layers.set(layer.service, [
-        () => {
-          const fiber = new FiberRuntime(provider, this.context.fork())
-          fiber.startSync()
-          return fiber as Fiber.Live<never, any>
-        },
-        Maybe.Nothing,
-      ]),
-    )(context.fiberRefs)
-
-    this.popFiberRef(FiberRef.Layers)
-
-    this._current = Maybe.Just(instr.fx.instr)
   }
 
   protected processProvideService(
     instr: Extract<AnyInstruction, { readonly tag: 'ProvideService' }>,
   ) {
-    FiberRefs.setFiberRefLocally(
-      FiberRef.Services,
-      this.getInternalFiberRef(FiberRef.Services).value.set(instr.service, instr.implementation),
-    )(this.context.fiberRefs)
-
-    this.popFiberRef(FiberRef.Services)
-
-    this._current = Maybe.Just(instr.fx.instr)
+    this.withFiberRef(Builtin.Services, (services) =>
+      pipe(
+        instr.fx,
+        Fx.fiberRefLocally(
+          Builtin.Services,
+          services.value.set(instr.service, instr.implementation),
+        ),
+      ),
+    )
   }
 
   protected processSetConcurrencyLevel(
     instr: Extract<AnyInstruction, { readonly tag: 'SetConcurrencyLevel' }>,
   ) {
-    this.pushPopFiberRef(FiberRef.CurrentConcurrencyLevel, new Semaphore(instr.concurrencyLevel))
+    this.pushPopFiberRef(Builtin.CurrentConcurrencyLevel, new Semaphore(instr.concurrencyLevel))
     this._current = Maybe.Just(instr.fx.instr)
   }
 
   protected processSetInterruptStatus(
     instr: Extract<AnyInstruction, { readonly tag: 'SetInterruptStatus' }>,
   ) {
-    const current = this.getInterruptStatus()
+    const currentlyInterruptable = this.getInterruptStatus()
 
     FiberRefs.setFiberRefLocally(
-      FiberRef.CurrentInterruptStatus,
+      Builtin.CurrentInterruptStatus,
       instr.interruptStatus,
     )(this.context.fiberRefs)
 
     this.pushFrame(
       ExitFrame((exit) =>
         Fx.lazy(() => {
-          FiberRefs.popLocalFiberRef(FiberRef.CurrentInterruptStatus)(this.context.fiberRefs)
+          FiberRefs.popLocalFiberRef(Builtin.CurrentInterruptStatus)(this.context.fiberRefs)
 
-          if (current && this._interruptedBy.size > 0) {
+          if (currentlyInterruptable && this._interruptedBy.size > 0) {
             return Fx.fromExit(
               Array.from(this._interruptedBy).reduce(
-                (e, id) => concatExitSeq(e, Either.Left(Cause.interrupted(id))),
+                (e, id) => concatExitSeq(e, Exit.interrupt(id)),
                 exit,
               ),
             )
@@ -519,10 +506,13 @@ export class FiberRuntime<F extends Fx.AnyFx>
       return (this._current = Maybe.Just(state.fx.instr))
     }
 
+    // Add Stack trace before asynchrony occurs
+    this.pushPopFiberRef(Builtin.CurrentTrace, this.getRuntimeTrace())
+
     const inner = settable()
 
     inner.add(
-      addObserver(instr.future as any, (fx) => {
+      addObserver(instr.future, (fx) => {
         if (!inner.isDisposed()) {
           inner.dispose()
           this._current = Maybe.Just(fx.instr)
@@ -537,15 +527,16 @@ export class FiberRuntime<F extends Fx.AnyFx>
   }
 
   protected uncaughtException(error: unknown) {
-    const stackTrace = this.getInternalFiberRef(FiberRef.CurrentTrace)
-    const trimmed = Trace.getTrimmedTrace(Cause.unexpected(error), stackTrace)
-    const current = Trace.getTraceUpTo(
-      stackTrace.push(trimmed),
-      this.context.platform.maxTraceCount,
-    )
-    const cause = Cause.traced(Trace.concat(trimmed, current))(Cause.unexpected(error))
+    this.withFiberRef(Builtin.CurrentTrace, (stackTrace) => {
+      const trimmed = Trace.getTrimmedTrace(Cause.unexpected(error), stackTrace)
+      const current = Trace.getTraceUpTo(
+        stackTrace.push(trimmed),
+        this.context.platform.maxTraceCount,
+      )
+      const cause = Cause.traced(Trace.concat(trimmed, current))(Cause.unexpected(error))
 
-    this.unwindStack(cause)
+      return Fx.fromCause(cause)
+    })
   }
 
   protected pushFrame(frame: Frame) {
@@ -624,7 +615,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
 
   protected reportFailure(cause: Cause.AnyCause) {
     this.context.platform.reportFailure(
-      [FiberId.debug(this.id), prettyPrint(cause, this.context.renderer)].join('\n'),
+      [FiberId.debug(this.id), prettyPrint(cause, this.context.platform.renderer)].join('\n'),
     )
   }
 
@@ -632,31 +623,31 @@ export class FiberRuntime<F extends Fx.AnyFx>
     const inner = settable()
 
     inner.add(
-      this._disposable.add(
-        this.context.platform.timer.setTimer((time) => {
-          inner.dispose()
-          f(time)
-        }, Delay(0)),
-      ),
+      this.context.platform.timer.setTimer((time) => {
+        inner.dispose()
+        f(time)
+      }, Delay(0)),
     )
 
+    inner.add(this._disposable.add(inner))
+
     return inner
   }
 
   protected getInterruptStatus = (): boolean =>
-    this.getInternalFiberRef(FiberRef.CurrentInterruptStatus).value
+    pipe(
+      this.context.fiberRefs,
+      FiberRefs.maybeGetFiberRefValue(Builtin.CurrentInterruptStatus),
+      Maybe.getOrElse(() => true),
+    )
 
   protected pushPopFiberRef = (ref: FiberRef.AnyFiberRef, value: any) => {
-    FiberRefs.setFiberRefLocally(ref as any, value)(this.context.fiberRefs)
-
-    this.popFiberRef(ref)
-  }
+    FiberRefs.setFiberRefLocally(ref, value)(this.context.fiberRefs)
 
-  protected popFiberRef = (ref: FiberRef.AnyFiberRef) => {
     this.pushFrame(
       ExitFrame((exit) =>
         Fx.lazy(() => {
-          FiberRefs.popLocalFiberRef(ref as any)(this.context.fiberRefs)
+          FiberRefs.popLocalFiberRef(ref)(this.context.fiberRefs)
 
           return Fx.fromExit(exit)
         }),
@@ -664,45 +655,72 @@ export class FiberRuntime<F extends Fx.AnyFx>
     )
   }
 
-  protected getOrCreateCurrentEnv(): Env.Env<any> {
-    const locals = this.context.fiberRefs.locals.get()
-    const maybe = locals.get(FiberRef.CurrentEnv)
+  protected withFiberRef<R, E, A, R2, E2, B>(
+    ref: FiberRef.FiberRef<R, E, A>,
+    f: (a: Stack<A>) => Fx.Fx<R2, E2, B>,
+  ): void {
+    const fiberRefs = this.context.fiberRefs
+    const currentValue = fiberRefs.locals.get().get(ref)
 
-    if (maybe.tag === 'Just') {
-      return maybe.value.value
+    if (Maybe.isJust(currentValue)) {
+      this._current = Maybe.Just(f(currentValue.value).instr)
+      return
     }
 
-    const env = Env.Env(this.context.fiberRefs)
-
-    locals.set(FiberRef.CurrentEnv, new Stack(env))
-
-    return env
-  }
-
-  protected getInternalFiberRef<R, E, A>(ref: FiberRef.FiberRef<R, E, A>): Stack<A> {
-    const maybe = this.context.fiberRefs.locals.get().get(ref)
+    const initializing = fiberRefs.initializing.get()
+    const initializingFiber = initializing.get(ref)
 
-    if (maybe.tag === 'Just') {
-      return maybe.value
+    if (Maybe.isJust(initializingFiber)) {
+      this._current = Maybe.Just(
+        pipe(
+          (initializingFiber.value as Fiber.Live<E, A>).exit,
+          Fx.flatMap(Fx.fromExit),
+          Fx.flatMap((a) => f(new Stack(a))),
+        ).instr,
+      )
+      return
     }
 
-    throw new Error(
-      `There is a bug in @typed/Fx's FiberRuntime not having access to expected FiberRef`,
+    this._current = Maybe.Just(
+      pipe(
+        Fx.forkInContext(this.context.fork({ fiberRefs: this.context.fiberRefs }))(ref.initial),
+        Fx.tap((fiber) =>
+          Fx.fromLazy(() => fiberRefs.initializing.modify((a) => [null, a.set(ref, fiber)])),
+        ),
+        Fx.flatMap(join),
+        Fx.ensuring((exit) =>
+          Fx.fromLazy(() => {
+            fiberRefs.initializing.modify((a) => [null, a.remove(ref)])
+
+            if (Either.isRight(exit)) {
+              FiberRefs.setFiberRef(ref, exit.right)(this.context.fiberRefs)
+            }
+          }),
+        ),
+        Fx.flatMap((a) => f(new Stack(a))),
+      ).instr,
     )
   }
 
   protected getCurrentTrace(): Trace.Trace {
-    const maybe = this.context.fiberRefs.locals.get().get(FiberRef.CurrentTrace)
-
-    if (maybe.tag === 'Just') {
-      return Trace.getTraceUpTo(
-        this.getInternalFiberRef(FiberRef.CurrentTrace),
-        this.context.platform.maxTraceCount,
-      )
-    }
+    return pipe(
+      this.context.fiberRefs,
+      FiberRefs.maybeGetFiberRefStack(Builtin.CurrentTrace),
+      Maybe.match(
+        () => Trace.Trace.runtime(new Error()),
+        (stackTrace) => Trace.getTraceUpTo(stackTrace, this.context.platform.maxTraceCount),
+      ),
+    )
+  }
 
-    throw new Error(
-      `There is a bug in @typed/Fx's FiberRuntime not having access to the StackTrace`,
+  protected getRuntimeTrace(): Trace.Trace {
+    return pipe(
+      this.context.fiberRefs,
+      FiberRefs.maybeGetFiberRefStack(Builtin.CurrentTrace),
+      Maybe.match(
+        () => Trace.Trace.runtime(new Error()),
+        (stackTrace) => Trace.getTrimmedTrace(Cause.Empty, stackTrace),
+      ),
     )
   }