effect 4.0.0-beta.5 → 4.0.0-beta.50

package/dist/Schedule.d.ts

@@ -1,3 +1,4 @@
+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";
@@ -6,7 +7,6 @@ import type { LazyArg } from "./Function.ts";
 import { type Pipeable } from "./Pipeable.ts";
 import * as Pull from "./Pull.ts";
 import * as Result from "./Result.ts";
-import * as ServiceMap from "./ServiceMap.ts";
 import type { Contravariant, Covariant } from "./Types.ts";
 declare const TypeId = "~effect/Schedule";
 /**
@@ -18,7 +18,7 @@ declare 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
@@ -31,7 +31,7 @@ declare 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
  *   )
  *
@@ -121,7 +121,7 @@ export interface Metadata<Output = unknown, Input = unknown> extends InputMetada
  * @since 4.0.0
  * @category Metadata
  */
-export declare const CurrentMetadata: ServiceMap.Reference<Metadata<unknown, unknown>>;
+export declare const CurrentMetadata: Context.Reference<Metadata<unknown, unknown>>;
 /**
  * The Schedule namespace contains types and utilities for working with schedules.
  *
@@ -143,7 +143,7 @@ export declare const CurrentMetadata: ServiceMap.Reference<Metadata<unknown, unk
  *     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}`
  *     }),
@@ -265,7 +265,7 @@ export declare const isSchedule: (u: unknown) => u is Schedule<unknown, never, u
  *
  * // These can be combined and transformed as needed
  * const complexSchedule = simpleSchedule.pipe(
- *   Schedule.compose(Schedule.recurs(3))
+ *   Schedule.both(Schedule.recurs(3))
  * )
  * ```
  *
@@ -367,7 +367,9 @@ export declare const toStepWithSleep: <Output, Input, Error, Env>(schedule: Sche
  *
  * @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(
@@ -463,7 +465,7 @@ export declare const toStepWithSleep: <Output, Input, Error, Env>(schedule: Sche
  *     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}`
  *     }),
@@ -484,7 +486,9 @@ export declare 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(
@@ -580,7 +584,7 @@ export declare 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}`
      *     }),
@@ -594,14 +598,16 @@ export declare const addDelay: {
      * @since 2.0.0
      * @category utils
      */
-    <Output, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <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>;
     /**
      * Returns a new `Schedule` that adds the delay computed by the specified
      * effectful function to the the next recurrence of the schedule.
      *
      * @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(
@@ -697,7 +703,7 @@ export declare 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}`
      *     }),
@@ -711,7 +717,7 @@ export declare const addDelay: {
      * @since 2.0.0
      * @category utils
      */
-    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Effect<Duration.DurationInput, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Effect<Duration.Input, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a new `Schedule` that will first execute the left (i.e. `self`)
@@ -720,7 +726,9 @@ export declare 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(
@@ -739,7 +747,7 @@ export declare 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}`
  *     }),
@@ -759,7 +767,9 @@ export declare 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(
@@ -778,7 +788,7 @@ export declare 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}`
      *     }),
@@ -798,7 +808,9 @@ export declare 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(
@@ -817,7 +829,7 @@ export declare 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}`
      *     }),
@@ -962,7 +974,9 @@ export declare 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
@@ -1004,7 +1018,7 @@ export declare 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}`
@@ -1030,7 +1044,9 @@ export declare 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
@@ -1072,7 +1088,7 @@ export declare 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}`
@@ -1098,7 +1114,9 @@ export declare 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
@@ -1140,7 +1158,7 @@ export declare 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}`
@@ -1478,196 +1496,6 @@ export declare const bothWith: {
      */
     <Output, Input, Error, Env, Output2, Input2, Error2, Env2, Output3>(self: Schedule<Output, Input, Error, Env>, other: Schedule<Output2, Input2, Error2, Env2>, combine: (selfOutput: Output, otherOutput: Output2) => Output3): Schedule<Output3, 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
- */
-export declare 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>;
-};
 /**
  * Returns a new `Schedule` that always recurs, collecting all inputs of the
  * schedule into an array.
@@ -1935,7 +1763,7 @@ export declare const collectWhile: {
      * @since 2.0.0
      * @category utilities
      */
