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

package/dist/Schedule.js

@@ -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
@@ -33,13 +33,16 @@ import * as Cause from "./Cause.js";
 import * as Cron from "./Cron.js";
 import * as Duration from "./Duration.js";
 import { constant, dual, identity } from "./Function.js";
+import { isEffect } from "./internal/core.js";
 import * as effect from "./internal/effect.js";
+import * as random from "./internal/random.js";
 import { pipeArguments } from "./Pipeable.js";
 import { hasProperty } from "./Predicate.js";
 import * as Pull from "./Pull.js";
 import * as Result from "./Result.js";
 import * as ServiceMap from "./ServiceMap.js";
 const TypeId = "~effect/Schedule";
+const randomNext = /*#__PURE__*/random.Random.useSync(random => random.nextDoubleUnsafe());
 /**
  * @since 4.0.0
  * @category Metadata
@@ -103,7 +106,7 @@ export const isSchedule = u => hasProperty(u, TypeId);
  *
  * // These can be combined and transformed as needed
  * const complexSchedule = simpleSchedule.pipe(
- *   Schedule.compose(Schedule.recurs(3))
+ *   Schedule.both(Schedule.recurs(3))
  * )
  * ```
  *
@@ -242,7 +245,9 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  *
  * @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(
@@ -338,7 +343,7 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  *     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}`
  *     }),
@@ -352,7 +357,7 @@ export const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedul
  * @since 2.0.0
  * @category utils
  */
