effect 4.0.0-beta.4 → 4.0.0-beta.40

package/dist/Stream.js

@@ -12,12 +12,12 @@ import * as Equal from "./Equal.js";
 import * as ExecutionPlan from "./ExecutionPlan.js";
 import * as Exit from "./Exit.js";
 import * as Fiber from "./Fiber.js";
-import * as Filter from "./Filter.js";
 import { constant, constTrue, constVoid, dual, identity } from "./Function.js";
 import * as internalExecutionPlan from "./internal/executionPlan.js";
 import * as internal from "./internal/stream.js";
 import { addSpanStackTrace } from "./internal/tracer.js";
 import * as Iterable from "./Iterable.js";
+import * as Latch from "./Latch.js";
 import * as MutableHashMap from "./MutableHashMap.js";
 import * as MutableList from "./MutableList.js";
 import * as Option from "./Option.js";
@@ -32,7 +32,11 @@ import * as Scope from "./Scope.js";
 import * as ServiceMap from "./ServiceMap.js";
 import * as Sink from "./Sink.js";
 import { isString } from "./String.js";
-const TypeId = "~effect/Stream";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const TypeId = "~effect/Stream";
 /**
  * Checks whether a value is a Stream.
  *
@@ -667,6 +671,10 @@ export const fromIteratorSucceed = (iterator, maxChunkSize) => fromChannel(Chann
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
+ * **Options**
+ *
+ * - `chunkSize`: Maximum number of values emitted per chunk.
+ *
  * @example
  * ```ts
  * import { Console, Effect, Stream } from "effect"
@@ -686,7 +694,7 @@ export const fromIteratorSucceed = (iterator, maxChunkSize) => fromChannel(Chann
  * @since 2.0.0
  * @category Constructors
  */
