effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/Schedule.ts

@@ -12,7 +12,7 @@
  *
  * // Retry with exponential backoff
  * const retryPolicy = Schedule.exponential("100 millis", 2.0)
- *   .pipe(Schedule.compose(Schedule.recurs(3)))
+ *   .pipe(Schedule.both(Schedule.recurs(3)))
  *
  * const program = Effect.gen(function*() {
  *   // This will retry up to 3 times with exponential backoff
@@ -36,8 +36,9 @@ import * as Duration from "./Duration.ts"
 import type { Effect } from "./Effect.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, dual, identity } from "./Function.ts"
-
+import { isEffect } from "./internal/core.ts"
 import * as effect from "./internal/effect.ts"
+import * as random from "./internal/random.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Pull from "./Pull.ts"
@@ -47,6 +48,8 @@ import type { Contravariant, Covariant, Mutable } from "./Types.ts"
 
 const TypeId = "~effect/Schedule"
 
+const randomNext: Effect<number> = random.Random.useSync((random) => random.nextDoubleUnsafe())
+
 /**
  * A Schedule defines a strategy for repeating or retrying effects based on some policy.
  *
@@ -56,7 +59,7 @@ const TypeId = "~effect/Schedule"
  *
  * // Basic retry schedule - retry up to 3 times with exponential backoff
  * const retrySchedule = Schedule.exponential("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(3))
+ *   Schedule.both(Schedule.recurs(3))
  * )
  *
  * // Basic repeat schedule - repeat every 30 seconds forever
@@ -69,7 +72,7 @@ const TypeId = "~effect/Schedule"
  * const program = Effect.gen(function*() {
  *   // Using retry schedule
  *   const result1 = yield* Effect.retry(
- *     Effect.fail("temporary error"),
+ *     Effect.suspend(() => Math.random() > 0.5 ? Effect.fail("temporary error") : Effect.succeed("Success")),
  *     retrySchedule
  *   )
  *
@@ -197,7 +200,7 @@ export const CurrentMetadata = ServiceMap.Reference<Metadata>("effect/Schedule/C
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 3) {
- *         yield* Effect.fail(`Attempt ${attempt} failed`)
+ *         return yield* Effect.fail(`Attempt ${attempt} failed`)
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -333,7 +336,7 @@ export const isSchedule = (u: unknown): u is Schedule<unknown, never, unknown, u
  *
  * // These can be combined and transformed as needed
  * const complexSchedule = simpleSchedule.pipe(
- *   Schedule.compose(Schedule.recurs(3))
+ *   Schedule.both(Schedule.recurs(3))
  * )
  * ```
  *
@@ -520,7 +523,9 @@ export const toStepWithSleep = <Output, Input, Error, Env>(
  *
  * @example
  * ```ts
- * import { Console, Duration, Effect, Schedule } from "effect"
+ * import { Console, Data, Duration, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Add random jitter to schedule delays
  * const jitteredSchedule = Schedule.addDelay(
@@ -616,7 +621,7 @@ export const toStepWithSleep = <Output, Input, Error, Env>(
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 5) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -637,7 +642,9 @@ export const addDelay: {
    *
    * @example
    * ```ts
-   * import { Console, Duration, Effect, Schedule } from "effect"
+   * import { Console, Data, Duration, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // Add random jitter to schedule delays
    * const jitteredSchedule = Schedule.addDelay(
@@ -733,7 +740,7 @@ export const addDelay: {
    *     Effect.gen(function*() {
    *       attempt++
    *       if (attempt < 5) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -747,7 +754,7 @@ export const addDelay: {
    * @since 2.0.0
    * @category utils
    */
-  <Output, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>): <Input, Error, Env>(
+  <Output, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Duration.Input, Error2, Env2>): <Input, Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Output, Input, Error | Error2, Env | Env2>
   /**
@@ -756,7 +763,9 @@ export const addDelay: {
    *
    * @example
    * ```ts
-   * import { Console, Duration, Effect, Schedule } from "effect"
+   * import { Console, Data, Duration, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // Add random jitter to schedule delays
    * const jitteredSchedule = Schedule.addDelay(
@@ -852,7 +861,7 @@ export const addDelay: {
    *     Effect.gen(function*() {
    *       attempt++
    *       if (attempt < 5) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -868,17 +877,16 @@ export const addDelay: {
    */
   <Output, Input, Error, Env, Error2 = never, Env2 = never>(
     self: Schedule<Output, Input, Error, Env>,
-    f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>
+    f: (output: Output) => Effect<Duration.Input, Error2, Env2>
   ): Schedule<Output, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
-  f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>
+  f: (output: Output) => Effect<Duration.Input, Error2, Env2>
 ): Schedule<Output, Input, Error | Error2, Env | Env2> =>
   modifyDelay(
     self,
     (output, delay) =>
-      effect.map(f(output), (d) =>
-        Duration.sum(Duration.fromDurationInputUnsafe(d), Duration.fromDurationInputUnsafe(delay)))
+      effect.map(f(output), (d) => Duration.sum(Duration.fromInputUnsafe(d), Duration.fromInputUnsafe(delay)))
   ))
 
 /**
@@ -888,7 +896,9 @@ export const addDelay: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // First retry 3 times quickly, then switch to slower retries
  * const quickRetries = Schedule.exponential("100 millis").pipe(
@@ -907,7 +917,7 @@ export const addDelay: {
  *       attempt++
  *       yield* Console.log(`Attempt ${attempt}`)
  *       if (attempt < 6) {
- *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Failure ${attempt}` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -927,7 +937,9 @@ export const andThen: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // First retry 3 times quickly, then switch to slower retries
    * const quickRetries = Schedule.exponential("100 millis").pipe(
@@ -946,7 +958,7 @@ export const andThen: {
    *       attempt++
    *       yield* Console.log(`Attempt ${attempt}`)
    *       if (attempt < 6) {
-   *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Failure ${attempt}` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -968,7 +980,9 @@ export const andThen: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // First retry 3 times quickly, then switch to slower retries
    * const quickRetries = Schedule.exponential("100 millis").pipe(
@@ -987,7 +1001,7 @@ export const andThen: {
    *       attempt++
    *       yield* Console.log(`Attempt ${attempt}`)
    *       if (attempt < 6) {
-   *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Failure ${attempt}` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -1140,116 +1154,211 @@ export const andThenResult: {
 } = dual(2, <Output, Input, Error, Env, Output2, Input2, Error2, Env2>(
   self: Schedule<Output, Input, Error, Env>,
   other: Schedule<Output2, Input2, Error2, Env2>
-): Schedule<Result.Result<Output2, Output>, Input & Input2, Error | Error2, Env | Env2> =>
-  fromStep(effect.map(
-    effect.zip(toStep(self), toStep(other)),
-    ([leftStep, rightStep]) => {
-      let currentStep: (now: number, input: Input & Input2) => Pull.Pull<
-        [Output | Output2, Duration.Duration],
+): Schedule<Result.Result<Output, Output2>, Input & Input2, Error | Error2, Env | Env2> =>
+  fromStep(effect.sync(() => {
+    let currentSide = 0
+    let currentStep:
+      | undefined
+      | ((now: number, input: Input & Input2) => Pull.Pull<
+        [Result.Result<Output, Output2>, Duration.Duration],
         Error | Error2,
-        Output | Output2,
+        Result.Result<Output, Output2>,
         Env | Env2
-      > = leftStep
-      let toResult: (output: Output | Output2) => Result.Result<Output2, Output> = Result.fail as any
-      return (now, input) =>
-        Pull.matchEffect(currentStep(now, input), {
-          onSuccess: ([output, duration]) =>
-            effect.succeed</**
-             * Returns a new `Schedule` that will first execute the left (i.e. `self`)
-             * schedule to completion. Once the left schedule is complete, the right (i.e.
-             * `other`) schedule will be executed to completion.
-             *
-             * The output of the resulting schedule is a `Result` where outputs of the
-             * left schedule are emitted as `Result.Err<Output>` and outputs of the right
-             * schedule are emitted as `Result.Ok<Output>`.
-             *
-             * @example
-             * ```ts
-             * import { Console, Effect, Result, Schedule } from "effect"
-             *
-             * // 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))
-             * )
-             *
-             * const program = Effect.gen(function*() {
-             *   yield* Effect.repeat(
-             *     Effect.gen(function*() {
-             *       yield* Console.log("Task executed")
-             *       return "task-result"
-             *     }),
-             *     phaseTracker.pipe(
-             *       Schedule.tapOutput((result) =>
-             *         Result.match(result, {
-             *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
-             *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
-             *         })
-             *       )
-             *     )
-             *   )
-             * })
-             * ```
-             *
-             * @since 2.0.0
-             * @category sequencing
-             */
-            [Result.Result<Output2, Output>, Duration.Duration]>([toResult(output), duration]),
-          onFailure: effect.failCause,
-          onDone: (output) =>
-            effect.suspend(() => {
-              const pull = effect.succeed</**
-               * Returns a new `Schedule` that will first execute the left (i.e. `self`)
-               * schedule to completion. Once the left schedule is complete, the right (i.e.
-               * `other`) schedule will be executed to completion.
-               *
-               * The output of the resulting schedule is a `Result` where outputs of the
-               * left schedule are emitted as `Result.Err<Output>` and outputs of the right
-               * schedule are emitted as `Result.Ok<Output>`.
-               *
-               * @example
-               * ```ts
-               * import { Console, Effect, Result, Schedule } from "effect"
-               *
-               * // 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))
-               * )
-               *
-               * const program = Effect.gen(function*() {
-               *   yield* Effect.repeat(
-               *     Effect.gen(function*() {
-               *       yield* Console.log("Task executed")
-               *       return "task-result"
-               *     }),
-               *     phaseTracker.pipe(
-               *       Schedule.tapOutput((result) =>
-               *         Result.match(result, {
-               *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
-               *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
-               *         })
-               *       )
-               *     )
-               *   )
-               * })
-               * ```
-               *
-               * @since 2.0.0
-               * @category sequencing
-               */
-              [Result.Result<Output2, Output>, Duration.Duration]>(
-                [toResult(output), Duration.zero]
-              )
-              if (currentStep === leftStep) {
-                currentStep = rightStep
-                toResult = Result.succeed as any
-              }
-              return pull
-            })
-        });
-    }
-  )))
+      >)
+    const left = map(self, Result.succeed)
+    const right = map(other, Result.fail)
+    return function recur(
+      now,
+      input
+    ): Pull.Pull<
+      [Result.Result<Output, Output2>, Duration.Duration],
+      Error | Error2,
+      Result.Result<Output, Output2>,
+      Env | Env2
+    > {
+      if (currentStep) return currentStep(now, input)
+      return toStep<
+        /**
+         * Returns a new `Schedule` that will first execute the left (i.e. `self`)
+         * schedule to completion. Once the left schedule is complete, the right (i.e.
+         * `other`) schedule will be executed to completion.
+         *
+         * The output of the resulting schedule is a `Result` where outputs of the
+         * left schedule are emitted as `Result.Err<Output>` and outputs of the right
+         * schedule are emitted as `Result.Ok<Output>`.
+         *
+         * @example
+         * ```ts
+         * import { Console, Effect, Result, Schedule } from "effect"
+         *
+         * // 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))
+         * )
+         *
+         * const program = Effect.gen(function*() {
+         *   yield* Effect.repeat(
+         *     Effect.gen(function*() {
+         *       yield* Console.log("Task executed")
+         *       return "task-result"
+         *     }),
+         *     phaseTracker.pipe(
+         *       Schedule.tapOutput((result) =>
+         *         Result.match(result, {
+         *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
+         *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
+         *         })
+         *       )
+         *     )
+         *   )
+         * })
+         * ```
+         *
+         * @since 2.0.0
+         * @category sequencing
+         */
+        Result.Result<Output, Output2>,
+        /**
+         * Returns a new `Schedule` that will first execute the left (i.e. `self`)
+         * schedule to completion. Once the left schedule is complete, the right (i.e.
+         * `other`) schedule will be executed to completion.
+         *
+         * The output of the resulting schedule is a `Result` where outputs of the
+         * left schedule are emitted as `Result.Err<Output>` and outputs of the right
+         * schedule are emitted as `Result.Ok<Output>`.
+         *
+         * @example
+         * ```ts
+         * import { Console, Effect, Result, Schedule } from "effect"
+         *
+         * // 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))
+         * )
+         *
+         * const program = Effect.gen(function*() {
+         *   yield* Effect.repeat(
+         *     Effect.gen(function*() {
+         *       yield* Console.log("Task executed")
+         *       return "task-result"
+         *     }),
+         *     phaseTracker.pipe(
+         *       Schedule.tapOutput((result) =>
+         *         Result.match(result, {
+         *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
+         *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
+         *         })
+         *       )
+         *     )
+         *   )
+         * })
+         * ```
+         *
+         * @since 2.0.0
+         * @category sequencing
+         */
+        Input & Input2,
+        /**
+         * Returns a new `Schedule` that will first execute the left (i.e. `self`)
+         * schedule to completion. Once the left schedule is complete, the right (i.e.
+         * `other`) schedule will be executed to completion.
+         *
+         * The output of the resulting schedule is a `Result` where outputs of the
+         * left schedule are emitted as `Result.Err<Output>` and outputs of the right
+         * schedule are emitted as `Result.Ok<Output>`.
+         *
+         * @example
+         * ```ts
+         * import { Console, Effect, Result, Schedule } from "effect"
+         *
+         * // 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))
+         * )
+         *
+         * const program = Effect.gen(function*() {
+         *   yield* Effect.repeat(
+         *     Effect.gen(function*() {
+         *       yield* Console.log("Task executed")
+         *       return "task-result"
+         *     }),
+         *     phaseTracker.pipe(
+         *       Schedule.tapOutput((result) =>
+         *         Result.match(result, {
+         *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
+         *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
+         *         })
+         *       )
+         *     )
+         *   )
+         * })
+         * ```
+         *
+         * @since 2.0.0
+         * @category sequencing
+         */
+        Error | Error2,
+        /**
+         * Returns a new `Schedule` that will first execute the left (i.e. `self`)
+         * schedule to completion. Once the left schedule is complete, the right (i.e.
+         * `other`) schedule will be executed to completion.
+         *
+         * The output of the resulting schedule is a `Result` where outputs of the
+         * left schedule are emitted as `Result.Err<Output>` and outputs of the right
+         * schedule are emitted as `Result.Ok<Output>`.
+         *
+         * @example
+         * ```ts
+         * import { Console, Effect, Result, Schedule } from "effect"
+         *
+         * // 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))
+         * )
+         *
+         * const program = Effect.gen(function*() {
+         *   yield* Effect.repeat(
+         *     Effect.gen(function*() {
+         *       yield* Console.log("Task executed")
+         *       return "task-result"
+         *     }),
+         *     phaseTracker.pipe(
+         *       Schedule.tapOutput((result) =>
+         *         Result.match(result, {
+         *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
+         *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
+         *         })
+         *       )
+         *     )
+         *   )
+         * })
+         * ```
+         *
+         * @since 2.0.0
+         * @category sequencing
+         */
+        Env | Env2
+      >(currentSide === 0 ? left : right).pipe(
+        effect.flatMap((step) => {
+          currentSide++
+          if (currentSide === 1) {
+            currentStep = (now, input) =>
+              Pull.catchDone(step(now, input), (_) => {
+                currentStep = undefined
+                return recur(now, input)
+              })
+            return currentStep(now, input)
+          }
+          currentStep = step
+          return currentStep(now, input)
+        })
+      );
+    };
+  })))
 
 /**
  * Combines two `Schedule`s by recurring if both of the two schedules want
@@ -1258,7 +1367,9 @@ export const andThenResult: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * 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
@@ -1300,7 +1411,7 @@ export const andThenResult: {
  *       yield* Console.log(`Retry attempt ${attempt}`)
  *
  *       if (attempt < 3) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -1326,7 +1437,9 @@ export const both: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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
@@ -1368,7 +1481,7 @@ export const both: {
    *       yield* Console.log(`Retry attempt ${attempt}`)
    *
    *       if (attempt < 3) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -1396,7 +1509,9 @@ export const both: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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
@@ -1438,7 +1553,7 @@ export const both: {
    *       yield* Console.log(`Retry attempt ${attempt}`)
    *
    *       if (attempt < 3) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -1838,205 +1953,6 @@ export const bothWith: {
       })
   )))
 
-/**
- * Returns a new `Schedule` that combines two schedules by running them
- * sequentially. First the current schedule runs to completion, then the
- * other schedule runs to completion. The output is a tuple of both results.
- *
- * @example
- * ```ts
- * import { Console, Effect, Schedule } from "effect"
- *
- * // Compose a quick retry phase followed by slower retry phase
- * const fastRetries = Schedule.exponential("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(3)) // 3 fast retries
- * )
- *
- * const slowRetries = Schedule.exponential("2 seconds").pipe(
- *   Schedule.compose(Schedule.recurs(2)) // 2 slow retries
- * )
- *
- * // Sequential composition: fast retries first, then slow retries
- * const composedRetry = Schedule.compose(fastRetries, slowRetries)
- * // Outputs: [number_from_fast_phase, number_from_slow_phase]
- *
- * const program = Effect.gen(function*() {
- *   let attempt = 0
- *
- *   const result = yield* Effect.retry(
- *     Effect.gen(function*() {
- *       attempt++
- *       yield* Console.log(`Attempt ${attempt}`)
- *
- *       if (attempt < 7) { // Needs both phases to succeed
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
- *       }
- *
- *       return `Success on attempt ${attempt}`
- *     }),
- *     composedRetry.pipe(
- *       Schedule.tapOutput(([fastResult, slowResult]) =>
- *         Console.log(`Fast phase: ${fastResult}, Slow phase: ${slowResult}`)
- *       )
- *     )
- *   )
- *
- *   yield* Console.log(`Final result: ${result}`)
- * })
- *
- * // Compose different schedule types
- * const warmupAndMaintenance = Schedule.compose(
- *   Schedule.fixed("500 millis").pipe(Schedule.take(5)), // 5 warmup cycles
- *   Schedule.spaced("5 seconds") // then regular maintenance
- * )
- *
- * // Progressive backoff: fixed first, then exponential
- * const progressiveBackoff = Schedule.compose(
- *   Schedule.fixed("100 millis").pipe(Schedule.take(3)), // Fixed: 100ms, 100ms, 100ms
- *   Schedule.exponential("500 millis").pipe(Schedule.take(3)) // Then exponential: 500ms, 1s, 2s
- * )
- * ```
- *
- * @since 2.0.0
- * @category sequencing
- */
-export const compose: {
-  /**
-   * Returns a new `Schedule` that combines two schedules by running them
-   * sequentially. First the current schedule runs to completion, then the
-   * other schedule runs to completion. The output is a tuple of both results.
-   *
-   * @example
-   * ```ts
-   * import { Console, Effect, Schedule } from "effect"
-   *
-   * // Compose a quick retry phase followed by slower retry phase
-   * const fastRetries = Schedule.exponential("100 millis").pipe(
-   *   Schedule.compose(Schedule.recurs(3)) // 3 fast retries
-   * )
-   *
-   * const slowRetries = Schedule.exponential("2 seconds").pipe(
-   *   Schedule.compose(Schedule.recurs(2)) // 2 slow retries
-   * )
-   *
-   * // Sequential composition: fast retries first, then slow retries
-   * const composedRetry = Schedule.compose(fastRetries, slowRetries)
-   * // Outputs: [number_from_fast_phase, number_from_slow_phase]
-   *
-   * const program = Effect.gen(function*() {
-   *   let attempt = 0
-   *
-   *   const result = yield* Effect.retry(
-   *     Effect.gen(function*() {
-   *       attempt++
-   *       yield* Console.log(`Attempt ${attempt}`)
-   *
-   *       if (attempt < 7) { // Needs both phases to succeed
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
-   *       }
-   *
-   *       return `Success on attempt ${attempt}`
-   *     }),
-   *     composedRetry.pipe(
-   *       Schedule.tapOutput(([fastResult, slowResult]) =>
-   *         Console.log(`Fast phase: ${fastResult}, Slow phase: ${slowResult}`)
-   *       )
-   *     )
-   *   )
-   *
-   *   yield* Console.log(`Final result: ${result}`)
-   * })
-   *
-   * // Compose different schedule types
-   * const warmupAndMaintenance = Schedule.compose(
-   *   Schedule.fixed("500 millis").pipe(Schedule.take(5)), // 5 warmup cycles
-   *   Schedule.spaced("5 seconds") // then regular maintenance
-   * )
-   *
-   * // Progressive backoff: fixed first, then exponential
-   * const progressiveBackoff = Schedule.compose(
-   *   Schedule.fixed("100 millis").pipe(Schedule.take(3)), // Fixed: 100ms, 100ms, 100ms
-   *   Schedule.exponential("500 millis").pipe(Schedule.take(3)) // Then exponential: 500ms, 1s, 2s
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category sequencing
-   */
-  <Output2, Input2, Error2, Env2>(other: Schedule<Output2, Input2, Error2, Env2>): <Output, Input, Error, Env>(
-    self: Schedule<Output, Input, Error, Env>
-  ) => Schedule<[Output, Output2], Input & Input2, Error | Error2, Env | Env2>
-  /**
-   * Returns a new `Schedule` that combines two schedules by running them
-   * sequentially. First the current schedule runs to completion, then the
-   * other schedule runs to completion. The output is a tuple of both results.
-   *
-   * @example
-   * ```ts
-   * import { Console, Effect, Schedule } from "effect"
-   *
-   * // Compose a quick retry phase followed by slower retry phase
-   * const fastRetries = Schedule.exponential("100 millis").pipe(
-   *   Schedule.compose(Schedule.recurs(3)) // 3 fast retries
-   * )
-   *
-   * const slowRetries = Schedule.exponential("2 seconds").pipe(
-   *   Schedule.compose(Schedule.recurs(2)) // 2 slow retries
-   * )
-   *
-   * // Sequential composition: fast retries first, then slow retries
-   * const composedRetry = Schedule.compose(fastRetries, slowRetries)
-   * // Outputs: [number_from_fast_phase, number_from_slow_phase]
-   *
-   * const program = Effect.gen(function*() {
-   *   let attempt = 0
-   *
-   *   const result = yield* Effect.retry(
-   *     Effect.gen(function*() {
-   *       attempt++
-   *       yield* Console.log(`Attempt ${attempt}`)
-   *
-   *       if (attempt < 7) { // Needs both phases to succeed
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
-   *       }
-   *
-   *       return `Success on attempt ${attempt}`
-   *     }),
-   *     composedRetry.pipe(
-   *       Schedule.tapOutput(([fastResult, slowResult]) =>
-   *         Console.log(`Fast phase: ${fastResult}, Slow phase: ${slowResult}`)
-   *       )
-   *     )
-   *   )
-   *
-   *   yield* Console.log(`Final result: ${result}`)
-   * })
-   *
-   * // Compose different schedule types
-   * const warmupAndMaintenance = Schedule.compose(
-   *   Schedule.fixed("500 millis").pipe(Schedule.take(5)), // 5 warmup cycles
-   *   Schedule.spaced("5 seconds") // then regular maintenance
-   * )
-   *
-   * // Progressive backoff: fixed first, then exponential
-   * const progressiveBackoff = Schedule.compose(
-   *   Schedule.fixed("100 millis").pipe(Schedule.take(3)), // Fixed: 100ms, 100ms, 100ms
-   *   Schedule.exponential("500 millis").pipe(Schedule.take(3)) // Then exponential: 500ms, 1s, 2s
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category sequencing
-   */
-  <Output, Input, Error, Env, Output2, Input2, Error2, Env2>(
-    self: Schedule<Output, Input, Error, Env>,
-    other: Schedule<Output2, Input2, Error2, Env2>
-  ): Schedule<[Output, Output2], Input & Input2, Error | Error2, Env | Env2>
-} = dual(2, <Output, Input, Error, Env, Output2, Input2, Error2, Env2>(
-  self: Schedule<Output, Input, Error, Env>,
-  other: Schedule<Output2, Input2, Error2, Env2>
-): Schedule<[Output, Output2], Input & Input2, Error | Error2, Env | Env2> => both(self, other))
-
 /**
  * Returns a new `Schedule` that always recurs, collecting all inputs of the
  * schedule into an array.
@@ -2313,7 +2229,7 @@ export const collectWhile: {
   <Input, Output, Error2 = never, Env2 = never>(
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): <Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Array<Output>, Input, Error | Error2, Env | Env2>
@@ -2425,19 +2341,18 @@ export const collectWhile: {
     self: Schedule<Output, Input, Error, Env>,
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): Schedule<Array<Output>, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   predicate: (
     metadata: Metadata<Output, Input>
-  ) => Effect<boolean, Error2, Env2>
+  ) => boolean | Effect<boolean, Error2, Env2>
 ): Schedule<Array<Output>, Input, Error | Error2, Env | Env2> =>
-  reduce(while_(self, predicate), () => [] as Array<Output>, (outputs, output) =>
-    effect.succeed((() => {
-      outputs.push(output)
-      return outputs
-    })())))
+  reduce(while_(self, predicate), () => [] as Array<Output>, (outputs, output) => {
+    outputs.push(output)
+    return outputs
+  }))
 
 /**
  * Returns a new `Schedule` that recurs on the specified `Cron` schedule and
@@ -2445,7 +2360,9 @@ export const collectWhile: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class ScheduledTaskError extends Data.TaggedError("ScheduledTaskError")<{ readonly message: string }> {}
  *
  * // Run every minute
  * const everyMinute = Schedule.cron("* * * * *")
@@ -2546,7 +2463,7 @@ export const collectWhile: {
  *       yield* Console.log("Complex scheduled task...")
  *       // Simulate occasional failures
  *       if (Math.random() < 0.3) {
- *         yield* Effect.fail(new Error("Scheduled task failed"))
+ *         return yield* Effect.fail(new ScheduledTaskError({ message: "Scheduled task failed" }))
  *       }
  *       return "success"
  *     }),
@@ -2569,7 +2486,9 @@ export const cron: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class ScheduledTaskError extends Data.TaggedError("ScheduledTaskError")<{ readonly message: string }> {}
    *
    * // Run every minute
    * const everyMinute = Schedule.cron("* * * * *")
@@ -2670,7 +2589,7 @@ export const cron: {
    *       yield* Console.log("Complex scheduled task...")
    *       // Simulate occasional failures
    *       if (Math.random() < 0.3) {
-   *         yield* Effect.fail(new Error("Scheduled task failed"))
+   *         return yield* Effect.fail(new ScheduledTaskError({ message: "Scheduled task failed" }))
    *       }
    *       return "success"
    *     }),
@@ -2693,7 +2612,9 @@ export const cron: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class ScheduledTaskError extends Data.TaggedError("ScheduledTaskError")<{ readonly message: string }> {}
    *
    * // Run every minute
    * const everyMinute = Schedule.cron("* * * * *")
@@ -2794,7 +2715,7 @@ export const cron: {
    *       yield* Console.log("Complex scheduled task...")
    *       // Simulate occasional failures
    *       if (Math.random() < 0.3) {
-   *         yield* Effect.fail(new Error("Scheduled task failed"))
+   *         return yield* Effect.fail(new ScheduledTaskError({ message: "Scheduled task failed" }))
    *       }
    *       return "success"
    *     }),
@@ -2925,8 +2846,8 @@ export const delays = <Out, In, E, R>(self: Schedule<Out, In, E, R>): Schedule<D
  * @since 2.0.0
  * @category constructors
  */
