@fncts/io 0.0.10 → 0.0.13

package/_mjs/Sink/api.mjs

@@ -9,27 +9,29 @@ import * as tsplus_module_7 from "@fncts/io/Ref/api/get";
 import * as tsplus_module_8 from "@fncts/io/Ref/constructors";
 import * as tsplus_module_9 from "@fncts/io/IO/api";
 import * as tsplus_module_10 from "@fncts/io/collection/immutable/Conc/mapIO";
-import * as tsplus_module_11 from "@fncts/io/IO/api/environment";
-import * as tsplus_module_12 from "@fncts/base/data/function/api";
-import * as tsplus_module_13 from "@fncts/io/collection/immutable/Conc/filterIO";
-import * as tsplus_module_14 from "@fncts/base/data/Maybe/constructors";
-import * as tsplus_module_15 from "@fncts/base/data/Either/destructors";
-import * as tsplus_module_16 from "@fncts/io/Queue/api/operations";
-import * as tsplus_module_17 from "@fncts/io/IO/api/acquireRelease";
-import * as tsplus_module_18 from "@fncts/base/data/Cause/api";
-import * as tsplus_module_19 from "@fncts/base/data/Maybe/definition";
-import * as tsplus_module_20 from "@fncts/base/data/Maybe/destructors";
-import * as tsplus_module_21 from "@fncts/base/collection/immutable/Conc";
-import * as tsplus_module_22 from "@fncts/base/collection/immutable/Conc/constructors";
-import * as tsplus_module_23 from "@fncts/base/data/Either/api";
-import * as tsplus_module_24 from "@fncts/base/data/Either/constructors";
-import * as tsplus_module_25 from "@fncts/io/Channel/internal/MergeDecision";
-import * as tsplus_module_26 from "@fncts/io/Channel/api/mergeWith";
-import * as tsplus_module_27 from "@fncts/io/Hub/api";
-import * as tsplus_module_28 from "@fncts/base/collection/Iterable/api";
-import * as tsplus_module_29 from "@fncts/io/Clock/api";
-import * as tsplus_module_30 from "@fncts/base/data/Duration/api";
-import * as tsplus_module_31 from "@fncts/base/data/Exit/api";
+import * as tsplus_module_11 from "@fncts/io/collection/immutable/Conc/dropUntilIO";
+import * as tsplus_module_12 from "@fncts/io/collection/immutable/Conc/dropWhileIO";
+import * as tsplus_module_13 from "@fncts/io/IO/api/environment";
+import * as tsplus_module_14 from "@fncts/base/data/function/api";
+import * as tsplus_module_15 from "@fncts/io/collection/immutable/Conc/filterIO";
+import * as tsplus_module_16 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_17 from "@fncts/base/data/Either/destructors";
+import * as tsplus_module_18 from "@fncts/io/Queue/api/operations";
+import * as tsplus_module_19 from "@fncts/io/IO/api/acquireRelease";
+import * as tsplus_module_20 from "@fncts/base/data/Cause/api";
+import * as tsplus_module_21 from "@fncts/base/data/Maybe/definition";
+import * as tsplus_module_22 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_23 from "@fncts/base/collection/immutable/Conc";
+import * as tsplus_module_24 from "@fncts/base/collection/immutable/Conc/constructors";
+import * as tsplus_module_25 from "@fncts/base/data/Either/api";
+import * as tsplus_module_26 from "@fncts/base/data/Either/constructors";
+import * as tsplus_module_27 from "@fncts/io/Channel/internal/MergeDecision";
+import * as tsplus_module_28 from "@fncts/io/Channel/api/mergeWith";
+import * as tsplus_module_29 from "@fncts/io/Hub/api";
+import * as tsplus_module_30 from "@fncts/base/collection/Iterable/api";
+import * as tsplus_module_31 from "@fncts/io/Clock/api";
+import * as tsplus_module_32 from "@fncts/base/data/Duration/api";
+import * as tsplus_module_33 from "@fncts/base/data/Exit/api";
 export const collectAllWhileWith = collectAllWhileWith_1;
 export const contramap = contramap_1;
 export const contramapChunks = contramapChunks_1;
@@ -67,41 +69,53 @@ export const zipWith = zipWith_1;
 export const zipWithC = zipWithC_1;
 import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 /**
+ * Like {@link zip}, but keeps only the result from this sink
+ *
  * @tsplus fluent fncts.io.Sink apFirst
  */
 
 export function apFirst(self, that) {
-  return zipWith_1(() => self, that, (z, _) => z);
+  return zipWith_1(() => self, that, (z, _) => z, fileName_1 + ":14:22");
 }
 /**
+ * Like {@link zipC}, but keeps only the result from this sink
+ *
  * @tsplus fluent fncts.io.Sink apFirstC
  */
 
 export function apFirstC(self, that) {
-  return zipWithC_1(() => self, that, (z, _) => z);
+  return zipWithC_1(() => self, that, (z, _) => z, fileName_1 + ":26:23");
 }
 /**
+ * Like {@link zip}, but keeps only the result from the `that` sink
+ *
  * @tsplus fluent fncts.io.Sink apSecond
  */
 
-export function apSecond(self, that) {
-  return zipWith_1(() => self, that, (_, z1) => z1);
+export function apSecond(self, that, __tsplusTrace) {
+  return zipWith_1(() => self, that, (_, z1) => z1, __tsplusTrace);
 }
 /**
+ * Like {@link zipC}, but keeps only the result from the `that` sink
+ *
  * @tsplus fluent fncts.io.Sink apSecondC
  */
 
-export function apSecondC(self, that) {
-  return zipWithC_1(() => self, that, (_, z1) => z1);
+export function apSecondC(self, that, __tsplusTrace) {
+  return zipWithC_1(() => self, that, (_, z1) => z1, __tsplusTrace);
 }
 /**
+ * Replaces this sink's result with the provided value.
+ *
  * @tsplus fluent fncts.io.Sink as
  */
 
-export function as(self, z) {
-  return map_1(self, () => z(), fileName_1 + ":49:18");
+export function as(self, z, __tsplusTrace) {
+  return map_1(self, () => z(), __tsplusTrace);
 }
 /**
+ * Repeatedly runs the sink and accumulates its results into a chunk
+ *
  * @tsplus fluent fncts.io.Sink collectAll
  */
 
@@ -109,6 +123,10 @@ export function collectAll(self, __tsplusTrace) {
   return collectAllWhileWith_1(self, () => tsplus_module_1.empty(), () => true, (s, z) => tsplus_module_2.append_(s, z), __tsplusTrace);
 }
 /**
+ * Repeatedly runs the sink for as long as its results satisfy the predicate
+ * `p`. The sink's results will be accumulated using the stepping function
+ * `f`.
+ *
  * @tsplus fluent fncts.io.Sink collectAllWhileWith
  */
 
@@ -133,6 +151,9 @@ function collectAllWhileWith_1(self, z, p, f, __tsplusTrace) {
   }));
 }
 /**
+ * Collects the leftovers from the stream when the sink succeeds and returns
+ * them as part of the sink's result
+ *
  * @tsplus getter fncts.io.Sink collectLeftover
  */
 
@@ -141,72 +162,96 @@ export function collectLeftover(self, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_5.map_(tsplus_module_4.collectElements(self.channel), ([chunks, z]) => [z, tsplus_module_2.flatten(chunks)]));
 }
 /**
+ * Transforms this sink's input elements.
+ *
  * @tsplus fluent fncts.io.Sink contramap
  */
 