-    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
+    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
     /**
      * Returns a new `Schedule` that recurs as long as the specified `predicate`
      * returns `true`, collecting all outputs of the schedule into an array.
@@ -2040,7 +1868,7 @@ export declare const collectWhile: {
      * @since 2.0.0
      * @category utilities
      */
-    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): Schedule<Array<Output>, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a new `Schedule` that recurs on the specified `Cron` schedule and
@@ -2048,7 +1876,9 @@ export declare 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("* * * * *")
@@ -2149,7 +1979,7 @@ export declare 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"
  *     }),
@@ -2172,7 +2002,9 @@ export declare 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("* * * * *")
@@ -2273,7 +2105,7 @@ export declare 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"
      *     }),
@@ -2296,7 +2128,9 @@ export declare 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("* * * * *")
@@ -2397,7 +2231,7 @@ export declare 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"
      *     }),
@@ -2508,14 +2342,16 @@ export declare const delays: <Out, In, E, R>(self: Schedule<Out, In, E, R>) => S
  * @since 2.0.0
  * @category constructors
  */
-export declare const duration: (durationInput: Duration.DurationInput) => Schedule<Duration.Duration>;
+export declare const duration: (durationInput: Duration.Input) => Schedule<Duration.Duration>;
 /**
  * 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")
@@ -2577,7 +2413,7 @@ export declare const duration: (durationInput: Duration.DurationInput) => Schedu
  *       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}`
@@ -2594,7 +2430,7 @@ export declare const duration: (durationInput: Duration.DurationInput) => Schedu
  * @since 4.0.0
  * @category constructors
  */
-export declare const during: (duration: Duration.DurationInput) => Schedule<Duration.Duration>;
+export declare const during: (duration: Duration.Input) => Schedule<Duration.Duration>;
 /**
  * Combines two `Schedule`s by recurring if either of the two schedules wants
  * to recur, using the minimum of the two durations between recurrences and
@@ -2602,7 +2438,9 @@ export declare const during: (duration: Duration.DurationInput) => Schedule<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))
@@ -2646,7 +2484,7 @@ export declare const during: (duration: Duration.DurationInput) => Schedule<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}`
@@ -2672,7 +2510,9 @@ export declare 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))
@@ -2716,7 +2556,7 @@ export declare 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}`
@@ -2742,7 +2582,9 @@ export declare 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))
@@ -2786,7 +2628,7 @@ export declare 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}`
@@ -3176,7 +3018,9 @@ export declare const elapsed: Schedule<Duration.Duration>;
  *
  * @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")
@@ -3188,7 +3032,7 @@ export declare const elapsed: Schedule<Duration.Duration>;
  *
  * // 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*() {
@@ -3199,7 +3043,7 @@ export declare const elapsed: Schedule<Duration.Duration>;
  *       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}`
  *     }),
@@ -3215,7 +3059,7 @@ export declare const elapsed: Schedule<Duration.Duration>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const exponential: (base: Duration.DurationInput, factor?: number) => Schedule<Duration.Duration>;
+export declare const exponential: (base: Duration.Input, factor?: number) => Schedule<Duration.Duration>;
 /**
  * A schedule that always recurs, increasing delays by summing the preceding
  * two delays (similar to the fibonacci sequence). Returns the current
@@ -3223,7 +3067,9 @@ export declare const exponential: (base: Duration.DurationInput, factor?: number
  *
  * @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")
@@ -3239,13 +3085,13 @@ export declare const exponential: (base: Duration.DurationInput, factor?: number
  *       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}`))
  *     )
  *   )
@@ -3280,7 +3126,7 @@ export declare const exponential: (base: Duration.DurationInput, factor?: number
  * @since 2.0.0
  * @category constructors
  */
