effect 4.0.0-beta.6 → 4.0.0-beta.62

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
@@ -30,6 +30,7 @@
  * @since 2.0.0
  */
 import * as Cause from "./Cause.ts"
+import * as Context from "./Context.ts"
 import * as Cron from "./Cron.ts"
 import type * as DateTime from "./DateTime.ts"
 import * as Duration from "./Duration.ts"
@@ -38,15 +39,17 @@ 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"
 import * as Result from "./Result.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 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
  *   )
  *
@@ -163,7 +166,7 @@ export interface Metadata<Output = unknown, Input = unknown> extends InputMetada
  * @since 4.0.0
  * @category Metadata
  */
-export const CurrentMetadata = ServiceMap.Reference<Metadata>("effect/Schedule/CurrentMetadata", {
+export const CurrentMetadata = Context.Reference<Metadata>("effect/Schedule/CurrentMetadata", {
   defaultValue: constant({
     input: undefined,
     output: undefined,
@@ -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}`
    *     }),
@@ -1353,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
@@ -1395,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}`
@@ -1421,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
@@ -1463,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}`
@@ -1491,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
@@ -1533,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}`
@@ -1933,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.
@@ -2408,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>
@@ -2520,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
@@ -2540,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("* * * * *")
@@ -2641,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"
  *     }),
@@ -2664,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("* * * * *")
@@ -2765,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"
    *     }),
@@ -2788,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("* * * * *")
@@ -2889,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"
    *     }),
@@ -3020,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])
@@ -3035,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")
@@ -3097,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}`
@@ -3114,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)))
   )
 
 /**
@@ -3127,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))
@@ -3171,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}`
@@ -3197,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))
@@ -3241,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}`
@@ -3269,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))
@@ -3313,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}`
@@ -3817,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")
@@ -3829,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*() {
@@ -3840,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}`
  *     }),
@@ -3857,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])
@@ -3874,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")
@@ -3890,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}`))
  *     )
  *   )
@@ -3931,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
@@ -4008,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
+      })
+  }))
 }
 
 /**
@@ -4303,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>
@@ -4343,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.
  *
@@ -4403,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)
@@ -4418,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}`
@@ -4431,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
@@ -4679,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>
@@ -4797,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)
+        }
       })
   })))
 
@@ -4849,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*() {
@@ -4867,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])))
 }
 
@@ -4879,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)}`)
  *   )
  * )
@@ -4896,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}`
  *     }),
@@ -4945,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)}`)
@@ -4967,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(
@@ -4980,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
@@ -5002,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)}`)
    *   )
    * )
@@ -5019,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}`
    *     }),
@@ -5068,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)}`)
@@ -5090,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(
@@ -5103,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
@@ -5127,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)}`)
    *   )
    * )
@@ -5144,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}`
    *     }),
@@ -5193,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)}`)
@@ -5215,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(
@@ -5228,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
@@ -5262,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(
@@ -5277,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}`
  *     }),
@@ -5346,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(
@@ -5361,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}`
    *     }),
@@ -5432,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(
@@ -5447,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}`
    *     }),
@@ -5528,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(
@@ -5561,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}`
@@ -5607,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(
@@ -5640,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}`
@@ -5688,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(
@@ -5721,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}`
@@ -5881,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>
@@ -5889,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))
         )
       })
@@ -5958,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,
@@ -6049,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.
  *