-function contramap_1(self, f) {
-  return contramapChunks_1(self, chunk => tsplus_module_2.map_(chunk, f));
+function contramap_1(self, f, __tsplusTrace) {
+  return contramapChunks_1(self, chunk => tsplus_module_2.map_(chunk, f), __tsplusTrace);
 }
 /**
+ * Transforms this sink's input chunks. `f` must preserve chunking-invariance
+ *
  * @tsplus fluent fncts.io.Sink contramapChunks
  */
 
 
-function contramapChunks_1(self, f) {
+function contramapChunks_1(self, f, __tsplusTrace) {
   const loop = tsplus_module_4.readWith(chunk => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(f(chunk)), loop), tsplus_module_4.failNow, tsplus_module_5.succeedNow);
   return new tsplus_module_3.Sink(tsplus_module_4.pipeTo_(loop, self.channel));
 }
 /**
+ * Effectfully transforms this sink's input chunks. `f` must preserve
+ * chunking-invariance
+ *
  * @tsplus fluent fncts.io.Sink contramapChunksIO
  */
 
 
-function contramapChunksIO_1(self, f) {
+function contramapChunksIO_1(self, f, __tsplusTrace) {
   const loop = tsplus_module_4.readWith(chunk => tsplus_module_5.apSecond_(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(chunk)), tsplus_module_4.writeNow), loop), tsplus_module_4.failNow, tsplus_module_5.succeedNow);
   return new tsplus_module_3.Sink(tsplus_module_4.pipeToOrFail_(loop, self.channel));
 }
 /**
+ * Effectfully transforms this sink's input elements.
+ *
  * @tsplus fluent fncts.io.Sink contramapIO
  */
 
 
-function contramapIO_1(self, f) {
-  return contramapChunksIO_1(self, chunk => tsplus_module_10.mapIO_(chunk, f));
+function contramapIO_1(self, f, __tsplusTrace) {
+  return contramapChunksIO_1(self, chunk => tsplus_module_10.mapIO_(chunk, f), __tsplusTrace);
 }
 /**
+ * Transforms both inputs and result of this sink using the provided
+ * functions.
+ *
  * @tsplus fluent fncts.io.Sink dimap
  */
 
 
-export function dimap(self, f, g) {
-  return map_1(contramap_1(self, f), g, fileName_1 + ":171:31");
+export function dimap(self, f, g, __tsplusTrace) {
+  return map_1(contramap_1(self, f, __tsplusTrace), g, __tsplusTrace);
 }
 /**
+ * Transforms both input chunks and result of this sink using the provided
+ * functions.
+ *
  * @tsplus fluent fncts.io.Sink dimapChunks
  */
 
-export function dimapChunks(self, f, g) {
-  return map_1(contramapChunks_1(self, f), g, fileName_1 + ":182:37");
+export function dimapChunks(self, f, g, __tsplusTrace) {
+  return map_1(contramapChunks_1(self, f, __tsplusTrace), g, __tsplusTrace);
 }
 /**
+ * Effectfully transforms both input chunks and result of this sink using the
+ * provided functions. `f` and `g` must preserve chunking-invariance
+ *
  * @tsplus fluent fncts.io.Sink dimapChunksIO
  */
 
-export function dimapChunksIO(self, f, g) {
-  return mapIO_1(contramapChunksIO_1(self, f), g, fileName_1 + ":193:41");
+export function dimapChunksIO(self, f, g, __tsplusTrace) {
+  return mapIO_1(contramapChunksIO_1(self, f, __tsplusTrace), g, __tsplusTrace);
 }
 /**
+ * Effectfully transforms both inputs and result of this sink using the
+ * provided functions.
+ *
  * @tsplus fluent fncts.io.Sink dimapIO
  */
 
-export function dimapIO(self, f, g) {
-  return mapIO_1(contramapIO_1(self, f), g, fileName_1 + ":204:35");
+export function dimapIO(self, f, g, __tsplusTrace) {
+  return mapIO_1(contramapIO_1(self, f, __tsplusTrace), g, __tsplusTrace);
 }
 /**
+ * Returns a lazily constructed sink that may require effects for its
+ * creation.
+ *
  * @tsplus static fncts.io.SinkOps defer
  */
 
-function defer_1(sink) {
+function defer_1(sink, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_4.defer(() => sink().channel));
 }
 
@@ -219,10 +264,41 @@ const drainLoop = /*#__PURE__*/tsplus_module_4.readWithCause(() => drainLoop, ts
 
 export const drain = /*#__PURE__*/new tsplus_module_3.Sink(drainLoop);
 /**
+ * Drops incoming elements until the predicate `p` is satisfied.
+ *
+ * @tsplus static fncts.io.SinkOps dropUntil
+ */
+
+export function makeDropUntil(p, __tsplusTrace) {
+  const loop = tsplus_module_4.readWith(inp => {
+    const leftover = tsplus_module_2.dropUntil(inp, p);
+    const more = tsplus_module_2.isEmpty(leftover);
+
+    if (more) {
+      return loop;
+    } else {
+      return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftover), tsplus_module_4.id());
+    }
+  }, tsplus_module_4.failNow, () => tsplus_module_4.unit);
+  return new tsplus_module_3.Sink(loop);
+}
+/**
+ * Drops incoming elements until the effectful predicate `p` is satisfied.
+ *
+ * @tsplus static fncts.io.SinkOps dropUntilIO
+ */
+
+export function makeDropUntilIO(p, __tsplusTrace) {
+  const loop = tsplus_module_4.readWith(inp => tsplus_module_4.unwrap(() => tsplus_module_9.map_(tsplus_module_11.dropUntilIO(inp, p, __tsplusTrace), leftover => tsplus_module_2.isEmpty(leftover) ? loop : tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftover), tsplus_module_4.id()), __tsplusTrace)), tsplus_module_4.failNow, () => tsplus_module_4.unit);
+  return new tsplus_module_3.Sink(loop);
+}
+/**
+ * Drops incoming elements as long as the predicate `p` is satisfied.
+ *
  * @tsplus static fncts.io.SinkOps dropWhile
  */
 
-export function dropWhile(predicate) {
+export function makeDropWhile(predicate, __tsplusTrace) {
   const loop = tsplus_module_4.readWith(inp => {
     const leftover = tsplus_module_2.dropWhile_(inp, predicate);
     const more = tsplus_module_2.isEmpty(leftover);
@@ -236,41 +312,64 @@ export function dropWhile(predicate) {
   return new tsplus_module_3.Sink(loop);
 }
 /**
+ * Drops incoming elements as long as the effectful predicate `p` is
+ * satisfied.
+ *
+ * @tsplus static fncts.io.SinkOps dropWhileIO
+ */
+
+export function dropWhileIO(p, __tsplusTrace) {
+  const loop = tsplus_module_4.readWith(inp => tsplus_module_4.unwrap(() => tsplus_module_9.map_(tsplus_module_12.dropWhileIO(inp, p, __tsplusTrace), leftover => tsplus_module_2.isEmpty(leftover) ? loop : tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftover), tsplus_module_4.id()), __tsplusTrace)), tsplus_module_4.failNow, () => tsplus_module_4.unit);
+  return new tsplus_module_3.Sink(loop);
+}
+/**
+ * Accesses the whole environment of the sink.
+ *
  * @tsplus static fncts.io.SinkOps environment
  */
 
 export function environment(__tsplusTrace) {
-  return fromIO_1(() => tsplus_module_11.environment(__tsplusTrace));
+  return fromIO_1(() => tsplus_module_13.environment(__tsplusTrace), __tsplusTrace);
 }
 /**
+ * Accesses the environment of the sink.
+ *
  * @tsplus static fncts.io.SinkOps environmentWith
  */
 
 export function environmentWith(f, __tsplusTrace) {
-  return fromIO_1(() => tsplus_module_11.environmentWith(f, __tsplusTrace));
+  return fromIO_1(() => tsplus_module_13.environmentWith(f, __tsplusTrace), __tsplusTrace);
 }
 /**
+ * Accesses the environment of the sink in the context of an effect.
+ *
  * @tsplus static fncts.io.SinkOps environmentWithIO
  */
 
 export function environmentWithIO(f, __tsplusTrace) {
-  return fromIO_1(() => tsplus_module_11.environmentWithIO(f, __tsplusTrace));
+  return fromIO_1(() => tsplus_module_13.environmentWithIO(f, __tsplusTrace), __tsplusTrace);
 }
 /**
+ * Accesses the environment of the sink in the context of a sink.
+ *
  * @tsplus static fncts.io.SinkOps environmentWithSink
  */
 
 export function environmentWithSink(f, __tsplusTrace) {
-  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_11.environmentWith(tsplus_module_12.compose_(f, s => s.channel), __tsplusTrace)));
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_13.environmentWith(tsplus_module_14.compose_(f, s => s.channel), __tsplusTrace)));
 }
 /**
+ * A sink that always fails with the specified error.
+ *
  * @tsplus static fncts.io.SinkOps fail
  */
 
