effect 4.0.0-beta.94 → 4.0.0-beta.97

package/dist/Schedule.js

@@ -1,13 +1,3 @@
-/**
- * Describes policies for retrying, repeating, and pacing Effect programs.
- *
- * A `Schedule<Output, Input, Error, Env>` is stepped with an input value. Each
- * step either stops or produces an output together with the delay before the
- * next step. Schedules are used by retry, repeat, stream, and channel APIs to
- * decide when work should continue, how long to wait, and when to stop.
- *
- * @since 2.0.0
- */
 import * as Cause from "./Cause.js";
 import * as Context from "./Context.js";
 import * as Cron from "./Cron.js";
@@ -161,7 +151,7 @@ export const fromStepWithMetadata = step => fromStep(effect.map(step, f => {
  * import { Effect, Schedule } from "effect"
  *
  * // Extract step function from an existing schedule
- * const schedule = Schedule.exponential("100 millis").pipe(Schedule.take(3))
+ * const schedule = Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 3 }))
  *
  * const program = Effect.gen(function*() {
  *   const stepFn = yield* Schedule.toStep(schedule)
@@ -221,7 +211,7 @@ export const toStepWithMetadata = schedule => effect.clockWith(clock => effect.m
  * import { Effect, Schedule } from "effect"
  *
  * // Convert schedule to step function with automatic sleeping
- * const schedule = Schedule.spaced("1 second").pipe(Schedule.take(3))
+ * const schedule = Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 3 }))
  *
  * const program = Effect.gen(function*() {
  *   const stepWithSleep = yield* Schedule.toStepWithSleep(schedule)
@@ -254,10 +244,10 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  *
  * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
- * // Add a deterministic extra delay based on the schedule output
+ * // Add a deterministic extra delay based on the schedule metadata
  * const delayedSchedule = Schedule.addDelay(
- *   Schedule.exponential("100 millis").pipe(Schedule.take(5)),
- *   (output) =>
+ *   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 5 })),
+ *   ({ output }) =>
  *     Effect.succeed(Duration.millis(Duration.toMillis(output) * 0.25))
  * )
  *
@@ -265,7 +255,7 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  *   yield* Effect.repeat(
  *     Effect.succeed("delayed task"),
  *     delayedSchedule.pipe(
- *       Schedule.tapOutput((delay) =>
+ *       Schedule.tap(({ output: delay }) =>
  *         Console.log(`Base delay: ${delay}`)
  *       )
  *     )
@@ -275,7 +265,7 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  * // Add adaptive delay based on execution count
  * const adaptiveSchedule = Schedule.addDelay(
  *   Schedule.recurs(6),
- *   (executionCount) =>
+ *   ({ output: executionCount }) =>
  *     // Increase delay as execution count grows
  *     Effect.succeed(Duration.millis(executionCount * 200))
  * )
@@ -287,7 +277,7 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  *       return "adaptive"
  *     }),
  *     adaptiveSchedule.pipe(
- *       Schedule.tapOutput((count) =>
+ *       Schedule.tap(({ output: count }) =>
  *         Console.log(`Execution ${count + 1} with adaptive delay`)
  *       )
  *     )
@@ -298,8 +288,8 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  * const loadByExecution = [1, 3, 2, 4] as const
  *
  * const dynamicSchedule = Schedule.addDelay(
- *   Schedule.spaced("1 second").pipe(Schedule.take(4)),
- *   (executionNumber) => {
+ *   Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 4 })),
+ *   ({ output: executionNumber }) => {
  *     const load = loadByExecution[executionNumber] ?? 1
  *     return Effect.succeed(Duration.millis(load * 100))
  *   }
@@ -317,7 +307,7 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  *
  * // Combine with retry for progressive backoff
  * const progressiveRetrySchedule = Schedule.addDelay(
- *   Schedule.exponential("50 millis").pipe(Schedule.take(4)),
+ *   Schedule.exponential("50 millis").pipe(Schedule.upTo({ times: 4 })),
  *   () => Effect.succeed(Duration.millis(100)) // Fixed additional delay
  * )
  *
@@ -342,7 +332,7 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  * @category delays & timeouts
  * @since 2.0.0
  */
-export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, (output, delay) => effect.map(f(output), d => Duration.sum(Duration.fromInputUnsafe(d), Duration.fromInputUnsafe(delay)))));
+export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, metadata => effect.map(f(metadata), d => Duration.sum(Duration.fromInputUnsafe(d), metadata.duration))));
 /**
  * Returns a schedule that runs `self` to completion, then runs `other`, and
  * merges their outputs.
@@ -356,10 +346,10 @@ export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, (out
  *
  * // First retry 3 times quickly, then switch to slower retries
  * const quickRetries = Schedule.exponential("100 millis").pipe(
- *   Schedule.take(3)
+ *   Schedule.upTo({ times: 3 })
  * )
  * const slowRetries = Schedule.exponential("1 second").pipe(
- *   Schedule.take(2)
+ *   Schedule.upTo({ times: 2 })
  * )
  *
  * const combinedRetries = Schedule.andThen(quickRetries, slowRetries)
@@ -383,7 +373,9 @@ export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, (out
  * @category sequencing
  * @since 2.0.0
  */
