effect 3.10.19 → 3.11.0

package/dist/esm/internal/stream.js

@@ -30,7 +30,6 @@ import * as Tuple from "../Tuple.js";
 import * as channel from "./channel.js";
 import * as channelExecutor from "./channel/channelExecutor.js";
 import * as MergeStrategy from "./channel/mergeStrategy.js";
-import * as singleProducerAsyncInput from "./channel/singleProducerAsyncInput.js";
 import * as core from "./core-stream.js";
 import * as doNotation from "./doNotation.js";
 import { RingBuffer } from "./ringBuffer.js";
@@ -97,7 +96,7 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fi
 /** @internal */
 export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule) => {
   const layer = Effect.all([Handoff.make(), Ref.make(SinkEndReason.ScheduleEnd), Ref.make(Chunk.empty()), Schedule.driver(schedule), Ref.make(false), Ref.make(false)]);
-  return pipe(fromEffect(layer), flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed, endAfterEmit]) => {
+  return fromEffect(layer).pipe(flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed, endAfterEmit]) => {
     const handoffProducer = core.readWithCause({
       onInput: input => core.flatMap(core.fromEffect(pipe(handoff, Handoff.offer(HandoffSignal.emit(input)), Effect.when(() => Chunk.isNonEmpty(input)))), () => handoffProducer),
       onFailure: cause => core.fromEffect(Handoff.offer(handoff, HandoffSignal.halt(cause))),
@@ -129,7 +128,7 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
     }), channel.unwrap);
     const timeout = lastB => scheduleDriver.next(lastB);
     const scheduledAggregator = (sinkFiber, scheduleFiber, scope) => {
-      const forkSink = pipe(Ref.set(consumed, false), Effect.zipRight(Ref.set(endAfterEmit, false)), Effect.zipRight(pipe(handoffConsumer, channel.pipeToOrFail(_sink.toChannel(sink)), core.collectElements, channelExecutor.run, Effect.forkIn(scope))));
+      const forkSink = pipe(Ref.set(consumed, false), Effect.zipRight(Ref.set(endAfterEmit, false)), Effect.zipRight(pipe(handoffConsumer, channel.pipeToOrFail(_sink.toChannel(sink)), core.collectElements, channel.run, Effect.forkIn(scope))));
       const handleSide = (leftovers, b, c) => pipe(Ref.set(sinkLeftovers, Chunk.flatten(leftovers)), Effect.zipRight(Effect.map(Ref.get(sinkEndReason), reason => {
         switch (reason._tag) {
           case SinkEndReason.OP_SCHEDULE_END:
@@ -162,7 +161,7 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
         })
       }));
     };
-    return unwrapScoped(pipe(self, toChannel, core.pipeTo(handoffProducer), channelExecutor.run, Effect.forkScoped, Effect.zipRight(pipe(handoffConsumer, channel.pipeToOrFail(_sink.toChannel(sink)), core.collectElements, channelExecutor.run, Effect.forkScoped, Effect.flatMap(sinkFiber => pipe(Effect.forkScoped(timeout(Option.none())), Effect.flatMap(scheduleFiber => pipe(Effect.scope, Effect.map(scope => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))))));
+    return unwrapScopedWith(scope => core.pipeTo(toChannel(self), handoffProducer).pipe(channel.run, Effect.forkIn(scope), Effect.zipRight(channel.pipeToOrFail(handoffConsumer, _sink.toChannel(sink)).pipe(core.collectElements, channel.run, Effect.forkIn(scope), Effect.flatMap(sinkFiber => timeout(Option.none()).pipe(Effect.forkIn(scope), Effect.map(scheduleFiber => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))));
   }));
 });
 /** @internal */
@@ -361,7 +360,7 @@ const bufferSignal = (scoped, bufferChannel) => {
     }))));
     return process;
   };