-export const duration = (durationInput: Duration.DurationInput): Schedule<Duration.Duration> => {
-  const duration = Duration.fromDurationInputUnsafe(durationInput)
+export const duration = (durationInput: Duration.Input): Schedule<Duration.Duration> => {
+  const duration = Duration.fromInputUnsafe(durationInput)
   return fromStepWithMetadata(effect.succeed((meta) =>
     meta.attempt === 1
       ? effect.succeed([duration, duration])
@@ -2940,7 +2861,9 @@ export const duration = (durationInput: Duration.DurationInput): Schedule<Durati
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Run a task for exactly 5 seconds, regardless of how many iterations
  * const fiveSecondSchedule = Schedule.during("5 seconds")
@@ -3002,7 +2925,7 @@ export const duration = (durationInput: Duration.DurationInput): Schedule<Durati
  *       yield* Console.log(`Retry attempt ${attempt}`)
  *
  *       if (Math.random() < 0.8) { // 80% failure rate
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -3019,10 +2942,10 @@ export const duration = (durationInput: Duration.DurationInput): Schedule<Durati
  * @since 4.0.0
  * @category constructors
  */
-export const during = (duration: Duration.DurationInput): Schedule<Duration.Duration> =>
+export const during = (duration: Duration.Input): Schedule<Duration.Duration> =>
   while_(
     elapsed,
-    ({ output }) => effect.succeed(Duration.isLessThanOrEqualTo(output, Duration.fromDurationInputUnsafe(duration)))
+    ({ output }) => effect.succeed(Duration.isLessThanOrEqualTo(output, Duration.fromInputUnsafe(duration)))
   )
 
 /**
@@ -3032,7 +2955,9 @@ export const during = (duration: Duration.DurationInput): Schedule<Duration.Dura
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * 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))
@@ -3076,7 +3001,7 @@ export const during = (duration: Duration.DurationInput): Schedule<Duration.Dura
  *       yield* Console.log(`Retry attempt ${attempt}`)
  *
  *       if (attempt < 6) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -3102,7 +3027,9 @@ export const either: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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))
@@ -3146,7 +3073,7 @@ export const either: {
    *       yield* Console.log(`Retry attempt ${attempt}`)
    *
    *       if (attempt < 6) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -3174,7 +3101,9 @@ export const either: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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))
@@ -3218,7 +3147,7 @@ export const either: {
    *       yield* Console.log(`Retry attempt ${attempt}`)
    *
    *       if (attempt < 6) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -3722,7 +3651,9 @@ export const elapsed: Schedule<Duration.Duration> = fromStepWithMetadata(
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryFailure extends Data.TaggedError("RetryFailure")<{ readonly message: string }> {}
  *
  * // Basic exponential backoff with default factor of 2
  * const basicExponential = Schedule.exponential("100 millis")
@@ -3734,7 +3665,7 @@ export const elapsed: Schedule<Duration.Duration> = fromStepWithMetadata(
  *
  * // Retry with exponential backoff (limited to 5 attempts)
  * const retryPolicy = Schedule.exponential("50 millis").pipe(
- *   Schedule.compose(Schedule.recurs(5))
+ *   Schedule.both(Schedule.recurs(5))
  * )
  *
  * const program = Effect.gen(function*() {
@@ -3745,7 +3676,7 @@ export const elapsed: Schedule<Duration.Duration> = fromStepWithMetadata(
  *       attempt++
  *       if (attempt < 4) {
  *         yield* Console.log(`Attempt ${attempt} failed, retrying...`)
- *         yield* Effect.fail(new Error(`Failure ${attempt}`))
+ *         return yield* Effect.fail(new RetryFailure({ message: `Failure ${attempt}` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -3762,10 +3693,10 @@ export const elapsed: Schedule<Duration.Duration> = fromStepWithMetadata(
  * @category constructors
  */
 export const exponential = (
-  base: Duration.DurationInput,
+  base: Duration.Input,
   factor: number = 2
 ): Schedule<Duration.Duration> => {
-  const baseMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(base))
+  const baseMillis = Duration.toMillis(Duration.fromInputUnsafe(base))
   return fromStepWithMetadata(effect.succeed((meta) => {
     const duration = Duration.millis(baseMillis * Math.pow(factor, meta.attempt - 1))
     return effect.succeed([duration, duration])
@@ -3779,7 +3710,9 @@ export const exponential = (
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Basic fibonacci schedule starting with 100ms
  * const fibSchedule = Schedule.fibonacci("100 millis")
@@ -3795,13 +3728,13 @@ export const exponential = (
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 5) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
  *     }),
  *     Schedule.fibonacci("50 millis").pipe(
- *       Schedule.compose(Schedule.recurs(6)), // Maximum 6 retries
+ *       Schedule.both(Schedule.recurs(6)), // Maximum 6 retries
  *       Schedule.tapOutput((delay) => Console.log(`Next retry in ${delay}`))
  *     )
  *   )
@@ -3836,8 +3769,8 @@ export const exponential = (
  * @since 2.0.0
  * @category constructors
  */
-export const fibonacci = (one: Duration.DurationInput): Schedule<Duration.Duration> => {
-  const oneMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(one))
+export const fibonacci = (one: Duration.Input): Schedule<Duration.Duration> => {
+  const oneMillis = Duration.toMillis(Duration.fromInputUnsafe(one))
   return fromStep(effect.sync(() => {
     let a = 0
     let b = oneMillis
@@ -3913,16 +3846,28 @@ export const fibonacci = (one: Duration.DurationInput): Schedule<Duration.Durati
  * @since 2.0.0
  * @category constructors
  */
-export const fixed = (interval: Duration.DurationInput): Schedule<number> => {
-  const window = Duration.toMillis(Duration.fromDurationInputUnsafe(interval))
-  return fromStepWithMetadata(effect.succeed((meta) =>
-    effect.succeed([
-      meta.attempt - 1,
-      window === 0 || meta.elapsedSincePrevious > window
-        ? Duration.zero
-        : Duration.millis(window - (meta.elapsed % window))
-    ])
-  ))
+export const fixed = (interval: Duration.Input): Schedule<number> => {
+  const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
+  return fromStepWithMetadata(effect.sync(() => {
+    let start = 0
+    let lastRun = 0
+    return (meta) =>
+      effect.sync(() => {
+        if (window === 0) {
+          return [meta.attempt - 1, Duration.zero] as const
+        }
+        if (meta.attempt === 1) {
+          start = meta.now
+          lastRun = meta.now + window
+          return [0, Duration.millis(window)] as const
+        }
+        const runningBehind = meta.now > (lastRun + window)
+        const boundary = window - ((meta.now - start) % window)
+        const delay = runningBehind ? 0 : boundary === 0 ? window : boundary
+        lastRun = runningBehind ? meta.now : meta.now + delay
+        return [meta.attempt - 1, Duration.millis(delay)] as const
+      })
+  }))
 }
 
 /**
@@ -4050,7 +3995,7 @@ export const map: {
    * @since 2.0.0
    * @category mapping
    */
-  <Output, Output2, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Output2, Error2, Env2>): <Input, Error, Env>(
+  <Output, Output2, Error2 = never, Env2 = never>(f: (output: Output) => Output2 | Effect<Output2, Error2, Env2>): <Input, Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Output2, Input, Error | Error2, Env | Env2>
   /**
@@ -4117,17 +4062,24 @@ export const map: {
    */
   <Output, Input, Error, Env, Output2, Error2 = never, Env2 = never>(
     self: Schedule<Output, Input, Error, Env>,
-    f: (output: Output) => Effect<Output2, Error2, Env2>
+    f: (output: Output) => Output2 | Effect<Output2, Error2, Env2>
   ): Schedule<Output2, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Output2, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
-  f: (output: Output) => Effect<Output2, Error2, Env2>
+  f: (output: Output) => Output2 | Effect<Output2, Error2, Env2>
 ): Schedule<Output2, Input, Error | Error2, Env | Env2> => {
   const handle = Pull.matchEffect({
-    onSuccess: ([output, duration]: [Output, Duration.Duration]) =>
-      effect.map(f(output), (output) => [output, duration] as [Output2, Duration.Duration]),
+    onSuccess: ([output, duration]: [Output, Duration.Duration]) => {
+      const result = f(output)
+      if (!isEffect(result)) return effect.succeed([result, duration] as [Output2, Duration.Duration])
+      return effect.map(result, (output) => [output, duration] as [Output2, Duration.Duration])
+    },
     onFailure: effect.failCause<Error>,
-    onDone: (output: Output) => effect.flatMap(f(output), Cause.done)
+    onDone: (output: Output) => {
+      const result = f(output)
+      if (!isEffect(result)) return Cause.done(result as Output2)
+      return effect.flatMap(result, Cause.done)
+    }
   })
   return fromStep(effect.map(toStep(self), (step) => (now, input) => handle(step(now, input))))
 })
@@ -4201,7 +4153,7 @@ export const modifyDelay: {
     f: (
       output: Output,
       delay: Duration.Duration
-    ) => Effect<Duration.DurationInput, Error2, Env2>
+    ) => Effect<Duration.Input, Error2, Env2>
   ): <Input, Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Output, Input, Error | Error2, Env | Env2>
@@ -4241,22 +4193,39 @@ export const modifyDelay: {
     self: Schedule<Output, Input, Error, Env>,
     f: (
       output: Output,
-      delay: Duration.DurationInput
-    ) => Effect<Duration.DurationInput, Error2, Env2>
+      delay: Duration.Input
+    ) => Effect<Duration.Input, Error2, Env2>
   ): Schedule<Output, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   f: (
     output: Output,
-    delay: Duration.DurationInput
-  ) => Effect<Duration.DurationInput, Error2, Env2>
+    delay: Duration.Input
+  ) => Effect<Duration.Input, Error2, Env2>
 ): Schedule<Output, Input, Error | Error2, Env | Env2> =>
   fromStep(effect.map(toStep(self), (step) => (now, input) =>
     effect.flatMap(
       step(now, input),
-      ([output, delay]) => effect.map(f(output, delay), (delay) => [output, Duration.fromDurationInputUnsafe(delay)])
+      ([output, delay]) => effect.map(f(output, delay), (delay) => [output, Duration.fromInputUnsafe(delay)])
     ))))
 
+/**
+ * Returns a new `Schedule` that randomly adjusts each recurrence delay.
+ *
+ * Delays are jittered between `80%` and `120%` of the original delay.
+ *
+ * @since 2.0.0
+ * @category utilities
+ */
+export const jittered = <Output, Input, Error, Env>(
+  self: Schedule<Output, Input, Error, Env>
+): Schedule<Output, Input, Error, Env> =>
+  modifyDelay(self, (_, delay) =>
+    effect.map(randomNext, (random) => {
+      const millis = Duration.toMillis(Duration.fromInputUnsafe(delay))
+      return Duration.millis(millis * 0.8 * (1 - random) + millis * 1.2 * random)
+    }))
+
 /**
  * Returns a new `Schedule` that outputs the inputs of the specified schedule.
  *
@@ -4301,7 +4270,9 @@ export const passthrough = <Output, Input, Error, Env>(
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Basic recurs - retry at most 3 times
  * const maxThreeAttempts = Schedule.recurs(3)
@@ -4316,7 +4287,7 @@ export const passthrough = <Output, Input, Error, Env>(
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 4) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -4329,7 +4300,7 @@ export const passthrough = <Output, Input, Error, Env>(
  *
  * // Combining recurs with other schedules for sophisticated retry logic
  * const complexRetry = Schedule.exponential("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(3)) // At most 3 attempts
+ *   Schedule.both(Schedule.recurs(3)) // At most 3 attempts
  * )
  *
  * // Repeat an effect exactly 10 times
@@ -4577,7 +4548,7 @@ export const reduce: {
    */
   <State, Output, Error2 = never, Env2 = never>(
     initial: LazyArg<State>,
-    combine: (state: State, output: Output) => Effect<State, Error2, Env2>
+    combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>
   ): <Input, Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<State, Input, Error | Error2, Env | Env2>
@@ -4695,24 +4666,33 @@ export const reduce: {
   <Output, Input, Error, Env, State, Error2 = never, Env2 = never>(
     self: Schedule<Output, Input, Error, Env>,
     initial: LazyArg<State>,
-    combine: (state: State, output: Output) => Effect<State, Error2, Env2>
+    combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>
   ): Schedule<State, Input, Error | Error2, Env | Env2>
 } = dual(3, <Output, Input, Error, Env, State, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   initial: LazyArg<State>,
-  combine: (state: State, output: Output) => Effect<State, Error2, Env2>
+  combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>
 ): Schedule<State, Input, Error | Error2, Env | Env2> =>
   fromStep(effect.map(toStep(self), (step) => {
     let state = initial()
     return (now, input) =>
       Pull.matchEffect(step(now, input), {
-        onSuccess: ([output, delay]) =>
-          effect.map(combine(state, output), (nextState) => {
+        onSuccess([output, delay]) {
+          const next = combine(state, output)
+          if (!isEffect(next)) {
+            state = next
+            return effect.succeed([next, delay] as [State, Duration.Duration])
+          }
+          return effect.map(next, (nextState) => {
             state = nextState
             return [nextState, delay]
-          }),
+          })
+        },
         onFailure: effect.failCause,
-        onDone: (output) => effect.flatMap(combine(state, output), Cause.done)
+        onDone(output) {
+          const next = combine(state, output)
+          return isEffect(next) ? effect.flatMap(next, Cause.done) : Cause.done(next)
+        }
       })
   })))
 
@@ -4747,7 +4727,7 @@ export const reduce: {
  *
  * // Simple spaced schedule with limited repetitions
  * const limitedSpaced = Schedule.spaced("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(5)) // at most 5 times
+ *   Schedule.both(Schedule.recurs(5)) // at most 5 times
  * )
  *
  * const program = Effect.gen(function*() {
@@ -4765,8 +4745,8 @@ export const reduce: {
  * @since 2.0.0
  * @category constructors
  */
-export const spaced = (duration: Duration.DurationInput): Schedule<number> => {
-  const decoded = Duration.fromDurationInputUnsafe(duration)
+export const spaced = (duration: Duration.Input): Schedule<number> => {
+  const decoded = Duration.fromInputUnsafe(duration)
   return fromStepWithMetadata(effect.succeed((meta) => effect.succeed([meta.attempt - 1, decoded])))
 }
 
@@ -4777,12 +4757,14 @@ export const spaced = (duration: Duration.DurationInput): Schedule<number> => {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * 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: Error) =>
+ *   Schedule.tapInput((error: RetryError) =>
  *     Console.log(`Retry triggered by error: ${String(error)}`)
  *   )
  * )
@@ -4794,7 +4776,7 @@ export const spaced = (duration: Duration.DurationInput): Schedule<number> => {
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 4) {
- *         yield* Effect.fail(new Error(`Network timeout on attempt ${attempt}`))
+ *         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -4843,7 +4825,7 @@ export const spaced = (duration: Duration.DurationInput): Schedule<number> => {
  * // Conditional alerting based on input
  * const alertingSchedule = Schedule.exponential("200 millis").pipe(
  *   Schedule.take(6),
- *   Schedule.tapInput((error: Error) =>
+ *   Schedule.tapInput((error: RetryError) =>
  *     Effect.gen(function*() {
  *       if (String(error).includes("critical")) {
  *         yield* Console.log(`🚨 CRITICAL ERROR: ${String(error)}`)
@@ -4865,7 +4847,7 @@ export const spaced = (duration: Duration.DurationInput): Schedule<number> => {
  *       const errorType = isCritical
  *         ? "critical database failure"
  *         : "temporary network issue"
- *       yield* Effect.fail(new Error(errorType))
+ *       return yield* Effect.fail(new RetryError({ message: errorType }))
  *     }),
  *     alertingSchedule
  *   ).pipe(
@@ -4878,10 +4860,10 @@ export const spaced = (duration: Duration.DurationInput): Schedule<number> => {
  * // Chain multiple input taps for different purposes
  * const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
  *   Schedule.take(5),
- *   Schedule.tapInput((error: Error) =>
- *     Console.log(`Error occurred: ${error.name}`)
+ *   Schedule.tapInput((error: RetryError) =>
+ *     Console.log(`Error occurred: ${error._tag}`)
  *   ),
- *   Schedule.tapInput((error: Error) =>
+ *   Schedule.tapInput((error: RetryError) =>
  *     String(error).length > 20
  *       ? Console.log("📝 Long error message detected")
  *       : Effect.void
@@ -4900,12 +4882,14 @@ export const tapInput: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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: Error) =>
+   *   Schedule.tapInput((error: RetryError) =>
    *     Console.log(`Retry triggered by error: ${String(error)}`)
    *   )
    * )
@@ -4917,7 +4901,7 @@ export const tapInput: {
    *     Effect.gen(function*() {
    *       attempt++
    *       if (attempt < 4) {
-   *         yield* Effect.fail(new Error(`Network timeout on attempt ${attempt}`))
+   *         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -4966,7 +4950,7 @@ export const tapInput: {
    * // Conditional alerting based on input
    * const alertingSchedule = Schedule.exponential("200 millis").pipe(
    *   Schedule.take(6),
-   *   Schedule.tapInput((error: Error) =>
+   *   Schedule.tapInput((error: RetryError) =>
    *     Effect.gen(function*() {
    *       if (String(error).includes("critical")) {
    *         yield* Console.log(`🚨 CRITICAL ERROR: ${String(error)}`)
@@ -4988,7 +4972,7 @@ export const tapInput: {
    *       const errorType = isCritical
    *         ? "critical database failure"
    *         : "temporary network issue"
-   *       yield* Effect.fail(new Error(errorType))
+   *       return yield* Effect.fail(new RetryError({ message: errorType }))
    *     }),
    *     alertingSchedule
    *   ).pipe(
@@ -5001,10 +4985,10 @@ export const tapInput: {
    * // Chain multiple input taps for different purposes
    * const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
    *   Schedule.take(5),
-   *   Schedule.tapInput((error: Error) =>
-   *     Console.log(`Error occurred: ${error.name}`)
+   *   Schedule.tapInput((error: RetryError) =>
+   *     Console.log(`Error occurred: ${error._tag}`)
    *   ),
-   *   Schedule.tapInput((error: Error) =>
+   *   Schedule.tapInput((error: RetryError) =>
    *     String(error).length > 20
    *       ? Console.log("📝 Long error message detected")
    *       : Effect.void
@@ -5025,12 +5009,14 @@ export const tapInput: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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: Error) =>
+   *   Schedule.tapInput((error: RetryError) =>
    *     Console.log(`Retry triggered by error: ${String(error)}`)
    *   )
    * )
@@ -5042,7 +5028,7 @@ export const tapInput: {
    *     Effect.gen(function*() {
    *       attempt++
    *       if (attempt < 4) {
-   *         yield* Effect.fail(new Error(`Network timeout on attempt ${attempt}`))
+   *         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -5091,7 +5077,7 @@ export const tapInput: {
    * // Conditional alerting based on input
    * const alertingSchedule = Schedule.exponential("200 millis").pipe(
    *   Schedule.take(6),
-   *   Schedule.tapInput((error: Error) =>
+   *   Schedule.tapInput((error: RetryError) =>
    *     Effect.gen(function*() {
    *       if (String(error).includes("critical")) {
    *         yield* Console.log(`🚨 CRITICAL ERROR: ${String(error)}`)
@@ -5113,7 +5099,7 @@ export const tapInput: {
    *       const errorType = isCritical
    *         ? "critical database failure"
    *         : "temporary network issue"
-   *       yield* Effect.fail(new Error(errorType))
+   *       return yield* Effect.fail(new RetryError({ message: errorType }))
    *     }),
    *     alertingSchedule
    *   ).pipe(
@@ -5126,10 +5112,10 @@ export const tapInput: {
    * // Chain multiple input taps for different purposes
    * const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
    *   Schedule.take(5),
-   *   Schedule.tapInput((error: Error) =>
-   *     Console.log(`Error occurred: ${error.name}`)
+   *   Schedule.tapInput((error: RetryError) =>
+   *     Console.log(`Error occurred: ${error._tag}`)
    *   ),
-   *   Schedule.tapInput((error: Error) =>
+   *   Schedule.tapInput((error: RetryError) =>
    *     String(error).length > 20
    *       ? Console.log("📝 Long error message detected")
    *       : Effect.void
@@ -5160,7 +5146,9 @@ export const tapInput: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * 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(
@@ -5175,7 +5163,7 @@ export const tapInput: {
  *     Effect.gen(function*() {
  *       attempt++
  *       if (attempt < 4) {
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *       return `Success on attempt ${attempt}`
  *     }),
@@ -5244,7 +5232,9 @@ export const tapOutput: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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(
@@ -5259,7 +5249,7 @@ export const tapOutput: {
    *     Effect.gen(function*() {
    *       attempt++
    *       if (attempt < 4) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -5330,7 +5320,9 @@ export const tapOutput: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * 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(
@@ -5345,7 +5337,7 @@ export const tapOutput: {
    *     Effect.gen(function*() {
    *       attempt++
    *       if (attempt < 4) {
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *       return `Success on attempt ${attempt}`
    *     }),
@@ -5426,7 +5418,9 @@ export const tapOutput: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Limit an infinite schedule to run only 5 times
  * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
@@ -5459,7 +5453,7 @@ export const tapOutput: {
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 5) { // Will fail more than 3 times
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -5505,7 +5499,9 @@ export const take: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // Limit an infinite schedule to run only 5 times
    * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
@@ -5538,7 +5534,7 @@ export const take: {
    *       yield* Console.log(`Attempt ${attempt}`)
    *
    *       if (attempt < 5) { // Will fail more than 3 times
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -5586,7 +5582,9 @@ export const take: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // Limit an infinite schedule to run only 5 times
    * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
@@ -5619,7 +5617,7 @@ export const take: {
    *       yield* Console.log(`Attempt ${attempt}`)
    *
    *       if (attempt < 5) { // Will fail more than 3 times
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -5779,7 +5777,7 @@ const while_: {
   <Input, Output, Error2 = never, Env2 = never>(
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): <Error, Env>(
     self: Schedule<Output, Input, Error, Env>
   ) => Schedule<Output, Input, Error | Error2, Env | Env2>
@@ -5787,21 +5785,22 @@ const while_: {
     self: Schedule<Output, Input, Error, Env>,
     predicate: (
       metadata: Metadata<Output, Input>
-    ) => Effect<boolean, Error2, Env2>
+    ) => boolean | Effect<boolean, Error2, Env2>
   ): Schedule<Output, Input, Error | Error2, Env | Env2>
 } = dual(2, <Output, Input, Error, Env, Error2 = never, Env2 = never>(
   self: Schedule<Output, Input, Error, Env>,
   predicate: (
     metadata: Metadata<Output, Input>
-  ) => Effect<boolean, Error2, Env2>
+  ) => boolean | Effect<boolean, Error2, Env2>
 ): Schedule<Output, Input, Error | Error2, Env | Env2> =>
   fromStep(effect.map(toStep(self), (step) => {
     const meta = metadataFn()
     return (now, input) =>
       effect.flatMap(step(now, input), (result) => {
         const [output, duration] = result
+        const eff = predicate({ ...meta(now, input), output, duration })
         return effect.flatMap(
-          predicate({ ...meta(now, input), output, duration }),
+          isEffect(eff) ? eff : effect.succeed(eff),
           (check) => (check ? effect.succeed(result) : Cause.done(output))
         )
       })
@@ -5856,8 +5855,8 @@ export {
  * @since 2.0.0
  * @category constructors
  */
-export const windowed = (interval: Duration.DurationInput): Schedule<number> => {
-  const window = Duration.toMillis(Duration.fromDurationInputUnsafe(interval))
+export const windowed = (interval: Duration.Input): Schedule<number> => {
+  const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
   return fromStepWithMetadata(effect.succeed((meta) =>
     effect.sync(() => [
       meta.attempt - 1,
@@ -5947,6 +5946,16 @@ export const satisfiesInputType = <T>() =>
   self: Schedule<Output, Input, Error, Env>
 ): Schedule<Output, Input, Error, Env> => self
 
+/**
+ * Sets the input type of the provided schedule to a specified type, without
+ * altering the schedule's behavior.
+ *
+ * @since 2.0.0
+ * @category ensuring types
+ */
+export const setInputType =
+  <T>() => <Output, Error, Env>(self: Schedule<Output, T, Error, Env>): Schedule<Output, T, Error, Env> => self
+
 /**
  * Ensures that the provided schedule respects a specified output type.
  *