-export function fail(e) {
+export function fail(e, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_4.fail(e));
 }
 /**
+ * Creates a sink halting with a specified cause.
+ *
  * @tsplus static fncts.io.SinkOps failCause
  */
 
@@ -278,6 +377,8 @@ function failCause_1(cause, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_5.failCause(cause));
 }
 /**
+ * Creates a sink halting with a specified cause.
+ *
  * @tsplus static fncts.io.SinkOps failCauseNow
  */
 
@@ -286,6 +387,8 @@ function failCauseNow_1(cause, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_5.failCauseNow(cause));
 }
 /**
+ * A sink that always fails with the specified error.
+ *
  * @tsplus static fncts.io.SinkOps failNow
  */
 
@@ -294,21 +397,27 @@ function failNow_1(e, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_4.failNow(e));
 }
 /**
+ * Filters the sink's input with the given predicate
+ *
  * @tsplus static fncts.io.SinkOps filterInput
  */
 
 
 export function filterInput(self, p, __tsplusTrace) {
-  return contramapChunks_1(self, chunk => tsplus_module_2.filter_(chunk, p));
+  return contramapChunks_1(self, chunk => tsplus_module_2.filter_(chunk, p), __tsplusTrace);
 }
 /**
+ * Filters the sink's input with the given IO predicate
+ *
  * @tsplus static fncts.io.SinkOps filterInputIO
  */
 
 export function filterInputIO(self, p, __tsplusTrace) {
-  return contramapChunksIO_1(self, chunk => tsplus_module_13.filterIO(chunk, p));
+  return contramapChunksIO_1(self, chunk => tsplus_module_15.filterIO(chunk, p), __tsplusTrace);
 }
 /**
+ * Creates a sink that produces values until one verifies the predicate `f`.
+ *
  * @tsplus fluent fncts.io.Sink findIO
  */
 
@@ -316,12 +425,18 @@ export function findIO(self, f, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_9.zip_(tsplus_module_8.make(() => tsplus_module_1.empty()), tsplus_module_8.make(() => false))), ([leftoversRef, upstreamDoneRef]) => {
     const upstreamMarker = tsplus_module_4.readWith(inp => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(inp), upstreamMarker), tsplus_module_4.failNow, x => tsplus_module_4.as_(tsplus_module_4.fromIO(() => tsplus_module_6.set_(upstreamDoneRef, true)), () => x));
     const loop = tsplus_module_4.matchChannel_(tsplus_module_4.collectElements(self.channel), tsplus_module_4.failNow, ([leftovers, doneValue]) => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(doneValue)), satisfied => tsplus_module_5.apSecond_(tsplus_module_4.fromIO(() => tsplus_module_6.set_(leftoversRef, tsplus_module_2.flatten(leftovers))), tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_7.get(upstreamDoneRef)), upstreamDone => {
-      if (satisfied) return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => tsplus_module_14.just(doneValue));else if (upstreamDone) return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => tsplus_module_14.nothing());else return loop;
+      if (satisfied) return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => tsplus_module_16.just(doneValue));else if (upstreamDone) return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => tsplus_module_16.nothing());else return loop;
     }))));
     return tsplus_module_4.pipeTo_(tsplus_module_4.pipeTo_(upstreamMarker, tsplus_module_4.bufferChunk(leftoversRef)), loop);
   }));
 }
 /**
+ * Runs this sink until it yields a result, then uses that result to create
+ * another sink from the provided function which will continue to run until it
+ * yields a result.
+ *
+ * This function essentially runs sinks in sequence.
+ *
  * @tsplus fluent fncts.io.Sink flatMap
  */
 
@@ -329,6 +444,8 @@ function flatMap_1(self, f, __tsplusTrace) {
   return matchSink_1(self, failNow_1, f, __tsplusTrace);
 }
 /**
+ * Creates a sink from a {@link Channel}
+ *
  * @tsplus static fncts.io.SinkOps fromChannel
  * @tsplus static fncts.io.SinkOps __call
  */
@@ -338,6 +455,8 @@ export function fromChannel(channel) {
   return new tsplus_module_3.Sink(channel);
 }
 /**
+ * Creates a sink from a chunk processing function.
+ *
  * @tsplus static fncts.io.SinkOps fromPush
  */
 
@@ -346,69 +465,89 @@ export function fromPush(push, __tsplusTrace) {
 }
 
 function fromPushPull(push) {
-  return tsplus_module_4.readWith(inp => tsplus_module_4.matchChannel_(tsplus_module_4.fromIO(() => push(tsplus_module_14.just(inp))), ([r, leftovers]) => tsplus_module_15.match_(r, e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_4.failNow(e)), z => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(z))), () => fromPushPull(push)), tsplus_module_4.failNow, () => tsplus_module_4.matchChannel_(tsplus_module_4.fromIO(() => push(tsplus_module_14.nothing())), ([r, leftovers]) => tsplus_module_15.match_(r, e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_4.failNow(e)), z => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(z))), () => tsplus_module_4.fromIO(() => tsplus_module_9.halt(() => new Error("empty sink"), fileName_1 + ":427:37"))));
+  return tsplus_module_4.readWith(inp => tsplus_module_4.matchChannel_(tsplus_module_4.fromIO(() => push(tsplus_module_16.just(inp))), ([r, leftovers]) => tsplus_module_17.match_(r, e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_4.failNow(e)), z => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(z))), () => fromPushPull(push)), tsplus_module_4.failNow, () => tsplus_module_4.matchChannel_(tsplus_module_4.fromIO(() => push(tsplus_module_16.nothing())), ([r, leftovers]) => tsplus_module_17.match_(r, e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_4.failNow(e)), z => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(z))), () => tsplus_module_4.fromIO(() => tsplus_module_9.halt(() => new Error("empty sink"), fileName_1 + ":591:37"))));
 }
 /**
+ * Create a sink which enqueues each element into the specified queue.
+ *
  * @tsplus static fncts.io.SinkOps fromQueue
  */
 
 
