@fncts/io 0.0.48 → 0.0.50

package/_mjs/Fiber/FiberRuntime.mjs

@@ -1,152 +1,697 @@
 var _a;
 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/api";
-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/io/STM/api/atomically";
-import * as tsplus_module_18 from "@fncts/io/IO/api/environment";
-import * as tsplus_module_19 from "@fncts/base/data/FiberId/constructors";
-import * as tsplus_module_20 from "@fncts/base/data/TraceElement/definition";
-import * as tsplus_module_21 from "@fncts/base/data/Trace/constructors";
-import * as tsplus_module_22 from "@fncts/base/data/Cause/api/isEmpty";
-import * as tsplus_module_23 from "@fncts/base/collection/immutable/HashMap/api";
-import * as tsplus_module_24 from "@fncts/io/FiberRef/api";
-import * as tsplus_module_25 from "@fncts/base/collection/immutable/List/api";
-import * as tsplus_module_26 from "@fncts/io/FiberScope/constructors";
-import * as tsplus_module_27 from "@fncts/base/data/Maybe/api";
-import * as tsplus_module_28 from "@fncts/io/LogLevel";
-import * as tsplus_module_29 from "@fncts/io/Logger/constructors";
-import * as tsplus_module_30 from "@fncts/io/Logger/api";
+import * as tsplus_module_1 from "@fncts/io/IO/api";
+import * as tsplus_module_2 from "@fncts/io/FiberRefs/api";
+import * as tsplus_module_3 from "@fncts/io/RuntimeFlags/RuntimeFlags";
+import * as tsplus_module_4 from "@fncts/io/RuntimeFlags/Patch";
+import * as tsplus_module_5 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_6 from "@fncts/io/FiberScope/constructors";
+import * as tsplus_module_7 from "@fncts/base/collection/immutable/List/constructors";
+import * as tsplus_module_8 from "@fncts/base/data/TraceElement/definition";
+import * as tsplus_module_9 from "@fncts/base/collection/immutable/HashMap/api";
+import * as tsplus_module_10 from "@fncts/io/FiberRef/api";
+import * as tsplus_module_11 from "@fncts/io/FiberRef/unsafe";
+import * as tsplus_module_12 from "@fncts/base/data/Exit/constructors";
+import * as tsplus_module_13 from "@fncts/base/collection/immutable/Conc/constructors";
+import * as tsplus_module_14 from "@fncts/base/data/Trace/constructors";
+import * as tsplus_module_15 from "@fncts/base/data/Cause/api";
+import * as tsplus_module_16 from "@fncts/io/Fiber/FiberMessage";
+import * as tsplus_module_17 from "@fncts/base/data/Cause/api/isEmpty";
+import * as tsplus_module_18 from "@fncts/base/data/Maybe/api";
+import * as tsplus_module_19 from "@fncts/io/LogLevel";
+import * as tsplus_module_20 from "@fncts/io/Logger/constructors";
+import * as tsplus_module_21 from "@fncts/io/Logger/api";
+import * as tsplus_module_22 from "@fncts/base/collection/immutable/List/api";
+import * as tsplus_module_23 from "@fncts/io/IO/definition";
+import * as tsplus_module_24 from "@fncts/base/data/Exit/api";
+import * as tsplus_module_25 from "@fncts/io/FiberStatus/constructors";
+import * as tsplus_module_26 from "@fncts/io/STM/api/atomically";
+import * as tsplus_module_27 from "@fncts/base/data/exceptions";
+import * as tsplus_module_28 from "@fncts/io/IO/api/environment";
+import * as tsplus_module_29 from "@fncts/base/collection/immutable/Conc/api";
+import * as tsplus_module_30 from "@fncts/base/data/Either/constructors";
+import * as tsplus_module_31 from "@fncts/io/IO/api/asyncInterrupt";
+import * as tsplus_module_32 from "@fncts/base/collection/immutable/Conc/api/empty";
+import * as tsplus_module_33 from "@fncts/base/data/FiberId/constructors";
+import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
 import { isIOError } from "@fncts/base/data/exceptions";
 import { Trace } from "@fncts/base/data/Trace";
+import { assert } from "@fncts/base/util/assert";
 import { FiberTypeId, FiberVariance } 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 { IOPrimitive, isIO } from "../IO/definition.mjs";
