effect 4.0.0-beta.3 → 4.0.0-beta.30

package/src/Schedule.ts

@@ -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.
  *
@@ -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}`
  *     }),
@@ -346,7 +349,7 @@ export const fromStep = <Input, Output, EnvX, Error, ErrorX, Env>(
     Error,
     Env
   >
-): Schedule<Output, Input, Error | ErrorX, Env | EnvX> => {
+): Schedule<Output, Input, Error | Pull.ExcludeDone<ErrorX>, Env | EnvX> => {
   const self = Object.create(ScheduleProto)
   self.step = step
   return self
@@ -395,7 +398,7 @@ export const fromStepWithMetadata = <Input, Output, EnvX, ErrorX, Error, Env>(
     Error,
     Env
   >
-): Schedule<Output, Input, Error | ErrorX, Env | EnvX> =>
+): Schedule<Output, Input, Error | Pull.ExcludeDone<ErrorX>, Env | EnvX> =>
   fromStep(effect.map(step, (f) => {
     const meta = metadataFn()
     return (now, input) => f(meta(now, input))
@@ -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}`
@@ -1845,7 +1960,9 @@ export const bothWith: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
  *
  * // Compose a quick retry phase followed by slower retry phase
  * const fastRetries = Schedule.exponential("100 millis").pipe(
@@ -1869,7 +1986,7 @@ export const bothWith: {
  *       yield* Console.log(`Attempt ${attempt}`)
  *
  *       if (attempt < 7) { // Needs both phases to succeed
- *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+ *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
  *       }
  *
  *       return `Success on attempt ${attempt}`
@@ -1908,7 +2025,9 @@ export const compose: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // Compose a quick retry phase followed by slower retry phase
    * const fastRetries = Schedule.exponential("100 millis").pipe(
@@ -1932,7 +2051,7 @@ export const compose: {
    *       yield* Console.log(`Attempt ${attempt}`)
    *
    *       if (attempt < 7) { // Needs both phases to succeed
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -1973,7 +2092,9 @@ export const compose: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
    *
    * // Compose a quick retry phase followed by slower retry phase
    * const fastRetries = Schedule.exponential("100 millis").pipe(
@@ -1997,7 +2118,7 @@ export const compose: {
    *       yield* Console.log(`Attempt ${attempt}`)
    *
    *       if (attempt < 7) { // Needs both phases to succeed
-   *         yield* Effect.fail(new Error(`Attempt ${attempt} failed`))
+   *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
    *       }
    *
    *       return `Success on attempt ${attempt}`
@@ -2313,7 +2434,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 +2546,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 +2565,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 +2668,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 +2691,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 +2794,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 +2817,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 +2920,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"
    *     }),
@@ -2916,13 +3042,33 @@ export const delays = <Out, In, E, R>(self: Schedule<Out, In, E, R>): Schedule<D
     )
   )
 
+/**
+ * Returns a schedule that recurs once after the specified duration.
+ *
+ * The schedule outputs the configured duration for its first recurrence and
+ * then completes.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+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])
+      : Cause.done(Duration.zero)
+  ))
+}
+
 /**
  * Returns a new `Schedule` that will always recur, but only during the
  * specified `duration` of time.
  *
  * @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")
@@ -2984,7 +3130,7 @@ export const delays = <Out, In, E, R>(self: Schedule<Out, In, E, R>): Schedule<D
  *       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}`
@@ -3001,10 +3147,10 @@ export const delays = <Out, In, E, R>(self: Schedule<Out, In, E, R>): Schedule<D
  * @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)))
   )
 
 /**
@@ -3014,7 +3160,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))
@@ -3058,7 +3206,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}`
@@ -3084,7 +3232,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))
@@ -3128,7 +3278,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}`
@@ -3156,7 +3306,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))
@@ -3200,7 +3352,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}`
@@ -3704,7 +3856,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")
@@ -3727,7 +3881,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}`
  *     }),
@@ -3744,10 +3898,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])
@@ -3761,7 +3915,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")
@@ -3777,7 +3933,7 @@ 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}`
@@ -3818,8 +3974,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
@@ -3895,12 +4051,12 @@ 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))
+export const fixed = (interval: Duration.Input): Schedule<number> => {
+  const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
   return fromStepWithMetadata(effect.succeed((meta) =>
     effect.succeed([
       meta.attempt - 1,
-      window === 0 || meta.elapsedSincePrevious > window
+      window === 0
         ? Duration.zero
         : Duration.millis(window - (meta.elapsed % window))
     ])
@@ -4032,7 +4188,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>
   /**
@@ -4099,17 +4255,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))))
 })
@@ -4183,7 +4346,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>
@@ -4223,22 +4386,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.
  *
@@ -4283,7 +4463,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)
@@ -4298,7 +4480,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}`
@@ -4559,7 +4741,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>
@@ -4677,24 +4859,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,8 +4938,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])))
 }
 
@@ -4759,12 +4950,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)}`)
  *   )
  * )
@@ -4776,7 +4969,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}`
  *     }),
@@ -4825,7 +5018,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)}`)
@@ -4847,7 +5040,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(
@@ -4860,10 +5053,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
@@ -4882,12 +5075,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)}`)
    *   )
    * )
@@ -4899,7 +5094,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}`
    *     }),
@@ -4948,7 +5143,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)}`)
@@ -4970,7 +5165,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(
@@ -4983,10 +5178,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
@@ -5007,12 +5202,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)}`)
    *   )
    * )
@@ -5024,7 +5221,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}`
    *     }),
@@ -5073,7 +5270,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)}`)
@@ -5095,7 +5292,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(
@@ -5108,10 +5305,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
@@ -5142,7 +5339,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(
@@ -5157,7 +5356,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}`
  *     }),
@@ -5226,7 +5425,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(
@@ -5241,7 +5442,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}`
    *     }),
@@ -5312,7 +5513,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(
@@ -5327,7 +5530,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}`
    *     }),
@@ -5408,7 +5611,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(
@@ -5441,7 +5646,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}`
@@ -5487,7 +5692,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(
@@ -5520,7 +5727,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}`
@@ -5568,7 +5775,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(
@@ -5601,7 +5810,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}`
@@ -5761,7 +5970,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>
@@ -5769,21 +5978,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))
         )
       })
@@ -5838,8 +6048,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,
@@ -5929,6 +6139,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.
  *