-function fromQueue_1(queue) {
-  return unwrap_1(() => tsplus_module_9.map_(tsplus_module_9.succeed(queue, fileName_1 + ":436:32"), queue => makeForeachChunk_1(inp => tsplus_module_16.offerAll_(queue, inp), fileName_1 + ":436:72"), fileName_1 + ":436:43"));
+function fromQueue_1(queue, __tsplusTrace) {
+  return unwrap_1(() => tsplus_module_9.map_(tsplus_module_9.succeed(queue, __tsplusTrace), queue => makeForeachChunk_1(inp => tsplus_module_18.offerAll_(queue, inp), __tsplusTrace), __tsplusTrace));
 }
 /**
+ * Create a sink which enqueues each element into the specified queue. The
+ * queue will be shutdown once the stream is closed.
+ *
  * @tsplus static fncts.io.SinkOps fromQueueWithShutdown
  */
 
 
-function fromQueueWithShutdown_1(queue) {
-  return unwrapScoped_1(() => tsplus_module_9.map_(tsplus_module_17.acquireRelease(() => tsplus_module_9.succeed(queue, fileName_1 + ":444:15"), queue => tsplus_module_16.shutdown(queue)), queue => fromQueue_1(() => queue), fileName_1 + ":446:11"));
+function fromQueueWithShutdown_1(queue, __tsplusTrace) {
+  return unwrapScoped_1(() => tsplus_module_9.map_(tsplus_module_19.acquireRelease(() => tsplus_module_9.succeed(queue, __tsplusTrace), queue => tsplus_module_18.shutdown(queue)), queue => fromQueue_1(() => queue, __tsplusTrace), __tsplusTrace), __tsplusTrace);
 }
 /**
+ * Create a sink which publishes each element to the specified hub.
+ *
  * @tsplus static fncts.io.SinkOps fromHub
  */
 
 
-export function fromHub(hub) {
-  return fromQueue_1(hub);
+export function fromHub(hub, __tsplusTrace) {
+  return fromQueue_1(hub, __tsplusTrace);
 }
 /**
+ * Create a sink which publishes each element to the specified hub. The hub
+ * will be shutdown once the stream is closed.
+ *
  * @tsplus static fncts.io.SinkOps fromHubWithShutdown
  */
 
-export function fromHubWithShutdown(hub) {
-  return fromQueueWithShutdown_1(hub);
+export function fromHubWithShutdown(hub, __tsplusTrace) {
+  return fromQueueWithShutdown_1(hub, __tsplusTrace);
 }
 /**
+ * Creates a single-value sink produced from an effect
+ *
  * @tsplus static fncts.io.SinkOps fromIO
  */
 
-function fromIO_1(b) {
+function fromIO_1(b, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_4.fromIO(b));
 }
 /**
+ * Creates a sink halting with the specified unchecked value.
+ *
  * @tsplus static fncts.io.SinkOps halt
  */
 
 
 export function halt(defect, __tsplusTrace) {
-  return failCause_1(() => tsplus_module_18.halt(defect()), __tsplusTrace);
+  return failCause_1(() => tsplus_module_20.halt(defect()), __tsplusTrace);
 }
 /**
+ * Creates a sink halting with the specified unchecked value.
+ *
  * @tsplus static fncts.io.SinkOps haltNow
  */
 
 export function haltNow(defect, __tsplusTrace) {
-  return failCauseNow_1(tsplus_module_18.halt(defect), __tsplusTrace);
+  return failCauseNow_1(tsplus_module_20.halt(defect), __tsplusTrace);
 }
 /**
+ * Creates a sink containing the first value.
+ *
  * @tsplus static fncts.io.SinkOps head
  */
 
 export function head(__tsplusTrace) {
-  return makeFold_1(() => tsplus_module_14.nothing(), elem => tsplus_module_19.isNothing(elem), (s, inp) => tsplus_module_20.match_(s, () => tsplus_module_14.just(inp), () => s), __tsplusTrace);
+  return makeFold_1(() => tsplus_module_16.nothing(), elem => tsplus_module_21.isNothing(elem), (s, inp) => tsplus_module_22.match_(s, () => tsplus_module_16.just(inp), () => s), __tsplusTrace);
 }
 /**
+ * Drains the remaining elements from the stream after the sink finishes
+ *
  * @tsplus getter fncts.io.Sink ignoreLeftover
  */
 
@@ -416,14 +555,19 @@ function ignoreLeftover_1(self, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_4.drain(self.channel));
 }
 /**
+ * Creates a sink containing the last value.
+ *
  * @tsplus static fncts.io.SinkOps last
  */
 
 
 export function last(__tsplusTrace) {
-  return makeFoldLeft_1(() => tsplus_module_14.nothing(), (_, inp) => tsplus_module_14.just(inp));
+  return makeFoldLeft_1(() => tsplus_module_16.nothing(), (_, inp) => tsplus_module_16.just(inp));
 }
 /**
+ * Creates a sink that does not consume any input but provides the given chunk
+ * as its leftovers
+ *
  * @tsplus static fncts.io.SinkOps leftover
  */
 
@@ -431,11 +575,13 @@ export function leftover(c, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_4.write(c));
 }
 /**
+ * Logs the specified message at the current log level.
+ *
  * @tsplus static fncts.io.SinkOps log
  */
 
 export function log(message, __tsplusTrace) {
-  return fromIO_1(() => tsplus_module_9.log(message, __tsplusTrace));
+  return fromIO_1(() => tsplus_module_9.log(message, __tsplusTrace), __tsplusTrace);
 }
 /**
  * A sink that collects all of its inputs into a chunk.
@@ -450,9 +596,16 @@ export function makeCollectAll() {
 function collectLoop(state) {
   return tsplus_module_4.readWithCause(inp => collectLoop(tsplus_module_2.concat_(state, inp)), tsplus_module_5.failCauseNow, () => tsplus_module_5.endNow(state));
 }
+/**
+ * A sink that collects first `n` elements into a chunk. Note that the chunk
+ * is preallocated and must fit in memory.
+ *
+ * @tsplus static fncts.io.SinkOps collectAllN
+ */
+
 
 export function makeCollectAllN(n) {
-  return flatMap_1(fromIO_1(() => tsplus_module_9.succeed(() => new tsplus_module_21.ConcBuilder(), fileName_1 + ":549:32")), builder => map_1(makeFoldUntil_1(() => builder, n, (builder, inp) => builder.append(inp), fileName_1 + ":550:19"), builder => builder.result(), fileName_1 + ":550:95"), fileName_1 + ":549:64");
+  return flatMap_1(fromIO_1(() => tsplus_module_9.succeed(() => new tsplus_module_23.ConcBuilder(), fileName_1 + ":755:32"), fileName_1 + ":755:21"), builder => map_1(makeFoldUntil_1(() => builder, n, (builder, inp) => builder.append(inp), fileName_1 + ":756:19"), builder => builder.result(), fileName_1 + ":756:95"), fileName_1 + ":755:64");
 }
 /**
  * A sink that executes the provided effectful function for every element fed to it.
@@ -464,6 +617,9 @@ export function makeForeach(f, __tsplusTrace) {
   return makeForeachWhile_1(inp => tsplus_module_9.as_(f(inp), () => true), __tsplusTrace);
 }
 /**
+ * A sink that executes the provided effectful function for every chunk fed to
+ * it.
+ *
  * @tsplus static fncts.io.SinkOps foreachChunk
  */
 
@@ -492,6 +648,9 @@ function foreachWhileLoop(f, chunk, idx, len, cont) {
   return tsplus_module_4.catchAll_(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(tsplus_module_2.unsafeGet_(chunk, idx))), b => b ? foreachWhileLoop(f, chunk, idx + 1, len, cont) : tsplus_module_4.writeNow(tsplus_module_2.drop_(chunk, idx))), e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(tsplus_module_2.drop_(chunk, idx)), tsplus_module_4.failNow(e)));
 }
 /**
+ * A sink that executes the provided effectful function for every chunk fed to
+ * it until `f` evaluates to `false`.
+ *
  * @tsplus static fncts.io.SinkOps foreachChunkWhile
  */
 