-export const andThen = /*#__PURE__*/dual(2, (self, other) => map(andThenResult(self, other), result => effect.succeed(Result.merge(result))));
+export const andThen = /*#__PURE__*/dual(2, (self, other) => map(andThenResult(self, other), ({
+  output
+}) => effect.succeed(Result.merge(output))));
 /**
  * Returns a schedule that runs `self` to completion, then runs `other`, and
  * preserves which schedule produced each output.
@@ -401,8 +393,8 @@ export const andThen = /*#__PURE__*/dual(2, (self, other) => map(andThenResult(s
  *
  * // Track which phase of the schedule we're in
  * const phaseTracker = Schedule.andThenResult(
- *   Schedule.exponential("100 millis").pipe(Schedule.take(2)),
- *   Schedule.spaced("500 millis").pipe(Schedule.take(2))
+ *   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 2 })),
+ *   Schedule.spaced("500 millis").pipe(Schedule.upTo({ times: 2 }))
  * )
  *
  * const program = Effect.gen(function*() {
@@ -412,7 +404,7 @@ export const andThen = /*#__PURE__*/dual(2, (self, other) => map(andThenResult(s
  *       return "task-result"
  *     }),
  *     phaseTracker.pipe(
- *       Schedule.tapOutput((result) =>
+ *       Schedule.tap(({ output: result }) =>
  *         Result.match(result, {
  *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
  *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
@@ -429,8 +421,12 @@ export const andThen = /*#__PURE__*/dual(2, (self, other) => map(andThenResult(s
 export const andThenResult = /*#__PURE__*/dual(2, (self, other) => fromStep(effect.sync(() => {
   let currentSide = 0;
   let currentStep;
-  const left = map(self, Result.fail);
-  const right = map(other, Result.succeed);
+  const left = map(self, ({
+    output
+  }) => Result.fail(output));
+  const right = map(other, ({
+    output
+  }) => Result.succeed(output));
   return function recur(now, input) {
     if (currentStep) return currentStep(now, input);
     return toStep(currentSide === 0 ? left : right).pipe(effect.flatMap(step => {
@@ -448,366 +444,70 @@ export const andThenResult = /*#__PURE__*/dual(2, (self, other) => fromStep(effe
   };
 })));
 /**
- * Combines two `Schedule`s by recurring if both of the two schedules want
- * to recur, using the maximum of the two durations between recurrences and
- * outputting a tuple of the outputs of both schedules.
+ * Combines schedules by recurring while all schedules want to recur, using the
+ * maximum delay between recurrences and outputting that maximum delay.
  *
  * **When to use**
  *
- * Use when the combined schedule should continue only while both schedules still recur.
+ * Use when a combined policy should continue only while every schedule still
+ * recurs, and should wait for the slowest schedule between recurrences.
  *
- * **Example** (Combining time and attempt limits)
+ * **Example** (Combining retry schedules by their maximum delay)
  *
  * ```ts
  * import { Console, Data, Effect, Schedule } from "effect"
  *
  * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
- * // Both schedules must want to continue for the combined schedule to continue
- * const timeLimit = Schedule.spaced("1 second").pipe(Schedule.take(5)) // max 5 times
- * const attemptLimit = Schedule.recurs(3) // max 3 attempts
- *
- * // Continues only while BOTH schedules want to continue (intersection/AND logic)
- * const bothSchedule = Schedule.both(timeLimit, attemptLimit)
- * // Outputs: [time_result, attempt_count] tuple
+ * const retrySchedule = Schedule.max([
+ *   Schedule.fixed("5 seconds"),
+ *   Schedule.exponential("5 seconds"),
+ *   Schedule.spaced("10 seconds")
+ * ])
  *
  * const program = Effect.gen(function*() {
- *   const results = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task completed"
- *     }),
- *     bothSchedule.pipe(
- *       Schedule.tapOutput(([timeResult, attemptResult]) =>
- *         Console.log(`Time: ${timeResult}, Attempts: ${attemptResult}`)
- *       )
- *     )
- *   )
- *
- *   yield* Console.log("Completed all executions")
- * })
- *
- * // Both with different delay strategies - uses maximum delay
- * const fastSchedule = Schedule.fixed("500 millis").pipe(Schedule.take(4))
- * const slowSchedule = Schedule.spaced("2 seconds").pipe(Schedule.take(6))
- *
- * // Will use the slower (maximum) delay and stop when first schedule exhausts
- * const conservativeSchedule = Schedule.both(fastSchedule, slowSchedule)
- *
- * const retryProgram = Effect.gen(function*() {
  *   let attempt = 0
  *
- *   const result = yield* Effect.retry(
+ *   yield* Effect.retry(
  *     Effect.gen(function*() {
  *       attempt++
  *       yield* Console.log(`Retry attempt ${attempt}`)
- *
  *       if (attempt < 3) {
  *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
- *
- *       return `Success on attempt ${attempt}`
- *     }),
- *     conservativeSchedule
- *   )
- *
- *   yield* Console.log(`Final result: ${result}`)
- * })
- *
- * // Both provides intersection semantics (AND logic)
- * // Compare with either which provides union semantics (OR logic)
- * ```
- *
- * @see {@link either} for continuing while either schedule still recurs
- *
- * @category combining
- * @since 2.0.0
- */
-export const both = /*#__PURE__*/dual(2, (self, other) => bothWith(self, other, (left, right) => [left, right]));
-/**
- * Combines two `Schedule`s by recurring if both of the two schedules want
- * to recur, using the maximum of the two durations between recurrences and
- * outputting the result of the left schedule (i.e. `self`).
- *
- * **When to use**
- *
- * Use when two schedules must both allow recurrence and only the left schedule's
- * output is needed.
- *
- * **Example** (Combining schedules and keeping the left output)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Combine two schedules, keeping left output
- * const leftSchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.map(() => Effect.succeed("left-result"))
- * )
- * const rightSchedule = Schedule.spaced("50 millis")
- *
- * const combined = Schedule.bothLeft(leftSchedule, rightSchedule)
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task-done"
- *     }),
- *     combined.pipe(Schedule.take(3))
- *   )
- * })
- * ```
- *
- * @category combining
- * @since 2.0.0
- */
-export const bothLeft = /*#__PURE__*/dual(2, (self, other) => bothWith(self, other, output => output));
-/**
- * Combines two `Schedule`s by recurring if both of the two schedules want
- * to recur, using the maximum of the two durations between recurrences and
- * outputting the result of the right schedule (i.e. `other`).
- *
- * **When to use**
- *
- * Use when two schedules must both allow recurrence and only the right
- * schedule's output is needed.
- *
- * **Example** (Combining schedules and keeping the right output)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Combine two schedules, keeping right output
- * const leftSchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.map(() => Effect.succeed("left-result"))
- * )
- * const rightSchedule = Schedule.spaced("50 millis").pipe(
- *   Schedule.map(() => Effect.succeed("right-result"))
- * )
- *
- * const combined = Schedule.bothRight(leftSchedule, rightSchedule)
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task-done"
- *     }),
- *     combined.pipe(Schedule.take(3))
- *   )
- * })
- * ```
- *
- * @category combining
- * @since 2.0.0
- */
-export const bothRight = /*#__PURE__*/dual(2, (self, other) => bothWith(self, other, (_, output) => output));
-/**
- * Combines two `Schedule`s by recurring if both of the two schedules want
- * to recur, using the maximum of the two durations between recurrences and
- * outputting the result of the combination of both schedule outputs using the
- * specified `combine` function.
- *
- * **When to use**
- *
- * Use when two schedules must both allow recurrence and their outputs should be
- * combined into a custom value.
- *
- * **Example** (Combining schedule outputs)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Combine two schedules with custom output combination
- * const leftSchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.map(() => Effect.succeed("left"))
- * )
- * const rightSchedule = Schedule.spaced("50 millis").pipe(
- *   Schedule.map(() => Effect.succeed("right"))
- * )
- *
- * const combined = Schedule.bothWith(
- *   leftSchedule,
- *   rightSchedule,
- *   (left, right) => `${left}-${right}`
- * )
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task-result"
+ *       return "success"
  *     }),
- *     combined.pipe(Schedule.take(3))
+ *     retrySchedule.pipe(
+ *       Schedule.tap(({ output: duration }) =>
+ *         Console.log(`Waiting for the slowest schedule: ${duration}`)
+ *       )
+ *     )
  *   )
  * })
  * ```
  *
  * @category combining
- * @since 2.0.0
- */
-export const bothWith = /*#__PURE__*/dual(3, (self, other, combine) => fromStep(effect.map(effect.zip(toStep(self), toStep(other)), ([stepLeft, stepRight]) => (now, input) => Pull.matchEffect(stepLeft(now, input), {
-  onSuccess: leftResult => stepRight(now, input).pipe(effect.map(rightResult => [combine(leftResult[0], rightResult[0]), Duration.max(leftResult[1], rightResult[1])]), Pull.catchDone(rightDone => Cause.done(combine(leftResult[0], rightDone)))),
-  onDone: leftDone => stepRight(now, input).pipe(effect.flatMap(rightResult => Cause.done(combine(leftDone, rightResult[0]))), Pull.catchDone(rightDone => Cause.done(combine(leftDone, rightDone)))),
-  onFailure: effect.failCause
-}))));
-/**
- * Returns a new `Schedule` that follows `self` and outputs the inputs seen so
- * far as an array.
- *
- * **Details**
- *
- * This does not make the schedule run forever. The collected schedule stops
- * when `self` stops and fails when `self` fails.
- *
- * **Example** (Collecting schedule inputs)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Collect all inputs passed to the schedule
- * const inputCollector = Schedule.collectInputs(
- *   Schedule.spaced("100 millis")
- * )
- *
- * const program = Effect.gen(function*() {
- *   let counter = 0
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       counter++
- *       yield* Console.log(`Iteration ${counter}`)
- *       return `result-${counter}`
- *     }),
- *     inputCollector.pipe(Schedule.take(4))
- *   )
- * })
- * ```
- *
- * @category collecting
- * @since 4.0.0
- */
-export const collectInputs = self => collectWhile(passthrough(self), () => effect.succeed(true));
-/**
- * Returns a new `Schedule` that follows `self` and outputs the schedule outputs
- * seen so far as an array.
- *
- * **Details**
- *
- * This does not make the schedule run forever. The collected schedule stops
- * when `self` stops and fails when `self` fails.
- *
- * **Example** (Collecting schedule outputs)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Collect all outputs from the schedule
- * const outputCollector = Schedule.collectOutputs(
- *   Schedule.recurs(4)
- * )
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task-result"
- *     }),
- *     outputCollector.pipe(Schedule.take(4))
- *   )
- * })
- * ```
- *
- * @category collecting
  * @since 4.0.0
  */
-export const collectOutputs = self => collectWhile(self, () => effect.succeed(true));
-/**
- * Returns a new `Schedule` that recurs as long as the specified `predicate`
- * returns `true`, collecting all outputs of the schedule into an array.
- *
- * **Example** (Collecting outputs while a condition holds)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Collect outputs while condition is met
- * const collectWhileSmall = Schedule.collectWhile(
- *   Schedule.exponential("100 millis"),
- *   (metadata) =>
- *     Effect.succeed(metadata.attempt <= 5 && metadata.elapsed < 2000)
- * )
- *
- * const conditionalProgram = Effect.gen(function*() {
- *   let attempt = 0
- *
- *   const attempts = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       attempt++
- *       yield* Console.log(`Retry attempt ${attempt}`)
- *       return `attempt-${attempt}`
- *     }),
- *     collectWhileSmall
- *   )
- *
- *   yield* Console.log(`Collected attempts: [${attempts.join(", ")}]`)
- * })
- *
- * // Collect with effectful predicate
- * const collectWithCheck = Schedule.collectWhile(
- *   Schedule.fixed("1 second"),
- *   (metadata) =>
- *     Effect.gen(function*() {
- *       const shouldContinue = metadata.attempt < 5
- *       yield* Console.log(
- *         `Check ${metadata.attempt}: continue = ${shouldContinue}`
- *       )
- *       return shouldContinue
- *     })
- * )
- *
- * const effectfulProgram = Effect.gen(function*() {
- *   const results = yield* Effect.repeat(
- *     Effect.succeed("checked"),
- *     collectWithCheck
- *   )
- *
- *   yield* Console.log(`Final collection: ${results.length} items`)
- * })
- *
- * // Collect samples with condition
- * const samples = [12, 18, 24, 30, 36]
- *
- * const collectSamples = Schedule.collectWhile(
- *   Schedule.spaced("200 millis"),
- *   (metadata) =>
- *     Effect.succeed(metadata.attempt <= 5 && metadata.elapsed < 2000)
- * )
- *
- * const samplingProgram = Effect.gen(function*() {
- *   let index = 0
- *   const collected = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       const sample = samples[index++]
- *       yield* Console.log(`Sample: ${sample}`)
- *       return sample
- *     }),
- *     collectSamples
- *   )
- *
- *   const average = collected.reduce((sum, s) => sum + s, 0) / collected.length
- *   yield* Console.log(
- *     `Collected ${collected.length} samples, average: ${average.toFixed(1)}`
- *   )
- * })
- * ```
- *
- * @category collecting
- * @since 2.0.0
- */
-export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(while_(self, predicate), () => [], (outputs, output) => {
-  outputs.push(output);
-  return outputs;
-}));
+export const max = schedules => fromStep(effect.map(effect.all(schedules.map(toStep)), steps => (now, input) => effect.flatMap(effect.forEach(steps, step => Pull.matchEffect(step(now, input), {
+  onSuccess: result => effect.succeed(result[1]),
+  onDone: () => effect.undefined,
+  onFailure: effect.failCause
+})), results => {
+  const duration = maxDuration(results);
+  if (duration === undefined) {
+    return Cause.done(Duration.zero);
+  }
+  return effect.succeed([duration, duration]);
+})));
+const maxDuration = results => {
+  let max = results[0];
+  for (let i = 1; i < results.length; i++) {
+    max = results[i] && max && Duration.max(max, results[i]);
+    if (max === undefined) break;
+  }
+  return max;
+};
 /**
  * Returns a new `Schedule` that recurs on the specified `Cron` schedule and
  * outputs the duration between recurrences.
@@ -829,8 +529,8 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  *       return "minute"
  *     }),
  *     everyMinute.pipe(
- *       Schedule.take(3), // Run only 3 times for demo
- *       Schedule.tapOutput((duration) =>
+ *       Schedule.upTo({ times: 3 }), // Run only 3 times for demo
+ *       Schedule.tap(({ output: duration }) =>
  *         Console.log(`Next execution in: ${duration}`)
  *       )
  *     )
@@ -850,7 +550,7 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  *       return "backup-done"
  *     }),
  *     dailyBackup.pipe(
- *       Schedule.take(2) // Run 2 times for demo
+ *       Schedule.upTo({ times: 2 }) // Run 2 times for demo
  *     )
  *   )
  * })
@@ -869,7 +569,7 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  *       yield* Console.log(`Report generated: ${JSON.stringify(report)}`)
  *       return report
  *     }),
- *     weeklyReport.pipe(Schedule.take(1))
+ *     weeklyReport.pipe(Schedule.upTo({ times: 1 }))
  *   )
  * })
  *
@@ -888,7 +588,7 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  *       return status
  *     }),
  *     businessHoursCheck.pipe(
- *       Schedule.take(4) // Demo with 4 checks
+ *       Schedule.upTo({ times: 4 }) // Demo with 4 checks
  *     )
  *   )
  * })
@@ -904,13 +604,13 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  *       yield* Console.log(`Processed ${invoiceCount} invoices`)
  *       return { count: invoiceCount, batch: "2024-01-a" }
  *     }),
- *     monthlyInvoice.pipe(Schedule.take(1))
+ *     monthlyInvoice.pipe(Schedule.upTo({ times: 1 }))
  *   )
  * })
  *
  * // Complex cron with error handling
  * const complexCron = Schedule.cron("0 2,4,6 * * *").pipe(
- *   Schedule.tapOutput((duration) =>
+ *   Schedule.tap(({ output: duration }) =>
  *     Console.log(`Scheduled to run again in ${duration}`)
  *   )
  * )
@@ -927,7 +627,7 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  *       }
  *       return "success"
  *     }),
- *     complexCron.pipe(Schedule.take(3))
+ *     complexCron.pipe(Schedule.upTo({ times: 3 }))
  *   ).pipe(
  *     Effect.catch((error: unknown) =>
  *       Console.log(`Cron task error: ${String(error)}`)
@@ -941,97 +641,17 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  */
 export const cron = (expression, tz) => {
   const parsed = Cron.isCron(expression) ? Result.succeed(expression) : Cron.parse(expression, tz);
-  return fromStep(effect.map(effect.fromResult(parsed), cron => (now, _) => effect.sync(() => {
-    const next = Cron.next(cron, now).getTime();
-    const duration = Duration.millis(next - now);
-    return [duration, duration];
-  })));
+  return fromStep(effect.map(effect.fromResult(parsed), cron => (now, _) => {
+    if (now === Number.POSITIVE_INFINITY) {
+      return Cause.done(Duration.zero);
+    }
+    return effect.sync(() => {
+      const next = Cron.next(cron, now).getTime();
+      const duration = Duration.millis(next - now);
+      return [duration, duration];
+    });
+  }));
 };
-/**
- * Returns a new schedule that outputs the delay between each occurrence.
- *
- * **Example** (Extracting schedule delays)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Extract delays from an exponential backoff schedule
- * const exponentialDelays = Schedule.delays(
- *   Schedule.exponential("100 millis").pipe(Schedule.take(5))
- * )
- *
- * const delayProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task result"
- *     }),
- *     exponentialDelays.pipe(
- *       Schedule.tapOutput((delay) =>
- *         Console.log(`Waiting ${delay} before next execution`)
- *       )
- *     )
- *   )
- * })
- *
- * // Monitor delays from a Fibonacci schedule
- * const fibonacciDelays = Schedule.delays(
- *   Schedule.fibonacci("200 millis").pipe(Schedule.take(8))
- * )
- *
- * const fibDelayProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Console.log("Fibonacci task"),
- *     fibonacciDelays.pipe(
- *       Schedule.tapOutput((delay) => Console.log(`Fibonacci delay: ${delay}`))
- *     )
- *   )
- * })
- *
- * // Extract delays for analysis or logging
- * const analyzeDelays = Schedule.delays(
- *   Schedule.spaced("1 second").pipe(Schedule.take(3))
- * ).pipe(
- *   Schedule.tapOutput((delay) =>
- *     Effect.gen(function*() {
- *       yield* Console.log(`Recorded delay: ${delay}`)
- *       // In real applications, might send to metrics system
- *     })
- *   )
- * )
- *
- * // Combine delays with other schedules for complex timing
- * const adaptiveSchedule = Schedule.unfold(100, (delay) => Effect.succeed(delay * 1.5)).pipe(
- *   Schedule.take(6)
- * )
- *
- * const adaptiveDelays = Schedule.delays(adaptiveSchedule)
- *
- * const adaptiveProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Adaptive task execution")
- *       return "completed"
- *     }),
- *     adaptiveDelays.pipe(
- *       Schedule.tapOutput((delay) => Console.log(`Adaptive delay: ${delay}`))
- *     )
- *   )
- * })
- *
- * // Use delays to implement custom timing logic
- * const customTimingSchedule = Schedule.delays(
- *   Schedule.exponential("50 millis").pipe(Schedule.take(4))
- * ).pipe(
- *   Schedule.map((delay) => Effect.succeed(`Next execution in ${delay}`)),
- *   Schedule.tapOutput((message) => Console.log(message))
- * )
- * ```
- *
- * @category constructors
- * @since 2.0.0
- */
-export const delays = self => fromStep(effect.map(toStep(self), step => (now, input) => Pull.catchDone(effect.map(step(now, input), ([_, duration]) => [duration, duration]), _ => Cause.done(Duration.zero))));
 /**
  * Returns a schedule that recurs once after the specified duration.
  *
@@ -1090,7 +710,7 @@ export const duration = durationInput => {
  *       return "task done"
  *     }),
  *     fiveSecondSchedule.pipe(
- *       Schedule.tapOutput((elapsedDuration) =>
+ *       Schedule.tap(({ output: elapsedDuration }) =>
  *         Console.log(`Total elapsed: ${elapsedDuration}`)
  *       )
  *     )
@@ -1100,10 +720,11 @@ export const duration = durationInput => {
  * })
  *
  * // Combine with other schedules for time-bounded execution
- * const timeAndCountLimited = Schedule.spaced("1 second").pipe(
- *   Schedule.both(Schedule.during("10 seconds")), // Stop after 10 seconds OR
- *   Schedule.both(Schedule.recurs(15)) // 15 attempts, whichever comes first
- * )
+ * const timeAndCountLimited = Schedule.max([
+ *   Schedule.spaced("1 second"),
+ *   Schedule.during("10 seconds"), // Stop after 10 seconds OR
+ *   Schedule.recurs(15) // 15 attempts, whichever comes first
+ * ])
  *
  * // Burst execution within time window
  * const burstWindow = Schedule.during("3 seconds")
@@ -1123,9 +744,10 @@ export const duration = durationInput => {
  * })
  *
  * // Timed retry window - retry for up to 30 seconds
- * const timedRetry = Schedule.exponential("200 millis").pipe(
- *   Schedule.both(Schedule.during("30 seconds"))
- * )
+ * const timedRetry = Schedule.max([
+ *   Schedule.exponential("200 millis"),
+ *   Schedule.during("30 seconds")
+ * ])
  *
  * const retryProgram = Effect.gen(function*() {
  *   let attempt = 0
@@ -1155,162 +777,52 @@ export const duration = durationInput => {
  * @category constructors
  * @since 4.0.0
  */
-export const during = duration => while_(elapsed, ({
-  output
-}) => effect.succeed(Duration.isLessThanOrEqualTo(output, Duration.fromInputUnsafe(duration))));
+export const during = duration => {
+  const durationMillis = Duration.toMillis(duration);
+  return fromStepWithMetadata(effect.succeed(meta => {
+    const elapsed = Duration.millis(meta.elapsed);
+    return meta.elapsed > durationMillis ? effect.succeed([elapsed, Duration.zero]) : Cause.done(elapsed);
+  }));
+};
 /**
- * Combines two `Schedule`s by recurring if either of the two schedules wants
- * to recur, using the minimum of the two durations between recurrences and
- * outputting a tuple of the outputs of both schedules.
+ * Combines schedules by recurring while at least one schedule wants to recur,
+ * using the minimum delay between recurrences and outputting that minimum delay.
  *
  * **When to use**
  *
- * Use when the combined schedule should continue while at least one schedule still recurs.
+ * Use when a combined policy should continue while any schedule still recurs,
+ * and should wait for the fastest schedule between recurrences.
  *
- * **Example** (Combining schedules with either semantics)
+ * **Example** (Combining retry schedules by their minimum delay)
  *
  * ```ts
  * import { Console, Data, Effect, Schedule } from "effect"
  *
  * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
- * // Either continues as long as at least one schedule wants to continue
- * const timeBasedSchedule = Schedule.spaced("2 seconds").pipe(Schedule.take(3))
- * const countBasedSchedule = Schedule.recurs(5)
- *
- * // Continues until both schedules are exhausted (either still wants to recur)
- * const eitherSchedule = Schedule.either(timeBasedSchedule, countBasedSchedule)
- * // Outputs: [time_result, count_result] tuple
+ * const retrySchedule = Schedule.min([
+ *   Schedule.fixed("5 seconds"),
+ *   Schedule.exponential("5 seconds"),
+ *   Schedule.spaced("10 seconds")
+ * ])
  *
  * const program = Effect.gen(function*() {
- *   const results = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task completed"
- *     }),
- *     eitherSchedule.pipe(
- *       Schedule.tapOutput(([timeResult, countResult]) =>
- *         Console.log(`Time: ${timeResult}, Count: ${countResult}`)
- *       )
- *     )
- *   )
- *
- *   yield* Console.log(`Total executions: ${results.length}`)
- * })
- *
- * // Either with different delay strategies
- * const aggressiveRetry = Schedule.exponential("100 millis").pipe(
- *   Schedule.take(3)
- * )
- * const fallbackRetry = Schedule.fixed("5 seconds").pipe(Schedule.take(2))
- *
- * // Will use the more aggressive retry until it's exhausted, then fallback
- * const combinedRetry = Schedule.either(aggressiveRetry, fallbackRetry)
- *
- * const retryProgram = Effect.gen(function*() {
  *   let attempt = 0
  *
- *   const result = yield* Effect.retry(
+ *   yield* Effect.retry(
  *     Effect.gen(function*() {
  *       attempt++
  *       yield* Console.log(`Retry attempt ${attempt}`)
- *
- *       if (attempt < 6) {
+ *       if (attempt < 3) {
  *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
- *
- *       return `Success on attempt ${attempt}`
- *     }),
- *     combinedRetry
- *   )
- *
- *   yield* Console.log(`Final result: ${result}`)
- * })
- *
- * // Either provides union semantics (OR logic)
- * // Compare with both, which provides intersection semantics (AND logic)
- * ```
- *
- * @see {@link both} for continuing only while both schedules still recur
- *
- * @category combining
- * @since 2.0.0
- */
-export const either = /*#__PURE__*/dual(2, (self, other) => eitherWith(self, other, (left, right) => [left, right]));
-/**
- * Combines two `Schedule`s by recurring if either of the two schedules wants
- * to recur, using the minimum of the two durations between recurrences and
- * outputting the result of the left schedule (i.e. `self`).
- *
- * **When to use**
- *
- * Use when either schedule may keep recurrence going and only the left
- * schedule's output is needed.
- *
- * **Example** (Combining either schedules and keeping the left output)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Combine two schedules with either semantics, keeping left output
- * const primarySchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.map(() => Effect.succeed("primary-result")),
- *   Schedule.take(2)
- * )
- * const backupSchedule = Schedule.spaced("500 millis").pipe(
- *   Schedule.map(() => Effect.succeed("backup-result"))
- * )
- *
- * const combined = Schedule.eitherLeft(primarySchedule, backupSchedule)
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task-done"
- *     }),
- *     combined.pipe(Schedule.take(5))
- *   )
- * })
- * ```
- *
- * @category combining
- * @since 4.0.0
- */
-export const eitherLeft = /*#__PURE__*/dual(2, (self, other) => eitherWith(self, other, output => output));
-/**
- * Combines two `Schedule`s by recurring if either of the two schedules wants
- * to recur, using the minimum of the two durations between recurrences and
- * outputting the result of the right schedule (i.e. `other`).
- *
- * **When to use**
- *
- * Use when either schedule may keep recurrence going and only the right
- * schedule's output is needed.
- *
- * **Example** (Combining either schedules and keeping the right output)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Combine two schedules with either semantics, keeping right output
- * const primarySchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.map(() => Effect.succeed("primary-result")),
- *   Schedule.take(2)
- * )
- * const backupSchedule = Schedule.spaced("500 millis").pipe(
- *   Schedule.map(() => Effect.succeed("backup-result"))
- * )
- *
- * const combined = Schedule.eitherRight(primarySchedule, backupSchedule)
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task-done"
+ *       return "success"
  *     }),
- *     combined.pipe(Schedule.take(5))
+ *     retrySchedule.pipe(
+ *       Schedule.tap(({ output: duration }) =>
+ *         Console.log(`Waiting for the fastest schedule: ${duration}`)
+ *       )
+ *     )
  *   )
  * })
  * ```
@@ -1318,89 +830,27 @@ export const eitherLeft = /*#__PURE__*/dual(2, (self, other) => eitherWith(self,
  * @category combining
  * @since 4.0.0
  */
-export const eitherRight = /*#__PURE__*/dual(2, (self, other) => eitherWith(self, other, (_, output) => output));
-/**
- * Combines two `Schedule`s by recurring if either of the two schedules wants
- * to recur, using the minimum of the two durations between recurrences and
- * outputting the result of the combination of both schedule outputs using the
- * specified `combine` function.
- *
- * **When to use**
- *
- * Use when either schedule may keep recurrence going and their outputs should be
- * combined into a custom value.
- *
- * **Example** (Combining either schedule outputs)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Combine schedules with either semantics and custom combination
- * const primarySchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.map(() => Effect.succeed("primary")),
- *   Schedule.take(2)
- * )
- * const fallbackSchedule = Schedule.spaced("500 millis").pipe(
- *   Schedule.map(() => Effect.succeed("fallback"))
- * )
- *
- * const combined = Schedule.eitherWith(
- *   primarySchedule,
- *   fallbackSchedule,
- *   (primary, fallback) => `${primary}+${fallback}`
- * )
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task-result"
- *     }),
- *     combined.pipe(Schedule.take(5))
- *   )
- * })
- * ```
- *
- * @category combining
- * @since 2.0.0
- */
-export const eitherWith = /*#__PURE__*/dual(3, (self, other, combine) => fromStep(effect.map(effect.zip(toStep(self), toStep(other)), ([stepLeft, stepRight]) => (now, input) => Pull.matchEffect(stepLeft(now, input), {
-  onSuccess: leftResult => stepRight(now, input).pipe(effect.map(rightResult => [combine(leftResult[0], rightResult[0]), Duration.min(leftResult[1], rightResult[1])]), Pull.catchDone(rightDone => effect.succeed([combine(leftResult[0], rightDone), leftResult[1]]))),
-  onFailure: effect.failCause,
-  onDone: leftDone => stepRight(now, input).pipe(effect.map(rightResult => [combine(leftDone, rightResult[0]), rightResult[1]]), Pull.catchDone(rightDone => Cause.done(combine(leftDone, rightDone))))
-}))));
-/**
- * Schedule that always recurs and returns the total elapsed duration since the
- * first recurrence.
- *
- * **Details**
- *
- * This schedule never stops and outputs the cumulative time that has passed since the schedule
- * started executing. Useful for tracking execution time or implementing time-based logic.
- *
- * **Example** (Measuring elapsed schedule time)
- *
- * ```ts
- * import { Console, Duration, Effect, Schedule } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Console.log("Running task..."),
- *     Schedule.spaced("1 second").pipe(
- *       Schedule.both(Schedule.elapsed),
- *       Schedule.tapOutput(([count, duration]) =>
- *         Console.log(`Run ${count}, elapsed: ${Duration.toMillis(duration)}ms`)
- *       ),
- *       Schedule.take(5)
- *     )
- *   )
- * })
- * ```
- *
- * @category constructors
- * @since 2.0.0
- */
-export const elapsed = /*#__PURE__*/fromStepWithMetadata(/*#__PURE__*/effect.succeed(meta => effect.succeed([Duration.millis(meta.elapsed), Duration.zero])));
+export const min = schedules => fromStep(effect.map(effect.all(schedules.map(toStep)), steps => (now, input) => effect.flatMap(effect.forEach(steps, step => Pull.matchEffect(step(now, input), {
+  onSuccess: result => effect.succeed(result[1]),
+  onDone: () => effect.undefined,
+  onFailure: effect.failCause
+})), results => {
+  const duration = minDuration(results);
+  if (duration === undefined) {
+    return Cause.done(Duration.zero);
+  }
+  return effect.succeed([duration, duration]);
+})));
+const minDuration = results => {
+  let min = undefined;
+  for (let i = 0; i < results.length; i++) {
+    const duration = results[i];
+    if (duration !== undefined) {
+      min = min === undefined ? duration : Duration.min(min, duration);
+    }
+  }
+  return min;
+};
 /**
  * Schedule that always recurs, but will wait a certain amount between
  * repetitions, given by `base * factor.pow(n)`, where `n` is the number of
@@ -1422,9 +872,10 @@ export const elapsed = /*#__PURE__*/fromStepWithMetadata(/*#__PURE__*/effect.suc
  * // Delays: 200ms, 300ms, 450ms, 675ms, 1012ms, ...
  *
  * // Retry with exponential backoff (limited to 5 attempts)
- * const retryPolicy = Schedule.exponential("50 millis").pipe(
- *   Schedule.both(Schedule.recurs(5))
- * )
+ * const retryPolicy = Schedule.max([
+ *   Schedule.exponential("50 millis"),
+ *   Schedule.recurs(5)
+ * ])
  *
  * const program = Effect.gen(function*() {
  *   let attempt = 0
@@ -1488,9 +939,11 @@ export const exponential = (base, factor = 2) => {
  *
  *       return `Success on attempt ${attempt}`
  *     }),
- *     Schedule.fibonacci("50 millis").pipe(
- *       Schedule.both(Schedule.recurs(6)), // Maximum 6 retries
- *       Schedule.tapOutput((delay) => Console.log(`Next retry in ${delay}`))
+ *     Schedule.max([
+ *       Schedule.fibonacci("50 millis"),
+ *       Schedule.recurs(6) // Maximum 6 retries
+ *     ]).pipe(
+ *       Schedule.tap(({ output: delay }) => Console.log(`Next retry in ${delay}`))
  *     )
  *   )
  *
@@ -1504,7 +957,7 @@ export const exponential = (base, factor = 2) => {
  * }).pipe(
  *   Effect.repeat(
  *     Schedule.fibonacci("200 millis").pipe(
- *       Schedule.take(8) // First 8 heartbeats
+ *       Schedule.upTo({ times: 8 }) // First 8 heartbeats
  *     )
  *   )
  * )
@@ -1570,7 +1023,7 @@ export const fibonacci = one => {
  *   yield* Effect.sleep("200 millis") // simulate health check work
  *   return "healthy"
  * }).pipe(
- *   Effect.repeat(Schedule.fixed("2 seconds").pipe(Schedule.take(5)))
+ *   Effect.repeat(Schedule.fixed("2 seconds").pipe(Schedule.upTo({ times: 5 })))
  * )
  *
  * // Difference between fixed and spaced:
@@ -1587,12 +1040,12 @@ export const fibonacci = one => {
  * // Fixed schedule: if task takes 1.5s but interval is 1s,
  * // next execution happens immediately (no pile-up)
  * const fixedSchedule = longRunningTask.pipe(
- *   Effect.repeat(Schedule.fixed("1 second").pipe(Schedule.take(3)))
+ *   Effect.repeat(Schedule.fixed("1 second").pipe(Schedule.upTo({ times: 3 })))
  * )
  *
  * // Comparing with spaced (waits 1s AFTER each task)
  * const spacedSchedule = longRunningTask.pipe(
- *   Effect.repeat(Schedule.spaced("1 second").pipe(Schedule.take(3)))
+ *   Effect.repeat(Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 3 })))
  * )
  *
  * const program = Effect.gen(function*() {
@@ -1632,8 +1085,14 @@ export const fixed = interval => {
   }));
 };
 /**
- * Returns a new `Schedule` that maps the output of this schedule using the
- * specified function.
+ * Returns a new `Schedule` that maps each schedule decision to a new output
+ * using the full schedule metadata.
+ *
+ * **Details**
+ *
+ * The callback receives the schedule input, output, selected delay duration,
+ * current attempt, and elapsed timing information. Return either a plain value
+ * or an `Effect` that produces the new output.
  *
  * **Example** (Mapping schedule outputs)
  *
@@ -1642,17 +1101,17 @@ export const fixed = interval => {
  *
  * // Transform schedule output from number to string
  * const countSchedule = Schedule.recurs(5).pipe(
- *   Schedule.map((count) => Effect.succeed(`Execution #${count + 1}`))
+ *   Schedule.map(({ output: count }) => Effect.succeed(`Execution #${count + 1}`))
  * )
  *
  * // Map schedule delays to human-readable format
  * const readableDelays = Schedule.exponential("100 millis").pipe(
- *   Schedule.map((duration) => Effect.succeed(`Next retry in ${duration}`))
+ *   Schedule.map(({ output: delay }) => Effect.succeed(`Next retry in ${delay}`))
  * )
  *
  * // Transform numeric output to structured data
  * const structuredSchedule = Schedule.spaced("1 second").pipe(
- *   Schedule.map((recurrence) => Effect.succeed({
+ *   Schedule.map(({ output: recurrence }) => Effect.succeed({
  *     iteration: recurrence + 1,
  *     phase: recurrence < 5 ? "warmup" as const : "steady" as const
  *   }))
@@ -1662,8 +1121,8 @@ export const fixed = interval => {
  *   const results = yield* Effect.repeat(
  *     Effect.succeed("task completed"),
  *     structuredSchedule.pipe(
- *       Schedule.take(8),
- *       Schedule.tapOutput((info) =>
+ *       Schedule.upTo({ times: 8 }),
+ *       Schedule.tap(({ output: info }) =>
  *         Console.log(
  *           `${info.phase} phase - iteration ${info.iteration}`
  *         )
@@ -1676,7 +1135,7 @@ export const fixed = interval => {
  *
  * // Map with effectful transformation
  * const effectfulMap = Schedule.fixed("2 seconds").pipe(
- *   Schedule.map((count) =>
+ *   Schedule.map(({ output: count }) =>
  *     Effect.gen(function*() {
  *       yield* Console.log(`Processing count: ${count}`)
  *       return count * 10
@@ -1684,45 +1143,55 @@ export const fixed = interval => {
  *   )
  * )
  *
- * // Combine mapping with other schedule operations
+ * // Use timing metadata in the mapped output
  * const complexSchedule = Schedule.fibonacci("100 millis").pipe(
- *   Schedule.map((delay) => Effect.succeed(`Delay: ${delay}`))
+ *   Schedule.map(({ output: delay, attempt }) =>
+ *     Effect.succeed(`Attempt ${attempt} delay: ${delay}`)
+ *   )
  * )
  * ```
  *
  * @category mapping
  * @since 2.0.0
  */
-export const map = /*#__PURE__*/dual(2, (self, f) => {
-  const handle = Pull.matchEffect({
+export const map = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => {
+  const meta = metadataFn();
+  return (now, input) => Pull.matchEffect(step(now, input), {
     onSuccess: ([output, duration]) => {
-      const result = f(output);
+      const result = f({
+        ...meta(now, input),
+        output,
+        duration
+      });
       if (!isEffect(result)) return effect.succeed([result, duration]);
       return effect.map(result, output => [output, duration]);
     },
     onFailure: effect.failCause,
     onDone: output => {
-      const result = f(output);
+      const result = f({
+        ...meta(now, input),
+        output,
+        duration: Duration.zero
+      });
       if (!isEffect(result)) return Cause.done(result);
       return effect.flatMap(result, Cause.done);
     }
   });
-  return fromStep(effect.map(toStep(self), step => (now, input) => handle(step(now, input))));
-});
+})));
 /**
  * Returns a new `Schedule` that modifies the delay of the next recurrence
  * of the schedule using the specified effectful function.
  *
- * **Example** (Modifying delays from schedule output)
+ * **Example** (Modifying delays from schedule metadata)
  *
  * ```ts
  * import { Console, Duration, Effect, Schedule } from "effect"
  *
  * // Modify delays based on output - increase delay on high iteration counts
  * const adaptiveDelay = Schedule.recurs(10).pipe(
- *   Schedule.modifyDelay((output, delay) => {
+ *   Schedule.modifyDelay(({ output, duration }) => {
  *     // Double the delay if we're seeing high iteration counts
- *     return Effect.succeed(output > 5 ? Duration.times(delay, 2) : delay)
+ *     return Effect.succeed(output > 5 ? Duration.times(duration, 2) : duration)
  *   })
  * )
  *
@@ -1734,7 +1203,7 @@ export const map = /*#__PURE__*/dual(2, (self, f) => {
  *       yield* Console.log(`Attempt ${counter}`)
  *       return counter
  *     }),
- *     adaptiveDelay.pipe(Schedule.take(8))
+ *     adaptiveDelay.pipe(Schedule.upTo({ times: 8 }))
  *   )
  * })
  * ```
@@ -1742,7 +1211,14 @@ export const map = /*#__PURE__*/dual(2, (self, f) => {
  * @category delays & timeouts
  * @since 2.0.0
  */
-export const modifyDelay = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => (now, input) => effect.flatMap(step(now, input), ([output, delay]) => effect.map(f(output, delay), delay => [output, Duration.fromInputUnsafe(delay)])))));
+export const modifyDelay = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => {
+  const meta = metadataFn();
+  return (now, input) => effect.flatMap(step(now, input), ([output, duration]) => effect.map(f({
+    ...meta(now, input),
+    output,
+    duration
+  }), replacement => [output, Duration.fromInputUnsafe(replacement)]));
+})));
 /**
  * Returns a new `Schedule` that randomly adjusts each recurrence delay.
  *
@@ -1760,8 +1236,10 @@ export const modifyDelay = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map
  * @category delays & timeouts
  * @since 2.0.0
  */
-export const jittered = self => modifyDelay(self, (_, delay) => effect.map(randomNext, random => {
-  const millis = Duration.toMillis(Duration.fromInputUnsafe(delay));
+export const jittered = self => modifyDelay(self, ({
+  duration
+}) => effect.map(randomNext, random => {
+  const millis = Duration.toMillis(duration);
   return Duration.millis(millis * 0.8 * (1 - random) + millis * 1.2 * random);
 }));
 /**
@@ -1774,7 +1252,7 @@ export const jittered = self => modifyDelay(self, (_, delay) => effect.map(rando
  *
  * // Create a schedule that outputs the inputs instead of original outputs
  * const inputSchedule = Schedule.passthrough(
- *   Schedule.exponential("100 millis").pipe(Schedule.take(3))
+ *   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 3 }))
  * )
  *
  * const program = Effect.gen(function*() {
@@ -1844,9 +1322,10 @@ export const passthrough = self => fromStep(effect.map(toStep(self), step => (no
  * })
  *
  * // Combining recurs with other schedules for sophisticated retry logic
- * const complexRetry = Schedule.exponential("100 millis").pipe(
- *   Schedule.both(Schedule.recurs(3)) // At most 3 retries
- * )
+ * const complexRetry = Schedule.max([
+ *   Schedule.exponential("100 millis"),
+ *   Schedule.recurs(3) // At most 3 retries
+ * ])
  *
  * // Allow ten recurrences after the initial run
  * const tenRecurrences = Effect.gen(function*() {
@@ -1858,11 +1337,11 @@ export const passthrough = self => fromStep(effect.map(toStep(self), step => (no
  *
  * // The schedule outputs the current recurrence count (0-based)
  * const countingSchedule = Schedule.recurs(3).pipe(
- *   Schedule.tapOutput((count) => Console.log(`Execution #${count + 1}`))
+ *   Schedule.tap(({ output: count }) => Console.log(`Execution #${count + 1}`))
  * )
  * ```
  *
- * @see {@link take} for limiting an existing schedule
+ * @see {@link upTo} for limiting an existing schedule
  *
  * @category constructors
  * @since 2.0.0
@@ -1870,139 +1349,6 @@ export const passthrough = self => fromStep(effect.map(toStep(self), step => (no
 export const recurs = times => while_(forever, ({
   attempt
 }) => effect.succeed(attempt <= times));
-/**
- * Returns a new `Schedule` that combines the outputs of the provided schedule
- * using the specified effectful `combine` function and starting from the
- * specified `initial` state.
- *
- * **Example** (Reducing schedule outputs)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Sum up execution counts from a counter schedule
- * const sumSchedule = Schedule.reduce(
- *   Schedule.recurs(5),
- *   () => 0, // Initial sum
- *   (sum, count) => Effect.succeed(sum + count) // Add each count to the sum
- * )
- *
- * const sumProgram = Effect.gen(function*() {
- *   const finalSum = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "task"
- *     }),
- *     sumSchedule.pipe(
- *       Schedule.tapOutput((sum) => Console.log(`Running sum: ${sum}`))
- *     )
- *   )
- *
- *   yield* Console.log(`Final sum: ${finalSum}`)
- * })
- *
- * // Build a history of execution counts
- * const historySchedule = Schedule.reduce(
- *   Schedule.spaced("1 second").pipe(Schedule.take(4)),
- *   () => [] as Array<number>, // Initial empty array
- *   (history, executionNumber) => Effect.succeed([...history, executionNumber])
- * )
- *
- * const historyProgram = Effect.gen(function*() {
- *   const timeline = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Recording execution...")
- *       return "recorded"
- *     }),
- *     historySchedule
- *   )
- *
- *   yield* Console.log(
- *     `Execution timeline: ${timeline.join(", ")}`
- *   )
- * })
- *
- * // Accumulate metrics with effectful combination
- * const metricsAccumulator = Schedule.reduce(
- *   Schedule.recurs(6),
- *   () => ({ total: 0, count: 0, max: 0 }),
- *   (metrics, executionCount) => Effect.succeed({
- *     total: metrics.total + executionCount + 1,
- *     count: metrics.count + 1,
- *     max: Math.max(metrics.max, executionCount + 1)
- *   })
- * )
- *
- * const metricsProgram = Effect.gen(function*() {
- *   const finalMetrics = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Processing...")
- *       return "processed"
- *     }),
- *     metricsAccumulator
- *   )
- *
- *   const average = finalMetrics.total / finalMetrics.count
- *   yield* Console.log(`Final metrics: ${finalMetrics.count} executions`)
- *   yield* Console.log(
- *     `Average delay: ${average.toFixed(1)}ms, Max delay: ${finalMetrics.max}ms`
- *   )
- * })
- *
- * // Build configuration state over time
- * const configBuilder = Schedule.reduce(
- *   Schedule.fixed("500 millis").pipe(Schedule.take(3)),
- *   () => ({ retries: 1, timeout: 1000, backoff: 100 }),
- *   (config, executionNumber) => Effect.succeed({
- *     retries: config.retries + 1,
- *     timeout: config.timeout * 1.5,
- *     backoff: Math.min(config.backoff * 2, 5000)
- *   })
- * )
- *
- * const configProgram = Effect.gen(function*() {
- *   const finalConfig = yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Updating configuration...")
- *       return "updated"
- *     }),
- *     configBuilder.pipe(
- *       Schedule.tapOutput((config) =>
- *         Console.log(
- *           `Config: retries=${config.retries}, timeout=${config.timeout}ms`
- *         )
- *       )
- *     )
- *   )
- *
- *   yield* Console.log(`Final config: ${JSON.stringify(finalConfig)}`)
- * })
- * ```
- *
- * @category folding
- * @since 2.0.0
- */
-export const reduce = /*#__PURE__*/dual(3, (self, initial, combine) => fromStep(effect.map(toStep(self), step => {
-  let state = initial();
-  return (now, input) => Pull.matchEffect(step(now, input), {
-    onSuccess([output, delay]) {
-      const next = combine(state, output);
-      if (!isEffect(next)) {
-        state = next;
-        return effect.succeed([next, delay]);
-      }
-      return effect.map(next, nextState => {
-        state = nextState;
-        return [nextState, delay];
-      });
-    },
-    onFailure: effect.failCause,
-    onDone(output) {
-      const next = combine(state, output);
-      return isEffect(next) ? effect.flatMap(next, Cause.done) : Cause.done(next);
-    }
-  });
-})));
 /**
  * Returns a schedule that recurs continuously, each repetition spaced the
  * specified duration from the last run.
@@ -2033,14 +1379,15 @@ export const reduce = /*#__PURE__*/dual(3, (self, initial, combine) => fromStep(
  *   return "Task completed"
  * }).pipe(
  *   Effect.repeat(
- *     Schedule.spaced("1 second").pipe(Schedule.take(5))
+ *     Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 5 }))
  *   )
  * )
  *
  * // Simple spaced schedule with limited repetitions
- * const limitedSpaced = Schedule.spaced("100 millis").pipe(
- *   Schedule.both(Schedule.recurs(5)) // at most 5 times
- * )
+ * const limitedSpaced = Schedule.max([
+ *   Schedule.spaced("100 millis"),
+ *   Schedule.recurs(5) // at most 5 times
+ * ])
  *
  * const program = Effect.gen(function*() {
  *   yield* Console.log("Starting spaced execution...")
@@ -2079,7 +1426,7 @@ export const spaced = duration => {
  * import { Console, Effect, Schedule } from "effect"
  *
  * const monitoredSchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.take(5),
+ *   Schedule.upTo({ times: 5 }),
  *   Schedule.tap((metadata) =>
  *     Console.log(
  *       `Attempt ${metadata.attempt} produced ${metadata.output} ` +
@@ -2106,235 +1453,27 @@ export const tap = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(
   }));
 })));
 /**
- * Returns a new `Schedule` that allows execution of an effectful function for
- * every input to the schedule, but does not alter the inputs and outputs of
- * the schedule.
- *
- * **Example** (Tapping retry inputs)
- *
- * ```ts
- * import { Console, Data, Effect, Schedule } from "effect"
- *
- * class RetryError extends Data.TaggedError("RetryError")<{ readonly message: string }> {}
- *
- * // Log retry errors for debugging
- * const errorLoggingSchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.take(3),
- *   Schedule.tapInput((error: RetryError) =>
- *     Console.log(`Retry triggered by error: ${String(error)}`)
- *   )
- * )
- *
- * const retryProgram = Effect.gen(function*() {
- *   let attempt = 0
- *
- *   const result = yield* Effect.retry(
- *     Effect.gen(function*() {
- *       attempt++
- *       if (attempt < 4) {
- *         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
- *       }
- *       return `Success on attempt ${attempt}`
- *     }),
- *     errorLoggingSchedule
- *   )
- *
- *   yield* Console.log(`Final result: ${result}`)
- * })
- *
- * // Monitor input frequency for metrics
- * const inputMonitoringSchedule = Schedule.spaced("1 second").pipe(
- *   Schedule.take(5),
- *   Schedule.tapInput((input: unknown) =>
- *     Effect.gen(function*() {
- *       yield* Console.log(`Input type: ${typeof input}`)
- *       // In real applications, might send metrics to monitoring system
- *     })
- *   )
- * )
- *
- * // Input validation with side effects
- * const validatingSchedule = Schedule.fixed("500 millis").pipe(
- *   Schedule.take(4),
- *   Schedule.tapInput((input: any) =>
- *     Effect.gen(function*() {
- *       if (typeof input === "object" && input !== null) {
- *         yield* Console.log(`Valid object input: ${JSON.stringify(input)}`)
- *       } else {
- *         yield* Console.log(`Warning: Non-object input received: ${input}`)
- *       }
- *     })
- *   )
- * )
- *
- * const validationProgram = Effect.gen(function*() {
- *   let count = 0
- *
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       count++
- *       yield* Console.log("Task with validation")
- *       return { data: `sample-${count}` }
- *     }),
- *     validatingSchedule
- *   )
- * })
- *
- * // Conditional alerting based on input
- * const alertingSchedule = Schedule.exponential("200 millis").pipe(
- *   Schedule.take(6),
- *   Schedule.tapInput((error: RetryError) =>
- *     Effect.gen(function*() {
- *       if (String(error).includes("critical")) {
- *         yield* Console.log(`Critical error: ${String(error)}`)
- *         // In real applications, might trigger alerts or notifications
- *       } else {
- *         yield* Console.log(`Regular error: ${String(error)}`)
- *       }
- *     })
- *   )
- * )
- *
- * const alertProgram = Effect.gen(function*() {
- *   let attempt = 0
- *
- *   yield* Effect.retry(
- *     Effect.gen(function*() {
- *       attempt++
- *       const isCritical = attempt === 3
- *       const errorType = isCritical
- *         ? "critical database failure"
- *         : "temporary network issue"
- *       return yield* Effect.fail(new RetryError({ message: errorType }))
- *     }),
- *     alertingSchedule
- *   ).pipe(
- *     Effect.catch((error: unknown) =>
- *       Console.log(`All retries exhausted: ${String(error)}`)
- *     )
- *   )
- * })
- *
- * // Chain multiple input taps for different purposes
- * const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
- *   Schedule.take(5),
- *   Schedule.tapInput((error: RetryError) =>
- *     Console.log(`Error occurred: ${error._tag}`)
- *   ),
- *   Schedule.tapInput((error: RetryError) =>
- *     String(error).length > 20
- *       ? Console.log("Long error message detected")
- *       : Effect.void
- *   )
- * )
- * ```
- *
- * @category sequencing
- * @since 2.0.0
- */
-export const tapInput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => (now, input) => effect.andThen(f(input), step(now, input)))));
-/**
- * Returns a new `Schedule` that allows execution of an effectful function for
- * every output of the schedule, but does not alter the inputs and outputs of
- * the schedule.
- *
- * **Example** (Tapping schedule outputs)
- *
- * ```ts
- * import { Console, Data, Effect, Schedule } from "effect"
- *
- * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
- *
- * // Log schedule outputs for debugging/monitoring
- * const monitoredSchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.take(5),
- *   Schedule.tapOutput((delay) => Console.log(`Next delay will be: ${delay}`))
- * )
- *
- * const retryProgram = Effect.gen(function*() {
- *   let attempt = 0
- *
- *   const result = yield* Effect.retry(
- *     Effect.gen(function*() {
- *       attempt++
- *       if (attempt < 4) {
- *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
- *       }
- *       return `Success on attempt ${attempt}`
- *     }),
- *     monitoredSchedule
- *   )
- *
- *   yield* Console.log(`Final result: ${result}`)
- * })
- *
- * // Tap output for metrics collection
- * const metricsSchedule = Schedule.spaced("1 second").pipe(
- *   Schedule.take(10),
- *   Schedule.tapOutput((executionCount) =>
- *     Effect.gen(function*() {
- *       // Simulate metrics collection
- *       yield* Console.log(`Recording metric: execution_count=${executionCount}`)
- *       // In real code, this might send to monitoring system
- *     })
- *   )
- * )
- *
- * // Tap output with conditional side effects
- * const alertingSchedule = Schedule.fibonacci("200 millis").pipe(
- *   Schedule.take(8),
- *   Schedule.tapOutput((delay) =>
- *     Effect.gen(function*() {
- *       const delayMs = delay.toString()
- *       if (delayMs.includes("1000")) { // Alert on delays >= 1 second
- *         yield* Console.log(`High delay detected: ${delay}`)
- *       }
- *     })
- *   )
- * )
- *
- * const healthCheckProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Performing health check...")
- *       return "healthy"
- *     }),
- *     alertingSchedule
- *   )
- * })
- *
- * // Chain multiple taps for different purposes
- * const comprehensiveSchedule = Schedule.fixed("500 millis").pipe(
- *   Schedule.take(6),
- *   Schedule.tapOutput((count) => Console.log(`Execution ${count + 1}`)),
- *   Schedule.tapOutput((count) =>
- *     count % 3 === 0
- *       ? Console.log("Checkpoint reached")
- *       : Effect.void
- *   )
- * )
- * ```
- *
- * @category sequencing
- * @since 2.0.0
- */
-export const tapOutput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => (now, input) => effect.tap(step(now, input), ([output]) => f(output)))));
-/**
- * Returns a new `Schedule` that takes at most the specified number of outputs
- * from the schedule. Once the specified number of outputs is reached, the
- * schedule will stop.
+ * Returns a new `Schedule` that limits an existing schedule by elapsed
+ * duration, number of outputs, or both.
  *
  * **When to use**
  *
- * Use to limit an existing schedule while preserving its output and delay behavior.
+ * Use to bound an existing schedule while preserving its output and delay
+ * behavior. When both `duration` and `times` are specified, the schedule
+ * stops as soon as either limit is reached.
  *
  * **Gotchas**
  *
- * `take(n)` limits schedule outputs. When used with repeat or retry, the
- * effect is evaluated once before the schedule is stepped, so the total number
- * of evaluations can be one greater than the number of outputs taken.
+ * The `times` option limits schedule outputs. When used with repeat or retry,
+ * the effect is evaluated once before the schedule is stepped, so the total
+ * number of evaluations can be one greater than the configured number of
+ * outputs.
  *
- * **Example** (Taking a limited number of recurrences)
+ * The `duration` option is based on the elapsed time observed by the schedule
+ * step. Long-running effects can cause the duration limit to be detected on the
+ * following schedule step.
+ *
+ * **Example** (Limiting by duration and recurrence count)
  *
  * ```ts
  * import { Console, Data, Effect, Schedule } from "effect"
@@ -2343,7 +1482,7 @@ export const tapOutput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(t
  *
  * // Limit an infinite schedule to five recurrences
  * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
- *   Schedule.take(5) // Will stop after 5 schedule outputs
+ *   Schedule.upTo({ times: 5 })
  * )
  *
  * const heartbeatProgram = Effect.gen(function*() {
@@ -2358,9 +1497,12 @@ export const tapOutput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(t
  *   yield* Console.log("Heartbeat sequence completed")
  * })
  *
- * // Limit retry attempts to a specific number
+ * // Limit retry attempts by both count and elapsed time
  * const limitedRetry = Schedule.exponential("100 millis").pipe(
- *   Schedule.take(3) // At most 3 retry attempts
+ *   Schedule.upTo({
+ *     duration: "5 seconds",
+ *     times: 3
+ *   })
  * )
  *
  * const retryProgram = Effect.gen(function*() {
@@ -2387,138 +1529,22 @@ export const tapOutput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(t
  *   )
  * )
  *
- * // Combine take with other schedule operations
- * const samplingSchedule = Schedule.fixed("500 millis").pipe(
- *   Schedule.take(10), // Take at most 10 schedule outputs
- *   Schedule.map((count) => Effect.succeed(`Sample #${count + 1}`))
+ * // Empty options leave the schedule unchanged
+ * const unchanged = Schedule.fixed("500 millis").pipe(
+ *   Schedule.upTo({})
  * )
- *
- * const samplingProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       const value = "sample"
- *       yield* Console.log(`Sampled value: ${value}`)
- *       return value
- *     }),
- *     samplingSchedule.pipe(
- *       Schedule.tapOutput((label) => Console.log(`Completed: ${label}`))
- *     )
- *   )
- * })
  * ```
  *
- * @see {@link recurs} for creating a count-limited schedule
- *
- * @category taking
+ * @category filtering
  * @since 4.0.0
  */