-export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, (output, delay) => effect.map(f(output), d => Duration.sum(Duration.fromDurationInputUnsafe(d), Duration.fromDurationInputUnsafe(delay)))));
+export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, (output, delay) => effect.map(f(output), d => Duration.sum(Duration.fromInputUnsafe(d), Duration.fromInputUnsafe(delay)))));
 /**
  * Returns a new `Schedule` that will first execute the left (i.e. `self`)
  * schedule to completion. Once the left schedule is complete, the right (i.e.
@@ -360,7 +365,9 @@ export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, (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 }> {}
  *
  * // First retry 3 times quickly, then switch to slower retries
  * const quickRetries = Schedule.exponential("100 millis").pipe(
@@ -379,7 +386,7 @@ export const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, (out
  *       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}`
  *     }),
@@ -432,21 +439,26 @@ export const andThen = /*#__PURE__*/dual(2, (self, other) => map(andThenResult(s
  * @since 2.0.0
  * @category sequencing
  */
-export const andThenResult = /*#__PURE__*/dual(2, (self, other) => fromStep(effect.map(effect.zip(toStep(self), toStep(other)), ([leftStep, rightStep]) => {
-  let currentStep = leftStep;
-  let toResult = Result.fail;
-  return (now, input) => Pull.matchEffect(currentStep(now, input), {
-    onSuccess: ([output, duration]) => effect.succeed([toResult(output), duration]),
-    onFailure: effect.failCause,
-    onDone: output => effect.suspend(() => {
-      const pull = effect.succeed([toResult(output), Duration.zero]);
-      if (currentStep === leftStep) {
-        currentStep = rightStep;
-        toResult = Result.succeed;
+export const andThenResult = /*#__PURE__*/dual(2, (self, other) => fromStep(effect.sync(() => {
+  let currentSide = 0;
+  let currentStep;
+  const left = map(self, Result.succeed);
+  const right = map(other, Result.fail);
+  return function recur(now, input) {
+    if (currentStep) return currentStep(now, input);
+    return toStep(currentSide === 0 ? left : right).pipe(effect.flatMap(step => {
+      currentSide++;
+      if (currentSide === 1) {
+        currentStep = (now, input) => Pull.catchDone(step(now, input), _ => {
+          currentStep = undefined;
+          return recur(now, input);
+        });
+        return currentStep(now, input);
       }
-      return pull;
-    })
-  });
+      currentStep = step;
+      return currentStep(now, input);
+    }));
+  };
 })));
 /**
  * Combines two `Schedule`s by recurring if both of the two schedules want
@@ -455,7 +467,9 @@ export const andThenResult = /*#__PURE__*/dual(2, (self, other) => fromStep(effe
  *
  * @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
@@ -497,7 +511,7 @@ export const andThenResult = /*#__PURE__*/dual(2, (self, other) => fromStep(effe
  *       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}`
@@ -625,69 +639,6 @@ export const bothWith = /*#__PURE__*/dual(3, (self, other, combine) => fromStep(
   onDone: leftDone => stepRight(now, input).pipe(effect.flatMap(rightResult => Cause.done(combine(leftDone, rightResult[0]))), Pull.catchDone(rightDone => Cause.done(combine(leftDone, rightDone)))),
   onFailure: effect.failCause
 }))));
-/**
- * Returns a new `Schedule` that 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 = /*#__PURE__*/dual(2, (self, other) => both(self, other));
 /**
  * Returns a new `Schedule` that always recurs, collecting all inputs of the
  * schedule into an array.
@@ -850,17 +801,19 @@ export const collectOutputs = self => collectWhile(self, () => effect.succeed(tr
  * @since 2.0.0
  * @category utilities
  */
-export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(while_(self, predicate), () => [], (outputs, output) => effect.succeed((() => {
+export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(while_(self, predicate), () => [], (outputs, output) => {
   outputs.push(output);
   return outputs;
-})())));
+}));
 /**
  * Returns a new `Schedule` that recurs on the specified `Cron` schedule and
  * outputs the duration between recurrences.
  *
  * @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("* * * * *")
@@ -961,7 +914,7 @@ export const collectWhile = /*#__PURE__*/dual(2, (self, predicate) => reduce(whi
  *       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"
  *     }),
@@ -1079,7 +1032,7 @@ export const delays = self => fromStep(effect.map(toStep(self), step => (now, in
  * @category constructors
  */
 export const duration = durationInput => {
-  const duration = Duration.fromDurationInputUnsafe(durationInput);
+  const duration = Duration.fromInputUnsafe(durationInput);
   return fromStepWithMetadata(effect.succeed(meta => meta.attempt === 1 ? effect.succeed([duration, duration]) : Cause.done(Duration.zero)));
 };
 /**
@@ -1088,7 +1041,9 @@ export const duration = durationInput => {
  *
  * @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")
@@ -1150,7 +1105,7 @@ export const duration = durationInput => {
  *       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}`
@@ -1169,7 +1124,7 @@ export const duration = durationInput => {
  */
 export const during = duration => while_(elapsed, ({
   output
-}) => effect.succeed(Duration.isLessThanOrEqualTo(output, Duration.fromDurationInputUnsafe(duration))));
+}) => effect.succeed(Duration.isLessThanOrEqualTo(output, Duration.fromInputUnsafe(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
@@ -1177,7 +1132,9 @@ export const during = duration => while_(elapsed, ({
  *
  * @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))
@@ -1221,7 +1178,7 @@ export const during = duration => while_(elapsed, ({
  *       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}`
@@ -1391,7 +1348,9 @@ export const elapsed = /*#__PURE__*/fromStepWithMetadata(/*#__PURE__*/effect.suc
  *
  * @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")
@@ -1403,7 +1362,7 @@ export const elapsed = /*#__PURE__*/fromStepWithMetadata(/*#__PURE__*/effect.suc
  *
  * // 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*() {
@@ -1414,7 +1373,7 @@ export const elapsed = /*#__PURE__*/fromStepWithMetadata(/*#__PURE__*/effect.suc
  *       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}`
  *     }),
@@ -1431,7 +1390,7 @@ export const elapsed = /*#__PURE__*/fromStepWithMetadata(/*#__PURE__*/effect.suc
  * @category constructors
  */
 export const exponential = (base, factor = 2) => {
-  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]);
@@ -1444,7 +1403,9 @@ export const exponential = (base, factor = 2) => {
  *
  * @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")
@@ -1460,13 +1421,13 @@ export const exponential = (base, factor = 2) => {
  *       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}`))
  *     )
  *   )
@@ -1502,7 +1463,7 @@ export const exponential = (base, factor = 2) => {
  * @category constructors
  */
 export const fibonacci = one => {
-  const oneMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(one));
+  const oneMillis = Duration.toMillis(Duration.fromInputUnsafe(one));
   return fromStep(effect.sync(() => {
     let a = 0;
     let b = oneMillis;
@@ -1578,8 +1539,26 @@ export const fibonacci = one => {
  * @category constructors
  */
 export const fixed = interval => {
-  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)])));
+  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];
+      }
+      if (meta.attempt === 1) {
+        start = meta.now;
+        lastRun = meta.now + window;
+        return [0, Duration.millis(window)];
+      }
+      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)];
+    });
+  }));
 };
 /**
  * Returns a new `Schedule` that maps the output of this schedule using the
@@ -1645,9 +1624,17 @@ export const fixed = interval => {
  */
 export const map = /*#__PURE__*/dual(2, (self, f) => {
   const handle = Pull.matchEffect({
-    onSuccess: ([output, duration]) => effect.map(f(output), output => [output, duration]),
+    onSuccess: ([output, duration]) => {
+      const result = f(output);
+      if (!isEffect(result)) return effect.succeed([result, duration]);
+      return effect.map(result, output => [output, duration]);
+    },
     onFailure: effect.failCause,
-    onDone: output => effect.flatMap(f(output), Cause.done)
+    onDone: output => {
+      const result = f(output);
+      if (!isEffect(result)) return Cause.done(result);
+      return effect.flatMap(result, Cause.done);
+    }
   });
   return fromStep(effect.map(toStep(self), step => (now, input) => handle(step(now, input))));
 });
@@ -1683,7 +1670,19 @@ export const map = /*#__PURE__*/dual(2, (self, f) => {
  * @since 2.0.0
  * @category utilities
  */
-export const modifyDelay = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => (now, input) => effect.flatMap(step(now, input), ([output, delay]) => effect.map(f(output, delay), delay => [output, Duration.fromDurationInputUnsafe(delay)])))));
+export const modifyDelay = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => (now, input) => effect.flatMap(step(now, input), ([output, delay]) => effect.map(f(output, delay), delay => [output, Duration.fromInputUnsafe(delay)])))));
+/**
+ * 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 = self => 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.
  *
@@ -1723,7 +1722,9 @@ export const passthrough = self => fromStep(effect.map(toStep(self), step => (no
  *
  * @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)
@@ -1738,7 +1739,7 @@ export const passthrough = self => fromStep(effect.map(toStep(self), step => (no
  *       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}`
@@ -1751,7 +1752,7 @@ export const passthrough = self => fromStep(effect.map(toStep(self), step => (no
  *
  * // Combining recurs with other schedules for sophisticated retry logic
  * const complexRetry = Schedule.exponential("100 millis").pipe(
- *   Schedule.compose(Schedule.recurs(3)) // At most 3 attempts
+ *   Schedule.both(Schedule.recurs(3)) // At most 3 attempts
  * )
  *
  * // Repeat an effect exactly 10 times
@@ -1888,12 +1889,22 @@ export const recurs = times => while_(forever, ({
 export const reduce = /*#__PURE__*/dual(3, (self, initial, combine) => fromStep(effect.map(toStep(self), step => {
   let state = initial();
   return (now, input) => Pull.matchEffect(step(now, input), {
-    onSuccess: ([output, delay]) => effect.map(combine(state, output), nextState => {
-      state = nextState;
-      return [nextState, delay];
-    }),
+    onSuccess([output, delay]) {
+      const next = combine(state, output);
+      if (!isEffect(next)) {
+        state = next;
+        return effect.succeed([next, delay]);
+      }
+      return effect.map(next, nextState => {
+        state = nextState;
+        return [nextState, delay];
+      });
+    },
     onFailure: effect.failCause,
-    onDone: output => 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);
+    }
   });
 })));
 /**
@@ -1927,7 +1938,7 @@ export const reduce = /*#__PURE__*/dual(3, (self, initial, combine) => fromStep(
  *
  * // 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*() {
@@ -1946,7 +1957,7 @@ export const reduce = /*#__PURE__*/dual(3, (self, initial, combine) => fromStep(
  * @category constructors
  */
 export const spaced = duration => {
-  const decoded = Duration.fromDurationInputUnsafe(duration);
+  const decoded = Duration.fromInputUnsafe(duration);
   return fromStepWithMetadata(effect.succeed(meta => effect.succeed([meta.attempt - 1, decoded])));
 };
 /**
@@ -1956,12 +1967,14 @@ export const spaced = duration => {
  *
  * @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)}`)
  *   )
  * )
@@ -1973,7 +1986,7 @@ export const spaced = duration => {
  *     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}`
  *     }),
@@ -2022,7 +2035,7 @@ export const spaced = duration => {
  * // 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)}`)
@@ -2044,7 +2057,7 @@ export const spaced = duration => {
  *       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(
@@ -2057,10 +2070,10 @@ export const spaced = duration => {
  * // 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
@@ -2079,7 +2092,9 @@ export const tapInput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(to
  *
  * @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(
@@ -2094,7 +2109,7 @@ export const tapInput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(to
  *     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}`
  *     }),
@@ -2163,7 +2178,9 @@ export const tapOutput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(t
  *
  * @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(
@@ -2196,7 +2213,7 @@ export const tapOutput = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(t
  *       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}`
@@ -2345,11 +2362,12 @@ const while_ = /*#__PURE__*/dual(2, (self, predicate) => fromStep(effect.map(toS
   const meta = metadataFn();
   return (now, input) => effect.flatMap(step(now, input), result => {
     const [output, duration] = result;
-    return effect.flatMap(predicate({
+    const eff = predicate({
       ...meta(now, input),
       output,
       duration
-    }), check => check ? effect.succeed(result) : Cause.done(output));
+    });
+    return effect.flatMap(isEffect(eff) ? eff : effect.succeed(eff), check => check ? effect.succeed(result) : Cause.done(output));
   });
 })));
 export {
@@ -2400,7 +2418,7 @@ while_ as while };
  * @category constructors
  */
 export const windowed = interval => {
-  const window = Duration.toMillis(Duration.fromDurationInputUnsafe(interval));
+  const window = Duration.toMillis(Duration.fromInputUnsafe(interval));
   return fromStepWithMetadata(effect.succeed(meta => effect.sync(() => [meta.attempt - 1, window === 0 ? Duration.zero : Duration.millis(window - meta.elapsed % window)])));
 };
 /**
@@ -2473,6 +2491,14 @@ identity_ as identity };
  * @category ensuring types
  */
 export const satisfiesInputType = () => self => 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 = () => self => self;
 /**
  * Ensures that the provided schedule respects a specified output type.
  *