@fncts/io 0.0.1

package/_cjs/Fiber/FiberContext.cjs

@@ -0,0 +1,1219 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.currentFiber = exports.TracedCont = exports.InterruptExit = exports.HandlerFrame = exports.Finalizer = exports.FiberContext = void 0;
+exports.unsafeCurrentFiber = unsafeCurrentFiber;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Hashable/definition"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/FiberId/api"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Hashable/hash"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Equatable/definition"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Fiber/api/id"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Equatable/api"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberState/constructors"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/internal/Stack"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberRefs/api"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/HashMap/api"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberRefs/join"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/api"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc"));
+
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api/empty"));
+
+var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Future/api"));
+
+var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/environment"));
+
+var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/fulfill"));
+
+var tsplus_module_20 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Future/constructors"));
+
+var tsplus_module_21 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
+
+var tsplus_module_22 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberScope/constructors"));
+
+var tsplus_module_23 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/constructors"));
+
+var tsplus_module_24 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/RuntimeConfig"));
+
+var tsplus_module_25 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Supervisor/constructors"));
+
+var tsplus_module_26 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
+
+var tsplus_module_27 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/constructors"));
+
+var tsplus_module_28 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/InterruptStatus/constructors"));
+
+var tsplus_module_29 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Supervisor/api"));
+
+var tsplus_module_30 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberRef/constructors"));
+
+var tsplus_module_31 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/api"));
+
+var tsplus_module_32 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/exceptions"));
+
+var tsplus_module_33 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/FiberId/constructors"));
+
+var tsplus_module_34 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/interrupt"));
+
+var tsplus_module_35 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberRef/api"));
+
+var tsplus_module_36 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/definition"));
+
+var tsplus_module_37 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api/isEmpty"));
+
+var tsplus_module_38 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberStatus/constructors"));
+
+var tsplus_module_39 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/CancellerState"));
+
+var tsplus_module_40 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberState/api"));
+
+var tsplus_module_41 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/TraceElement/definition"));
+
+var tsplus_module_42 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/FiberDescriptor"));
+
+var tsplus_module_43 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/api"));
+
+var tsplus_module_44 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Trace/definition"));
+
+var _AtomicReference = /*#__PURE__*/require("@fncts/base/internal/AtomicReference");
+
+var _definition6 = /*#__PURE__*/require("@fncts/io/Fiber/definition");
+
+var _Scheduler = /*#__PURE__*/require("@fncts/io/internal/Scheduler");
+
+var _StackTraceBuilder = /*#__PURE__*/require("@fncts/io/internal/StackTraceBuilder");
+
+var _definition7 = /*#__PURE__*/require("@fncts/io/IO/definition");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const fileName_1 = "(@fncts/io) src/Fiber/FiberContext.ts";
+
+class InterruptExit {
+  constructor(apply, trace) {
+    this.apply = apply;
+    this.trace = trace;
+    this._tag = "InterruptExit";
+  }
+
+}
+
+exports.InterruptExit = InterruptExit;
+
+class HandlerFrame {
+  constructor(apply, trace) {
+    this.apply = apply;
+    this.trace = trace;
+    this._tag = "HandlerFrame";
+  }
+
+}
+
+exports.HandlerFrame = HandlerFrame;
+
+class TracedCont {
+  constructor(apply, trace) {
+    this.apply = apply;
+    this.trace = trace;
+    this._tag = "TracedCont";
+  }
+
+}
+
+exports.TracedCont = TracedCont;
+
+class Finalizer {
+  constructor(finalizer, apply, trace) {
+    this.finalizer = finalizer;
+    this.apply = apply;
+    this.trace = trace;
+    this._tag = "Finalizer";
+  }
+
+}
+
+exports.Finalizer = Finalizer;
+const currentFiber = /*#__PURE__*/new _AtomicReference.AtomicReference(null);
+exports.currentFiber = currentFiber;
+
+function unsafeCurrentFiber() {
+  return tsplus_module_1.fromNullable(currentFiber.get);
+}
+/**
+ * `FiberContext` provides all of the context and facilities required to run a `IO`
+ *
+ * @tsplus type fncts.io.Fiber
+ */
+
+
+class FiberContext {
+  constructor(fiberId, runtimeConfig, interruptStatus, fiberRefLocals, _children) {
+    this.fiberId = fiberId;
+    this.runtimeConfig = runtimeConfig;
+    this.interruptStatus = interruptStatus;
+    this.fiberRefLocals = fiberRefLocals;
+    this._children = _children;
+    this._typeId = _definition6.FiberTypeId;
+    this._tag = "RuntimeFiber";
+    this.state = tsplus_module_8.initial();
+    this.asyncEpoch = 0 | 0;
+    this.stack = tsplus_module_9.mkStack();
+    this.nextIO = null;
+    this.interruptExit = new InterruptExit(v => {
+      if (this.unsafeIsInterruptible) {
+        this.interruptStatus.pop();
+        return tsplus_module_10.succeedNow(v, fileName_1 + ":585:27");
+      } else {
+        return tsplus_module_10.succeed(() => {
+          this.interruptStatus.pop();
+          return v;
+        }, fileName_1 + ":587:24");
+      }
+    });
+    this.currentSupervisor = this.runtimeConfig.supervisor;
+  }
+
+  get [tsplus_module_2.hashSymbol]() {
+    return tsplus_module_4.hashString(tsplus_module_3.threadName(this.id));
+  }
+
+  [tsplus_module_5.equalsSymbol](that) {
+    return (0, _definition6.isFiber)(that) && tsplus_module_7.strictEquals(this.id, tsplus_module_6.id(that));
+  }
+
+  get poll() {
+    return tsplus_module_10.succeed(() => this.unsafePoll(), fileName_1 + ":89:22");
+  }
+
+  get inheritRefs() {
+    return tsplus_module_10.defer(() => {
+      const childFiberRefs = tsplus_module_11.make(this.fiberRefLocals.get);
+
+      if (tsplus_module_12.isEmpty(childFiberRefs.fiberRefLocals)) {
+        return tsplus_module_10.unit;
+      } else {
+        return tsplus_module_10.updateFiberRefs((parentFiberId, parentFiberRefs) => tsplus_module_13.join(parentFiberRefs, parentFiberId, childFiberRefs), fileName_1 + ":98:34");
+      }
+    }, fileName_1 + ":93:20");
+  }
+
+  get id() {
+    return this.fiberId;
+  }
+
+  awaitAsync(k) {
+    const exit = this.unsafeAddObserver(exit => k(tsplus_module_14.flatten(exit)));
+
+    if (exit != null) {
+      k(exit);
+    }
+  }
+
+  get children() {
+    return this.evalOnIO(tsplus_module_10.succeed(() => {
+      const concBuilder = new tsplus_module_15.ConcBuilder(tsplus_module_16.empty());
+
+      for (const child of this._children) {
+        concBuilder.append(child);
+      }
+
+      return concBuilder.result();
+    }, fileName_1 + ":119:17"), tsplus_module_10.succeed(() => tsplus_module_16.empty(), fileName_1 + ":128:17"), fileName_1 + ":118:25");
+  }
+
+  evalOnIO(effect, orElse, __tsplusTrace) {
+    return tsplus_module_10.flatMap_(tsplus_module_18.environment(fileName_1 + ":138:33"), r => tsplus_module_10.flatMap_(tsplus_module_20.make(), p => tsplus_module_10.flatMap_(this.evalOn(tsplus_module_19.fulfill_(tsplus_module_18.provideEnvironment_(effect, r, fileName_1 + ":140:46"), p), tsplus_module_19.fulfill_(tsplus_module_18.provideEnvironment_(orElse, r, fileName_1 + ":140:87"), p)), () => tsplus_module_17.wait(p), fileName_1 + ":140:8"), fileName_1 + ":139:18"), fileName_1 + ":138:18");
+  }
+
+  get await() {
+    return tsplus_module_10.asyncInterrupt(k => {
+      const cb = x => k(tsplus_module_10.fromExit(() => x, fileName_1 + ":147:78"));
+
+      const result = this.unsafeAddObserver(cb);
+
+      if (result == null) {
+        return tsplus_module_21.left(tsplus_module_10.succeed(() => this.unsafeRemoveObserver(cb), fileName_1 + ":150:38"));
+      } else {
+        return tsplus_module_21.right(tsplus_module_10.succeedNow(result, fileName_1 + ":152:42"));
+      }
+    }, this.fiberId, fileName_1 + ":146:29");
+  }
+
+  run() {
+    this.runUntil(this.runtimeConfig.yieldOpCount);
+  }
+
+  get scope() {
+    return tsplus_module_22.unsafeMake(this);
+  }
+
+  get status() {
+    return tsplus_module_10.succeedNow(this.state.status, fileName_1 + ":166:25");
+  }
+
+  get trace() {
+    return tsplus_module_10.succeed(() => this.unsafeCaptureTrace(tsplus_module_23.empty()), fileName_1 + ":170:22");
+  }
+
+  interruptAs(fiberId) {
+    return this.unsafeInterruptAs(fiberId);
+  }
+
+  evalOn(effect, orElse) {
+    return tsplus_module_10.defer(() => this.unsafeEvalOn(effect, orElse), fileName_1 + ":178:20");
+  }
+
+  get location() {
+    return this.fiberId.location;
+  }
+  /**
+   * The main evaluator loop for the fiber. For purely synchronous effects, this will run either
+   * to completion, or for the specified maximum operation count. For effects with asynchronous
+   * callbacks, the loop will proceed no further than the first asynchronous boundary.
+   */
+
+
+  runUntil(maxOpCount) {
+    try {
+      let current = this.nextIO;
+      this.nextIO = null;
+      let extraTrace = undefined;
+      const flags = this.runtimeConfig.flags;
+      const superviseOps = flags.isEnabled(tsplus_module_24.RuntimeConfigFlag.SuperviseOperations) && this.currentSupervisor !== tsplus_module_25.none;
+      this.runtimeConfig.flags.isEnabled(tsplus_module_24.RuntimeConfigFlag.EnableCurrentFiber) && currentFiber.set(this);
+      this.currentSupervisor !== tsplus_module_25.none && this.currentSupervisor.unsafeOnResume(this);
+
+      while (current !== null) {
+        try {
+          let opCount = 0;
+
+          while (current !== null) {
+            if (!this.unsafeShouldInterrupt) {
+              const message = this.unsafeDrainMailbox();
+
+              if (message !== null) {
+                const oldIO = current;
+                current = (0, _definition7.concrete)(tsplus_module_10.flatMap_(message, () => oldIO, fileName_1 + ":215:55"));
+              } else if (opCount === maxOpCount) {
+                this.unsafeRunLater(current);
+                current = null;
+              } else {
+                superviseOps && this.currentSupervisor.unsafeOnEffect(this, current);
+
+                switch (current._tag) {
+                  case "Chain"
+                  /* IOTag.Chain */
+                  :
+                    {
+                      const nested = (0, _definition7.concrete)(current.io);
+                      const k = current.f;
+
+                      switch (nested._tag) {
+                        case "SucceedNow"
+                        /* IOTag.SucceedNow */
+                        :
+                          {
+                            current = (0, _definition7.concrete)(k(nested.value));
+                            break;
+                          }
+
+                        case "SucceedLazy"
+                        /* IOTag.Succeed */
+                        :
+                          {
+                            extraTrace = nested.trace;
+                            const value = nested.effect();
+                            extraTrace = undefined;
+                            current = (0, _definition7.concrete)(k(value));
+                            break;
+                          }
+
+                        case "SucceedLazyWith"
+                        /* IOTag.SucceedWith */
+                        :
+                          {
+                            extraTrace = current.trace;
+                            const value = nested.effect(this.runtimeConfig, this.fiberId);
+                            extraTrace = undefined;
+                            current = (0, _definition7.concrete)(k(value));
+                            break;
+                          }
+
+                        case "Yield"
+                        /* IOTag.Yield */
+                        :
+                          {
+                            extraTrace = current.trace;
+                            this.unsafeRunLater((0, _definition7.concrete)(tsplus_module_10.unit));
+                            extraTrace = undefined;
+                            current = null;
+                            break;
+                          }
+
+                        default:
+                          {
+                            this.stack.push(new TracedCont(current.f, current.trace));
+                            current = (0, _definition7.concrete)(current.io);
+                            break;
+                          }
+                      }
+
+                      break;
+                    }
+
+                  case "Trace"
+                  /* IOTag.Trace */
+                  :
+                    {
+                      current = this.unsafeNextEffect(this.unsafeCaptureTrace(tsplus_module_23.cons(current.trace, tsplus_module_23.nil())));
+                      break;
+                    }
+
+                  case "SucceedNow"
+                  /* IOTag.SucceedNow */
+                  :
+                    {
+                      current = this.unsafeNextEffect(current.value);
+                      break;
+                    }
+
+                  case "SucceedLazy"
+                  /* IOTag.Succeed */
+                  :
+                    {
+                      current = this.unsafeNextEffect(current.effect());
+                      break;
+                    }
+
+                  case "SucceedLazyWith"
+                  /* IOTag.SucceedWith */
+                  :
+                    {
+                      current = this.unsafeNextEffect(current.effect(this.runtimeConfig, this.fiberId));
+                      break;
+                    }
+
+                  case "Fail"
+                  /* IOTag.Fail */
+                  :
+                    {
+                      const fastPathTrace = extraTrace === undefined ? tsplus_module_23.nil() : tsplus_module_23.cons(extraTrace, tsplus_module_23.nil());
+                      extraTrace = undefined;
+                      const cause = current.cause();
+                      const tracedCause = tsplus_module_26.isTraced(cause) ? cause : tsplus_module_26.traced(cause, this.unsafeCaptureTrace(tsplus_module_23.cons(current.trace, fastPathTrace)));
+                      const discardedFolds = this.unsafeUnwindStack();
+                      const strippedCause = discardedFolds ? // We threw away some error handlers while unwinding the stack because
+                      tsplus_module_26.stripFailures( // We threw away some error handlers while unwinding the stack because
+                      // we got interrupted during this instruction. So it's not safe to return
+                      // typed failures from cause0, because they might not be typed correctly.
+                      // Instead, we strip the typed failures, and return the remainders and
+                      // the interruption
+                      tracedCause) : tracedCause;
+                      const suppressed = this.unsafeClearSuppressedCause();
+                      const fullCause = tsplus_module_26.contains_(strippedCause, suppressed) ? strippedCause : tsplus_module_26.then(strippedCause, suppressed);
+
+                      if (!this.stack.hasNext) {
+                        // Error not caught, stack is empty:
+                        this.unsafeSetInterrupting(true);
+                        current = this.unsafeTryDone(tsplus_module_27.failCause(fullCause), current.trace);
+                      } else {
+                        this.unsafeSetInterrupting(false); // Error caught, next continuation on the stack will deal
+                        // with it, so we just have to compute it here
+
+                        current = this.unsafeNextEffect(fullCause);
+                      }
+
+                      break;
+                    }
+
+                  case "Match"
+                  /* IOTag.Match */
+                  :
+                    {
+                      this.stack.push(current);
+                      current = (0, _definition7.concrete)(current.io);
+                      break;
+                    }
+
+                  case "SetInterrupt"
+                  /* IOTag.SetInterrupt */
+                  :
+                    {
+                      const boolFlag = current.flag.toBoolean;
+
+                      if (this.unsafeIsInterruptible !== boolFlag) {
+                        this.interruptStatus.push(current.flag.toBoolean);
+                        this.unsafeRestoreInterruptStatus();
+                      }
+
+                      current = (0, _definition7.concrete)(current.io);
+                      break;
+                    }
+
+                  case "GetInterrupt"
+                  /* IOTag.GetInterrupt */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(current.f(tsplus_module_28.fromBoolean(this.unsafeIsInterruptible)));
+                      break;
+                    }
+
+                  case "Async"
+                  /* IOTag.Async */
+                  :
+                    {
+                      const trace = current.trace;
+                      const epoch = this.asyncEpoch;
+                      this.asyncEpoch = epoch + 1;
+                      this.unsafeEnterAsync(epoch, current.blockingOn, trace);
+                      const r = current.register(this.unsafeCreateAsyncResume(epoch));
+
+                      switch (r._tag) {
+                        case "Left":
+                          {
+                            this.unsafeSetAsyncCanceller(epoch, r.left);
+
+                            if (this.unsafeShouldInterrupt) {
+                              if (this.unsafeExitAsync(epoch)) {
+                                this.unsafeSetInterrupting(true);
+                                current = (0, _definition7.concrete)(tsplus_module_10.flatMap_(r.left, () => tsplus_module_10.failCauseNow(this.unsafeClearSuppressedCause(), fileName_1 + ":348:67"), fileName_1 + ":348:45"));
+                              } else {
+                                current = null;
+                              }
+                            } else {
+                              current = null;
+                            }
+
+                            break;
+                          }
+
+                        case "Right":
+                          {
+                            if (!this.unsafeExitAsync(epoch)) {
+                              current = null;
+                            } else {
+                              current = (0, _definition7.concrete)(r.right);
+                            }
+                          }
+                      }
+
+                      break;
+                    }
+
+                  case "Fork"
+                  /* IOTag.Fork */
+                  :
+                    {
+                      current = this.unsafeNextEffect(this.unsafeFork((0, _definition7.concrete)(current.io), current.scope, current.trace));
+                      break;
+                    }
+
+                  case "GetDescriptor"
+                  /* IOTag.GetDescriptor */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(current.f(this.unsafeGetDescriptor()));
+                      break;
+                    }
+
+                  case "Yield"
+                  /* IOTag.Yield */
+                  :
+                    {
+                      current = null;
+                      this.unsafeRunLater((0, _definition7.concrete)(tsplus_module_10.unit));
+                      break;
+                    }
+
+                  case "Defer"
+                  /* IOTag.Defer */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(current.make());
+                      break;
+                    }
+
+                  case "DeferWith"
+                  /* IOTag.DeferWith */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(current.make(this.runtimeConfig, this.fiberId));
+                      break;
+                    }
+
+                  case "FiberRefModifyAll"
+                  /* IOTag.FiberRefModifyAll */
+                  :
+                    {
+                      const [result, newValue] = current.f(this.fiberId, tsplus_module_11.make(this.fiberRefLocals.get));
+                      this.fiberRefLocals.set(newValue.fiberRefLocals);
+                      current = this.unsafeNextEffect(result);
+                      break;
+                    }
+
+                  case "FiberRefModify"
+                  /* IOTag.FiberRefModify */
+                  :
+                    {
+                      const c = current;
+                      const [result, newValue] = current.f(this.unsafeGetRef(current.fiberRef));
+                      this.unsafeSetRef(c.fiberRef, newValue);
+                      current = this.unsafeNextEffect(result);
+                      break;
+                    }
+
+                  case "FiberRefLocally"
+                  /* IOTag.FiberRefLocally */
+                  :
+                    {
+                      const oldValue = this.unsafeGetRef(current.fiberRef);
+                      const fiberRef = current.fiberRef;
+                      this.unsafeSetRef(fiberRef, current.localValue);
+                      this.unsafeAddFinalizer(tsplus_module_10.succeed(() => {
+                        this.unsafeSetRef(fiberRef, oldValue);
+                      }, fileName_1 + ":412:33"));
+                      current = (0, _definition7.concrete)(current.io);
+                      break;
+                    }
+
+                  case "FiberRefDelete"
+                  /* IOTag.FiberRefDelete */
+                  :
+                    {
+                      this.unsafeDeleteRef(current.fiberRef);
+                      current = this.unsafeNextEffect(undefined);
+                      break;
+                    }
+
+                  case "FiberRefWith"
+                  /* IOTag.FiberRefWith */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(current.f(this.unsafeGetRef(current.fiberRef)));
+                      break;
+                    }
+
+                  case "GetRuntimeConfig"
+                  /* IOTag.GetRuntimeConfig */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(current.f(this.runtimeConfig));
+                      break;
+                    }
+
+                  case "Race"
+                  /* IOTag.Race */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(this.unsafeRace(current));
+                      break;
+                    }
+
+                  case "Supervise"
+                  /* IOTag.Supervise */
+                  :
+                    {
+                      const oldSupervisor = this.currentSupervisor;
+                      this.currentSupervisor = tsplus_module_29.zip_(current.supervisor, oldSupervisor);
+                      this.unsafeAddFinalizer(tsplus_module_10.succeed(() => {
+                        this.currentSupervisor = oldSupervisor;
+                      }, fileName_1 + ":445:33"));
+                      current = (0, _definition7.concrete)(current.io);
+                      break;
+                    }
+
+                  case "GetForkScope"
+                  /* IOTag.GetForkScope */
+                  :
+                    {
+                      current = (0, _definition7.concrete)(current.f(tsplus_module_31.getOrElse_(this.unsafeGetRef(tsplus_module_30.forkScopeOverride), () => this.scope)));
+                      break;
+                    }
+
+                  case "OverrideForkScope"
+                  /* IOTag.OverrideForkScope */
+                  :
+                    {
+                      const oldForkScopeOverride = this.unsafeGetRef(tsplus_module_30.forkScopeOverride);
+                      this.unsafeSetRef(tsplus_module_30.forkScopeOverride, current.forkScope);
+                      this.unsafeAddFinalizer(tsplus_module_10.succeed(() => {
+                        this.unsafeSetRef(tsplus_module_30.forkScopeOverride, oldForkScopeOverride);
+                      }, fileName_1 + ":462:33"));
+                      current = (0, _definition7.concrete)(current.io);
+                      break;
+                    }
+
+                  case "Ensuring"
+                  /* IOTag.Ensuring */
+                  :
+                    {
+                      this.unsafeAddFinalizer(current.finalizer);
+                      current = (0, _definition7.concrete)(current.io);
+                      break;
+                    }
+
+                  case "Logged"
+                  /* IOTag.Logged */
+                  :
+                    {
+                      this.unsafeLogWith(current.message, current.cause, current.overrideLogLevel, current.overrideRef1, current.overrideValue1, current.trace);
+                      current = this.unsafeNextEffect(undefined);
+                      break;
+                    }
+
+                  case "SetRuntimeConfig"
+                  /* IOTag.SetRuntimeConfig */
+                  :
+                    {
+                      this.runtimeConfig = current.runtimeConfig;
+                      current = (0, _definition7.concrete)(tsplus_module_10.unit);
+                      break;
+                    }
+
+                  default:
+                    {
+                      console.log("Unrecognized Instruction", current);
+                      throw new Error("Unrecognized Instruction");
+                    }
+                }
+              }
+            } else {
+              const trace = current.trace;
+              current = (0, _definition7.concrete)(tsplus_module_10.failCauseNow(this.unsafeClearSuppressedCause(), trace));
+              this.unsafeSetInterrupting(true);
+            }
+
+            opCount++;
+          }
+        } catch (e) {
+          if (tsplus_module_32.isInterruptedException(e)) {
+            const trace = current ? current.trace : undefined;
+            current = (0, _definition7.concrete)(tsplus_module_34.interruptAs(tsplus_module_33.none, trace));
+            this.unsafeSetInterrupting(true);
+          } else if ((0, _definition7.isIOError)(e)) {
+            switch (e.exit._tag) {
+              case "Success":
+                {
+                  current = this.unsafeNextEffect(e.exit.value);
+                  break;
+                }
+
+              case "Failure":
+                {
+                  const trace = current ? current.trace : undefined;
+                  current = (0, _definition7.concrete)(tsplus_module_10.failCauseNow(e.exit.cause, trace));
+                }
+            }
+          } else {
+            this.unsafeSetInterrupting(true);
+            current = (0, _definition7.concrete)(tsplus_module_10.haltNow(e, fileName_1 + ":524:42"));
+          }
+        }
+      }
+    } finally {
+      currentFiber.set(null);
+      this.currentSupervisor !== tsplus_module_25.none && this.currentSupervisor.unsafeOnSuspend(this);
+    }
+  }
+
+  unsafeRunLater(i0) {
+    (0, _Scheduler.defaultScheduler)(() => {
+      this.nextIO = i0;
+      this.runUntil(this.runtimeConfig.yieldOpCount);
+    });
+  }
+
+  unsafeGetRef(ref) {
+    return tsplus_module_31.getOrElse_(tsplus_module_31.map_(tsplus_module_12.get_(this.fiberRefLocals.get, ref), _ => _.head[1]), () => tsplus_module_35.initial(ref));
+  }
+
+  unsafeGetRefs(fiberRefLocals) {
+    return tsplus_module_12.map_(fiberRefLocals.get, stack => stack.head[1]);
+  }
+
+  unsafeSetRef(ref, value) {
+    const oldState = this.fiberRefLocals.get;
+    const oldStack = tsplus_module_31.getOrElse_(tsplus_module_12.get_(oldState, ref), () => tsplus_module_23.empty());
+    let newStack;
+
+    if (tsplus_module_36.isEmpty(oldStack)) {
+      newStack = tsplus_module_23.cons([this.fiberId, value]);
+    } else if (tsplus_module_7.strictEquals(oldStack.head[0], this.fiberId)) {
+      newStack = tsplus_module_23.cons([this.fiberId, value], oldStack.tail);
+    } else {
+      newStack = tsplus_module_23.cons([this.fiberId, value], oldStack);
+    }
+
+    const newState = tsplus_module_12.set_(oldState, ref, newStack);
+    this.fiberRefLocals.set(newState);
+  }
+
+  unsafeDeleteRef(ref) {
+    this.fiberRefLocals.set(tsplus_module_12.remove_(this.fiberRefLocals.get, ref));
+  }
+
+  unsafePoll() {
+    switch (this.state._tag) {
+      case "Executing":
+        {
+          return tsplus_module_1.nothing();
+        }
+
+      case "Done":
+        {
+          return tsplus_module_1.just(this.state.value);
+        }
+    }
+  }
+
+  unsafeAddFinalizer(finalizer) {
+    this.stack.push(new Finalizer(finalizer, v => {
+      this.unsafeDisableInterruption();
+      this.unsafeRestoreInterruptStatus();
+      return tsplus_module_10.map_(finalizer, () => v, fileName_1 + ":599:29");
+    }));
+  }
+
+  get unsafeIsInterruptible() {
+    return this.interruptStatus.hasNext ? this.interruptStatus.peek() : true;
+  }
+
+  get unsafeIsInterrupted() {
+    return this.state.interruptors.size > 0;
+  }
+
+  get unsafeIsInterrupting() {
+    return this.state.status.isInterrupting;
+  }
+
+  get unsafeShouldInterrupt() {
+    return this.unsafeIsInterrupted && this.unsafeIsInterruptible && !this.unsafeIsInterrupting;
+  }
+
+  unsafeDisableInterruption() {
+    this.interruptStatus.push(false);
+  }
+
+  unsafeRestoreInterruptStatus() {
+    this.stack.push(this.interruptExit);
+  }
+
+  unsafeAddSuppressedCause(cause) {
+    if (!tsplus_module_37.isEmpty(cause)) {
+      if (this.state._tag === "Executing") {
+        this.state.suppressed = tsplus_module_26.then(this.state.suppressed, cause);
+      }
+    }
+  }
+  /**
+   * Unwinds the stack, looking for the first error handler, and exiting
+   * interruptible / uninterruptible regions.
+   */
+
+
+  unsafeUnwindStack() {
+    let unwinding = true;
+    let discardedFolds = false; // Unwind the stack, looking for an error handler:
+
+    while (unwinding && this.stack.hasNext) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const frame = this.stack.pop();
+
+      switch (frame._tag) {
+        case "InterruptExit":
+          {
+            this.interruptStatus.pop();
+            break;
+          }
+
+        case "Finalizer":
+          {
+            this.unsafeDisableInterruption();
+            this.stack.push(new TracedCont(cause => tsplus_module_10.matchCauseIO_(frame.finalizer, finalizerCause => {
+              this.interruptStatus.pop();
+              this.unsafeAddSuppressedCause(finalizerCause);
+              return tsplus_module_10.failCauseNow(cause, fileName_1 + ":663:43");
+            }, () => {
+              this.interruptStatus.pop();
+              return tsplus_module_10.failCauseNow(cause, fileName_1 + ":667:43");
+            }, fileName_1 + ":659:45"), frame.trace));
+            unwinding = false;
+            break;
+          }
+
+        case "Match"
+        /* IOTag.Match */
+        :
+          {
+            if (!this.unsafeShouldInterrupt) {
+              // Push error handler back onto the stack and halt iteration:
+              this.stack.push(new HandlerFrame(frame.onFailure, frame.trace));
+              unwinding = false;
+            } else {
+              discardedFolds = true;
+            }
+
+            break;
+          }
+      }
+    }
+
+    return discardedFolds;
+  }
+
+  unsafeAddObserver(k) {
+    switch (this.state._tag) {
+      case "Done":
+        {
+          return this.state.value;
+        }
+
+      case "Executing":
+        {
+          this.state.observers.add(k);
+          return null;
+        }
+    }
+  }
+
+  unsafeNextEffect(value) {
+    if (this.stack.hasNext) {
+      const k = this.stack.pop();
+      return (0, _definition7.concrete)(k.apply(value));
+    } else {
+      return this.unsafeTryDone(tsplus_module_27.succeed(value));
+    }
+  }
+
+  unsafeNotifyObservers(v, observers) {
+    if (observers.size > 0) {
+      const result = tsplus_module_27.succeed(v);
+      observers.forEach(k => k(result));
+    }
+  }
+
+  unsafeRemoveObserver(k) {
+    if (this.state._tag === "Executing") {
+      this.state.observers.delete(k);
+    }
+  }
+
+  unsafeInterruptAs(fiberId) {
+    const interruptedCause = tsplus_module_26.interrupt(fiberId);
+    return tsplus_module_10.defer(() => {
+      const oldState = this.state;
+
+      if (this.state._tag === "Executing" && this.state.status._tag === "Suspended" && this.state.status.interruptible && this.state.asyncCanceller._tag === "Registered") {
+        const asyncCanceller = this.state.asyncCanceller.asyncCanceller;
+        const interrupt = tsplus_module_10.failCauseNow(interruptedCause, fileName_1 + ":737:52");
+        this.state.status = tsplus_module_38.running(true);
+        this.state.interruptors = new Set(oldState.interruptors).add(fiberId);
+        this.state.asyncCanceller = tsplus_module_39.empty;
+        this.unsafeRunLater((0, _definition7.concrete)(tsplus_module_10.flatMap_(asyncCanceller, () => interrupt, fileName_1 + ":741:60")));
+      } else if (this.state._tag === "Executing") {
+        const newCause = tsplus_module_26.then(this.state.suppressed, interruptedCause);
+        this.state.interruptors.add(fiberId);
+        this.state.suppressed = newCause;
+      }
+
+      return this.await;
+    }, fileName_1 + ":728:20");
+  }
+
+  unsafeTryDone(exit, trace) {
+    switch (this.state._tag) {
+      case "Done":
+        {
+          // Already done
+          return null;
+        }
+
+      case "Executing":
+        {
+          if (this.state.mailbox !== null) {
+            // Not done because the mailbox isn't empty
+            const mailbox = this.state.mailbox;
+            this.state.mailbox = null;
+            this.unsafeSetInterrupting(true);
+            return (0, _definition7.concrete)(tsplus_module_10.flatMap_(mailbox, () => tsplus_module_10.fromExit(() => exit, fileName_1 + ":763:60"), fileName_1 + ":763:42"));
+          } else if (this._children.size === 0) {
+            // We are truly "done" because all the children of this fiber have terminated,
+            // and there are no more pending effects that we have to execute on the fiber.
+            const interruptorsCause = tsplus_module_40.interruptorsCause(this.state);
+            const newExit = tsplus_module_37.isEmpty(interruptorsCause) ? exit : tsplus_module_14.mapErrorCause_(exit, cause => {
+              if (tsplus_module_26.contains_(cause, interruptorsCause)) {
+                return cause;
+              } else {
+                return tsplus_module_26.then(cause, interruptorsCause);
+              }
+            });
+            const observers = this.state.observers;
+            this.state = tsplus_module_8.done(newExit);
+            this.unsafeReportUnhandled(newExit);
+            this.unsafeNotifyObservers(newExit, observers);
+            return null;
+          } else {
+            // not done because there are children left to close
+            this.unsafeSetInterrupting(true);
+            let interruptChildren = tsplus_module_10.unit;
+
+            this._children.forEach(child => {
+              interruptChildren = tsplus_module_10.flatMap_(interruptChildren, () => child.interruptAs(this.fiberId), fileName_1 + ":795:58");
+            });
+
+            this._children.clear();
+
+            return (0, _definition7.concrete)(tsplus_module_10.flatMap_(interruptChildren, () => tsplus_module_10.fromExit(() => exit, fileName_1 + ":799:70"), fileName_1 + ":799:52"));
+          }
+        }
+    }
+  }
+
+  unsafeSetAsyncCanceller(epoch, asyncCanceller0) {
+    const asyncCanceller = !asyncCanceller0 ? tsplus_module_10.unit : asyncCanceller0;
+
+    if (this.state._tag === "Executing") {
+      if (this.state.status._tag === "Suspended" && this.state.asyncCanceller._tag === "Pending" && this.state.status.epoch === epoch) {
+        this.state.asyncCanceller = tsplus_module_39.registered(asyncCanceller);
+      } else if (this.state.status._tag === "Suspended" && this.state.asyncCanceller._tag === "Registered" && this.state.status.epoch === epoch) {
+        throw new Error("inconsistent state in setAsyncCanceller");
+      }
+    } else {
+      return;
+    }
+  }
+
+  unsafeReportUnhandled(exit, trace) {
+    if (exit._tag === "Failure"
+    /* ExitTag.Failure */
+    ) {
+      this.runtimeConfig.reportFailure(exit.cause);
+    }
+  }
+
+  unsafeSetInterrupting(value) {
+    switch (this.state._tag) {
+      case "Executing":
+        {
+          this.state.status = this.state.status.withInterrupting(value);
+          return;
+        }
+
+      case "Done":
+        {
+          return;
+        }
+    }
+  }
+
+  unsafeEnterAsync(epoch, blockingOn, trace) {
+    if (this.state._tag === "Executing" && this.state.status._tag === "Running"
+    /* FiberStatusTag.Running */
+    && this.state.asyncCanceller._tag === "Empty") {
+      const newStatus = tsplus_module_38.suspended(this.state.status.interrupting, this.unsafeIsInterruptible && !this.unsafeIsInterrupting, epoch, blockingOn, trace);
+      this.state.status = newStatus;
+      this.state.asyncCanceller = tsplus_module_39.pending;
+    } else {
+      throw new tsplus_module_32.IllegalStateError(`Fiber ${tsplus_module_3.threadName(this.fiberId)} is not running`);
+    }
+  }
+
+  unsafeExitAsync(epoch) {
+    if (this.state._tag === "Executing" && this.state.status._tag === "Suspended" && this.state.status.epoch === epoch) {
+      this.state.status = tsplus_module_38.running(this.state.status.interrupting);
+      this.state.asyncCanceller = tsplus_module_39.empty;
+      return true;
+    }
+
+    return false;
+  }
+
+  unsafeCreateAsyncResume(epoch) {
+    return _ => {
+      if (this.unsafeExitAsync(epoch)) {
+        this.unsafeRunLater((0, _definition7.concrete)(_));
+      }
+    };
+  }
+
+  unsafeFork(io, forkScope = tsplus_module_1.nothing(), trace) {
+    const childId = tsplus_module_33.unsafeMake(tsplus_module_41.parse(trace));
+    const childFiberRefLocals = tsplus_module_12.mapWithIndex_(this.fiberRefLocals.get, (fiberRef, stack) => {
+      const oldValue = stack.head[1];
+      const newValue = tsplus_module_35.patch(fiberRef)(tsplus_module_35.fork(fiberRef))(oldValue);
+
+      if (oldValue === newValue) {
+        return stack;
+      } else {
+        return tsplus_module_23.cons([childId, newValue], stack);
+      }
+    });
+    const parentScope = tsplus_module_31.getOrElse_(tsplus_module_31.orElse_(forkScope, () => this.unsafeGetRef(tsplus_module_30.forkScopeOverride)), () => this.scope);
+    const grandChildren = new Set();
+    const childContext = new FiberContext(childId, this.runtimeConfig, tsplus_module_9.single(this.unsafeIsInterruptible), new _AtomicReference.AtomicReference(childFiberRefLocals), grandChildren);
+
+    if (this.currentSupervisor !== tsplus_module_25.none) {
+      this.currentSupervisor.unsafeOnStart(this.unsafeGetRef(tsplus_module_30.currentEnvironment), io, tsplus_module_1.just(this), childContext);
+      childContext.unsafeOnDone(exit => {
+        this.currentSupervisor.unsafeOnEnd(tsplus_module_14.flatten(exit), childContext);
+      });
+    }
+
+    const childIO = !parentScope.unsafeAdd(childContext) ? tsplus_module_34.interruptAs(parentScope.fiberId, fileName_1 + ":928:74") : io;
+    childContext.nextIO = (0, _definition7.concrete)(childIO);
+    (0, _Scheduler.defaultScheduler)(() => childContext.runUntil(this.runtimeConfig.yieldOpCount));
+    return childContext;
+  }
+
+  unsafeOnDone(k) {
+    const exit = this.unsafeAddObserver(k);
+
+    if (exit == null) {
+      return;
+    } else {
+      k(tsplus_module_27.succeed(exit));
+    }
+  }
+
+  unsafeClearSuppressedCause() {
+    switch (this.state._tag) {
+      case "Executing":
+        {
+          const suppressed = this.state.suppressed;
+          this.state.suppressed = tsplus_module_26.empty();
+          return suppressed;
+        }
+
+      case "Done":
+        {
+          return tsplus_module_26.empty();
+        }
+    }
+  }
+
+  unsafeGetDescriptor() {
+    return new tsplus_module_42.FiberDescriptor(this.fiberId, this.state.status, this.state.interruptors, tsplus_module_28.fromBoolean(this.unsafeIsInterruptible), this.scope);
+  }
+
+  unsafeRace(race) {
+    const raceIndicator = new _AtomicReference.AtomicReference(true);
+    const left = this.unsafeFork((0, _definition7.concrete)(race.left), tsplus_module_1.nothing(), race.trace);
+    const right = this.unsafeFork((0, _definition7.concrete)(race.right), tsplus_module_1.nothing(), race.trace);
+    return tsplus_module_10.async(cb => {
+      const leftRegister = left.unsafeAddObserver(() => {
+        this.unsafeCompleteRace(left, right, race.leftWins, raceIndicator, cb);
+      });
+
+      if (leftRegister != null) {
+        this.unsafeCompleteRace(left, right, race.leftWins, raceIndicator, cb);
+      } else {
+        const rightRegister = right.unsafeAddObserver(exit => {
+          this.unsafeCompleteRace(left, right, race.rightWins, raceIndicator, cb);
+        });
+
+        if (rightRegister != null) {
+          this.unsafeCompleteRace(right, left, race.rightWins, raceIndicator, cb);
+        }
+      }
+    }, tsplus_module_3.combine_(left.fiberId, right.fiberId), fileName_1 + ":975:20");
+  }
+
+  unsafeCompleteRace(winner, loser, cont, ab, cb) {
+    if (ab.compareAndSet(true, false)) {
+      cb(cont(winner, loser));
+    }
+  }
+
+  unsafeCaptureTrace(prefix) {
+    const builder = new _StackTraceBuilder.StackTraceBuilder();
+    tsplus_module_43.forEach_(prefix, element => builder.append(tsplus_module_41.parse(element)));
+    const stack = this.stack.clone();
+
+    while (stack.hasNext) {
+      builder.append(tsplus_module_41.parse(stack.pop().trace));
+    }
+
+    return new tsplus_module_44.Trace(this.fiberId, builder.result());
+  }
+
+  unsafeEvalOn(effect, orElse) {
+    if (this.state._tag === "Executing") {
+      const newMailbox = this.state.mailbox == null ? effect : tsplus_module_10.flatMap_(this.state.mailbox, () => effect, fileName_1 + ":1019:92");
+      this.state.mailbox = newMailbox;
+      return tsplus_module_10.unit;
+    } else {
+      return tsplus_module_10.asUnit(orElse);
+    }
+  }
+
+  unsafeDrainMailbox() {
+    if (this.state._tag === "Executing") {
+      const mailbox = this.state.mailbox;
+      this.state.mailbox = null;
+      return mailbox;
+    } else {
+      return null;
+    }
+  }
+
+  unsafeAddChild(child) {
+    this.unsafeEvalOn(tsplus_module_10.succeed(() => {
+      this._children.add(child);
+    }, fileName_1 + ":1039:17"), tsplus_module_10.unit);
+  }
+
+  unsafeLog(message, trace) {
+    const logLevel = this.unsafeGetRef(tsplus_module_30.currentLogLevel);
+    const spans = this.unsafeGetRef(tsplus_module_30.currentLogSpan);
+    const annotations = this.unsafeGetRef(tsplus_module_30.currentLogAnnotations);
+    this.runtimeConfig.logger.log(tsplus_module_41.parse(trace), this.fiberId, logLevel, message, tsplus_module_26.empty(), this.fiberRefLocals.get, spans, annotations);
+  }
+
+  unsafeLogWith(message, cause, overrideLogLevel, overrideRef1 = null, overrideValue1 = null, trace) {
+    const logLevel = tsplus_module_31.getOrElse_(overrideLogLevel, () => this.unsafeGetRef(tsplus_module_30.currentLogLevel));
+    const spans = this.unsafeGetRef(tsplus_module_30.currentLogSpan);
+    const annotations = this.unsafeGetRef(tsplus_module_30.currentLogAnnotations);
+    let contextMap;
+
+    if (overrideRef1 !== null) {
+      const map = this.unsafeGetRefs(this.fiberRefLocals);
+
+      if (overrideValue1 === null) {
+        tsplus_module_12.remove_(map, overrideRef1);
+      } else {
+        tsplus_module_12.set_(map, overrideRef1, overrideValue1);
+      }
+
+      contextMap = map;
+    } else {
+      contextMap = this.fiberRefLocals.get;
+    }
+
+    this.runtimeConfig.logger.log(tsplus_module_41.parse(trace), this.fiberId, logLevel, message, cause, contextMap, spans, annotations);
+  }
+
+}
+
+exports.FiberContext = FiberContext;
+//# sourceMappingURL=FiberContext.cjs.map