effect 2.0.0-next.5 → 2.0.0-next.50

package/dist/core-dd1edd7a.cjs.dev.js

@@ -0,0 +1,1072 @@
+'use strict';
+
+var Cause_dist_effectCause = require('../Cause/dist/effect-Cause.cjs.dev.js');
+var Context_dist_effectContext = require('../Context/dist/effect-Context.cjs.dev.js');
+var Effect_dist_effectEffect = require('../Effect/dist/effect-Effect.cjs.dev.js');
+var Either_dist_effectEither = require('../Either/dist/effect-Either.cjs.dev.js');
+var Equal_dist_effectEqual = require('../Equal/dist/effect-Equal.cjs.dev.js');
+var Exit_dist_effectExit = require('../Exit/dist/effect-Exit.cjs.dev.js');
+var FiberRef_dist_effectFiberRef = require('../FiberRef/dist/effect-FiberRef.cjs.dev.js');
+var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
+var Hash_dist_effectHash = require('../Hash/dist/effect-Hash.cjs.dev.js');
+var core = require('./core-b4bf44d3.cjs.dev.js');
+var Effectable = require('./Effectable-71c10ab9.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+var Stream_dist_effectStream = require('../Stream/dist/effect-Stream.cjs.dev.js');
+var sink = require('./sink-1794329b.cjs.dev.js');
+
+/** @internal */
+const OP_WITH_STM_RUNTIME = "WithSTMRuntime";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_FAILURE = "OnFailure";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_RETRY = "OnRetry";
+
+/** @internal */
+
+/** @internal */
+const OP_ON_SUCCESS = "OnSuccess";
+
+/** @internal */
+
+/** @internal */
+const OP_PROVIDE = "Provide";
+
+/** @internal */
+
+/** @internal */
+const OP_SYNC = "Sync";
+
+/** @internal */
+
+/** @internal */
+const OP_SUCCEED$1 = "Succeed";
+
+/** @internal */
+
+/** @internal */
+const OP_RETRY$1 = "Retry";
+
+/** @internal */
+
+/** @internal */
+const OP_FAIL$1 = "Fail";
+
+/** @internal */
+
+/** @internal */
+const OP_DIE$1 = "Die";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPT$1 = "Interrupt";
+
+/** @internal */
+
+/** @internal */
+const OP_FAIL = "Fail";
+
+/** @internal */
+
+/** @internal */
+const OP_DIE = "Die";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPT = "Interrupt";
+
+/** @internal */
+
+/** @internal */
+const OP_SUCCEED = "Succeed";
+
+/** @internal */
+
+/** @internal */
+const OP_RETRY = "Retry";
+
+/** @internal */
+
+/** @internal */
+const OP_DONE$1 = "Done";
+
+/** @internal */
+
+/** @internal */
+const OP_SUSPEND = "Suspend";
+
+/** @internal */
+
+/** @internal */
+class Versioned {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+/** @internal */
+
+/** @internal */
+const make$1 = (ref, isNew) => ({
+  ref,
+  isNew,
+  isChanged: false,
+  expected: ref.versioned,
+  newValue: ref.versioned.value
+});
+const unsafeGet = self => {
+  return self.newValue;
+};
+
+/** @internal */
+const unsafeSet = (self, value) => {
+  self.isChanged = true;
+  self.newValue = value;
+};
+
+/** @internal */
+const commit$1 = self => {
+  self.ref.versioned = new Versioned(self.newValue);
+};
+
+/** @internal */
+const copy = self => ({
+  ref: self.ref,
+  isNew: self.isNew,
+  isChanged: self.isChanged,
+  expected: self.expected,
+  newValue: self.newValue
+});
+
+/** @internal */
+const isInvalid = self => {
+  return self.ref.versioned !== self.expected;
+};
+
+/** @internal */
+const isChanged = self => {
+  return self.isChanged;
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisInvalid = "Invalid";
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisReadWrite = "ReadWrite";
+
+/** @internal */
+
+/** @internal */
+const JournalAnalysisReadOnly = "ReadOnly";
+
+/** @internal */
+
+/** @internal */
+const commitJournal = journal => {
+  for (const entry of journal) {
+    commit$1(entry[1]);
+  }
+};
+
+/**
+ * Analyzes the journal, determining whether it is valid and whether it is
+ * read only in a single pass. Note that information on whether the
+ * journal is read only will only be accurate if the journal is valid, due
+ * to short-circuiting that occurs on an invalid journal.
+ *
+ * @internal
+ */
+const analyzeJournal = journal => {
+  let val = JournalAnalysisReadOnly;
+  for (const [, entry] of journal) {
+    val = isInvalid(entry) ? JournalAnalysisInvalid : isChanged(entry) ? JournalAnalysisReadWrite : val;
+    if (val === JournalAnalysisInvalid) {
+      return val;
+    }
+  }
+  return val;
+};
+
+/** @internal */
+const prepareResetJournal = journal => {
+  const saved = new Map();
+  for (const entry of journal) {
+    saved.set(entry[0], copy(entry[1]));
+  }
+  return () => {
+    journal.clear();
+    for (const entry of saved) {
+      journal.set(entry[0], entry[1]);
+    }
+  };
+};
+
+/** @internal */
+const collectTodos = journal => {
+  const allTodos = new Map();
+  for (const [, entry] of journal) {
+    for (const todo of entry.ref.todos) {
+      allTodos.set(todo[0], todo[1]);
+    }
+    entry.ref.todos = new Map();
+  }
+  return allTodos;
+};
+
+/** @internal */
+const execTodos = todos => {
+  const todosSorted = Array.from(todos.entries()).sort((x, y) => x[0] - y[0]);
+  for (const [_, todo] of todosSorted) {
+    todo();
+  }
+};
+
+/** @internal */
+const addTodo = (txnId, journal, todoEffect) => {
+  let added = false;
+  for (const [, entry] of journal) {
+    if (!entry.ref.todos.has(txnId)) {
+      entry.ref.todos.set(txnId, todoEffect);
+      added = true;
+    }
+  }
+  return added;
+};
+
+/** @internal */
+const OP_DONE = "Done";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPTED = "Interrupted";
+
+/** @internal */
+
+/** @internal */
+const OP_RUNNING = "Running";
+
+/** @internal */
+
+/** @internal */
+const STMStateSymbolKey = "effect/STM/State";
+
+/** @internal */
+const STMStateTypeId = /*#__PURE__*/Symbol.for(STMStateSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isSTMState = u => {
+  return typeof u === "object" && u != null && STMStateTypeId in u;
+};
+
+/** @internal */
+const isRunning = self => {
+  return self._tag === OP_RUNNING;
+};
+
+/** @internal */
+const isDone = self => {
+  return self._tag === OP_DONE;
+};
+
+/** @internal */
+const done$1 = exit => {
+  return {
+    [STMStateTypeId]: STMStateTypeId,
+    _tag: OP_DONE,
+    exit,
+    [Hash_dist_effectHash.symbol]() {
+      return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(STMStateSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_DONE)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(exit)));
+    },
+    [Equal_dist_effectEqual.symbol](that) {
+      return isSTMState(that) && that._tag === OP_DONE && Equal_dist_effectEqual.equals(exit, that.exit);
+    }
+  };
+};
+
+/** @internal */
+const interrupted = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OP_INTERRUPTED,
+  [Hash_dist_effectHash.symbol]() {
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(STMStateSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_INTERRUPTED)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash("interrupted")));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isSTMState(that) && that._tag === OP_INTERRUPTED;
+  }
+};
+
+/** @internal */
+const running = {
+  [STMStateTypeId]: STMStateTypeId,
+  _tag: OP_RUNNING,
+  [Hash_dist_effectHash.symbol]() {
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(STMStateSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_RUNNING)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash("running")));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isSTMState(that) && that._tag === OP_RUNNING;
+  }
+};
+
+/** @internal */
+const fromTExit = tExit => {
+  switch (tExit._tag) {
+    case OP_FAIL:
+      {
+        return done$1(Exit_dist_effectExit.fail(tExit.error));
+      }
+    case OP_DIE:
+      {
+        return done$1(Exit_dist_effectExit.die(tExit.defect));
+      }
+    case OP_INTERRUPT:
+      {
+        return done$1(Exit_dist_effectExit.interrupt(tExit.fiberId));
+      }
+    case OP_SUCCEED:
+      {
+        return done$1(Exit_dist_effectExit.succeed(tExit.value));
+      }
+    case OP_RETRY:
+      {
+        throw new Error("BUG: STM.STMState.fromTExit - please report an issue at https://github.com/Effect-TS/io/issues");
+      }
+  }
+};
+
+/** @internal */
+const TExitSymbolKey = "effect/TExit";
+
+/** @internal */
+const TExitTypeId = /*#__PURE__*/Symbol.for(TExitSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const variance = {
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isExit = u => {
+  return typeof u === "object" && u != null && TExitTypeId in u;
+};
+
+/** @internal */
+const isSuccess = self => {
+  return self._tag === OP_SUCCEED;
+};
+
+/** @internal */
+const isRetry = self => {
+  return self._tag === OP_RETRY;
+};
+
+/** @internal */
+const fail$1 = error => ({
+  [TExitTypeId]: variance,
+  _tag: OP_FAIL,
+  error,
+  [Hash_dist_effectHash.symbol]() {
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(TExitSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_FAIL)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(error)));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isExit(that) && that._tag === OP_FAIL && Equal_dist_effectEqual.equals(error, that.error);
+  }
+});
+
+/** @internal */
+const die$1 = defect => ({
+  [TExitTypeId]: variance,
+  _tag: OP_DIE,
+  defect,
+  [Hash_dist_effectHash.symbol]() {
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(TExitSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_DIE)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(defect)));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isExit(that) && that._tag === OP_DIE && Equal_dist_effectEqual.equals(defect, that.defect);
+  }
+});
+
+/** @internal */
+const interrupt$1 = fiberId => ({
+  [TExitTypeId]: variance,
+  _tag: OP_INTERRUPT,
+  fiberId,
+  [Hash_dist_effectHash.symbol]() {
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(TExitSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_INTERRUPT)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(fiberId)));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isExit(that) && that._tag === OP_INTERRUPT && Equal_dist_effectEqual.equals(fiberId, that.fiberId);
+  }
+});
+
+/** @internal */
+const succeed$1 = value => ({
+  [TExitTypeId]: variance,
+  _tag: OP_SUCCEED,
+  value,
+  [Hash_dist_effectHash.symbol]() {
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(TExitSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_SUCCEED)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(value)));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isExit(that) && that._tag === OP_SUCCEED && Equal_dist_effectEqual.equals(value, that.value);
+  }
+});
+
+/** @internal */
+const retry$1 = {
+  [TExitTypeId]: variance,
+  _tag: OP_RETRY,
+  [Hash_dist_effectHash.symbol]() {
+    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(TExitSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(OP_RETRY)), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash("retry")));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isExit(that) && isRetry(that);
+  }
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const done = exit => {
+  return {
+    _tag: OP_DONE$1,
+    exit
+  };
+};
+
+/** @internal */
+const suspend = journal => {
+  return {
+    _tag: OP_SUSPEND,
+    journal
+  };
+};
+
+/** @internal */
+
+/** @internal */
+const txnCounter = {
+  ref: 0
+};
+
+/** @internal */
+const make = () => {
+  const newId = txnCounter.ref + 1;
+  txnCounter.ref = newId;
+  return newId;
+};
+
+/** @internal */
+const STMSymbolKey = "effect/STM";
+
+/** @internal */
+const STMTypeId = /*#__PURE__*/Symbol.for(STMSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const stmVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+class STMPrimitive {
+  _tag = Effectable.OP_COMMIT;
+  _op = Effectable.OP_COMMIT;
+  i1 = undefined;
+  i2 = undefined;
+  get [STMTypeId]() {
+    return stmVariance;
+  }
+  constructor(i0) {
+    this.i0 = i0;
+    this[Effect_dist_effectEffect.EffectTypeId] = stmVariance;
+    this[Stream_dist_effectStream.StreamTypeId] = stmVariance;
+    this[sink.SinkTypeId] = stmVariance;
+    this[sink.ChannelTypeId] = stmVariance;
+  }
+  [Equal_dist_effectEqual.symbol](that) {
+    return this === that;
+  }
+  [Hash_dist_effectHash.symbol]() {
+    return Hash_dist_effectHash.random(this);
+  }
+  commit() {
+    return unsafeAtomically(this, Function_dist_effectFunction.constVoid, Function_dist_effectFunction.constVoid);
+  }
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const isSTM = u => typeof u === "object" && u != null && STMTypeId in u;
+
+/** @internal */
+const commit = self => unsafeAtomically(self, Function_dist_effectFunction.constVoid, Function_dist_effectFunction.constVoid);
+
+/** @internal */
+const unsafeAtomically = (self, onDone, onInterrupt) => core.withFiberRuntime(state => {
+  const fiberId = state.id();
+  const env = state.getFiberRef(FiberRef_dist_effectFiberRef.currentContext);
+  const scheduler = state.getFiberRef(FiberRef_dist_effectFiberRef.currentScheduler);
+  const priority = state.getFiberRef(FiberRef_dist_effectFiberRef.currentSchedulingPriority);
+  const commitResult = tryCommitSync(fiberId, self, env, scheduler, priority);
+  switch (commitResult._tag) {
+    case OP_DONE$1:
+      {
+        onDone(commitResult.exit);
+        return commitResult.exit;
+      }
+    case OP_SUSPEND:
+      {
+        const txnId = make();
+        const state = {
+          value: running
+        };
+        const effect = Effect_dist_effectEffect.async(k => tryCommitAsync(fiberId, self, txnId, state, env, scheduler, priority, k));
+        return Effect_dist_effectEffect.uninterruptibleMask(restore => Function_dist_effectFunction.pipe(restore(effect), Effect_dist_effectEffect.catchAllCause(cause => {
+          let currentState = state.value;
+          if (isRunning(currentState)) {
+            state.value = interrupted;
+          }
+          currentState = state.value;
+          if (isDone(currentState)) {
+            onDone(currentState.exit);
+            return currentState.exit;
+          }
+          onInterrupt();
+          return Effect_dist_effectEffect.failCause(cause);
+        })));
+      }
+  }
+});
+
+/** @internal */
+const tryCommit = (fiberId, stm, state, env, scheduler, priority) => {
+  const journal = new Map();
+  const tExit = new STMDriver(stm, journal, fiberId, env).run();
+  const analysis = analyzeJournal(journal);
+  if (analysis === JournalAnalysisReadWrite) {
+    commitJournal(journal);
+  } else if (analysis === JournalAnalysisInvalid) {
+    throw new Error("BUG: STM.TryCommit.tryCommit - please report an issue at https://github.com/Effect-TS/io/issues");
+  }
+  switch (tExit._tag) {
+    case OP_SUCCEED:
+      {
+        state.value = fromTExit(tExit);
+        return completeTodos(Exit_dist_effectExit.succeed(tExit.value), journal, scheduler, priority);
+      }
+    case OP_FAIL:
+      {
+        state.value = fromTExit(tExit);
+        const cause = Cause_dist_effectCause.fail(tExit.error);
+        return completeTodos(Exit_dist_effectExit.failCause(cause), journal, scheduler, priority);
+      }
+    case OP_DIE:
+      {
+        state.value = fromTExit(tExit);
+        const cause = Cause_dist_effectCause.die(tExit.defect);
+        return completeTodos(Exit_dist_effectExit.failCause(cause), journal, scheduler, priority);
+      }
+    case OP_INTERRUPT:
+      {
+        state.value = fromTExit(tExit);
+        const cause = Cause_dist_effectCause.interrupt(fiberId);
+        return completeTodos(Exit_dist_effectExit.failCause(cause), journal, scheduler, priority);
+      }
+    case OP_RETRY:
+      {
+        return suspend(journal);
+      }
+  }
+};
+
+/** @internal */
+const tryCommitSync = (fiberId, stm, env, scheduler, priority) => {
+  const journal = new Map();
+  const tExit = new STMDriver(stm, journal, fiberId, env).run();
+  const analysis = analyzeJournal(journal);
+  if (analysis === JournalAnalysisReadWrite && isSuccess(tExit)) {
+    commitJournal(journal);
+  } else if (analysis === JournalAnalysisInvalid) {
+    throw new Error("BUG: STM.TryCommit.tryCommitSync - please report an issue at https://github.com/Effect-TS/io/issues");
+  }
+  switch (tExit._tag) {
+    case OP_SUCCEED:
+      {
+        return completeTodos(Exit_dist_effectExit.succeed(tExit.value), journal, scheduler, priority);
+      }
+    case OP_FAIL:
+      {
+        const cause = Cause_dist_effectCause.fail(tExit.error);
+        return completeTodos(Exit_dist_effectExit.failCause(cause), journal, scheduler, priority);
+      }
+    case OP_DIE:
+      {
+        const cause = Cause_dist_effectCause.die(tExit.defect);
+        return completeTodos(Exit_dist_effectExit.failCause(cause), journal, scheduler, priority);
+      }
+    case OP_INTERRUPT:
+      {
+        const cause = Cause_dist_effectCause.interrupt(fiberId);
+        return completeTodos(Exit_dist_effectExit.failCause(cause), journal, scheduler, priority);
+      }
+    case OP_RETRY:
+      {
+        return suspend(journal);
+      }
+  }
+};
+
+/** @internal */
+const tryCommitAsync = (fiberId, self, txnId, state, context, scheduler, priority, k) => {
+  if (isRunning(state.value)) {
+    const result = tryCommit(fiberId, self, state, context, scheduler, priority);
+    switch (result._tag) {
+      case OP_DONE$1:
+        {
+          completeTryCommit(result.exit, k);
+          break;
+        }
+      case OP_SUSPEND:
+        {
+          addTodo(txnId, result.journal, () => tryCommitAsync(fiberId, self, txnId, state, context, scheduler, priority, k));
+          break;
+        }
+    }
+  }
+};
+
+/** @internal */
+const completeTodos = (exit, journal, scheduler, priority) => {
+  const todos = collectTodos(journal);
+  if (todos.size > 0) {
+    scheduler.scheduleTask(() => execTodos(todos), priority);
+  }
+  return done(exit);
+};
+
+/** @internal */
+const completeTryCommit = (exit, k) => {
+  k(exit);
+};
+
+/** @internal */
+
+/** @internal */
+const context = () => effect((_, __, env) => env);
+
+/** @internal */
+const contextWith = f => map(context(), f);
+
+/** @internal */
+const contextWithSTM = f => flatMap(context(), f);
+
+/** @internal */
+class STMDriver {
+  contStack = [];
+  constructor(self, journal, fiberId, r0) {
+    this.self = self;
+    this.journal = journal;
+    this.fiberId = fiberId;
+    this.env = r0;
+  }
+  getEnv() {
+    return this.env;
+  }
+  pushStack(cont) {
+    this.contStack.push(cont);
+  }
+  popStack() {
+    return this.contStack.pop();
+  }
+  nextSuccess() {
+    let current = this.popStack();
+    while (current !== undefined && current.i0 !== OP_ON_SUCCESS) {
+      current = this.popStack();
+    }
+    return current;
+  }
+  nextFailure() {
+    let current = this.popStack();
+    while (current !== undefined && current.i0 !== OP_ON_FAILURE) {
+      current = this.popStack();
+    }
+    return current;
+  }
+  nextRetry() {
+    let current = this.popStack();
+    while (current !== undefined && current.i0 !== OP_ON_RETRY) {
+      current = this.popStack();
+    }
+    return current;
+  }
+  run() {
+    let curr = this.self;
+    let exit = undefined;
+    while (exit === undefined && curr !== undefined) {
+      try {
+        const current = curr;
+        if (current) {
+          switch (current._tag) {
+            case "Tag":
+              {
+                curr = effect((_, __, env) => Context_dist_effectContext.unsafeGet(env, current));
+                break;
+              }
+            case "Left":
+              {
+                curr = fail(current.left);
+                break;
+              }
+            case "None":
+              {
+                curr = fail(Cause_dist_effectCause.NoSuchElementException());
+                break;
+              }
+            case "Right":
+              {
+                curr = succeed(current.right);
+                break;
+              }
+            case "Some":
+              {
+                curr = succeed(current.value);
+                break;
+              }
+            case "Commit":
+              {
+                switch (current.i0) {
+                  case OP_DIE$1:
+                    {
+                      exit = die$1(current.i1());
+                      break;
+                    }
+                  case OP_FAIL$1:
+                    {
+                      const cont = this.nextFailure();
+                      if (cont === undefined) {
+                        exit = fail$1(current.i1());
+                      } else {
+                        curr = cont.i2(current.i1());
+                      }
+                      break;
+                    }
+                  case OP_RETRY$1:
+                    {
+                      const cont = this.nextRetry();
+                      if (cont === undefined) {
+                        exit = retry$1;
+                      } else {
+                        curr = cont.i2();
+                      }
+                      break;
+                    }
+                  case OP_INTERRUPT$1:
+                    {
+                      exit = interrupt$1(this.fiberId);
+                      break;
+                    }
+                  case OP_WITH_STM_RUNTIME:
+                    {
+                      curr = current.i1(this);
+                      break;
+                    }
+                  case OP_ON_SUCCESS:
+                  case OP_ON_FAILURE:
+                  case OP_ON_RETRY:
+                    {
+                      this.pushStack(current);
+                      curr = current.i1;
+                      break;
+                    }
+                  case OP_PROVIDE:
+                    {
+                      const env = this.env;
+                      this.env = current.i2(env);
+                      curr = Function_dist_effectFunction.pipe(current.i1, ensuring(sync(() => this.env = env)));
+                      break;
+                    }
+                  case OP_SUCCEED$1:
+                    {
+                      const value = current.i1;
+                      const cont = this.nextSuccess();
+                      if (cont === undefined) {
+                        exit = succeed$1(value);
+                      } else {
+                        curr = cont.i2(value);
+                      }
+                      break;
+                    }
+                  case OP_SYNC:
+                    {
+                      const value = current.i1();
+                      const cont = this.nextSuccess();
+                      if (cont === undefined) {
+                        exit = succeed$1(value);
+                      } else {
+                        curr = cont.i2(value);
+                      }
+                      break;
+                    }
+                }
+                break;
+              }
+          }
+        }
+      } catch (e) {
+        curr = die(e);
+      }
+    }
+    return exit;
+  }
+}
+
+/** @internal */
+const catchAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const stm = new STMPrimitive(OP_ON_FAILURE);
+  stm.i1 = self;
+  stm.i2 = f;
+  return stm;
+});
+
+/** @internal */
+const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const stm = new STMPrimitive(OP_PROVIDE);
+  stm.i1 = self;
+  stm.i2 = f;
+  return stm;
+});
+
+/** @internal */
+const die = defect => dieSync(() => defect);
+
+/** @internal */
+const dieMessage = message => dieSync(() => Cause_dist_effectCause.RuntimeException(message));
+
+/** @internal */
+const dieSync = evaluate => {
+  const stm = new STMPrimitive(OP_DIE$1);
+  stm.i1 = evaluate;
+  return stm;
+};
+
+/** @internal */
+const effect = f => withSTMRuntime(_ => succeed(f(_.journal, _.fiberId, _.getEnv())));
+
+/** @internal */
+const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => matchSTM(self, {
+  onFailure: e => zipRight(finalizer, fail(e)),
+  onSuccess: a => zipRight(finalizer, succeed(a))
+}));
+
+/** @internal */
+const fail = error => failSync(() => error);
+
+/** @internal */
+const failSync = evaluate => {
+  const stm = new STMPrimitive(OP_FAIL$1);
+  stm.i1 = evaluate;
+  return stm;
+};
+
+/** @internal */
+const flatMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const stm = new STMPrimitive(OP_ON_SUCCESS);
+  stm.i1 = self;
+  stm.i2 = f;
+  return stm;
+});
+
+/** @internal */
+const matchSTM = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => Function_dist_effectFunction.pipe(self, map(Either_dist_effectEither.right), catchAll(e => Function_dist_effectFunction.pipe(onFailure(e), map(Either_dist_effectEither.left))), flatMap(either => {
+  switch (either._tag) {
+    case "Left":
+      {
+        return succeed(either.left);
+      }
+    case "Right":
+      {
+        return onSuccess(either.right);
+      }
+  }
+})));
+
+/** @internal */
+const withSTMRuntime = f => {
+  const stm = new STMPrimitive(OP_WITH_STM_RUNTIME);
+  stm.i1 = f;
+  return stm;
+};
+
+/** @internal */
+const interrupt = /*#__PURE__*/withSTMRuntime(_ => {
+  const stm = new STMPrimitive(OP_INTERRUPT$1);
+  stm.i1 = _.fiberId;
+  return stm;
+});
+
+/** @internal */
+const interruptAs = fiberId => {
+  const stm = new STMPrimitive(OP_INTERRUPT$1);
+  stm.i1 = fiberId;
+  return stm;
+};
+
+/** @internal */
+const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, flatMap(a => sync(() => f(a)))));
+
+/** @internal */
+const orTry = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
+  const stm = new STMPrimitive(OP_ON_RETRY);
+  stm.i1 = self;
+  stm.i2 = that;
+  return stm;
+});
+
+/** @internal */
+const retry = /*#__PURE__*/new STMPrimitive(OP_RETRY$1);
+
+/** @internal */
+const succeed = value => {
+  const stm = new STMPrimitive(OP_SUCCEED$1);
+  stm.i1 = value;
+  return stm;
+};
+
+/** @internal */
+const sync = evaluate => {
+  const stm = new STMPrimitive(OP_SYNC);
+  stm.i1 = evaluate;
+  return stm;
+};
+
+/** @internal */
+const zip = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWith(that, (a, a1) => [a, a1])));
+
+/** @internal */
+const zipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, flatMap(a => Function_dist_effectFunction.pipe(that, map(() => a)))));
+
+/** @internal */
+const zipRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, flatMap(() => that)));
+
+/** @internal */
+const zipWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => Function_dist_effectFunction.pipe(self, flatMap(a => Function_dist_effectFunction.pipe(that, map(b => f(a, b))))));
+
+exports.STMTypeId = STMTypeId;
+exports.Versioned = Versioned;
+exports.catchAll = catchAll;
+exports.commit = commit;
+exports.context = context;
+exports.contextWith = contextWith;
+exports.contextWithSTM = contextWithSTM;
+exports.die = die;
+exports.dieMessage = dieMessage;
+exports.dieSync = dieSync;
+exports.done = done$1;
+exports.effect = effect;
+exports.ensuring = ensuring;
+exports.fail = fail;
+exports.failSync = failSync;
+exports.flatMap = flatMap;
+exports.interrupt = interrupt;
+exports.interruptAs = interruptAs;
+exports.interrupted = interrupted;
+exports.isDone = isDone;
+exports.isSTM = isSTM;
+exports.make = make$1;
+exports.map = map;
+exports.mapInputContext = mapInputContext;
+exports.matchSTM = matchSTM;
+exports.orTry = orTry;
+exports.prepareResetJournal = prepareResetJournal;
+exports.retry = retry;
+exports.running = running;
+exports.succeed = succeed;
+exports.sync = sync;
+exports.unsafeAtomically = unsafeAtomically;
+exports.unsafeGet = unsafeGet;
+exports.unsafeSet = unsafeSet;
+exports.withSTMRuntime = withSTMRuntime;
+exports.zip = zip;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;