effect 4.0.0-rc.118 → 4.0.1

package/dist/Stream.js

@@ -5219,19 +5219,15 @@ export const mapAccumArrayEffect = /*#__PURE__*/dual(args => isStream(args[0]),
  * @since 2.0.0
  */
 export const scan = /*#__PURE__*/dual(3, (self, initial, f) => suspend(() => {
-  let isFirst = true;
-  return fromChannel(Channel.mapAccum(self.channel, initial, (state, arr) => {
+  const seed = initial();
+  return concat(succeed(seed), fromChannel(Channel.mapAccum(self.channel, () => seed, (state, arr) => {
     const states = Arr.empty();
-    if (isFirst) {
-      isFirst = false;
-      states.push(state);
-    }
     for (let index = 0; index < arr.length; index++) {
       state = f(state, arr[index]);
       states.push(state);
     }
     return [state, Arr.of(states)];
-  }));
+  })));
 }));
 /**
  * Accumulates state effectfully and emits the initial state plus each accumulated state.
@@ -5405,31 +5401,30 @@ const throttleShapeEffect = (self, cost, units, duration, burst) => transformPul
   const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));
   const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
   let tokens = units;
-  let timestampMs = clock.currentTimeMillisUnsafe();
+  let timestampNanos = clock.monotonicTimeNanosUnsafe();
   return Effect.succeed(Effect.flatMap(pull, arr => Effect.flatMap(cost(arr), weight => {
-    const currentMs = clock.currentTimeMillisUnsafe();
-    const elapsed = currentMs - timestampMs;
+    const currentNanos = clock.monotonicTimeNanosUnsafe();
+    const elapsed = Number(currentNanos - timestampNanos) / 1_000_000;
     const cycles = elapsed / durationMs;
     const sum = tokens + cycles * units;
-    const available = sum < 0 ? max : Math.min(sum, max);
+    const available = Math.min(sum, max);
     const remaining = available - weight;
     if (remaining >= 0) {
       tokens = remaining;
-      timestampMs = currentMs;
+      timestampNanos = currentNanos;
       return Effect.succeed(arr);
     }
-    // Calculate delay needed
     const waitCycles = -remaining / units;
     const delayMs = Math.max(0, waitCycles * durationMs);
     if (delayMs > 0) {
       return Effect.flatMap(Effect.sleep(delayMs), () => {
         tokens = remaining;
-        timestampMs = currentMs;
+        timestampNanos = currentNanos;
         return Effect.succeed(arr);
       });
     }
     tokens = remaining;
-    timestampMs = currentMs;
+    timestampNanos = currentNanos;
     return Effect.succeed(arr);
   })));
 }));
@@ -5515,8 +5510,9 @@ export const grouped = /*#__PURE__*/dual(2, (self, n) => chunks(rechunk(self, n)
  *
  * **Details**
  *
- * Finite fractional chunk sizes are rounded down. `NaN` and non-positive sizes
- * are treated as `1`.
+ * The duration starts when the first element of a group arrives, so an idle
+ * stream does not wake up. Finite fractional chunk sizes are rounded down.
+ * `NaN` and non-positive sizes are treated as `1`.
  *
  * **Example** (Grouping elements by size or time)
  *
@@ -5784,6 +5780,18 @@ export const aggregate = /*#__PURE__*/dual(2, (self, sink) => aggregateWithin(se
  * **Details**
  *
  * The schedule can flush the current aggregation even if the sink has not finished.
+ * It is stepped at most once per aggregation, when the aggregation receives its
+ * first element, with the previous aggregation's output as input. An aggregation
+ * the sink completes immediately, such as one built from leftovers, may finish
+ * without stepping the schedule.
+ *
+ * Time between aggregations is hidden from the schedule, so an idle stream does
+ * not run it. Time-based schedules such as `Schedule.fixed` and
+ * `Schedule.upTo({ duration })` only count time spent aggregating; use
+ * `Schedule.spaced` for a flush timer.
+ *
+ * When the schedule ends, the stream emits the current aggregation and any sink
+ * leftovers, then ends without pulling more from upstream.
  *
  * **Example** (Aggregating with a sink and schedule)
  *
@@ -5813,55 +5821,58 @@ export const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fr
   const buffer = yield* Queue.make({
     capacity: 0
   });
-  // upstream -> buffer
   yield* pull.pipe(pullLatch.whenOpen, Effect.flatMap(arr => {
     pullLatch.closeUnsafe();
     return Queue.offer(buffer, arr);
   }), Effect.forever,
-  // don't disable autoYield to prevent choking the schedule
+  // Keep autoYield enabled so the schedule can run.
   Effect.catchCause(cause => Queue.failCause(buffer, cause)), Effect.forkIn(scope));
-  // schedule -> buffer
+  // The schedule clock excludes time between aggregations.
+  const clock = yield* Clock;
+  const step = yield* Schedule.toStep(schedule);
+  const hasInput = Latch.makeUnsafe(false);
+  let scheduleTime = clock.currentTimeMillisUnsafe();
+  let openedAt = 0;
   let lastOutput = Option.none();
   let leftover;
-  let sinkHasInput = false;
-  const step = yield* Schedule.toStepWithSleep(schedule);
-  const stepLoop = Effect.suspend(function loop() {
-    return Effect.flatMap(step(lastOutput), () => !sinkHasInput ? loop() : Queue.offer(buffer, scheduleStep));
-  });
-  const stepToBuffer = stepLoop.pipe(Effect.flatMap(() => Effect.never), Pull.catchDone(() => Cause.done()));
-  // buffer -> sink
-  const pullFromBuffer = Queue.take(buffer).pipe(Effect.flatMap(arr => {
-    if (arr === scheduleStep) {
-      return Cause.done();
+  const onInput = chunk => {
+    if (hasInput.openUnsafe()) {
+      openedAt = clock.currentTimeMillisUnsafe();
     }
-    sinkHasInput = true;
-    return Effect.succeed(arr);
-  }));
+    return Effect.succeed(chunk);
+  };
+  const stepToBuffer = hasInput.await.pipe(Effect.flatMap(() => step(scheduleTime, lastOutput)), Effect.flatMap(([, delay]) => Effect.sleep(delay)), Effect.flatMap(() => Queue.offer(buffer, scheduleStep)),
+  // End input so the sink drains leftovers without further upstream pulls.
+  Pull.catchDone(() => Queue.end(buffer)), Effect.flatMap(() => Effect.never));
   const sinkUpstream = Effect.suspend(() => {
     if (leftover !== undefined) {
       const chunk = leftover;
       leftover = undefined;
-      sinkHasInput = true;
-      return Effect.succeed(chunk);
+      return onInput(chunk);
     }
-    pullLatch.openUnsafe();
-    return pullFromBuffer;
+    if (buffer.state._tag === "Open") {
+      pullLatch.openUnsafe();
+    }
+    return Effect.flatMap(Queue.take(buffer), arr => arr === scheduleStep ? Cause.done() : onInput(arr));
   });
-  const catchSinkHalt = Effect.flatMap(([value, leftover_]) => {
-    // ignore the last output if the upstream only pulled a halt
-    if (!sinkHasInput && buffer.state._tag === "Done") return Cause.done();
+  const emit = Effect.flatMap(([value, leftover_]) => {
+    if (hasInput.isOpen()) {
+      scheduleTime += clock.currentTimeMillisUnsafe() - openedAt;
+    } else if (buffer.state._tag === "Done") {
+      return Cause.done();
+    }
     lastOutput = Option.some(value);
     leftover = leftover_;
     return Effect.succeed(Arr.of(value));
   });
   return Effect.suspend(() => {
-    // if the buffer has exited and there is no more data to process
     if (buffer.state._tag === "Done" && leftover === undefined) {
       return buffer.state.exit;
     }
-    sinkHasInput = leftover !== undefined;
-    return Effect.succeed(Effect.suspend(() => sink.transform(sinkUpstream, scope)));
-  }).pipe(Effect.flatMap(pull => Effect.raceFirst(catchSinkHalt(pull), stepToBuffer)));
+    hasInput.closeUnsafe();
+    const pull = emit(Effect.suspend(() => sink.transform(sinkUpstream, scope)));
+    return buffer.state._tag === "Open" ? Effect.raceFirst(pull, stepToBuffer) : pull;
+  });
 }))));
 /**
  * Creates a fixed-size tuple of streams that each emit