Function unsafeAtomically

packages/effect/src/internal/stm/core.ts:192–235

(
  self: STM.STM<A, E, R>,
  onDone: (exit: Exit.Exit<A, E>) => unknown,
  onInterrupt: LazyArg<unknown>
)

/** @internal */
export const unsafeAtomically = <A, E, R>(
  self: STM.STM<A, E, R>,
  onDone: (exit: Exit.Exit<A, E>) => unknown,
  onInterrupt: LazyArg<unknown>
): Effect.Effect<A, E, R> =>
  withFiberRuntime((state) => {
    const fiberId = state.id()
    const env = state.getFiberRef(FiberRef.currentContext) as Context.Context<R>
    const scheduler = state.getFiberRef(FiberRef.currentScheduler)
    const priority = state.getFiberRef(FiberRef.currentSchedulingPriority)
    const commitResult = tryCommitSync(fiberId, self, env, scheduler, priority)
    switch (commitResult._tag) {
      case TryCommitOpCodes.OP_DONE: {
        onDone(commitResult.exit)
        return commitResult.exit
      }
      case TryCommitOpCodes.OP_SUSPEND: {
        const txnId = TxnId.make()
        const state: { value: STMState.STMState<A, E> } = { value: STMState.running }
        const effect = Effect.async(
          (k: (effect: Effect.Effect<A, E, R>) => unknown): void =>
            tryCommitAsync(fiberId, self, txnId, state, env, scheduler, priority, k)
        )
        return Effect.uninterruptibleMask((restore) =>
          pipe(
            restore(effect),
            Effect.catchAllCause((cause) => {
              let currentState = state.value
              if (STMState.isRunning(currentState)) {
                state.value = STMState.interrupted
              }
              currentState = state.value
              if (STMState.isDone(currentState)) {
                onDone(currentState.exit)
                return currentState.exit
              }
              onInterrupt()
              return Effect.failCause(cause)
            })
          )
        )
      }
    }
  })

/** @internal */
const tryCommit = <A, E, R>(