Function invokeWithInterrupt

packages/effect/src/internal/fiberRuntime.ts:3719–3786

(
  self: Effect.Effect<A, E, R>,
  entries: ReadonlyArray<Entry<unknown>>,
  onInterrupt?: () => void
)

  entries: ReadonlyArray<Entry<unknown>>,
  onInterrupt?: () => void
) => Effect.Effect<void, E, R> = <A, E, R>(
  self: Effect.Effect<A, E, R>,
  entries: ReadonlyArray<Entry<unknown>>,
  onInterrupt?: () => void
) =>
  core.fiberIdWith((id) =>
    ensuring(
      core.flatMap(
        forkDaemon(core.interruptible(self)),
        (processing) =>
          core.async<void, E>((cb) => {
            const counts = entries.map((_) => _.listeners.count)
            const checkDone = () => {
              if (counts.every((count) => count === 0)) {
                if (
                  entries.every((_) => {
                    if (_.result.state.current._tag === "Pending") {
                      return true
                    } else if (
                      _.result.state.current._tag === "Done" &&
                      core.exitIsExit(_.result.state.current.effect) &&
                      _.result.state.current.effect._tag === "Failure" &&
                      internalCause.isInterrupted(_.result.state.current.effect.cause)
                    ) {
                      return true
                    } else {
                      return false
                    }
                  })
                ) {
                  cleanup.forEach((f) => f())
                  onInterrupt?.()
                  cb(core.interruptFiber(processing))
                }
              }
            }
            processing.addObserver((exit) => {
              cleanup.forEach((f) => f())
              cb(exit)
            })
            const cleanup = entries.map((r, i) => {
              const observer = (count: number) => {
                counts[i] = count
                checkDone()
              }
              r.listeners.addObserver(observer)
              return () => r.listeners.removeObserver(observer)
            })
            checkDone()
            return core.sync(() => {
              cleanup.forEach((f) => f())
            })
          })
      ),
      core.suspend(() => {
        const residual = entries.flatMap((entry) => {
          if (!entry.state.completed) {
            return [entry]