effect 4.0.0-beta.6 → 4.0.0-beta.8

package/src/Pool.ts

@@ -172,7 +172,7 @@ export const makeWithTTL = <A, E, R>(options: {
   readonly max: number
   readonly concurrency?: number | undefined
   readonly targetUtilization?: number | undefined
-  readonly timeToLive: Duration.DurationInput
+  readonly timeToLive: Duration.Input
   readonly timeToLiveStrategy?: "creation" | "usage" | undefined
 }): Effect.Effect<Pool<A, E>, never, R | Scope.Scope> =>
   Effect.flatMap(
@@ -473,10 +473,10 @@ const strategyNoop = <A, E>(): Strategy<A, E> => ({
   reclaim: (_) => Effect.undefined
 })
 
-const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const clock = yield* Clock
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
-  const ttlMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(ttl))
+  const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
   const creationTimes = new WeakMap<PoolItem<A, E>, number>()
   return identity<Strategy<A, E>>({
     run: (pool) => {
@@ -506,7 +506,7 @@ const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Dura
   })
 })
 
-const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
   return identity<Strategy<A, E>>({
     run: (pool) => {

package/src/Random.ts

@@ -23,8 +23,9 @@
  */
 import * as Effect from "./Effect.ts"
 import { dual } from "./Function.ts"
+import * as random from "./internal/random.ts"
 import * as Predicate from "./Predicate.ts"
-import * as ServiceMap from "./ServiceMap.ts"
+import type * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * Represents a service for generating random numbers.
@@ -49,23 +50,13 @@ import * as ServiceMap from "./ServiceMap.ts"
  * @since 4.0.0
  * @category Random Number Generators
  */
-export const Random = ServiceMap.Reference<{
+export const Random: ServiceMap.Reference<{
   nextIntUnsafe(): number
   nextDoubleUnsafe(): number
-}>("effect/Random", {
-  defaultValue: () => ({
-    nextIntUnsafe() {
-      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
-        Number.MIN_SAFE_INTEGER
-    },
-    nextDoubleUnsafe() {
-      return Math.random()
-    }
-  })
-})
+}> = random.Random
 
 const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effect<A> =>
-  Effect.withFiber((fiber) => Effect.succeed(f(ServiceMap.get(fiber.services, Random))))
+  Effect.withFiber((fiber) => Effect.succeed(f(fiber.getRef(Random))))
 
 /**
  * Generates a random number between 0 (inclusive) and 1 (inclusive).

package/src/RcMap.ts

@@ -292,7 +292,7 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity?: undefined
     }
   ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
@@ -335,13 +335,13 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity: number
     }
   ): Effect.Effect<RcMap<K, A, E | Cause.ExceededCapacityError>, never, Scope.Scope | R>
 } = <K, A, E, R>(options: {
   readonly lookup: (key: K) => Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+  readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
   readonly capacity?: number | undefined
 }) =>
   Effect.withFiber<RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
@@ -352,8 +352,8 @@ export const make: {
       services,
       scope,
       idleTimeToLive: typeof options.idleTimeToLive === "function"
-        ? flow(options.idleTimeToLive, Duration.fromDurationInputUnsafe)
-        : constant(Duration.fromDurationInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
+        ? flow(options.idleTimeToLive, Duration.fromInputUnsafe)
+        : constant(Duration.fromInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
       capacity: Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
     })
     return Effect.as(

package/src/RcRef.ts

@@ -120,7 +120,7 @@ export const make: <A, E, R>(
      * When the reference count reaches zero, the resource will be released
      * after this duration.
      */
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ) => Effect.Effect<RcRef<A, E>, never, R | Scope> = internal.make
 

package/src/Reducer.ts

@@ -1,17 +1,107 @@
 /**
+ * A module for reducing collections of values into a single result.
+ *
+ * A `Reducer<A>` extends {@link Combiner.Combiner} by adding an
+ * `initialValue` (identity element) and a `combineAll` method that folds an
+ * entire collection. Think `Array.prototype.reduce`, but packaged as a
+ * reusable, composable value.
+ *
+ * ## Mental model
+ *
+ * - **Reducer** – a {@link Combiner.Combiner} plus an `initialValue` and a
+ *   `combineAll` method.
+ * - **initialValue** – the neutral/identity element. Combining any value with
+ *   `initialValue` should return the original value unchanged (e.g. `0` for
+ *   addition, `""` for string concatenation).
+ * - **combineAll** – folds an `Iterable<A>` starting from `initialValue`.
+ *   When omitted from {@link make}, a default left-to-right fold is used.
+ * - **Purity** – all reducers produced by this module are pure; they never
+ *   mutate their arguments.
+ * - **Composability** – reducers can be lifted into `Option`, `Struct`,
+ *   `Tuple`, `Record`, and other container types via helpers in those modules.
+ * - **Subtype of Combiner** – every `Reducer` is also a valid
+ *   `Combiner`, so you can pass a `Reducer` anywhere a `Combiner` is
+ *   expected.
+ *
+ * ## Common tasks
+ *
+ * - Create a reducer from a combine function and initial value → {@link make}
+ * - Swap argument order → {@link flip}
+ * - Combine two values without an initial value → use {@link Combiner.Combiner}
+ *   instead
+ *
+ * ## Gotchas
+ *
+ * - `combineAll` on an empty iterable returns `initialValue`, not an error.
+ * - The default `combineAll` folds left-to-right. If your `combine` is not
+ *   associative, order matters. Pass a custom `combineAll` to {@link make} if
+ *   you need different traversal or short-circuiting.
+ * - A `Reducer` is also a valid `Combiner` — but a `Combiner` is *not* a
+ *   `Reducer` (it lacks `initialValue`).
+ *
+ * ## Quickstart
+ *
+ * **Example** (summing a list of numbers)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Sum = Reducer.make<number>((a, b) => a + b, 0)
+ *
+ * console.log(Sum.combine(3, 4))
+ * // Output: 7
+ *
+ * console.log(Sum.combineAll([1, 2, 3, 4]))
+ * // Output: 10
+ *
+ * console.log(Sum.combineAll([]))
+ * // Output: 0
+ * ```
+ *
+ * ## See also
+ *
+ * - {@link make} – the primary constructor
+ * - {@link Reducer} – the core interface
+ * - {@link Combiner.Combiner} – the parent interface (no `initialValue`)
+ *
  * @since 4.0.0
  */
 
 import type * as Combiner from "./Combiner.ts"
 
 /**
- * A `Reducer` is a `Combiner` with an `initialValue` and a way to
- * combine a whole collection. Think `Array.prototype.reduce`, but reusable.
+ * Represents a strategy for reducing a collection of values of type `A` into
+ * a single result.
+ *
+ * Extends {@link Combiner.Combiner} with:
+ * - `initialValue` – the identity/neutral element for `combine`.
+ * - `combineAll` – folds an entire `Iterable<A>` from `initialValue`.
+ *
+ * When to use:
+ * - You need to fold/reduce a collection into a single value.
+ * - You want a reusable reducing strategy that can be passed to library
+ *   functions like `Struct.makeReducer`, `Option.makeReducer`, or
+ *   `Record.makeReducerUnion`.
+ * - You need both the combining logic *and* a known starting value.
+ *
+ * Many modules ship pre-built reducers:
+ * - `Number.ReducerSum`, `Number.ReducerMultiply`
+ * - `String.ReducerConcat`
+ * - `Boolean.ReducerAnd`, `Boolean.ReducerOr`
  *
- * Common initial values:
- * - numbers with addition: `0`
- * - strings with concatenation: `""`
- * - arrays with concatenation: `[]`
+ * **Example** (string concatenation reducer)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Concat = Reducer.make<string>((a, b) => a + b, "")
+ *
+ * console.log(Concat.combineAll(["hello", " ", "world"]))
+ * // Output: "hello world"
+ * ```
+ *
+ * @see {@link make} – create a `Reducer` from a function and initial value
+ * @see {@link Combiner.Combiner} – parent interface without `initialValue`
  *
  * @category model
  * @since 4.0.0
@@ -27,7 +117,44 @@ export interface Reducer<A> extends Combiner.Combiner<A> {
 /**
  * Creates a `Reducer` from a `combine` function and an `initialValue`.
  *
- * If `combineAll` is omitted, a default implementation reduces left-to-right.
+ * When to use:
+ * - You have a custom reducing operation not covered by a pre-built reducer.
+ * - You want to provide an optimized `combineAll` (e.g. short-circuiting on
+ *   a known absorbing element like `0` for multiplication).
+ *
+ * Behavior:
+ * - If `combineAll` is omitted, a default left-to-right fold starting from
+ *   `initialValue` is used.
+ * - If `combineAll` is provided, it completely replaces the default fold.
+ * - Pure – the returned reducer does not mutate its arguments.
+ *
+ * **Example** (multiplication with short-circuit)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Product = Reducer.make<number>(
+ *   (a, b) => a * b,
+ *   1,
+ *   (collection) => {
+ *     let acc = 1
+ *     for (const n of collection) {
+ *       if (n === 0) return 0
+ *       acc *= n
+ *     }
+ *     return acc
+ *   }
+ * )
+ *
+ * console.log(Product.combineAll([2, 3, 4]))
+ * // Output: 24
+ *
+ * console.log(Product.combineAll([2, 0, 4]))
+ * // Output: 0
+ * ```
+ *
+ * @see {@link Reducer} – the interface this creates
+ * @see {@link flip} – reverse the argument order
  *
  * @since 4.0.0
  */
@@ -51,6 +178,38 @@ export function make<A>(
 }
 
 /**
+ * Reverses the argument order of a reducer's `combine` method.
+ *
+ * When to use:
+ * - You need the "right" value to act as the accumulator side.
+ * - You want to reverse the natural direction of a non-commutative reducer
+ *   (e.g. string concatenation becomes prepend).
+ *
+ * Behavior:
+ * - Returns a new `Reducer` where `combine(self, that)` calls the original
+ *   reducer as `combine(that, self)`.
+ * - The `initialValue` is preserved from the original reducer.
+ * - The `combineAll` is re-derived from the flipped `combine` (using the
+ *   default left-to-right fold), not carried over from the original.
+ * - Does not mutate the input reducer.
+ *
+ * **Example** (reversing string concatenation)
+ *
+ * ```ts
+ * import { Reducer, String } from "effect"
+ *
+ * const Prepend = Reducer.flip(String.ReducerConcat)
+ *
+ * console.log(Prepend.combine("a", "b"))
+ * // Output: "ba"
+ *
+ * console.log(Prepend.combineAll(["a", "b", "c"]))
+ * // Output: "cba"
+ * ```
+ *
+ * @see {@link make}
+ * @see {@link Combiner.flip} – the same operation on a plain `Combiner`
+ *
  * @since 4.0.0
  */
 export function flip<A>(reducer: Reducer<A>): Reducer<A> {

package/src/RequestResolver.ts

@@ -652,7 +652,7 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  (duration: Duration.DurationInput): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
+  (duration: Duration.Input): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
   /**
    * Sets the batch delay window for this request resolver to the specified duration.
    *
@@ -683,10 +683,10 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A>
 } = dual(
   2,
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A> =>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A> =>
     makeWith({
       ...self,
       delay: Effect.sleep(duration)
@@ -1448,7 +1448,7 @@ export const asCache: {
   >(
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1475,7 +1475,7 @@ export const asCache: {
     self: RequestResolver<A>,
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): Effect.Effect<
@@ -1493,7 +1493,7 @@ export const asCache: {
   ServiceMode extends "lookup" | "construction" = never
 >(self: RequestResolver<A>, options: {
   readonly capacity: number
-  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   Cache.Cache<
@@ -1629,7 +1629,7 @@ export const persisted: {
   <A extends Request.Request<any, Persistence.PersistenceError | Schema.SchemaError, any> & Persistable.Any>(
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1647,7 +1647,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): Effect.Effect<
@@ -1663,7 +1663,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ) {

package/src/Schedule.ts

@@ -38,6 +38,7 @@ import type { LazyArg } from "./Function.ts"
 import { constant, dual, identity } from "./Function.ts"
 import { isEffect } from "./internal/core.ts"
 import * as effect from "./internal/effect.ts"
+import * as random from "./internal/random.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Pull from "./Pull.ts"
@@ -47,6 +48,8 @@ import type { Contravariant, Covariant, Mutable } from "./Types.ts"
 
 const TypeId = "~effect/Schedule"
 
+const randomNext: Effect<number> = random.Random.useSync((random) => random.nextDoubleUnsafe())
+
 /**
  * A Schedule defines a strategy for repeating or retrying effects based on some policy.
  *
@@ -747,7 +750,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>
   /**
@@ -868,17 +871,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)))
   ))
 
 /**
@@ -3020,8 +3022,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])
@@ -3114,10 +3116,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)))
   )
 
 /**
@@ -3857,10 +3859,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])
@@ -3931,8 +3933,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,8 +4010,8 @@ export const fibonacci = (one: Duration.DurationInput): Schedule<Duration.Durati
  * @since 2.0.0
  * @category constructors
  */
-export const fixed = (interval: Duration.DurationInput): Schedule<number> => {
-  const window = Duration.toMillis(Duration.fromDurationInputUnsafe(interval))
+export const fixed = (interval: Duration.Input): Schedule<number> => {
+  const window = Duration.toMillis(Duration.fromInputUnsafe(interval))
   return fromStepWithMetadata(effect.succeed((meta) =>
     effect.succeed([
       meta.attempt - 1,
@@ -4303,7 +4305,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 +4345,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.
  *
@@ -4867,8 +4886,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])))
 }
 
@@ -5958,8 +5977,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,

package/src/Schema.ts

@@ -325,7 +325,7 @@ export declare namespace Schema {
   /**
    * @since 4.0.0
    */
-  export type Type<S extends Top> = S["Type"]
+  export type Type<S> = S extends Top ? S["Type"] : never
 }
 
 /**
@@ -353,15 +353,15 @@ export declare namespace Codec {
   /**
    * @since 4.0.0
    */
-  export type Encoded<S extends Top> = S["Encoded"]
+  export type Encoded<S> = S extends Top ? S["Encoded"] : never
   /**
    * @since 4.0.0
    */
-  export type DecodingServices<S extends Top> = S["DecodingServices"]
+  export type DecodingServices<S> = S extends Top ? S["DecodingServices"] : never
   /**
    * @since 4.0.0
    */
-  export type EncodingServices<S extends Top> = S["EncodingServices"]
+  export type EncodingServices<S> = S extends Top ? S["EncodingServices"] : never
   /**
    * @since 4.0.0
    */

package/src/ScopedCache.ts

@@ -69,7 +69,7 @@ export const makeWith = <
 >(options: {
   readonly lookup: (key: Key) => Effect.Effect<A, E, R | Scope.Scope>
   readonly capacity: number
-  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   ScopedCache<Key, A, E, "lookup" extends ServiceMode ? Exclude<R, Scope.Scope> : never>,
@@ -88,7 +88,7 @@ export const makeWith = <
     self.state = { _tag: "Open", map }
     self.capacity = options.capacity
     self.timeToLive = options.timeToLive
-      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromDurationInputUnsafe(options.timeToLive!(exit, key))
+      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromInputUnsafe(options.timeToLive!(exit, key))
       : defaultTimeToLive
     return effect.as(
       Scope.addFinalizer(
@@ -116,7 +116,7 @@ export const make = <
   options: {
     readonly lookup: (key: Key) => Effect.Effect<A, E, R | Scope.Scope>
     readonly capacity: number
-    readonly timeToLive?: Duration.DurationInput | undefined
+    readonly timeToLive?: Duration.Input | undefined
     readonly requireServicesAt?: ServiceMode | undefined
   }
 ): Effect.Effect<