@@ -501,11 +660,14 @@ export function makeForeachChunkWhile(f, __tsplusTrace) {
   return new tsplus_module_3.Sink(reader);
 }
 /**
+ * A sink that folds its inputs with the provided function, termination
+ * predicate and initial state.
+ *
  * @tsplus static fncts.io.SinkOps fold
  */
 
 function makeFold_1(z, contFn, f, __tsplusTrace) {
-  return defer_1(() => new tsplus_module_3.Sink(foldReader(z(), contFn, f)));
+  return defer_1(() => new tsplus_module_3.Sink(foldReader(z(), contFn, f)), __tsplusTrace);
 }
 /**
  * @tsplus tailRec
@@ -569,6 +731,11 @@ function foldReader(s, contFn, f) {
   }
 }
 /**
+ * Creates a sink that folds elements of type `In` into a structure of type
+ * `S` until `max` elements have been folded.
+ *
+ * Like {@link foldWeighted}, but with a constant cost function of 1.
+ *
  * @tsplus static fncts.io.SinkOps foldUntil
  */
 
@@ -577,12 +744,17 @@ function makeFoldUntil_1(z, max, f, __tsplusTrace) {
   return unwrap_1(() => tsplus_module_9.map_(tsplus_module_9.succeed(max, __tsplusTrace), max => map_1(makeFold_1(() => [z(), 0], ([_, n]) => n < max, ([o, count], i) => [f(o, i), count + 1], __tsplusTrace), ([s]) => s, __tsplusTrace), __tsplusTrace));
 }
 /**
+ * A sink that folds its input chunks with the provided function, termination
+ * predicate and initial state. `contFn` condition is checked only for the
+ * initial value and at the end of processing of each chunk. `f` and `contFn`
+ * must preserve chunking-invariance.
+ *
  * @tsplus static fncts.io.SinkOps foldChunks
  */
 
 
-function makeFoldChunks_1(z, contFn, f) {
-  return defer_1(() => new tsplus_module_3.Sink(foldChunksReader(z(), contFn, f)));
+function makeFoldChunks_1(z, contFn, f, __tsplusTrace) {
+  return defer_1(() => new tsplus_module_3.Sink(foldChunksReader(z(), contFn, f)), __tsplusTrace);
 }
 
 function foldChunksReader(s, contFn, f) {
@@ -596,12 +768,17 @@ function foldChunksReader(s, contFn, f) {
   }
 }
 /**
+ * A sink that effectfully folds its input chunks with the provided function,
+ * termination predicate and initial state. `contFn` condition is checked only
+ * for the initial value and at the end of processing of each chunk. `f` and
+ * `contFn` must preserve chunking-invariance.
+ *
  * @tsplus static fncts.io.SinkOps foldChunksIO
  */
 
 
-function makeFoldChunksIO_1(z, contFn, f) {
-  return defer_1(() => new tsplus_module_3.Sink(foldChunksIOReader(z(), contFn, f)));
+function makeFoldChunksIO_1(z, contFn, f, __tsplusTrace) {
+  return defer_1(() => new tsplus_module_3.Sink(foldChunksIOReader(z(), contFn, f)), __tsplusTrace);
 }
 
 function foldChunksIOReader(s, contFn, f) {
@@ -612,54 +789,68 @@ function foldChunksIOReader(s, contFn, f) {
   }
 }
 /**
+ * A sink that folds its inputs with the provided function and initial state.
+ *
  * @tsplus static fncts.io.SinkOps foldLeft
  */
 
 
 function makeFoldLeft_1(z, f) {
-  return ignoreLeftover_1(makeFold_1(z, () => true, f, fileName_1 + ":772:19"), fileName_1 + ":772:37");
+  return ignoreLeftover_1(makeFold_1(z, () => true, f, fileName_1 + ":1006:19"), fileName_1 + ":1006:37");
 }
 /**
+ * A sink that folds its input chunks with the provided function and initial
+ * state. `f` must preserve chunking-invariance.
+ *
  * @tsplus static fncts.io.SinkOps foldLeftChunks
  */
 
 
 export function makeFoldLeftChunks(z, f) {
-  return ignoreLeftover_1(makeFoldChunks_1(z, () => true, f), fileName_1 + ":782:43");
+  return ignoreLeftover_1(makeFoldChunks_1(z, () => true, f, fileName_1 + ":1016:25"), fileName_1 + ":1016:43");
 }
 /**
+ * A sink that effectfully folds its input chunks with the provided function
+ * and initial state. `f` must preserve chunking-invariance.
+ *
  * @tsplus static fncts.io.SinkOps foldLeftChunksIO
  */
 
-export function makeFoldLeftChunksIO(z, f) {
-  return makeFoldChunksIO_1(z, () => true, f);
+export function makeFoldLeftChunksIO(z, f, __tsplusTrace) {
+  return makeFoldChunksIO_1(z, () => true, f, __tsplusTrace);
 }
 /**
+ * A sink that effectfully folds its inputs with the provided function and
+ * initial state.
+ *
  * @tsplus static fncts.io.SinkOps foldLeftIO
  */
 
-export function makeFoldLeftIO(z, f) {
+export function makeFoldLeftIO(z, f, __tsplusTrace) {
   return makeFoldIO_1(z, () => true, f);
 }
 /**
+ * A sink that effectfully folds its inputs with the provided function,
+ * termination predicate and initial state.
+ *
  * @tsplus static fncts.io.SinkOps foldIO
  */
 
 function makeFoldIO_1(z, contFn, f) {
-  return defer_1(() => new tsplus_module_3.Sink(foldIOReader(z(), contFn, f)));
+  return defer_1(() => new tsplus_module_3.Sink(foldIOReader(z(), contFn, f)), fileName_1 + ":1058:20");
 }
 
 function foldChunkSplitIO(s, contFn, f, chunk, idx, len) {
   if (idx === len) {
-    return tsplus_module_9.succeedNow([s, tsplus_module_14.nothing()], fileName_1 + ":822:25");
+    return tsplus_module_9.succeedNow([s, tsplus_module_16.nothing()], fileName_1 + ":1070:25");
   } else {
     return tsplus_module_9.flatMap_(f(s, tsplus_module_2.unsafeGet_(chunk, idx)), s1 => {
       if (contFn(s1)) {
         return foldChunkSplitIO(s1, contFn, f, chunk, idx + 1, len);
       } else {
-        return tsplus_module_9.succeedNow([s1, tsplus_module_14.just(tsplus_module_2.drop_(chunk, idx + 1))], fileName_1 + ":828:29");
+        return tsplus_module_9.succeedNow([s1, tsplus_module_16.just(tsplus_module_2.drop_(chunk, idx + 1))], fileName_1 + ":1076:29");
       }
-    }, fileName_1 + ":824:36");
+    }, fileName_1 + ":1072:36");
   }
 }
 
@@ -667,22 +858,43 @@ function foldIOReader(s, contFn, f) {
   if (!contFn(s)) {
     return tsplus_module_5.succeedNow(s);
   } else {
-    return tsplus_module_4.readWith(inp => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => foldChunkSplitIO(s, contFn, f, inp, 0, inp.length)), ([nextS, leftovers]) => tsplus_module_20.match_(leftovers, () => foldIOReader(nextS, contFn, f), l => tsplus_module_4.as_(tsplus_module_4.writeNow(l), () => nextS))), err => tsplus_module_4.failNow(err), _ => tsplus_module_5.succeedNow(_));
+    return tsplus_module_4.readWith(inp => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => foldChunkSplitIO(s, contFn, f, inp, 0, inp.length)), ([nextS, leftovers]) => tsplus_module_22.match_(leftovers, () => foldIOReader(nextS, contFn, f), l => tsplus_module_4.as_(tsplus_module_4.writeNow(l), () => nextS))), err => tsplus_module_4.failNow(err), _ => tsplus_module_5.succeedNow(_));
   }
 }
 /**
+ * Creates a sink that effectfully folds elements of type `In` into a
+ * structure of type `S` until `max` elements have been folded.
+ *
+ * Like {@link makeFoldWeightedIO}, but with a constant cost function of 1.
+ *
  * @tsplus static fncts.io.SinkOps foldUntilIO
  */
 
 
