effect 2.0.0-next.8 → 2.0.0

package/dist/cjs/internal/channel.js

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