-export const fromIterable = iterable => Array.isArray(iterable) ? fromArray(iterable) : fromChannel(Channel.fromIterableArray(iterable));
+export const fromIterable = (iterable, options) => Array.isArray(iterable) && options?.chunkSize === undefined ? fromArray(iterable) : fromChannel(Channel.fromIterableArray(iterable, options?.chunkSize));
 /**
  * Creates a stream from an effect producing an iterable of values.
  *
@@ -927,7 +935,9 @@ export const fromPubSubTake = pubsub => fromChannel(Channel.fromPubSubTake(pubsu
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const readableStream = new ReadableStream({
  *   start(controller) {
@@ -941,7 +951,7 @@ export const fromPubSubTake = pubsub => fromChannel(Channel.fromPubSubTake(pubsu
  * const program = Effect.gen(function*() {
  *   const stream = Stream.fromReadableStream({
  *     evaluate: () => readableStream,
- *     onError: (error) => new Error(String(error))
+ *     onError: (cause) => new StreamError({ cause })
  *   })
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
@@ -970,7 +980,9 @@ export const fromReadableStream = options => fromChannel(Channel.fromTransform(E
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const iterable = (async function*() {
  *   yield 1
@@ -979,7 +991,7 @@ export const fromReadableStream = options => fromChannel(Channel.fromTransform(E
  * })()
  *
  * const program = Effect.gen(function*() {
- *   const stream = Stream.fromAsyncIterable(iterable, (error) => new Error(String(error)))
+ *   const stream = Stream.fromAsyncIterable(iterable, (cause) => new StreamError({ cause }))
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
  * })
@@ -1002,7 +1014,7 @@ export const fromAsyncIterable = (iterable, onError) => fromChannel(Channel.from
  *
  * const program = Effect.gen(function*() {
  *   const schedule = Schedule.spaced("50 millis").pipe(
- *     Schedule.compose(Schedule.recurs(2))
+ *     Schedule.both(Schedule.recurs(2))
  *   )
  *   const stream = Stream.fromSchedule(schedule)
  *   const values = yield* Stream.runCollect(stream)
@@ -1588,8 +1600,8 @@ export const tapBoth = /*#__PURE__*/dual(2, (self, options) => self.pipe(tapErro
  * @category Sequencing
  */
 export const tapSink = /*#__PURE__*/dual(2, (self, sink) => transformPullBracket(self, Effect.fnUntraced(function* (pull, _, scope) {
-  const upstreamLatch = Effect.makeLatchUnsafe();
-  const sinkLatch = Effect.makeLatchUnsafe();
+  const upstreamLatch = Latch.makeUnsafe();
+  const sinkLatch = Latch.makeUnsafe();
   let chunk = undefined;
   let causeSink = undefined;
   let sinkDone = false;
@@ -1851,10 +1863,52 @@ export const schedule = /*#__PURE__*/dual(2, (self, schedule) => self.channel.pi
  * @since 2.0.0
  * @category Rate Limiting
  */
-export const timeout = /*#__PURE__*/dual(2, (self, duration) => transformPull(self, (pull, _scope) => Effect.succeed(Effect.timeoutOrElse(pull, {
+export const timeout = /*#__PURE__*/dual(2, (self, duration) => timeoutOrElse(self, {
   duration,
-  onTimeout: () => Cause.done()
-}))));
+  orElse: () => empty
+}));
+/**
+ * @since 2.0.0
+ * @category Rate Limiting
+ */
+export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => {
+  const duration = Duration.fromInputUnsafe(options.duration);
+  if (!Duration.isFinite(duration)) return self;
+  if (Duration.isZero(duration)) return suspend(options.orElse);
+  const timeoutSymbol = Symbol();
+  return catchCause(suspend(() => {
+    const parent = Fiber.getCurrent();
+    const clock = parent.getRef(Clock);
+    const durationMs = Duration.toMillis(duration);
+    let deadline = undefined;
+    const latch = Latch.makeUnsafe(false);
+    return merge(transformPull(self, (pull, _scope) => Effect.suspend(() => {
+      deadline = clock.currentTimeMillisUnsafe() + durationMs;
+      latch.openUnsafe();
+      return pull;
+    }).pipe(Effect.map(arr => {
+      latch.closeUnsafe();
+      deadline = undefined;
+      return arr;
+    }), Effect.succeed)), fromEffectDrain(Effect.gen(function* () {
+      while (true) {
+        yield* latch.await;
+        if (deadline === undefined) continue;
+        yield* Effect.sleep(deadline - clock.currentTimeMillisUnsafe());
+        if (deadline === undefined) continue;
+        const remaining = deadline - clock.currentTimeMillisUnsafe();
+        if (remaining > 0) continue;
+        return yield* Effect.die(timeoutSymbol);
+      }
+    })), {
+      haltStrategy: "left"
+    });
+  }), cause => {
+    const isTimeout = cause.reasons.find(r => r._tag === "Die" && r.defect === timeoutSymbol);
+    if (isTimeout) return options.orElse();
+    return failCause(cause);
+  });
+});
 /**
  * Repeats each element of the stream according to the provided schedule,
  * including the original emission.
@@ -2040,7 +2094,7 @@ export const prepend = /*#__PURE__*/dual(2, (self, values) => concat(fromIterabl
  * @since 2.0.0
  * @category Merging
  */
-export const merge = /*#__PURE__*/dual(2, (self, that, options) => fromChannel(Channel.merge(toChannel(self), toChannel(that), options)));
+export const merge = /*#__PURE__*/dual(args => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel(Channel.merge(toChannel(self), toChannel(that), options)));
 /**
  * Merges this stream with a background effect, keeping the stream's elements.
  *
@@ -2647,7 +2701,7 @@ export const zipWithPreviousAndNext = self => mapAccumArray(self, () => ({
 export const zipLatestAll = (...streams) => fromChannel(Channel.suspend(() => {
   const latest = [];
   const emitted = new Set();
-  const readyLatch = Effect.makeLatchUnsafe();
+  const readyLatch = Latch.makeUnsafe();
   return Channel.mergeAll(Channel.fromArray(streams.map((s, i) => s.channel.pipe(Channel.flattenArray, Channel.mapEffect(a => {
     latest[i] = a;
     if (!emitted.has(i)) {
@@ -2807,19 +2861,22 @@ export const race = /*#__PURE__*/dual(2, (left, right) => raceAll(left, right));
  * @since 2.0.0
  * @category Filtering
  */
-export const filter = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterArray(toChannel(self), filter)));
+export const filter = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArray(toChannel(self), predicate)));
 /**
- * Effectfully filters and maps elements in a single pass.
+ * Filters and maps stream elements in one pass using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMap = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArray(toChannel(self), filter)));
+/**
+ * Effectfully filters elements in a single pass.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
- *
- * const filter = Filter.makeEffect((n: number) =>
- *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
- * )
+ * import { Console, Effect, Stream } from "effect"
  *
- * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+ * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
  *
  * const program = Effect.gen(function*() {
  *   const result = yield* Stream.runCollect(stream)
@@ -2827,27 +2884,32 @@ export const filter = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
  * @category Filtering
  */
-export const filterEffect = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterArrayEffect(toChannel(self), filter)));
+export const filterEffect = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArrayEffect(toChannel(self), predicate)));
 /**
- * Partitions a stream using a Filter and exposes passing and failing values as queues.
+ * Effectfully filters and maps elements in a single pass.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapEffect = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArrayEffect(toChannel(self), filter)));
+/**
+ * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
  *
  * Each queue fails with the stream error or `Cause.Done` when the source ends.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
- *     Stream.partitionQueue(
- *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
- *     )
+ *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
  *   )
  *
  *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -2875,11 +2937,19 @@ export const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__
   const fails = yield* Queue.make({
     capacity
   });
-  const partitionArr = Arr.partition(filter);
   yield* Effect.gen(function* () {
     while (true) {
       const chunk = yield* pull;
-      const [excluded, satisfying] = partitionArr(chunk);
+      const excluded = [];
+      const satisfying = [];
+      for (let i = 0; i < chunk.length; i++) {
+        const result = filter(chunk[i]);
+        if (Result.isFailure(result)) {
+          excluded.push(result.failure);
+        } else {
+          satisfying.push(result.success);
+        }
+      }
       let passFiber = undefined;
       if (satisfying.length > 0) {
         const leftover = Queue.offerAllUnsafe(passes, satisfying);
@@ -2903,38 +2973,14 @@ export const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__
   return [passes, fails];
 }));
 /**
- * Splits a stream using an effectful filter, producing pass and fail streams.
+ * Splits a stream using an effectful `Filter`, producing pass and fail streams.
  *
  * @since 4.0.0
  * @category Filtering
- *
- * @example
- * ```ts
- * import { Console, Effect, Result, Stream } from "effect"
- *
- * const program = Effect.scoped(
- *   Effect.gen(function*() {
- *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
- *       Stream.partitionEffect((n) =>
- *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- *       )
- *     )
- *     const result = yield* Effect.all({
- *       evens: Stream.runCollect(evens),
- *       odds: Stream.runCollect(odds)
- *     })
- *     yield* Console.log(result)
- *   })
- * )
- *
- * Effect.runPromise(program)
- * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
- * ```
  */