-export function makeFoldUntilIO(z, max, f) {
-  return map_1(makeFoldIO_1(() => [z(), 0], ([_, n]) => n < max(), ([o, count], i) => tsplus_module_9.map_(f(o, i), s => [s, count + 1], fileName_1 + ":867:35")), ([s]) => s, fileName_1 + ":868:8");
+export function makeFoldUntilIO(z, max, f, __tsplusTrace) {
+  return map_1(makeFoldIO_1(() => [z(), 0], ([_, n]) => n < max(), ([o, count], i) => tsplus_module_9.map_(f(o, i), s => [s, count + 1], __tsplusTrace)), ([s]) => s, __tsplusTrace);
 }
 /**
+ * Creates a sink that folds elements of type `In` into a structure of type
+ * `S`, until `max` worth of elements (determined by the `costFn`) have been
+ * folded.
+ *
+ * The `decompose` function will be used for decomposing elements that cause
+ * an `S` aggregate to cross `max` into smaller elements.
+ *
+ *
+ * Be vigilant with this function, it has to generate "simpler" values or the
+ * fold may never end. A value is considered indivisible if `decompose` yields
+ * the empty chunk or a single-valued chunk. In these cases, there is no other
+ * choice than to yield a value that will cross the threshold.
+ *
+ * The {@link makeFoldWeightedDecomposeIO} allows the decompose function to return a
+ * `IO` value, and consequently it allows the sink to fail.
+ *
  * @tsplus static fncts.io.SinkOps foldWeightedDecompose
  */
 
-function makeFoldWeightedDecompose_1(z, costFn, max, decompose, f) {
+function makeFoldWeightedDecompose_1(z, costFn, max, decompose, f, __tsplusTrace) {
   return defer_1(() => {
     /**
      * @tsplus tailRec
@@ -725,35 +937,46 @@ function makeFoldWeightedDecompose_1(z, costFn, max, decompose, f) {
     }
 
     return new tsplus_module_3.Sink(go(z(), 0, false, max()));
-  });
+  }, __tsplusTrace);
 }
 /**
+ * Creates a sink that effectfully folds elements of type `In` into a
+ * structure of type `S`, until `max` worth of elements (determined by the
+ * `costFn`) have been folded.
+ *
+ * The `decompose` function will be used for decomposing elements that cause
+ * an `S` aggregate to cross `max` into smaller elements. Be vigilant with
+ * this function, it has to generate "simpler" values or the fold may never
+ * end. A value is considered indivisible if `decompose` yields the empty
+ * chunk or a single-valued chunk. In these cases, there is no other choice
+ * than to yield a value that will cross the threshold.
+ *
  * @tsplus static fncts.io.SinkOps foldWeightedDecomposeIO
  */
 
 
-function makeFoldWeightedDecomposeIO_1(z, costFn, max, decompose, f) {
+function makeFoldWeightedDecomposeIO_1(z, costFn, max, decompose, f, __tsplusTrace) {
   return defer_1(() => {
     function fold(inp, s, max, dirty, cost, idx) {
       if (idx === inp.length) {
-        return tsplus_module_9.succeedNow([s, cost, dirty, tsplus_module_1.empty()], fileName_1 + ":961:29");
+        return tsplus_module_9.succeedNow([s, cost, dirty, tsplus_module_1.empty()], __tsplusTrace);
       } else {
         const elem = tsplus_module_2.unsafeGet_(inp, idx);
-        return tsplus_module_9.flatMap_(tsplus_module_9.map_(costFn(s, elem), _ => cost + _, fileName_1 + ":965:15"), total => {
+        return tsplus_module_9.flatMap_(tsplus_module_9.map_(costFn(s, elem), _ => cost + _, __tsplusTrace), total => {
           if (total <= max) {
-            return tsplus_module_9.flatMap_(f(s, elem), s => fold(inp, s, max, true, total, idx + 1), fileName_1 + ":968:40");
+            return tsplus_module_9.flatMap_(f(s, elem), s => fold(inp, s, max, true, total, idx + 1), __tsplusTrace);
           } else {
             return tsplus_module_9.flatMap_(decompose(elem), decomposed => {
               if (decomposed.length <= 1 && !dirty) {
-                return tsplus_module_9.map_(f(s, elem), s => [s, total, true, tsplus_module_2.drop_(inp, idx + 1)], fileName_1 + ":972:40");
+                return tsplus_module_9.map_(f(s, elem), s => [s, total, true, tsplus_module_2.drop_(inp, idx + 1)], __tsplusTrace);
               } else if (decomposed.length <= 1 && dirty) {
-                return tsplus_module_9.succeedNow([s, cost, dirty, tsplus_module_2.drop_(inp, idx)], fileName_1 + ":974:39");
+                return tsplus_module_9.succeedNow([s, cost, dirty, tsplus_module_2.drop_(inp, idx)], __tsplusTrace);
               } else {
                 return fold(tsplus_module_2.concat_(decomposed, tsplus_module_2.drop_(inp, idx + 1)), s, max, dirty, cost, 0);
               }
-            }, fileName_1 + ":970:45");
+            }, __tsplusTrace);
           }
-        }, fileName_1 + ":966:19");
+        }, __tsplusTrace);
       }
     }
 
@@ -770,22 +993,40 @@ function makeFoldWeightedDecomposeIO_1(z, costFn, max, decompose, f) {
     }
 
     return new tsplus_module_3.Sink(go(z(), 0, false, max()));
-  });
+  }, __tsplusTrace);
 }
 /**
+ * Creates a sink that folds elements of type `In` into a structure of type
+ * `S`, until `max` worth of elements (determined by the `costFn`) have been
+ * folded.
+ *
+ * @note
+ *   Elements that have an individual cost larger than `max` will force the
+ *   sink to cross the `max` cost. See {@link makeFoldWeightedDecompose} for a variant
+ *   that can handle these cases.
+ *
  * @tsplus static fncts.io.SinkOps foldWeighted
  */
 
 
-export function makeFoldWeighted(z, costFn, max, f) {
-  return makeFoldWeightedDecompose_1(z, costFn, max, tsplus_module_22.single, f);
+export function makeFoldWeighted(z, costFn, max, f, __tsplusTrace) {
+  return makeFoldWeightedDecompose_1(z, costFn, max, tsplus_module_24.single, f, __tsplusTrace);
 }
 /**
+ * Creates a sink that effectfully folds elements of type `In` into a
+ * structure of type `S`, until `max` worth of elements (determined by the
+ * `costFn`) have been folded.
+ *
+ * @note
+ *   Elements that have an individual cost larger than `max` will force the
+ *   sink to cross the `max` cost. See {@link makeFoldWeightedDecomposeIO} for a
+ *   variant that can handle these cases.
+ *
  * @tsplus static fncts.io.SinkOps foldWeightedIO
  */
 
-export function makeFoldWeightedIO(z, costFn, max, f) {
-  return makeFoldWeightedDecomposeIO_1(z, costFn, max, inp => tsplus_module_9.succeedNow(tsplus_module_22.single(inp), fileName_1 + ":1030:77"), f);
+export function makeFoldWeightedIO(z, costFn, max, f, __tsplusTrace) {
+  return makeFoldWeightedDecomposeIO_1(z, costFn, max, inp => tsplus_module_9.succeedNow(tsplus_module_24.single(inp), __tsplusTrace), f, __tsplusTrace);
 }
 /**
  * Transforms this sink's result.
@@ -836,14 +1077,19 @@ function matchSink_1(self, onFailure, onSuccess, __tsplusTrace) {
   })));
 }
 /**
+ * Switch to another sink in case of failure
+ *
  * @tsplus fluent fncts.io.Sink orElse
  */
 
 
 export function orElse(self, that, __tsplusTrace) {
-  return defer_1(() => new tsplus_module_3.Sink(tsplus_module_4.orElse_(self.channel, that().channel)));
+  return defer_1(() => new tsplus_module_3.Sink(tsplus_module_4.orElse_(self.channel, that().channel)), __tsplusTrace);
 }
 /**
+ * Provides the sink with its required environment, which eliminates its
+ * dependency on `R`.
+ *
  * @tsplus fluent fncts.io.Sink provideEnvironment
  */
 
@@ -851,20 +1097,29 @@ export function provideEnvironment(self, r, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_4.provideEnvironment_(self.channel, r));
 }
 /**
+ * Runs both sinks in parallel on the input, returning the result or the
+ * error from the one that finishes first.
+ *
  * @tsplus fluent fncts.io.Sink race
  */
 
-export function race(self, that) {
-  return map_1(raceBoth_1(self, that), result => tsplus_module_23.merge(result), fileName_1 + ":1136:33");
+export function race(self, that, __tsplusTrace) {
+  return map_1(raceBoth_1(self, that), result => tsplus_module_25.merge(result), __tsplusTrace);
 }
 /**
+ * Runs both sinks in parallel on the input, returning the result or the error
+ * from the one that finishes first.
+ *
  * @tsplus fluent fncts.io.Sink raceBoth
  */
 
-function raceBoth_1(self, that, capacity = () => 16) {
-  return raceWith_1(self, that, selfDone => tsplus_module_25.done(tsplus_module_9.map_(tsplus_module_9.fromExitNow(selfDone, fileName_1 + ":1149:52"), tsplus_module_24.left, fileName_1 + ":1149:66")), thatDone => tsplus_module_25.done(tsplus_module_9.map_(tsplus_module_9.fromExitNow(thatDone, fileName_1 + ":1150:52"), tsplus_module_24.right, fileName_1 + ":1150:66")), capacity, fileName_1 + ":1147:23");
+function raceBoth_1(self, that, capacity = () => 16, __tsplusTrace) {
+  return raceWith_1(self, that, selfDone => tsplus_module_27.done(tsplus_module_9.map_(tsplus_module_9.fromExitNow(selfDone, __tsplusTrace), tsplus_module_26.left, __tsplusTrace)), thatDone => tsplus_module_27.done(tsplus_module_9.map_(tsplus_module_9.fromExitNow(thatDone, __tsplusTrace), tsplus_module_26.right, __tsplusTrace)), capacity, __tsplusTrace);
 }
 /**
+ * Runs both sinks in parallel on the input, using the specified merge
+ * function as soon as one result or the other has been computed.
+ *
  * @tsplus fluent fncts.io.Sink raceWith
  */
 
@@ -873,16 +1128,18 @@ function raceWith_1(self, that, leftDone, rightDone, capacity = () => 16, __tspl
   const scoped = tsplus_module_9.defer(() => {
     const that0 = that();
     const capacity0 = capacity();
-    return tsplus_module_9.flatMap_(tsplus_module_27.makeBounded(capacity()), hub => tsplus_module_9.flatMap_(tsplus_module_4.fromHubScoped(() => hub), c1 => tsplus_module_9.map_(tsplus_module_4.fromHubScoped(() => hub), c2 => {
+    return tsplus_module_9.flatMap_(tsplus_module_29.makeBounded(capacity()), hub => tsplus_module_9.flatMap_(tsplus_module_4.fromHubScoped(() => hub), c1 => tsplus_module_9.map_(tsplus_module_4.fromHubScoped(() => hub), c2 => {
       const reader = tsplus_module_4.toHub(() => hub);
-      const writer = tsplus_module_26.mergeWith_(tsplus_module_4.pipeTo_(c1, self.channel), tsplus_module_4.pipeTo_(c2, that0.channel), leftDone, rightDone);
-      const channel = tsplus_module_26.mergeWith_(reader, writer, () => tsplus_module_25.wait(tsplus_module_9.fromExitNow), done => tsplus_module_25.done(tsplus_module_9.fromExitNow(done, __tsplusTrace)));
+      const writer = tsplus_module_28.mergeWith_(tsplus_module_4.pipeTo_(c1, self.channel), tsplus_module_4.pipeTo_(c2, that0.channel), leftDone, rightDone);
+      const channel = tsplus_module_28.mergeWith_(reader, writer, () => tsplus_module_27.wait(tsplus_module_9.fromExitNow), done => tsplus_module_27.done(tsplus_module_9.fromExitNow(done, __tsplusTrace)));
       return new tsplus_module_3.Sink(channel);
     }, __tsplusTrace), __tsplusTrace), __tsplusTrace);
   }, __tsplusTrace);
-  return unwrapScoped_1(() => scoped);
+  return unwrapScoped_1(() => scoped, __tsplusTrace);
 }
 /**
+ * Accesses the specified service in the environment of the effect.
+ *
  * @tsplus static fncts.io.SinkOps service
  */
 
@@ -891,18 +1148,23 @@ export function service(
 /** @tsplus auto */
 tag) {
   const tag_1 = tag;
-  return serviceWith_1(tsplus_module_12.identity, tag_1);
+  return serviceWith_1(tsplus_module_14.identity, tag_1);
 }
 /**
+ * Accesses the specified service in the environment of the sink.
+ *
  * @tsplus static fncts.io.SinkOps serviceWith
  */
 
 function serviceWith_1(f,
 /** @tsplus auto */
 tag) {
-  return fromIO_1(() => tsplus_module_11.serviceWith(f, tag));
+  return fromIO_1(() => tsplus_module_13.serviceWith(f, tag), fileName_1 + ":1523:21");
 }
 /**
+ * Accesses the specified service in the environment of the sink in the
+ * context of an effect.
+ *
  * @tsplus static fncts.io.SinkOps serviceWithIO
  */
 
@@ -910,22 +1172,29 @@ tag) {
 export function serviceWithIO(f,
 /** @tsplus auto */
 tag) {
-  return fromIO_1(() => tsplus_module_11.serviceWithIO(f, tag, fileName_1 + ":1210:38"));
+  return fromIO_1(() => tsplus_module_13.serviceWithIO(f, tag, fileName_1 + ":1536:38"), fileName_1 + ":1536:21");
 }
 /**
+ * Accesses the specified service in the environment of the sink in the
+ * context of a sink.
+ *
  * @tsplus static fncts.io.SinkOps serviceWithSink
  */
 
 export function serviceWithSink(f,
 /** @tsplus auto */
 tag) {
-  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_11.serviceWith(tsplus_module_12.compose_(f, s => s.channel), tag)));
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_13.serviceWith(tsplus_module_14.compose_(f, s => s.channel), tag)));
 }
 /**
+ * Splits the sink on the specified predicate, returning a new sink that
+ * consumes elements until an element after the first satisfies the specified
+ * predicate.
+ *
  * @tsplus fluent fncts.io.Sink splitWhere
  */
 
-export function splitWhere(self, p) {
+export function splitWhere(self, p, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_8.make(() => tsplus_module_1.empty())), ref => tsplus_module_5.flatMap_(tsplus_module_4.collectElements(tsplus_module_4.pipeToOrFail_(splitter(p, false, ref), self.channel)), ([leftovers, z]) => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_7.get(ref)), leftover => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(tsplus_module_2.concat_(leftover, tsplus_module_2.flatten(leftovers))), tsplus_module_5.succeedNow(z))))));
 }
 
