@fncts/io 0.0.1

package/_mjs/Stream/api.mjs

@@ -0,0 +1,2178 @@
+const fileName_1 = "(@fncts/io) src/Stream/api.ts";
+import * as tsplus_module_1 from "@fncts/io/IO/api";
+import * as tsplus_module_2 from "@fncts/io/Schedule/api";
+import * as tsplus_module_3 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_4 from "@fncts/base/data/Either/destructors";
+import * as tsplus_module_5 from "@fncts/io/Stream/internal/Handoff";
+import * as tsplus_module_6 from "@fncts/io/Ref/constructors";
+import * as tsplus_module_7 from "@fncts/base/collection/immutable/Conc/api/empty";
+import * as tsplus_module_8 from "@fncts/io/Schedule/api/driver";
+import * as tsplus_module_9 from "@fncts/io/IO/api/sequenceT";
+import * as tsplus_module_10 from "@fncts/io/Channel/api";
+import * as tsplus_module_11 from "@fncts/io/Channel/core-api";
+import * as tsplus_module_12 from "@fncts/base/collection/immutable/Conc/api";
+import * as tsplus_module_13 from "@fncts/io/Ref/api/set";
+import * as tsplus_module_14 from "@fncts/io/Ref/api/modify";
+import * as tsplus_module_15 from "@fncts/base/data/Cause/api";
+import * as tsplus_module_16 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_17 from "@fncts/base/data/Either/constructors";
+import * as tsplus_module_18 from "@fncts/base/collection/immutable/Conc/constructors";
+import * as tsplus_module_19 from "@fncts/io/Stream/internal/SinkEndReason";
+import * as tsplus_module_20 from "@fncts/io/Fiber/api/interrupt";
+import * as tsplus_module_21 from "@fncts/io/IO/api/forkScoped";
+import * as tsplus_module_22 from "@fncts/io/IO/api/core-scope";
+import * as tsplus_module_23 from "@fncts/io/Channel/api/runScoped";
+import * as tsplus_module_24 from "@fncts/io/Stream/internal/Take";
+import * as tsplus_module_25 from "@fncts/io/Queue/api/operations";
+import * as tsplus_module_26 from "@fncts/io/IO/runtime";
+import * as tsplus_module_27 from "@fncts/io/Queue/constructors";
+import * as tsplus_module_28 from "@fncts/io/IO/api/acquireRelease";
+import * as tsplus_module_29 from "@fncts/io/IO/api/acquireReleaseExit";
+import * as tsplus_module_30 from "@fncts/io/Hub/api";
+import * as tsplus_module_31 from "@fncts/base/collection/immutable/Conc/api/replicate";
+import * as tsplus_module_32 from "@fncts/base/data/Exit/api";
+import * as tsplus_module_33 from "@fncts/io/Future/api";
+import * as tsplus_module_34 from "@fncts/io/Future/constructors";
+import * as tsplus_module_35 from "@fncts/io/Ref/api/get";
+import * as tsplus_module_36 from "@fncts/base/data/Maybe/api";
+import * as tsplus_module_37 from "@fncts/base/data/Exit/constructors";
+import * as tsplus_module_38 from "@fncts/io/Stream/internal/DebounceState";
+import * as tsplus_module_39 from "@fncts/io/Fiber/api/join";
+import * as tsplus_module_40 from "@fncts/io/Clock/api";
+import * as tsplus_module_41 from "@fncts/base/collection/immutable/HashMap/api";
+import * as tsplus_module_42 from "@fncts/io/TSemaphore/api";
+import * as tsplus_module_43 from "@fncts/io/STM/api";
+import * as tsplus_module_44 from "@fncts/io/TSemaphore/constructors";
+import * as tsplus_module_45 from "@fncts/io/Sink/api";
+import * as tsplus_module_46 from "@fncts/base/data/Predicate/api";
+import * as tsplus_module_47 from "@fncts/io/Fiber/api/poll";
+import * as tsplus_module_48 from "@fncts/io/IO/api/environment";
+import * as tsplus_module_49 from "@fncts/io/collection/immutable/Conc/findIO";
+import * as tsplus_module_50 from "@fncts/base/data/Exit/definition";
+import * as tsplus_module_51 from "@fncts/io/Stream/internal/Pull";
+import * as tsplus_module_52 from "@fncts/io/Queue/api/takeBetween";
+import * as tsplus_module_53 from "@fncts/io/Channel/api/interruptWhen";
+import * as tsplus_module_54 from "@fncts/io/collection/immutable/Conc/mapIO";
+import * as tsplus_module_55 from "@fncts/io/Channel/api/mapOutIOC";
+import * as tsplus_module_56 from "@fncts/io/Channel/api/mergeMap";
+import * as tsplus_module_57 from "@fncts/io/Channel/internal/MergeDecision";
+import * as tsplus_module_58 from "@fncts/io/Channel/api/mergeWith";
+import * as tsplus_module_59 from "@fncts/io/Layer/MemoMap";
+import * as tsplus_module_60 from "@fncts/io/Layer/api";
+import * as tsplus_module_61 from "@fncts/io/Channel/api/runDrain";
+import * as tsplus_module_62 from "@fncts/base/data/exceptions";
+import * as tsplus_module_63 from "@fncts/io/collection/immutable/Conc/takeWhileIO";
+import * as tsplus_module_64 from "@fncts/io/Channel/api/toPull";
+export const aggregateAsyncWithin_ = aggregateAsyncWithin_1;
+export const aggregateAsyncWithinEither_ = aggregateAsyncWithinEither_1;
+export const apSecond_ = apSecond_1;
+export const asyncInterrupt = asyncInterrupt_1;
+export const asyncMaybe = asyncMaybe_1;
+export const broadcastedQueues_ = broadcastedQueues_1;
+export const broadcastedQueuesDynamic_ = broadcastedQueuesDynamic_1;
+export const catchAll_ = catchAll_1;
+export const catchAllCause_ = catchAllCause_1;
+export const flatMap_ = flatMap_1;
+export const concat_ = concat_1;
+export const crossWith_ = crossWith_1;
+export const distributedWithDynamic_ = distributedWithDynamic_1;
+export const drop_ = drop_1;
+export const dropWhile_ = dropWhile_1;
+export const ensuring_ = ensuring_1;
+export const environment = environment_1;
+export const failNow = failNow_1;
+export const failCauseNow = failCauseNow_1;
+export const filterMap_ = filterMap_1;
+export const flatten = flatten_1;
+export const flattenExitOption = flattenExitOption_1;
+export const flattenTake = flattenTake_1;
+export const flattenChunks = flattenChunks_1;
+export const forever = forever_1;
+export const fromChunkNow = fromChunkNow_1;
+export const fromChunk = fromChunk_1;
+export const scoped = scoped_1;
+export const fromIO = fromIO_1;
+export const fromIOMaybe = fromIOMaybe_1;
+export const fromPull = fromPull_1;
+export const fromQueue_ = fromQueue_1;
+export const fromQueueWithShutdown = fromQueueWithShutdown_1;
+export const halt = halt_1;
+export const interleaveWith_ = interleaveWith_1;
+export const loopOnChunks_ = loopOnChunks_1;
+export const loopOnPartialChunks_ = loopOnPartialChunks_1;
+export const loopOnPartialChunksElements_ = loopOnPartialChunksElements_1;
+export const map_ = map_1;
+export const mapAccumIO_ = mapAccumIO_1;
+export const mapChunks_ = mapChunks_1;
+export const mapConcatChunk_ = mapConcatChunk_1;
+export const mapError_ = mapError_1;
+export const mapIO_ = mapIO_1;
+export const mergeMap_ = mergeMap_1;
+export const mergeEither_ = mergeEither_1;
+export const mergeWith_ = mergeWith_1;
+export const orElse_ = orElse_1;
+export const pipeThrough_ = pipeThrough_1;
+export const provideEnvironment_ = provideEnvironment_1;
+export const provideLayer_ = provideLayer_1;
+export const repeatIOMaybe = repeatIOMaybe_1;
+export const repeatIOChunkMaybe = repeatIOChunkMaybe_1;
+export const run_ = run_1;
+export const runForeachScoped_ = runForeachScoped_1;
+export const runIntoElementsScoped_ = runIntoElementsScoped_1;
+export const runIntoQueueScoped_ = runIntoQueueScoped_1;
+export const runIntoHubScoped_ = runIntoHubScoped_1;
+export const runScoped_ = runScoped_1;
+export const scanIO_ = scanIO_1;
+export const scanReduceIO_ = scanReduceIO_1;
+export const succeedNow = succeedNow_1;
+export const throttleEnforceIO_ = throttleEnforceIO_1;
+export const toHub_ = toHub_1;
+export const toPull = toPull_1;
+export const toQueue_ = toQueue_1;
+export const toQueueOfElements_ = toQueueOfElements_1;
+export const toQueueUnbounded = toQueueUnbounded_1;
+export const unfoldChunkIO = unfoldChunkIO_1;
+export const unfoldIO = unfoldIO_1;
+export const unfoldChunk = unfoldChunk_1;
+export const unwrap = unwrap_1;
+export const unwrapScoped = unwrapScoped_1;
+import { constVoid, identity, tuple } from "@fncts/base/data/function";
+import { DEFAULT_CHUNK_SIZE, Stream } from "./definition.mjs";
+import { ScheduleEnd, ScheduleTimeout, SinkEnd, UpstreamEnd } from "./internal/SinkEndReason.mjs";
+/**
+ * Submerges the error case of an `Either` into the `Stream`.
+ *
+ * @tsplus getter fncts.io.Stream absolve
+ */
+
+export function absolve(self) {
+  return mapIO_1(self, either => tsplus_module_1.fromEither(() => either, fileName_1 + ":24:46"));
+}
+/**
+ * Aggregates elements of this stream using the provided sink for as long
+ * as the downstream operators on the stream are busy.
+ *
+ * This operator divides the stream into two asynchronous "islands". Operators upstream
+ * of this operator run on one fiber, while downstream operators run on another. Whenever
+ * the downstream fiber is busy processing elements, the upstream fiber will feed elements
+ * into the sink until it signals completion.
+ *
+ * Any sink can be used here, but see `Sink.foldWeightedM` and `Sink.foldUntilM` for
+ * sinks that cover the common usecases.
+ *
+ * @tsplus fluent fncts.io.Stream aggregateAsync
+ */
+
+export function aggregateAsync_(stream, sink) {
+  return aggregateAsyncWithin_1(stream, sink, tsplus_module_2.forever);
+}
+/**
+ * Like `aggregateAsyncWithinEither`, but only returns the `Right` results.
+ *
+ * @tsplus fluent fncts.io.Stream aggregateAsyncWithin
+ */
+
+function aggregateAsyncWithin_1(stream, sink, schedule) {
+  return filterMap_1(aggregateAsyncWithinEither_1(stream, sink, schedule), cb => tsplus_module_4.match_(cb, () => tsplus_module_3.nothing(), tsplus_module_3.just));
+}
+/**
+ * Aggregates elements using the provided sink until it completes, or until the
+ * delay signalled by the schedule has passed.
+ *
+ * This operator divides the stream into two asynchronous islands. Operators upstream
+ * of this operator run on one fiber, while downstream operators run on another. Elements
+ * will be aggregated by the sink until the downstream fiber pulls the aggregated value,
+ * or until the schedule's delay has passed.
+ *
+ * Aggregated elements will be fed into the schedule to determine the delays between
+ * pulls.
+ *
+ * @tsplus fluent fncts.io.Stream aggregateAsyncWithinEither
+ */
+
+
+function aggregateAsyncWithinEither_1(stream, sink, schedule) {
+  const deps = tsplus_module_9.sequenceT(tsplus_module_5.make(), tsplus_module_6.make(() => new SinkEnd()), tsplus_module_6.make(() => tsplus_module_7.empty()), tsplus_module_8.driver(schedule));
+  return flatMap_1(fromIO_1(deps), ([handoff, sinkEndReason, sinkLeftovers, scheduleDriver]) => {
+    const handoffProducer = tsplus_module_10.readWithCause(_in => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_5.emit(_in))), handoffProducer), cause => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_5.halt(cause))), _ => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_5.end(new UpstreamEnd()))));
+    const handoffConsumer = tsplus_module_10.unwrap(tsplus_module_1.flatMap_(tsplus_module_14.getAndSet_(sinkLeftovers, tsplus_module_7.empty()), leftovers => {
+      if (tsplus_module_12.isEmpty(leftovers)) {
+        return tsplus_module_1.succeedNow(tsplus_module_11.apSecond_(tsplus_module_10.writeNow(leftovers), handoffConsumer), fileName_1 + ":100:31");
+      } else {
+        return tsplus_module_1.map_(tsplus_module_5.take(handoff), signal => tsplus_module_5.matchSignal_(signal, {
+          Emit: ({
+            els
+          }) => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(els), handoffConsumer),
+          Halt: ({
+            error
+          }) => tsplus_module_11.failCause(() => error),
+          End: ({
+            reason
+          }) => tsplus_module_10.fromIO(tsplus_module_13.set_(sinkEndReason, reason))
+        }), fileName_1 + ":102:34");
+      }
+    }, fileName_1 + ":98:55"));
+
+    const scheduledAggregator = lastB => {
+      const timeout = tsplus_module_1.matchCauseIO_(scheduleDriver.next(lastB, fileName_1 + ":116:42"), _ => tsplus_module_4.match_(tsplus_module_15.failureOrCause(_), () => tsplus_module_5.offer(handoff, tsplus_module_5.end(new ScheduleTimeout())), cause => tsplus_module_5.offer(handoff, tsplus_module_5.halt(cause))), c => tsplus_module_5.offer(handoff, tsplus_module_5.end(new ScheduleEnd(c))), fileName_1 + ":116:62");
+      return tsplus_module_11.flatMap_(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(tsplus_module_21.forkScoped(timeout), fiber => {
+        return tsplus_module_11.flatMap_(tsplus_module_10.doneCollect(tsplus_module_10.pipeToOrFail_(handoffConsumer, sink.channel)), ([leftovers, b]) => {
+          return tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_1.apSecond_(tsplus_module_20.interrupt(fiber), tsplus_module_13.set_(sinkLeftovers, tsplus_module_12.flatten(leftovers)), fileName_1 + ":128:59")), tsplus_module_10.unwrap(tsplus_module_14.modify_(sinkEndReason, reason => tsplus_module_19.matchSinkEndReason_(reason, {
+            ScheduleEnd: ({
+              c
+            }) => tuple(tsplus_module_10.as_(tsplus_module_10.writeNow(tsplus_module_18.from([tsplus_module_17.right(b), tsplus_module_17.left(c)])), () => tsplus_module_3.just(b)), new SinkEnd()),
+            ScheduleTimeout: () => tuple(tsplus_module_10.as_(tsplus_module_10.writeNow(tsplus_module_18.single(tsplus_module_17.right(b))), () => tsplus_module_3.just(b)), new SinkEnd()),
+            SinkEnd: () => tuple(tsplus_module_10.as_(tsplus_module_10.writeNow(tsplus_module_18.single(tsplus_module_17.right(b))), () => tsplus_module_3.just(b)), new SinkEnd()),
+            UpstreamEnd: () => tuple(tsplus_module_10.as_(tsplus_module_10.writeNow(tsplus_module_18.single(tsplus_module_17.right(b))), () => tsplus_module_3.nothing()), new UpstreamEnd())
+          }))));
+        });
+      }, fileName_1 + ":126:31")), _ => tsplus_module_16.match_(_, () => tsplus_module_10.unit, () => scheduledAggregator(_)));
+    };
+
+    return apSecond_1(scoped_1(tsplus_module_22.forkDaemon(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(stream.channel, handoffProducer)))), new Stream(scheduledAggregator(tsplus_module_3.nothing())));
+  });
+}
+/**
+ * Composes this stream with the specified stream to create a cartesian product of elements,
+ * but keeps only elements from this stream.
+ * The `that` stream would be run multiple times, for every element in the `this` stream.
+ *
+ * @tsplus fluent fncts.io.Stream apFirst
+ */
+
+
+export function apFirst_(stream, that) {
+  return crossWith_1(stream, that, (a, _) => a);
+}
+/**
+ * Composes this stream with the specified stream to create a cartesian product of elements,
+ * but keeps only elements from the other stream.
+ * The `that` stream would be run multiple times, for every element in the `this` stream.
+ *
+ * @tsplus fluent fncts.io.Stream apSecond
+ */
+
+function apSecond_1(stream, that) {
+  return crossWith_1(stream, that, (_, b) => b);
+}
+/**
+ * Maps the success values of this stream to the specified constant value.
+ *
+ * @tsplus fluent fncts.io.Stream as
+ */
+
+
+export function as_(stream, b) {
+  return map_1(stream, () => b());
+}
+/**
+ * @tsplus static fncts.io.StreamOps asyncInterrupt
+ */
+
+function asyncInterrupt_1(register, outputBuffer = 16) {
+  return unwrapScoped_1(tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_27.makeBounded(outputBuffer), queue => tsplus_module_25.shutdown(queue)), output => tsplus_module_1.flatMap_(tsplus_module_26.runtime(fileName_1 + ":208:40"), runtime => tsplus_module_1.map_(tsplus_module_1.succeed(() => register((k, cb) => {
+    const effect = tsplus_module_1.flatMap_(tsplus_module_24.fromPull(k), a => tsplus_module_25.offer_(output, a), fileName_1 + ":212:52");
+    return runtime.unsafeRunAsyncWith(effect, cb || constVoid, fileName_1 + ":213:46");
+  }), fileName_1 + ":210:19"), eitherStream => tsplus_module_4.match_(eitherStream, canceler => {
+    const loop = tsplus_module_10.unwrap(tsplus_module_1.match_(tsplus_module_1.flatMap_(tsplus_module_25.take(output), take => tsplus_module_24.done(take), fileName_1 + ":221:23"), maybeError => tsplus_module_16.match_(maybeError, () => tsplus_module_11.endNow(undefined), tsplus_module_10.failNow), as => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(as), loop), fileName_1 + ":222:21"));
+    return ensuring_1(new Stream(loop), canceler);
+  }, stream => unwrap_1(tsplus_module_1.as_(tsplus_module_25.shutdown(output), () => stream))), fileName_1 + ":209:29"), fileName_1 + ":208:29"), fileName_1 + ":207:29"));
+}
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple times.
+ * The registration of the callback can possibly return the stream synchronously.
+ * The optionality of the error type `E` can be used to signal the end of the stream,
+ * by setting it to `None`.
+ *
+ * @tsplus static fncts.io.StreamOps asyncMaybe
+ */
+
+
+function asyncMaybe_1(register, outputBuffer = 16) {
+  return asyncInterrupt_1(k => tsplus_module_16.match_(register(k), () => tsplus_module_17.left(tsplus_module_1.unit), tsplus_module_17.right), outputBuffer);
+}
+/**
+ * @tsplus static fncts.io.StreamOps async
+ */
+
+
+export function async(register, outputBuffer = 16) {
+  return asyncMaybe_1(cb => {
+    register(cb);
+    return tsplus_module_3.nothing();
+  }, outputBuffer);
+}
+/**
+ * @tsplus static fncts.io.StreamOps asyncIO
+ */
+
+export function asyncIO(register, outputBuffer = 16) {
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_27.makeBounded(outputBuffer), _ => tsplus_module_25.shutdown(_)), output => tsplus_module_1.flatMap_(tsplus_module_26.runtime(fileName_1 + ":278:37"), runtime => tsplus_module_1.map_(register((k, cb) => runtime.unsafeRunAsyncWith(tsplus_module_1.flatMap_(tsplus_module_24.fromPull(k), a => tsplus_module_25.offer_(output, a), fileName_1 + ":282:39"), cb || constVoid, fileName_1 + ":281:39")), () => {
+    const loop = tsplus_module_10.unwrap(tsplus_module_1.matchCauseIO_(tsplus_module_1.flatMap_(tsplus_module_25.take(output), take => tsplus_module_24.done(take), fileName_1 + ":289:21"), cause => tsplus_module_1.as_(tsplus_module_25.shutdown(output), () => tsplus_module_4.match_(tsplus_module_15.failureOrCause(cause), maybeError => tsplus_module_16.match_(maybeError, () => tsplus_module_11.endNow(undefined), tsplus_module_10.failNow), tsplus_module_11.failCauseNow)), as => tsplus_module_1.succeed(() => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(as), loop), fileName_1 + ":298:33"), fileName_1 + ":290:26"));
+    return loop;
+  }), fileName_1 + ":278:26"), fileName_1 + ":277:26")));
+}
+/**
+ * Returns a stream whose failure and success channels have been mapped by
+ * the specified pair of functions, `f` and `g`.
+ */
+
+export function bimap_(stream, f, g) {
+  return map_1(mapError_1(stream, f), g);
+}
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed
+ *
+ * @tsplus static fncts.io.StreamOps acquireRelease
+ */
+
+export function acquireRelease_(acquire, release) {
+  return scoped_1(tsplus_module_28.acquireRelease(() => acquire, release));
+}
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed
+ *
+ * @tsplus static fncts.io.StreamOps acquireReleaseExit
+ */
+
+export function acquireReleaseExit_(acquire, release) {
+  return scoped_1(tsplus_module_29.acquireReleaseExit(() => acquire, release, fileName_1 + ":338:45"));
+}
+/**
+ * Fan out the stream, producing a list of streams that have the same elements as this stream.
+ * The driver stream will only ever advance of the `maximumLag` chunks before the
+ * slowest downstream stream.
+ *
+ * @tsplus fluent fncts.io.Stream broadcast
+ */
+
+export function broadcast_(stream, n, maximumLag) {
+  return tsplus_module_1.map_(broadcastedQueues_1(stream, n, maximumLag), c => tsplus_module_12.map_(c, hub => flattenTake_1(fromQueueWithShutdown_1(hub))), fileName_1 + ":355:9");
+}
+/**
+ * Fan out the stream, producing a dynamic number of streams that have the same elements as this stream.
+ * The driver stream will only ever advance of the `maximumLag` chunks before the
+ * slowest downstream stream.
+ *
+ * @tsplus fluent fncts.io.Stream broadcastDynamic
+ */
+
+export function broadcastDynamic_(stream, maximumLag) {
+  return tsplus_module_1.map_(broadcastedQueuesDynamic_1(stream, maximumLag), scoped => flattenTake_1(flatMap_1(scoped_1(scoped), fromQueue_1)), fileName_1 + ":371:9");
+}
+/**
+ * Converts the stream to a managed list of queues. Every value will be replicated to every queue with the
+ * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @tsplus fluent fncts.io.Stream broadcastedQueues
+ */
+
+function broadcastedQueues_1(stream, n, maximumLag) {
+  return tsplus_module_1.flatMap_(tsplus_module_30.makeBounded(maximumLag), hub => tsplus_module_1.flatMap_(tsplus_module_1.sequenceIterable(tsplus_module_31.replicate(n, tsplus_module_30.subscribe(hub))), queues => tsplus_module_1.map_(tsplus_module_1.fork(runIntoHubScoped_1(stream, hub)), () => queues), fileName_1 + ":389:21"), fileName_1 + ":388:21");
+}
+/**
+ * Converts the stream to a managed dynamic amount of queues. Every chunk will be replicated to every queue with the
+ * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @tsplus fluent fncts.io.Stream broadcastedQueuesDynamic
+ */
+
+
+function broadcastedQueuesDynamic_1(stream, maximumLag) {
+  return tsplus_module_1.map_(toHub_1(stream, maximumLag), hub => tsplus_module_30.subscribe(hub), fileName_1 + ":407:38");
+}
+/**
+ * Allows a faster producer to progress independently of a slower consumer by buffering
+ * up to `capacity` elements in a queue.
+ *
+ * @tsplus fluent fncts.io.Stream buffer
+ */
+
+
+export function buffer_(stream, capacity) {
+  const queue = toQueueOfElements_1(stream, capacity);
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(queue, queue => {
+    const process = tsplus_module_11.flatMap_(tsplus_module_10.fromIO(tsplus_module_25.take(queue)), exit => tsplus_module_32.match_(exit, cause => tsplus_module_16.match_(tsplus_module_15.flipCauseOption(cause), () => tsplus_module_11.endNow(undefined), tsplus_module_11.failCauseNow), value => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(tsplus_module_18.single(value)), process)));
+    return process;
+  }, fileName_1 + ":420:16")));
+}
+/**
+ * @tsplus fluent fncts.io.Stream bufferChunks
+ */
+
+export function bufferChunks_(stream, capacity) {
+  const queue = toQueue_1(stream, capacity);
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(queue, queue => {
+    const process = tsplus_module_11.flatMap_(tsplus_module_10.fromIO(tsplus_module_25.take(queue)), take => tsplus_module_24.match_(take, tsplus_module_11.endNow(undefined), tsplus_module_11.failCauseNow, value => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(value), process)));
+    return process;
+  }, fileName_1 + ":442:16")));
+}
+/**
+ * Allows a faster producer to progress independently of a slower consumer by buffering
+ * elements into an unbounded queue.
+ *
+ * @tsplus getter fncts.io.Stream bufferUnbounded
+ */
+
+export function bufferUnbounded(stream) {
+  const queue = toQueueUnbounded_1(stream);
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(queue, queue => {
+    const process = tsplus_module_11.flatMap_(tsplus_module_10.fromIO(tsplus_module_25.take(queue)), take => tsplus_module_24.match_(take, tsplus_module_11.endNow(undefined), tsplus_module_11.failCauseNow, value => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(value), process)));
+    return process;
+  }, fileName_1 + ":467:16")));
+}
+
+function bufferSignalProducer(queue, ref) {
+  const terminate = take => tsplus_module_10.fromIO(tsplus_module_1.flatMap_(tsplus_module_35.get(ref), latch => tsplus_module_1.flatMap_(tsplus_module_33.wait(latch), () => tsplus_module_1.flatMap_(tsplus_module_34.make(), p => tsplus_module_1.flatMap_(tsplus_module_25.offer_(queue, tuple(take, p)), () => tsplus_module_1.flatMap_(tsplus_module_13.set_(ref, p), () => tsplus_module_1.map_(tsplus_module_33.wait(p), () => void 0), fileName_1 + ":493:10"), fileName_1 + ":492:10"), fileName_1 + ":491:20"), fileName_1 + ":490:10"), fileName_1 + ":489:24"));
+
+  return tsplus_module_10.readWith(inp => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_1.flatMap_(tsplus_module_34.make(), p => tsplus_module_1.flatMap_(tsplus_module_25.offer_(queue, tuple(tsplus_module_24.chunk(inp), p)), added => tsplus_module_1.map_(tsplus_module_1.when_(tsplus_module_13.set_(ref, p), () => added, fileName_1 + ":503:28"), () => void 0), fileName_1 + ":502:26"), fileName_1 + ":501:26")), bufferSignalProducer(queue, ref)), e => terminate(tsplus_module_24.fail(e)), () => terminate(tsplus_module_24.end));
+}
+
+function bufferSignalConsumer(queue) {
+  const process = tsplus_module_11.flatMap_(tsplus_module_10.fromIO(tsplus_module_25.take(queue)), ([take, promise]) => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_33.succeed_(promise, undefined)), tsplus_module_24.match_(take, tsplus_module_11.endNow(undefined), tsplus_module_11.failCauseNow, value => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(value), process))));
+  return process;
+}
+/**
+ * Switches over to the stream produced by the provided function in case this one
+ * fails with a typed error.
+ *
+ * @tsplus fluent fncts.io.Stream catchAll
+ */
+
+
+function catchAll_1(stream, f) {
+  return catchAllCause_1(stream, cause => tsplus_module_4.match_(tsplus_module_15.failureOrCause(cause), f, failCauseNow_1));
+}
+/**
+ * Switches over to the stream produced by the provided function in case this one
+ * fails. Allows recovery from all causes of failure, including interruption if the
+ * stream is uninterruptible.
+ *
+ * @tsplus fluent fncts.io.Stream catchAllCause
+ */
+
+
+function catchAllCause_1(stream, f) {
+  const channel = tsplus_module_10.catchAllCause_(stream.channel, cause => f(cause).channel);
+  return new Stream(channel);
+}
+/**
+ * Switches over to the stream produced by the provided function in case this one
+ * fails with some typed error.
+ *
+ * @tsplus fluent fncts.io.Stream catchJust
+ */
+
+
+export function catchJust_(stream, pf) {
+  return catchAll_1(stream, e => tsplus_module_36.getOrElse_(pf(e), () => failNow_1(e)));
+}
+/**
+ * Switches over to the stream produced by the provided function in case this one
+ * fails with some errors. Allows recovery from all causes of failure, including interruption if the
+ * stream is uninterruptible.
+ *
+ * @tsplus fluent fncts.io.Stream catchJustCause
+ */
+
+export function catchJustCause_(stream, pf) {
+  return catchAllCause_1(stream, cause => tsplus_module_36.getOrElse_(pf(cause), () => failCauseNow_1(cause)));
+}
+/**
+ * Returns a stream made of the concatenation in strict order of all the streams
+ * produced by passing each element of this stream to `f`
+ *
+ * @tsplus fluent fncts.io.Stream flatMap
+ */
+
+function flatMap_1(stream, f) {
+  return new Stream(tsplus_module_10.concatMap_(stream.channel, as => tsplus_module_12.foldLeft_(tsplus_module_12.map_(as, a => f(a).channel), tsplus_module_10.unit, (s, a) => tsplus_module_11.flatMap_(s, () => a))));
+}
+/**
+ * Exposes the underlying chunks of the stream as a stream of chunks of elements
+ *
+ * @tsplus getter fncts.io.Stream chunks
+ */
+
+
+export function chunks(stream) {
+  return mapChunks_1(stream, tsplus_module_18.single);
+}
+
+function changesWithWriter(f, last) {
+  return tsplus_module_10.readWithCause(chunk => {
+    const [newLast, newChunk] = tsplus_module_12.foldLeft_(chunk, [last, tsplus_module_7.empty()], ([maybeLast, os], o1) => tsplus_module_16.match_(maybeLast, () => [tsplus_module_3.just(o1), tsplus_module_12.append_(os, o1)], o => f(o, o1) ? [tsplus_module_3.just(o1), os] : [tsplus_module_3.just(o1), tsplus_module_12.append_(os, o1)]));
+    return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(newChunk), changesWithWriter(f, newLast));
+  }, tsplus_module_11.failCauseNow, () => tsplus_module_10.unit);
+}
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified function to determine
+ * whether two elements are equal.
+ *
+ * @tsplus fluent fncts.io.Stream changesWith
+ */
+
+
+export function changesWith_(stream, f) {
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, changesWithWriter(f, tsplus_module_3.nothing())));
+}
+/**
+ * Transforms all elements of the stream for as long as the specified partial function is defined.
+ *
+ * @tsplus fluent fncts.io.Stream collectWhile
+ */
+
+export function collectWhile_(stream, pf) {
+  const loop = tsplus_module_10.readWith(inp => {
+    const mapped = tsplus_module_12.collectWhile_(inp, pf);
+
+    if (mapped.length === inp.length) {
+      return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(mapped), loop);
+    } else {
+      return tsplus_module_10.writeNow(mapped);
+    }
+  }, tsplus_module_10.failNow, tsplus_module_11.succeedNow);
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, loop));
+}
+/**
+ * Effectfully transforms all elements of the stream for as long as the specified partial function is defined.
+ */
+
+export function collectWhileIO_(stream, pf) {
+  return loopOnPartialChunks_1(stream, (chunk, emit) => {
+    const pfJust = a => tsplus_module_16.match_(pf(a), () => tsplus_module_1.succeedNow(false, fileName_1 + ":675:28"), effect => tsplus_module_1.as_(tsplus_module_1.flatMap_(effect, emit, fileName_1 + ":676:35"), () => true));
+
+    const loop = chunk => {
+      if (tsplus_module_12.isEmpty(chunk)) {
+        return tsplus_module_1.succeedNow(true, fileName_1 + ":681:29");
+      } else {
+        return tsplus_module_1.flatMap_(pfJust(tsplus_module_12.unsafeHead(chunk)), cont => cont ? loop(tsplus_module_12.unsafeTail(chunk)) : tsplus_module_1.succeedNow(false, fileName_1 + ":683:105"), fileName_1 + ":683:48");
+      }
+    };
+
+    return loop(chunk);
+  });
+}
+
+function combineProducer(handoff, latch) {
+  return tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.take(latch)), tsplus_module_10.readWithCause(value => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_37.succeed(value))), combineProducer(handoff, latch)), cause => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_37.failCause(tsplus_module_15.map_(cause, tsplus_module_3.just)))), () => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_37.fail(tsplus_module_3.nothing()))), combineProducer(handoff, latch))));
+}
+/**
+ * Combines the elements from this stream and the specified stream by repeatedly applying the
+ * function `f` to extract an element using both sides and conceptually "offer"
+ * it to the destination stream. `f` can maintain some internal state to control
+ * the combining process, with the initial state being specified by `s`.
+ *
+ * Where possible, prefer `Stream#combineChunks` for a more efficient implementation.
+ *
+ * @tsplus fluent fncts.io.Stream combine
+ */
+
+
+export function combine_(stream, that, s, f) {
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(tsplus_module_1.flatMap_(tsplus_module_5.make(), left => tsplus_module_1.flatMap_(tsplus_module_5.make(), right => tsplus_module_1.flatMap_(tsplus_module_5.make(), latchL => tsplus_module_1.flatMap_(tsplus_module_5.make(), latchR => tsplus_module_1.flatMap_(tsplus_module_1.fork(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(tsplus_module_10.concatMap_(stream.channel, tsplus_module_10.writeChunk), combineProducer(left, latchL)))), () => tsplus_module_1.map_(tsplus_module_1.fork(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(tsplus_module_10.concatMap_(that.channel, tsplus_module_10.writeChunk), combineProducer(right, latchR)))), () => tuple(left, right, latchL, latchR)), fileName_1 + ":731:10"), fileName_1 + ":730:25"), fileName_1 + ":729:25"), fileName_1 + ":728:25"), fileName_1 + ":727:25"), ([left, right, latchL, latchR]) => {
+    const pullLeft = tsplus_module_1.flatMap_(tsplus_module_1.apSecond_(tsplus_module_5.offer(latchL, undefined), tsplus_module_5.take(left), fileName_1 + ":735:59"), tsplus_module_1.fromExitNow, fileName_1 + ":735:78");
+    const pullRight = tsplus_module_1.flatMap_(tsplus_module_1.apSecond_(tsplus_module_5.offer(latchR, undefined), tsplus_module_5.take(right), fileName_1 + ":736:59"), tsplus_module_1.fromExitNow, fileName_1 + ":736:79");
+    return unfoldIO_1(s, s => tsplus_module_1.flatMap_(f(s, pullLeft, pullRight), exit => tsplus_module_1.optional(tsplus_module_1.fromExitNow(exit, fileName_1 + ":737:100")), fileName_1 + ":737:75")).channel;
+  }, fileName_1 + ":734:13")));
+}
+
+function combineChunksProducer(handoff, latch) {
+  return tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.take(latch)), tsplus_module_10.readWithCause(chunk => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_24.chunk(chunk))), combineChunksProducer(handoff, latch)), cause => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_24.failCause(cause))), () => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_24.end)), combineChunksProducer(handoff, latch))));
+}
+/**
+ * Combines the chunks from this stream and the specified stream by repeatedly applying the
+ * function `f` to extract a chunk using both sides and conceptually "offer"
+ * it to the destination stream. `f` can maintain some internal state to control
+ * the combining process, with the initial state being specified by `s`.
+ *
+ * @tsplus fluent fncts.io.Stream combineChunks
+ */
+
+
+export function combineChunks_(stream, that, s, f) {
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(tsplus_module_1.flatMap_(tsplus_module_5.make(), left => tsplus_module_1.flatMap_(tsplus_module_5.make(), right => tsplus_module_1.flatMap_(tsplus_module_5.make(), latchL => tsplus_module_1.flatMap_(tsplus_module_5.make(), latchR => tsplus_module_1.flatMap_(tsplus_module_1.fork(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(stream.channel, combineChunksProducer(left, latchL)))), () => tsplus_module_1.map_(tsplus_module_1.fork(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(that.channel, combineChunksProducer(right, latchR)))), () => tuple(left, right, latchL, latchR)), fileName_1 + ":782:10"), fileName_1 + ":781:25"), fileName_1 + ":780:25"), fileName_1 + ":779:25"), fileName_1 + ":778:25"), ([left, right, latchL, latchR]) => {
+    const pullLeft = tsplus_module_1.flatMap_(tsplus_module_1.apSecond_(tsplus_module_5.offer(latchL, undefined), tsplus_module_5.take(left), fileName_1 + ":788:20"), take => tsplus_module_24.done(take), fileName_1 + ":789:19");
+    const pullRight = tsplus_module_1.flatMap_(tsplus_module_1.apSecond_(tsplus_module_5.offer(latchR, undefined), tsplus_module_5.take(right), fileName_1 + ":792:20"), take => tsplus_module_24.done(take), fileName_1 + ":793:19");
+    return unfoldChunkIO_1(s, s => tsplus_module_1.flatMap_(f(s, pullLeft, pullRight), exit => tsplus_module_1.optional(tsplus_module_1.fromExit(() => exit, fileName_1 + ":794:102")), fileName_1 + ":794:80")).channel;
+  }, fileName_1 + ":785:13")));
+}
+/**
+ * Concatenates the specified stream with this stream, resulting in a stream
+ * that emits the elements from this stream and then the elements from the specified stream.
+ *
+ * @tsplus fluent fncts.io.Stream concat
+ */
+
+function concat_1(stream, that) {
+  return new Stream(tsplus_module_11.apSecond_(stream.channel, that.channel));
+}
+/**
+ * Composes this stream with the specified stream to create a cartesian product of elements.
+ * The `that` stream would be run multiple times, for every element in the `this` stream.
+ *
+ * @tsplus fluent fncts.io.Stream cross
+ */
+
+
+export function cross_(stream, that) {
+  return new Stream(tsplus_module_10.concatMap_(stream.channel, as => tsplus_module_10.mapOut_(that.channel, bs => tsplus_module_12.flatMap_(as, a => tsplus_module_12.map_(bs, b => tuple(a, b))))));
+}
+/**
+ * Composes this stream with the specified stream to create a cartesian product of elements
+ * with a specified function.
+ * The `fb` stream would be run multiple times, for every element in the `fa` stream.
+ *
+ * @tsplus fluent fncts.io.Stream crossWith
+ */
+
+function crossWith_1(fa, fb, f) {
+  return flatMap_1(fa, a => map_1(fb, b => f(a, b)));
+}
+/**
+ * Provides some of the environment required to run this effect,
+ * leaving the remainder `R0`.
+ *
+ * @tsplus fluent fncts.io.Stream contramapEnvironment
+ */
+
+
+export function contramapEnvironment_(ra, f) {
+  return flatMap_1(environment_1(), r0 => provideEnvironment_1(ra, f(r0)));
+}
+/**
+ * @tsplus fluent fncts.io.Stream debounce
+ */
+
+export function debounce_(stream, duration) {
+  return unwrap_1(tsplus_module_22.transplant(grafter => tsplus_module_1.map_(tsplus_module_5.make(), handoff => {
+    function enqueue(last) {
+      return tsplus_module_1.map_(grafter(tsplus_module_1.fork(tsplus_module_1.as_(tsplus_module_40.sleep(duration, fileName_1 + ":866:37"), () => last))), f => consumer(tsplus_module_38.previous(f)), fileName_1 + ":866:66");
+    }
+
+    const producer = tsplus_module_10.readWithCause(inp => tsplus_module_16.match_(tsplus_module_12.last(inp), () => producer, last => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_5.emit(tsplus_module_18.single(last)))), producer)), cause => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_5.halt(cause))), () => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_5.end(new UpstreamEnd()))));
+
+    function consumer(state) {
+      return tsplus_module_10.unwrap(tsplus_module_38.match_(state, {
+        NotStarted: () => tsplus_module_1.map_(tsplus_module_5.take(handoff), signal => tsplus_module_5.matchSignal_(signal, {
+          Emit: ({
+            els
+          }) => tsplus_module_10.unwrap(enqueue(els)),
+          Halt: ({
+            error
+          }) => tsplus_module_11.failCauseNow(error),
+          End: () => tsplus_module_10.unit
+        }), fileName_1 + ":881:33"),
+        Current: ({
+          fiber
+        }) => tsplus_module_1.map_(tsplus_module_39.join(fiber), signal => tsplus_module_5.matchSignal_(signal, {
+          Emit: ({
+            els
+          }) => tsplus_module_10.unwrap(enqueue(els)),
+          Halt: ({
+            error
+          }) => tsplus_module_11.failCauseNow(error),
+          End: () => tsplus_module_10.unit
+        }), fileName_1 + ":889:31"),
+        Previous: ({
+          fiber
+        }) => tsplus_module_22.raceWith_(tsplus_module_39.join(fiber), () => tsplus_module_5.take(handoff), (ex, current) => tsplus_module_32.match_(ex, cause => tsplus_module_1.as_(tsplus_module_20.interrupt(current), () => tsplus_module_11.failCauseNow(cause)), chunk => tsplus_module_1.succeedNow(tsplus_module_11.apSecond_(tsplus_module_10.writeNow(chunk), consumer(tsplus_module_38.current(current))), fileName_1 + ":903:38")), (ex, previous) => tsplus_module_32.match_(ex, cause => tsplus_module_1.as_(tsplus_module_20.interrupt(previous), () => tsplus_module_11.failCauseNow(cause)), signal => tsplus_module_5.matchSignal_(signal, {
+          Emit: ({
+            els
+          }) => tsplus_module_1.apSecond_(tsplus_module_20.interrupt(previous), enqueue(els), fileName_1 + ":910:73"),
+          Halt: ({
+            error
+          }) => tsplus_module_1.as_(tsplus_module_20.interrupt(previous), () => tsplus_module_11.failCauseNow(error)),
+          End: () => tsplus_module_1.map_(tsplus_module_39.join(previous), chunk => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(chunk), tsplus_module_10.unit), fileName_1 + ":912:55")
+        })), fileName_1 + ":897:36")
+      }));
+    }
+
+    return apSecond_1(scoped_1(tsplus_module_1.fork(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(stream.channel, producer)))), new Stream(consumer(tsplus_module_38.notStarted)));
+  }, fileName_1 + ":864:26"), fileName_1 + ":862:18"));
+}
+
+function defaultIfEmptyWriter(fb) {
+  return tsplus_module_10.readWith(i => tsplus_module_12.isEmpty(i) ? defaultIfEmptyWriter(fb) : tsplus_module_11.apSecond_(tsplus_module_10.writeNow(i), tsplus_module_10.id()), tsplus_module_10.failNow, () => fb.channel);
+}
+/**
+ * Switches to the provided stream in case this one is empty.
+ *
+ * @tsplus fluent fncts.io.Stream defaultIfEmpty
+ */
+
+
+export function defaultIfEmpty_(fa, fb) {
+  return new Stream(tsplus_module_10.pipeTo_(fa.channel, defaultIfEmptyWriter(fb)));
+}
+/**
+ * More powerful version of `broadcast`. Allows to provide a function that determines what
+ * queues should receive which elements. The decide function will receive the indices of the queues
+ * in the resulting list.
+ *
+ * @tsplus fluent fncts.io.Stream distributedWith
+ */
+
+export function distributedWith_(self, n, maximumLag, decide) {
+  return tsplus_module_1.flatMap_(tsplus_module_34.make(), p => tsplus_module_1.flatMap_(distributedWithDynamic_1(self, maximumLag, a => tsplus_module_1.flatMap_(tsplus_module_33.wait(p), f => f(a), fileName_1 + ":968:31"), () => tsplus_module_1.unit), next => tsplus_module_1.flatMap_(tsplus_module_1.sequenceIterable(tsplus_module_12.map_(tsplus_module_18.range(0, n), id => tsplus_module_1.map_(next, ([key, queue]) => [[key, id], queue], fileName_1 + ":973:48"))), entries => {
+    const [mappings, queues] = tsplus_module_12.foldRight_(entries, [tsplus_module_41.makeDefault(), tsplus_module_7.empty()], ([mapping, queue], [mappings, queues]) => [tsplus_module_41.set_(mappings, mapping[0], mapping[1]), tsplus_module_12.append_(queues, queue)]);
+    return tsplus_module_1.as_(tsplus_module_33.succeed_(p, a => tsplus_module_1.map_(decide(a), f => key => f(tsplus_module_36.toUndefined(tsplus_module_41.get_(mappings, key))), fileName_1 + ":979:48")), () => queues);
+  }, fileName_1 + ":974:18"), fileName_1 + ":971:15"), fileName_1 + ":964:77");
+}
+/**
+ * More powerful version of `ZStream#distributedWith`. This returns a function that will produce
+ * new queues and corresponding indices.
+ * You can also provide a function that will be executed after the final events are enqueued in all queues.
+ * Shutdown of the queues is handled by the driver.
+ * Downstream users can also shutdown queues manually. In this case the driver will
+ * continue but no longer backpressure on them.
+ *
+ * @tsplus fluent fncts.io.Stream distributedWithDynamic
+ */
+
+function distributedWithDynamic_1(self, maximumLag, decide, done = () => tsplus_module_1.unit) {
+  const offer = queuesRef => a => tsplus_module_1.flatMap_(decide(a), shouldProcess => tsplus_module_1.flatMap_(tsplus_module_35.get(queuesRef), queues => tsplus_module_1.flatMap_(tsplus_module_1.foldLeft_(queues, tsplus_module_7.empty(), (b, [id, queue]) => {
+    if (shouldProcess(id)) {
+      return tsplus_module_1.matchCauseIO_(tsplus_module_25.offer_(queue, tsplus_module_37.succeed(a)), c => tsplus_module_15.interrupted(c) ? tsplus_module_1.succeedNow(tsplus_module_12.append_(b, id), fileName_1 + ":1009:52") : tsplus_module_1.failCauseNow(c, fileName_1 + ":1009:84"), () => tsplus_module_1.succeedNow(b, fileName_1 + ":1010:34"), fileName_1 + ":1008:61");
+    } else {
+      return tsplus_module_1.succeedNow(b, fileName_1 + ":1013:33");
+    }
+  }, fileName_1 + ":1006:20"), ids => tsplus_module_12.isNonEmpty(ids) ? tsplus_module_14.update_(queuesRef, map => tsplus_module_41.removeMany_(map, ids)) : tsplus_module_1.unit, fileName_1 + ":1015:19"), fileName_1 + ":1004:30"), fileName_1 + ":1003:30");
+
+  return tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_6.make(() => tsplus_module_41.makeDefault()), ref => tsplus_module_1.flatMap_(tsplus_module_35.get(ref), qs => tsplus_module_1.foreach_(tsplus_module_41.values(qs), q => tsplus_module_25.shutdown(q), fileName_1 + ":1022:43"), fileName_1 + ":1022:24")), queuesRef => tsplus_module_1.map_(tsplus_module_1.flatMap_(tsplus_module_43.atomically(tsplus_module_44.make(1)), queuesLock => tsplus_module_1.flatMap_(tsplus_module_6.make(() => tsplus_module_1.flatMap_(tsplus_module_27.makeBounded(maximumLag), queue => tsplus_module_1.flatMap_(tsplus_module_1.succeed(() => Symbol(), fileName_1 + ":1033:41"), id => tsplus_module_1.map_(tsplus_module_14.update_(queuesRef, map => tsplus_module_41.set_(map, id, queue)), () => tuple(id, queue)), fileName_1 + ":1033:30"), fileName_1 + ":1032:30")), newQueue => {
+    const finalize = endTake => tsplus_module_42.withPermitSelf(queuesLock)(tsplus_module_1.asUnit(tsplus_module_1.flatMap_(tsplus_module_13.set_(newQueue, tsplus_module_1.flatMap_(tsplus_module_27.makeBounded(1), queue => tsplus_module_1.flatMap_(tsplus_module_25.offer_(queue, endTake), () => {
+      const id = Symbol();
+      return tsplus_module_1.map_(tsplus_module_14.update_(queuesRef, map => tsplus_module_41.set_(map, id, queue)), () => tuple(id, queue));
+    }, fileName_1 + ":1045:20"), fileName_1 + ":1044:34")), () => tsplus_module_1.flatMap_(tsplus_module_1.map_(tsplus_module_35.get(queuesRef), map => tsplus_module_41.values(map), fileName_1 + ":1053:53"), queues => tsplus_module_1.flatMap_(tsplus_module_1.foreach_(queues, queue => tsplus_module_1.catchJustCause_(tsplus_module_25.offer_(queue, endTake), c => tsplus_module_15.interrupted(c) ? tsplus_module_3.just(tsplus_module_1.unit) : tsplus_module_3.nothing()), fileName_1 + ":1055:31"), () => tsplus_module_1.map_(done(endTake), () => void 0), fileName_1 + ":1054:20"), fileName_1 + ":1053:35"), fileName_1 + ":1051:23")));
+
+    return tsplus_module_1.map_(tsplus_module_1.fork(tsplus_module_1.matchCauseIO_(runForeachScoped_1(self, offer(queuesRef)), cause => finalize(tsplus_module_37.failCause(tsplus_module_15.map_(cause, tsplus_module_3.just))), () => finalize(tsplus_module_37.fail(tsplus_module_3.nothing())), fileName_1 + ":1067:63")), () => tsplus_module_42.withPermitSelf(queuesLock)(tsplus_module_1.flatten(tsplus_module_35.get(newQueue))));
+  }, fileName_1 + ":1029:29"), fileName_1 + ":1028:29"), add => add, fileName_1 + ":1026:18"), fileName_1 + ":1020:24");
+}
+/**
+ * Converts this stream to a stream that executes its effects but emits no
+ * elements. Useful for sequencing effects using streams.
+ *
+ * @tsplus getter fncts.io.Stream drain
+ */
+
+
+export function drain(fa) {
+  return new Stream(tsplus_module_10.drain(fa.channel));
+}
+
+function dropLoop(r) {
+  return tsplus_module_10.readWith(inp => {
+    const dropped = tsplus_module_12.drop_(inp, r);
+    const leftover = Math.max(0, r - inp.length);
+    const more = tsplus_module_12.isEmpty(inp) || leftover > 0;
+    return more ? dropLoop(leftover) : tsplus_module_11.apSecond_(tsplus_module_10.write(() => dropped), tsplus_module_10.id());
+  }, tsplus_module_10.failNow, () => tsplus_module_10.unit);
+}
+/**
+ * Drops the specified number of elements from this stream.
+ *
+ * @tsplus fluent fncts.io.Stream drop
+ */
+
+
+function drop_1(stream, n) {
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, dropLoop(n)));
+}
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ *
+ * @tsplus fluent fncts.io.Stream dropWhile
+ */
+
+
+function dropWhile_1(stream, p) {
+  return pipeThrough_1(stream, tsplus_module_45.dropWhile(p));
+}
+/**
+ * Drops all elements of the stream until the specified predicate evaluates
+ * to `true`.
+ *
+ * @tsplus fluent fncts.io.Stream dropUntil
+ */
+
+
+export function dropUntil_(stream, p) {
+  return drop_1(dropWhile_1(stream, tsplus_module_46.invert(p)), 1);
+}
+/**
+ * Returns a stream whose failures and successes have been lifted into an
+ * `Either`. The resulting stream cannot fail, because the failures have
+ * been exposed as part of the `Either` success case.
+ *
+ * @note the stream will end as soon as the first error occurs.
+ *
+ * @tsplus getter fncts.io.Stream either
+ */
+
+export function either(stream) {
+  return catchAll_1(map_1(stream, tsplus_module_17.right), e => succeedNow_1(tsplus_module_17.left(e)));
+}
+/**
+ * @tsplus static fncts.io.StreamOps empty
+ */
+
+const empty_1 = /*#__PURE__*/fromChunkNow_1( /*#__PURE__*/tsplus_module_7.empty());
+export const empty = empty_1;
+
+function endWhenWriter(fiber) {
+  return tsplus_module_10.unwrap(tsplus_module_1.map_(tsplus_module_47.poll(fiber), maybeExit => tsplus_module_16.match_(maybeExit, () => tsplus_module_10.readWith(inp => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(inp), endWhenWriter(fiber)), tsplus_module_10.failNow, () => tsplus_module_10.unit), exit => tsplus_module_32.match_(exit, tsplus_module_11.failCauseNow, () => tsplus_module_10.unit)), fileName_1 + ":1155:19"));
+}
+/**
+ * Halts the evaluation of this stream when the provided IO completes. The given IO
+ * will be forked as part of the returned stream, and its success will be discarded.
+ *
+ * An element in the process of being pulled will not be interrupted when the IO
+ * completes. See `interruptWhen` for this behavior.
+ *
+ * If the IO completes with a failure, the stream will emit that failure.
+ *
+ * @tsplus fluent fncts.io.Stream endWhen
+ */
+
+
+export function endWhen_(stream, io) {
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(tsplus_module_21.forkScoped(io), fiber => tsplus_module_10.pipeTo_(stream.channel, endWhenWriter(fiber)), fileName_1 + ":1181:59")));
+}
+/**
+ * @tsplus fluent fncts.io.Stream ensuring
+ */
+
+function ensuring_1(self, finalizer) {
+  return new Stream(tsplus_module_10.ensuring_(self.channel, finalizer));
+}
+/**
+ * @tsplus static fncts.io.StreamOps environment
+ */
+
+
+function environment_1() {
+  return fromIO_1(tsplus_module_48.environment(fileName_1 + ":1195:38"));
+}
+/**
+ * Accesses the environment of the stream.
+ *
+ * @tsplus static fncts.io.StreamOps environmentWith
+ */
+
+
+export function environmentWith(f) {
+  return map_1(environment_1(), f);
+}
+/**
+ * Accesses the environment of the stream in the context of an effect.
+ *
+ * @tsplus static fncts.io.StreamOps environmentWithIO
+ */
+
+export function environmentWithIO(f) {
+  return mapIO_1(environment_1(), f);
+}
+/**
+ * Accesses the environment of the stream in the context of a stream.
+ *
+ * @tsplus static fncts.io.StreamOps environmentWithStream
+ */
+
+export function environmentWithStream(f) {
+  return flatMap_1(environment_1(), f);
+}
+/**
+ * Halt a stream with the specified error
+ *
+ * @tsplus static fncts.io.StreamOps failNow
+ */
+
+function failNow_1(error) {
+  return new Stream(tsplus_module_10.failNow(error));
+}
+/**
+ * Halt a stream with the specified error
+ *
+ * @tsplus static fncts.io.StreamOps fail
+ */
+
+
+export function fail(error) {
+  return new Stream(tsplus_module_10.fail(error));
+}
+/**
+ * The stream that always halts with `cause`.
+ *
+ * @tsplus static fncts.io.StreamOps failCauseNow
+ */
+
+function failCauseNow_1(cause) {
+  return fromIO_1(tsplus_module_1.failCauseNow(cause, fileName_1 + ":1249:39"));
+}
+/**
+ * The stream that always halts with `cause`.
+ *
+ * @tsplus static fncts.io.StreamOps failCause
+ */
+
+
+export function failCause(cause) {
+  return fromIO_1(tsplus_module_1.failCause(cause, fileName_1 + ":1258:36"));
+}
+export function filter_(fa, predicate) {
+  return mapChunks_1(fa, chunk => tsplus_module_12.filter_(chunk, predicate));
+}
+/**
+ * @tsplus fluent fncts.io.Stream filterIO
+ */
+
+export function filterIO_(fa, f) {
+  return loopOnPartialChunksElements_1(fa, (a, emit) => tsplus_module_1.flatMap_(f(a), r => r ? emit(a) : tsplus_module_1.unit, fileName_1 + ":1277:66"));
+}
+/**
+ * @tsplus fluent fncts.io.Stream filterMap
+ */
+
+function filterMap_1(fa, f) {
+  return mapChunks_1(fa, chunk => tsplus_module_12.filterMap_(chunk, f));
+}
+/**
+ * @tsplus fluent fncts.io.Stream filterMapIO
+ */
+
+
+export function filterMapIO_(fa, f) {
+  return loopOnPartialChunksElements_1(fa, (a, emit) => tsplus_module_1.flatMap_(f(a), maybeB => tsplus_module_16.match_(maybeB, () => tsplus_module_1.unit, emit), fileName_1 + ":1294:66"));
+}
+/**
+ * Finds the first element emitted by this stream that satisfies the provided predicate.
+ *
+ * @tsplus fluent fncts.io.Stream find
+ */
+
+export function find_(stream, p) {
+  const loop = tsplus_module_10.readWith(inp => tsplus_module_16.match_(tsplus_module_12.find_(inp, p), () => loop, a => tsplus_module_10.writeNow(tsplus_module_18.single(a))), tsplus_module_10.failNow, () => tsplus_module_10.unit);
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, loop));
+}
+/**
+ * Finds the first element emitted by this stream that satisfies the provided effectful predicate.
+ *
+ * @tsplus fluent fncts.io.Stream findIO
+ */
+
+export function findIO_(stream, f) {
+  const loop = tsplus_module_10.readWith(inp => tsplus_module_10.unwrap(tsplus_module_1.map_(tsplus_module_49.findIO_(inp, f), maybeA => tsplus_module_16.match_(maybeA, () => loop, a => tsplus_module_10.writeNow(tsplus_module_18.single(a))), fileName_1 + ":1327:26")), tsplus_module_10.failNow, () => tsplus_module_10.unit);
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, loop));
+}
+/**
+ * Flattens this stream-of-streams into a stream made of the concatenation in
+ * strict order of all the streams.
+ *
+ * @tsplus getter fncts.io.Stream flatten
+ */
+
+function flatten_1(self) {
+  return flatMap_1(self, identity);
+}
+/**
+ * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
+ *
+ * For `Exit<E, A>` values that do not signal end-of-stream, prefer:
+ *
+ * @tsplus getter fncts.io.Stream flattenExitOption
+ */
+
+
+function flattenExitOption_1(stream) {
+  const processChunk = (chunk, cont) => {
+    const [toEmit, rest] = tsplus_module_12.splitWhere_(chunk, _ => !tsplus_module_50.isSuccess(_));
+    const next = tsplus_module_16.match_(tsplus_module_12.head(rest), () => cont, exit => tsplus_module_32.match_(exit, cause => tsplus_module_16.match_(tsplus_module_15.flipCauseOption(cause), () => tsplus_module_11.endNow(undefined), tsplus_module_11.failCauseNow), () => tsplus_module_11.endNow(undefined)));
+    return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(tsplus_module_12.filterMap_(toEmit, exit => tsplus_module_32.match_(exit, () => tsplus_module_3.nothing(), tsplus_module_3.just))), next);
+  };
+
+  const process = tsplus_module_10.readWithCause(chunk => processChunk(chunk, process), tsplus_module_11.failCauseNow, _ => tsplus_module_11.endNow(undefined));
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, process));
+}
+/**
+ * Unwraps `Exit` values and flatten chunks that also signify end-of-stream by failing with `None`.
+ *
+ * @tsplus getter fncts.io.Stream flattenTake
+ */
+
+
+function flattenTake_1(stream) {
+  return flattenChunks_1(flattenExitOption_1(map_1(stream, take => take.exit)));
+}
+/**
+ * Submerges the chunks carried by this stream into the stream's structure, while
+ * still preserving them.
+ *
+ * @tsplus getter fncts.io.Stream flattenChunks
+ */
+
+
+function flattenChunks_1(stream) {
+  return new Stream(tsplus_module_10.mapOut_(stream.channel, c => tsplus_module_12.flatten(c)));
+}
+/**
+ * Repeats this stream forever.
+ *
+ * @tsplus getter fncts.io.Stream forever
+ */
+
+
+function forever_1(stream) {
+  return new Stream(tsplus_module_10.repeated(stream.channel));
+}
+/**
+ * Creates a stream from a `Chunk` of values
+ *
+ * @tsplus static fncts.io.StreamOps fromChunkNow
+ */
+
+
+function fromChunkNow_1(c) {
+  return new Stream(tsplus_module_10.defer(() => tsplus_module_12.isEmpty(c) ? tsplus_module_10.unit : tsplus_module_10.writeNow(c)));
+}
+/**
+ * Creates a stream from a `Chunk` of values
+ *
+ * @tsplus static fncts.io.StreamOps fromChunk
+ */
+
+
+function fromChunk_1(c) {
+  return new Stream(tsplus_module_10.unwrap(tsplus_module_1.succeedNow(tsplus_module_10.write(c), fileName_1 + ":1427:49")));
+}
+/**
+ * Creates a single-valued stream from a managed resource
+ *
+ * @tsplus static fncts.io.StreamOps scoped
+ */
+
+
+function scoped_1(stream) {
+  return new Stream(tsplus_module_10.scoped(() => tsplus_module_1.map_(stream, tsplus_module_18.single, fileName_1 + ":1436:46")));
+}
+/**
+ * Creates a stream from an effect producing a value of type `A`
+ *
+ * @tsplus static fncts.io.StreamOps fromIO
+ */
+
+
+function fromIO_1(fa) {
+  return fromIOMaybe_1(tsplus_module_1.mapError_(fa, tsplus_module_3.just, fileName_1 + ":1445:40"));
+}
+/**
+ * Creates a stream from an effect producing a value of type `A` or an empty Stream
+ *
+ * @tsplus static fncts.io.StreamOps fromIOMaybe
+ */
+
+
+function fromIOMaybe_1(fa) {
+  return new Stream(tsplus_module_10.unwrap(tsplus_module_1.match_(fa, maybeError => tsplus_module_16.match_(maybeError, () => tsplus_module_10.unit, tsplus_module_10.failNow), a => tsplus_module_10.writeNow(tsplus_module_18.single(a)), fileName_1 + ":1456:15")));
+}
+
+function fromAsyncIterableLoop(iterator) {
+  return tsplus_module_10.unwrap(tsplus_module_1.async(k => {
+    iterator.next().then(result => result.done ? k(tsplus_module_1.succeedNow(tsplus_module_11.end(() => undefined), fileName_1 + ":1473:30")) : k(tsplus_module_1.succeedNow(tsplus_module_11.apSecond_(tsplus_module_10.writeNow(tsplus_module_18.single(result.value)), fromAsyncIterableLoop(iterator)), fileName_1 + ":1474:30")));
+  }));
+}
+/**
+ * @tsplus static fncts.io.StreamOps fromAsyncIterable
+ */
+
+
+export function fromAsyncIterable(iterable) {
+  return new Stream(fromAsyncIterableLoop(iterable[Symbol.asyncIterator]()));
+}
+/**
+ * @tsplus static fncts.io.StreamOps fromIterable
+ */
+
+export function fromIterable(iterable, maxChunkSize = DEFAULT_CHUNK_SIZE) {
+  return unwrap_1(tsplus_module_1.succeed(() => {
+    const loop = iterator => tsplus_module_10.unwrap(tsplus_module_1.succeed(() => {
+      let result = iterator.next();
+
+      if (result.done) {
+        return tsplus_module_10.unit;
+      }
+
+      if (maxChunkSize === 1) {
+        return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(tsplus_module_18.single(result.value)), loop(iterator));
+      } else {
+        const out = Array(maxChunkSize);
+        out[0] = result.value;
+        let count = 1;
+
+        while (count < maxChunkSize && !(result = iterator.next()).done) {
+          out[count] = result.value;
+          count++;
+        }
+
+        return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(tsplus_module_18.from(out)), loop(iterator));
+      }
+    }, fileName_1 + ":1495:21"));
+
+    return new Stream(loop(iterable[Symbol.iterator]()));
+  }, fileName_1 + ":1492:15"));
+}
+/**
+ * @tsplus static fncts.io.StreamOps fromIterableSingle
+ */
+
+export function fromIterableSingle(iterable) {
+  return flatMap_1(fromIO_1(tsplus_module_1.succeed(() => iterable[Symbol.iterator](), fileName_1 + ":1523:34")), iterator => repeatIOMaybe_1(tsplus_module_1.defer(() => {
+    const value = iterator.next();
+
+    if (value.done) {
+      return tsplus_module_1.failNow(tsplus_module_3.nothing(), fileName_1 + ":1528:28");
+    } else {
+      return tsplus_module_1.succeedNow(value.value, fileName_1 + ":1530:31");
+    }
+  }, fileName_1 + ":1525:15")));
+}
+/**
+ * @tsplus static fncts.io.StreamOps fromPull
+ */
+
+function fromPull_1(scopedPull) {
+  return unwrapScoped_1(tsplus_module_1.map_(scopedPull, pull => repeatIOChunkMaybe_1(pull), fileName_1 + ":1541:44"));
+}
+/**
+ * Creates a stream from a `Queue` of values
+ *
+ * @tsplus static fncts.io.StreamOps fromQueue
+ */
+
+
+function fromQueue_1(queue, maxChunkSize = DEFAULT_CHUNK_SIZE) {
+  return repeatIOChunkMaybe_1(tsplus_module_1.catchAllCause_(tsplus_module_1.map_(tsplus_module_52.takeBetween_(queue, 1, maxChunkSize), tsplus_module_18.from, fileName_1 + ":1556:11"), c => tsplus_module_1.flatMap_(tsplus_module_25.isShutdown(queue), down => {
+    if (down && tsplus_module_15.interrupted(c)) {
+      return tsplus_module_51.end;
+    } else {
+      return tsplus_module_51.failCause(c);
+    }
+  }, fileName_1 + ":1558:33"), fileName_1 + ":1557:21"));
+}
+/**
+ * @tsplus static fncts.io.StreamOps fromQueueWithShutdown
+ */
+
+
+function fromQueueWithShutdown_1(queue, maxChunkSize = DEFAULT_CHUNK_SIZE) {
+  return ensuring_1(fromQueue_1(queue, maxChunkSize), tsplus_module_25.shutdown(queue));
+}
+/**
+ * Halt a stream with the specified exception
+ *
+ * @tsplus static fncts.io.StreamOps haltNow
+ */
+
+
+export function haltNow(u) {
+  return new Stream(tsplus_module_10.halt(() => u));
+}
+/**
+ * Halt a stream with the specified exception
+ *
+ * @tsplus static fncts.io.StreamOps halt
+ */
+
+function halt_1(u) {
+  return new Stream(tsplus_module_10.halt(u));
+}
+
+function haltWhenWriter(fiber) {
+  return tsplus_module_10.unwrap(tsplus_module_1.map_(tsplus_module_47.poll(fiber), maybeExit => tsplus_module_16.match_(maybeExit, () => tsplus_module_10.readWith(i => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(i), haltWhenWriter(fiber)), tsplus_module_10.failNow, () => tsplus_module_10.unit), exit => tsplus_module_32.match_(exit, tsplus_module_11.failCauseNow, () => tsplus_module_10.unit)), fileName_1 + ":1601:19"));
+}
+/**
+ * Halts the evaluation of this stream when the provided IO completes. The
+ * given IO will be forked as part of the returned stream, and its success
+ * will be discarded.
+ *
+ * An element in the process of being pulled will not be interrupted when the
+ * IO completes. See `interruptWhen` for this behavior.
+ *
+ * If the IO completes with a failure, the stream will emit that failure.
+ *
+ * @tsplus fluent fncts.io.Stream haltWhen
+ */
+
+
+export function haltWhen_(fa, io) {
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(tsplus_module_21.forkScoped(io), fiber => tsplus_module_10.pipeTo_(fa.channel, haltWhenWriter(fiber)), fileName_1 + ":1628:59")));
+}
+
+function haltWhenFutureWriter(future) {
+  return tsplus_module_10.unwrap(tsplus_module_1.map_(tsplus_module_33.poll(future), maybeIO => tsplus_module_16.match_(maybeIO, () => tsplus_module_10.readWith(i => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(i), haltWhenFutureWriter(future)), tsplus_module_10.failNow, () => tsplus_module_10.unit), io => tsplus_module_10.unwrap(tsplus_module_1.match_(io, tsplus_module_10.failNow, () => tsplus_module_10.unit, fileName_1 + ":1643:40"))), fileName_1 + ":1635:20"));
+}
+/**
+ * Halts the evaluation of this stream when the provided promise resolves.
+ *
+ * If the promise completes with a failure, the stream will emit that failure.
+ *
+ * @tsplus fluent fncts.io.Stream haltWhen
+ */
+
+
+export function haltWhenFuture_(fa, future) {
+  return new Stream(tsplus_module_10.pipeTo_(fa.channel, haltWhenFutureWriter(future)));
+}
+/**
+ * @tsplus fluent fncts.io.Stream interleave
+ */
+
+export function interleave_(sa, sb) {
+  return interleaveWith_1(sa, sb, forever_1(fromChunk_1(() => tsplus_module_18.make(true, false))));
+}
+
+function interleaveWithProducer(handoff) {
+  return tsplus_module_10.readWithCause(value => tsplus_module_11.apSecond_(tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_24.single(value))), interleaveWithProducer(handoff)), cause => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_24.failCause(cause))), () => tsplus_module_10.fromIO(tsplus_module_5.offer(handoff, tsplus_module_24.end)));
+}
+/**
+ * Combines this stream and the specified stream deterministically using the
+ * stream of boolean values `b` to control which stream to pull from next.
+ * `true` indicates to pull from this stream and `false` indicates to pull
+ * from the specified stream. Only consumes as many elements as requested by
+ * `b`. If either this stream or the specified stream are exhausted further
+ * requests for values from that stream will be ignored.
+ *
+ * @tsplus fluent fncts.io.Stream interleaveWith
+ */
+
+
+function interleaveWith_1(sa, sb, b) {
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(tsplus_module_1.flatMap_(tsplus_module_5.make(), left => tsplus_module_1.flatMap_(tsplus_module_5.make(), right => tsplus_module_1.flatMap_(tsplus_module_1.fork(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(tsplus_module_10.concatMap_(sa.channel, tsplus_module_10.writeChunk), interleaveWithProducer(left)))), () => tsplus_module_1.map_(tsplus_module_1.fork(tsplus_module_23.runScoped(tsplus_module_10.pipeTo_(tsplus_module_10.concatMap_(sb.channel, tsplus_module_10.writeChunk), interleaveWithProducer(right)))), () => tuple(left, right)), fileName_1 + ":1698:10"), fileName_1 + ":1697:24"), fileName_1 + ":1696:24"), ([left, right]) => {
+    const process = (leftDone, rightDone) => tsplus_module_10.readWithCause(b => {
+      if (b && !leftDone) {
+        return tsplus_module_11.flatMap_(tsplus_module_10.fromIO(tsplus_module_5.take(left)), take => tsplus_module_24.match_(take, rightDone ? tsplus_module_10.unit : process(true, rightDone), tsplus_module_11.failCauseNow, chunk => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(chunk), process(leftDone, rightDone))));
+      }
+
+      if (!b && !rightDone) {
+        return tsplus_module_11.flatMap_(tsplus_module_10.fromIO(tsplus_module_5.take(right)), take => tsplus_module_24.match_(take, leftDone ? tsplus_module_10.unit : process(leftDone, true), tsplus_module_11.failCauseNow, chunk => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(chunk), process(leftDone, rightDone))));
+      }
+
+      return process(leftDone, rightDone);
+    }, tsplus_module_11.failCauseNow, () => tsplus_module_10.unit);
+
+    return tsplus_module_10.pipeTo_(tsplus_module_10.concatMap_(b.channel, tsplus_module_10.writeChunk), process(false, false));
+  }, fileName_1 + ":1701:13")));
+}
+
+function intersperseWriter(middle, isFirst) {
+  return tsplus_module_10.readWith(inp => {
+    const builder = tsplus_module_12.builder();
+    let flagResult = isFirst;
+    tsplus_module_12.forEach_(inp, a => {
+      if (flagResult) {
+        flagResult = false;
+        builder.append(a);
+      } else {
+        builder.append(middle);
+        builder.append(a);
+      }
+    });
+    return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(builder.result()), intersperseWriter(middle, flagResult));
+  }, tsplus_module_10.failNow, () => tsplus_module_10.unit);
+}
+/**
+ * Intersperse stream with provided element
+ */
+
+
+export function intersperse_(stream, middle) {
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, intersperseWriter(middle, true)));
+}
+/**
+ * Interrupts the evaluation of this stream when the provided IO completes. The given
+ * IO will be forked as part of this stream, and its success will be discarded. This
+ * combinator will also interrupt any in-progress element being pulled from upstream.
+ *
+ * If the IO completes with a failure before the stream completes, the returned stream
+ * will emit that failure.
+ *
+ * @tsplus fluent fncts.io.Stream interruptWhen
+ */
+
+export function interruptWhen_(stream, io) {
+  return new Stream(tsplus_module_53.interruptWhen_(stream.channel, io));
+}
+/**
+ * @tsplus fluent fncts.io.Stream interruptWhen
+ */
+
+export function interruptWhenFuture_(fa, future) {
+  return new Stream(tsplus_module_53.interruptWhenFuture_(fa.channel, future));
+}
+/**
+ * Loops over the stream chunks concatenating the result of f
+ *
+ * @tsplus fluent fncts.io.Stream loopOnChunks
+ */
+
+function loopOnChunks_1(stream, f) {
+  const loop = tsplus_module_10.readWithCause(chunk => tsplus_module_11.flatMap_(f(chunk), cont => cont ? loop : tsplus_module_11.endNow(false)), tsplus_module_11.failCauseNow, _ => tsplus_module_11.succeedNow(false));
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, loop));
+}
+/**
+ * Loops on chunks emitting partially
+ *
+ * @tsplus fluent fncts.io.Stream loopOnPartialChunks
+ */
+
+
+function loopOnPartialChunks_1(stream, f) {
+  return loopOnChunks_1(stream, chunk => tsplus_module_10.unwrap(tsplus_module_1.defer(() => {
+    let outputChunk = tsplus_module_7.empty();
+    return tsplus_module_1.catchAll_(tsplus_module_1.map_(f(chunk, a => tsplus_module_1.succeed(() => {
+      outputChunk = tsplus_module_12.append_(outputChunk, a);
+    }, fileName_1 + ":1822:21")), cont => tsplus_module_11.apSecond_(tsplus_module_10.write(() => outputChunk), tsplus_module_11.endNow(cont)), fileName_1 + ":1826:15"), failure => tsplus_module_1.succeed(() => {
+      if (tsplus_module_12.isEmpty(outputChunk)) {
+        return tsplus_module_10.failNow(failure);
+      } else {
+        return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(outputChunk), tsplus_module_10.failNow(failure));
+      }
+    }, fileName_1 + ":1828:23"), fileName_1 + ":1827:20");
+  }, fileName_1 + ":1819:15")));
+}
+/**
+ * Loops on chunks elements emitting partially
+ *
+ * @tsplus fluent fncts.io.Stream loopOnPartialChunksElements
+ */
+
+
+function loopOnPartialChunksElements_1(stream, f) {
+  return loopOnPartialChunks_1(stream, (as, emit) => tsplus_module_1.as_(tsplus_module_54.mapIO_(as, a => f(a, emit)), () => true));
+}
+/**
+ * Transforms the elements of this stream using the supplied function.
+ *
+ * @tsplus fluent fncts.io.Stream map
+ */
+
+
+function map_1(stream, f) {
+  return new Stream(tsplus_module_10.mapOut_(stream.channel, as => tsplus_module_12.map_(as, f)));
+}
+
+function mapAccumAccumulator(currS, f) {
+  return tsplus_module_10.readWith(inp => {
+    const [bs, nextS] = tsplus_module_12.mapAccum_(inp, currS, f);
+    return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(bs), mapAccumAccumulator(nextS, f));
+  }, tsplus_module_10.failNow, () => tsplus_module_10.unit);
+}
+/**
+ * Statefully maps over the elements of this stream to produce new elements.
+ *
+ * @tsplus fluent fncts.io.Stream mapAccum
+ */
+
+
+export function mapAccum_(stream, s, f) {
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, mapAccumAccumulator(s, f)));
+}
+
+function mapAccumIOAccumulator(s, f) {
+  return tsplus_module_10.readWith(inp => tsplus_module_10.unwrap(tsplus_module_1.defer(() => {
+    const outputChunk = tsplus_module_12.builder();
+
+    const emit = b => tsplus_module_1.succeed(() => {
+      outputChunk.append(b);
+    }, fileName_1 + ":1899:23");
+
+    return tsplus_module_1.match_(tsplus_module_1.foldLeft_(inp, s, (s1, a) => tsplus_module_1.flatMap_(f(s1, a), ([b, s2]) => tsplus_module_1.as_(emit(b), () => s2), fileName_1 + ":1902:65"), fileName_1 + ":1902:29"), e => {
+      const partialResult = outputChunk.result();
+      return tsplus_module_12.isNonEmpty(partialResult) ? tsplus_module_11.apSecond_(tsplus_module_10.writeNow(partialResult), tsplus_module_10.failNow(e)) : tsplus_module_10.failNow(e);
+    }, s => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(outputChunk.result()), mapAccumIOAccumulator(s, f)), fileName_1 + ":1902:101");
+  }, fileName_1 + ":1896:17")), tsplus_module_10.failNow, () => tsplus_module_10.unit);
+}
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * new elements.
+ *
+ * @tsplus fluent fncts.io.Stream mapAccumIO
+ */
+
+
+function mapAccumIO_1(stream, s, f) {
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, mapAccumIOAccumulator(s, f)));
+}
+/**
+ * Transforms the chunks emitted by this stream.
+ *
+ * @tsplus fluent fncts.io.Stream mapChunks
+ */
+
+
+function mapChunks_1(stream, f) {
+  return new Stream(tsplus_module_10.mapOut_(stream.channel, f));
+}
+/**
+ * Effectfully transforms the chunks emitted by this stream.
+ *
+ * @tsplus fluent fncts.io.Stream mapChunksIO
+ */
+
+
+export function mapChunksIO_(stream, f) {
+  return new Stream(tsplus_module_10.mapOutIO_(stream.channel, f));
+}
+/**
+ * Maps each element to an iterable, and flattens the iterables into the
+ * output of this stream.
+ *
+ * @tsplus fluent fncts.io.Stream mapConcat
+ */
+
+export function mapConcat_(stream, f) {
+  return mapConcatChunk_1(stream, a => tsplus_module_18.from(f(a)));
+}
+/**
+ * Maps each element to a chunk, and flattens the chunks into the output of
+ * this stream.
+ *
+ * @tsplus fluent fncts.io.Stream mapConcatChunk
+ */
+
+function mapConcatChunk_1(stream, f) {
+  return mapChunks_1(stream, c => tsplus_module_12.flatMap_(c, f));
+}
+/**
+ * Effectfully maps each element to a chunk, and flattens the chunks into
+ * the output of this stream.
+ *
+ * @tsplus fluent fncts.io.Stream mapConcatChunkIO
+ */
+
+
+export function mapConcatChunkIO_(stream, f) {
+  return mapConcatChunk_1(mapIO_1(stream, f), identity);
+}
+/**
+ * Effectfully maps each element to an iterable, and flattens the iterables into
+ * the output of this stream.
+ *
+ * @tsplus fluent fncts.io.Stream mapConcatIO
+ */
+
+export function mapConcatIO_(stream, f) {
+  return mapConcatChunk_1(mapIO_1(stream, a => tsplus_module_1.map_(f(a), tsplus_module_18.from, fileName_1 + ":1996:38")), identity);
+}
+/**
+ * Transforms the errors emitted by this stream using `f`.
+ *
+ * @tsplus fluent fncts.io.Stream mapError
+ */
+
+function mapError_1(stream, f) {
+  return new Stream(tsplus_module_10.mapError_(stream.channel, f));
+}
+/**
+ * Transforms the full causes of failures emitted by this stream.
+ *
+ * @tsplus fluent fncts.io.Stream mapErrorCause
+ */
+
+
+export function mapErrorCause_(fa, f) {
+  return new Stream(tsplus_module_10.mapErrorCause_(fa.channel, f));
+}
+/**
+ * Maps over elements of the stream with the specified effectful function.
+ *
+ * @tsplus fluent fncts.io.Stream mapIO
+ */
+
+function mapIO_1(stream, f) {
+  return loopOnPartialChunksElements_1(stream, (a, emit) => tsplus_module_1.flatMap_(f(a), emit, fileName_1 + ":2026:70"));
+}
+/**
+ * Maps over elements of the stream with the specified effectful function,
+ * executing up to `n` invocations of `f` concurrently. Transformed elements
+ * will be emitted in the original order.
+ *
+ * @note This combinator destroys the chunking structure. It's recommended to use chunkN afterwards.
+ *
+ * @tsplus fluent fncts.io.Stream mapIOC
+ */
+
+
+export function mapIOC_(stream, n, f) {
+  return new Stream(tsplus_module_10.mapOut_(tsplus_module_55.mapOutIOC_(tsplus_module_10.concatMap_(stream.channel, tsplus_module_10.writeChunk), n, f), tsplus_module_18.single));
+}
+/**
+ * Maps each element of this stream to another stream and returns the
+ * non-deterministic merge of those streams, executing up to `n` inner streams
+ * concurrently. Up to `bufferSize` elements of the produced streams may be
+ * buffered in memory by this operator.
+ *
+ * @tsplus fluent fncts.io.Stream mergeMap
+ */
+
+function mergeMap_1(ma, f, n, bufferSize = 16) {
+  return new Stream(tsplus_module_56.mergeMap_(tsplus_module_10.concatMap_(ma.channel, tsplus_module_10.writeChunk), a => f(a).channel, n, bufferSize));
+}
+/**
+ * Maps over elements of the stream with the specified effectful function,
+ * executing up to `n` invocations of `f` concurrently. The element order
+ * is not enforced by this combinator, and elements may be reordered.
+ *
+ * @tsplus fluent fncts.io.Stream mergeMapIO
+ */
+
+
+export function mergeMapIO_(stream, f, n, bufferSize = 16) {
+  return mergeMap_1(stream, a => fromIO_1(f(a)), n, bufferSize);
+}
+/**
+ * @tsplus fluent fncts.io.Stream mergeEither
+ */
+
+function mergeEither_1(fa, fb) {
+  return mergeWith_1(fa, fb, tsplus_module_17.left, tsplus_module_17.right);
+}
+
+export function mergeWithHandler(terminate) {
+  return exit => terminate || !tsplus_module_50.isSuccess(exit) ? tsplus_module_57.done(tsplus_module_1.fromExitNow(exit, fileName_1 + ":2093:71")) : tsplus_module_57.wait(tsplus_module_1.fromExitNow);
+}
+/**
+ * @tsplus fluent fncts.io.Stream mergeWith
+ */
+
+function mergeWith_1(sa, sb, l, r, strategy = "Both") {
+  return new Stream(tsplus_module_58.mergeWith_(map_1(sa, l).channel, map_1(sb, r).channel, mergeWithHandler(strategy === "Either" || strategy === "Left"), mergeWithHandler(strategy === "Either" || strategy === "Right")));
+}
+/**
+ * Runs the specified effect if this stream fails, providing the error to the effect if it exists.
+ *
+ * Note: Unlike `IO.onError`, there is no guarantee that the provided effect will not be interrupted.
+ *
+ * @tsplus fluent fncts.io.Stream onError
+ */
+
+
+export function onError_(stream, cleanup) {
+  return catchAllCause_1(stream, cause => fromIO_1(tsplus_module_1.apSecond_(cleanup(cause), tsplus_module_1.failCauseNow(cause, fileName_1 + ":2130:88"), fileName_1 + ":2130:72")));
+}
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also Stream#catchAll
+ *
+ * @tsplus fluent fncts.io.Stream orElse
+ */
+
+function orElse_1(stream, that) {
+  return new Stream(tsplus_module_10.orElse_(stream.channel, that().channel));
+}
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also ZStream#catchAll
+ *
+ * @tsplus fluent fncts.io.Stream orElseEither
+ */
+
+
+export function orElseEither_(stream, that) {
+  return orElse_1(map_1(stream, tsplus_module_17.left), () => map_1(that(), tsplus_module_17.right));
+}
+/**
+ * Fails with given error in case this one fails with a typed error.
+ *
+ * See also Stream#catchAll
+ *
+ * @tsplus fluent fncts.io.Stream orElseFail
+ */
+
+export function orElseFail_(stream, e) {
+  return orElse_1(stream, () => failNow_1(e()));
+}
+/**
+ * Switches to the provided stream in case this one fails with the `None` value.
+ *
+ * See also Stream#catchAll.
+ */
+
+export function orElseOptional_(stream, that) {
+  return catchAll_1(stream, maybeError => tsplus_module_16.match_(maybeError, () => that(), e => failNow_1(tsplus_module_3.just(e))));
+}
+/**
+ * Succeeds with the specified value if this one fails with a typed error.
+ *
+ * @tsplus fluent fncts.io.Stream orElseSucceed
+ */
+
+export function orElseSucceed_(stream, a) {
+  return orElse_1(stream, () => succeedNow_1(a()));
+}
+/**
+ * @tsplus fluent fncts.io.Stream pipeThrough
+ */
+
+function pipeThrough_1(ma, sa) {
+  return new Stream(tsplus_module_10.pipeToOrFail_(ma.channel, sa.channel));
+}
+/**
+ * Provides the stream with its required environment, which eliminates
+ * its dependency on `R`.
+ *
+ * @tsplus fluent fncts.io.Stream provideEnvironment
+ */
+
+
+function provideEnvironment_1(ra, r) {
+  return new Stream(tsplus_module_10.provideEnvironment_(ra.channel, r));
+}
+/**
+ * @tsplus fluent fncts.io.Stream provideLayer
+ */
+
+
+function provideLayer_1(self, layer, __tsplusTrace) {
+  return new Stream(tsplus_module_10.unwrapScoped(tsplus_module_1.map_(tsplus_module_59.build(layer), r => tsplus_module_10.provideEnvironment_(self.channel, r), __tsplusTrace)));
+}
+/**
+ * @tsplus fluent fncts.io.Stream provideSomeLayer
+ */
+
+
+export function provideSomeLayer_(self, layer, __tsplusTrace) {
+  // @ts-expect-error
+  return provideLayer_1(self, tsplus_module_60.and_(tsplus_module_60.environment(), layer), __tsplusTrace);
+}
+
+class Rechunker {
+  constructor(n) {
+    this.n = n;
+    this.builder = [];
+    this.pos = 0;
+  }
+
+  write(elem) {
+    this.builder.push(elem);
+    this.pos += 1;
+
+    if (this.pos === this.n) {
+      const result = this.builder;
+      this.builder = [];
+      this.pos = 0;
+      return tsplus_module_18.from(result);
+    }
+
+    return null;
+  }
+
+  emitOfNotEmpty() {
+    if (this.pos !== 0) {
+      return tsplus_module_10.writeNow(tsplus_module_18.from(this.builder));
+    } else {
+      return tsplus_module_10.unit;
+    }
+  }
+
+  get isEmpty() {
+    return this.pos === 0;
+  }
+
+}
+
+function rechunkProcess(rechunker, target) {
+  return tsplus_module_10.readWithCause(chunk => {
+    if (chunk.length === target && rechunker.isEmpty) {
+      return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(chunk), rechunkProcess(rechunker, target));
+    } else if (chunk.length > 0) {
+      const chunks = [];
+      let result = null;
+      let i = 0;
+
+      while (i < chunk.length) {
+        while (i < chunk.length && result === null) {
+          result = rechunker.write(tsplus_module_12.unsafeGet_(chunk, i));
+          i += 1;
+        }
+
+        if (result !== null) {
+          chunks.push(result);
+          result = null;
+        }
+      }
+
+      return tsplus_module_11.apSecond_(tsplus_module_10.writeAll(chunks), rechunkProcess(rechunker, target));
+    } else {
+      return rechunkProcess(rechunker, target);
+    }
+  }, cause => tsplus_module_11.apSecond_(rechunker.emitOfNotEmpty(), tsplus_module_11.failCauseNow(cause)), () => rechunker.emitOfNotEmpty());
+}
+/**
+ * Re-chunks the elements of the stream into chunks of
+ * `n` elements each.
+ * The last chunk might contain less than `n` elements
+ *
+ * @tsplus fluent fncts.io.Stream rechunk
+ */
+
+
+export function rechunk_(stream, n) {
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, rechunkProcess(new Rechunker(n), n)));
+}
+/**
+ * Repeats the provided value infinitely.
+ *
+ * @tsplus static fncts.io.StreamOps repeatValue
+ */
+
+export function repeatValue(a) {
+  return new Stream(tsplus_module_10.repeated(tsplus_module_10.writeNow(tsplus_module_18.single(a))));
+}
+/**
+ * Creates a stream from an effect producing a value of type `A` which repeats forever.
+ *
+ * @tsplus static fncts.io.StreamOps repeatIO
+ */
+
+export function repeatIO(fa) {
+  return repeatIOMaybe_1(tsplus_module_1.mapError_(fa, tsplus_module_3.just, fileName_1 + ":2335:42"));
+}
+/**
+ * Creates a stream from an effect producing values of type `A` until it fails with None.
+ *
+ * @tsplus static fncts.io.StreamOps repeatIOMaybe
+ */
+
+function repeatIOMaybe_1(fa) {
+  return repeatIOChunkMaybe_1(tsplus_module_1.map_(fa, tsplus_module_18.single, fileName_1 + ":2344:35"));
+}
+/**
+ * Creates a stream from an effect producing chunks of `A` values which repeats forever.
+ *
+ * @tsplus static fncts.io.StreamOps repeatIOChunk
+ */
+
+
+export function repeatIOChunk(fa) {
+  return repeatIOChunkMaybe_1(tsplus_module_1.mapError_(fa, tsplus_module_3.just, fileName_1 + ":2353:40"));
+}
+/**
+ * Creates a stream from an effect producing chunks of `A` values until it fails with None.
+ *
+ * @tsplus static fncts.io.StreamOps repeatIOChunkMaybe
+ */
+
+function repeatIOChunkMaybe_1(fa) {
+  return unfoldChunkIO_1(undefined, _ => tsplus_module_1.catchAll_(tsplus_module_1.map_(fa, chunk => tsplus_module_3.just(tuple(chunk, undefined)), fileName_1 + ":2364:11"), maybeError => tsplus_module_16.match_(maybeError, () => tsplus_module_1.succeedNow(tsplus_module_3.nothing(), fileName_1 + ":2365:69"), tsplus_module_1.failNow), fileName_1 + ":2365:16"));
+}
+/**
+ * Runs the sink on the stream to produce either the sink's result or an error.
+ *
+ * @tsplus fluent fncts.io.Stream run
+ */
+
+
+function run_1(stream, sink) {
+  return tsplus_module_61.runDrain(tsplus_module_10.pipeToOrFail_(stream.channel, sink.channel));
+}
+/**
+ * Runs the stream and collects all of its elements to a chunk.
+ *
+ * @tsplus getter fncts.io.Stream runCollect
+ */
+
+
+export function runCollect(stream) {
+  return run_1(stream, tsplus_module_45.collectAll());
+}
+/**
+ * Runs the stream and collects ignore its elements.
+ *
+ * @tsplus getter fncts.io.Stream runDrain
+ */
+
+export function runDrain(stream) {
+  return run_1(stream, tsplus_module_45.drain);
+}
+/**
+ * @tsplus fluent fncts.io.Stream runForeachScoped
+ */
+
+function runForeachScoped_1(self, f) {
+  return runScoped_1(self, tsplus_module_45.foreach(f));
+}
+/**
+ * Like `into`, but provides the result as a `Managed` to allow for scope
+ * composition.
+ *
+ * @tsplus fluent fncts.io.Stream runIntoElementsScoped
+ */
+
+
+function runIntoElementsScoped_1(stream, queue) {
+  const writer = tsplus_module_10.readWith(inp => tsplus_module_11.apSecond_(tsplus_module_12.foldLeft_(inp, tsplus_module_10.unit, (channel, a) => tsplus_module_11.apSecond_(channel, tsplus_module_10.writeNow(tsplus_module_37.succeed(a)))), writer), err => tsplus_module_10.writeNow(tsplus_module_37.fail(tsplus_module_3.just(err))), () => tsplus_module_10.writeNow(tsplus_module_37.fail(tsplus_module_3.nothing())));
+  return tsplus_module_1.asUnit(tsplus_module_23.runScoped(tsplus_module_10.drain(tsplus_module_10.mapOutIO_(tsplus_module_10.pipeTo_(stream.channel, writer), exit => tsplus_module_25.offer_(queue, exit)))));
+}
+/**
+ * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
+ * composition.
+ *
+ * @tsplus fluent fncts.io.Stream runIntoQueueScoped
+ */
+
+
+function runIntoQueueScoped_1(stream, queue) {
+  const writer = tsplus_module_10.readWithCause(inp => tsplus_module_11.apSecond_(tsplus_module_10.writeNow(tsplus_module_24.chunk(inp)), writer), cause => tsplus_module_10.writeNow(tsplus_module_24.failCause(cause)), _ => tsplus_module_10.writeNow(tsplus_module_24.end));
+  return tsplus_module_1.asUnit(tsplus_module_23.runScoped(tsplus_module_10.drain(tsplus_module_10.mapOutIO_(tsplus_module_10.pipeTo_(stream.channel, writer), take => tsplus_module_25.offer_(queue, take)))));
+}
+/**
+ * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
+ * composition.
+ *
+ * @tsplus fluent fncts.io.Stream runIntoHubScoped
+ */
+
+
+function runIntoHubScoped_1(stream, hub) {
+  return runIntoQueueScoped_1(stream, tsplus_module_30.toQueue(hub));
+}
+/**
+ * Runs the sink on the stream to produce either the sink's result or an error.
+ *
+ * @tsplus fluent fncts.io.Stream runScoped
+ */
+
+
+function runScoped_1(stream, sink) {
+  return tsplus_module_23.runScoped(tsplus_module_10.drain(tsplus_module_10.pipeToOrFail_(stream.channel, sink.channel)));
+}
+/**
+ * Statefully maps over the elements of this stream to produce all intermediate results
+ * of type `B` given an initial B.
+ *
+ * @tsplus fluent fncts.io.Stream scan
+ */
+
+
+export function scan_(sa, b, f) {
+  return scanIO_1(sa, b, (b, a) => tsplus_module_1.succeedNow(f(b, a), fileName_1 + ":2484:46"));
+}
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce all
+ * intermediate results of type `B` given an initial B.
+ *
+ * @tsplus fluent fncts.io.Stream scanIO
+ */
+
+function scanIO_1(sa, b, f) {
+  return concat_1(succeedNow_1(b), mapAccumIO_1(sa, b, (b, a) => tsplus_module_1.map_(f(b, a), b => [b, b], fileName_1 + ":2498:76")));
+}
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results.
+ *
+ * @tsplus fluent fncts.io.Stream scanReduce
+ */
+
+
+export function scanReduce_(fa, f) {
+  return scanReduceIO_1(fa, (b, a) => tsplus_module_1.succeedNow(f(b, a), fileName_1 + ":2508:49"));
+}
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results.
+ *
+ * @tsplus fluent fncts.io.Stream scanReduceIO
+ */
+
+function scanReduceIO_1(fa, f) {
+  return mapAccumIO_1(fa, tsplus_module_3.nothing(), (s, a) => tsplus_module_16.match_(s, () => tsplus_module_1.succeedNow([a, tsplus_module_3.just(a)], fileName_1 + ":2523:26"), b => tsplus_module_1.map_(f(b, a), b => [b, tsplus_module_3.just(b)], fileName_1 + ":2524:25")));
+}
+/**
+ * Creates a single-valued pure stream
+ *
+ * @tsplus static fncts.io.StreamOps succeedNow
+ */
+
+
+function succeedNow_1(o) {
+  return fromChunkNow_1(tsplus_module_18.single(o));
+}
+/**
+ * Creates a single-valued pure stream
+ *
+ * @tsplus static fncts.io.StreamOps succeed
+ */
+
+
+export function succeed(a) {
+  return fromChunk_1(() => tsplus_module_18.single(a()));
+}
+
+function takeLoop(n) {
+  return tsplus_module_10.readWithCause(inp => {
+    const taken = tsplus_module_12.take_(inp, n);
+    const left = Math.max(n - taken.length, 0);
+
+    if (left > 0) {
+      return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(taken), takeLoop(left));
+    } else {
+      return tsplus_module_10.writeNow(taken);
+    }
+  }, tsplus_module_11.failCauseNow, tsplus_module_11.endNow);
+}
+/**
+ * Takes the specified number of elements from this stream.
+ *
+ * @tsplus fluent fncts.io.Stream take
+ */
+
+
+export function take_(stream, n) {
+  if (n <= 0) {
+    return empty_1;
+  }
+
+  if (!Number.isInteger(n)) {
+    return halt_1(() => new tsplus_module_62.IllegalArgumentError(`${n} should be an integer`, "Stream.take"));
+  }
+
+  return new Stream(tsplus_module_10.pipeTo_(stream.channel, takeLoop(n)));
+}
+/**
+ * @tsplus fluent fncts.io.Stream takeUntilIO
+ */
+
+export function takeUntilIO_(ma, f) {
+  return loopOnPartialChunks_1(ma, (chunk, emit) => tsplus_module_1.map_(tsplus_module_63.takeWhileIO_(chunk, v => tsplus_module_1.apSecond_(emit(v), tsplus_module_1.map_(f(v), b => !b, fileName_1 + ":2587:52"), fileName_1 + ":2587:43")), taken => tsplus_module_12.isEmpty(tsplus_module_12.take_(tsplus_module_12.drop_(taken, taken.length), 1)), fileName_1 + ":2588:11"));
+}
+
+function takeUntilLoop(p) {
+  return tsplus_module_10.readWith(chunk => {
+    const taken = tsplus_module_12.takeWhile_(chunk, tsplus_module_46.invert(p));
+    const last = tsplus_module_12.take_(tsplus_module_12.drop_(chunk, taken.length), 1);
+
+    if (tsplus_module_12.isEmpty(last)) {
+      return tsplus_module_11.apSecond_(tsplus_module_10.writeNow(taken), takeUntilLoop(p));
+    } else {
+      return tsplus_module_10.writeNow(tsplus_module_12.concat_(taken, last));
+    }
+  }, tsplus_module_10.failNow, tsplus_module_11.succeedNow);
+}
+/**
+ * Takes all elements of the stream until the specified predicate evaluates
+ * to `true`.
+ *
+ * @tsplus fluent fncts.io.Stream takeUntil
+ */
+
+
+export function takeUntil_(fa, p) {
+  return new Stream(tsplus_module_10.pipeTo_(fa.channel, takeUntilLoop(p)));
+}
+/**
+ * @tsplus fluent fncts.io.Stream tap
+ */
+
+export function tap_(ma, f) {
+  return mapIO_1(ma, a => tsplus_module_1.as_(f(a), () => a));
+}
+/**
+ * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
+ * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
+ * tokens up to a `units + burst` threshold. Chunks that do not meet the bandwidth constraints are dropped.
+ * The weight of each chunk is determined by the `costFn` function.
+ *
+ * @tsplus fluent fncts.io.Stream throttleEnforce
+ */
+
+export function throttleEnforce_(sa, costFn, units, duration, burst = 0) {
+  return throttleEnforceIO_1(sa, chunk => tsplus_module_1.succeedNow(costFn(chunk), fileName_1 + ":2640:55"), units, duration, burst);
+}
+
+function throttleEnforceIOLoop(costFn, units, duration, burst, tokens, timestamp) {
+  return tsplus_module_10.readWith(inp => tsplus_module_10.unwrap(tsplus_module_1.zipWith_(costFn(inp), tsplus_module_40.currentTime, (weight, current) => {
+    const elapsed = current - timestamp;
+    const cycles = elapsed / duration;
+
+    const available = (() => {
+      const sum = tokens + cycles * units;
+      const max = units + burst < 0 ? Number.MAX_SAFE_INTEGER : units + burst;
+      return sum < 0 ? max : Math.min(sum, max);
+    })();
+
+    return weight <= available ? tsplus_module_11.apSecond_(tsplus_module_10.writeNow(inp), throttleEnforceIOLoop(costFn, units, duration, burst, available - weight, current)) : throttleEnforceIOLoop(costFn, units, duration, burst, available - weight, current);
+  })), tsplus_module_10.failNow, () => tsplus_module_10.unit);
+}
+/**
+ * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
+ * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
+ * tokens up to a `units + burst` threshold. Chunks that do not meet the bandwidth constraints are dropped.
+ * The weight of each chunk is determined by the `costFn` effectful function.
+ *
+ * @tsplus fluent fncts.io.Stream throttleEnforceIO
+ */
+
+
+function throttleEnforceIO_1(sa, costFn, units, duration, burst = 0) {
+  return new Stream(tsplus_module_11.flatMap_(tsplus_module_10.fromIO(tsplus_module_40.currentTime), current => tsplus_module_10.pipeTo_(sa.channel, throttleEnforceIOLoop(costFn, units, duration, burst, units, current))));
+}
+/**
+ * Converts the stream to a managed hub of chunks. After the managed hub is used,
+ * the hub will never again produce values and should be discarded.
+ *
+ * @tsplus fluent fncts.io.Stream toHub
+ */
+
+
+function toHub_1(stream, capacity) {
+  return tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_30.makeBounded(capacity), _ => tsplus_module_30.shutdown(_)), hub => tsplus_module_1.map_(tsplus_module_1.fork(runIntoHubScoped_1(stream, hub)), () => hub), fileName_1 + ":2706:18");
+}
+/**
+ * Interpret the stream as a managed pull
+ *
+ * @tsplus getter fncts.io.Stream toPull
+ */
+
+
+function toPull_1(stream) {
+  return tsplus_module_1.map_(tsplus_module_64.toPull(stream.channel), io => tsplus_module_1.flatMap_(tsplus_module_1.mapError_(io, tsplus_module_3.just, fileName_1 + ":2719:16"), r => tsplus_module_4.match_(r, () => tsplus_module_1.failNow(tsplus_module_3.nothing(), fileName_1 + ":2719:68"), tsplus_module_1.succeedNow), fileName_1 + ":2719:36"), fileName_1 + ":2718:35");
+}
+/**
+ * Converts the stream to a managed queue of chunks. After the managed queue is used,
+ * the queue will never again produce values and should be discarded.
+ *
+ * @tsplus fluent fncts.io.Stream toQueue
+ */
+
+
+function toQueue_1(stream, capacity = 2) {
+  return tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_27.makeBounded(capacity), _ => tsplus_module_25.shutdown(_)), queue => tsplus_module_1.map_(tsplus_module_1.fork(runIntoQueueScoped_1(stream, queue)), () => queue), fileName_1 + ":2731:20");
+}
+/**
+ * @tsplus fluent fncts.io.Stream toQueueDropping
+ */
+
+
+export function toQueueDropping_(stream, capacity = 2) {
+  return tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_27.makeDropping(capacity), _ => tsplus_module_25.shutdown(_)), queue => tsplus_module_1.map_(tsplus_module_1.fork(runIntoQueueScoped_1(stream, queue)), () => queue), fileName_1 + ":2745:20");
+}
+/**
+ * @tsplus fluent fncts.io.Stream toQueueOfElements
+ */
+
+function toQueueOfElements_1(stream, capacity = 2) {
+  return tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_27.makeBounded(capacity), _ => tsplus_module_25.shutdown(_)), queue => tsplus_module_1.map_(tsplus_module_1.fork(runIntoElementsScoped_1(stream, queue)), () => queue), fileName_1 + ":2759:20");
+}
+/**
+ * @tsplus fluent fncts.io.Stream toQueueSliding
+ */
+
+
+export function toQueueSliding_(stream, capacity = 2) {
+  return tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_27.makeSliding(capacity), _ => tsplus_module_25.shutdown(_)), queue => tsplus_module_1.map_(tsplus_module_1.fork(runIntoQueueScoped_1(stream, queue)), () => queue), fileName_1 + ":2773:20");
+}
+/**
+ * Converts the stream into an unbounded managed queue. After the managed queue
+ * is used, the queue will never again produce values and should be discarded.
+ *
+ * @tsplus getter fncts.io.Stream toQueueUnbounded
+ */
+
+function toQueueUnbounded_1(stream) {
+  return tsplus_module_1.flatMap_(tsplus_module_28.acquireRelease(() => tsplus_module_27.makeUnbounded(), _ => tsplus_module_25.shutdown(_)), queue => tsplus_module_1.map_(tsplus_module_1.fork(runIntoQueueScoped_1(stream, queue)), () => queue), fileName_1 + ":2787:20");
+}
+
+function unfoldChunkIOLoop(s, f) {
+  return tsplus_module_10.unwrap(tsplus_module_1.map_(f(s), m => tsplus_module_16.match_(m, () => tsplus_module_10.unit, ([as, s]) => tsplus_module_11.flatMap_(tsplus_module_10.writeNow(as), () => unfoldChunkIOLoop(s, f))), fileName_1 + ":2798:13"));
+}
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
+ *
+ * @tsplus static fncts.io.StreamOps unfoldChunkIO
+ */
+
+
+function unfoldChunkIO_1(s, f) {
+  return new Stream(unfoldChunkIOLoop(s, f));
+}
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
+ *
+ * @tsplus static fncts.io.StreamOps unfoldIO
+ */
+
+
+function unfoldIO_1(s, f) {
+  return unfoldChunkIO_1(s, _ => tsplus_module_1.map_(f(_), m => tsplus_module_36.map_(m, ([a, s]) => tuple(tsplus_module_18.single(a), s)), fileName_1 + ":2822:42"));
+}
+
+function unfoldChunkLoop(s, f) {
+  return tsplus_module_16.match_(f(s), () => tsplus_module_10.unit, ([as, s]) => tsplus_module_11.flatMap_(tsplus_module_10.writeNow(as), () => unfoldChunkLoop(s, f)));
+}
+/**
+ * @tsplus static fncts.io.StreamOps unfoldChunk
+ */
+
+
+function unfoldChunk_1(s, f) {
+  return new Stream(tsplus_module_10.defer(() => unfoldChunkLoop(s, f)));
+}
+/**
+ * @tsplus static fncts.io.StreamOps unfold
+ */
+
+
+export function unfold(s, f) {
+  return unfoldChunk_1(s, s => tsplus_module_36.map_(f(s), ([a, s]) => tuple(tsplus_module_18.single(a), s)));
+}
+/**
+ * Creates a stream produced from an IO
+ *
+ * @tsplus static fncts.io.StreamOps unwrap
+ */
+
+function unwrap_1(stream) {
+  return flatten_1(fromIO_1(stream));
+}
+/**
+ * Creates a stream produced from a managed
+ *
+ * @tsplus static fncts.io.StreamOps unwrapScoped
+ */
+
+
+function unwrapScoped_1(stream) {
+  return flatten_1(scoped_1(stream));
+}
+/**
+ * Zips the two streams so that when a value is emitted by either of the two
+ * streams, it is combined with the latest value from the other stream to
+ * produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @tsplus fluent fncts.io.Stream zipWithLatest
+ */
+
+
+export function zipWithLatest_(fa, fb, f) {
+  function pullNonEmpty(pull) {
+    return tsplus_module_1.flatMap_(pull, chunk => tsplus_module_12.isNonEmpty(chunk) ? pullNonEmpty(pull) : tsplus_module_1.succeedNow(chunk, fileName_1 + ":2886:90"), fileName_1 + ":2886:24");
+  }
+
+  return fromPull_1(tsplus_module_1.flatMap_(tsplus_module_1.map_(toPull_1(fa), pullNonEmpty, fileName_1 + ":2890:36"), left => tsplus_module_1.flatMap_(tsplus_module_1.map_(toPull_1(fb), pullNonEmpty, fileName_1 + ":2891:36"), right => toPull_1(flatMap_1(fromIOMaybe_1(tsplus_module_22.raceWith_(left, () => right, (leftDone, rightFiber) => tsplus_module_1.zipWith_(tsplus_module_1.fromExitNow(leftDone, fileName_1 + ":2896:53"), tsplus_module_39.join(rightFiber), (l, r) => tuple(l, r, true)), (rightDone, leftFiber) => tsplus_module_1.zipWith_(tsplus_module_1.fromExitNow(rightDone, fileName_1 + ":2897:53"), tsplus_module_39.join(leftFiber), (r, l) => tuple(l, r, false)), fileName_1 + ":2894:24")), ([l, r, leftFirst]) => flatMap_1(fromIO_1(tsplus_module_6.make(() => tuple(tsplus_module_12.unsafeGet_(l, l.length - 1), tsplus_module_12.unsafeGet_(r, r.length - 1)))), latest => concat_1(fromChunk_1(() => leftFirst ? tsplus_module_12.map_(r, b => f(tsplus_module_12.unsafeGet_(l, l.length - 1), b)) : tsplus_module_12.map_(l, a => f(a, tsplus_module_12.unsafeGet_(r, r.length - 1)))), flatMap_1(mapIO_1(mergeEither_1(repeatIOMaybe_1(left), repeatIOMaybe_1(right)), ab => tsplus_module_4.match_(ab, leftChunk => tsplus_module_14.modify_(latest, ([_, rightLatest]) => tuple(tsplus_module_12.map_(leftChunk, a => f(a, rightLatest)), tuple(tsplus_module_12.unsafeGet_(leftChunk, leftChunk.length - 1), rightLatest))), rightChunk => tsplus_module_14.modify_(latest, ([leftLatest, _]) => tuple(tsplus_module_12.map_(rightChunk, b => f(leftLatest, b)), tuple(leftLatest, tsplus_module_12.unsafeGet_(rightChunk, rightChunk.length - 1)))))), fromChunkNow_1))))), fileName_1 + ":2891:22"), fileName_1 + ":2890:22"));
+}
+//# sourceMappingURL=api.mjs.map