-export const take = /*#__PURE__*/dual(2, (self, n) => while_(self, ({
-  attempt
-}) => effect.succeed(attempt <= n)));
-/**
- * Creates a schedule that unfolds a state by repeatedly applying a function,
- * outputting the current state and computing the next state.
- *
- * **Example** (Unfolding schedule state)
- *
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Counter schedule that increments by 1 each time
- * const counterSchedule = Schedule.unfold(0, (n) => Effect.succeed(n + 1))
- * // Outputs: 0, 1, 2, 3, 4, 5, ...
- *
- * const countingProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("Task executed")
- *       return "done"
- *     }),
- *     counterSchedule.pipe(
- *       Schedule.take(5),
- *       Schedule.tapOutput((count) => Console.log(`Count: ${count}`))
- *     )
- *   )
- * })
- *
- * // Fibonacci sequence schedule
- * const fibonacciSchedule = Schedule.unfold(
- *   [0, 1] as [number, number],
- *   ([a, b]) => Effect.succeed([b, a + b] as [number, number])
- * )
- * // Outputs: [0,1], [1,1], [1,2], [2,3], [3,5], [5,8], ...
- *
- * const fibProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Console.log("Fibonacci step"),
- *     fibonacciSchedule.pipe(
- *       Schedule.take(8),
- *       Schedule.tapOutput(([a, b]) => Console.log(`Fib: ${a}, next: ${b}`))
- *     )
- *   )
- * })
- *
- * // Effectful unfold - exponential backoff with state
- * const exponentialState = Schedule.unfold(
- *   100,
- *   (delayMs) =>
- *     Effect.gen(function*() {
- *       yield* Console.log(`Current delay: ${delayMs}ms`)
- *       return Math.min(delayMs * 2, 5000) // Cap at 5 seconds
- *     })
- * )
- *
- * // Deterministic delay adjustment schedule
- * const adjustedDelaySchedule = Schedule.unfold(
- *   { delay: 1000, adjustment: 100 },
- *   ({ delay, adjustment }) =>
- *     Effect.gen(function*() {
- *       const nextDelay = Math.max(100, delay + adjustment)
- *       yield* Console.log(`Adjusted delay: ${nextDelay}ms`)
- *       return { delay: nextDelay, adjustment: adjustment * -1 }
- *     })
- * )
- *
- * // State machine schedule
- * type State = "init" | "warming" | "active" | "cooling"
- * const stateMachineSchedule = Schedule.unfold("init" as State, (state) => {
- *   switch (state) {
- *     case "init":
- *       return Effect.succeed("warming" as State)
- *     case "warming":
- *       return Effect.succeed("active" as State)
- *     case "active":
- *       return Effect.succeed("cooling" as State)
- *     case "cooling":
- *       return Effect.succeed("active" as State)
- *   }
- * })
- *
- * const stateMachineProgram = Effect.gen(function*() {
- *   yield* Effect.repeat(
- *     Effect.gen(function*() {
- *       yield* Console.log("State machine step")
- *       return "step"
- *     }),
- *     stateMachineSchedule.pipe(
- *       Schedule.take(10),
- *       Schedule.tapOutput((state) => Console.log(`State: ${state}`))
- *     )
- *   )
- * })
- * ```
- *
- * @category constructors
- * @since 2.0.0
- */
-export const unfold = (initial, next) => fromStep(effect.sync(() => {
-  let state = initial;
-  return constant(effect.map(effect.suspend(() => next(state)), nextState => {
-    const prev = state;
-    state = nextState;
-    return [prev, Duration.zero];
-  }));
-}));
+export const upTo = /*#__PURE__*/dual(2, (self, options) => {
+  const duration = options.duration === undefined ? undefined : Duration.fromInputUnsafe(options.duration);
+  return while_(self, ({
+    attempt,
+    elapsed
+  }) => effect.succeed((options.times === undefined || attempt <= options.times) && (duration === undefined || Duration.isLessThanOrEqualTo(Duration.millis(elapsed), duration))));
+});
 const while_ = /*#__PURE__*/dual(2, (self, predicate) => fromStep(effect.map(toStep(self), step => {
   const meta = metadataFn();
   return (now, input) => effect.flatMap(step(now, input), result => {
@@ -2546,8 +1572,7 @@ export {
  * `Effect<boolean, ...>`, preserves the output and delay when it returns
  * `true`, and stops the schedule when it returns `false`.
  *
- * @see {@link collectWhile} for collecting outputs while using the same predicate
- * @see {@link take} for stopping after a fixed number of schedule outputs
+ * @see {@link upTo} for stopping after a fixed number of schedule outputs
  *
  * @category filtering
  * @since 4.0.0
@@ -2582,7 +1607,7 @@ while_ as while };
  *       yield* Console.log("Window task executed")
  *       return "window-task"
  *     }),
- *     windowSchedule.pipe(Schedule.take(4))
+ *     windowSchedule.pipe(Schedule.upTo({ times: 4 }))
  *   )
  * })
  * ```
@@ -2616,7 +1641,7 @@ export const windowed = interval => {
  *       yield* Console.log("Running forever...")
  *       return "continuous-task"
  *     }),
- *     infiniteSchedule.pipe(Schedule.take(5)) // Limit for demo
+ *     infiniteSchedule.pipe(Schedule.upTo({ times: 5 })) // Limit for demo
  *   )
  * })
  * ```
@@ -2647,37 +1672,6 @@ export {
  * @since 2.0.0
  */
 identity_ as identity };
-/**
- * Ensures that a schedule's input type extends a given type `T`.
- *
- * **When to use**
- *
- * Use when you need a generic helper to prove that an existing schedule can
- * consume a required input type without changing runtime behavior.
- *
- * **Example** (Constraining schedule input types)
- *
- * ```ts
- * import { Schedule } from "effect"
- *
- * declare const StringInputSchedule: Schedule.Schedule<number, string>
- * declare const NumberInputSchedule: Schedule.Schedule<number, number>
- *
- * const satisfiesStringInput = Schedule.satisfiesInputType<string>()
- *
- * // This works because the schedule input type is string.
- * const validSchedule = satisfiesStringInput(StringInputSchedule)
- *
- * // This would cause a TypeScript compilation error:
- * // const invalidSchedule = satisfiesStringInput(NumberInputSchedule)
- * ```
- *
- * @see {@link setInputType} for adapting an input-agnostic schedule
- *
- * @category utility types
- * @since 4.0.0
- */
-export const satisfiesInputType = () => self => self;
 /**
  * Sets the input type of the provided schedule without altering its behavior.
  *
@@ -2700,106 +1694,8 @@ export const satisfiesInputType = () => self => self;
  * )
  * ```
  *
- * @see {@link satisfiesInputType} for checking an existing input type
- *
  * @category utility types
  * @since 4.0.0
  */
 export const setInputType = () => self => self;
-/**
- * Ensures that a schedule's output type extends a given type `T`.
- *
- * **Details**
- *
- * This helper is checked at compile time and does not change the schedule's
- * runtime behavior.
- *
- * **Example** (Constraining schedule output types)
- *
- * ```ts
- * import { Schedule } from "effect"
- *
- * declare const StringOutputSchedule: Schedule.Schedule<string>
- * declare const NumberOutputSchedule: Schedule.Schedule<number>
- *
- * const satisfiesStringOutput = Schedule.satisfiesOutputType<string>()
- *
- * // This works because the schedule output type is string.
- * const validSchedule = satisfiesStringOutput(StringOutputSchedule)
- *
- * // This would cause a TypeScript compilation error:
- * // const invalidSchedule = satisfiesStringOutput(NumberOutputSchedule)
- * ```
- *
- * @category utility types
- * @since 4.0.0
- */
-export const satisfiesOutputType = () => self => self;
-/**
- * Ensures that a schedule's error type extends a given type `T`.
- *
- * **Details**
- *
- * This helper is checked at compile time and does not change the schedule's
- * runtime behavior.
- *
- * **Example** (Constraining schedule error types)
- *
- * ```ts
- * import { Data, Schedule } from "effect"
- *
- * // Create a custom error using Data.TaggedError
- * class CustomError extends Data.TaggedError("CustomError")<{
- *   message: string
- * }> {}
- *
- * declare const CustomErrorSchedule: Schedule.Schedule<number, unknown, CustomError>
- * declare const StringErrorSchedule: Schedule.Schedule<number, unknown, string>
- *
- * const satisfiesCustomError = Schedule.satisfiesErrorType<CustomError>()
- *
- * // This works because the schedule error type is CustomError.
- * const validSchedule = satisfiesCustomError(CustomErrorSchedule)
- *
- * // This would cause a TypeScript compilation error:
- * // const invalidSchedule = satisfiesCustomError(StringErrorSchedule)
- * ```
- *
- * @category utility types
- * @since 4.0.0
- */
-export const satisfiesErrorType = () => self => self;
-/**
- * Ensures that a schedule's context type extends a given type `T`.
- *
- * **Details**
- *
- * This helper is checked at compile time and does not change the schedule's
- * runtime behavior.
- *
- * **Example** (Constraining schedule service types)
- *
- * ```ts
- * import { Schedule } from "effect"
- *
- * interface Logger {
- *   readonly log: (message: string) => void
- * }
- *
- * declare const LoggerSchedule: Schedule.Schedule<number, unknown, never, Logger>
- * declare const NumberSchedule: Schedule.Schedule<number, unknown, never, number>
- *
- * const satisfiesLogger = Schedule.satisfiesServicesType<Logger>()
- *
- * // This works because the schedule context type is Logger.
- * const validSchedule = satisfiesLogger(LoggerSchedule)
- *
- * // This would cause a TypeScript compilation error:
- * // const invalidSchedule = satisfiesLogger(NumberSchedule)
- * ```
- *
- * @category utility types
- * @since 4.0.0
- */
-export const satisfiesServicesType = () => self => self;
 //# sourceMappingURL=Schedule.js.map