-  return channel.unwrapScoped(pipe(scoped, Effect.flatMap(queue => pipe(Deferred.make(), Effect.tap(start => Deferred.succeed(start, void 0)), Effect.flatMap(start => pipe(Ref.make(start), Effect.flatMap(ref => pipe(bufferChannel, core.pipeTo(producer(queue, ref)), channelExecutor.runScoped, Effect.forkScoped)), Effect.as(consumer(queue))))))));
+  return channel.unwrapScoped(pipe(scoped, Effect.flatMap(queue => pipe(Deferred.make(), Effect.tap(start => Deferred.succeed(start, void 0)), Effect.flatMap(start => pipe(Ref.make(start), Effect.flatMap(ref => pipe(bufferChannel, core.pipeTo(producer(queue, ref)), channel.runScoped, Effect.forkScoped)), Effect.as(consumer(queue))))))));
 };
 /** @internal */
 export const catchAll = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => Either.match(Cause.failureOrCause(cause), {
@@ -429,26 +428,18 @@ export const chunksWith = /*#__PURE__*/dual(2, (self, f) => flattenChunks(f(chun
 const unsome = effect => Effect.catchAll(Effect.asSome(effect), o => o._tag === "None" ? Effect.succeedNone : Effect.fail(o.value));
 /** @internal */
 export const combine = /*#__PURE__*/dual(4, (self, that, s, f) => {
-  const producer = (handoff, latch) => pipe(core.fromEffect(Handoff.take(latch)), channel.zipRight(core.readWithCause({
-    onInput: input => core.flatMap(core.fromEffect(pipe(handoff, Handoff.offer(Exit.succeed(input)))), () => producer(handoff, latch)),
-    onFailure: cause => core.fromEffect(Handoff.offer(handoff, Exit.failCause(pipe(cause, Cause.map(Option.some))))),
-    onDone: () => core.flatMap(core.fromEffect(Handoff.offer(handoff, Exit.fail(Option.none()))), () => producer(handoff, latch))
-  })));
-  return new StreamImpl(channel.unwrapScoped(Effect.gen(function* ($) {
-    const left = yield* $(Handoff.make());
-    const right = yield* $(Handoff.make());
-    const latchL = yield* $(Handoff.make());
-    const latchR = yield* $(Handoff.make());
-    yield* $(toChannel(self), channel.concatMap(channel.writeChunk), core.pipeTo(producer(left, latchL)), channelExecutor.runScoped, Effect.forkScoped);
-    yield* $(toChannel(that), channel.concatMap(channel.writeChunk), core.pipeTo(producer(right, latchR)), channelExecutor.runScoped, Effect.forkScoped);
-    const pullLeft = pipe(latchL, Handoff.offer(void 0),
-    // TODO: remove
-    Effect.zipRight(pipe(Handoff.take(left), Effect.flatMap(exit => Effect.suspend(() => exit)))));
-    const pullRight = pipe(latchR, Handoff.offer(void 0),
-    // TODO: remove
-    Effect.zipRight(pipe(Handoff.take(right), Effect.flatMap(exit => Effect.suspend(() => exit)))));
+  function producer(handoff, latch) {
+    return core.fromEffect(Handoff.take(latch)).pipe(channel.zipRight(core.readWithCause({
+      onInput: input => core.flatMap(core.fromEffect(Handoff.offer(handoff, Exit.succeed(input))), () => producer(handoff, latch)),
+      onFailure: cause => core.fromEffect(Handoff.offer(handoff, Exit.failCause(pipe(cause, Cause.map(Option.some))))),
+      onDone: () => core.flatMap(core.fromEffect(Handoff.offer(handoff, Exit.fail(Option.none()))), () => producer(handoff, latch))
+    })));
+  }
+  return new StreamImpl(channel.unwrapScopedWith(scope => Effect.all([Handoff.make(), Handoff.make(), Handoff.make(), Handoff.make()]).pipe(Effect.tap(([left, _, latchL]) => toChannel(self).pipe(channel.concatMap(channel.writeChunk), core.pipeTo(producer(left, latchL)), channelExecutor.runIn(scope), Effect.forkIn(scope))), Effect.tap(([, right, _, rightL]) => toChannel(that).pipe(channel.concatMap(channel.writeChunk), core.pipeTo(producer(right, rightL)), channelExecutor.runIn(scope), Effect.forkIn(scope))), Effect.map(([left, right, latchL, latchR]) => {
+    const pullLeft = Handoff.offer(latchL, void 0).pipe(Effect.zipRight(Handoff.take(left).pipe(Effect.flatMap(identity))));
+    const pullRight = Handoff.offer(latchR, void 0).pipe(Effect.zipRight(Handoff.take(right).pipe(Effect.flatMap(identity))));
     return toChannel(unfoldEffect(s, s => Effect.flatMap(f(s, pullLeft, pullRight), unsome)));
-  })));
+  }))));
 });
 /** @internal */
 export const combineChunks = /*#__PURE__*/dual(4, (self, that, s, f) => {
@@ -457,11 +448,11 @@ export const combineChunks = /*#__PURE__*/dual(4, (self, that, s, f) => {
     onFailure: cause => core.fromEffect(Handoff.offer(handoff, InternalTake.failCause(cause))),
     onDone: () => core.fromEffect(Handoff.offer(handoff, InternalTake.end))
   }));
-  return new StreamImpl(pipe(Effect.all([Handoff.make(), Handoff.make(), Handoff.make(), Handoff.make()]), Effect.tap(([left, _, latchL]) => pipe(toChannel(self), core.pipeTo(producer(left, latchL)), channelExecutor.runScoped, Effect.forkScoped)), Effect.tap(([_, right, __, latchR]) => pipe(toChannel(that), core.pipeTo(producer(right, latchR)), channelExecutor.runScoped, Effect.forkScoped)), Effect.map(([left, right, latchL, latchR]) => {
-    const pullLeft = pipe(latchL, Handoff.offer(void 0), Effect.zipRight(pipe(Handoff.take(left), Effect.flatMap(InternalTake.done))));
-    const pullRight = pipe(latchR, Handoff.offer(void 0), Effect.zipRight(pipe(Handoff.take(right), Effect.flatMap(InternalTake.done))));
+  return new StreamImpl(channel.unwrapScopedWith(scope => Effect.all([Handoff.make(), Handoff.make(), Handoff.make(), Handoff.make()]).pipe(Effect.tap(([left, _, latchL]) => core.pipeTo(toChannel(self), producer(left, latchL)).pipe(channelExecutor.runIn(scope), Effect.forkIn(scope))), Effect.tap(([_, right, __, latchR]) => core.pipeTo(toChannel(that), producer(right, latchR)).pipe(channelExecutor.runIn(scope), Effect.forkIn(scope))), Effect.map(([left, right, latchL, latchR]) => {
+    const pullLeft = Handoff.offer(latchL, void 0).pipe(Effect.zipRight(Handoff.take(left).pipe(Effect.flatMap(InternalTake.done))));
+    const pullRight = Handoff.offer(latchR, void 0).pipe(Effect.zipRight(Handoff.take(right).pipe(Effect.flatMap(InternalTake.done))));
     return toChannel(unfoldChunkEffect(s, s => Effect.flatMap(f(s, pullLeft, pullRight), unsome)));
-  }), channel.unwrapScoped));
+  }))));
 });
 /** @internal */
 export const concat = /*#__PURE__*/dual(2, (self, that) => new StreamImpl(pipe(toChannel(self), channel.zipRight(toChannel(that)))));
@@ -476,21 +467,24 @@ export const crossRight = /*#__PURE__*/dual(2, (left, right) => flatMap(left, ()
 /** @internal */
 export const crossWith = /*#__PURE__*/dual(3, (left, right, f) => pipe(left, flatMap(a => pipe(right, map(b => f(a, b))))));
 /** @internal */
-export const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(singleProducerAsyncInput.make(), Effect.flatMap(input => Effect.transplant(grafter => pipe(Handoff.make(), Effect.map(handoff => {
-  const enqueue = last => pipe(Clock.sleep(duration), Effect.as(last), Effect.fork, grafter, Effect.map(fiber => consumer(DebounceState.previous(fiber))));
+export const debounce = /*#__PURE__*/dual(2, (self, duration) => unwrapScopedWith(scope => Effect.gen(function* () {
+  const handoff = yield* Handoff.make();
+  function enqueue(last) {
+    return Clock.sleep(duration).pipe(Effect.as(last), Effect.forkIn(scope), Effect.map(fiber => consumer(DebounceState.previous(fiber))));
+  }
   const producer = core.readWithCause({
     onInput: input => Option.match(Chunk.last(input), {
       onNone: () => producer,
-      onSome: last => core.flatMap(core.fromEffect(Handoff.offer(handoff, HandoffSignal.emit(Chunk.of(last)))), () => producer)
+      onSome: elem => core.fromEffect(Handoff.offer(handoff, HandoffSignal.emit(Chunk.of(elem)))).pipe(core.flatMap(() => producer))
     }),
     onFailure: cause => core.fromEffect(Handoff.offer(handoff, HandoffSignal.halt(cause))),
     onDone: () => core.fromEffect(Handoff.offer(handoff, HandoffSignal.end(SinkEndReason.UpstreamEnd)))
   });
-  const consumer = state => {
+  function consumer(state) {
     switch (state._tag) {
       case DebounceState.OP_NOT_STARTED:
         {
-          return pipe(Handoff.take(handoff), Effect.map(signal => {
+          return channel.unwrap(Handoff.take(handoff).pipe(Effect.map(signal => {
             switch (signal._tag) {
               case HandoffSignal.OP_EMIT:
                 {
@@ -505,39 +499,39 @@ export const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(singleProd
                   return core.void;
                 }
             }
-          }), channel.unwrap);
+          })));
         }
       case DebounceState.OP_PREVIOUS:
         {
-          return channel.unwrap(Effect.raceWith(Fiber.join(state.fiber), Handoff.take(handoff), {
+          return channel.unwrap(Handoff.take(handoff).pipe(Effect.forkIn(scope), Effect.flatMap(handoffFiber => Effect.raceWith(Fiber.join(state.fiber), Fiber.join(handoffFiber), {
             onSelfDone: (leftExit, current) => Exit.match(leftExit, {
-              onFailure: cause => pipe(Fiber.interrupt(current), Effect.as(core.failCause(cause))),
-              onSuccess: chunk => Effect.succeed(pipe(core.write(chunk), core.flatMap(() => consumer(DebounceState.current(current)))))
+              onFailure: cause => Fiber.interrupt(current).pipe(Effect.as(core.failCause(cause))),
+              onSuccess: chunk => Fiber.interrupt(current).pipe(Effect.zipRight(Effect.succeed(core.write(chunk).pipe(core.flatMap(() => consumer(DebounceState.current(handoffFiber)))))))
             }),
             onOtherDone: (rightExit, previous) => Exit.match(rightExit, {
-              onFailure: cause => pipe(Fiber.interrupt(previous), Effect.as(core.failCause(cause))),
+              onFailure: cause => Fiber.interrupt(previous).pipe(Effect.as(core.failCause(cause))),
               onSuccess: signal => {
                 switch (signal._tag) {
                   case HandoffSignal.OP_EMIT:
                     {
-                      return pipe(Fiber.interrupt(previous), Effect.zipRight(enqueue(signal.elements)));
+                      return Fiber.interrupt(previous).pipe(Effect.zipRight(enqueue(signal.elements)));
                     }
                   case HandoffSignal.OP_HALT:
                     {
-                      return pipe(Fiber.interrupt(previous), Effect.as(core.failCause(signal.cause)));
+                      return Fiber.interrupt(previous).pipe(Effect.as(core.failCause(signal.cause)));
                     }
                   case HandoffSignal.OP_END:
                     {
-                      return pipe(Fiber.join(previous), Effect.map(chunk => pipe(core.write(chunk), channel.zipRight(core.void))));
+                      return Fiber.join(previous).pipe(Effect.map(chunk => core.write(chunk).pipe(channel.zipRight(core.void))));
                     }
                 }
               }
             })
-          }));
+          }))));
         }
       case DebounceState.OP_CURRENT:
         {
-          return pipe(Fiber.join(state.fiber), Effect.map(signal => {
+          return channel.unwrap(Fiber.join(state.fiber).pipe(Effect.map(signal => {
             switch (signal._tag) {
               case HandoffSignal.OP_EMIT:
                 {
@@ -552,13 +546,12 @@ export const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(singleProd
                   return core.void;
                 }
             }
-          }), channel.unwrap);
+          })));
         }
     }
-  };
-  const debounceChannel = pipe(channel.fromInput(input), core.pipeTo(producer), channelExecutor.run, Effect.forkScoped, Effect.as(pipe(consumer(DebounceState.notStarted), core.embedInput(input))), channel.unwrapScoped);
-  return new StreamImpl(pipe(toChannel(self), core.pipeTo(debounceChannel)));
-})))), unwrap));
+  }
+  return scopedWith(scope => core.pipeTo(toChannel(self), producer).pipe(channelExecutor.runIn(scope), Effect.forkIn(scope))).pipe(crossRight(new StreamImpl(consumer(DebounceState.notStarted))));
+})));
 /** @internal */
 export const die = defect => fromEffect(Effect.die(defect));
 /** @internal */
@@ -630,7 +623,7 @@ export const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximu
 /** @internal */
 export const drain = self => new StreamImpl(channel.drain(toChannel(self)));
 /** @internal */
-export const drainFork = /*#__PURE__*/dual(2, (self, that) => pipe(fromEffect(Deferred.make()), flatMap(backgroundDied => pipe(scoped(pipe(that, runForEachScoped(() => Effect.void), Effect.catchAllCause(cause => Deferred.failCause(backgroundDied, cause)), Effect.forkScoped)), crossRight(pipe(self, interruptWhenDeferred(backgroundDied)))))));
+export const drainFork = /*#__PURE__*/dual(2, (self, that) => fromEffect(Deferred.make()).pipe(flatMap(backgroundDied => scopedWith(scope => toChannel(that).pipe(channel.drain, channelExecutor.runIn(scope), Effect.catchAllCause(cause => Deferred.failCause(backgroundDied, cause)), Effect.forkIn(scope))).pipe(crossRight(interruptWhenDeferred(self, backgroundDied))))));
 /** @internal */
 export const drop = /*#__PURE__*/dual(2, (self, n) => {
   const loop = r => core.readWith({
@@ -1143,7 +1136,7 @@ export const haltWhen = /*#__PURE__*/dual(2, (self, effect) => {
       onSuccess: () => core.void
     })
   })), channel.unwrap);
-  return new StreamImpl(pipe(Effect.forkScoped(effect), Effect.map(fiber => pipe(toChannel(self), core.pipeTo(writer(fiber)))), channel.unwrapScoped));
+  return new StreamImpl(channel.unwrapScopedWith(scope => effect.pipe(Effect.forkIn(scope), Effect.map(fiber => toChannel(self).pipe(core.pipeTo(writer(fiber)))))));
 });
 /** @internal */
 export const haltAfter = /*#__PURE__*/dual(2, (self, duration) => pipe(self, haltWhen(Clock.sleep(duration))));
@@ -1173,7 +1166,7 @@ export const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => {
     onFailure: cause => core.fromEffect(Handoff.offer(handoff, InternalTake.failCause(cause))),
     onDone: () => core.fromEffect(Handoff.offer(handoff, InternalTake.end))
   });
-  return new StreamImpl(channel.unwrapScoped(pipe(Handoff.make(), Effect.zip(Handoff.make()), Effect.tap(([left]) => pipe(toChannel(self), channel.concatMap(channel.writeChunk), core.pipeTo(producer(left)), channelExecutor.runScoped, Effect.forkScoped)), Effect.tap(([_, right]) => pipe(toChannel(that), channel.concatMap(channel.writeChunk), core.pipeTo(producer(right)), channelExecutor.runScoped, Effect.forkScoped)), Effect.map(([left, right]) => {
+  return new StreamImpl(channel.unwrapScopedWith(scope => pipe(Handoff.make(), Effect.zip(Handoff.make()), Effect.tap(([left]) => toChannel(self).pipe(channel.concatMap(channel.writeChunk), core.pipeTo(producer(left)), channelExecutor.runIn(scope), Effect.forkIn(scope))), Effect.tap(([_, right]) => toChannel(that).pipe(channel.concatMap(channel.writeChunk), core.pipeTo(producer(right)), channelExecutor.runIn(scope), Effect.forkIn(scope))), Effect.map(([left, right]) => {
     const process = (leftDone, rightDone) => core.readWithCause({
       onInput: bool => {
         if (bool && !leftDone) {
@@ -1495,7 +1488,7 @@ export const prepend = /*#__PURE__*/dual(2, (self, values) => new StreamImpl(cha
 /** @internal */
 export const provideContext = /*#__PURE__*/dual(2, (self, context) => new StreamImpl(pipe(toChannel(self), core.provideContext(context))));
 /** @internal */
-export const provideLayer = /*#__PURE__*/dual(2, (self, layer) => new StreamImpl(channel.unwrapScoped(pipe(Layer.build(layer), Effect.map(env => pipe(toChannel(self), core.provideContext(env)))))));
+export const provideLayer = /*#__PURE__*/dual(2, (self, layer) => new StreamImpl(channel.unwrapScopedWith(scope => Layer.buildWithScope(layer, scope).pipe(Effect.map(env => pipe(toChannel(self), core.provideContext(env)))))));
 /** @internal */
 export const provideService = /*#__PURE__*/dual(3, (self, tag, resource) => provideServiceEffect(self, tag, Effect.succeed(resource)));
 /** @internal */
@@ -1682,43 +1675,43 @@ export const retry = /*#__PURE__*/dual(2, (self, schedule) => Schedule.driver(sc
   return loop;
 }), channel.unwrap, fromChannel));
 /** @internal */
-export const run = /*#__PURE__*/dual(2, (self, sink) => pipe(toChannel(self), channel.pipeToOrFail(_sink.toChannel(sink)), channel.runDrain));
+export const run = /*#__PURE__*/dual(2, (self, sink) => toChannel(self).pipe(channel.pipeToOrFail(_sink.toChannel(sink)), channel.runDrain));
 /** @internal */
-export const runCollect = self => pipe(self, run(_sink.collectAll()));
+export const runCollect = self => run(self, _sink.collectAll());
 /** @internal */
-export const runCount = self => pipe(self, run(_sink.count));
+export const runCount = self => run(self, _sink.count);
 /** @internal */
-export const runDrain = self => pipe(self, run(_sink.drain));
+export const runDrain = self => run(self, _sink.drain);
 /** @internal */
-export const runFold = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, runFoldWhileScoped(s, constTrue, f), Effect.scoped));
+export const runFold = /*#__PURE__*/dual(3, (self, s, f) => runFoldWhile(self, s, constTrue, f));
 /** @internal */
-export const runFoldEffect = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, runFoldWhileScopedEffect(s, constTrue, f), Effect.scoped));
+export const runFoldEffect = /*#__PURE__*/dual(3, (self, s, f) => runFoldWhileEffect(self, s, constTrue, f));
 /** @internal */
 export const runFoldScoped = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, runFoldWhileScoped(s, constTrue, f)));
 /** @internal */
 export const runFoldScopedEffect = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, runFoldWhileScopedEffect(s, constTrue, f)));
 /** @internal */
-export const runFoldWhile = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runFoldWhileScoped(s, cont, f), Effect.scoped));
+export const runFoldWhile = /*#__PURE__*/dual(4, (self, s, cont, f) => run(self, _sink.fold(s, cont, f)));
 /** @internal */
-export const runFoldWhileEffect = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runFoldWhileScopedEffect(s, cont, f), Effect.scoped));
+export const runFoldWhileEffect = /*#__PURE__*/dual(4, (self, s, cont, f) => run(self, _sink.foldEffect(s, cont, f)));
 /** @internal */
 export const runFoldWhileScoped = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runScoped(_sink.fold(s, cont, f))));
 /** @internal */
 export const runFoldWhileScopedEffect = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runScoped(_sink.foldEffect(s, cont, f))));
 /** @internal */
-export const runForEach = /*#__PURE__*/dual(2, (self, f) => pipe(self, run(_sink.forEach(f))));
+export const runForEach = /*#__PURE__*/dual(2, (self, f) => run(self, _sink.forEach(f)));
 /** @internal */
-export const runForEachChunk = /*#__PURE__*/dual(2, (self, f) => pipe(self, run(_sink.forEachChunk(f))));
+export const runForEachChunk = /*#__PURE__*/dual(2, (self, f) => run(self, _sink.forEachChunk(f)));
 /** @internal */
 export const runForEachChunkScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(_sink.forEachChunk(f))));
 /** @internal */
 export const runForEachScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(_sink.forEach(f))));
 /** @internal */