@@ -934,7 +1203,7 @@ function splitter(p, written, leftovers) {
     if (tsplus_module_2.isEmpty(inp)) {
       return splitter(p, written, leftovers);
     } else if (written) {
-      const index = tsplus_module_28.findIndex(inp, p);
+      const index = tsplus_module_30.findIndex(inp, p);
 
       if (index === -1) {
         return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(inp), splitter(p, true, leftovers));
@@ -943,7 +1212,7 @@ function splitter(p, written, leftovers) {
         return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(left), tsplus_module_4.fromIO(() => tsplus_module_6.set_(leftovers, right)));
       }
     } else {
-      const index = tsplus_module_28.findIndex(inp, p);
+      const index = tsplus_module_30.findIndex(inp, p);
 
       if (index === -1) {
         return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(inp), splitter(p, true, leftovers));
@@ -955,6 +1224,8 @@ function splitter(p, written, leftovers) {
   }, tsplus_module_5.failCauseNow, tsplus_module_5.succeedNow);
 }
 /**
+ * A sink that immediately ends with the specified value.
+ *
  * @tsplus static fncts.io.SinkOps succeed
  */
 
@@ -963,6 +1234,8 @@ export function succeed(z, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_5.succeed(z));
 }
 /**
+ * A sink that immediately ends with the specified value.
+ *
  * @tsplus static fncts.io.SinkOps succeedNow
  */
 
