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

package/internal/channel.esm.js

@@ -0,0 +1,648 @@
+import { failureOrCause, map as map$2, isInterrupted, die, isDieType } from '../Cause/dist/effect-Cause.esm.js';
+import { fromIterable, unsafeGet as unsafeGet$1, empty, isEmpty, unsafeFromArray } from '../Chunk/dist/effect-Chunk.esm.js';
+import { add, merge as merge$1, make as make$4, unsafeGet } from '../Context/dist/effect-Context.esm.js';
+import { await as _await, make as make$1, succeed as succeed$2, failCause as failCause$2, isDone } from '../Deferred/dist/effect-Deferred.esm.js';
+import { unit, flatMap as flatMap$1, uninterruptible, tap, context as context$1, map as map$1, suspend as suspend$1, matchCause, flatten as flatten$1, gen, acquireRelease, makeSemaphore, matchCauseEffect, failCause as failCause$1, zipRight as zipRight$1, interruptible, asUnit as asUnit$1, succeed as succeed$1, uninterruptibleMask, exit, raceFirst, tapErrorCause, intoDeferred, forkScoped, forever, raceWith, as as as$1, race, scoped as scoped$1, when, repeatWhile, zip as zip$1, zipWith, forkDaemon, never as never$1, sync as sync$1, withSpanScoped, repeatUntil, catchAllCause as catchAllCause$1 } from '../Effect/dist/effect-Effect.esm.js';
+import { match, left, right } from '../Either/dist/effect-Either.esm.js';
+import { equals } from '../Equal/dist/effect-Equal.esm.js';
+import { failCause as failCause$3, match as match$3, succeed as succeed$3, zip as zip$2 } from '../Exit/dist/effect-Exit.esm.js';
+import { interrupt, join, await as _await$1 } from '../Fiber/dist/effect-Fiber.esm.js';
+import { pipe, dual, constVoid, identity } from '../Function/dist/effect-Function.esm.js';
+import { subscribe } from '../Hub/dist/effect-Hub.esm.js';
+import { build, merge, context as context$2 } from '../Layer/dist/effect-Layer.esm.js';
+import { match as match$1, none, some, isSome } from '../Option/dist/effect-Option.esm.js';
+import { take, bounded, shutdown, offer, unbounded, size } from '../Queue/dist/effect-Queue.esm.js';
+import { make, get, set, update, modify } from '../Ref/dist/effect-Ref.esm.js';
+import { make as make$3, extend, close } from '../Scope/dist/effect-Scope.esm.js';
+import { runScoped, run as run$1, ChannelExecutor, readUpstream } from './channel/channelExecutor.esm.js';
+import { Done, Await } from './channel/mergeDecision.esm.js';
+import { BothRunning, RightDone, LeftDone } from './channel/mergeState.esm.js';
+import { match as match$2, BackPressure } from './channel/mergeStrategy.esm.js';
+import { make as make$2 } from './channel/singleProducerAsyncInput.esm.js';
+import { flatMap, fromEffect, ensuringWith, suspend, catchAllCause, failCause, concatMapWith, readWith, write, fail, succeedNow, pipeTo, concatAll, readWithCause, succeed, foldCauseChannel, sync, embedInput, provideContext, readOrFail, collectElements, acquireReleaseOut, concatAllWith, unit as unit$1, isChannel } from './core-stream.esm.js';
+import { OP_DONE as OP_DONE$1 } from './opCodes/channelMergeDecision.esm.js';
+import { OP_RIGHT_DONE, OP_LEFT_DONE, OP_BOTH_RUNNING } from './opCodes/channelMergeState.esm.js';
+import { OP_READ, OP_FROM_EFFECT, OP_EMIT, OP_DONE } from './opCodes/channelState.esm.js';
+
+/** @internal */
+const acquireUseRelease = (acquire, use, release) => flatMap(fromEffect(make(() => unit)), ref => pipe(fromEffect(uninterruptible(tap(acquire, a => set(ref, exit => release(a, exit))))), flatMap(use), ensuringWith(exit => flatMap$1(get(ref), f => f(exit)))));
+
+/** @internal */
+const as = /*#__PURE__*/dual(2, (self, value) => map(self, () => value));
+
+/** @internal */
+const asUnit = self => map(self, constVoid);
+
+/** @internal */
+const buffer = options => suspend(() => {
+  const doBuffer = (empty, isEmpty, ref) => unwrap(modify(ref, inElem => isEmpty(inElem) ? [readWith({
+    onInput: input => flatMap(write(input), () => doBuffer(empty, isEmpty, ref)),
+    onFailure: error => fail(error),
+    onDone: done => succeedNow(done)
+  }), inElem] : [flatMap(write(inElem), () => doBuffer(empty, isEmpty, ref)), empty]));
+  return doBuffer(options.empty, options.isEmpty, options.ref);
+});
+
+/** @internal */
+const bufferChunk = ref => buffer({
+  empty: empty(),
+  isEmpty: isEmpty,
+  ref
+});
+
+/** @internal */
+const catchAll = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => match(failureOrCause(cause), {
+  onLeft: f,
+  onRight: failCause
+})));
+
+/** @internal */
+const concatMap = /*#__PURE__*/dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
+
+/** @internal */
+const collect = /*#__PURE__*/dual(2, (self, pf) => {
+  const collector = readWith({
+    onInput: out => match$1(pf(out), {
+      onNone: () => collector,
+      onSome: out2 => flatMap(write(out2), () => collector)
+    }),
+    onFailure: fail,
+    onDone: succeedNow
+  });
+  return pipeTo(self, collector);
+});
+
+/** @internal */
+const concatOut = self => concatAll(self);
+
+/** @internal */
+const mapInput = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: inElem => flatMap(write(inElem), () => reader),
+    onFailure: fail,
+    onDone: done => succeedNow(f(done))
+  });
+  return pipeTo(reader, self);
+});
+
+/** @internal */
+const mapInputEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: inElem => flatMap(write(inElem), () => reader),
+    onFailure: fail,
+    onDone: done => fromEffect(f(done))
+  });
+  return pipeTo(reader, self);
+});
+
+/** @internal */
+const mapInputError = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: inElem => flatMap(write(inElem), () => reader),
+    onFailure: error => fail(f(error)),
+    onDone: succeedNow
+  });
+  return pipeTo(reader, self);
+});
+
+/** @internal */
+const mapInputErrorEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: inElem => flatMap(write(inElem), () => reader),
+    onFailure: error => fromEffect(f(error)),
+    onDone: succeedNow
+  });
+  return pipeTo(reader, self);
+});
+
+/** @internal */
+const mapInputIn = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: inElem => flatMap(write(f(inElem)), () => reader),
+    onFailure: fail,
+    onDone: succeedNow
+  });
+  return pipeTo(reader, self);
+});
+const mapInputInEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: inElem => flatMap(flatMap(fromEffect(f(inElem)), write), () => reader),
+    onFailure: fail,
+    onDone: succeedNow
+  });
+  return pipeTo(reader, self);
+});
+
+/** @internal */
+const doneCollect = self => suspend(() => {
+  const builder = [];
+  return pipe(pipeTo(self, doneCollectReader(builder)), flatMap(outDone => succeed([unsafeFromArray(builder), outDone])));
+});
+
+/** @internal */
+const doneCollectReader = builder => {
+  return readWith({
+    onInput: outElem => flatMap(sync(() => {
+      builder.push(outElem);
+    }), () => doneCollectReader(builder)),
+    onFailure: fail,
+    onDone: succeed
+  });
+};
+
+/** @internal */
+const drain = self => {
+  const drainer = readWithCause({
+    onInput: () => drainer,
+    onFailure: failCause,
+    onDone: succeed
+  });
+  return pipeTo(self, drainer);
+};
+
+/** @internal */
+const emitCollect = self => flatMap(doneCollect(self), write);
+
+/** @internal */
+const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => ensuringWith(self, () => finalizer));
+
+/** @internal */
+const context = () => fromEffect(context$1());
+
+/** @internal */
+const contextWith = f => map(context(), f);
+
+/** @internal */
+const contextWithChannel = f => flatMap(context(), f);
+
+/** @internal */
+const contextWithEffect = f => mapEffect(context(), f);
+
+/** @internal */
+const flatten = self => flatMap(self, identity);
+
+/** @internal */
+const foldChannel = /*#__PURE__*/dual(2, (self, options) => foldCauseChannel(self, {
+  onFailure: cause => {
+    const either = failureOrCause(cause);
+    switch (either._tag) {
+      case "Left":
+        {
+          return options.onFailure(either.left);
+        }
+      case "Right":
+        {
+          return failCause(either.right);
+        }
+    }
+  },
+  onSuccess: options.onSuccess
+}));
+
+/** @internal */
+const fromEither = either => suspend(() => match(either, {
+  onLeft: fail,
+  onRight: succeed
+}));
+
+/** @internal */
+const fromInput = input => unwrap(input.takeWith(failCause, elem => flatMap(write(elem), () => fromInput(input)), succeed));
+
+/** @internal */
+const fromHub = hub => unwrapScoped(map$1(subscribe(hub), fromQueue));
+
+/** @internal */
+const fromHubScoped = hub => map$1(subscribe(hub), fromQueue);
+
+/** @internal */
+const fromOption = option => suspend(() => match$1(option, {
+  onNone: () => fail(none()),
+  onSome: succeed
+}));
+
+/** @internal */
+const fromQueue = queue => suspend(() => fromQueueInternal(queue));
+
+/** @internal */
+const fromQueueInternal = queue => pipe(fromEffect(take(queue)), flatMap(match({
+  onLeft: match$3({
+    onFailure: failCause,
+    onSuccess: succeedNow
+  }),
+  onRight: elem => flatMap(write(elem), () => fromQueueInternal(queue))
+})));
+
+/** @internal */
+const identityChannel = () => readWith({
+  onInput: input => flatMap(write(input), () => identityChannel()),
+  onFailure: fail,
+  onDone: succeedNow
+});
+
+/** @internal */
+const interruptWhen = /*#__PURE__*/dual(2, (self, effect) => mergeWith(self, {
+  other: fromEffect(effect),
+  onSelfDone: selfDone => Done(suspend$1(() => selfDone)),
+  onOtherDone: effectDone => Done(suspend$1(() => effectDone))
+}));
+
+/** @internal */
+const interruptWhenDeferred = /*#__PURE__*/dual(2, (self, deferred) => interruptWhen(self, _await(deferred)));
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => sync(() => f(a))));
+
+/** @internal */
+const mapEffect = /*#__PURE__*/dual(2, (self, f) => flatMap(self, z => fromEffect(f(z))));
+
+/** @internal */
+const mapError = /*#__PURE__*/dual(2, (self, f) => mapErrorCause(self, map$2(f)));
+
+/** @internal */
+const mapErrorCause = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => failCause(f(cause))));
+
+/** @internal */
+const mapOut = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWith({
+    onInput: outElem => flatMap(write(f(outElem)), () => reader),
+    onFailure: fail,
+    onDone: succeedNow
+  });
+  return pipeTo(self, reader);
+});
+
+/** @internal */
+const mapOutEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const reader = readWithCause({
+    onInput: outElem => pipe(fromEffect(f(outElem)), flatMap(write), flatMap(() => reader)),
+    onFailure: failCause,
+    onDone: succeedNow
+  });
+  return pipeTo(self, reader);
+});
+
+/** @internal */
+const mapOutEffectPar = /*#__PURE__*/dual(3, (self, f, n) => pipe(gen(function* ($) {
+  const queue = yield* $(acquireRelease(bounded(n), queue => shutdown(queue)));
+  const errorSignal = yield* $(make$1());
+  const withPermits = n === Number.POSITIVE_INFINITY ? _ => identity : (yield* $(makeSemaphore(n))).withPermits;
+  const pull = yield* $(toPull(self));
+  yield* $(matchCauseEffect(pull, {
+    onFailure: cause => offer(queue, failCause$1(cause)),
+    onSuccess: either => match(either, {
+      onLeft: outDone => {
+        const lock = withPermits(n);
+        return zipRight$1(interruptible(lock(unit)), asUnit$1(offer(queue, succeed$1(left(outDone)))));
+      },
+      onRight: outElem => gen(function* ($) {
+        const deferred = yield* $(make$1());
+        const latch = yield* $(make$1());
+        yield* $(asUnit$1(offer(queue, map$1(_await(deferred), right))));
+        yield* $(succeed$2(latch, void 0), zipRight$1(pipe(uninterruptibleMask(restore => pipe(exit(restore(_await(errorSignal))), raceFirst(exit(restore(f(outElem)))),
+        // TODO: remove
+        flatMap$1(exit => suspend$1(() => exit)))), tapErrorCause(cause => failCause$2(errorSignal, cause)), intoDeferred(deferred))), withPermits(1), forkScoped);
+        yield* $(_await(latch));
+      })
+    })
+  }), forever, interruptible, forkScoped);
+  return queue;
+}), map$1(queue => {
+  const consumer = unwrap(matchCause(flatten$1(take(queue)), {
+    onFailure: failCause,
+    onSuccess: match({
+      onLeft: succeedNow,
+      onRight: outElem => flatMap(write(outElem), () => consumer)
+    })
+  }));
+  return consumer;
+}), unwrapScoped));
+
+/** @internal */
+const mergeAll = options => {
+  return channels => mergeAllWith(options)(channels, constVoid);
+};
+
+/** @internal */
+const mergeAllUnbounded = channels => mergeAllWith({
+  concurrency: "unbounded"
+})(channels, constVoid);
+
+/** @internal */
+const mergeAllUnboundedWith = (channels, f) => mergeAllWith({
+  concurrency: "unbounded"
+})(channels, f);
+
+/** @internal */
+const mergeAllWith = ({
+  bufferSize = 16,
+  concurrency,
+  mergeStrategy = BackPressure()
+}) => (channels, f) => pipe(gen(function* ($) {
+  const input = yield* $(make$2());
+  const queueReader = fromInput(input);
+  const queue = yield* $(acquireRelease(bounded(bufferSize), queue => shutdown(queue)));
+  const cancelers = yield* $(acquireRelease(unbounded(), queue => shutdown(queue)));
+  const lastDone = yield* $(make(none()));
+  const errorSignal = yield* $(make$1());
+  const withPermits = concurrency === "unbounded" ? _ => identity : (yield* $(makeSemaphore(concurrency))).withPermits;
+  const pull = yield* $(toPull(channels));
+  const evaluatePull = pull => pipe(flatMap$1(pull, match({
+    onLeft: done => succeed$1(some(done)),
+    onRight: outElem => as$1(offer(queue, succeed$1(right(outElem))), none())
+  })), repeatUntil(isSome), flatMap$1(match$1({
+    onNone: () => unit,
+    onSome: outDone => update(lastDone, match$1({
+      onNone: () => some(outDone),
+      onSome: lastDone => some(f(lastDone, outDone))
+    }))
+  })), catchAllCause$1(cause => isInterrupted(cause) ? failCause$1(cause) : pipe(offer(queue, failCause$1(cause)), zipRight$1(succeed$2(errorSignal, void 0)), asUnit$1)));
+  yield* $(matchCauseEffect(pull, {
+    onFailure: cause => pipe(offer(queue, failCause$1(cause)), zipRight$1(succeed$1(false))),
+    onSuccess: match({
+      onLeft: outDone => raceWith(_await(errorSignal), withPermits(concurrency)(unit), {
+        onSelfDone: (_, permitAcquisition) => pipe(interrupt(permitAcquisition), as$1(false)),
+        onOtherDone: (_, failureAwait) => pipe(interrupt(failureAwait), zipRight$1(pipe(get(lastDone), flatMap$1(match$1({
+          onNone: () => offer(queue, succeed$1(left(outDone))),
+          onSome: lastDone => offer(queue, succeed$1(left(f(lastDone, outDone))))
+        })), as$1(false))))
+      }),
+      onRight: channel => pipe(mergeStrategy, match$2({
+        onBackPressure: () => gen(function* ($) {
+          const latch = yield* $(make$1());
+          const raceEffects = pipe(queueReader, pipeTo(channel), toPull, flatMap$1(pull => pipe(evaluatePull(pull), race(_await(errorSignal)))), scoped$1);
+          yield* $(succeed$2(latch, void 0), zipRight$1(raceEffects), withPermits(1), forkScoped);
+          yield* $(_await(latch));
+          const errored = yield* $(isDone(errorSignal));
+          return !errored;
+        }),
+        onBufferSliding: () => gen(function* ($) {
+          const canceler = yield* $(make$1());
+          const latch = yield* $(make$1());
+          const size$1 = yield* $(size(cancelers));
+          yield* $(take(cancelers), flatMap$1(_ => succeed$2(_, void 0)), when(() => concurrency === "unbounded" ? false : size$1 >= concurrency));
+          yield* $(offer(cancelers, canceler));
+          const raceEffects = pipe(queueReader, pipeTo(channel), toPull, flatMap$1(pull => pipe(evaluatePull(pull), race(_await(errorSignal)), race(_await(canceler)))), scoped$1);
+          yield* $(succeed$2(latch, void 0), zipRight$1(raceEffects), withPermits(1), forkScoped);
+          yield* $(_await(latch));
+          const errored = yield* $(isDone(errorSignal));
+          return !errored;
+        })
+      }))
+    })
+  }), repeatWhile(identity), forkScoped);
+  return [queue, input];
+}), map$1(([queue, input]) => {
+  const consumer = pipe(take(queue), flatten$1, matchCause({
+    onFailure: failCause,
+    onSuccess: match({
+      onLeft: succeedNow,
+      onRight: outElem => flatMap(write(outElem), () => consumer)
+    })
+  }), unwrap);
+  return embedInput(consumer, input);
+}), unwrapScoped);
+
+/** @internal */
+const mergeMap = /*#__PURE__*/dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
+
+/** @internal */
+const mergeOut = /*#__PURE__*/dual(2, (self, n) => mergeAll({
+  concurrency: n
+})(mapOut(self, identity)));
+
+/** @internal */
+const mergeOutWith = /*#__PURE__*/dual(3, (self, n, f) => mergeAllWith({
+  concurrency: n
+})(mapOut(self, identity), f));
+
+/** @internal */
+const mergeWith = /*#__PURE__*/dual(2, (self, options) => unwrapScoped(flatMap$1(make$2(), input => {
+  const queueReader = fromInput(input);
+  return map$1(zip$1(toPull(pipeTo(queueReader, self)), toPull(pipeTo(queueReader, options.other))), ([pullL, pullR]) => {
+    const handleSide = (exit, fiber, pull) => (done, both, single) => {
+      const onDecision = decision => {
+        const op = decision;
+        if (op._tag === OP_DONE$1) {
+          return succeed$1(fromEffect(zipRight$1(interrupt(fiber), op.effect)));
+        }
+        return map$1(_await$1(fiber), match$3({
+          onFailure: cause => fromEffect(op.f(failCause$3(cause))),
+          onSuccess: match({
+            onLeft: done => fromEffect(op.f(succeed$3(done))),
+            onRight: elem => zipRight(write(elem), go(single(op.f)))
+          })
+        }));
+      };
+      return match$3(exit, {
+        onFailure: cause => onDecision(done(failCause$3(cause))),
+        onSuccess: match({
+          onLeft: z => onDecision(done(succeed$3(z))),
+          onRight: elem => succeed$1(flatMap(write(elem), () => flatMap(fromEffect(forkDaemon(pull)), leftFiber => go(both(leftFiber, fiber)))))
+        })
+      });
+    };
+    const go = state => {
+      switch (state._tag) {
+        case OP_BOTH_RUNNING:
+          {
+            const leftJoin = interruptible(join(state.left));
+            const rightJoin = interruptible(join(state.right));
+            return unwrap(raceWith(leftJoin, rightJoin, {
+              onSelfDone: (leftExit, rf) => zipRight$1(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
+              onOtherDone: (rightExit, lf) => zipRight$1(interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), f => RightDone(f)))
+            }));
+          }
+        case OP_LEFT_DONE:
+          {
+            return unwrap(map$1(exit(pullR), match$3({
+              onFailure: cause => fromEffect(state.f(failCause$3(cause))),
+              onSuccess: match({
+                onLeft: done => fromEffect(state.f(succeed$3(done))),
+                onRight: elem => flatMap(write(elem), () => go(LeftDone(state.f)))
+              })
+            })));
+          }
+        case OP_RIGHT_DONE:
+          {
+            return unwrap(map$1(exit(pullL), match$3({
+              onFailure: cause => fromEffect(state.f(failCause$3(cause))),
+              onSuccess: match({
+                onLeft: done => fromEffect(state.f(succeed$3(done))),
+                onRight: elem => flatMap(write(elem), () => go(RightDone(state.f)))
+              })
+            })));
+          }
+      }
+    };
+    return pipe(fromEffect(zipWith(forkDaemon(pullL), forkDaemon(pullR), (left, right) => BothRunning(left, right))), flatMap(go), embedInput(input));
+  });
+})));
+
+/** @internal */
+const never = /*#__PURE__*/fromEffect(never$1);
+
+/** @internal */
+const orDie = /*#__PURE__*/dual(2, (self, error) => orDieWith(self, error));
+
+/** @internal */
+const orDieWith = /*#__PURE__*/dual(2, (self, f) => catchAll(self, e => {
+  throw f(e);
+}));
+
+/** @internal */
+const orElse = /*#__PURE__*/dual(2, (self, that) => catchAll(self, that));
+
+/** @internal */
+const pipeToOrFail = /*#__PURE__*/dual(2, (self, that) => suspend(() => {
+  let channelException = undefined;
+  const reader = readWith({
+    onInput: outElem => flatMap(write(outElem), () => reader),
+    onFailure: outErr => {
+      channelException = ChannelException(outErr);
+      return failCause(die(channelException));
+    },
+    onDone: succeedNow
+  });
+  const writer = readWithCause({
+    onInput: outElem => pipe(write(outElem), flatMap(() => writer)),
+    onFailure: cause => isDieType(cause) && isChannelException(cause.defect) && equals(cause.defect, channelException) ? fail(cause.defect.error) : failCause(cause),
+    onDone: succeedNow
+  });
+  return pipeTo(pipeTo(pipeTo(self, reader), that), writer);
+}));
+
+/** @internal */
+const provideService = /*#__PURE__*/dual(3, (self, tag, service) => {
+  return flatMap(context(), context => provideContext(self, add(context, tag, service)));
+});
+
+/** @internal */
+const provideLayer = /*#__PURE__*/dual(2, (self, layer) => unwrapScoped(map$1(build(layer), env => provideContext(self, env))));
+
+/** @internal */
+const mapInputContext = /*#__PURE__*/dual(2, (self, f) => contextWithChannel(context => provideContext(self, f(context))));
+
+/** @internal */
+const provideSomeLayer = /*#__PURE__*/dual(2, (self, layer) =>
+// @ts-expect-error
+provideLayer(self, merge(context$2(), layer)));
+
+/** @internal */
+const read = () => readOrFail(none());
+
+/** @internal */
+const repeated = self => flatMap(self, () => repeated(self));
+
+/** @internal */
+const run = self => scoped$1(runScoped(self));
+
+/** @internal */
+const runCollect = self => run$1(collectElements(self));
+
+/** @internal */
+const runDrain = self => run$1(drain(self));
+
+/** @internal */
+const scoped = effect => unwrap(uninterruptibleMask(restore => map$1(make$3(), scope => acquireReleaseOut(tapErrorCause(restore(extend(scope)(effect)), cause => close(scope, failCause$3(cause))), (_, exit) => close(scope, exit)))));
+
+/** @internal */
+const toHub = hub => toQueue(hub);
+
+/** @internal */
+const toPull = self => map$1(acquireRelease(sync$1(() => new ChannelExecutor(self, void 0, identity)), (exec, exit) => {
+  const finalize = exec.close(exit);
+  return finalize === undefined ? unit : finalize;
+}), exec => suspend$1(() => interpretToPull(exec.run(), exec)));
+
+/** @internal */
+const interpretToPull = (channelState, exec) => {
+  const state = channelState;
+  switch (state._tag) {
+    case OP_DONE:
+      {
+        return match$3(exec.getDone(), {
+          onFailure: failCause$1,
+          onSuccess: done => succeed$1(left(done))
+        });
+      }
+    case OP_EMIT:
+      {
+        return succeed$1(right(exec.getEmit()));
+      }
+    case OP_FROM_EFFECT:
+      {
+        return pipe(state.effect, flatMap$1(() => interpretToPull(exec.run(), exec)));
+      }
+    case OP_READ:
+      {
+        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => failCause$1(cause));
+      }
+  }
+};
+
+/** @internal */
+const toQueue = queue => suspend(() => toQueueInternal(queue));
+
+/** @internal */
+const toQueueInternal = queue => {
+  return readWithCause({
+    onInput: elem => flatMap(fromEffect(offer(queue, right(elem))), () => toQueueInternal(queue)),
+    onFailure: cause => fromEffect(pipe(offer(queue, left(failCause$3(cause))))),
+    onDone: done => fromEffect(pipe(offer(queue, left(succeed$3(done)))))
+  });
+};
+
+/** @internal */
+const unwrap = channel => flatten(fromEffect(channel));
+
+/** @internal */
+const unwrapScoped = self => concatAllWith(scoped(self), (d, _) => d, (d, _) => d);
+
+/** @internal */
+const updateService = /*#__PURE__*/dual(3, (self, tag, f) => mapInputContext(self, context => merge$1(context, make$4(tag, f(unsafeGet(context, tag))))));
+
+/** @internal */
+const withSpan = /*#__PURE__*/dual(3, (self, name, options) => unwrapScoped(as$1(withSpanScoped(name, options), self)));
+
+/** @internal */
+const writeAll = (...outs) => writeChunk(fromIterable(outs));
+
+/** @internal */
+const writeChunk = outs => writeChunkWriter(0, outs.length, outs);
+
+/** @internal */
+const writeChunkWriter = (idx, len, chunk) => {
+  return idx === len ? unit$1 : pipe(write(pipe(chunk, unsafeGet$1(idx))), flatMap(() => writeChunkWriter(idx + 1, len, chunk)));
+};
+
+/** @internal */
+const zip = /*#__PURE__*/dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith(self, {
+  other: that,
+  onSelfDone: exit1 => Await(exit2 => suspend$1(() => zip$2(exit1, exit2))),
+  onOtherDone: exit2 => Await(exit1 => suspend$1(() => zip$2(exit1, exit2)))
+}) : flatMap(self, a => map(that, b => [a, b])));
+
+/** @internal */
+const zipLeft = /*#__PURE__*/dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? map(zip(self, that, {
+  concurrent: true
+}), tuple => tuple[0]) : flatMap(self, z => as(that, z)));
+
+/** @internal */
+const zipRight = /*#__PURE__*/dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? map(zip(self, that, {
+  concurrent: true
+}), tuple => tuple[1]) : flatMap(self, () => that));
+
+/** @internal */
+const ChannelExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Channel/ChannelException");
+
+/** @internal */
+const ChannelException = error => ({
+  _tag: "ChannelException",
+  [ChannelExceptionTypeId]: ChannelExceptionTypeId,
+  error
+});
+
+/** @internal */
+const isChannelException = u => typeof u === "object" && u != null && ChannelExceptionTypeId in u;
+
+export { ChannelException, ChannelExceptionTypeId, acquireUseRelease, as, asUnit, buffer, bufferChunk, catchAll, collect, concatMap, concatOut, context, contextWith, contextWithChannel, contextWithEffect, doneCollect, drain, emitCollect, ensuring, flatten, foldChannel, fromEither, fromHub, fromHubScoped, fromInput, fromOption, fromQueue, identityChannel, interruptWhen, interruptWhenDeferred, isChannelException, map, mapEffect, mapError, mapErrorCause, mapInput, mapInputContext, mapInputEffect, mapInputError, mapInputErrorEffect, mapInputIn, mapInputInEffect, mapOut, mapOutEffect, mapOutEffectPar, mergeAll, mergeAllUnbounded, mergeAllUnboundedWith, mergeAllWith, mergeMap, mergeOut, mergeOutWith, mergeWith, never, orDie, orDieWith, orElse, pipeToOrFail, provideLayer, provideService, provideSomeLayer, read, repeated, run, runCollect, runDrain, scoped, toHub, toPull, toQueue, unwrap, unwrapScoped, updateService, withSpan, writeAll, writeChunk, zip, zipLeft, zipRight };