effect 2.0.0-next.38 → 2.0.0-next.39

package/{dist/core-f6cae6d7.esm.js → internal/stm/core.esm.js}

@@ -1,505 +1,26 @@
-import { i as interrupt$3, d as die$3, f as fail$3, N as NoSuchElementException, R as RuntimeException } from './Cause-5946c7a3.esm.js';
-import { u as unsafeGet$1 } from './Context-c41aa832.esm.js';
-import { E as EffectTypeId, a as async, u as uninterruptibleMask, c as catchAllCause, f as failCause } from './Effect-ee05a487.esm.js';
-import { l as left, r as right } from './Either-aa46c018.esm.js';
-import { s as symbol$1, e as equals } from './Equal-2a99fde3.esm.js';
-import { s as succeed$2, i as interrupt$2, d as die$2, f as fail$2, a as failCause$1 } from './Exit-666b4f01.esm.js';
-import { c as currentContext, a as currentScheduler, b as currentSchedulingPriority } from './FiberRef-ddf157fd.esm.js';
-import { p as pipe, d as dual, b as constVoid } from './Function-12511160.esm.js';
-import { s as symbol, c as combine, h as hash, r as random } from './Hash-7910f34f.esm.js';
-import { w as withFiberRuntime } from './core-64ab7ff5.esm.js';
-import { m as OP_COMMIT } from './Effectable-a292d920.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { S as StreamTypeId } from './Stream-a54c82e5.esm.js';
-import { S as SinkTypeId, C as ChannelTypeId } from './sink-637a9670.esm.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,
-    [symbol]() {
-      return pipe(hash(STMStateSymbolKey), combine(hash(OP_DONE)), combine(hash(exit)));
-    },
-    [symbol$1](that) {
-      return isSTMState(that) && that._tag === OP_DONE && equals(exit, that.exit);
-    }
-  };
-};
-
-/** @internal */
-const interrupted = {
-  [STMStateTypeId]: STMStateTypeId,
-  _tag: OP_INTERRUPTED,
-  [symbol]() {
-    return pipe(hash(STMStateSymbolKey), combine(hash(OP_INTERRUPTED)), combine(hash("interrupted")));
-  },
-  [symbol$1](that) {
-    return isSTMState(that) && that._tag === OP_INTERRUPTED;
-  }
-};
-
-/** @internal */
-const running = {
-  [STMStateTypeId]: STMStateTypeId,
-  _tag: OP_RUNNING,
-  [symbol]() {
-    return pipe(hash(STMStateSymbolKey), combine(hash(OP_RUNNING)), combine(hash("running")));
-  },
-  [symbol$1](that) {
-    return isSTMState(that) && that._tag === OP_RUNNING;
-  }
-};
-
-/** @internal */
-const fromTExit = tExit => {
-  switch (tExit._tag) {
-    case OP_FAIL:
-      {
-        return done$1(fail$2(tExit.error));
-      }
-    case OP_DIE:
-      {
-        return done$1(die$2(tExit.defect));
-      }
-    case OP_INTERRUPT:
-      {
-        return done$1(interrupt$2(tExit.fiberId));
-      }
-    case OP_SUCCEED:
-      {
-        return done$1(succeed$2(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,
-  [symbol]() {
-    return pipe(hash(TExitSymbolKey), combine(hash(OP_FAIL)), combine(hash(error)));
-  },
-  [symbol$1](that) {
-    return isExit(that) && that._tag === OP_FAIL && equals(error, that.error);
-  }
-});
-
-/** @internal */
-const die$1 = defect => ({
-  [TExitTypeId]: variance,
-  _tag: OP_DIE,
-  defect,
-  [symbol]() {
-    return pipe(hash(TExitSymbolKey), combine(hash(OP_DIE)), combine(hash(defect)));
-  },
-  [symbol$1](that) {
-    return isExit(that) && that._tag === OP_DIE && equals(defect, that.defect);
-  }
-});
-
-/** @internal */
-const interrupt$1 = fiberId => ({
-  [TExitTypeId]: variance,
-  _tag: OP_INTERRUPT,
-  fiberId,
-  [symbol]() {
-    return pipe(hash(TExitSymbolKey), combine(hash(OP_INTERRUPT)), combine(hash(fiberId)));
-  },
-  [symbol$1](that) {
-    return isExit(that) && that._tag === OP_INTERRUPT && equals(fiberId, that.fiberId);
-  }
-});
-
-/** @internal */
-const succeed$1 = value => ({
-  [TExitTypeId]: variance,
-  _tag: OP_SUCCEED,
-  value,
-  [symbol]() {
-    return pipe(hash(TExitSymbolKey), combine(hash(OP_SUCCEED)), combine(hash(value)));
-  },
-  [symbol$1](that) {
-    return isExit(that) && that._tag === OP_SUCCEED && equals(value, that.value);
-  }
-});
-
-/** @internal */
-const retry$1 = {
-  [TExitTypeId]: variance,
-  _tag: OP_RETRY,
-  [symbol]() {
-    return pipe(hash(TExitSymbolKey), combine(hash(OP_RETRY)), combine(hash("retry")));
-  },
-  [symbol$1](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;
-};
+import { interrupt as interrupt$1, die as die$1, fail as fail$1, NoSuchElementException, RuntimeException } from '../../Cause/dist/effect-Cause.esm.js';
+import { unsafeGet } from '../../Context/dist/effect-Context.esm.js';
+import { EffectTypeId, async, uninterruptibleMask, catchAllCause, failCause } from '../../Effect/dist/effect-Effect.esm.js';
+import { left, right } from '../../Either/dist/effect-Either.esm.js';
+import { symbol } from '../../Equal/dist/effect-Equal.esm.js';
+import { failCause as failCause$1, succeed as succeed$1 } from '../../Exit/dist/effect-Exit.esm.js';
+import { currentContext, currentScheduler, currentSchedulingPriority } from '../../FiberRef/dist/effect-FiberRef.esm.js';
+import { dual, pipe, constVoid } from '../../Function/dist/effect-Function.esm.js';
+import { symbol as symbol$1, random } from '../../Hash/dist/effect-Hash.esm.js';
+import { withFiberRuntime } from '../core.esm.js';
+import { OP_COMMIT } from '../opCodes/effect.esm.js';
+import { OP_RETRY, OP_ON_SUCCESS, OP_ON_FAILURE, OP_ON_RETRY, OP_SYNC, OP_SUCCEED as OP_SUCCEED$1, OP_PROVIDE, OP_WITH_STM_RUNTIME, OP_INTERRUPT as OP_INTERRUPT$1, OP_FAIL as OP_FAIL$1, OP_DIE as OP_DIE$1 } from './opCodes/stm.esm.js';
+import { OP_RETRY as OP_RETRY$1, OP_INTERRUPT, OP_DIE, OP_FAIL, OP_SUCCEED } from './opCodes/tExit.esm.js';
+import { OP_SUSPEND, OP_DONE } from './opCodes/tryCommit.esm.js';
+import { analyzeJournal, JournalAnalysisReadWrite, commitJournal, JournalAnalysisInvalid, collectTodos, execTodos, addTodo } from './stm/journal.esm.js';
+import { isRunning, isDone, interrupted, running, fromTExit } from './stm/stmState.esm.js';
+import { isSuccess, succeed as succeed$2, interrupt as interrupt$2, retry as retry$1, fail as fail$2, die as die$2 } from './stm/tExit.esm.js';
+import { suspend, done } from './stm/tryCommit.esm.js';
+import { make } from './stm/txnId.esm.js';
+import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
+import { StreamTypeId } from '../../Stream/dist/effect-Stream.esm.js';
+import { ChannelTypeId } from '../core-stream.esm.js';
+import { SinkTypeId } from '../sink.esm.js';
 
 /** @internal */
 const STMSymbolKey = "effect/STM";
@@ -556,10 +77,10 @@ class STMPrimitive {
     this[SinkTypeId] = stmVariance;
     this[ChannelTypeId] = stmVariance;
   }
-  [symbol$1](that) {
+  [symbol](that) {
     return this === that;
   }
-  [symbol]() {
+  [symbol$1]() {
     return random(this);
   }
   commit() {
@@ -584,7 +105,7 @@ const unsafeAtomically = (self, onDone, onInterrupt) => withFiberRuntime(state =
   const priority = state.getFiberRef(currentSchedulingPriority);
   const commitResult = tryCommitSync(fiberId, self, env, scheduler, priority);
   switch (commitResult._tag) {
-    case OP_DONE$1:
+    case OP_DONE:
       {
         onDone(commitResult.exit);
         return commitResult.exit;
@@ -627,27 +148,27 @@ const tryCommit = (fiberId, stm, state, env, scheduler, priority) => {
     case OP_SUCCEED:
       {
         state.value = fromTExit(tExit);
-        return completeTodos(succeed$2(tExit.value), journal, scheduler, priority);
+        return completeTodos(succeed$1(tExit.value), journal, scheduler, priority);
       }
     case OP_FAIL:
       {
         state.value = fromTExit(tExit);
-        const cause = fail$3(tExit.error);
+        const cause = fail$1(tExit.error);
         return completeTodos(failCause$1(cause), journal, scheduler, priority);
       }
     case OP_DIE:
       {
         state.value = fromTExit(tExit);
-        const cause = die$3(tExit.defect);
+        const cause = die$1(tExit.defect);
         return completeTodos(failCause$1(cause), journal, scheduler, priority);
       }
     case OP_INTERRUPT:
       {
         state.value = fromTExit(tExit);
-        const cause = interrupt$3(fiberId);
+        const cause = interrupt$1(fiberId);
         return completeTodos(failCause$1(cause), journal, scheduler, priority);
       }
-    case OP_RETRY:
+    case OP_RETRY$1:
       {
         return suspend(journal);
       }
@@ -667,24 +188,24 @@ const tryCommitSync = (fiberId, stm, env, scheduler, priority) => {
   switch (tExit._tag) {
     case OP_SUCCEED:
       {
-        return completeTodos(succeed$2(tExit.value), journal, scheduler, priority);
+        return completeTodos(succeed$1(tExit.value), journal, scheduler, priority);
       }
     case OP_FAIL:
       {
-        const cause = fail$3(tExit.error);
+        const cause = fail$1(tExit.error);
         return completeTodos(failCause$1(cause), journal, scheduler, priority);
       }
     case OP_DIE:
       {
-        const cause = die$3(tExit.defect);
+        const cause = die$1(tExit.defect);
         return completeTodos(failCause$1(cause), journal, scheduler, priority);
       }
     case OP_INTERRUPT:
       {
-        const cause = interrupt$3(fiberId);
+        const cause = interrupt$1(fiberId);
         return completeTodos(failCause$1(cause), journal, scheduler, priority);
       }
-    case OP_RETRY:
+    case OP_RETRY$1:
       {
         return suspend(journal);
       }
@@ -696,7 +217,7 @@ const tryCommitAsync = (fiberId, self, txnId, state, context, scheduler, priorit
   if (isRunning(state.value)) {
     const result = tryCommit(fiberId, self, state, context, scheduler, priority);
     switch (result._tag) {
-      case OP_DONE$1:
+      case OP_DONE:
         {
           completeTryCommit(result.exit, k);
           break;
@@ -784,7 +305,7 @@ class STMDriver {
           switch (current._tag) {
             case "Tag":
               {
-                curr = effect((_, __, env) => unsafeGet$1(env, current));
+                curr = effect((_, __, env) => unsafeGet(env, current));
                 break;
               }
             case "Left":
@@ -812,20 +333,20 @@ class STMDriver {
                 switch (current.i0) {
                   case OP_DIE$1:
                     {
-                      exit = die$1(current.i1());
+                      exit = die$2(current.i1());
                       break;
                     }
                   case OP_FAIL$1:
                     {
                       const cont = this.nextFailure();
                       if (cont === undefined) {
-                        exit = fail$1(current.i1());
+                        exit = fail$2(current.i1());
                       } else {
                         curr = cont.i2(current.i1());
                       }
                       break;
                     }
-                  case OP_RETRY$1:
+                  case OP_RETRY:
                     {
                       const cont = this.nextRetry();
                       if (cont === undefined) {
@@ -837,7 +358,7 @@ class STMDriver {
                     }
                   case OP_INTERRUPT$1:
                     {
-                      exit = interrupt$1(this.fiberId);
+                      exit = interrupt$2(this.fiberId);
                       break;
                     }
                   case OP_WITH_STM_RUNTIME:
@@ -865,7 +386,7 @@ class STMDriver {
                       const value = current.i1;
                       const cont = this.nextSuccess();
                       if (cont === undefined) {
-                        exit = succeed$1(value);
+                        exit = succeed$2(value);
                       } else {
                         curr = cont.i2(value);
                       }
@@ -876,7 +397,7 @@ class STMDriver {
                       const value = current.i1();
                       const cont = this.nextSuccess();
                       if (cont === undefined) {
-                        exit = succeed$1(value);
+                        exit = succeed$2(value);
                       } else {
                         curr = cont.i2(value);
                       }
@@ -1001,7 +522,7 @@ const orTry = /*#__PURE__*/dual(2, (self, that) => {
 });
 
 /** @internal */
-const retry = /*#__PURE__*/new STMPrimitive(OP_RETRY$1);
+const retry = /*#__PURE__*/new STMPrimitive(OP_RETRY);
 
 /** @internal */
 const succeed = value => {
@@ -1029,4 +550,4 @@ const zipRight = /*#__PURE__*/dual(2, (self, that) => pipe(self, flatMap(() => t
 /** @internal */
 const zipWith = /*#__PURE__*/dual(3, (self, that, f) => pipe(self, flatMap(a => pipe(that, map(b => f(a, b))))));
 
-export { isDone as A, unsafeAtomically as B, effect as C, running as D, interrupted as E, done$1 as F, prepareResetJournal as G, withSTMRuntime as H, unsafeGet as I, unsafeSet as J, make$1 as K, STMTypeId as S, Versioned as V, commit as a, context as b, catchAll as c, contextWith as d, contextWithSTM as e, die as f, dieMessage as g, dieSync as h, isSTM as i, ensuring as j, fail as k, failSync as l, mapInputContext as m, flatMap as n, matchSTM as o, interrupt as p, interruptAs as q, map as r, orTry as s, retry as t, succeed as u, sync as v, zipLeft as w, zipRight as x, zipWith as y, zip as z };
+export { STMDriver, STMTypeId, catchAll, commit, context, contextWith, contextWithSTM, die, dieMessage, dieSync, effect, ensuring, fail, failSync, flatMap, interrupt, interruptAs, isSTM, map, mapInputContext, matchSTM, orTry, retry, succeed, sync, unsafeAtomically, withSTMRuntime, zip, zipLeft, zipRight, zipWith };