-export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(self.pipe(mapEffect(filter, options), partitionQueue(identity, options)), ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]));
+export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(mapEffect(self, a => filter(a), options), result => result, options), ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]));
 /**
- * Splits a stream into excluded and satisfying substreams using a predicate,
- * refinement, or Filter.
+ * Splits a stream into excluded and satisfying substreams using a `Filter`.
  *
  * The faster stream may advance up to `bufferSize` elements ahead of the slower
  * one.
@@ -2944,12 +2990,12 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [excluded, satisfying] = yield* Stream.partition(
  *     Stream.make(1, 2, 3, 4),
- *     (n) => n % 2 === 0
+ *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
  *   )
  *   const left = yield* Stream.runCollect(excluded)
  *   const right = yield* Stream.runCollect(satisfying)
@@ -2960,9 +3006,9 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  * })
  * ```
  */
-export const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(filter, {
+export const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(self, filter, {
   capacity: options?.bufferSize ?? 16
-})(self), ([passes, fails]) => [fromQueue(fails), fromQueue(passes)]));
+}), ([passes, fails]) => [fromQueue(fails), fromQueue(passes)]));
 /**
  * Returns the specified stream if the given condition is satisfied, otherwise
  * returns an empty stream.
@@ -3218,7 +3264,7 @@ catch_ as catch };
  */
 export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Channel.tapError(f), fromChannel));
 /**
- * Recovers from errors that match a filter by switching to a recovery stream.
+ * Recovers from errors that match a predicate by switching to a recovery stream.
  *
  * When a failure matches the filter, the stream switches to the recovery
  * stream. Non-matching failures propagate downstream, so the error type is
@@ -3232,12 +3278,12 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Chan
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Stream } from "effect"
+ * import { Console, Effect, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2).pipe(
  *   Stream.concat(Stream.fail(42)),
  *   Stream.catchIf(
- *     Filter.fromPredicate((error): error is 42 => error === 42),
+ *     (error): error is 42 => error === 42,
  *     () => Stream.make(999)
  *   )
  * )
@@ -3254,7 +3300,15 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Chan
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchIf = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, f, orElse) => fromChannel(Channel.catchIf(toChannel(self), filter, e => f(e).channel, orElse && (e => orElse(e).channel))));
+export const catchIf = /*#__PURE__*/dual(args => isStream(args[0]), (self, predicate, f, orElse) => fromChannel(Channel.catchIf(toChannel(self), predicate, e => f(e).channel, orElse && (e => orElse(e).channel))));
+/**
+ * Recovers from errors that match a `Filter` by switching to a recovery
+ * stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchFilter = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, f, orElse) => fromChannel(Channel.catchFilter(toChannel(self), filter, e => f(e).channel, orElse && (e => orElse(e).channel))));
 /**
  * Recovers from failures whose `_tag` matches the provided value by switching to
  * the stream returned by `f`.
@@ -3330,7 +3384,7 @@ export const catchTag = /*#__PURE__*/dual(args => isStream(args[0]), (self, k, f
  */
 export const catchTags = /*#__PURE__*/dual(args => isStream(args[0]), (self, cases, orElse) => {
   let keys;
-  return catchIf(self, e => {
+  return catchFilter(self, e => {
     keys ??= Object.keys(cases);
     return hasProperty(e, "_tag") && isString(e["_tag"]) && keys.includes(e["_tag"]) ? Result.succeed(e) : Result.fail(e);
   }, e => cases[e["_tag"]](e), orElse);
@@ -3378,7 +3432,7 @@ export const catchTags = /*#__PURE__*/dual(args => isStream(args[0]), (self, cas
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchReason = /*#__PURE__*/dual(args => isStream(args[0]), (self, errorTag, reasonTag, f, orElse) => fromChannel(Channel.catchReason(toChannel(self), errorTag, reasonTag, reason => f(reason).channel, orElse && (reason => orElse(reason).channel))));
+export const catchReason = /*#__PURE__*/dual(args => isStream(args[0]), (self, errorTag, reasonTag, f, orElse) => fromChannel(Channel.catchReason(toChannel(self), errorTag, reasonTag, (reason, error) => f(reason, error).channel, orElse && ((reason, error) => orElse(reason, error).channel))));
 /**
  * Catches multiple reasons within a tagged error using an object of handlers.
  *
@@ -3424,9 +3478,9 @@ export const catchReasons = /*#__PURE__*/dual(args => isStream(args[0]), (self,
   const handlers = {};
   for (const key of Object.keys(cases)) {
     const handler = cases[key];
-    handlers[key] = reason => handler(reason).channel;
+    handlers[key] = (reason, error) => handler(reason, error).channel;
   }
-  const orElseHandler = orElse && (reason => orElse(reason).channel);
+  const orElseHandler = orElse && ((reason, error) => orElse(reason, error).channel);
   return fromChannel(Channel.catchReasons(self.channel, errorTag, handlers, orElseHandler));
 });
 /**
@@ -3486,7 +3540,15 @@ export const mapError = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.ma
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchCauseIf = /*#__PURE__*/dual(3, (self, filter, f) => fromChannel(Channel.catchCauseIf(self.channel, filter, (failure, cause) => f(failure, cause).channel)));
+export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => fromChannel(Channel.catchCauseIf(self.channel, predicate, cause => f(cause).channel)));
+/**
+ * Recovers from stream failures by filtering the `Cause` and switching to a
+ * recovery stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => fromChannel(Channel.catchCauseFilter(self.channel, filter, (failure, cause) => f(failure, cause).channel)));
 /**
  * Switches to a fallback stream if this stream is empty.
  *
@@ -3900,13 +3962,34 @@ export const takeUntilEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  * @since 2.0.0
  * @category Filtering
  */
-export const takeWhile = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+export const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {
   let i = 0;
   let done = false;
   const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {
     const out = [];
     for (let j = 0; j < chunk.length; j++) {
-      const result = Filter.apply(f, chunk[j], i++);
+      if (!predicate(chunk[j], i++)) {
+        done = true;
+        break;
+      }
+      out.push(chunk[j]);
+    }
+    return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : done ? Cause.done() : pump;
+  });
+  return pump;
+})));
+/**
+ * Takes the longest initial prefix of elements that satisfy the filter.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const takeWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+  let done = false;
+  const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {
+    const out = [];
+    for (let j = 0; j < chunk.length; j++) {
+      const result = filter(chunk[j]);
       if (Result.isFailure(result)) {
         done = true;
         break;
@@ -4043,11 +4126,27 @@ export const dropUntilEffect = /*#__PURE__*/dual(2, (self, predicate) => drop(dr
  * @since 2.0.0
  * @category Filtering
  */
-export const dropWhile = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+export const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {
   let dropping = true;
   let index = 0;
   const filtered = Effect.flatMap(pull, arr => {
-    const found = arr.findIndex(a => Result.isFailure(Filter.apply(f, a, index++)));
+    const found = arr.findIndex(a => !predicate(a, index++));
+    if (found === -1) return filtered;
+    dropping = false;
+    return Effect.succeed(arr.slice(found));
+  });
+  return Effect.suspend(() => dropping ? filtered : pull);
+})));
+/**
+ * Drops elements while the filter succeeds.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const dropWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+  let dropping = true;
+  const filtered = Effect.flatMap(pull, arr => {
+    const found = arr.findIndex(a => Result.isFailure(filter(a)));
     if (found === -1) return filtered;
     dropping = false;
     return Effect.succeed(arr.slice(found));
@@ -4639,13 +4738,13 @@ export const scanEffect = /*#__PURE__*/dual(3, (self, initial, f) => self.channe
  */
 export const debounce = /*#__PURE__*/dual(2, (self, duration) => transformPull(self, Effect.fnUntraced(function* (pull, scope) {
   const clock = yield* Clock;
-  const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration));
+  const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));
   let lastArr;
   let cause;
   let emitAtMs = Infinity;
-  const pullLatch = Effect.makeLatchUnsafe();
-  const emitLatch = Effect.makeLatchUnsafe();
-  const endLatch = Effect.makeLatchUnsafe();
+  const pullLatch = Latch.makeUnsafe();
+  const emitLatch = Latch.makeUnsafe();
+  const endLatch = Latch.makeUnsafe();
   yield* pull.pipe(pullLatch.whenOpen, Effect.flatMap(arr => {
     emitLatch.openUnsafe();
     lastArr = arr;
@@ -4736,7 +4835,7 @@ export const throttleEffect = /*#__PURE__*/dual(2, (self, options) => {
   return throttleShapeEffect(self, options.cost, options.units, options.duration, burst);
 });
 const throttleEnforceEffect = (self, cost, units, duration, burst) => transformPull(self, pull => Effect.clockWith(clock => {
-  const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration));
+  const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));
   const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
   let tokens = units;
   let timestampMs = clock.currentTimeMillisUnsafe();
@@ -4758,7 +4857,7 @@ const throttleEnforceEffect = (self, cost, units, duration, burst) => transformP
   }));
 }));
 const throttleShapeEffect = (self, cost, units, duration, burst) => transformPull(self, pull => Effect.clockWith(clock => {
-  const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration));
+  const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));
   const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
   let tokens = units;
   let timestampMs = clock.currentTimeMillisUnsafe();