@@ -970,6 +1243,9 @@ export function succeedNow(z, __tsplusTrace) {
   return new tsplus_module_3.Sink(tsplus_module_5.succeedNow(z));
 }
 /**
+ * Summarize a sink by running an effect when the sink starts and again when
+ * it completes
+ *
  * @tsplus fluent fncts.io.Sink summarized
  */
 
@@ -982,14 +1258,16 @@ function summarized_1(self, summary, f, __tsplusTrace) {
 
 
 export function timed(self, __tsplusTrace) {
-  return summarized_1(self, () => tsplus_module_29.currentTime, (start, end) => tsplus_module_30.fromInterval(start, end), __tsplusTrace);
+  return summarized_1(self, () => tsplus_module_31.currentTime, (start, end) => tsplus_module_32.fromInterval(start, end), __tsplusTrace);
 }
 /**
+ * Creates a sink produced from an effect.
+ *
  * @tsplus static fncts.io.SinkOps unwrap
  */
 
 function unwrap_1(io) {
-  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_9.map_(io(), sink => sink.channel, fileName_1 + ":1332:42")));
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_9.map_(io(), sink => sink.channel, fileName_1 + ":1675:42")));
 }
 /**
  * Creates a sink produced from a scoped effect.
@@ -998,23 +1276,30 @@ function unwrap_1(io) {
  */
 
 
-function unwrapScoped_1(scoped) {
-  return new tsplus_module_3.Sink(tsplus_module_4.unwrapScoped(() => tsplus_module_9.map_(scoped(), sink => sink.channel, fileName_1 + ":1343:52")));
+function unwrapScoped_1(scoped, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrapScoped(() => tsplus_module_9.map_(scoped(), sink => sink.channel, __tsplusTrace)));
 }
 /**
+ * Feeds inputs to this sink until it yields a result, then switches over to
+ * the provided sink until it yields a result, finally combining the two
+ * results into a tuple.
+ *
  * @tsplus fluent fncts.io.Sink zip
  */
 
 
-export function zip(self, that) {
-  return zipWith_1(() => self, that, tsplus_module_12.tuple);
+export function zip(self, that, __tsplusTrace) {
+  return zipWith_1(() => self, that, tsplus_module_14.tuple, __tsplusTrace);
 }
 /**
+ * Runs both sinks in parallel on the input and combines the results in a
+ * tuple.
+ *
  * @tsplus fluent fncts.io.Sink zipC
  */
 
-export function zipC(self, that) {
-  return zipWithC_1(() => self, that, tsplus_module_12.tuple);
+export function zipC(self, that, __tsplusTrace) {
+  return zipWithC_1(() => self, that, tsplus_module_14.tuple, __tsplusTrace);
 }
 /**
  * Feeds inputs to this sink until it yields a result, then switches over to
@@ -1024,8 +1309,8 @@ export function zipC(self, that) {
  * @tsplus fluent fncts.io.Sink zipWith
  */
 
-function zipWith_1(self, that, f) {
-  return defer_1(() => flatMap_1(self(), z => map_1(that(), z1 => f(z, z1), fileName_1 + ":1378:53"), fileName_1 + ":1378:35"));
+function zipWith_1(self, that, f, __tsplusTrace) {
+  return defer_1(() => flatMap_1(self(), z => map_1(that(), z1 => f(z, z1), __tsplusTrace), __tsplusTrace), __tsplusTrace);
 }
 /**
  * Runs both sinks in parallel on the input and combines the results using the
@@ -1035,7 +1320,7 @@ function zipWith_1(self, that, f) {
  */
 
 
-function zipWithC_1(self, that, f) {
-  return defer_1(() => raceWith_1(self(), () => that(), exit => tsplus_module_31.match_(exit, err => tsplus_module_25.done(tsplus_module_9.failCauseNow(err, fileName_1 + ":1397:54")), lz => tsplus_module_25.wait(exit => tsplus_module_31.match_(exit, cause => tsplus_module_9.failCauseNow(cause, fileName_1 + ":1401:43"), rz => tsplus_module_9.succeedNow(f(lz, rz), fileName_1 + ":1402:38")))), exit => tsplus_module_31.match_(exit, err => tsplus_module_25.done(tsplus_module_9.failCauseNow(err, fileName_1 + ":1408:54")), rz => tsplus_module_25.wait(exit => tsplus_module_31.match_(exit, cause => tsplus_module_9.failCauseNow(cause, fileName_1 + ":1412:43"), lz => tsplus_module_9.succeedNow(f(lz, rz), fileName_1 + ":1413:38"))))));
+function zipWithC_1(self, that, f, __tsplusTrace) {
+  return defer_1(() => raceWith_1(self(), () => that(), exit => tsplus_module_33.match_(exit, err => tsplus_module_27.done(tsplus_module_9.failCauseNow(err, __tsplusTrace)), lz => tsplus_module_27.wait(exit => tsplus_module_33.match_(exit, cause => tsplus_module_9.failCauseNow(cause, __tsplusTrace), rz => tsplus_module_9.succeedNow(f(lz, rz), __tsplusTrace)))), exit => tsplus_module_33.match_(exit, err => tsplus_module_27.done(tsplus_module_9.failCauseNow(err, __tsplusTrace)), rz => tsplus_module_27.wait(exit => tsplus_module_33.match_(exit, cause => tsplus_module_9.failCauseNow(cause, __tsplusTrace), lz => tsplus_module_9.succeedNow(f(lz, rz), __tsplusTrace))))), __tsplusTrace);
 }
 //# sourceMappingURL=api.mjs.map