-export declare const fibonacci: (one: Duration.DurationInput) => Schedule<Duration.Duration>;
+export declare const fibonacci: (one: Duration.Input) => Schedule<Duration.Duration>;
 /**
  * Returns a `Schedule` that recurs on the specified fixed `interval` and
  * outputs the number of repetitions of the schedule so far.
@@ -3343,7 +3189,7 @@ export declare const fibonacci: (one: Duration.DurationInput) => Schedule<Durati
  * @since 2.0.0
  * @category constructors
  */
-export declare const fixed: (interval: Duration.DurationInput) => Schedule<number>;
+export declare const fixed: (interval: Duration.Input) => Schedule<number>;
 /**
  * Returns a new `Schedule` that maps the output of this schedule using the
  * specified function.
@@ -3469,7 +3315,7 @@ export declare const map: {
      * @since 2.0.0
      * @category mapping
      */
-    <Output, Output2, Error2 = never, Env2 = never>(f: (output: Output) => Effect<Output2, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output2, Input, Error | Error2, Env | Env2>;
+    <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>;
     /**
      * Returns a new `Schedule` that maps the output of this schedule using the
      * specified function.
@@ -3532,7 +3378,7 @@ export declare const map: {
      * @since 2.0.0
      * @category mapping
      */
-    <Output, Input, Error, Env, Output2, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Effect<Output2, Error2, Env2>): Schedule<Output2, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Output2, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output) => Output2 | Effect<Output2, Error2, Env2>): Schedule<Output2, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a new `Schedule` that modifies the delay of the next recurrence
@@ -3599,7 +3445,7 @@ export declare const modifyDelay: {
      * @since 2.0.0
      * @category utilities
      */
-    <Output, Error2 = never, Env2 = never>(f: (output: Output, delay: Duration.Duration) => Effect<Duration.DurationInput, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Error2 = never, Env2 = never>(f: (output: Output, delay: Duration.Duration) => Effect<Duration.Input, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
     /**
      * Returns a new `Schedule` that modifies the delay of the next recurrence
      * of the schedule using the specified effectual function.
@@ -3632,8 +3478,17 @@ export declare const modifyDelay: {
      * @since 2.0.0
      * @category utilities
      */
-    <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>): Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, f: (output: Output, delay: Duration.Input) => Effect<Duration.Input, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
 };
+/**
+ * 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 declare const jittered: <Output, Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error, Env>;
 /**
  * Returns a new `Schedule` that outputs the inputs of the specified schedule.
  *
@@ -3669,7 +3524,9 @@ export declare const passthrough: <Output, Input, Error, Env>(self: Schedule<Out
  *
  * @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)
@@ -3684,7 +3541,7 @@ export declare const passthrough: <Output, Input, Error, Env>(self: Schedule<Out
  *       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}`
@@ -3697,7 +3554,7 @@ export declare const passthrough: <Output, Input, Error, Env>(self: Schedule<Out
  *
  * // 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
@@ -3941,7 +3798,7 @@ export declare const reduce: {
      * @since 2.0.0
      * @category utilities
      */
-    <State, Output, Error2 = never, Env2 = never>(initial: LazyArg<State>, combine: (state: State, output: Output) => Effect<State, Error2, Env2>): <Input, Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<State, Input, Error | Error2, Env | Env2>;
+    <State, Output, Error2 = never, Env2 = never>(initial: LazyArg<State>, 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>;
     /**
      * Returns a new `Schedule` that combines the outputs of the provided schedule
      * using the specified effectful `combine` function and starting from the
@@ -4053,7 +3910,7 @@ export declare const reduce: {
      * @since 2.0.0
      * @category utilities
      */
-    <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>): Schedule<State, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, State, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, initial: LazyArg<State>, combine: (state: State, output: Output) => State | Effect<State, Error2, Env2>): Schedule<State, Input, Error | Error2, Env | Env2>;
 };
 /**
  * Returns a schedule that recurs continuously, each repetition spaced the
@@ -4086,7 +3943,7 @@ export declare 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*() {
@@ -4104,7 +3961,7 @@ export declare const reduce: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const spaced: (duration: Duration.DurationInput) => Schedule<number>;
+export declare const spaced: (duration: Duration.Input) => Schedule<number>;
 /**
  * Returns a new `Schedule` that allows execution of an effectful function for
  * every input to the schedule, but does not alter the inputs and outputs of
@@ -4112,12 +3969,14 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  *
  * @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)}`)
  *   )
  * )
@@ -4129,7 +3988,7 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  *     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}`
  *     }),
@@ -4178,7 +4037,7 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  * // 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)}`)
@@ -4200,7 +4059,7 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  *       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(
@@ -4213,10 +4072,10 @@ export declare const spaced: (duration: Duration.DurationInput) => Schedule<numb
  * // 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
@@ -4235,12 +4094,14 @@ export declare 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)}`)
      *   )
      * )
@@ -4252,7 +4113,7 @@ export declare 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}`
      *     }),
@@ -4301,7 +4162,7 @@ export declare 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)}`)
@@ -4323,7 +4184,7 @@ export declare 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(
@@ -4336,10 +4197,10 @@ export declare 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
@@ -4358,12 +4219,14 @@ export declare 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)}`)
      *   )
      * )
@@ -4375,7 +4238,7 @@ export declare 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}`
      *     }),
@@ -4424,7 +4287,7 @@ export declare 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)}`)
@@ -4446,7 +4309,7 @@ export declare 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(
@@ -4459,10 +4322,10 @@ export declare 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
@@ -4482,7 +4345,9 @@ export declare 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(
@@ -4497,7 +4362,7 @@ export declare 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}`
  *     }),
@@ -4566,7 +4431,9 @@ export declare 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(
@@ -4581,7 +4448,7 @@ export declare 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}`
      *     }),
@@ -4650,7 +4517,9 @@ export declare 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(
@@ -4665,7 +4534,7 @@ export declare 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}`
      *     }),
@@ -4735,7 +4604,9 @@ export declare 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(
@@ -4768,7 +4639,7 @@ export declare 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}`
@@ -4814,7 +4685,9 @@ export declare 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(
@@ -4847,7 +4720,7 @@ export declare 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}`
@@ -4893,7 +4766,9 @@ export declare 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(
@@ -4926,7 +4801,7 @@ export declare 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}`
@@ -5064,8 +4939,8 @@ export declare const take: {
  */
 export declare const unfold: <State, Error = never, Env = never>(initial: State, next: (state: State) => Effect<State, Error, Env>) => Schedule<State, unknown, Error, Env>;
 declare const while_: {
-    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
-    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => Effect<boolean, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Input, Output, Error2 = never, Env2 = never>(predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): <Error, Env>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error | Error2, Env | Env2>;
+    <Output, Input, Error, Env, Error2 = never, Env2 = never>(self: Schedule<Output, Input, Error, Env>, predicate: (metadata: Metadata<Output, Input>) => boolean | Effect<boolean, Error2, Env2>): Schedule<Output, Input, Error | Error2, Env | Env2>;
 };
 export { 
 /**
@@ -5114,7 +4989,7 @@ while_ as while };
  * @since 2.0.0
  * @category constructors
  */
-export declare const windowed: (interval: Duration.DurationInput) => Schedule<number>;
+export declare const windowed: (interval: Duration.Input) => Schedule<number>;
 /**
  * Returns a new `Schedule` that will recur forever.
  *
@@ -5184,6 +5059,14 @@ identity_ as identity };
  * @category ensuring types
  */
 export declare const satisfiesInputType: <T>() => <Input extends T, Output = never, Error = never, Env = never>(self: Schedule<Output, Input, Error, Env>) => Schedule<Output, Input, Error, Env>;
+/**
+ * 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 declare const setInputType: <T>() => <Output, Error, Env>(self: Schedule<Output, T, Error, Env>) => Schedule<Output, T, Error, Env>;
 /**
  * Ensures that the provided schedule respects a specified output type.
  *