@fncts/io 0.0.21 → 0.0.22

package/_mjs/Fiber/FiberRuntime.mjs

@@ -0,0 +1,728 @@
+const fileName_1 = "(@fncts/io) src/Fiber/FiberRuntime.ts";
+import * as tsplus_module_1 from "@fncts/base/collection/immutable/List/constructors";
+import * as tsplus_module_2 from "@fncts/base/internal/Stack";
+import * as tsplus_module_3 from "@fncts/io/Future/constructors";
+import * as tsplus_module_4 from "@fncts/io/IO/api";
+import * as tsplus_module_5 from "@fncts/io/Future/api";
+import * as tsplus_module_6 from "@fncts/io/Fiber/FiberMessage";
+import * as tsplus_module_7 from "@fncts/base/collection/immutable/Conc/constructors";
+import * as tsplus_module_8 from "@fncts/io/FiberRefs/join";
+import * as tsplus_module_9 from "@fncts/io/RuntimeFlags/RuntimeFlags";
+import * as tsplus_module_10 from "@fncts/io/RuntimeFlags/Patch";
+import * as tsplus_module_11 from "@fncts/base/data/Cause/api";
+import * as tsplus_module_12 from "@fncts/io/FiberRef/unsafe";
+import * as tsplus_module_13 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_14 from "@fncts/base/data/exceptions";
+import * as tsplus_module_15 from "@fncts/io/IO/definition";
+import * as tsplus_module_16 from "@fncts/base/data/Exit/constructors";
+import * as tsplus_module_17 from "@fncts/base/data/FiberId/constructors";
+import * as tsplus_module_18 from "@fncts/base/data/Cause/api/isEmpty";
+import * as tsplus_module_19 from "@fncts/io/FiberRefs/api";
+import * as tsplus_module_20 from "@fncts/base/data/TraceElement/definition";
+import * as tsplus_module_21 from "@fncts/base/collection/immutable/List/api";
+import * as tsplus_module_22 from "@fncts/io/FiberScope/constructors";
+import * as tsplus_module_23 from "@fncts/base/data/Maybe/api";
+import * as tsplus_module_24 from "@fncts/io/LogLevel";
+import * as tsplus_module_25 from "@fncts/io/Logger/constructors";
+import * as tsplus_module_26 from "@fncts/io/Logger/api";
+import { Trace } from "@fncts/base/data/Trace";
+import { FiberTypeId } from "@fncts/io/Fiber/definition";
+import { StackTraceBuilder } from "@fncts/io/internal/StackTraceBuilder";
+import { Done, Suspended } from "../FiberStatus.mjs";
+import { Running } from "../FiberStatus.mjs";
+import { LinkedQueue } from "../internal/MutableQueue.mjs";
+import { isIO } from "../IO/definition.mjs";
+import { WhileLoop } from "../IO/definition.mjs";
+import { isIOError } from "../IO/definition.mjs";
+export class RevertFlags {
+  constructor(patch, trace) {
+    this.patch = patch;
+    this.trace = trace;
+    this._tag = "RevertFlags" /* ContinuationTag.RevertFlags */;
+  }
+}
+
+export class UpdateTrace {
+  constructor(trace) {
+    this.trace = trace;
+    this._tag = "UpdateTrace" /* ContinuationTag.UpdateTrace */;
+  }
+}
+/**
+ * @tsplus type fncts.io.Fiber
+ */
+export class FiberRuntime {
+  constructor(fiberId, fiberRefs0, runtimeFlags0) {
+    this.fiberId = fiberId;
+    this.runtimeFlags0 = runtimeFlags0;
+    this._typeId = FiberTypeId;
+    this._tag = "RuntimeFiber";
+    this.queue = new LinkedQueue();
+    this._children = null;
+    this.observers = tsplus_module_1.make();
+    this.running = false;
+    this.stack = new tsplus_module_2.Stack();
+    this.asyncInterruptor = null;
+    this.asyncTrace = null;
+    this.asyncBlockinOn = null;
+    this._exitValue = null;
+    this.location = this.fiberId.location;
+    this._fiberRefs = fiberRefs0;
+    this._runtimeFlags = runtimeFlags0;
+  }
+  get id() {
+    return this.fiberId;
+  }
+  ask(f) {
+    return tsplus_module_4.defer(() => {
+      const future = tsplus_module_3.unsafeMake(this.fiberId);
+      this.tell(tsplus_module_6.mkStateful((fiber, status) => tsplus_module_5.unsafeDone(tsplus_module_4.succeed(() => f(fiber, status), fileName_1 + ":76:86"), fileName_1 + ":76:75")(future)));
+      return tsplus_module_5.wait(future, fileName_1 + ":78:20");
+    }, fileName_1 + ":73:20");
+  }
+  get await() {
+    return tsplus_module_4.async(cb => this.tell(tsplus_module_6.mkStateful((fiber, _) => {
+      if (fiber._exitValue !== null) cb(tsplus_module_4.succeedNow(fiber.exitValue(), fileName_1 + ":87:60"));else fiber.addObserver(exit => cb(tsplus_module_4.succeedNow(exit, fileName_1 + ":88:62")));
+    })), this.id, fileName_1 + ":83:20");
+  }
+  get children() {
+    return this.ask(fiber => tsplus_module_7.from(fiber.getChildren()));
+  }
+  get fiberRefs() {
+    return this.ask(fiber => fiber.getFiberRefs());
+  }
+  get inheritAll() {
+    return tsplus_module_4.withFiberRuntime((parentFiber, parentStatus) => {
+      const parentFiberId = parentFiber.id;
+      const parentFiberRefs = parentFiber.getFiberRefs();
+      const parentRuntimeFlags = parentStatus.runtimeFlags;
+      const childFiberRefs = this.getFiberRefs();
+      const updatedFiberRefs = tsplus_module_8.join(parentFiberId, childFiberRefs)(parentFiberRefs);
+      parentFiber.setFiberRefs(updatedFiberRefs);
+      return tsplus_module_4.flatMap(childRuntimeFlags => {
+        const patch = tsplus_module_10.exclude(tsplus_module_10.exclude(tsplus_module_9.diff(parentRuntimeFlags, childRuntimeFlags), 64 /* RuntimeFlag.WindDown */), 1 /* RuntimeFlag.Interruption */);
+        return tsplus_module_4.updateRuntimeFlags(patch, fileName_1 + ":120:37");
+      }, fileName_1 + ":114:39")(this.runtimeFlags);
+    }, fileName_1 + ":104:31");
+  }
+  get runtimeFlags() {
+    return this.ask((state, status) => {
+      if (status._tag === 0 /* FiberStatusTag.Done */) return state._runtimeFlags;else return status.runtimeFlags;
+    });
+  }
+  interruptAsFork(fiberId) {
+    return tsplus_module_4.succeed(() => {
+      const cause = tsplus_module_11.interrupt(fiberId);
+      this.tell(tsplus_module_6.mkInterruptSignal(cause));
+    }, fileName_1 + ":133:22");
+  }
+  getSupervisor() {
+    return this.getFiberRef(tsplus_module_12.currentSupervisor);
+  }
+  get poll() {
+    return tsplus_module_4.succeed(() => tsplus_module_13.fromNullable(this.exitValue()), fileName_1 + ":144:22");
+  }
+  run() {
+    this.drainQueueOnCurrentThread();
+  }
+  drainQueueOnCurrentThread() {
+    // assert(this.running, "Invalid state in FiberRuntime: Fiber is not running");
+    let recurse = true;
+    while (recurse) {
+      let evaluationSignal = 0 /* EvaluationSignal.Continue */;
+      if (tsplus_module_9.currentFiber(this._runtimeFlags)) {
+        // TODO
+      }
+      try {
+        while (evaluationSignal === 0 /* EvaluationSignal.Continue */) {
+          evaluationSignal = this.queue.isEmpty ? 2 /* EvaluationSignal.Done */ : this.evaluateMessageWhileSuspended(this.queue.dequeue(null));
+        }
+      } finally {
+        this.running = false;
+        if (tsplus_module_9.currentFiber(this._runtimeFlags)) {
+          // TODO
+        }
+      }
+      if (!this.queue.isEmpty && !this.running) {
+        this.running = true;
+        if (evaluationSignal === 1 /* EvaluationSignal.YieldNow */) {
+          this.drainQueueLaterOnExecutor();
+          recurse = false;
+        } else {
+          recurse = true;
+        }
+      } else {
+        recurse = false;
+      }
+    }
+  }
+  drainQueueLaterOnExecutor() {
+    // assert(this.running, "Invalid state in FiberRuntime: Fiber is not running");
+    this.getFiberRef(tsplus_module_12.currentScheduler).scheduleTask(() => this.run());
+  }
+  drainQueueWhileRunning(runtimeFlags, lastTrace, cur0) {
+    let cur = cur0;
+    while (!this.queue.isEmpty) {
+      const message = this.queue.dequeue(null);
+      switch (message._tag) {
+        case 0 /* FiberMessageTag.InterruptSignal */:
+          {
+            this.processNewInterruptSignal(message.cause);
+            cur = tsplus_module_9.interruptible(runtimeFlags) ? tsplus_module_4.failCause(() => message.cause, fileName_1 + ":207:58") : cur;
+            break;
+          }
+        case 1 /* FiberMessageTag.GenStackTrace */:
+          {
+            const oldCur = cur;
+            cur = tsplus_module_4.flatMap(stackTrace => {
+              message.onTrace(stackTrace);
+              return oldCur;
+            }, undefined)(tsplus_module_4.stackTrace(undefined));
+            break;
+          }
+        case 2 /* FiberMessageTag.Stateful */:
+          {
+            message.onFiber(this, new Running(runtimeFlags, lastTrace));
+            break;
+          }
+        case 3 /* FiberMessageTag.Resume */:
+          {
+            throw new tsplus_module_14.IllegalStateError("It is illegal to have multiple concurrent run loops in a single fiber");
+          }
+        case 4 /* FiberMessageTag.YieldNow */:
+          {
+            const oldCur = cur;
+            cur = tsplus_module_4.flatMap(() => oldCur, undefined)(tsplus_module_4.yieldNow);
+            break;
+          }
+      }
+    }
+    return cur;
+  }
+  evaluateEffect(effect0) {
+    // assert(this.running, "Invalid state in FiberRuntime: Fiber is not running");
+    this.getSupervisor().unsafeOnResume(this);
+    try {
+      let effect;
+      if (tsplus_module_9.interruptible(this._runtimeFlags) && this.isInterrupted()) {
+        effect = tsplus_module_4.failCause(() => this.getInterruptedCause(), fileName_1 + ":245:30");
+      } else {
+        effect = effect0;
+      }
+      let finalExit = null;
+      while (effect !== null) {
+        try {
+          const exit = this.runLoop(effect);
+          this._runtimeFlags = tsplus_module_9.enable(this._runtimeFlags, 64 /* RuntimeFlag.WindDown */);
+          const interruption = this.interruptAllChildren();
+          if (interruption === null) {
+            if (this.queue.isEmpty) {
+              finalExit = exit;
+              this.setExitValue(exit);
+            } else {
+              this.tell(tsplus_module_6.mkResume(tsplus_module_4.fromExitNow(exit, fileName_1 + ":263:59")));
+            }
+            effect = null;
+          } else {
+            effect = tsplus_module_4.flatMap(() => tsplus_module_4.fromExitNow(exit, fileName_1 + ":268:63"), this.id.location)(interruption);
+          }
+        } catch (e) {
+          if (isIO(e)) {
+            if (e._tag === 12 /* IOTag.YieldNow */) {
+              if (tsplus_module_9.cooperativeYielding(this._runtimeFlags)) {
+                this.tell(tsplus_module_6.YieldNow);
+                this.tell(tsplus_module_6.mkResume(tsplus_module_4.unit));
+                effect = null;
+              } else {
+                effect = tsplus_module_4.unit;
+              }
+            } else if (e._tag === 3 /* IOTag.Async */) {
+              effect = null;
+            } else {
+              throw new Error(`Unhandled op ${e._tag}`);
+            }
+          } else {
+            throw e;
+          }
+        }
+      }
+    } finally {
+      this.getSupervisor().unsafeOnSuspend(this);
+    }
+  }
+  runLoop(effect) {
+    // assert(this.running, "Invalid state in FiberRuntime: Fiber is not running");
+    let cur = effect;
+    let lastTrace = undefined;
+    let ops = 0;
+    while (true) {
+      if (tsplus_module_9.opSpervision(this._runtimeFlags)) {
+        this.getSupervisor().unsafeOnEffect(this, cur);
+      }
+      const nextTrace = cur.trace;
+      if (nextTrace !== undefined) lastTrace = nextTrace;
+      cur = this.drainQueueWhileRunning(this._runtimeFlags, lastTrace, cur);
+      ops += 1;
+      if (ops > 2048) {
+        ops = 0;
+        const oldCur = cur;
+        const trace = lastTrace;
+        cur = tsplus_module_4.flatMap(() => oldCur, trace)(tsplus_module_4.yieldNow);
+      }
+      try {
+        switch (cur._tag) {
+          case 2 /* IOTag.Sync */:
+            {
+              const value = cur.evaluate();
+              const cont = this.getNextSuccessCont();
+              if (cont) {
+                switch (cont._tag) {
+                  case 5 /* IOTag.OnSuccess */:
+                  case 4 /* IOTag.OnSuccessAndFailure */:
+                    {
+                      cur = cont.successK(value);
+                      break;
+                    }
+                  case 11 /* IOTag.WhileLoop */:
+                    {
+                      cont.process(value);
+                      if (cont.check()) {
+                        this.stack.push(cont);
+                        cur = cont.body();
+                      } else {
+                        cur = tsplus_module_4.unit;
+                      }
+                      break;
+                    }
+                  case "RevertFlags" /* ContinuationTag.RevertFlags */:
+                    {
+                      this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
+                      if (tsplus_module_9.interruptible(this._runtimeFlags) && this.isInterrupted()) {
+                        cur = tsplus_module_4.failCauseNow(this.getInterruptedCause(), fileName_1 + ":344:54");
+                      } else {
+                        cur = tsplus_module_4.succeedNow(value, fileName_1 + ":346:52");
+                      }
+                      break;
+                    }
+                  case "UpdateTrace" /* ContinuationTag.UpdateTrace */:
+                    {
+                      if (cont.trace !== undefined) lastTrace = cont.trace;
+                      cur = tsplus_module_4.unit;
+                      break;
+                    }
+                }
+              } else {
+                return tsplus_module_16.succeed(value);
+              }
+              break;
+            }
+          case 4 /* IOTag.OnSuccessAndFailure */:
+          case 6 /* IOTag.OnFailure */:
+          case 5 /* IOTag.OnSuccess */:
+            {
+              this.stack.push(cur);
+              cur = cur.first;
+              break;
+            }
+          case 3 /* IOTag.Async */:
+            {
+              this.asyncTrace = lastTrace;
+              this.asyncBlockinOn = cur.blockingOn();
+              this.initiateAsync(this._runtimeFlags, cur.registerCallback);
+              throw cur;
+            }
+          case 8 /* IOTag.UpdateRuntimeFlagsWithin */:
+            {
+              const updateFlags = cur.update;
+              const oldRuntimeFlags = this._runtimeFlags;
+              const newRuntimeFlags = tsplus_module_10.patch(updateFlags, oldRuntimeFlags);
+              if (newRuntimeFlags === oldRuntimeFlags) {
+                cur = cur.scope(oldRuntimeFlags);
+              } else {
+                if (tsplus_module_9.interruptible(newRuntimeFlags) && this.isInterrupted()) {
+                  cur = tsplus_module_4.failCauseNow(this.getInterruptedCause(), fileName_1 + ":383:50");
+                } else {
+                  this.patchRuntimeFlags(this._runtimeFlags, updateFlags);
+                  const revertFlags = tsplus_module_9.diff(newRuntimeFlags, oldRuntimeFlags);
+                  this.stack.push(new RevertFlags(revertFlags));
+                  cur = cur.scope(oldRuntimeFlags);
+                }
+              }
+              break;
+            }
+          case 9 /* IOTag.GenerateStackTrace */:
+            {
+              cur = tsplus_module_4.succeedNow(this.generateStackTrace(), fileName_1 + ":394:44");
+              break;
+            }
+          case 10 /* IOTag.Stateful */:
+            {
+              cur = cur.onState(this, new Running(this._runtimeFlags, lastTrace));
+              break;
+            }
+          case 0 /* IOTag.SucceedNow */:
+            {
+              const oldCur = cur;
+              const cont = this.getNextSuccessCont();
+              if (cont) {
+                switch (cont._tag) {
+                  case 5 /* IOTag.OnSuccess */:
+                  case 4 /* IOTag.OnSuccessAndFailure */:
+                    {
+                      cur = cont.successK(oldCur.value);
+                      break;
+                    }
+                  case 11 /* IOTag.WhileLoop */:
+                    {
+                      cont.process(oldCur.value);
+                      if (cont.check()) {
+                        this.stack.push(cont);
+                        cur = cont.body();
+                      } else {
+                        cur = tsplus_module_4.unit;
+                      }
+                      break;
+                    }
+                  case "RevertFlags" /* ContinuationTag.RevertFlags */:
+                    {
+                      this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
+                      if (tsplus_module_9.interruptible(this._runtimeFlags) && this.isInterrupted()) {
+                        cur = tsplus_module_4.failCauseNow(this.getInterruptedCause(), fileName_1 + ":424:54");
+                      }
+                      break;
+                    }
+                  case "UpdateTrace" /* ContinuationTag.UpdateTrace */:
+                    {
+                      if (cont.trace !== undefined) lastTrace = cont.trace;
+                      cur = tsplus_module_4.unit;
+                      break;
+                    }
+                }
+              } else {
+                return tsplus_module_16.succeed(oldCur.value);
+              }
+              break;
+            }
+          case 1 /* IOTag.Fail */:
+            {
+              const cause = cur.cause();
+              const cont = this.getNextFailCont();
+              if (cont) {
+                switch (cont._tag) {
+                  case 6 /* IOTag.OnFailure */:
+                  case 4 /* IOTag.OnSuccessAndFailure */:
+                    {
+                      if (!(tsplus_module_9.interruptible(this._runtimeFlags) && this.isInterrupted())) {
+                        cur = cont.failureK(cause);
+                      } else {
+                        cur = tsplus_module_4.failCauseNow(tsplus_module_11.stripFailures(cause), fileName_1 + ":449:54");
+                      }
+                      break;
+                    }
+                  case "RevertFlags" /* ContinuationTag.RevertFlags */:
+                    {
+                      this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
+                      if (tsplus_module_9.interruptible(this._runtimeFlags) && this.isInterrupted()) {
+                        const interruptedCause = this.getInterruptedCause();
+                        if (tsplus_module_11.contains(interruptedCause)(cause)) {
+                          cur = tsplus_module_4.failCauseNow(cause, fileName_1 + ":458:56");
+                        } else {
+                          cur = tsplus_module_4.failCauseNow(tsplus_module_11.then(cause, this.getInterruptedCause()), fileName_1 + ":460:56");
+                        }
+                      }
+                      break;
+                    }
+                  case "UpdateTrace" /* ContinuationTag.UpdateTrace */:
+                    {
+                      if (cont.trace !== undefined) lastTrace = cont.trace;
+                      cur = tsplus_module_4.unit;
+                      break;
+                    }
+                }
+              } else {
+                return tsplus_module_16.failCause(cause);
+              }
+              break;
+            }
+          case 7 /* IOTag.UpdateRuntimeFlags */:
+            {
+              this.patchRuntimeFlags(this._runtimeFlags, cur.update);
+              cur = tsplus_module_4.unit;
+              break;
+            }
+          case 11 /* IOTag.WhileLoop */:
+            {
+              const iterate = cur;
+              const check = iterate.check;
+              const body = iterate.body;
+              if (check()) {
+                cur = body();
+                this.stack.push(iterate);
+              } else {
+                cur = tsplus_module_4.unit;
+              }
+              break;
+            }
+          case 12 /* IOTag.YieldNow */:
+            {
+              throw cur;
+            }
+        }
+      } catch (e) {
+        if (isIOError(e)) {
+          cur = tsplus_module_4.failCauseNow(e.cause, fileName_1 + ":499:44");
+        } else if (isIO(e) && (e._tag === 3 /* IOTag.Async */ || e._tag === 12 /* IOTag.YieldNow */)) {
+          throw e;
+        } else if (tsplus_module_14.isInterruptedException(e)) {
+          cur = tsplus_module_4.failCauseNow(tsplus_module_11.both(tsplus_module_11.halt(e), tsplus_module_11.interrupt(tsplus_module_17.none)), fileName_1 + ":503:44");
+        } else {
+          cur = tsplus_module_4.failCauseNow(tsplus_module_11.halt(e), fileName_1 + ":505:44");
+        }
+      }
+    }
+  }
+  getInterruptedCause() {
+    return this.getFiberRef(tsplus_module_12.interruptedCause);
+  }
+  isInterrupted() {
+    return !tsplus_module_18.isEmpty(this.getFiberRef(tsplus_module_12.interruptedCause));
+  }
+  getFiberRef(fiberRef) {
+    return tsplus_module_19.getOrDefault(this._fiberRefs, fiberRef);
+  }
+  tell(message) {
+    this.queue.enqueue(message);
+    if (!this.running) {
+      this.running = true;
+      this.drainQueueLaterOnExecutor();
+    }
+  }
+  exitValue() {
+    return this._exitValue;
+  }
+  addObserver(observer) {
+    if (this._exitValue !== null) observer(this._exitValue);else this.observers = tsplus_module_1.cons(observer, this.observers);
+  }
+  getChildren() {
+    if (this._children === null) {
+      this._children = new Set();
+    }
+    return this._children;
+  }
+  getFiberRefs() {
+    return this._fiberRefs;
+  }
+  setFiberRefs(fiberRefs0) {
+    this._fiberRefs = fiberRefs0;
+  }
+  patchRuntimeFlags(oldRuntimeFlags, patch) {
+    const newRuntimeFlags = tsplus_module_10.patch(patch, oldRuntimeFlags);
+    this._runtimeFlags = newRuntimeFlags;
+    return newRuntimeFlags;
+  }
+  sendInterruptSignalToAllChildren() {
+    if (this._children === null || this._children.size === 0) return false;else {
+      let told = false;
+      for (const child of this._children) {
+        if (child !== null) {
+          child.tell(tsplus_module_6.mkInterruptSignal(tsplus_module_11.interrupt(this.id)));
+          told = true;
+        }
+      }
+      return told;
+    }
+  }
+  interruptAllChildren() {
+    if (this.sendInterruptSignalToAllChildren()) {
+      const iterator = this._children[Symbol.iterator]();
+      this._children = null;
+      let value;
+      const check = () => {
+        value = iterator.next();
+        return !value.done;
+      };
+      const body = () => {
+        if (value != null && !value.done) {
+          return value.value.await;
+        } else {
+          return tsplus_module_4.unit;
+        }
+      };
+      return new WhileLoop(check, body, () => {
+        //
+      }, this.id.location);
+    } else {
+      return null;
+    }
+  }
+  initiateAsync(runtimeFlags, asyncRegister) {
+    let alreadyCalled = false;
+    const callback = effect => {
+      if (!alreadyCalled) {
+        alreadyCalled = true;
+        this.tell(tsplus_module_6.mkResume(effect));
+      }
+    };
+    if (tsplus_module_9.interruptible(runtimeFlags)) this.asyncInterruptor = callback;
+    try {
+      asyncRegister(callback);
+    } catch (e) {
+      callback(tsplus_module_4.failCauseNow(tsplus_module_11.halt(e), fileName_1 + ":626:31"));
+    }
+  }
+  setFiberRef(fiberRef, value) {
+    this._fiberRefs = tsplus_module_19.updateAs(this._fiberRefs, this.fiberId, fiberRef, value);
+  }
+  addInterruptedCause(cause) {
+    const oldSC = this.getFiberRef(tsplus_module_12.interruptedCause);
+    if (tsplus_module_11.contains(cause)(oldSC)) {
+      return;
+    }
+    this.setFiberRef(tsplus_module_12.interruptedCause, tsplus_module_11.then(oldSC, cause));
+  }
+  processNewInterruptSignal(cause) {
+    this.addInterruptedCause(cause);
+    this.sendInterruptSignalToAllChildren();
+  }
+  evaluateMessageWhileSuspended(fiberMessage) {
+    switch (fiberMessage._tag) {
+      case 0 /* FiberMessageTag.InterruptSignal */:
+        {
+          this.processNewInterruptSignal(fiberMessage.cause);
+          if (this.asyncInterruptor !== null) {
+            this.asyncInterruptor(tsplus_module_4.failCause(() => fiberMessage.cause, fileName_1 + ":653:45"));
+            this.asyncInterruptor = null;
+          }
+          return 0 /* EvaluationSignal.Continue */;
+        }
+
+      case 1 /* FiberMessageTag.GenStackTrace */:
+        {
+          fiberMessage.onTrace(this.generateStackTrace());
+          return 0 /* EvaluationSignal.Continue */;
+        }
+
+      case 2 /* FiberMessageTag.Stateful */:
+        {
+          let status;
+          if (this._exitValue !== null) {
+            status = new Done();
+          } else if (this.asyncTrace === null) {
+            status = new Running(this._runtimeFlags, null);
+          } else {
+            status = new Suspended(this._runtimeFlags, this.asyncBlockinOn, this.asyncTrace);
+          }
+          fiberMessage.onFiber(this, status);
+          return 0 /* EvaluationSignal.Continue */;
+        }
+
+      case 3 /* FiberMessageTag.Resume */:
+        {
+          this.asyncInterruptor = null;
+          this.asyncTrace = null;
+          this.asyncBlockinOn = null;
+          this.evaluateEffect(fiberMessage.cont);
+          return 0 /* EvaluationSignal.Continue */;
+        }
+
+      case 4 /* FiberMessageTag.YieldNow */:
+        {
+          return 1 /* EvaluationSignal.YieldNow */;
+        }
+    }
+  }
+
+  generateStackTrace() {
+    const builder = new StackTraceBuilder();
+    const stack = this.stack.clone();
+    while (stack.hasNext) {
+      builder.append(tsplus_module_20.parse(stack.pop().trace));
+    }
+    return new Trace(this.fiberId, builder.result());
+  }
+  setExitValue(exit) {
+    this._exitValue = exit;
+    for (const observer of this.observers) {
+      observer(exit);
+    }
+    this.observers = tsplus_module_1.empty();
+  }
+  resume(effect) {
+    this.tell(tsplus_module_6.mkResume(effect));
+  }
+  start(effect) {
+    if (!this.running) {
+      try {
+        this.running = true;
+        this.evaluateEffect(effect);
+      } finally {
+        this.running = false;
+        if (!this.queue.isEmpty) {
+          this.drainQueueLaterOnExecutor();
+        }
+      }
+    } else {
+      this.tell(tsplus_module_6.mkResume(effect));
+    }
+  }
+  startFork(effect) {
+    this.tell(tsplus_module_6.mkResume(effect));
+  }
+  updateFiberRef(fiberRef, f) {
+    this.setFiberRef(fiberRef, f(this.getFiberRef(fiberRef)));
+  }
+  removeObserver(observer) {
+    this.observers = tsplus_module_21.filter(f => f !== observer)(this.observers);
+  }
+  addChild(child) {
+    this.getChildren().add(child);
+  }
+  removeChild(child) {
+    if (this._children !== null) {
+      this._children.delete(child);
+    }
+  }
+  get scope() {
+    return tsplus_module_22.unsafeMake(this);
+  }
+  log(message, cause, overrideLogLevel, trace) {
+    const logLevel = tsplus_module_23.getOrElse(() => this.getFiberRef(tsplus_module_12.currentLogLevel))(overrideLogLevel);
+    const spans = this.getFiberRef(tsplus_module_12.currentLogSpan);
+    const annotations = this.getFiberRef(tsplus_module_12.currentLogAnnotations);
+    const contextMap = this.getFiberRefs();
+    tsplus_module_26.filterLogLevel(level => tsplus_module_24.gte(tsplus_module_24.Info)(level))(tsplus_module_26.map(s => console.log(s))(tsplus_module_25.defaultString)).log(tsplus_module_20.parse(trace), this.fiberId, logLevel, message, cause, contextMap, spans, annotations);
+  }
+  deleteFiberRef(ref) {
+    this._fiberRefs = tsplus_module_19.remove(this._fiberRefs, ref);
+  }
+  get status() {
+    return this.ask((_, status) => status);
+  }
+  get trace() {
+    return tsplus_module_4.defer(() => {
+      const future = tsplus_module_3.unsafeMake(this.fiberId);
+      this.tell(tsplus_module_6.mkGenStackTrace(trace => tsplus_module_5.unsafeDone(tsplus_module_4.succeedNow(trace, fileName_1 + ":790:86"), fileName_1 + ":790:72")(future)));
+      return tsplus_module_5.wait(future, fileName_1 + ":791:20");
+    }, fileName_1 + ":788:20");
+  }
+  getNextSuccessCont() {
+    while (this.stack.hasNext) {
+      const frame = this.stack.pop();
+      if (frame._tag !== 6 /* IOTag.OnFailure */) {
+        return frame;
+      }
+    }
+  }
+  getNextFailCont() {
+    while (this.stack.hasNext) {
+      const frame = this.stack.pop();
+      if (frame._tag !== 5 /* IOTag.OnSuccess */ && frame._tag !== 11 /* IOTag.WhileLoop */) {
+        return frame;
+      }
+    }
+  }
+  isFatal(t) {
+    return this.getFiberRef(tsplus_module_12.currentIsFatal).apply(t);
+  }
+}
+//# sourceMappingURL=FiberRuntime.mjs.map