@@ -5125,7 +5224,7 @@ export const aggregate = /*#__PURE__*/dual(2, (self, sink) => aggregateWithin(se
  */
 export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fromChannel(Channel.fromTransformBracket(Effect.fnUntraced(function* (_upstream, _, scope) {
   const pull = yield* Channel.toPullScoped(self.channel, _);
-  const pullLatch = Effect.makeLatchUnsafe(false);
+  const pullLatch = Latch.makeUnsafe(false);
   const scheduleStep = Symbol();
   const buffer = yield* Queue.make({
     capacity: 0
@@ -5141,11 +5240,13 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fr
   Effect.catchCause(cause => Queue.failCause(buffer, cause)), Effect.forkIn(scope));
   // schedule -> buffer
   let lastOutput = Option.none();
+  let leftover;
   const step = yield* Schedule.toStepWithSleep(schedule);
-  const stepToBuffer = Effect.suspend(() => step(lastOutput)).pipe(Effect.flatMap(() => Queue.offer(buffer, scheduleStep)), Effect.flatMap(() => Effect.never), Pull.catchDone(() => Cause.done()));
+  const stepToBuffer = Effect.suspend(function loop() {
+    return step(lastOutput).pipe(Effect.flatMap(() => !hadChunk && leftover === undefined ? loop() : Queue.offer(buffer, scheduleStep)), Effect.flatMap(() => Effect.never), Pull.catchDone(() => Cause.done()));
+  });
   // buffer -> sink
   const pullFromBuffer = Queue.take(buffer).pipe(Effect.flatMap(arr => arr === scheduleStep ? Cause.done() : Effect.succeed(arr)));
-  let leftover;
   const sinkUpstream = Effect.suspend(() => {
     if (leftover !== undefined) {
       const chunk = leftover;
@@ -5157,7 +5258,7 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fr
     return pullFromBuffer;
   });
   const catchSinkHalt = Effect.flatMap(([value, leftover_]) => {
-    // ignore the last output if the upsteam only pulled a halt
+    // ignore the last output if the upstream only pulled a halt
     if (!hadChunk && buffer.state._tag === "Done") return Cause.done();
     lastOutput = Option.some(value);
     leftover = leftover_;
@@ -6168,7 +6269,7 @@ export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateSe
 export const withSpan = function () {
   const dataFirst = isStream(arguments[0]);
   const name = dataFirst ? arguments[1] : arguments[0];
-  const options = addSpanStackTrace(dataFirst ? arguments[1] : arguments[2]);
+  const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]);
   if (dataFirst) {
     const self = arguments[0];
     return fromChannel(Channel.withSpan(self.channel, name, options));
@@ -6707,7 +6808,7 @@ export const mkUint8Array = self => Channel.runFold(self.channel, () => new Uint
 export const toReadableStreamWith = /*#__PURE__*/dual(args => isStream(args[0]), (self, services, options) => {
   let currentResolve = undefined;
   let fiber = undefined;
-  const latch = Effect.makeLatchUnsafe(false);
+  const latch = Latch.makeUnsafe(false);
   return new ReadableStream({
     start(controller) {
       fiber = Effect.runFork(Effect.provideServices(runForEachArray(self, chunk => latch.whenOpen(Effect.sync(() => {