-export const runForEachWhile = /*#__PURE__*/dual(2, (self, f) => pipe(self, run(_sink.forEachWhile(f))));
+export const runForEachWhile = /*#__PURE__*/dual(2, (self, f) => run(self, _sink.forEachWhile(f)));
 /** @internal */
 export const runForEachWhileScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(_sink.forEachWhile(f))));
 /** @internal */
-export const runHead = self => pipe(self, run(_sink.head()));
+export const runHead = self => run(self, _sink.head());
 /** @internal */
 export const runIntoPubSub = /*#__PURE__*/dual(2, (self, pubsub) => pipe(self, runIntoQueue(pubsub)));
 /** @internal */
@@ -1732,7 +1725,7 @@ export const runIntoQueueElementsScoped = /*#__PURE__*/dual(2, (self, queue) =>
     onFailure: cause => core.fromEffect(Queue.offer(queue, Exit.failCause(Cause.map(cause, Option.some)))),
     onDone: () => core.fromEffect(Queue.offer(queue, Exit.fail(Option.none())))
   });
-  return pipe(core.pipeTo(toChannel(self), writer), channel.drain, channelExecutor.runScoped, Effect.asVoid);
+  return pipe(core.pipeTo(toChannel(self), writer), channel.drain, channel.runScoped, Effect.asVoid);
 });
 /** @internal */
 export const runIntoQueueScoped = /*#__PURE__*/dual(2, (self, queue) => {
@@ -1741,14 +1734,14 @@ export const runIntoQueueScoped = /*#__PURE__*/dual(2, (self, queue) => {
     onFailure: cause => core.write(InternalTake.failCause(cause)),
     onDone: () => core.write(InternalTake.end)
   });
-  return pipe(core.pipeTo(toChannel(self), writer), channel.mapOutEffect(take => Queue.offer(queue, take)), channel.drain, channelExecutor.runScoped, Effect.asVoid);
+  return pipe(core.pipeTo(toChannel(self), writer), channel.mapOutEffect(take => Queue.offer(queue, take)), channel.drain, channel.runScoped, Effect.asVoid);
 });
 /** @internal */