-export class RevertFlags {
-  constructor(patch, trace) {
-    this.patch = patch;
-    this.trace = trace;
-    this._ioOpCode = 14 /* IOTag.RevertFlags */;
-  }
-}
-export class UpdateTrace {
-  constructor(trace) {
-    this.trace = trace;
-    this._ioOpCode = 15 /* IOTag.UpdateTrace */;
-  }
-}
+import { IOPrimitive } from "../IO/definition.mjs";
+const MAX_FORKS_BEFORE_YIELD = 128;
+const MAX_DEPTH_BEFORE_TRAMPOLINE = 300;
+const INITIAL_STACK_SIZE = 16;
+const STACK_IDX_GC_THRESHOLD = 128;
 /**
  * @tsplus type fncts.io.Fiber
  */
 export class FiberRuntime {
+  get await() {
+    return tsplus_module_1.defer(() => this.awaitUnsafe(), fileName_1 + ":48:20");
+  }
+  get children() {
+    return tsplus_module_1.succeed(() => this.childrenChunk(this._children), fileName_1 + ":52:14");
+  }
+  get fiberRefs() {
+    return tsplus_module_1.succeed(() => this._fiberRefs, fileName_1 + ":56:14");
+  }
+  get id() {
+    return this.fiberId;
+  }
+  get inheritAll() {
+    return tsplus_module_1.withFiberRuntime((parentFiber, parentStatus) => {
+      const parentFiberId = parentFiber.id;
+      const parentFiberRefs = parentFiber.getFiberRefs();
+      const parentRuntimeFlags = parentStatus.runtimeFlags;
+      const childFiberRefs = this.getFiberRefs();
+      const updatedFiberRefs = tsplus_module_2.join(parentFiberId, childFiberRefs)(parentFiberRefs);
+      parentFiber.setFiberRefs(updatedFiberRefs);
+      return tsplus_module_1.flatMap(childRuntimeFlags => {
+        const patch = tsplus_module_4.exclude(tsplus_module_4.exclude(tsplus_module_3.diff(parentRuntimeFlags, childRuntimeFlags), 64 /* RuntimeFlag.WindDown */), 1 /* RuntimeFlag.Interruption */);
+        return tsplus_module_1.updateRuntimeFlags(patch, fileName_1 + ":80:37");
+      }, fileName_1 + ":74:39")(this.runtimeFlags);
+    }, fileName_1 + ":64:31");
+  }
+  get poll() {
+    return tsplus_module_1.succeed(() => tsplus_module_5.fromNullable(this.exitValue()), fileName_1 + ":86:22");
+  }
+  get runtimeFlags() {
+    return tsplus_module_1.succeed(() => this._runtimeFlags, fileName_1 + ":90:14");
+  }
+  get scope() {
+    return tsplus_module_6.unsafeMake(this);
+  }
+  get status() {
+    return tsplus_module_1.succeed(() => this.getStatus(), fileName_1 + ":98:14");
+  }
+  get trace() {
+    return tsplus_module_1.succeed(() => this.generateStackTrace(), fileName_1 + ":102:14");
+  }
   constructor(fiberId, fiberRefs0, runtimeFlags0) {
     this.fiberId = fiberId;
     this.runtimeFlags0 = runtimeFlags0;
-    this[_a] = FiberTypeId;
     this._tag = "RuntimeFiber";
-    this.queue = new LinkedQueue();
+    this[_a] = FiberTypeId;
+    this.location = this.fiberId.location;
+    this._asyncContWith = null;
+    this._blockingOn = null;
     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._forksSinceYield = 0;
+    this._stack = null;
+    this._stackSize = 0;
+    this.inbox = new LinkedQueue();
+    this.observers = tsplus_module_7.make();
+    this.running = false;
     this._fiberRefs = fiberRefs0;
     this._runtimeFlags = runtimeFlags0;
   }
-  get id() {
-    return this.fiberId;
+  addChild(child) {
+    this.getChildren().add(child);
   }
-  ask(f) {
-    return tsplus_module_4.defer(() => {
-      const future = tsplus_module_3.unsafeMake(this.fiberId);
-      this.tell(tsplus_module_6.stateful((fiber, status) => tsplus_module_5.unsafeDone(tsplus_module_4.succeed(() => f(fiber, status), fileName_1 + ":78:86"), fileName_1 + ":78:75")(future)));
-      return tsplus_module_5.wait(future, fileName_1 + ":80:20");
-    }, fileName_1 + ":75:20");
+  addChildren(children) {
+    if (this.isAlive()) {
+      const childs = this.getChildren();
+      if (this.shouldInterrupt()) {
+        const cause = this.getInterruptedCause();
+        for (const child of children) {
+          if (child.isAlive()) {
+            childs.add(child);
+            child.tellInterrupt(cause);
+          }
+        }
+      } else {
+        for (const child of children) {
+          if (child.isAlive()) {
+            childs.add(child);
+          }
+        }
+      }
+    } else {
+      const cause = this.getInterruptedCause();
+      for (const child of children) {
+        if (child.isAlive()) {
+          child.tellInterrupt(cause);
+        }
+      }
+    }
   }
-  get await() {
-    return tsplus_module_4.async(cb => this.tell(tsplus_module_6.stateful((fiber, _) => {
-      if (fiber._exitValue !== null) cb(tsplus_module_4.succeedNow(fiber.exitValue(), fileName_1 + ":89:60"));else fiber.addObserver(exit => cb(tsplus_module_4.succeedNow(exit, fileName_1 + ":90:62")));
-    })), this.id, fileName_1 + ":85:20");
+  addObserver(observer) {
+    if (this._exitValue !== null) observer(this._exitValue);else this.observers = tsplus_module_7.cons(observer, this.observers);
   }
-  get children() {
-    return this.ask(fiber => tsplus_module_7.from(fiber.getChildren()));
+  deleteFiberRef(ref) {
+    this._fiberRefs = tsplus_module_2.remove(this._fiberRefs, ref);
   }
-  get fiberRefs() {
-    return this.ask(fiber => fiber.getFiberRefs());
+  exitValue() {
+    return this._exitValue;
   }
-  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 + ":122:37");
-      }, fileName_1 + ":116:39")(this.runtimeFlags);
-    }, fileName_1 + ":106:31");
+  generateStackTrace() {
+    const builder = new StackTraceBuilder();
+    const stack = this._stack;
+    const size = this._stackSize;
+    if (stack !== null) {
+      for (let i = stack.length < size ? stack.length : size; i >= 0; i--) {
+        const k = stack[i];
+        if (k != null) {
+          builder.append(tsplus_module_8.parse(k.trace));
+        }
+      }
+      builder.append(tsplus_module_8.parse(this.id.location));
+    }
+    return new Trace(this.fiberId, builder.result());
   }
-  get runtimeFlags() {
-    return this.ask((state, status) => {
-      if (status._tag === 0 /* FiberStatusTag.Done */) return state._runtimeFlags;else return status.runtimeFlags;
-    });
+  getChildren() {
+    let children = this._children;
+    if (children === null) {
+      children = new IterableWeakSet();
+      this._children = children;
+    }
+    return children;
   }
-  interruptAsFork(fiberId) {
-    return tsplus_module_4.succeed(() => {
-      const cause = tsplus_module_11.interrupt(fiberId);
-      this.tell(tsplus_module_6.interruptSignal(cause));
-    }, fileName_1 + ":135:22");
+  getFiberRef(fiberRef) {
+    if (tsplus_module_9.has(fiberRef)(this._fiberRefs)) {
+      return tsplus_module_9.unsafeGet(fiberRef)(this._fiberRefs).head[1];
+    }
+    return tsplus_module_10.initial(fiberRef);
+  }
+  getFiberRefs() {
+    return this._fiberRefs;
+  }
+  getInterruptedCause() {
+    return this.getFiberRef(tsplus_module_11.interruptedCause);
   }
   getSupervisor() {
-    return this.getFiberRef(tsplus_module_12.currentSupervisor);
+    return this.getFiberRef(tsplus_module_11.currentSupervisor);
   }
-  get poll() {
-    return tsplus_module_4.succeed(() => tsplus_module_13.fromNullable(this.exitValue()), fileName_1 + ":146:22");
+  interruptAs(fiberId, __tsplusTrace) {
+    return tsplus_module_1.defer(() => {
+      const exit = this._exitValue;
+      if (exit !== null) {
+        return tsplus_module_12.succeed(exit, fileName_1 + ":224:28");
+      } else {
+        const cause = tsplus_module_15.interrupt(fiberId, tsplus_module_14.make(this.fiberId, tsplus_module_13.single(tsplus_module_8.parse(__tsplusTrace))));
+        this.tell(tsplus_module_16.interruptSignal(cause));
+        return this.awaitUnsafe(__tsplusTrace);
+      }
+    }, fileName_1 + ":221:20");
   }
-  run() {
-    this.drainQueueOnCurrentThread();
+  interruptAsFork(fiberId, __tsplusTrace) {
+    return tsplus_module_1.succeed(() => {
+      const cause = tsplus_module_15.interrupt(fiberId);
+      this.tell(tsplus_module_16.interruptSignal(cause));
+    }, fileName_1 + ":234:22");
+  }
+  isAlive() {
+    return this.exitValue === null;
+  }
+  isDone() {
+    return this.exitValue !== null;
+  }
+  isFatal(t) {
+    return this.getFiberRef(tsplus_module_11.currentIsFatal).apply(t);
+  }
+  isInterrupted() {
+    return !tsplus_module_17.isEmpty(this.getFiberRef(tsplus_module_11.interruptedCause));
+  }
+  log(message, cause, overrideLogLevel, trace) {
+    const logLevel = tsplus_module_18.getOrElse(() => this.getFiberRef(tsplus_module_11.currentLogLevel))(overrideLogLevel);
+    const spans = this.getFiberRef(tsplus_module_11.currentLogSpan);
+    const annotations = this.getFiberRef(tsplus_module_11.currentLogAnnotations);
+    const contextMap = this.getFiberRefs();
+    tsplus_module_21.filterLogLevel(level => tsplus_module_19.gte(tsplus_module_19.Info)(level))(tsplus_module_21.map(s => console.log(s))(tsplus_module_20.defaultString)).log(tsplus_module_8.parse(trace), this.fiberId, logLevel, message, cause, contextMap, spans, annotations);
+  }
+  removeChild(child) {
+    if (this._children !== null) {
+      this._children.delete(child);
+    }
+  }
+  removeObserver(observer) {
+    this.observers = tsplus_module_22.filter(f => f !== observer)(this.observers);
+  }
+  resume(effect) {
+    this.tell(tsplus_module_16.resume(effect));
+  }
+  runLoop(effect, minStackIndex, startStackIndex, currentDepth, currentOps) {
+    assert(this.running, "Invalid state in FiberRuntime: Fiber is not running");
+    let op = effect;
+    let ops = currentOps;
+    let stackIndex = startStackIndex;
+    if (currentDepth >= MAX_DEPTH_BEFORE_TRAMPOLINE) {
+      this.inbox.enqueue(tsplus_module_16.resume(effect));
+      return null;
+    }
+    while (true) {
+      if ((this._runtimeFlags & 8 /* RuntimeFlag.OpSupervision */) !== 0) {
+        this.getSupervisor().unsafeOnEffect(this, op);
+      }
+      op = this.drainQueueWhileRunning(op);
+      ops += 1;
+      if (ops > this.getFiberRef(tsplus_module_11.currentMaxFiberOps)) {
+        this.updateLastTrace(op.trace);
+        this.inbox.enqueue(tsplus_module_16.resume(op));
+        return null;
+      }
+      switch (op._ioOpCode) {
+        case 0 /* IOTag.SucceedNow */:
+          {
+            const value = op.i0;
+            op = null;
+            while (op === null && stackIndex > minStackIndex) {
+              stackIndex -= 1;
+              const continuation = this._stack[stackIndex];
+              this.popStackFrame(stackIndex);
+              switch (continuation._ioOpCode) {
+                case 5 /* IOTag.OnSuccess */:
+                  op = continuation.i1(value);
+                  break;
+                case 4 /* IOTag.OnSuccessAndFailure */:
+                  op = continuation.i2(value);
+                  break;
+                case 6 /* IOTag.UpdateRuntimeFlags */:
+                  op = this.patchRuntimeFlags(continuation.i0, null, null);
+                  break;
+              }
+            }
+            if (op === null) {
+              return tsplus_module_12.succeed(value, fileName_1 + ":348:32");
+            }
+            break;
+          }
+        case 2 /* IOTag.Sync */:
+          {
+            this.updateLastTrace(op.trace);
+            const value = op.i0();
+            op = null;
+            while (op === null && stackIndex > minStackIndex) {
+              stackIndex -= 1;
+              const continuation = this._stack[stackIndex];
+              this.popStackFrame(stackIndex);
+              switch (continuation._ioOpCode) {
+                case 5 /* IOTag.OnSuccess */:
+                  op = continuation.i1(value);
+                  break;
+                case 4 /* IOTag.OnSuccessAndFailure */:
+                  op = continuation.i2(value);
+                  break;
+                case 6 /* IOTag.UpdateRuntimeFlags */:
+                  op = this.patchRuntimeFlags(continuation.i0, null, null);
+                  break;
+              }
+            }
+            if (op === null) {
+              return tsplus_module_12.succeed(value, fileName_1 + ":378:32");
+            }
+            break;
+          }
+        case 5 /* IOTag.OnSuccess */:
+          {
+            this.updateLastTrace(op.trace);
+            const first = op.i0;
+            if (first === tsplus_module_1.unit) {
+              op = op.i1(undefined);
+            } else {
+              stackIndex = this.pushStackFrame(op, stackIndex);
+              const result = this.runLoop(first, stackIndex, stackIndex, currentDepth + 1, ops);
+              ops += 1;
+              if (result === null) {
+                return null;
+              }
+              stackIndex -= 1;
+              this.popStackFrame(stackIndex);
+              switch (result._tag) {
+                case "Success" /* ExitTag.Success */:
+                  op = op.i1(result.value);
+                  break;
+                case "Failure" /* ExitTag.Failure */:
+                  op = tsplus_module_1.failCauseNow(result.cause, fileName_1 + ":407:49");
+                  break;
+              }
+            }
+            break;
+          }
+        case 4 /* IOTag.OnSuccessAndFailure */:
+          {
+            this.updateLastTrace(op.trace);
+            stackIndex = this.pushStackFrame(op, stackIndex);
+            const result = this.runLoop(op.i0, stackIndex, stackIndex, currentDepth + 1, ops);
+            ops += 1;
+            if (result === null) {
+              return null;
+            }
+            stackIndex -= 1;
+            this.popStackFrame(stackIndex);
+            switch (result._tag) {
+              case "Success" /* ExitTag.Success */:
+                {
+                  op = op.i2(result.value);
+                  break;
+                }
+              case "Failure" /* ExitTag.Failure */:
+                {
+                  const cause = result.cause;
+                  if (this.shouldInterrupt()) {
+                    op = tsplus_module_1.failCauseNow(tsplus_module_15.stripFailures(cause), fileName_1 + ":436:49");
+                  } else {
+                    op = op.i1(result.cause);
+                  }
+                }
+            }
+            break;
+          }
+        case 3 /* IOTag.Async */:
+          {
+            this.updateLastTrace(op.trace);
+            this._blockingOn = op.i1();
+            op = this.initiateAsync(op.i0);
+            if (op === null) {
+              op = this.drainQueueAfterAsync();
+            }
+            if (op === null) {
+              return null;
+            }
+            if (this.shouldInterrupt()) {
+              op = tsplus_module_1.failCauseNow(this.getInterruptedCause(), fileName_1 + ":460:45");
+            }
+            break;
+          }
+        case 7 /* IOTag.UpdateRuntimeFlagsWithin */:
+          {
+            const trace = op.trace;
+            this.updateLastTrace(trace);
+            const updateFlags = op.i0;
+            const oldRuntimeFlags = this._runtimeFlags;
+            const newRuntimeFlags = tsplus_module_4.patch(updateFlags, oldRuntimeFlags);
+            if (newRuntimeFlags === oldRuntimeFlags) {
+              op = op.i1(oldRuntimeFlags);
+            } else {
+              if (tsplus_module_3.interruptible(newRuntimeFlags) && this.isInterrupted()) {
+                op = tsplus_module_1.failCauseNow(this.getInterruptedCause(), fileName_1 + ":476:47");
+              } else {
+                this.patchRuntimeFlagsOnly(updateFlags);
+                const revertFlags = tsplus_module_3.diff(newRuntimeFlags, oldRuntimeFlags);
+                const k = tsplus_module_1.updateRuntimeFlags(revertFlags, trace);
+                stackIndex = this.pushStackFrame(k, stackIndex);
+                const exit = this.runLoop(op.i1(oldRuntimeFlags), stackIndex, stackIndex, currentDepth + 1, ops);
+                ops += 1;
+                if (exit === null) {
+                  return null;
+                }
+                stackIndex -= 1;
+                this.popStackFrame(stackIndex);
+                op = this.patchRuntimeFlags(revertFlags, tsplus_module_24.causeOrNull(exit), exit);
+              }
+            }
+            break;
+          }
+        case 8 /* IOTag.Stateful */:
+          {
+            const trace = op.trace;
+            this.updateLastTrace(trace);
+            op = op.i0(this, tsplus_module_25.running(this._runtimeFlags, trace));
+            break;
+          }
+        case 1 /* IOTag.Fail */:
+          {
+            let cause = op.i0();
+            op = null;
+            while (op === null && stackIndex > minStackIndex) {
+              stackIndex -= 1;
+              const continuation = this._stack[stackIndex];
+              this.popStackFrame(stackIndex);
+              switch (continuation._ioOpCode) {
+                case 4 /* IOTag.OnSuccessAndFailure */:
+                  {
+                    if (this.shouldInterrupt()) {
+                      cause = tsplus_module_15.stripFailures(cause);
+                    } else {
+                      op = continuation.i1(cause);
+                    }
+                    break;
+                  }
+                case 6 /* IOTag.UpdateRuntimeFlags */:
+                  op = this.patchRuntimeFlags(continuation.i0, cause, null);
+                  break;
+              }
+            }
+            if (op === null) {
+              return tsplus_module_12.failCause(cause, fileName_1 + ":535:34");
+            }
+            break;
+          }
+        case 6 /* IOTag.UpdateRuntimeFlags */:
+          {
+            this.updateLastTrace(op.trace);
+            op = this.patchRuntimeFlags(op.i0, null, tsplus_module_1.unit);
+            break;
+          }
+        case 9 /* IOTag.WhileLoop */:
+          {
+            const iterate = op;
+            this.updateLastTrace(iterate.trace);
+            const check = iterate.i0;
+            const body = iterate.i1;
+            const process = iterate.i2;
+            stackIndex = this.pushStackFrame(iterate, stackIndex);
+            op = null;
+            const nextDepth = currentDepth + 1;
+            while (op === null && check()) {
+              const exit = this.runLoop(body(), stackIndex, stackIndex, nextDepth, ops);
+              if (exit === null) {
+                return null;
+              }
+              switch (exit._tag) {
+                case "Success" /* ExitTag.Success */:
+                  process(exit.value);
+                  break;
+                case "Failure" /* ExitTag.Failure */:
+                  op = tsplus_module_1.failCauseNow(exit.cause, fileName_1 + ":570:49");
+                  break;
+              }
+              ops += 1;
+            }
+            stackIndex -= 1;
+            this.popStackFrame(stackIndex);
+            if (op === null) {
+              op = tsplus_module_1.unit;
+            }
+            break;
+          }
+        case 10 /* IOTag.YieldNow */:
+          {
+            this.updateLastTrace(op.trace);
+            this.inbox.enqueue(tsplus_module_16.resume(tsplus_module_1.unit));
+            return null;
+          }
+        case 11 /* IOTag.Commit */:
+          {
+            op = tsplus_module_26.atomically(op, fileName_1 + ":592:30");
+            break;
+          }
+        case 13 /* IOTag.External */:
+          {
+            op = op.toIO;
+            break;
+          }
+        case null:
+          {
+            switch (op._tag) {
+              case "Just" /* MaybeTag.Just */:
+                {
+                  op = tsplus_module_1.succeedNow(op.value, fileName_1 + ":602:45");
+                  break;
+                }
+              case "Nothing" /* MaybeTag.Nothing */:
+                {
+                  op = tsplus_module_1.failNow(new tsplus_module_27.NoSuchElementError(), fileName_1 + ":606:42");
+                  break;
+                }
+              case "Left" /* EitherTag.Left */:
+                {
+                  op = tsplus_module_1.failNow(op.left, fileName_1 + ":610:42");
+                  break;
+                }
+              case "Right" /* EitherTag.Right */:
+                {
+                  op = tsplus_module_1.succeedNow(op.right, fileName_1 + ":614:45");
+                  break;
+                }
+              case "Failure" /* ExitTag.Failure */:
+                {
+                  op = tsplus_module_1.failCauseNow(op.cause, fileName_1 + ":618:47");
+                  break;
+                }
+              case "Success" /* ExitTag.Success */:
+                {
+                  op = tsplus_module_1.succeedNow(op.value, fileName_1 + ":622:45");
+                  break;
+                }
+              case "Tag":
+                {
+                  op = tsplus_module_28.service(op, fileName_1 + ":626:42");
+                  break;
+                }
+            }
+          }
+      }
+    }
+    throw new Error("runLoop must exist with a return statement from within the while loop");
+  }
+  setFiberRef(fiberRef, value) {
+    this._fiberRefs = tsplus_module_2.updateAs(this._fiberRefs, this.fiberId, fiberRef, value);
+  }
+  setFiberRefs(fiberRefs0) {
+    this._fiberRefs = fiberRefs0;
+  }
+  shouldYieldBeforeFork() {
+    if (tsplus_module_3.cooperativeYielding(this._runtimeFlags)) {
+      this._forksSinceYield += 1;
+      return this._forksSinceYield >= MAX_FORKS_BEFORE_YIELD;
+    }
+    return false;
+  }
+  start(effect) {
+    let result = null;
+    if (!this.running) {
+      try {
+        this.running = true;
+        result = this.evaluateEffect(0, effect);
+      } finally {
+        this.running = false;
+        if (!this.inbox.isEmpty) {
+          this.running = true;
+          this.drainQueueLaterOnExecutor();
+        }
+      }
+    } else {
+      this.tell(tsplus_module_16.resume(effect));
+    }
+    return result;
+  }
+  startConcurrently(io) {
+    this.tell(tsplus_module_16.resume(io));
+  }
+  startFork(effect) {
+    this.tell(tsplus_module_16.resume(effect));
+  }
+  startSuspended() {
+    let alreadyCalled = false;
+    const callback = io => {
+      if (!alreadyCalled) {
+        alreadyCalled = true;
+        this.tell(tsplus_module_16.resume(io));
+      }
+    };
+    this._asyncContWith = callback;
+    return callback;
+  }
+  tell(message) {
+    this.inbox.enqueue(message);
+    if (!this.running) {
+      this.running = true;
+      this.drainQueueLaterOnExecutor();
+    }
+  }
+  tellAddChild(child) {
+    return this.tell(tsplus_module_16.stateful(parentFiber => parentFiber.addChild(child)));
+  }
+  tellAddChildren(children) {
+    return this.tell(tsplus_module_16.stateful(parentFiber => parentFiber.addChildren(children)));
+  }
+  tellInterrupt(cause) {
+    this.tell(tsplus_module_16.interruptSignal(cause));
+  }
+  transferChildren(scope) {
+    const children = this._children;
+    if (children !== null && children.size > 0) {
+      const childs = this.childrenChunk(children);
+      this._children = null;
+      if (!tsplus_module_29.isEmpty(childs)) {
+        const flags = this._runtimeFlags;
+        for (const child of childs) {
+          scope.unsafeAdd(this, flags, child);
+        }
+      }
+    }
+  }
+  updateFiberRef(fiberRef, f) {
+    this.setFiberRef(fiberRef, f(this.getFiberRef(fiberRef)));
+  }
+  addInterruptedCause(cause) {
+    const oldSC = this.getFiberRef(tsplus_module_11.interruptedCause);
+    if (tsplus_module_15.contains(cause)(oldSC)) {
+      return;
+    }
+    this.setFiberRef(tsplus_module_11.interruptedCause, tsplus_module_15.sequential(oldSC, cause));
+  }
+  awaitUnsafe(trace) {
+    const exitValue = this._exitValue;
+    if (exitValue !== null) {
+      return tsplus_module_12.succeed(exitValue, fileName_1 + ":746:26");
+    } else {
+      return tsplus_module_31.asyncInterrupt(k => {
+        const cb = exit => k(tsplus_module_1.succeedNow(exit, fileName_1 + ":750:63"));
+        this.addObserver(cb);
+        return tsplus_module_30.left(tsplus_module_1.succeed(() => this.removeObserver(cb), fileName_1 + ":752:32"), fileName_1 + ":752:29");
+      }, this.id, trace);
+    }
+  }
+  childrenChunk(children) {
+    if (children === null) {
+      return tsplus_module_32.empty();
+    }
+    const builder = tsplus_module_29.builder();
+    children.forEach(child => {
+      if (child !== null) {
+        builder.append(child);
+      }
+    });
+    return builder.result();
+  }
+  drainQueueAfterAsync() {
+    let resumption = null;
+    let message = this.inbox.dequeue(null);
+    while (message !== null) {
+      switch (message._tag) {
+        case 0 /* FiberMessageTag.InterruptSignal */:
+          this.processNewInterruptSignal(message.cause);
+          break;
+        case 1 /* FiberMessageTag.Stateful */:
+          this.processStatefulMessage(message.onFiber);
+          break;
+        case 2 /* FiberMessageTag.Resume */:
+          resumption = message.cont;
+          break;
+      }
+      message = this.inbox.dequeue(null);
+    }
+    return resumption;
+  }
+  drainQueueLaterOnExecutor() {
+    // assert(this.running, "Invalid state in FiberRuntime: Fiber is not running");
+    this.getFiberRef(tsplus_module_11.currentScheduler).scheduleTask(() => this.run());
   }
-  drainQueueOnCurrentThread() {
+  drainQueueOnCurrentThread(depth) {
     // 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)) {
+      if (tsplus_module_3.currentFiber(this._runtimeFlags)) {
         // TODO
       }
       try {
         while (evaluationSignal === 0 /* EvaluationSignal.Continue */) {
-          evaluationSignal = this.queue.isEmpty ? 2 /* EvaluationSignal.Done */ : this.evaluateMessageWhileSuspended(this.queue.dequeue(null));
+          evaluationSignal = this.inbox.isEmpty ? 2 /* EvaluationSignal.Done */ : this.evaluateMessageWhileSuspended(depth, this.inbox.dequeue(null));
         }
       } finally {
         this.running = false;
-        if (tsplus_module_9.currentFiber(this._runtimeFlags)) {
+        if (tsplus_module_3.currentFiber(this._runtimeFlags)) {
           // TODO
         }
       }
-      if (!this.queue.isEmpty && !this.running) {
+      if (!this.inbox.isEmpty && !this.running) {
         this.running = true;
         if (evaluationSignal === 1 /* EvaluationSignal.YieldNow */) {
           this.drainQueueLaterOnExecutor();
@@ -159,441 +704,187 @@ export class FiberRuntime {
       }
     }
   }
-  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) {
+  drainQueueWhileRunning(cur0) {
     let cur = cur0;
-    while (!this.queue.isEmpty) {
-      const message = this.queue.dequeue(null);
+    let message = this.inbox.dequeue(null);
+    while (message) {
       switch (message._tag) {
         case 0 /* FiberMessageTag.InterruptSignal */:
           {
+            this.updateLastTrace(cur.trace);
             this.processNewInterruptSignal(message.cause);
-            cur = tsplus_module_9.interruptible(runtimeFlags) ? tsplus_module_4.failCause(() => message.cause, fileName_1 + ":209: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));
+            if (this.isInterruptible()) {
+              cur = tsplus_module_1.failCauseNow(message.cause, fileName_1 + ":850:46");
+            }
             break;
           }
-        case 2 /* FiberMessageTag.Stateful */:
+        case 1 /* FiberMessageTag.Stateful */:
           {
-            message.onFiber(this, new Running(runtimeFlags, lastTrace));
+            this.processStatefulMessage(message.onFiber);
             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 */:
+        case 2 /* FiberMessageTag.Resume */:
           {
-            const oldCur = cur;
-            cur = tsplus_module_4.flatMap(() => oldCur, undefined)(tsplus_module_4.yieldNow);
-            break;
+            throw new tsplus_module_27.IllegalStateError("It is illegal to have multiple concurrent run loops in a single fiber");
           }
       }
+      message = this.inbox.dequeue(null);
     }
     return cur;
   }
-  evaluateEffect(effect0) {
+  ensureStackCapacity(size) {
+    const stack = this._stack;
+    const stackLength = stack.length;
+    if (stackLength < size) {
+      const newSize = (size & size - 1) == 0 ? size : highestOneBit(size) << 1;
+      const newStack = new Array(newSize);
+      copyArray(stack, 0, newStack, 0, stackLength);
+      this._stack = newStack;
+    }
+  }
+  evaluateEffect(initialDepth, effect0) {
     // assert(this.running, "Invalid state in FiberRuntime: Fiber is not running");
-    this.getSupervisor().unsafeOnResume(this);
+    this._asyncContWith = null;
+    this._blockingOn = null;
+    this.updateLastTrace(effect0.trace);
+    const supervisor = this.getSupervisor();
+    supervisor.unsafeOnResume(this);
+    if (this._stack === null) {
+      this._stack = new Array(INITIAL_STACK_SIZE);
+    }
     try {
-      let effect;
-      if (tsplus_module_9.interruptible(this._runtimeFlags) && this.isInterrupted()) {
-        effect = tsplus_module_4.failCause(() => this.getInterruptedCause(), fileName_1 + ":247:30");
-      } else {
-        effect = effect0;
-      }
+      let 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.resume(tsplus_module_4.fromExitNow(exit, fileName_1 + ":265:59")));
-            }
+          if (this.shouldInterrupt()) {
+            effect = tsplus_module_1.failCause(() => this.getInterruptedCause(), fileName_1 + ":901:46");
+          }
+          const exit = this.runLoop(effect, 0, this._stackSize, initialDepth, 0);
+          if (exit === null) {
+            this._forksSinceYield = 0;
             effect = null;
           } else {
-            effect = tsplus_module_4.flatMap(() => tsplus_module_4.fromExitNow(exit, fileName_1 + ":270:63"), this.id.location)(interruption);
-          }
-        } catch (e) {
-          if (isIO(e)) {
-            if (e._ioOpCode === 12 /* IOTag.YieldNow */) {
-              if (tsplus_module_9.cooperativeYielding(this._runtimeFlags)) {
-                this.tell(tsplus_module_6.yieldNow);
-                this.tell(tsplus_module_6.resume(tsplus_module_4.unit));
-                effect = null;
+            this._runtimeFlags = tsplus_module_3.enable(this._runtimeFlags, 64 /* RuntimeFlag.WindDown */);
+            const interruption = this.interruptAllChildren();
+            if (interruption === null) {
+              if (this.inbox.isEmpty) {
+                finalExit = exit;
+                supervisor.unsafeOnEnd(finalExit, this);
+                this.setExitValue(exit);
               } else {
-                effect = tsplus_module_4.unit;
+                this.tell(tsplus_module_16.resume(tsplus_module_1.fromExitNow(exit, fileName_1 + ":921:61")));
               }
-            } else if (e._ioOpCode === 3 /* IOTag.Async */) {
               effect = null;
             } else {
-              throw new Error(`Unhandled op ${e._ioOpCode}`);
+              effect = tsplus_module_1.flatMap(() => tsplus_module_1.fromExitNow(exit, fileName_1 + ":926:77"), this.id.location)(interruption);
             }
+          }
+        } catch (t) {
+          if (this.isFatal(t)) {
+            // TODO
+          }
+          if (isIOError(t)) {
+            effect = tsplus_module_1.failCauseNow(t.cause, fileName_1 + ":935:49");
           } else {
-            throw e;
+            effect = tsplus_module_1.failCauseNow(tsplus_module_15.halt(t), fileName_1 + ":937:49");
           }
         }
       }
+      return finalExit;
     } finally {
+      this.gcStack();
       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 ((this._runtimeFlags & 8 /* RuntimeFlag.OpSupervision */) !== 0) {
-        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 > this.getFiberRef(tsplus_module_12.currentMaxFiberOps)) {
-        ops = 0;
-        const oldCur = cur;
-        const trace = lastTrace;
-        cur = tsplus_module_4.flatMap(() => oldCur, trace)(tsplus_module_4.yieldNow);
-      }
-      try {
-        switch (cur._ioOpCode) {
-          case 2 /* IOTag.Sync */:
-            {
-              const value = cur.i0();
-              const cont = this.getNextSuccessCont();
-              if (cont) {
-                switch (cont._ioOpCode) {
-                  case 5 /* IOTag.OnSuccess */:
-                    {
-                      cur = cont.i1(value);
-                      break;
-                    }
-                  case 4 /* IOTag.OnSuccessAndFailure */:
-                    {
-                      cur = cont.i2(value);
-                      break;
-                    }
-                  case 11 /* IOTag.WhileLoop */:
-                    {
-                      cont.i2(value);
-                      if (cont.i0()) {
-                        this.stack.push(cont);
-                        cur = cont.i1();
-                      } else {
-                        cur = tsplus_module_4.unit;
-                      }
-                      break;
-                    }
-                  case 14 /* IOTag.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 + ":350:54");
-                      } else {
-                        cur = tsplus_module_4.succeedNow(value, fileName_1 + ":352:52");
-                      }
-                      break;
-                    }
-                  case 15 /* IOTag.UpdateTrace */:
-                    {
-                      if (cont.trace !== undefined) lastTrace = cont.trace;
-                      cur = tsplus_module_4.unit;
-                      break;
-                    }
-                }
-              } else {
-                return tsplus_module_16.succeed(value, fileName_1 + ":363:34");
-              }
-              break;
-            }
-          case 4 /* IOTag.OnSuccessAndFailure */:
-          case 6 /* IOTag.OnFailure */:
-          case 5 /* IOTag.OnSuccess */:
-            {
-              this.stack.push(cur);
-              cur = cur.i0;
-              break;
-            }
-          case 3 /* IOTag.Async */:
-            {
-              this.asyncTrace = lastTrace;
-              this.asyncBlockinOn = cur.i1();
-              this.initiateAsync(this._runtimeFlags, cur.i0);
-              throw cur;
-            }
-          case 8 /* IOTag.UpdateRuntimeFlagsWithin */:
-            {
-              const updateFlags = cur.i0;
-              const oldRuntimeFlags = this._runtimeFlags;
-              const newRuntimeFlags = tsplus_module_10.patch(updateFlags, oldRuntimeFlags);
-              if (newRuntimeFlags === oldRuntimeFlags) {
-                cur = cur.i1(oldRuntimeFlags);
-              } else {
-                if (tsplus_module_9.interruptible(newRuntimeFlags) && this.isInterrupted()) {
-                  cur = tsplus_module_4.failCauseNow(this.getInterruptedCause(), fileName_1 + ":389:50");
-                } else {
-                  this.patchRuntimeFlags(this._runtimeFlags, updateFlags);
-                  const revertFlags = tsplus_module_9.diff(newRuntimeFlags, oldRuntimeFlags);
-                  this.stack.push(new RevertFlags(revertFlags));
-                  cur = cur.i1(oldRuntimeFlags);
-                }
-              }
-              break;
-            }
-          case 9 /* IOTag.GenerateStackTrace */:
-            {
-              cur = tsplus_module_4.succeedNow(this.generateStackTrace(), fileName_1 + ":400:44");
-              break;
-            }
-          case 10 /* IOTag.Stateful */:
-            {
-              cur = cur.i0(this, new Running(this._runtimeFlags, lastTrace));
-              break;
-            }
-          case 0 /* IOTag.SucceedNow */:
-            {
-              const oldCur = cur;
-              const cont = this.getNextSuccessCont();
-              if (cont) {
-                switch (cont._ioOpCode) {
-                  case 5 /* IOTag.OnSuccess */:
-                    {
-                      cur = cont.i1(oldCur.i0);
-                      break;
-                    }
-                  case 4 /* IOTag.OnSuccessAndFailure */:
-                    {
-                      cur = cont.i2(oldCur.i0);
-                      break;
-                    }
-                  case 11 /* IOTag.WhileLoop */:
-                    {
-                      cont.i2(oldCur.i0);
-                      if (cont.i0()) {
-                        this.stack.push(cont);
-                        cur = cont.i1();
-                      } else {
-                        cur = tsplus_module_4.unit;
-                      }
-                      break;
-                    }
-                  case 14 /* IOTag.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 + ":433:54");
-                      }
-                      break;
-                    }
-                  case 15 /* IOTag.UpdateTrace */:
-                    {
-                      if (cont.trace !== undefined) lastTrace = cont.trace;
-                      cur = tsplus_module_4.unit;
-                      break;
-                    }
-                }
-              } else {
-                return tsplus_module_16.succeed(oldCur.i0, fileName_1 + ":444:34");
-              }
-              break;
-            }
-          case 1 /* IOTag.Fail */:
-            {
-              const cause = cur.i0();
-              const cont = this.getNextFailCont();
-              if (cont) {
-                switch (cont._ioOpCode) {
-                  case 6 /* IOTag.OnFailure */:
-                  case 4 /* IOTag.OnSuccessAndFailure */:
-                    {
-                      if (!(tsplus_module_9.interruptible(this._runtimeFlags) && this.isInterrupted())) {
-                        cur = cont.i1(cause);
-                      } else {
-                        cur = tsplus_module_4.failCauseNow(tsplus_module_11.stripFailures(cause), fileName_1 + ":458:54");
-                      }
-                      break;
-                    }
-                  case 14 /* IOTag.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 + ":467:56");
-                        } else {
-                          cur = tsplus_module_4.failCauseNow(tsplus_module_11.sequential(cause, this.getInterruptedCause()), fileName_1 + ":469:56");
-                        }
-                      }
-                      break;
-                    }
-                  case 15 /* IOTag.UpdateTrace */:
-                    {
-                      if (cont.trace !== undefined) lastTrace = cont.trace;
-                      cur = tsplus_module_4.unit;
-                      break;
-                    }
-                }
-              } else {
-                return tsplus_module_16.failCause(cause, fileName_1 + ":481:36");
-              }
-              break;
-            }
-          case 7 /* IOTag.UpdateRuntimeFlags */:
-            {
-              this.patchRuntimeFlags(this._runtimeFlags, cur.i0);
-              cur = tsplus_module_4.unit;
-              break;
-            }
-          case 11 /* IOTag.WhileLoop */:
-            {
-              const iterate = cur;
-              const check = iterate.i0;
-              const body = iterate.i1;
-              if (check()) {
-                cur = body();
-                this.stack.push(iterate);
-              } else {
-                cur = tsplus_module_4.unit;
-              }
-              break;
-            }
-          case 12 /* IOTag.YieldNow */:
-            {
-              throw cur;
-            }
-          case 13 /* IOTag.Commit */:
-            {
-              cur = tsplus_module_17.atomically(cur, fileName_1 + ":506:34");
-              break;
-            }
-          case 16 /* IOTag.External */:
-            {
-              cur = cur.toIO;
-              break;
-            }
-          case null:
-            {
-              switch (cur._tag) {
-                case "Just" /* MaybeTag.Just */:
-                  {
-                    cur = tsplus_module_4.succeedNow(cur.value, fileName_1 + ":516:48");
-                    break;
-                  }
-                case "Nothing" /* MaybeTag.Nothing */:
-                  {
-                    cur = tsplus_module_4.failNow(new tsplus_module_14.NoSuchElementError(), fileName_1 + ":520:45");
-                    break;
-                  }
-                case "Left" /* EitherTag.Left */:
-                  {
-                    cur = tsplus_module_4.failNow(cur.left, fileName_1 + ":524:45");
-                    break;
-                  }
-                case "Right" /* EitherTag.Right */:
-                  {
-                    cur = tsplus_module_4.succeedNow(cur.right, fileName_1 + ":528:48");
-                    break;
-                  }
-                case "Failure" /* ExitTag.Failure */:
-                  {
-                    cur = tsplus_module_4.failCauseNow(cur.cause, fileName_1 + ":532:50");
-                    break;
-                  }
-                case "Success" /* ExitTag.Success */:
-                  {
-                    cur = tsplus_module_4.succeedNow(cur.value, fileName_1 + ":536:48");
-                    break;
-                  }
-                case "Tag":
-                  {
-                    cur = tsplus_module_18.service(cur, fileName_1 + ":540:45");
-                    break;
-                  }
-              }
-            }
+  evaluateMessageWhileSuspended(depth, fiberMessage) {
+    switch (fiberMessage._tag) {
+      case 0 /* FiberMessageTag.InterruptSignal */:
+        {
+          this.processNewInterruptSignal(fiberMessage.cause);
+          return 0 /* EvaluationSignal.Continue */;
         }
-      } catch (e) {
-        if (isIOError(e)) {
-          cur = tsplus_module_4.failCauseNow(e.cause, fileName_1 + ":548:44");
-        } else if (isIO(e) && (e._ioOpCode === 3 /* IOTag.Async */ || e._ioOpCode === 12 /* IOTag.YieldNow */)) {
-          throw e;
-        } else if (tsplus_module_14.isInterruptedException(e)) {
-          cur = tsplus_module_4.failCauseNow(tsplus_module_11.parallel(tsplus_module_11.halt(e), tsplus_module_11.interrupt(tsplus_module_19.none)), fileName_1 + ":555:44");
-        } else {
-          cur = tsplus_module_4.failCauseNow(tsplus_module_11.halt(e, tsplus_module_21.make(this.fiberId, tsplus_module_7.make(tsplus_module_20.parse(lastTrace)))), fileName_1 + ":557:44");
+      case 1 /* FiberMessageTag.Stateful */:
+        {
+          this.processStatefulMessage(fiberMessage.onFiber);
+          return 0 /* EvaluationSignal.Continue */;
+        }
+      case 2 /* FiberMessageTag.Resume */:
+        {
+          const nextEffect = fiberMessage.cont;
+          const exit = this.evaluateEffect(depth, nextEffect);
+          if (exit === null) {
+            return 1 /* EvaluationSignal.YieldNow */;
+          }
+          return 0 /* EvaluationSignal.Continue */;
         }
-      }
     }
   }
-  getInterruptedCause() {
-    return this.getFiberRef(tsplus_module_12.interruptedCause);
-  }
-  isInterrupted() {
-    return !tsplus_module_22.isEmpty(this.getFiberRef(tsplus_module_12.interruptedCause));
-  }
-  getFiberRef(fiberRef) {
-    if (tsplus_module_23.has(fiberRef)(this._fiberRefs)) {
-      return tsplus_module_23.unsafeGet(fiberRef)(this._fiberRefs).head[1];
+  /**
+   * Removes references of entries from the stack higher than the current index
+   * so that they can be garbage collected.
+   *
+   * @note
+   *   We only GC up to the {@link STACK_IDX_GC_THRESHOLD} index because
+   *   we know that entries in indices higher than that have been auto-gc'd
+   *   during the runloop
+   * @note
+   *   This method MUST be invoked by the fiber itself while it's still running.
+   */
+  gcStack() {
+    const fromIndex = this._stackSize;
+    if (fromIndex === 0) {
+      this._stack = null;
+    } else {
+      const stack = this._stack;
+      const toIndex = Math.min(STACK_IDX_GC_THRESHOLD, stack.length);
+      if (fromIndex < toIndex && stack[fromIndex] !== null) {
+        stack.fill(null, fromIndex, toIndex);
+      }
     }
-    return tsplus_module_24.initial(fiberRef);
   }
-  tell(message) {
-    this.queue.enqueue(message);
-    if (!this.running) {
-      this.running = true;
-      this.drainQueueLaterOnExecutor();
+  getStatus() {
+    if (this._exitValue !== null) {
+      return tsplus_module_25.done;
+    } else {
+      if (this._asyncContWith !== null) {
+        return tsplus_module_25.suspended(this._runtimeFlags, this._blockingOn ?? tsplus_module_33.none, this._lastTrace);
+      } else {
+        return tsplus_module_25.running(this._runtimeFlags, this._lastTrace);
+      }
     }
   }
-  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();
+  initiateAsync(asyncRegister) {
+    let alreadyCalled = false;
+    const callback = effect => {
+      if (!alreadyCalled) {
+        alreadyCalled = true;
+        this.tell(tsplus_module_16.resume(effect));
+      }
+    };
+    if (this.isInterruptible()) {
+      this._asyncContWith = callback;
+    } else {
+      this._asyncContWith = () => void 0;
     }
-    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.interruptSignal(tsplus_module_11.interrupt(this.id)));
-          told = true;
+    try {
+      const sync = asyncRegister(callback);
+      if (sync != null) {
+        if (!alreadyCalled) {
+          alreadyCalled = true;
+          this._asyncContWith = null;
+          this._blockingOn = null;
+          return sync;
+        } else {
+          this.log(() => "Async operation attempted synchronous resumption, but its callback was already invoked; synchronous value will be discarded", tsplus_module_15.empty(), tsplus_module_5.just(tsplus_module_19.Error, fileName_1 + ":1039:17"), this.id.location);
+          return null;
         }
+      } else {
+        return null;
       }
-      return told;
+    } catch (t) {
+      callback(tsplus_module_1.failCauseNow(tsplus_module_15.halt(t), fileName_1 + ":1049:31"));
+      return null;
     }
   }
   interruptAllChildren() {
@@ -609,10 +900,10 @@ export class FiberRuntime {
         if (value != null && !value.done) {
           return value.value.await;
         } else {
-          return tsplus_module_4.unit;
+          return tsplus_module_1.unit;
         }
       };
-      const io = new IOPrimitive(11 /* IOTag.WhileLoop */);
+      const io = new IOPrimitive(9 /* IOTag.WhileLoop */);
       io.i0 = check;
       io.i1 = body;
       io.i2 = () => {
@@ -623,170 +914,123 @@ export class FiberRuntime {
       return null;
     }
   }
-  initiateAsync(runtimeFlags, asyncRegister) {
-    let alreadyCalled = false;
-    const callback = effect => {
-      if (!alreadyCalled) {
-        alreadyCalled = true;
-        this.tell(tsplus_module_6.resume(effect));
+  isInterruptible() {
+    return tsplus_module_3.interruptible(this._runtimeFlags);
+  }
+  patchRuntimeFlags(patch, cause, continueEffect) {
+    const changed = this.patchRuntimeFlagsOnly(patch);
+    const interruptEnabled = tsplus_module_4.isEnabledPatch(patch, 1 /* RuntimeFlag.Interruption */);
+    if (changed && interruptEnabled && this.shouldInterrupt()) {
+      if (cause !== null) {
+        return tsplus_module_1.failCauseNow(tsplus_module_15.sequential(cause, this.getInterruptedCause()), fileName_1 + ":1103:43");
+      } else {
+        return tsplus_module_1.failCauseNow(this.getInterruptedCause(), fileName_1 + ":1105:43");
       }
-    };
-    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 + ":681:31"));
+    } else if (cause !== null) {
+      return tsplus_module_1.failCauseNow(cause, fileName_1 + ":1108:41");
+    } else {
+      return continueEffect;
     }
   }
-  setFiberRef(fiberRef, value) {
-    this._fiberRefs = tsplus_module_8.updateAs(this._fiberRefs, this.fiberId, fiberRef, value);
+  patchRuntimeFlagsOnly(patch) {
+    const oldFlags = this._runtimeFlags;
+    const newFlags = tsplus_module_4.patch(patch, oldFlags);
+    const changed = oldFlags !== newFlags;
+    if (changed) {
+      if (tsplus_module_4.isEnabledPatch(patch, 2 /* RuntimeFlag.CurrentFiber */)) {
+        // TODO
+      } else {
+        // TODO
+      }
+      this._runtimeFlags = newFlags;
+    }
+    return changed;
   }
-  addInterruptedCause(cause) {
-    const oldSC = this.getFiberRef(tsplus_module_12.interruptedCause);
-    if (tsplus_module_11.contains(cause)(oldSC)) {
-      return;
+  /**
+   * Sets the `_stackSize` to `nextStackIndex`.
+   *
+   * This method might also null out the entry in the stack to allow it to be
+   * GC'd, but only if the index is >= `FiberRuntime.StackIdxGcThreshold`.
+   *
+   * This is based on the assumption that when the stack is shallow, the entries
+   * in the array will keep being overwritten as the pointer moves up and down.
+   */
+  popStackFrame(nextStackIndex) {
+    if (nextStackIndex >= STACK_IDX_GC_THRESHOLD) {
+      this._stack[nextStackIndex] = null;
     }
-    this.setFiberRef(tsplus_module_12.interruptedCause, tsplus_module_11.sequential(oldSC, cause));
+    this._stackSize = nextStackIndex;
   }
   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 + ":708: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 */;
-        }
+    const k = this._asyncContWith;
+    if (k !== null) {
+      k(tsplus_module_1.failCauseNow(cause, fileName_1 + ":1154:24"));
     }
   }
-  generateStackTrace() {
-    const builder = new StackTraceBuilder();
-    const stack = this.stack.clone();
-    while (stack.hasNext) {
-      builder.append(tsplus_module_20.parse(stack.pop().trace));
+  processStatefulMessage(onFiber) {
+    try {
+      onFiber(this);
+    } catch (t) {
+      if (this.isFatal(t)) {
+        // TODO
+      } else {
+        this.log(() => `An unexpected error was encountered while processing stateful fiber message with callback ${onFiber}`, tsplus_module_15.halt(t), tsplus_module_5.just(tsplus_module_19.Error, fileName_1 + ":1168:15"), this.id.location);
+      }
     }
-    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();
+  pushStackFrame(k, stackIndex) {
+    const newSize = stackIndex + 1;
+    this.ensureStackCapacity(newSize);
+    this._stack[stackIndex] = k;
+    this._stackSize = newSize;
+    return newSize;
   }
-  resume(effect) {
-    this.tell(tsplus_module_6.resume(effect));
+  run() {
+    this.drainQueueOnCurrentThread(0);
   }
-  start(effect) {
-    if (!this.running) {
-      try {
-        this.running = true;
-        this.evaluateEffect(effect);
-      } finally {
-        this.running = false;
-        if (!this.queue.isEmpty) {
-          this.drainQueueLaterOnExecutor();
+  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_16.interruptSignal(tsplus_module_15.interrupt(this.id)));
+          told = true;
         }
       }
-    } else {
-      this.tell(tsplus_module_6.resume(effect));
+      return told;
     }
   }
-  startFork(effect) {
-    this.tell(tsplus_module_6.resume(effect));
-  }
-  updateFiberRef(fiberRef, f) {
-    this.setFiberRef(fiberRef, f(this.getFiberRef(fiberRef)));
-  }
-  removeObserver(observer) {
-    this.observers = tsplus_module_25.filter(f => f !== observer)(this.observers);
-  }
-  addChild(child) {
-    this.getChildren().add(child);
-  }
-  removeChild(child) {
-    if (this._children !== null) {
-      this._children.delete(child);
+  setExitValue(exit) {
+    this._exitValue = exit;
+    for (const observer of this.observers) {
+      observer(exit);
     }
+    this.observers = tsplus_module_7.empty();
   }
-  get scope() {
-    return tsplus_module_26.unsafeMake(this);
-  }
-  log(message, cause, overrideLogLevel, trace) {
-    const logLevel = tsplus_module_27.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_30.filterLogLevel(level => tsplus_module_28.gte(tsplus_module_28.Info)(level))(tsplus_module_30.map(s => console.log(s))(tsplus_module_29.defaultString)).log(tsplus_module_20.parse(trace), this.fiberId, logLevel, message, cause, contextMap, spans, annotations);
-  }
-  deleteFiberRef(ref) {
-    this._fiberRefs = tsplus_module_8.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.genStackTrace(trace => tsplus_module_5.unsafeDone(tsplus_module_4.succeedNow(trace, fileName_1 + ":845:86"), fileName_1 + ":845:72")(future)));
-      return tsplus_module_5.wait(future, fileName_1 + ":846:20");
-    }, fileName_1 + ":843:20");
-  }
-  getNextSuccessCont() {
-    while (this.stack.hasNext) {
-      const frame = this.stack.pop();
-      if (frame._ioOpCode !== 6 /* IOTag.OnFailure */) {
-        return frame;
-      }
-    }
+  shouldInterrupt() {
+    return this.isInterruptible() && this.isInterrupted();
   }
-  getNextFailCont() {
-    while (this.stack.hasNext) {
-      const frame = this.stack.pop();
-      if (frame._ioOpCode !== 5 /* IOTag.OnSuccess */ && frame._ioOpCode !== 11 /* IOTag.WhileLoop */) {
-        return frame;
-      }
+  updateLastTrace(newTrace) {
+    if (newTrace !== null && newTrace !== "" && this._lastTrace !== newTrace) {
+      this._lastTrace = newTrace;
     }
   }
-  isFatal(t) {
-    return this.getFiberRef(tsplus_module_12.currentIsFatal).apply(t);
-  }
 }
 _a = FiberTypeId;
+export function highestOneBit(i) {
+  i |= i >> 1;
+  i |= i >> 2;
+  i |= i >> 4;
+  i |= i >> 8;
+  i |= i >> 16;
+  return i - (i >>> 1);
+}
+function copyArray(source, sourcePos, dest, destPos, length) {
+  const j = Math.min(source.length, sourcePos + length);
+  for (let i = sourcePos; i < j; i++) {
+    dest[destPos + i - sourcePos] = source[i];
+  }
+}
 //# sourceMappingURL=FiberRuntime.mjs.map