-export const runLast = self => pipe(self, run(_sink.last()));
+export const runLast = self => run(self, _sink.last());
 /** @internal */
-export const runScoped = /*#__PURE__*/dual(2, (self, sink) => pipe(toChannel(self), channel.pipeToOrFail(_sink.toChannel(sink)), channel.drain, channelExecutor.runScoped));
+export const runScoped = /*#__PURE__*/dual(2, (self, sink) => pipe(toChannel(self), channel.pipeToOrFail(_sink.toChannel(sink)), channel.drain, channel.runScoped));
 /** @internal */
-export const runSum = self => pipe(self, run(_sink.sum));
+export const runSum = self => run(self, _sink.sum);
 /** @internal */
 export const scan = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, scanEffect(s, (s, a) => Effect.succeed(f(s, a)))));
 /** @internal */
@@ -1794,6 +1787,8 @@ export const scanEffect = /*#__PURE__*/dual(3, (self, s, f) => new StreamImpl(pi
 /** @internal */
 export const scoped = effect => new StreamImpl(channel.ensuring(channel.scoped(pipe(effect, Effect.map(Chunk.of))), Effect.void));
 /** @internal */
+export const scopedWith = f => new StreamImpl(channel.scopedWith(scope => f(scope).pipe(Effect.map(Chunk.of))));
+/** @internal */
 export const some = self => pipe(self, mapError(Option.some), someOrFail(() => Option.none()));
 /** @internal */
 export const someOrElse = /*#__PURE__*/dual(2, (self, fallback) => pipe(self, map(Option.getOrElse(fallback))));
@@ -2239,6 +2234,8 @@ export const unwrap = effect => flatten(fromEffect(effect));
 /** @internal */
 export const unwrapScoped = effect => flatten(scoped(effect));
 /** @internal */
+export const unwrapScopedWith = f => flatten(scopedWith(scope => f(scope)));
+/** @internal */
 export const updateService = /*#__PURE__*/dual(3, (self, tag, f) => pipe(self, mapInputContext(context => pipe(context, Context.add(tag, f(pipe(context, Context.unsafeGet(tag))))))));
 /** @internal */
 export const when = /*#__PURE__*/dual(2, (self, test) => pipe(self, whenEffect(Effect.sync(test))));