From 80ea5477d362510144fa509b58464c9e70de4038 Mon Sep 17 00:00:00 2001
From: Giulio Canti <giulio.canti@gmail.com>
Date: Thu, 15 Feb 2024 10:35:42 +0100
Subject: [PATCH] =?UTF-8?q?swap=20`Schedule`=20type=20parameters=20from=20?=
 =?UTF-8?q?`Schedule<out=20Env,=20in=20In,=20out=20Ou=E2=80=A6=20(#2155)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .changeset/chilled-paws-divide.md             |   6 +
 packages/effect/mod.sh                        |   2 +-
 packages/effect/mod.ts                        |  29 +-
 packages/effect/src/Effect.ts                 |  50 +-
 packages/effect/src/Layer.ts                  |  10 +-
 packages/effect/src/MetricPolling.ts          |  18 +-
 packages/effect/src/Reloadable.ts             |   8 +-
 packages/effect/src/Resource.ts               |   6 +-
 packages/effect/src/Schedule.ts               | 692 +++++++------
 packages/effect/src/Stream.ts                 |  84 +-
 .../effect/src/internal/effect/circular.ts    |   8 +-
 packages/effect/src/internal/layer.ts         |  20 +-
 .../effect/src/internal/metric/polling.ts     |  16 +-
 packages/effect/src/internal/reloadable.ts    |   8 +-
 packages/effect/src/internal/resource.ts      |   4 +-
 packages/effect/src/internal/schedule.ts      | 920 ++++++++----------
 packages/effect/src/internal/stream.ts        | 143 ++-
 packages/effect/test/Schedule.test.ts         |  14 +-
 packages/effect/test/TReentrantLock.test.ts   |   6 +-
 packages/platform/src/Http/Client.ts          |   4 +-
 packages/platform/src/internal/http/client.ts |   6 +-
 21 files changed, 990 insertions(+), 1064 deletions(-)
 create mode 100644 .changeset/chilled-paws-divide.md

diff --git a/.changeset/chilled-paws-divide.md b/.changeset/chilled-paws-divide.md
new file mode 100644
index 0000000000..ee4993a315
--- /dev/null
+++ b/.changeset/chilled-paws-divide.md
@@ -0,0 +1,6 @@
+---
+"effect": minor
+---
+
+- swap `Schedule` type parameters from `Schedule<out Env, in In, out Out>` to `Schedule<out Out, in In = unknown, out R = never>`, closes #2154
+- swap `ScheduleDriver` type parameters from `ScheduleDriver<out Env, in In, out Out>` to `ScheduleDriver<out Out, in In = unknown, out R = never>`
diff --git a/packages/effect/mod.sh b/packages/effect/mod.sh
index 4b67c47bc2..933d4c5923 100755
--- a/packages/effect/mod.sh
+++ b/packages/effect/mod.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-dirs=(../typeclass/src ../typeclass/test ../typeclass/dtslint)
+dirs=(../effect/src ../effect/test)
 for dir in ${dirs[@]};
 do
 echo Refactoring $dir
diff --git a/packages/effect/mod.ts b/packages/effect/mod.ts
index bebe7557f6..20e6a73909 100644
--- a/packages/effect/mod.ts
+++ b/packages/effect/mod.ts
@@ -2,7 +2,8 @@ import type k from "ast-types/gen/kinds.js"
 import type cs from "jscodeshift"
 
 const enabled = {
-  swapEitherParams: true,
+  swapScheduleParams: true,
+  swapEitherParams: false,
   swapLayerParams: false,
   swapSTMParams: false,
   swapSTMGenParams: false,
@@ -148,12 +149,35 @@ const swapSTMParams = swapParamsREA("STM")
 const swapSTMGenParams = swapParamsREA("STMGen")
 const swapLayerParams = swapParamsREA("Layer")
 
+// from: Schedule<out Env, in In, out Out>
+// to: Schedule<out Out, in In = unknown, out Env = never>
+const swapScheduleParams = (ast: cs.ASTPath<cs.TSTypeReference>) => {
+  const is = filter(ast, "Schedule")
+  if (
+    is(ast.value.typeName) &&
+    ast.value.typeParameters &&
+    ast.value.typeParameters.params.length === 3
+  ) {
+    const params = ast.value.typeParameters.params
+    const newParams = [params[2], params[1], params[0]]
+    popNever(newParams)
+    popUnknown(newParams)
+    ast.value.typeParameters.params = newParams
+  }
+}
+
 const popNever = (params: Array<k.TSTypeKind>) => {
   if (params.length > 0 && params[params.length - 1].type === "TSNeverKeyword") {
     params.pop()
   }
 }
 
+const popUnknown = (params: Array<k.TSTypeKind>) => {
+  if (params.length > 0 && params[params.length - 1].type === "TSUnknownKeyword") {
+    params.pop()
+  }
+}
+
 export default function transformer(file: cs.FileInfo, api: cs.API) {
   const j = api.jscodeshift
   const root = j(file.source)
@@ -173,6 +197,9 @@ export default function transformer(file: cs.FileInfo, api: cs.API) {
   }
 
   forEveryTypeReference(root, (ast) => {
+    if (enabled.swapScheduleParams) {
+      swapScheduleParams(ast)
+    }
     if (enabled.swapEitherParams) {
       swapEitherParams(ast)
     }
diff --git a/packages/effect/src/Effect.ts b/packages/effect/src/Effect.ts
index 0e957a86f1..aa91761d72 100644
--- a/packages/effect/src/Effect.ts
+++ b/packages/effect/src/Effect.ts
@@ -1737,13 +1737,13 @@ export declare namespace Retry {
    */
   export type Return<R, E, A, O extends Options<E>> = Effect<
     A,
-    | (O extends { schedule: Schedule.Schedule<infer _R, infer _I, infer _O> } ? E
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer _R> } ? E
       : O extends { until: Refinement<E, infer E2> } ? E2
       : E)
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never),
     | R
-    | (O extends { schedule: Schedule.Schedule<infer R, infer _I, infer _O> } ? R : never)
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer R> } ? R : never)
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
   > extends infer Z ? Z : never
@@ -1772,16 +1772,16 @@ export const retry: {
   ): <A, R>(
     self: Effect<A, E, R>
   ) => Retry.Return<R, E, A, O>
-  <R1, E, B>(
-    policy: Schedule.Schedule<R1, NoInfer<E>, B>
+  <B, E, R1>(
+    policy: Schedule.Schedule<B, NoInfer<E>, R1>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A, E, R1 | R>
   <A, E, R, O extends Retry.Options<E>>(
     self: Effect<A, E, R>,
     options: O
   ): Retry.Return<R, E, A, O>
-  <R, E, A, R1, B>(
+  <A, E, R, B, R1>(
     self: Effect<A, E, R>,
-    policy: Schedule.Schedule<R1, E, B>
+    policy: Schedule.Schedule<B, E, R1>
   ): Effect<A, E, R1 | R>
 } = _schedule.retry_combined
 
@@ -1794,13 +1794,13 @@ export const retry: {
  * @category error handling
  */
 export const retryOrElse: {
-  <R1, E, A1, A2, E2, R2>(
-    policy: Schedule.Schedule<R1, NoInfer<E>, A1>,
+  <A1, E, R1, A2, E2, R2>(
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
     orElse: (e: NoInfer<E>, out: A1) => Effect<A2, E2, R2>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E | E2, R1 | R2 | R>
   <A, E, R, A1, R1, A2, E2, R2>(
     self: Effect<A, E, R>,
-    policy: Schedule.Schedule<R1, NoInfer<E>, A1>,
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
     orElse: (e: NoInfer<E>, out: A1) => Effect<A2, E2, R2>
   ): Effect<A | A2, E | E2, R | R1 | R2>
 } = _schedule.retryOrElse_Effect
@@ -3936,14 +3936,14 @@ export declare namespace Repeat {
    * @category repetition / recursion
    */
   export type Return<R, E, A, O extends Options<A>> = Effect<
-    (O extends { schedule: Schedule.Schedule<infer _R, infer _I, infer Out> } ? Out
+    (O extends { schedule: Schedule.Schedule<infer Out, infer _I, infer _R> } ? Out
       : O extends { until: Refinement<A, infer B> } ? B
       : A),
     | E
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never),
     | R
-    | (O extends { schedule: Schedule.Schedule<infer R, infer _I, infer _O> } ? R : never)
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer R> } ? R : never)
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
   > extends infer Z ? Z : never
@@ -3971,19 +3971,19 @@ export declare namespace Repeat {
  * @category repetition / recursion
  */
 export const repeat: {
-  <A, O extends Repeat.Options<A>>(
+  <O extends Repeat.Options<A>, A>(
     options: O
   ): <E, R>(
     self: Effect<A, E, R>
   ) => Repeat.Return<R, E, A, O>
-  <R1, A, B>(
-    schedule: Schedule.Schedule<R1, A, B>
+  <B, A, R1>(
+    schedule: Schedule.Schedule<B, A, R1>
   ): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R1 | R>
   <A, E, R, O extends Repeat.Options<A>>(
     self: Effect<A, E, R>,
     options: O
   ): Repeat.Return<R, E, A, O>
-  <A, E, R, R1, B>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R1, A, B>): Effect<B, E, R | R1>
+  <A, E, R, B, R1>(self: Effect<A, E, R>, schedule: Schedule.Schedule<B, A, R1>): Effect<B, E, R | R1>
 } = _schedule.repeat_combined
 
 /**
@@ -4014,12 +4014,12 @@ export const repeatN: {
  */
 export const repeatOrElse: {
   <R2, A, B, E, E2, R3>(
-    schedule: Schedule.Schedule<R2, A, B>,
+    schedule: Schedule.Schedule<B, A, R2>,
     orElse: (error: E, option: Option.Option<B>) => Effect<B, E2, R3>
   ): <R>(self: Effect<A, E, R>) => Effect<B, E2, R2 | R3 | R>
   <A, E, R, R2, B, E2, R3>(
     self: Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, A, B>,
+    schedule: Schedule.Schedule<B, A, R2>,
     orElse: (error: E, option: Option.Option<B>) => Effect<B, E2, R3>
   ): Effect<B, E2, R | R2 | R3>
 } = _schedule.repeatOrElse_Effect
@@ -4034,8 +4034,8 @@ export const repeatOrElse: {
  * @category repetition / recursion
  */
 export const schedule: {
-  <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <A, E, R>(self: Effect<A, E, R>) => Effect<Out, E, R2 | R>
-  <A, E, R, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<Out, E, R | R2>
+  <R2, Out>(schedule: Schedule.Schedule<Out, unknown, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<Out, E, R2 | R>
+  <A, E, R, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<Out, unknown, R2>): Effect<Out, E, R | R2>
 } = _schedule.schedule_Effect
 
 /**
@@ -4046,12 +4046,12 @@ export const schedule: {
  * @category repetition / recursion
  */
 export const scheduleForked: {
-  <R2, Out>(
-    schedule: Schedule.Schedule<R2, unknown, Out>
+  <Out, R2>(
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<Out, E>, never, Scope.Scope | R2 | R>
-  <R, E, A, R2, Out>(
+  <A, E, R, Out, R2>(
     self: Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, Out>
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ): Effect<Fiber.RuntimeFiber<Out, E>, never, Scope.Scope | R | R2>
 } = circular.scheduleForked
 
@@ -4065,12 +4065,12 @@ export const scheduleForked: {
 export const scheduleFrom: {
   <R2, In, Out>(
     initial: In,
-    schedule: Schedule.Schedule<R2, In, Out>
+    schedule: Schedule.Schedule<Out, In, R2>
   ): <E, R>(self: Effect<In, E, R>) => Effect<Out, E, R2 | R>
   <In, E, R, R2, Out>(
     self: Effect<In, E, R>,
     initial: In,
-    schedule: Schedule.Schedule<R2, In, Out>
+    schedule: Schedule.Schedule<Out, In, R2>
   ): Effect<Out, E, R | R2>
 } = _schedule.scheduleFrom_Effect
 
diff --git a/packages/effect/src/Layer.ts b/packages/effect/src/Layer.ts
index 6d0c6fef9c..0da985fb98 100644
--- a/packages/effect/src/Layer.ts
+++ b/packages/effect/src/Layer.ts
@@ -597,12 +597,12 @@ export const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) =>
  * @category retrying
  */
 export const retry: {
-  <RIn2, E, X>(
-    schedule: Schedule.Schedule<RIn2, E, X>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
-  <RIn, E, ROut, RIn2, X>(
+  <X, E, RIn2>(
+    schedule: Schedule.Schedule<X, E, RIn2>
+  ): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
+  <ROut, E, RIn, X, RIn2>(
     self: Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<RIn2, E, X>
+    schedule: Schedule.Schedule<X, E, RIn2>
   ): Layer<ROut, E, RIn | RIn2>
 } = internal.retry
 
diff --git a/packages/effect/src/MetricPolling.ts b/packages/effect/src/MetricPolling.ts
index 508e721eb7..023fd33ac0 100644
--- a/packages/effect/src/MetricPolling.ts
+++ b/packages/effect/src/MetricPolling.ts
@@ -70,14 +70,14 @@ export const collectAll: <R, E, Out>(
  * @category utils
  */
 export const launch: {
-  <R2, A2>(
-    schedule: Schedule.Schedule<R2, unknown, A2>
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ): <Type, In, R, E, Out>(
     self: MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R2 | R>
-  <Type, In, R, E, Out, R2, A2>(
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R2 | R | Scope.Scope>
+  <Type, In, R, E, Out, A2, R2>(
     self: MetricPolling<Type, In, R, E, Out>,
-    schedule: Schedule.Schedule<R2, unknown, A2>
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ): Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R | R2>
 } = internal.launch
 
@@ -108,12 +108,12 @@ export const pollAndUpdate: <Type, In, R, E, Out>(
  * @category constructors
  */
 export const retry: {
-  <R2, E, _>(
-    policy: Schedule.Schedule<R2, E, _>
+  <_, E, R2>(
+    policy: Schedule.Schedule<_, E, R2>
   ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
-  <Type, In, R, Out, R2, E, _>(
+  <Type, In, R, E, Out, _, R2>(
     self: MetricPolling<Type, In, R, E, Out>,
-    policy: Schedule.Schedule<R2, E, _>
+    policy: Schedule.Schedule<_, E, R2>
   ): MetricPolling<Type, In, R | R2, E, Out>
 } = internal.retry
 
diff --git a/packages/effect/src/Reloadable.ts b/packages/effect/src/Reloadable.ts
index f0d9720a7e..2530ba5ffb 100644
--- a/packages/effect/src/Reloadable.ts
+++ b/packages/effect/src/Reloadable.ts
@@ -62,11 +62,11 @@ export declare namespace Reloadable {
  * @since 2.0.0
  * @category constructors
  */
-export const auto: <Out extends Context.Tag<any, any>, In, E, R>(
+export const auto: <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly schedule: Schedule.Schedule<R, unknown, unknown>
+    readonly schedule: Schedule.Schedule<unknown, unknown, R>
   }
 ) => Layer.Layer<Reloadable<Context.Tag.Identifier<Out>>, E, In | R> = internal.auto
 
@@ -78,11 +78,11 @@ export const auto: <Out extends Context.Tag<any, any>, In, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const autoFromConfig: <Out extends Context.Tag<any, any>, In, E, R>(
+export const autoFromConfig: <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
+    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
   }
 ) => Layer.Layer<Reloadable<Context.Tag.Identifier<Out>>, E, In | R> = internal.autoFromConfig
 
diff --git a/packages/effect/src/Resource.ts b/packages/effect/src/Resource.ts
index 4655ad10d1..dc9af2a864 100644
--- a/packages/effect/src/Resource.ts
+++ b/packages/effect/src/Resource.ts
@@ -61,10 +61,10 @@ export declare namespace Resource {
  * @since 2.0.0
  * @category constructors
  */
-export const auto: <A, E, R, R2, Out>(
+export const auto: <A, E, R, Out, R2>(
   acquire: Effect.Effect<A, E, R>,
-  policy: Schedule.Schedule<R2, unknown, Out>
-) => Effect.Effect<Resource<A, E>, never, Scope.Scope | R | R2> = internal.auto
+  policy: Schedule.Schedule<Out, unknown, R2>
+) => Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope> = internal.auto
 
 /**
  * Retrieves the current value stored in the cache.
diff --git a/packages/effect/src/Schedule.ts b/packages/effect/src/Schedule.ts
index 51f9650c3c..9e478fe67d 100644
--- a/packages/effect/src/Schedule.ts
+++ b/packages/effect/src/Schedule.ts
@@ -42,7 +42,7 @@ export const ScheduleDriverTypeId: unique symbol = internal.ScheduleDriverTypeId
 export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId
 
 /**
- * A `Schedule<Env, In, Out>` defines a recurring schedule, which consumes
+ * A `Schedule<Out, In, R>` defines a recurring schedule, which consumes
  * values of type `In`, and which returns values of type `Out`.
  *
  * Schedules are defined as a possibly infinite set of intervals spread out over
@@ -69,7 +69,7 @@ export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId
  * @category model
  * @since 2.0.0
  */
-export interface Schedule<out Env, in In, out Out> extends Schedule.Variance<Env, In, Out>, Pipeable {
+export interface Schedule<out Out, in In = unknown, out R = never> extends Schedule.Variance<Out, In, R>, Pipeable {
   /**
    * Initial State
    */
@@ -81,7 +81,7 @@ export interface Schedule<out Env, in In, out Out> extends Schedule.Variance<Env
     now: number,
     input: In,
     state: any
-  ): Effect.Effect<readonly [any, Out, ScheduleDecision.ScheduleDecision], never, Env>
+  ): Effect.Effect<readonly [any, Out, ScheduleDecision.ScheduleDecision], never, R>
 }
 
 /**
@@ -92,22 +92,22 @@ export declare namespace Schedule {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out Env, in In, out Out> {
+  export interface Variance<out Out, in In, out R> {
     readonly [ScheduleTypeId]: {
-      readonly _Env: Types.Covariant<Env>
-      readonly _In: Types.Contravariant<In>
       readonly _Out: Types.Covariant<Out>
+      readonly _In: Types.Contravariant<In>
+      readonly _R: Types.Covariant<R>
     }
   }
 
   /**
    * @since 2.0.0
    */
-  export interface DriverVariance<out Env, in In, out Out> {
+  export interface DriverVariance<out Out, in In, out R> {
     readonly [ScheduleDriverTypeId]: {
-      readonly _Env: Types.Covariant<Env>
-      readonly _In: Types.Contravariant<In>
       readonly _Out: Types.Covariant<Out>
+      readonly _In: Types.Contravariant<In>
+      readonly _R: Types.Covariant<R>
     }
   }
 }
@@ -116,11 +116,11 @@ export declare namespace Schedule {
  * @since 2.0.0
  * @category models
  */
-export interface ScheduleDriver<out Env, in In, out Out> extends Schedule.DriverVariance<Env, In, Out> {
+export interface ScheduleDriver<out Out, in In = unknown, out R = never> extends Schedule.DriverVariance<Out, In, R> {
   readonly state: Effect.Effect<unknown>
   readonly last: Effect.Effect<Out, Cause.NoSuchElementException>
   readonly reset: Effect.Effect<void>
-  next(input: In): Effect.Effect<Out, Option.Option<never>, Env>
+  next(input: In): Effect.Effect<Out, Option.Option<never>, R>
 }
 
 /**
@@ -130,14 +130,14 @@ export interface ScheduleDriver<out Env, in In, out Out> extends Schedule.Driver
  * @since 2.0.0
  * @category constructors
  */
-export const makeWithState: <S, Env, In, Out>(
+export const makeWithState: <S, In, Out, R = never>(
   initial: S,
   step: (
     now: number,
     input: In,
     state: S
-  ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, Env>
-) => Schedule<Env, In, Out> = internal.makeWithState
+  ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, R>
+) => Schedule<Out, In, R> = internal.makeWithState
 
 /**
  * Returns a new schedule with the given delay added to every interval defined
@@ -147,8 +147,8 @@ export const makeWithState: <S, Env, In, Out>(
  * @category utils
  */
 export const addDelay: {
-  <Out>(f: (out: Out) => Duration.DurationInput): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, f: (out: Out) => Duration.DurationInput): Schedule<Env, In, Out>
+  <Out>(f: (out: Out) => Duration.DurationInput): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, f: (out: Out) => Duration.DurationInput): Schedule<Out, In, R>
 } = internal.addDelay
 
 /**
@@ -159,13 +159,13 @@ export const addDelay: {
  * @category utils
  */
 export const addDelayEffect: {
-  <Out, Env2>(
-    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2>(
-    self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <Out, R2>(
+    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.addDelayEffect
 
 /**
@@ -175,13 +175,13 @@ export const addDelayEffect: {
  * @category sequencing
  */
 export const andThen: {
-  <Env1, In1, Out2>(
-    that: Schedule<Env1, In1, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In & In1, Out2 | Out>
-  <Env, In, Out, Env1, In1, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env1, In1, Out2>
-  ): Schedule<Env | Env1, In & In1, Out | Out2>
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2 | Out, In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<Out | Out2, In & In2, R | R2>
 } = internal.andThen
 
 /**
@@ -192,13 +192,13 @@ export const andThen: {
  * @category sequencing
  */
 export const andThenEither: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Either.Either<Out2, Out>>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, Either.Either<Out2, Out>>
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Either.Either<Out2, Out>, In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<Either.Either<Out2, Out>, In & In2, R | R2>
 } = internal.andThenEither
 
 /**
@@ -208,8 +208,8 @@ export const andThenEither: {
  * @category mapping
  */
 export const as: {
-  <Out2>(out: Out2): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out2>
-  <Env, In, Out, Out2>(self: Schedule<Env, In, Out>, out: Out2): Schedule<Env, In, Out2>
+  <Out2>(out: Out2): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>
+  <Out, In, R, Out2>(self: Schedule<Out, In, R>, out: Out2): Schedule<Out2, In, R>
 } = internal.as
 
 /**
@@ -218,7 +218,7 @@ export const as: {
  * @since 2.0.0
  * @category constructors
  */
-export const asUnit: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, void> = internal.asUnit
+export const asUnit: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<void, In, R> = internal.asUnit
 
 /**
  * Returns a new schedule that has both the inputs and outputs of this and the
@@ -228,21 +228,13 @@ export const asUnit: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<En
  * @category utils
  */
 export const bothInOut: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<
-    Env2 | Env,
-    readonly [In, In2], // readonly because contravariant
-    [Out, Out2]
-  >
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>
-  ): Schedule<
-    Env | Env2,
-    readonly [In, In2], // readonly because contravariant
-    [Out, Out2]
-  >
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], readonly [In, In2], R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<[Out, Out2], readonly [In, In2], R | R2>
 } = internal.bothInOut
 
 /**
@@ -254,8 +246,8 @@ export const bothInOut: {
  * @category utils
  */
 export const check: {
-  <In, Out>(test: (input: In, output: Out) => boolean): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, test: (input: In, output: Out) => boolean): Schedule<Env, In, Out>
+  <In, Out>(test: (input: In, output: Out) => boolean): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, test: (input: In, output: Out) => boolean): Schedule<Out, In, R>
 } = internal.check
 
 /**
@@ -267,13 +259,13 @@ export const check: {
  * @category utils
  */
 export const checkEffect: {
-  <In, Out, Env2>(
-    test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>
-  ): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2>(
-    self: Schedule<Env, In, Out>,
-    test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <In, Out, R2>(
+    test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
+  ): <R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.checkEffect
 
 /**
@@ -282,7 +274,7 @@ export const checkEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const collectAllInputs: <A>() => Schedule<never, A, Chunk.Chunk<A>> = internal.collectAllInputs
+export const collectAllInputs: <A>() => Schedule<Chunk.Chunk<A>, A> = internal.collectAllInputs
 
 /**
  * Returns a new schedule that collects the outputs of this one into a chunk.
@@ -290,7 +282,7 @@ export const collectAllInputs: <A>() => Schedule<never, A, Chunk.Chunk<A>> = int
  * @since 2.0.0
  * @category utils
  */
-export const collectAllOutputs: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Chunk.Chunk<Out>> =
+export const collectAllOutputs: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Chunk.Chunk<Out>, In, R> =
   internal.collectAllOutputs
 
 /**
@@ -300,7 +292,7 @@ export const collectAllOutputs: <Env, In, Out>(self: Schedule<Env, In, Out>) =>
  * @since 2.0.0
  * @category utils
  */
-export const collectUntil: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chunk<A>> = internal.collectUntil
+export const collectUntil: <A>(f: Predicate<A>) => Schedule<Chunk.Chunk<A>, A> = internal.collectUntil
 
 /**
  * A schedule that recurs until the effectful condition f fails, collecting
@@ -309,9 +301,9 @@ export const collectUntil: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chun
  * @since 2.0.0
  * @category utils
  */
-export const collectUntilEffect: <Env, A>(
-  f: (a: A) => Effect.Effect<boolean, never, Env>
-) => Schedule<Env, A, Chunk.Chunk<A>> = internal.collectUntilEffect
+export const collectUntilEffect: <A, R>(
+  f: (a: A) => Effect.Effect<boolean, never, R>
+) => Schedule<Chunk.Chunk<A>, A, R> = internal.collectUntilEffect
 
 /**
  * A schedule that recurs as long as the condition f holds, collecting all
@@ -320,7 +312,7 @@ export const collectUntilEffect: <Env, A>(
  * @since 2.0.0
  * @category utils
  */
-export const collectWhile: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chunk<A>> = internal.collectWhile
+export const collectWhile: <A>(f: Predicate<A>) => Schedule<Chunk.Chunk<A>, A> = internal.collectWhile
 
 /**
  * A schedule that recurs as long as the effectful condition holds, collecting
@@ -329,9 +321,9 @@ export const collectWhile: <A>(f: Predicate<A>) => Schedule<never, A, Chunk.Chun
  * @category utils
  * @since 2.0.0
  */
-export const collectWhileEffect: <Env, A>(
-  f: (a: A) => Effect.Effect<boolean, never, Env>
-) => Schedule<Env, A, Chunk.Chunk<A>> = internal.collectWhileEffect
+export const collectWhileEffect: <A, R>(
+  f: (a: A) => Effect.Effect<boolean, never, R>
+) => Schedule<Chunk.Chunk<A>, A, R> = internal.collectWhileEffect
 
 /**
  * Returns the composition of this schedule and the specified schedule, by
@@ -343,13 +335,8 @@ export const collectWhileEffect: <Env, A>(
  * @category utils
  */
 export const compose: {
-  <Env2, Out, Out2>(
-    that: Schedule<Env2, Out, Out2>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out2>
-  <Env, In, Out, Env2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, Out, Out2>
-  ): Schedule<Env | Env2, In, Out2>
+  <Out2, Out, R2>(that: Schedule<Out2, Out, R2>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>
+  <Out, In, R, Out2, R2>(self: Schedule<Out, In, R>, that: Schedule<Out2, Out, R2>): Schedule<Out2, In, R | R2>
 } = internal.compose
 
 /**
@@ -360,8 +347,8 @@ export const compose: {
  * @category mapping
  */
 export const mapInput: {
-  <In, In2>(f: (in2: In2) => In): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In2, Out>
-  <Env, In, Out, In2>(self: Schedule<Env, In, Out>, f: (in2: In2) => In): Schedule<Env, In2, Out>
+  <In, In2>(f: (in2: In2) => In): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R>
+  <Out, In, R, In2>(self: Schedule<Out, In, R>, f: (in2: In2) => In): Schedule<Out, In2, R>
 } = internal.mapInput
 
 /**
@@ -372,13 +359,13 @@ export const mapInput: {
  * @category context
  */
 export const mapInputContext: {
-  <Env0, Env>(
-    f: (env0: Context.Context<Env0>) => Context.Context<Env>
-  ): <In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env0, In, Out>
-  <Env0, Env, In, Out>(
-    self: Schedule<Env, In, Out>,
-    f: (env0: Context.Context<Env0>) => Context.Context<Env>
-  ): Schedule<Env0, In, Out>
+  <R0, R>(
+    f: (env0: Context.Context<R0>) => Context.Context<R>
+  ): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, R0>
+  <Out, In, R, R0>(
+    self: Schedule<Out, In, R>,
+    f: (env0: Context.Context<R0>) => Context.Context<R>
+  ): Schedule<Out, In, R0>
 } = internal.mapInputContext
 
 /**
@@ -389,13 +376,13 @@ export const mapInputContext: {
  * @category mapping
  */
 export const mapInputEffect: {
-  <In, Env2, In2>(
-    f: (in2: In2) => Effect.Effect<In, never, Env2>
-  ): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In2, Out>
-  <Env, In, Out, Env2, In2>(
-    self: Schedule<Env, In, Out>,
-    f: (in2: In2) => Effect.Effect<In, never, Env2>
-  ): Schedule<Env | Env2, In2, Out>
+  <In2, In, R2>(
+    f: (in2: In2) => Effect.Effect<In, never, R2>
+  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In2, R2 | R>
+  <Out, In, R, In2, R2>(
+    self: Schedule<Out, In, R>,
+    f: (in2: In2) => Effect.Effect<In, never, R2>
+  ): Schedule<Out, In2, R | R2>
 } = internal.mapInputEffect
 
 /**
@@ -404,7 +391,7 @@ export const mapInputEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const count: Schedule<never, unknown, number> = internal.count
+export const count: Schedule<number> = internal.count
 
 /**
  * Cron schedule that recurs every `minute` that matches the schedule.
@@ -416,7 +403,7 @@ export const count: Schedule<never, unknown, number> = internal.count
  * @since 2.0.0
  * @category constructors
  */
-export const cron: (expression: string | Cron.Cron) => Schedule<never, unknown, [number, number]> = internal.cron
+export const cron: (expression: string | Cron.Cron) => Schedule<[number, number]> = internal.cron
 
 /**
  * Cron-like schedule that recurs every specified `day` of month. Won't recur
@@ -429,7 +416,7 @@ export const cron: (expression: string | Cron.Cron) => Schedule<never, unknown,
  * @since 2.0.0
  * @category constructors
  */
-export const dayOfMonth: (day: number) => Schedule<never, unknown, number> = internal.dayOfMonth
+export const dayOfMonth: (day: number) => Schedule<number> = internal.dayOfMonth
 
 /**
  * Cron-like schedule that recurs every specified `day` of each week. It
@@ -441,7 +428,7 @@ export const dayOfMonth: (day: number) => Schedule<never, unknown, number> = int
  * @since 2.0.0
  * @category constructors
  */
-export const dayOfWeek: (day: number) => Schedule<never, unknown, number> = internal.dayOfWeek
+export const dayOfWeek: (day: number) => Schedule<number> = internal.dayOfWeek
 
 /**
  * Returns a new schedule with the specified effectfully computed delay added
@@ -453,11 +440,11 @@ export const dayOfWeek: (day: number) => Schedule<never, unknown, number> = inte
 export const delayed: {
   (
     f: (duration: Duration.Duration) => Duration.DurationInput
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(
-    self: Schedule<Env, In, Out>,
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(
+    self: Schedule<Out, In, R>,
     f: (duration: Duration.Duration) => Duration.DurationInput
-  ): Schedule<Env, In, Out>
+  ): Schedule<Out, In, R>
 } = internal.delayed
 
 /**
@@ -468,13 +455,13 @@ export const delayed: {
  * @category constructors
  */
 export const delayedEffect: {
-  <Env2>(
-    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2>(
-    self: Schedule<Env, In, Out>,
-    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <R2>(
+    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.delayedEffect
 
 /**
@@ -484,9 +471,9 @@ export const delayedEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const delayedSchedule: <Env, In>(
-  schedule: Schedule<Env, In, Duration.Duration>
-) => Schedule<Env, In, Duration.Duration> = internal.delayedSchedule
+export const delayedSchedule: <In, R>(
+  schedule: Schedule<Duration.Duration, In, R>
+) => Schedule<Duration.Duration, In, R> = internal.delayedSchedule
 
 /**
  * Returns a new schedule that outputs the delay between each occurence.
@@ -494,8 +481,7 @@ export const delayedSchedule: <Env, In>(
  * @since 2.0.0
  * @category constructors
  */
-export const delays: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Duration.Duration> =
-  internal.delays
+export const delays: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Duration.Duration, In, R> = internal.delays
 
 /**
  * Returns a new schedule that maps both the input and output.
@@ -504,19 +490,13 @@ export const delays: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<En
  * @category mapping
  */
 export const mapBoth: {
-  <In, Out, In2, Out2>(
-    options: {
-      readonly onInput: (in2: In2) => In
-      readonly onOutput: (out: Out) => Out2
-    }
-  ): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env, In2, Out2>
-  <Env, In, Out, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    options: {
-      readonly onInput: (in2: In2) => In
-      readonly onOutput: (out: Out) => Out2
-    }
-  ): Schedule<Env, In2, Out2>
+  <In2, In, Out, Out2>(
+    options: { readonly onInput: (in2: In2) => In; readonly onOutput: (out: Out) => Out2 }
+  ): <R>(self: Schedule<Out, In, R>) => Schedule<Out2, In2, R>
+  <Out, In, R, In2, Out2>(
+    self: Schedule<Out, In, R>,
+    options: { readonly onInput: (in2: In2) => In; readonly onOutput: (out: Out) => Out2 }
+  ): Schedule<Out2, In2, R>
 } = internal.mapBoth
 
 /**
@@ -526,19 +506,19 @@ export const mapBoth: {
  * @category mapping
  */
 export const mapBothEffect: {
-  <In2, Env2, In, Out, Env3, Out2>(
+  <In2, In, R2, Out, R3, Out2>(
     options: {
-      readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>
-      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>
+      readonly onInput: (input: In2) => Effect.Effect<In, never, R2>
+      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>
     }
-  ): <Env>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env3 | Env, In2, Out2>
-  <Env, In, Out, In2, Env2, Env3, Out2>(
-    self: Schedule<Env, In, Out>,
+  ): <R>(self: Schedule<Out, In, R>) => Schedule<Out2, In2, R2 | R3 | R>
+  <Out, In, R, In2, R2, Out2, R3>(
+    self: Schedule<Out, In, R>,
     options: {
-      readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>
-      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>
+      readonly onInput: (input: In2) => Effect.Effect<In, never, R2>
+      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>
     }
-  ): Schedule<Env | Env2 | Env3, In2, Out2>
+  ): Schedule<Out2, In2, R | R2 | R3>
 } = internal.mapBothEffect
 
 /**
@@ -548,9 +528,9 @@ export const mapBothEffect: {
  * @since 2.0.0
  * @category getter
  */
-export const driver: <Env, In, Out>(
-  self: Schedule<Env, In, Out>
-) => Effect.Effect<ScheduleDriver<Env, In, Out>> = internal.driver
+export const driver: <Out, In, R>(
+  self: Schedule<Out, In, R>
+) => Effect.Effect<ScheduleDriver<Out, In, R>> = internal.driver
 
 /**
  * A schedule that can recur one time, the specified amount of time into the
@@ -559,8 +539,7 @@ export const driver: <Env, In, Out>(
  * @since 2.0.0
  * @category constructors
  */
-export const duration: (duration: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration> =
-  internal.duration
+export const duration: (duration: Duration.DurationInput) => Schedule<Duration.Duration> = internal.duration
 
 /**
  * Returns a new schedule that performs a geometric union on the intervals
@@ -570,13 +549,13 @@ export const duration: (duration: Duration.DurationInput) => Schedule<never, unk
  * @category alternatives
  */
 export const either: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.either
 
 /**
@@ -586,15 +565,15 @@ export const either: {
  * @category alternatives
  */
 export const eitherWith: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>,
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
+  ): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.eitherWith
 
 /**
@@ -604,7 +583,7 @@ export const eitherWith: {
  * @since 2.0.0
  * @category constructors
  */
-export const elapsed: Schedule<never, unknown, Duration.Duration> = internal.elapsed
+export const elapsed: Schedule<Duration.Duration> = internal.elapsed
 
 /**
  * Returns a new schedule that will run the specified finalizer as soon as the
@@ -617,8 +596,8 @@ export const elapsed: Schedule<never, unknown, Duration.Duration> = internal.ela
  * @category finalization
  */
 export const ensuring: {
-  <X>(finalizer: Effect.Effect<X>): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out, X>(self: Schedule<Env, In, Out>, finalizer: Effect.Effect<X>): Schedule<Env, In, Out>
+  <X>(finalizer: Effect.Effect<X, never, never>): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R, X>(self: Schedule<Out, In, R>, finalizer: Effect.Effect<X, never, never>): Schedule<Out, In, R>
 } = internal.ensuring
 
 /**
@@ -632,7 +611,7 @@ export const ensuring: {
 export const exponential: (
   base: Duration.DurationInput,
   factor?: number
-) => Schedule<never, unknown, Duration.Duration> = internal.exponential
+) => Schedule<Duration.Duration> = internal.exponential
 
 /**
  * A schedule that always recurs, increasing delays by summing the preceding
@@ -642,8 +621,7 @@ export const exponential: (
  * @since 2.0.0
  * @category constructors
  */
-export const fibonacci: (one: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration> =
-  internal.fibonacci
+export const fibonacci: (one: Duration.DurationInput) => Schedule<Duration.Duration> = internal.fibonacci
 
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
@@ -660,7 +638,7 @@ export const fibonacci: (one: Duration.DurationInput) => Schedule<never, unknown
  * @since 2.0.0
  * @category constructors
  */
-export const fixed: (interval: Duration.DurationInput) => Schedule<never, unknown, number> = internal.fixed
+export const fixed: (interval: Duration.DurationInput) => Schedule<number> = internal.fixed
 
 /**
  * A schedule that always recurs, producing a count of repeats: 0, 1, 2.
@@ -668,7 +646,7 @@ export const fixed: (interval: Duration.DurationInput) => Schedule<never, unknow
  * @since 2.0.0
  * @category constructors
  */
-export const forever: Schedule<never, unknown, number> = internal.forever
+export const forever: Schedule<number> = internal.forever
 
 /**
  * A schedule that recurs once with the specified delay.
@@ -676,8 +654,7 @@ export const forever: Schedule<never, unknown, number> = internal.forever
  * @since 2.0.0
  * @category constructors
  */
-export const fromDelay: (delay: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration> =
-  internal.fromDelay
+export const fromDelay: (delay: Duration.DurationInput) => Schedule<Duration.Duration> = internal.fromDelay
 
 /**
  * A schedule that recurs once for each of the specified durations, delaying
@@ -690,7 +667,7 @@ export const fromDelay: (delay: Duration.DurationInput) => Schedule<never, unkno
 export const fromDelays: (
   delay: Duration.DurationInput,
   ...delays: Array<Duration.DurationInput>
-) => Schedule<never, unknown, Duration.Duration> = internal.fromDelays
+) => Schedule<Duration.Duration> = internal.fromDelays
 
 /**
  * A schedule that always recurs, mapping input values through the specified
@@ -699,7 +676,7 @@ export const fromDelays: (
  * @since 2.0.0
  * @category constructors
  */
-export const fromFunction: <A, B>(f: (a: A) => B) => Schedule<never, A, B> = internal.fromFunction
+export const fromFunction: <A, B>(f: (a: A) => B) => Schedule<B, A> = internal.fromFunction
 
 /**
  * Cron-like schedule that recurs every specified `hour` of each day. It
@@ -710,7 +687,7 @@ export const fromFunction: <A, B>(f: (a: A) => B) => Schedule<never, A, B> = int
  * @since 2.0.0
  * @category constructors
  */
-export const hourOfDay: (hour: number) => Schedule<never, unknown, number> = internal.hourOfDay
+export const hourOfDay: (hour: number) => Schedule<number> = internal.hourOfDay
 
 /**
  * A schedule that always recurs, which returns inputs as outputs.
@@ -718,7 +695,7 @@ export const hourOfDay: (hour: number) => Schedule<never, unknown, number> = int
  * @since 2.0.0
  * @category constructors
  */
-export const identity: <A>() => Schedule<never, A, A> = internal.identity
+export const identity: <A>() => Schedule<A, A> = internal.identity
 
 /**
  * Returns a new schedule that performs a geometric intersection on the
@@ -728,13 +705,13 @@ export const identity: <A>() => Schedule<never, A, A> = internal.identity
  * @category utils
  */
 export const intersect: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.intersect
 
 /**
@@ -746,15 +723,15 @@ export const intersect: {
  * @category utils
  */
 export const intersectWith: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>,
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
+  ): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.intersectWith
 
 /**
@@ -769,7 +746,7 @@ export const intersectWith: {
  * @since 2.0.0
  * @category constructors
  */
-export const jittered: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out> = internal.jittered
+export const jittered: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R> = internal.jittered
 
 /**
  * Returns a new schedule that randomly modifies the size of the intervals of
@@ -782,13 +759,13 @@ export const jittered: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<
  * @category constructors
  */
 export const jitteredWith: {
-  (options: { min?: number; max?: number }): <Env, In, Out>(
-    self: Schedule<Env, In, Out>
-  ) => Schedule<Env, In, Out>
-  <Env, In, Out>(
-    self: Schedule<Env, In, Out>,
-    options: { min?: number; max?: number }
-  ): Schedule<Env, In, Out>
+  (
+    options: { min?: number | undefined; max?: number | undefined }
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(
+    self: Schedule<Out, In, R>,
+    options: { min?: number | undefined; max?: number | undefined }
+  ): Schedule<Out, In, R>
 } = internal.jitteredWith
 
 /**
@@ -799,7 +776,7 @@ export const jitteredWith: {
  * @since 2.0.0
  * @category constructors
  */
-export const linear: (base: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration> = internal.linear
+export const linear: (base: Duration.DurationInput) => Schedule<Duration.Duration> = internal.linear
 
 /**
  * Returns a new schedule that maps the output of this schedule through the
@@ -809,8 +786,8 @@ export const linear: (base: Duration.DurationInput) => Schedule<never, unknown,
  * @category mapping
  */
 export const map: {
-  <Out, Out2>(f: (out: Out) => Out2): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out2>
-  <Env, In, Out, Out2>(self: Schedule<Env, In, Out>, f: (out: Out) => Out2): Schedule<Env, In, Out2>
+  <Out, Out2>(f: (out: Out) => Out2): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R>
+  <Out, In, R, Out2>(self: Schedule<Out, In, R>, f: (out: Out) => Out2): Schedule<Out2, In, R>
 } = internal.map
 
 /**
@@ -821,13 +798,13 @@ export const map: {
  * @category mapping
  */
 export const mapEffect: {
-  <Out, Env2, Out2>(
-    f: (out: Out) => Effect.Effect<Out2, never, Env2>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out2>
-  <Env, In, Out, Env2, Out2>(
-    self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Out2, never, Env2>
-  ): Schedule<Env | Env2, In, Out2>
+  <Out, Out2, R2>(
+    f: (out: Out) => Effect.Effect<Out2, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In, R2 | R>
+  <Out, In, R, Out2, R2>(
+    self: Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<Out2, never, R2>
+  ): Schedule<Out2, In, R | R2>
 } = internal.mapEffect
 
 /**
@@ -840,7 +817,7 @@ export const mapEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const minuteOfHour: (minute: number) => Schedule<never, unknown, number> = internal.minuteOfHour
+export const minuteOfHour: (minute: number) => Schedule<number> = internal.minuteOfHour
 
 /**
  * Returns a new schedule that modifies the delay using the specified
@@ -852,11 +829,11 @@ export const minuteOfHour: (minute: number) => Schedule<never, unknown, number>
 export const modifyDelay: {
   <Out>(
     f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(
-    self: Schedule<Env, In, Out>,
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(
+    self: Schedule<Out, In, R>,
     f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
-  ): Schedule<Env, In, Out>
+  ): Schedule<Out, In, R>
 } = internal.modifyDelay
 
 /**
@@ -867,13 +844,13 @@ export const modifyDelay: {
  * @category utils
  */
 export const modifyDelayEffect: {
-  <Out, Env2>(
-    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2>(
-    self: Schedule<Env, In, Out>,
-    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <Out, R2>(
+    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.modifyDelayEffect
 
 /**
@@ -885,13 +862,13 @@ export const modifyDelayEffect: {
  * @category utils
  */
 export const onDecision: {
-  <Out, Env2, X>(
-    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2, X>(
-    self: Schedule<Env, In, Out>,
-    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <Out, X, R2>(
+    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, X, R2>(
+    self: Schedule<Out, In, R>,
+    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.onDecision
 
 /**
@@ -900,7 +877,7 @@ export const onDecision: {
  * @since 2.0.0
  * @category constructors
  */
-export const once: Schedule<never, unknown, void> = internal.once
+export const once: Schedule<void> = internal.once
 
 /**
  * Returns a new schedule that passes through the inputs of this schedule.
@@ -908,8 +885,7 @@ export const once: Schedule<never, unknown, void> = internal.once
  * @since 2.0.0
  * @category utils
  */
-export const passthrough: <Env, Input, Output>(self: Schedule<Env, Input, Output>) => Schedule<Env, Input, Input> =
-  internal.passthrough
+export const passthrough: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<In, In, R> = internal.passthrough
 
 /**
  * Returns a new schedule with its context provided to it, so the
@@ -919,8 +895,8 @@ export const passthrough: <Env, Input, Output>(self: Schedule<Env, Input, Output
  * @category context
  */
 export const provideContext: {
-  <Env>(context: Context.Context<Env>): <In, Out>(self: Schedule<Env, In, Out>) => Schedule<never, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, context: Context.Context<Env>): Schedule<never, In, Out>
+  <R>(context: Context.Context<R>): <Out, In>(self: Schedule<Out, In, R>) => Schedule<Out, In, never>
+  <Out, In, R>(self: Schedule<Out, In, R>, context: Context.Context<R>): Schedule<Out, In, never>
 } = internal.provideContext
 
 /**
@@ -932,15 +908,15 @@ export const provideContext: {
  * @category context
  */
 export const provideService: {
-  <T, T1 extends T>(
-    tag: any,
-    service: T1
-  ): <Env, In, Out>(self: Schedule<T | Env, In, Out>) => Schedule<Exclude<Env, T>, In, Out>
-  <Env, T, In, Out, T1 extends T>(
-    self: Schedule<Env | T, In, Out>,
-    tag: any,
-    service: T1
-  ): Schedule<Exclude<Env, T>, In, Out>
+  <T extends Context.Tag<any, any>>(
+    tag: T,
+    service: Context.Tag.Service<T>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>
+  <Out, In, R, T extends Context.Tag<any, any>>(
+    self: Schedule<Out, In, R>,
+    tag: T,
+    service: Context.Tag.Service<T>
+  ): Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>
 } = internal.provideService
 
 /**
@@ -949,7 +925,7 @@ export const provideService: {
  * @since 2.0.0
  * @category utils
  */
-export const recurUntil: <A>(f: Predicate<A>) => Schedule<never, A, A> = internal.recurUntil
+export const recurUntil: <A>(f: Predicate<A>) => Schedule<A, A> = internal.recurUntil
 
 /**
  * A schedule that recurs for until the predicate evaluates to true.
@@ -957,7 +933,7 @@ export const recurUntil: <A>(f: Predicate<A>) => Schedule<never, A, A> = interna
  * @since 2.0.0
  * @category utils
  */
-export const recurUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, A> =
+export const recurUntilEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<A, A, R> =
   internal.recurUntilEffect
 
 /**
@@ -967,7 +943,7 @@ export const recurUntilEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, neve
  * @since 2.0.0
  * @category utils
  */
-export const recurUntilOption: <A, B>(pf: (a: A) => Option.Option<B>) => Schedule<never, A, Option.Option<B>> =
+export const recurUntilOption: <A, B>(pf: (a: A) => Option.Option<B>) => Schedule<Option.Option<B>, A> =
   internal.recurUntilOption
 
 /**
@@ -976,8 +952,7 @@ export const recurUntilOption: <A, B>(pf: (a: A) => Option.Option<B>) => Schedul
  * @since 2.0.0
  * @category utils
  */
-export const recurUpTo: (duration: Duration.DurationInput) => Schedule<never, unknown, Duration.Duration> =
-  internal.recurUpTo
+export const recurUpTo: (duration: Duration.DurationInput) => Schedule<Duration.Duration> = internal.recurUpTo
 
 /**
  * A schedule that recurs for as long as the predicate evaluates to true.
@@ -985,7 +960,7 @@ export const recurUpTo: (duration: Duration.DurationInput) => Schedule<never, un
  * @since 2.0.0
  * @category utils
  */
-export const recurWhile: <A>(f: Predicate<A>) => Schedule<never, A, A> = internal.recurWhile
+export const recurWhile: <A>(f: Predicate<A>) => Schedule<A, A> = internal.recurWhile
 
 /**
  * A schedule that recurs for as long as the effectful predicate evaluates to
@@ -994,7 +969,7 @@ export const recurWhile: <A>(f: Predicate<A>) => Schedule<never, A, A> = interna
  * @since 2.0.0
  * @category utils
  */
-export const recurWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, never, Env>) => Schedule<Env, A, A> =
+export const recurWhileEffect: <A, R>(f: (a: A) => Effect.Effect<boolean, never, R>) => Schedule<A, A, R> =
   internal.recurWhileEffect
 
 /**
@@ -1004,7 +979,7 @@ export const recurWhileEffect: <Env, A>(f: (a: A) => Effect.Effect<boolean, neve
  * @category constructors
  * @since 2.0.0
  */
-export const recurs: (n: number) => Schedule<never, unknown, number> = internal.recurs
+export const recurs: (n: number) => Schedule<number> = internal.recurs
 
 /**
  * Returns a new schedule that folds over the outputs of this one.
@@ -1013,8 +988,8 @@ export const recurs: (n: number) => Schedule<never, unknown, number> = internal.
  * @category folding
  */
 export const reduce: {
-  <Out, Z>(zero: Z, f: (z: Z, out: Out) => Z): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Z>
-  <Env, In, Out, Z>(self: Schedule<Env, In, Out>, zero: Z, f: (z: Z, out: Out) => Z): Schedule<Env, In, Z>
+  <Out, Z>(zero: Z, f: (z: Z, out: Out) => Z): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R>
+  <Out, In, R, Z>(self: Schedule<Out, In, R>, zero: Z, f: (z: Z, out: Out) => Z): Schedule<Z, In, R>
 } = internal.reduce
 
 /**
@@ -1024,15 +999,15 @@ export const reduce: {
  * @category folding
  */
 export const reduceEffect: {
-  <Out, Env1, Z>(
+  <Z, Out, R2>(
     zero: Z,
-    f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In, Z>
-  <Env, In, Out, Env1, Z>(
-    self: Schedule<Env, In, Out>,
+    f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Z, In, R2 | R>
+  <Out, In, R, Z, R2>(
+    self: Schedule<Out, In, R>,
     zero: Z,
-    f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>
-  ): Schedule<Env | Env1, In, Z>
+    f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>
+  ): Schedule<Z, In, R | R2>
 } = internal.reduceEffect
 
 /**
@@ -1042,7 +1017,7 @@ export const reduceEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const repeatForever: Schedule<never, unknown, number> = internal.forever
+export const repeatForever: Schedule<number> = internal.forever
 
 /**
  * Returns a new schedule that outputs the number of repetitions of this one.
@@ -1050,8 +1025,7 @@ export const repeatForever: Schedule<never, unknown, number> = internal.forever
  * @since 2.0.0
  * @category utils
  */
-export const repetitions: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, number> =
-  internal.repetitions
+export const repetitions: <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<number, In, R> = internal.repetitions
 
 /**
  * Return a new schedule that automatically resets the schedule to its initial
@@ -1061,8 +1035,8 @@ export const repetitions: <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedu
  * @category utils
  */
 export const resetAfter: {
-  (duration: Duration.DurationInput): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, duration: Duration.DurationInput): Schedule<Env, In, Out>
+  (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>
 } = internal.resetAfter
 
 /**
@@ -1073,8 +1047,8 @@ export const resetAfter: {
  * @category utils
  */
 export const resetWhen: {
-  <Out>(f: Predicate<Out>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<Out>): Schedule<Env, In, Out>
+  <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
 } = internal.resetWhen
 
 /**
@@ -1087,12 +1061,8 @@ export const run: {
   <In>(
     now: number,
     input: Iterable<In>
-  ): <Env, Out>(self: Schedule<Env, In, Out>) => Effect.Effect<Chunk.Chunk<Out>, never, Env>
-  <Env, In, Out>(
-    self: Schedule<Env, In, Out>,
-    now: number,
-    input: Iterable<In>
-  ): Effect.Effect<Chunk.Chunk<Out>, never, Env>
+  ): <Out, R>(self: Schedule<Out, In, R>) => Effect.Effect<Chunk.Chunk<Out>, never, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, now: number, input: Iterable<In>): Effect.Effect<Chunk.Chunk<Out>, never, R>
 } = internal.run
 
 /**
@@ -1105,7 +1075,7 @@ export const run: {
  * @since 2.0.0
  * @category constructors
  */
-export const secondOfMinute: (second: number) => Schedule<never, unknown, number> = internal.secondOfMinute
+export const secondOfMinute: (second: number) => Schedule<number> = internal.secondOfMinute
 
 /**
  * Returns a schedule that recurs continuously, each repetition spaced the
@@ -1114,7 +1084,7 @@ export const secondOfMinute: (second: number) => Schedule<never, unknown, number
  * @since 2.0.0
  * @category constructors
  */
-export const spaced: (duration: Duration.DurationInput) => Schedule<never, unknown, number> = internal.spaced
+export const spaced: (duration: Duration.DurationInput) => Schedule<number> = internal.spaced
 
 /**
  * A schedule that does not recur, it just stops.
@@ -1122,7 +1092,7 @@ export const spaced: (duration: Duration.DurationInput) => Schedule<never, unkno
  * @since 2.0.0
  * @category constructors
  */
-export const stop: Schedule<never, unknown, void> = internal.stop
+export const stop: Schedule<void> = internal.stop
 
 /**
  * Returns a schedule that repeats one time, producing the specified constant
@@ -1131,7 +1101,7 @@ export const stop: Schedule<never, unknown, void> = internal.stop
  * @since 2.0.0
  * @category constructors
  */
-export const succeed: <A>(value: A) => Schedule<never, unknown, A> = internal.succeed
+export const succeed: <A>(value: A) => Schedule<A> = internal.succeed
 
 /**
  * Returns a schedule that repeats one time, producing the specified constant
@@ -1140,7 +1110,7 @@ export const succeed: <A>(value: A) => Schedule<never, unknown, A> = internal.su
  * @category constructors
  * @since 2.0.0
  */
-export const sync: <A>(evaluate: LazyArg<A>) => Schedule<never, unknown, A> = internal.sync
+export const sync: <A>(evaluate: LazyArg<A>) => Schedule<A> = internal.sync
 
 /**
  * Returns a new schedule that effectfully processes every input to this
@@ -1150,13 +1120,13 @@ export const sync: <A>(evaluate: LazyArg<A>) => Schedule<never, unknown, A> = in
  * @category sequencing
  */
 export const tapInput: {
-  <Env2, In2, X>(
-    f: (input: In2) => Effect.Effect<X, never, Env2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out>
-  <Env, In, Out, Env2, In2, X>(
-    self: Schedule<Env, In, Out>,
-    f: (input: In2) => Effect.Effect<X, never, Env2>
-  ): Schedule<Env | Env2, In & In2, Out>
+  <In2, X, R2>(
+    f: (input: In2) => Effect.Effect<X, never, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
+  <Out, In, R, In2, X, R2>(
+    self: Schedule<Out, In, R>,
+    f: (input: In2) => Effect.Effect<X, never, R2>
+  ): Schedule<Out, In & In2, R | R2>
 } = internal.tapInput
 
 /**
@@ -1167,13 +1137,13 @@ export const tapInput: {
  * @category sequencing
  */
 export const tapOutput: {
-  <Out, XO extends Out, Env2, X>(
-    f: (out: XO) => Effect.Effect<X, never, Env2>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, XO extends Out, Env2, X>(
-    self: Schedule<Env, In, Out>,
-    f: (out: XO) => Effect.Effect<X, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <XO extends Out, X, R2, Out>(
+    f: (out: XO) => Effect.Effect<X, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, XO extends Out, X, R2>(
+    self: Schedule<Out, In, R>,
+    f: (out: XO) => Effect.Effect<X, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.tapOutput
 
 /**
@@ -1183,7 +1153,7 @@ export const tapOutput: {
  * @since 2.0.0
  * @category constructors
  */
-export const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<never, unknown, A> = internal.unfold
+export const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<A> = internal.unfold
 
 /**
  * Returns a new schedule that performs a geometric union on the intervals
@@ -1193,13 +1163,13 @@ export const unfold: <A>(initial: A, f: (a: A) => A) => Schedule<never, unknown,
  * @category utils
  */
 export const union: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.union
 
 /**
@@ -1211,15 +1181,15 @@ export const union: {
  * @category utils
  */
 export const unionWith: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, [Out, Out2]>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>,
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<[Out, Out2], In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ): Schedule<Env | Env2, In & In2, [Out, Out2]>
+  ): Schedule<[Out, Out2], In & In2, R | R2>
 } = internal.unionWith
 
 /**
@@ -1230,8 +1200,8 @@ export const unionWith: {
  * @category utils
  */
 export const untilInput: {
-  <In>(f: Predicate<In>): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<In>): Schedule<Env, In, Out>
+  <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>
 } = internal.untilInput
 
 /**
@@ -1242,13 +1212,13 @@ export const untilInput: {
  * @category utils
  */
 export const untilInputEffect: {
-  <In, Env2>(
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2>(
-    self: Schedule<Env, In, Out>,
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <In, R2>(
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.untilInputEffect
 
 /**
@@ -1259,8 +1229,8 @@ export const untilInputEffect: {
  * @category utils
  */
 export const untilOutput: {
-  <Out>(f: Predicate<Out>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<Out>): Schedule<Env, In, Out>
+  <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
 } = internal.untilOutput
 
 /**
@@ -1271,13 +1241,13 @@ export const untilOutput: {
  * @category utils
  */
 export const untilOutputEffect: {
-  <Out, Env2>(
-    f: (out: Out) => Effect.Effect<boolean, never, Env2>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2>(
-    self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<boolean, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <Out, R2>(
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.untilOutputEffect
 
 /**
@@ -1287,8 +1257,8 @@ export const untilOutputEffect: {
  * @category utils
  */
 export const upTo: {
-  (duration: Duration.DurationInput): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, duration: Duration.DurationInput): Schedule<Env, In, Out>
+  (duration: Duration.DurationInput): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, duration: Duration.DurationInput): Schedule<Out, In, R>
 } = internal.upTo
 
 /**
@@ -1299,8 +1269,8 @@ export const upTo: {
  * @category utils
  */
 export const whileInput: {
-  <In>(f: Predicate<In>): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<In>): Schedule<Env, In, Out>
+  <In>(f: Predicate<In>): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<In>): Schedule<Out, In, R>
 } = internal.whileInput
 
 /**
@@ -1311,13 +1281,13 @@ export const whileInput: {
  * @category utils
  */
 export const whileInputEffect: {
-  <In, Env2>(
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ): <Env, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In, Out>
-  <Env, In, Out, Env2>(
-    self: Schedule<Env, In, Out>,
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ): Schedule<Env | Env2, In, Out>
+  <In, R2>(
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ): <Out, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.whileInputEffect
 
 /**
@@ -1328,8 +1298,8 @@ export const whileInputEffect: {
  * @category utils
  */
 export const whileOutput: {
-  <Out>(f: Predicate<Out>): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env, In, Out>
-  <Env, In, Out>(self: Schedule<Env, In, Out>, f: Predicate<Out>): Schedule<Env, In, Out>
+  <Out>(f: Predicate<Out>): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R>
+  <Out, In, R>(self: Schedule<Out, In, R>, f: Predicate<Out>): Schedule<Out, In, R>
 } = internal.whileOutput
 
 /**
@@ -1340,13 +1310,13 @@ export const whileOutput: {
  * @category utils
  */
 export const whileOutputEffect: {
-  <Out, Env1>(
-    f: (out: Out) => Effect.Effect<boolean, never, Env1>
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env1 | Env, In, Out>
-  <Env, In, Out, Env1>(
-    self: Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<boolean, never, Env1>
-  ): Schedule<Env | Env1, In, Out>
+  <Out, R2>(
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In, R2 | R>
+  <Out, In, R, R2>(
+    self: Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ): Schedule<Out, In, R | R2>
 } = internal.whileOutputEffect
 
 /**
@@ -1365,7 +1335,7 @@ export const whileOutputEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const windowed: (interval: Duration.DurationInput) => Schedule<never, unknown, number> = internal.windowed
+export const windowed: (interval: Duration.DurationInput) => Schedule<number> = internal.windowed
 
 /**
  * The same as `intersect` but ignores the right output.
@@ -1374,13 +1344,13 @@ export const windowed: (interval: Duration.DurationInput) => Schedule<never, unk
  * @category zipping
  */
 export const zipLeft: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, Out>
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out, In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<Out, In & In2, R | R2>
 } = internal.zipLeft
 
 /**
@@ -1390,13 +1360,13 @@ export const zipLeft: {
  * @category zipping
  */
 export const zipRight: {
-  <Env2, In2, Out2>(
-    that: Schedule<Env2, In2, Out2>
-  ): <Env, In, Out>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out2>
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>
-  ): Schedule<Env | Env2, In & In2, Out2>
+  <Out2, In2, R2>(
+    that: Schedule<Out2, In2, R2>
+  ): <Out, In, R>(self: Schedule<Out, In, R>) => Schedule<Out2, In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>
+  ): Schedule<Out2, In & In2, R | R2>
 } = internal.zipRight
 
 /**
@@ -1406,13 +1376,13 @@ export const zipRight: {
  * @category zipping
  */
 export const zipWith: {
-  <Env2, In2, Out2, Out, Out3>(
-    that: Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2, Out, Out3>(
+    that: Schedule<Out2, In2, R2>,
     f: (out: Out, out2: Out2) => Out3
-  ): <Env, In>(self: Schedule<Env, In, Out>) => Schedule<Env2 | Env, In & In2, Out3>
-  <Env, In, Out, Env2, In2, Out2, Out3>(
-    self: Schedule<Env, In, Out>,
-    that: Schedule<Env2, In2, Out2>,
+  ): <In, R>(self: Schedule<Out, In, R>) => Schedule<Out3, In & In2, R2 | R>
+  <Out, In, R, Out2, In2, R2, Out3>(
+    self: Schedule<Out, In, R>,
+    that: Schedule<Out2, In2, R2>,
     f: (out: Out, out2: Out2) => Out3
-  ): Schedule<Env | Env2, In & In2, Out3>
+  ): Schedule<Out3, In & In2, R | R2>
 } = internal.zipWith
diff --git a/packages/effect/src/Stream.ts b/packages/effect/src/Stream.ts
index 1aec5a0b18..51308bdd3e 100644
--- a/packages/effect/src/Stream.ts
+++ b/packages/effect/src/Stream.ts
@@ -204,14 +204,14 @@ export const aggregate: {
  * @category utils
  */
 export const aggregateWithin: {
-  <B, A, A2, E2, R2, R3, C>(
+  <B, A, A2, E2, R2, C, R3>(
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R3 | R>
-  <A, E, R, B, A2, E2, R2, R3, C>(
+  <A, E, R, B, A2, E2, R2, C, R3>(
     self: Stream<A, E, R>,
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ): Stream<B, E | E2, R | R2 | R3>
 } = internal.aggregateWithin
 
@@ -233,14 +233,14 @@ export const aggregateWithin: {
  * @category utils
  */
 export const aggregateWithinEither: {
-  <B, A, A2, E2, R2, R3, C>(
+  <B, A, A2, E2, R2, C, R3>(
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ): <E, R>(self: Stream<A, E, R>) => Stream<Either.Either<B, C>, E2 | E, R2 | R3 | R>
-  <A, E, R, B, A2, E2, R2, R3, C>(
+  <A, E, R, B, A2, E2, R2, C, R3>(
     self: Stream<A, E, R>,
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ): Stream<Either.Either<B, C>, E | E2, R | R2 | R3>
 } = internal.aggregateWithinEither
 
@@ -1595,7 +1595,7 @@ export const fromReadableStreamByob: <E>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown, A>) => Stream<A, never, R> =
+export const fromSchedule: <A, R>(schedule: Schedule.Schedule<A, unknown, R>) => Stream<A, never, R> =
   internal.fromSchedule
 
 /**
@@ -2696,8 +2696,8 @@ export const refineOrDieWith: {
  * @category utils
  */
 export const repeat: {
-  <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
-  <R, E, A, R2, B>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<A, E, R | R2>
+  <B, R2>(schedule: Schedule.Schedule<B, unknown, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <R, E, A, B, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>): Stream<A, E, R | R2>
 } = internal.repeat
 
 /**
@@ -2747,9 +2747,9 @@ export const repeatEffectOption: <A, E, R>(effect: Effect.Effect<A, Option.Optio
  * @since 2.0.0
  * @category constructors
  */
-export const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(
+export const repeatEffectWithSchedule: <A, E, R, _, A0 extends A, R2>(
   effect: Effect.Effect<A, E, R>,
-  schedule: Schedule.Schedule<R2, A0, _>
+  schedule: Schedule.Schedule<_, A0, R2>
 ) => Stream<A, E, R | R2> = internal.repeatEffectWithSchedule
 
 /**
@@ -2761,12 +2761,12 @@ export const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(
  * @category utils
  */
 export const repeatEither: {
-  <R2, B>(
-    schedule: Schedule.Schedule<R2, unknown, B>
+  <B, R2>(
+    schedule: Schedule.Schedule<B, unknown, R2>
   ): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, B>, E, R2 | R>
-  <R, E, A, R2, B>(
+  <A, E, R, B, R2>(
     self: Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>
+    schedule: Schedule.Schedule<B, unknown, R2>
   ): Stream<Either.Either<A, B>, E, R | R2>
 } = internal.repeatEither
 
@@ -2781,8 +2781,8 @@ export const repeatEither: {
  * @category utils
  */
 export const repeatElements: {
-  <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
-  <R, E, A, R2, B>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<A, E, R | R2>
+  <B, R2>(schedule: Schedule.Schedule<B, unknown, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <A, E, R, B, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>): Stream<A, E, R | R2>
 } = internal.repeatElements
 
 /**
@@ -2801,13 +2801,13 @@ export const repeatElements: {
  * @category utils
  */
 export const repeatElementsWith: {
-  <R2, B, A, C>(
-    schedule: Schedule.Schedule<R2, unknown, B>,
+  <B, R2, A, C>(
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
-  ): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
-  <R, E, R2, B, A, C>(
+  ): <E, R>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
+  <A, E, R, B, R2, C>(
     self: Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>,
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
   ): Stream<C, E, R | R2>
 } = internal.repeatElementsWith
@@ -2830,13 +2830,13 @@ export const repeatValue: <A>(value: A) => Stream<A> = internal.repeatValue
  * @category utils
  */
 export const repeatWith: {
-  <R2, B, A, C>(
-    schedule: Schedule.Schedule<R2, unknown, B>,
+  <B, R2, A, C>(
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
-  ): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
-  <R, E, R2, B, A, C>(
+  ): <E, R>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
+  <A, E, R, B, R2, C>(
     self: Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>,
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
   ): Stream<C, E, R | R2>
 } = internal.repeatWith
@@ -2855,10 +2855,10 @@ export const repeatWith: {
  * @category utils
  */
 export const retry: {
-  <R2, E, E0 extends E, _>(
-    schedule: Schedule.Schedule<R2, E0, _>
-  ): <R, A>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
-  <R, A, R2, E, E0 extends E, _>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, E0, _>): Stream<A, E, R | R2>
+  <E0 extends E, R2, E, _>(
+    schedule: Schedule.Schedule<_, E0, R2>
+  ): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <A, E, R, _, E0 extends E, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<_, E0, R2>): Stream<A, E, R | R2>
 } = internal.retry
 
 /**
@@ -3313,10 +3313,10 @@ export const scanReduceEffect = internal.scanReduceEffect
  * @category utils
  */
 export const schedule: {
-  <R2, A, A0 extends A, _>(
-    schedule: Schedule.Schedule<R2, A0, _>
-  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
-  <R, E, R2, A, A0 extends A, _>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, A0, _>): Stream<A, E, R | R2>
+  <_, A0 extends A, R2, A>(
+    schedule: Schedule.Schedule<_, A0, R2>
+  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <A, E, R, _, A0 extends A, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<_, A0, R2>): Stream<A, E, R | R2>
 } = internal.schedule
 
 /**
@@ -3328,13 +3328,13 @@ export const schedule: {
  * @category utils
  */
 export const scheduleWith: {
-  <R2, A, A0 extends A, B, C>(
-    schedule: Schedule.Schedule<R2, A0, B>,
+  <B, A0 extends A, R2, A, C>(
+    schedule: Schedule.Schedule<B, A0, R2>,
     options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
-  ): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
-  <R, E, R2, A, A0 extends A, B, C>(
+  ): <E, R>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
+  <A, E, R, B, A0 extends A, R2, C>(
     self: Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, A0, B>,
+    schedule: Schedule.Schedule<B, A0, R2>,
     options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
   ): Stream<C, E, R | R2>
 } = internal.scheduleWith
diff --git a/packages/effect/src/internal/effect/circular.ts b/packages/effect/src/internal/effect/circular.ts
index 02d3c9f27f..dabec29f85 100644
--- a/packages/effect/src/internal/effect/circular.ts
+++ b/packages/effect/src/internal/effect/circular.ts
@@ -375,14 +375,14 @@ export const raceFirst = dual<
 
 /** @internal */
 export const scheduleForked = dual<
-  <R2, Out>(
-    schedule: Schedule.Schedule<R2, unknown, Out>
+  <Out, R2>(
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ) => <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope.Scope>,
-  <A, E, R, R2, Out>(
+  <A, E, R, Out, R2>(
     self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, Out>
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope.Scope>
 >(2, (self, schedule) => pipe(self, _schedule.schedule_Effect(schedule), forkScoped))
 
diff --git a/packages/effect/src/internal/layer.ts b/packages/effect/src/internal/layer.ts
index 691714e6f6..7d28948290 100644
--- a/packages/effect/src/internal/layer.ts
+++ b/packages/effect/src/internal/layer.ts
@@ -770,14 +770,14 @@ export const project = dual<
 
 /** @internal */
 export const retry = dual<
-  <RIn2, E, X>(
-    schedule: Schedule.Schedule<RIn2, E, X>
-  ) => <RIn, ROut>(
+  <X, E, RIn2>(
+    schedule: Schedule.Schedule<X, E, RIn2>
+  ) => <ROut, RIn>(
     self: Layer.Layer<ROut, E, RIn>
   ) => Layer.Layer<ROut, E, RIn | RIn2>,
-  <RIn, E, ROut, RIn2, X>(
+  <ROut, E, RIn, X, RIn2>(
     self: Layer.Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<RIn2, E, X>
+    schedule: Schedule.Schedule<X, E, RIn2>
   ) => Layer.Layer<ROut, E, RIn | RIn2>
 >(2, (self, schedule) =>
   suspend(() => {
@@ -790,10 +790,9 @@ export const retry = dual<
     )
   }))
 
-/** @internal */
-const retryLoop = <RIn, E, ROut, RIn2, X>(
+const retryLoop = <ROut, E, RIn, X, RIn2>(
   self: Layer.Layer<ROut, E, RIn>,
-  schedule: Schedule.Schedule<RIn2, E, X>,
+  schedule: Schedule.Schedule<X, E, RIn2>,
   stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
   state: unknown
 ): Layer.Layer<ROut, E, RIn | RIn2> => {
@@ -808,9 +807,8 @@ const retryLoop = <RIn, E, ROut, RIn2, X>(
   )
 }
 
-/** @internal */
-const retryUpdate = <RIn, E, X>(
-  schedule: Schedule.Schedule<RIn, E, X>,
+const retryUpdate = <X, E, RIn>(
+  schedule: Schedule.Schedule<X, E, RIn>,
   stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
   error: E,
   state: unknown
diff --git a/packages/effect/src/internal/metric/polling.ts b/packages/effect/src/internal/metric/polling.ts
index ef5079436f..9206220cb9 100644
--- a/packages/effect/src/internal/metric/polling.ts
+++ b/packages/effect/src/internal/metric/polling.ts
@@ -64,14 +64,14 @@ export const collectAll = <R, E, Out>(
 
 /** @internal */
 export const launch = dual<
-  <R2, A2>(
-    schedule: Schedule.Schedule<R2, unknown, A2>
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ) => <Type, In, R, E, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
   ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
-  <Type, In, R, E, Out, R2, A2>(
+  <Type, In, R, E, Out, A2, R2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    schedule: Schedule.Schedule<R2, unknown, A2>
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
 >(2, (self, schedule) =>
   pipe(
@@ -92,14 +92,14 @@ export const pollAndUpdate = <Type, In, R, E, Out>(
 
 /** @internal */
 export const retry = dual<
-  <R2, E, _>(
-    policy: Schedule.Schedule<R2, E, _>
+  <_, E, R2>(
+    policy: Schedule.Schedule<_, E, R2>
   ) => <Type, In, R, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
   ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>,
-  <Type, In, R, Out, R2, E, _>(
+  <Type, In, R, E, Out, _, R2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    policy: Schedule.Schedule<R2, E, _>
+    policy: Schedule.Schedule<_, E, R2>
   ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>
 >(2, (self, policy) => ({
   [MetricPollingTypeId]: MetricPollingTypeId,
diff --git a/packages/effect/src/internal/reloadable.ts b/packages/effect/src/internal/reloadable.ts
index f5c003188f..99e980c5cc 100644
--- a/packages/effect/src/internal/reloadable.ts
+++ b/packages/effect/src/internal/reloadable.ts
@@ -25,11 +25,11 @@ const reloadableVariance = {
 }
 
 /** @internal */
-export const auto = <Out extends Context.Tag<any, any>, In, E, R>(
+export const auto = <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly schedule: Schedule.Schedule<R, unknown, unknown>
+    readonly schedule: Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
   _layer.scoped(
@@ -52,11 +52,11 @@ export const auto = <Out extends Context.Tag<any, any>, In, E, R>(
   )
 
 /** @internal */
-export const autoFromConfig = <Out extends Context.Tag<any, any>, In, E, R>(
+export const autoFromConfig = <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
+    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
   _layer.scoped(
diff --git a/packages/effect/src/internal/resource.ts b/packages/effect/src/internal/resource.ts
index c0acc4a1ea..74a21dc314 100644
--- a/packages/effect/src/internal/resource.ts
+++ b/packages/effect/src/internal/resource.ts
@@ -24,9 +24,9 @@ const resourceVariance = {
 }
 
 /** @internal */
-export const auto = <A, E, R, R2, Out>(
+export const auto = <A, E, R, Out, R2>(
   acquire: Effect.Effect<A, E, R>,
-  policy: Schedule.Schedule<R2, unknown, Out>
+  policy: Schedule.Schedule<Out, unknown, R2>
 ): Effect.Effect<Resource.Resource<A, E>, never, R | R2 | Scope.Scope> =>
   core.tap(manual(acquire), (manual) =>
     fiberRuntime.acquireRelease(
diff --git a/packages/effect/src/internal/schedule.ts b/packages/effect/src/internal/schedule.ts
index 524d884549..17aef3a5dd 100644
--- a/packages/effect/src/internal/schedule.ts
+++ b/packages/effect/src/internal/schedule.ts
@@ -45,24 +45,24 @@ export const ScheduleDriverTypeId: Schedule.ScheduleDriverTypeId = Symbol.for(
 
 const scheduleVariance = {
   /* c8 ignore next */
-  _Env: (_: never) => _,
+  _Out: (_: never) => _,
   /* c8 ignore next */
   _In: (_: unknown) => _,
   /* c8 ignore next */
-  _Out: (_: never) => _
+  _R: (_: never) => _
 }
 
 const scheduleDriverVariance = {
   /* c8 ignore next */
-  _Env: (_: never) => _,
+  _Out: (_: never) => _,
   /* c8 ignore next */
   _In: (_: unknown) => _,
   /* c8 ignore next */
-  _Out: (_: never) => _
+  _R: (_: never) => _
 }
 
 /** @internal */
-class ScheduleImpl<S, Env, In, Out> implements Schedule.Schedule<Env, In, Out> {
+class ScheduleImpl<S, Out, In, R> implements Schedule.Schedule<Out, In, R> {
   [ScheduleTypeId] = scheduleVariance
   constructor(
     readonly initial: S,
@@ -70,7 +70,7 @@ class ScheduleImpl<S, Env, In, Out> implements Schedule.Schedule<Env, In, Out> {
       now: number,
       input: In,
       state: S
-    ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, Env>
+    ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, R>
   ) {
   }
   pipe() {
@@ -79,11 +79,11 @@ class ScheduleImpl<S, Env, In, Out> implements Schedule.Schedule<Env, In, Out> {
 }
 
 /** @internal */
-class ScheduleDriverImpl<Env, In, Out> implements Schedule.ScheduleDriver<Env, In, Out> {
+class ScheduleDriverImpl<Out, In, R> implements Schedule.ScheduleDriver<Out, In, R> {
   [ScheduleDriverTypeId] = scheduleDriverVariance
 
   constructor(
-    readonly schedule: Schedule.Schedule<Env, In, Out>,
+    readonly schedule: Schedule.Schedule<Out, In, R>,
     readonly ref: Ref.Ref<readonly [Option.Option<Out>, any]>
   ) {}
 
@@ -108,7 +108,7 @@ class ScheduleDriverImpl<Env, In, Out> implements Schedule.ScheduleDriver<Env, I
     return ref.set(this.ref, [Option.none(), this.schedule.initial])
   }
 
-  next(input: In): Effect.Effect<Out, Option.Option<never>, Env> {
+  next(input: In): Effect.Effect<Out, Option.Option<never>, R> {
     return pipe(
       core.map(ref.get(this.ref), (tuple) => tuple[1]),
       core.flatMap((state) =>
@@ -141,35 +141,35 @@ class ScheduleDriverImpl<Env, In, Out> implements Schedule.ScheduleDriver<Env, I
 }
 
 /** @internal */
-export const makeWithState = <S, Env, In, Out>(
+export const makeWithState = <S, In, Out, R = never>(
   initial: S,
   step: (
     now: number,
     input: In,
     state: S
-  ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, Env>
-): Schedule.Schedule<Env, In, Out> => new ScheduleImpl(initial, step)
+  ) => Effect.Effect<readonly [S, Out, ScheduleDecision.ScheduleDecision], never, R>
+): Schedule.Schedule<Out, In, R> => new ScheduleImpl(initial, step)
 
 /** @internal */
 export const addDelay = dual<
   <Out>(
     f: (out: Out) => Duration.DurationInput
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
     f: (out: Out) => Duration.DurationInput
-  ) => Schedule.Schedule<Env, In, Out>
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) => addDelayEffect(self, (out) => core.sync(() => f(out))))
 
 /** @internal */
 export const addDelayEffect = dual<
-  <Out, Env2>(
-    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <Out, R2>(
+    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<Duration.DurationInput, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) =>
   modifyDelayEffect(self, (out, duration) =>
     core.map(
@@ -179,48 +179,38 @@ export const addDelayEffect = dual<
 
 /** @internal */
 export const andThen = dual<
-  <Env1, In1, Out2>(
-    that: Schedule.Schedule<Env1, In1, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env1,
-    In & In1,
-    Out | Out2
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<
+    Out | Out2,
+    In & In2,
+    R | R2
   >,
-  <Env, In, Out, Env1, In1, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env1, In1, Out2>
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
   ) => Schedule.Schedule<
-    Env | Env1,
-    In & In1,
-    Out | Out2
+    Out | Out2,
+    In & In2,
+    R | R2
   >
 >(2, (self, that) => map(andThenEither(self, that), Either.merge))
 
 /** @internal */
 export const andThenEither = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    Either.Either<Out2, Out>
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    Either.Either<Out2, Out>
-  >
->(2, <Env, In, Out, Env2, In2, Out2>(
-  self: Schedule.Schedule<Env, In, Out>,
-  that: Schedule.Schedule<Env2, In2, Out2>
-): Schedule.Schedule<
-  Env | Env2,
-  In & In2,
-  Either.Either<Out2, Out>
-> =>
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>
+  ) => Schedule.Schedule<Either.Either<Out2, Out>, In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => Schedule.Schedule<Either.Either<Out2, Out>, In & In2, R | R2>
+>(2, <Out, In, R, Out2, In2, R2>(
+  self: Schedule.Schedule<Out, In, R>,
+  that: Schedule.Schedule<Out2, In2, R2>
+): Schedule.Schedule<Either.Either<Out2, Out>, In & In2, R | R2> =>
   makeWithState(
     [self.initial, that.initial, true as boolean] as const,
     (now, input, state) =>
@@ -252,32 +242,26 @@ export const andThenEither = dual<
 
 /** @internal */
 export const as = dual<
-  <Out2>(out: Out2) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out2>,
-  <Env, In, Out, Out2>(self: Schedule.Schedule<Env, In, Out>, out: Out2) => Schedule.Schedule<Env, In, Out2>
+  <Out2>(out: Out2) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out2, In, R>,
+  <Out, In, R, Out2>(self: Schedule.Schedule<Out, In, R>, out: Out2) => Schedule.Schedule<Out2, In, R>
 >(2, (self, out) => map(self, () => out))
 
 /** @internal */
-export const asUnit = <Env, In, Out>(
-  self: Schedule.Schedule<Env, In, Out>
-): Schedule.Schedule<Env, In, void> => map(self, constVoid)
+export const asUnit = <Out, In, R>(
+  self: Schedule.Schedule<Out, In, R>
+): Schedule.Schedule<void, In, R> => map(self, constVoid)
 
 /** @internal */
 export const bothInOut = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    readonly [In, In2],
-    [Out, Out2]
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => Schedule.Schedule<
-    Env | Env2,
-    readonly [In, In2],
-    [Out, Out2]
-  >
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>
+  ) => Schedule.Schedule<[Out, Out2], readonly [In, In2], R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => Schedule.Schedule<[Out, Out2], readonly [In, In2], R | R2>
 >(2, (self, that) =>
   makeWithState([self.initial, that.initial], (now, [in1, in2], state) =>
     core.zipWith(
@@ -300,22 +284,22 @@ export const bothInOut = dual<
 export const check = dual<
   <In, Out>(
     test: (input: In, output: Out) => boolean
-  ) => <Env>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
     test: (input: In, output: Out) => boolean
-  ) => Schedule.Schedule<Env, In, Out>
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, test) => checkEffect(self, (input, out) => core.sync(() => test(input, out))))
 
 /** @internal */
 export const checkEffect = dual<
-  <In, Out, Env2>(
-    test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>
-  ) => <Env>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    test: (input: In, output: Out) => Effect.Effect<boolean, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <In, Out, R2>(
+    test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
+  ) => <R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    test: (input: In, output: Out) => Effect.Effect<boolean, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, test) =>
   makeWithState(
     self.initial,
@@ -331,41 +315,41 @@ export const checkEffect = dual<
       })
   ))
 /** @internal */
-export const collectAllInputs = <A>(): Schedule.Schedule<never, A, Chunk.Chunk<A>> => collectAllOutputs(identity<A>())
+export const collectAllInputs = <A>(): Schedule.Schedule<Chunk.Chunk<A>, A> => collectAllOutputs(identity<A>())
 
 /** @internal */
-export const collectAllOutputs = <Env, In, Out>(
-  self: Schedule.Schedule<Env, In, Out>
-): Schedule.Schedule<Env, In, Chunk.Chunk<Out>> =>
+export const collectAllOutputs = <Out, In, R>(
+  self: Schedule.Schedule<Out, In, R>
+): Schedule.Schedule<Chunk.Chunk<Out>, In, R> =>
   reduce(self, Chunk.empty<Out>(), (outs, out) => pipe(outs, Chunk.append(out)))
 
 /** @internal */
-export const collectUntil = <A>(f: Predicate<A>): Schedule.Schedule<never, A, Chunk.Chunk<A>> =>
+export const collectUntil = <A>(f: Predicate<A>): Schedule.Schedule<Chunk.Chunk<A>, A> =>
   collectAllOutputs(recurUntil(f))
 
 /** @internal */
-export const collectUntilEffect = <Env, A>(
-  f: (a: A) => Effect.Effect<boolean, never, Env>
-): Schedule.Schedule<Env, A, Chunk.Chunk<A>> => collectAllOutputs(recurUntilEffect(f))
+export const collectUntilEffect = <A, R>(
+  f: (a: A) => Effect.Effect<boolean, never, R>
+): Schedule.Schedule<Chunk.Chunk<A>, A, R> => collectAllOutputs(recurUntilEffect(f))
 
 /** @internal */
-export const collectWhile = <A>(f: Predicate<A>): Schedule.Schedule<never, A, Chunk.Chunk<A>> =>
+export const collectWhile = <A>(f: Predicate<A>): Schedule.Schedule<Chunk.Chunk<A>, A> =>
   collectAllOutputs(recurWhile(f))
 
 /** @internal */
-export const collectWhileEffect = <Env, A>(
-  f: (a: A) => Effect.Effect<boolean, never, Env>
-): Schedule.Schedule<Env, A, Chunk.Chunk<A>> => collectAllOutputs(recurWhileEffect(f))
+export const collectWhileEffect = <A, R>(
+  f: (a: A) => Effect.Effect<boolean, never, R>
+): Schedule.Schedule<Chunk.Chunk<A>, A, R> => collectAllOutputs(recurWhileEffect(f))
 
 /** @internal */
 export const compose = dual<
-  <Env2, Out, Out2>(
-    that: Schedule.Schedule<Env2, Out, Out2>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out2>,
-  <Env, In, Out, Env2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, Out, Out2>
-  ) => Schedule.Schedule<Env | Env2, In, Out2>
+  <Out2, Out, R2>(
+    that: Schedule.Schedule<Out2, Out, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out2, In, R | R2>,
+  <Out, In, R, Out2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, Out, R2>
+  ) => Schedule.Schedule<Out2, In, R | R2>
 >(2, (self, that) =>
   makeWithState(
     [self.initial, that.initial] as const,
@@ -390,22 +374,22 @@ export const compose = dual<
 export const mapInput = dual<
   <In, In2>(
     f: (in2: In2) => In
-  ) => <Env, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In2, Out>,
-  <Env, In, Out, In2>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <Out, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In2, R>,
+  <Out, In, R, In2>(
+    self: Schedule.Schedule<Out, In, R>,
     f: (in2: In2) => In
-  ) => Schedule.Schedule<Env, In2, Out>
+  ) => Schedule.Schedule<Out, In2, R>
 >(2, (self, f) => mapInputEffect(self, (input2) => core.sync(() => f(input2))))
 
 /** @internal */
 export const mapInputContext = dual<
-  <Env0, Env>(
-    f: (env0: Context.Context<Env0>) => Context.Context<Env>
-  ) => <In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env0, In, Out>,
-  <Env0, Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (env0: Context.Context<Env0>) => Context.Context<Env>
-  ) => Schedule.Schedule<Env0, In, Out>
+  <R0, R>(
+    f: (env0: Context.Context<R0>) => Context.Context<R>
+  ) => <Out, In>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R0>,
+  <Out, In, R, R0>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (env0: Context.Context<R0>) => Context.Context<R>
+  ) => Schedule.Schedule<Out, In, R0>
 >(2, (self, f) =>
   makeWithState(
     self.initial,
@@ -414,13 +398,13 @@ export const mapInputContext = dual<
 
 /** @internal */
 export const mapInputEffect = dual<
-  <In, Env2, In2>(
-    f: (in2: In2) => Effect.Effect<In, never, Env2>
-  ) => <Env, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In2, Out>,
-  <Env, In, Out, Env2, In2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (in2: In2) => Effect.Effect<In, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In2, Out>
+  <In2, In, R2>(
+    f: (in2: In2) => Effect.Effect<In, never, R2>
+  ) => <Out, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In2, R | R2>,
+  <Out, In, R, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (in2: In2) => Effect.Effect<In, never, R2>
+  ) => Schedule.Schedule<Out, In2, R | R2>
 >(2, (self, f) =>
   makeWithState(self.initial, (now, input2, state) =>
     core.flatMap(
@@ -429,9 +413,9 @@ export const mapInputEffect = dual<
     )))
 
 /** @internal */
-export const cron = (expression: string | Cron.Cron): Schedule.Schedule<never, unknown, [number, number]> => {
+export const cron = (expression: string | Cron.Cron): Schedule.Schedule<[number, number]> => {
   const parsed = Cron.isCron(expression) ? Either.right(expression) : Cron.parse(expression)
-  return makeWithState<[boolean, [number, number, number]], never, unknown, [number, number]>(
+  return makeWithState<[boolean, [number, number, number]], unknown, [number, number]>(
     [true, [Number.MIN_SAFE_INTEGER, 0, 0]],
     (now, _, [initial, previous]) => {
       if (now < previous[0]) {
@@ -470,8 +454,8 @@ export const cron = (expression: string | Cron.Cron): Schedule.Schedule<never, u
 }
 
 /** @internal */
-export const dayOfMonth = (day: number): Schedule.Schedule<never, unknown, number> => {
-  return makeWithState<[number, number], never, unknown, number>(
+export const dayOfMonth = (day: number): Schedule.Schedule<number> => {
+  return makeWithState<[number, number], unknown, number>(
     [Number.NEGATIVE_INFINITY, 0],
     (now, _, state) => {
       if (!Number.isInteger(day) || day < 1 || 31 < day) {
@@ -499,8 +483,8 @@ export const dayOfMonth = (day: number): Schedule.Schedule<never, unknown, numbe
 }
 
 /** @internal */
-export const dayOfWeek = (day: number): Schedule.Schedule<never, unknown, number> => {
-  return makeWithState<[number, number], never, unknown, number>(
+export const dayOfWeek = (day: number): Schedule.Schedule<number> => {
+  return makeWithState<[number, number], unknown, number>(
     [Number.MIN_SAFE_INTEGER, 0],
     (now, _, state) => {
       if (!Number.isInteger(day) || day < 1 || 7 < day) {
@@ -531,33 +515,33 @@ export const dayOfWeek = (day: number): Schedule.Schedule<never, unknown, number
 export const delayed = dual<
   (
     f: (duration: Duration.Duration) => Duration.DurationInput
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
     f: (duration: Duration.Duration) => Duration.DurationInput
-  ) => Schedule.Schedule<Env, In, Out>
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) => delayedEffect(self, (duration) => core.sync(() => f(duration))))
 
 /** @internal */
 export const delayedEffect = dual<
-  <Env2>(
-    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <R2>(
+    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) => modifyDelayEffect(self, (_, delay) => f(delay)))
 
 /** @internal */
-export const delayedSchedule = <Env, In>(
-  schedule: Schedule.Schedule<Env, In, Duration.Duration>
-): Schedule.Schedule<Env, In, Duration.Duration> => addDelay(schedule, (x) => x)
+export const delayedSchedule = <In, R>(
+  schedule: Schedule.Schedule<Duration.Duration, In, R>
+): Schedule.Schedule<Duration.Duration, In, R> => addDelay(schedule, (x) => x)
 
 /** @internal */
-export const delays = <Env, In, Out>(
-  self: Schedule.Schedule<Env, In, Out>
-): Schedule.Schedule<Env, In, Duration.Duration> =>
+export const delays = <Out, In, R>(
+  self: Schedule.Schedule<Out, In, R>
+): Schedule.Schedule<Duration.Duration, In, R> =>
   makeWithState(self.initial, (now, input, state) =>
     pipe(
       self.step(now, input, state),
@@ -579,42 +563,42 @@ export const delays = <Env, In, Out>(
 
 /** @internal */
 export const mapBoth = dual<
-  <In, Out, In2, Out2>(
+  <In2, In, Out, Out2>(
     options: {
       readonly onInput: (in2: In2) => In
       readonly onOutput: (out: Out) => Out2
     }
-  ) => <Env>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In2, Out2>,
-  <Env, In, Out, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out2, In2, R>,
+  <Out, In, R, In2, Out2>(
+    self: Schedule.Schedule<Out, In, R>,
     options: {
       readonly onInput: (in2: In2) => In
       readonly onOutput: (out: Out) => Out2
     }
-  ) => Schedule.Schedule<Env, In2, Out2>
+  ) => Schedule.Schedule<Out2, In2, R>
 >(2, (self, { onInput, onOutput }) => map(mapInput(self, onInput), onOutput))
 
 /** @internal */
 export const mapBothEffect = dual<
-  <In2, Env2, In, Out, Env3, Out2>(
+  <In2, In, R2, Out, R3, Out2>(
     options: {
-      readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>
-      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>
+      readonly onInput: (input: In2) => Effect.Effect<In, never, R2>
+      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>
     }
-  ) => <Env>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2 | Env3, In2, Out2>,
-  <Env, In, Out, In2, Env2, Env3, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out2, In2, R | R2 | R3>,
+  <Out, In, R, In2, R2, Out2, R3>(
+    self: Schedule.Schedule<Out, In, R>,
     options: {
-      readonly onInput: (input: In2) => Effect.Effect<In, never, Env2>
-      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, Env3>
+      readonly onInput: (input: In2) => Effect.Effect<In, never, R2>
+      readonly onOutput: (out: Out) => Effect.Effect<Out2, never, R3>
     }
-  ) => Schedule.Schedule<Env | Env2 | Env3, In2, Out2>
+  ) => Schedule.Schedule<Out2, In2, R | R2 | R3>
 >(2, (self, { onInput, onOutput }) => mapEffect(mapInputEffect(self, onInput), onOutput))
 
 /** @internal */
-export const driver = <Env, In, Out>(
-  self: Schedule.Schedule<Env, In, Out>
-): Effect.Effect<Schedule.ScheduleDriver<Env, In, Out>> =>
+export const driver = <Out, In, R>(
+  self: Schedule.Schedule<Out, In, R>
+): Effect.Effect<Schedule.ScheduleDriver<Out, In, R>> =>
   pipe(
     ref.make<readonly [Option.Option<Out>, any]>([Option.none(), self.initial]),
     core.map((ref) => new ScheduleDriverImpl(self, ref))
@@ -623,7 +607,7 @@ export const driver = <Env, In, Out>(
 /** @internal */
 export const duration = (
   durationInput: Duration.DurationInput
-): Schedule.Schedule<never, unknown, Duration.Duration> => {
+): Schedule.Schedule<Duration.Duration> => {
   const duration = Duration.decode(durationInput)
   const durationMillis = Duration.toMillis(duration)
   return makeWithState(true as boolean, (now, _, state) =>
@@ -640,53 +624,37 @@ export const duration = (
 
 /** @internal */
 export const either = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>
 >(2, (self, that) => union(self, that))
 
 /** @internal */
 export const eitherWith = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >
+  ) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>
 >(3, (self, that, f) => unionWith(self, that, f))
 
 /** @internal */
 export const ensuring = dual<
   <X>(
     finalizer: Effect.Effect<X>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out, X>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R, X>(
+    self: Schedule.Schedule<Out, In, R>,
     finalizer: Effect.Effect<X>
-  ) => Schedule.Schedule<Env, In, Out>
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, finalizer) =>
   makeWithState(
     self.initial,
@@ -701,13 +669,13 @@ export const ensuring = dual<
 export const exponential = (
   baseInput: Duration.DurationInput,
   factor = 2.0
-): Schedule.Schedule<never, unknown, Duration.Duration> => {
+): Schedule.Schedule<Duration.Duration> => {
   const base = Duration.decode(baseInput)
   return delayedSchedule(map(forever, (i) => Duration.times(base, Math.pow(factor, i))))
 }
 
 /** @internal */
-export const fibonacci = (oneInput: Duration.DurationInput): Schedule.Schedule<never, unknown, Duration.Duration> => {
+export const fibonacci = (oneInput: Duration.DurationInput): Schedule.Schedule<Duration.Duration> => {
   const one = Duration.decode(oneInput)
   return delayedSchedule(
     pipe(
@@ -721,10 +689,10 @@ export const fibonacci = (oneInput: Duration.DurationInput): Schedule.Schedule<n
 }
 
 /** @internal */
-export const fixed = (intervalInput: Duration.DurationInput): Schedule.Schedule<never, unknown, number> => {
+export const fixed = (intervalInput: Duration.DurationInput): Schedule.Schedule<number> => {
   const interval = Duration.decode(intervalInput)
   const intervalMillis = Duration.toMillis(interval)
-  return makeWithState<[Option.Option<[number, number]>, number], never, unknown, number>(
+  return makeWithState<[Option.Option<[number, number]>, number], unknown, number>(
     [Option.none(), 0],
     (now, _, [option, n]) =>
       core.sync(() => {
@@ -756,14 +724,13 @@ export const fixed = (intervalInput: Duration.DurationInput): Schedule.Schedule<
 }
 
 /** @internal */
-export const fromDelay = (delay: Duration.DurationInput): Schedule.Schedule<never, unknown, Duration.Duration> =>
-  duration(delay)
+export const fromDelay = (delay: Duration.DurationInput): Schedule.Schedule<Duration.Duration> => duration(delay)
 
 /** @internal */
 export const fromDelays = (
   delay: Duration.DurationInput,
   ...delays: Array<Duration.DurationInput>
-): Schedule.Schedule<never, unknown, Duration.Duration> =>
+): Schedule.Schedule<Duration.Duration> =>
   makeWithState(
     [[delay, ...delays].map((_) => Duration.decode(_)) as Array<Duration.Duration>, true as boolean] as const,
     (now, _, [durations, cont]) =>
@@ -790,11 +757,11 @@ export const fromDelays = (
   )
 
 /** @internal */
-export const fromFunction = <A, B>(f: (a: A) => B): Schedule.Schedule<never, A, B> => map(identity<A>(), f)
+export const fromFunction = <A, B>(f: (a: A) => B): Schedule.Schedule<B, A> => map(identity<A>(), f)
 
 /** @internal */
-export const hourOfDay = (hour: number): Schedule.Schedule<never, unknown, number> =>
-  makeWithState<[number, number], never, unknown, number>(
+export const hourOfDay = (hour: number): Schedule.Schedule<number> =>
+  makeWithState<[number, number], unknown, number>(
     [Number.NEGATIVE_INFINITY, 0],
     (now, _, state) => {
       if (!Number.isInteger(hour) || hour < 0 || 23 < hour) {
@@ -821,7 +788,7 @@ export const hourOfDay = (hour: number): Schedule.Schedule<never, unknown, numbe
   )
 
 /** @internal */
-export const identity = <A>(): Schedule.Schedule<never, A, A> =>
+export const identity = <A>(): Schedule.Schedule<A, A> =>
   makeWithState(void 0, (now, input, state) =>
     core.succeed(
       [
@@ -833,52 +800,32 @@ export const identity = <A>(): Schedule.Schedule<never, A, A> =>
 
 /** @internal */
 export const intersect = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>
 >(2, (self, that) => intersectWith(self, that, Intervals.intersect))
 
 /** @internal */
 export const intersectWith = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >
+  ) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>
 >(3, <Env, In, Out, Env2, In2, Out2>(
-  self: Schedule.Schedule<Env, In, Out>,
-  that: Schedule.Schedule<Env2, In2, Out2>,
+  self: Schedule.Schedule<Out, In, Env>,
+  that: Schedule.Schedule<Out2, In2, Env2>,
   f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-): Schedule.Schedule<
-  Env | Env2,
-  In & In2,
-  [Out, Out2]
-> =>
-  makeWithState<[any, any], Env | Env2, In & In2, [Out, Out2]>(
+): Schedule.Schedule<[Out, Out2], In & In2, Env | Env2> =>
+  makeWithState<[any, any], In & In2, [Out, Out2], Env | Env2>(
     [self.initial, that.initial],
     (now, input: In & In2, state) =>
       pipe(
@@ -918,8 +865,8 @@ export const intersectWith = dual<
 
 /** @internal */
 const intersectWithLoop = <State, State1, Env, In, Out, Env1, In1, Out2>(
-  self: Schedule.Schedule<Env, In, Out>,
-  that: Schedule.Schedule<Env1, In1, Out2>,
+  self: Schedule.Schedule<Out, In, Env>,
+  that: Schedule.Schedule<Out2, In1, Env1>,
   input: In & In1,
   lState: State,
   out: Out,
@@ -989,18 +936,18 @@ const intersectWithLoop = <State, State1, Env, In, Out, Env1, In1, Out2>(
 }
 
 /** @internal */
-export const jittered = <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>): Schedule.Schedule<Env, In, Out> =>
+export const jittered = <Out, In, R>(self: Schedule.Schedule<Out, In, R>): Schedule.Schedule<Out, In, R> =>
   jitteredWith(self, { min: 0.8, max: 1.2 })
 
 /** @internal */
 export const jitteredWith = dual<
-  (options: { min?: number; max?: number }) => <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>
-  ) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
-    options: { min?: number; max?: number }
-  ) => Schedule.Schedule<Env, In, Out>
+  (options: { min?: number | undefined; max?: number | undefined }) => <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>
+  ) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
+    options: { min?: number | undefined; max?: number | undefined }
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, options) => {
   const { max, min } = Object.assign({ min: 0.8, max: 1.2 }, options)
   return delayedEffect(self, (duration) =>
@@ -1012,7 +959,7 @@ export const jitteredWith = dual<
 })
 
 /** @internal */
-export const linear = (baseInput: Duration.DurationInput): Schedule.Schedule<never, unknown, Duration.Duration> => {
+export const linear = (baseInput: Duration.DurationInput): Schedule.Schedule<Duration.Duration> => {
   const base = Duration.decode(baseInput)
   return delayedSchedule(map(forever, (i) => Duration.times(base, i + 1)))
 }
@@ -1021,22 +968,22 @@ export const linear = (baseInput: Duration.DurationInput): Schedule.Schedule<nev
 export const map = dual<
   <Out, Out2>(
     f: (out: Out) => Out2
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out2>,
-  <Env, In, Out, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out2, In, R>,
+  <Out, In, R, Out2>(
+    self: Schedule.Schedule<Out, In, R>,
     f: (out: Out) => Out2
-  ) => Schedule.Schedule<Env, In, Out2>
+  ) => Schedule.Schedule<Out2, In, R>
 >(2, (self, f) => mapEffect(self, (out) => core.sync(() => f(out))))
 
 /** @internal */
 export const mapEffect = dual<
-  <Out, Env2, Out2>(
-    f: (out: Out) => Effect.Effect<Out2, never, Env2>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out2>,
-  <Env, In, Out, Env2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<Out2, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out2>
+  <Out, Out2, R2>(
+    f: (out: Out) => Effect.Effect<Out2, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out2, In, R | R2>,
+  <Out, In, R, Out2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<Out2, never, R2>
+  ) => Schedule.Schedule<Out2, In, R | R2>
 >(2, (self, f) =>
   makeWithState(
     self.initial,
@@ -1049,8 +996,8 @@ export const mapEffect = dual<
   ))
 
 /** @internal */
-export const minuteOfHour = (minute: number): Schedule.Schedule<never, unknown, number> =>
-  makeWithState<[number, number], never, unknown, number>(
+export const minuteOfHour = (minute: number): Schedule.Schedule<number> =>
+  makeWithState<[number, number], unknown, number>(
     [Number.MIN_SAFE_INTEGER, 0],
     (now, _, state) => {
       if (!Number.isInteger(minute) || minute < 0 || 59 < minute) {
@@ -1080,22 +1027,22 @@ export const minuteOfHour = (minute: number): Schedule.Schedule<never, unknown,
 export const modifyDelay = dual<
   <Out>(
     f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
     f: (out: Out, duration: Duration.Duration) => Duration.DurationInput
-  ) => Schedule.Schedule<Env, In, Out>
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.sync(() => f(out, duration))))
 
 /** @internal */
 export const modifyDelayEffect = dual<
-  <Out, Env2>(
-    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <Out, R2>(
+    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: Out, duration: Duration.Duration) => Effect.Effect<Duration.DurationInput, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) =>
   makeWithState(
     self.initial,
@@ -1120,13 +1067,13 @@ export const modifyDelayEffect = dual<
 
 /** @internal */
 export const onDecision = dual<
-  <Out, Env2, X>(
-    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2, X>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <Out, X, R2>(
+    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, X, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect<X, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) =>
   makeWithState(
     self.initial,
@@ -1138,9 +1085,9 @@ export const onDecision = dual<
   ))
 
 /** @internal */
-export const passthrough = <Env, Input, Output>(
-  self: Schedule.Schedule<Env, Input, Output>
-): Schedule.Schedule<Env, Input, Input> =>
+export const passthrough = <Out, In, R>(
+  self: Schedule.Schedule<Out, In, R>
+): Schedule.Schedule<In, In, R> =>
   makeWithState(self.initial, (now, input, state) =>
     pipe(
       self.step(now, input, state),
@@ -1149,13 +1096,13 @@ export const passthrough = <Env, Input, Output>(
 
 /** @internal */
 export const provideContext = dual<
-  <Env>(
-    context: Context.Context<Env>
-  ) => <In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<never, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
-    context: Context.Context<Env>
-  ) => Schedule.Schedule<never, In, Out>
+  <R>(
+    context: Context.Context<R>
+  ) => <Out, In>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
+    context: Context.Context<R>
+  ) => Schedule.Schedule<Out, In>
 >(2, (self, context) =>
   makeWithState(self.initial, (now, input, state) =>
     core.provideContext(
@@ -1168,19 +1115,19 @@ export const provideService = dual<
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ) => <R, In, Out>(
-    self: Schedule.Schedule<R, In, Out>
-  ) => Schedule.Schedule<Exclude<R, Context.Tag.Identifier<T>>, In, Out>,
-  <R, In, Out, T extends Context.Tag<any, any>>(
-    self: Schedule.Schedule<R, In, Out>,
+  ) => <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>
+  ) => Schedule.Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>,
+  <Out, In, R, T extends Context.Tag<any, any>>(
+    self: Schedule.Schedule<Out, In, R>,
     tag: T,
     service: Context.Tag.Service<T>
-  ) => Schedule.Schedule<Exclude<R, Context.Tag.Identifier<T>>, In, Out>
->(3, <R, In, Out, T extends Context.Tag<any, any>>(
-  self: Schedule.Schedule<R, In, Out>,
+  ) => Schedule.Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>
+>(3, <Out, In, R, T extends Context.Tag<any, any>>(
+  self: Schedule.Schedule<Out, In, R>,
   tag: T,
   service: Context.Tag.Service<T>
-): Schedule.Schedule<Exclude<R, Context.Tag.Identifier<T>>, In, Out> =>
+): Schedule.Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>> =>
   makeWithState(self.initial, (now, input, state) =>
     core.contextWithEffect((env) =>
       core.provideContext(
@@ -1191,60 +1138,60 @@ export const provideService = dual<
     )))
 
 /** @internal */
-export const recurUntil = <A>(f: Predicate<A>): Schedule.Schedule<never, A, A> => untilInput(identity<A>(), f)
+export const recurUntil = <A>(f: Predicate<A>): Schedule.Schedule<A, A> => untilInput(identity<A>(), f)
 
 /** @internal */
-export const recurUntilEffect = <Env, A>(
-  f: (a: A) => Effect.Effect<boolean, never, Env>
-): Schedule.Schedule<Env, A, A> => untilInputEffect(identity<A>(), f)
+export const recurUntilEffect = <A, R>(
+  f: (a: A) => Effect.Effect<boolean, never, R>
+): Schedule.Schedule<A, A, R> => untilInputEffect(identity<A>(), f)
 
 /** @internal */
-export const recurUntilOption = <A, B>(pf: (a: A) => Option.Option<B>): Schedule.Schedule<never, A, Option.Option<B>> =>
+export const recurUntilOption = <A, B>(pf: (a: A) => Option.Option<B>): Schedule.Schedule<Option.Option<B>, A> =>
   untilOutput(map(identity<A>(), pf), Option.isSome)
 
 /** @internal */
 export const recurUpTo = (
   durationInput: Duration.DurationInput
-): Schedule.Schedule<never, unknown, Duration.Duration> => {
+): Schedule.Schedule<Duration.Duration> => {
   const duration = Duration.decode(durationInput)
   return whileOutput(elapsed, (elapsed) => Duration.lessThan(elapsed, duration))
 }
 
 /** @internal */
-export const recurWhile = <A>(f: Predicate<A>): Schedule.Schedule<never, A, A> => whileInput(identity<A>(), f)
+export const recurWhile = <A>(f: Predicate<A>): Schedule.Schedule<A, A> => whileInput(identity<A>(), f)
 
 /** @internal */
-export const recurWhileEffect = <Env, A>(
-  f: (a: A) => Effect.Effect<boolean, never, Env>
-): Schedule.Schedule<Env, A, A> => whileInputEffect(identity<A>(), f)
+export const recurWhileEffect = <A, R>(
+  f: (a: A) => Effect.Effect<boolean, never, R>
+): Schedule.Schedule<A, A, R> => whileInputEffect(identity<A>(), f)
 
 /** @internal */
-export const recurs = (n: number): Schedule.Schedule<never, unknown, number> => whileOutput(forever, (out) => out < n)
+export const recurs = (n: number): Schedule.Schedule<number> => whileOutput(forever, (out) => out < n)
 
 /** @internal */
 export const reduce = dual<
   <Out, Z>(
     zero: Z,
     f: (z: Z, out: Out) => Z
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Z>,
-  <Env, In, Out, Z>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Z, In, R>,
+  <Out, In, R, Z>(
+    self: Schedule.Schedule<Out, In, R>,
     zero: Z,
     f: (z: Z, out: Out) => Z
-  ) => Schedule.Schedule<Env, In, Z>
+  ) => Schedule.Schedule<Z, In, R>
 >(3, (self, zero, f) => reduceEffect(self, zero, (z, out) => core.sync(() => f(z, out))))
 
 /** @internal */
 export const reduceEffect = dual<
-  <Out, Env1, Z>(
+  <Z, Out, R2>(
     zero: Z,
-    f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env1, In, Z>,
-  <Env, In, Out, Env1, Z>(
-    self: Schedule.Schedule<Env, In, Out>,
+    f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Z, In, R | R2>,
+  <Out, In, R, Z, R2>(
+    self: Schedule.Schedule<Out, In, R>,
     zero: Z,
-    f: (z: Z, out: Out) => Effect.Effect<Z, never, Env1>
-  ) => Schedule.Schedule<Env | Env1, In, Z>
+    f: (z: Z, out: Out) => Effect.Effect<Z, never, R2>
+  ) => Schedule.Schedule<Z, In, R | R2>
 >(3, (self, zero, f) =>
   makeWithState(
     [self.initial, zero] as const,
@@ -1256,7 +1203,7 @@ export const reduceEffect = dual<
   ))
 
 /** @internal */
-export const repeatForever = <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>): Schedule.Schedule<Env, In, Out> =>
+export const repeatForever = <Env, In, Out>(self: Schedule.Schedule<Out, In, Env>): Schedule.Schedule<Out, In, Env> =>
   makeWithState(self.initial, (now, input, state) => {
     const step = (
       now: number,
@@ -1274,20 +1221,20 @@ export const repeatForever = <Env, In, Out>(self: Schedule.Schedule<Env, In, Out
   })
 
 /** @internal */
-export const repetitions = <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>): Schedule.Schedule<Env, In, number> =>
+export const repetitions = <Out, In, R>(self: Schedule.Schedule<Out, In, R>): Schedule.Schedule<number, In, R> =>
   reduce(self, 0, (n, _) => n + 1)
 
 /** @internal */
 export const resetAfter = dual<
   (
     duration: Duration.DurationInput
-  ) => <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>
-  ) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>
+  ) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
     duration: Duration.DurationInput
-  ) => Schedule.Schedule<Env, In, Out>
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, durationInput) => {
   const duration = Duration.decode(durationInput)
   return pipe(
@@ -1300,8 +1247,8 @@ export const resetAfter = dual<
 
 /** @internal */
 export const resetWhen = dual<
-  <Out>(f: Predicate<Out>) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>, f: Predicate<Out>) => Schedule.Schedule<Env, In, Out>
+  <Out>(f: Predicate<Out>) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(self: Schedule.Schedule<Out, In, R>, f: Predicate<Out>) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) =>
   makeWithState(
     self.initial,
@@ -1317,12 +1264,12 @@ export const run = dual<
   <In>(
     now: number,
     input: Iterable<In>
-  ) => <Env, Out>(self: Schedule.Schedule<Env, In, Out>) => Effect.Effect<Chunk.Chunk<Out>, never, Env>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
+  ) => <Out, R>(self: Schedule.Schedule<Out, In, R>) => Effect.Effect<Chunk.Chunk<Out>, never, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
     now: number,
     input: Iterable<In>
-  ) => Effect.Effect<Chunk.Chunk<Out>, never, Env>
+  ) => Effect.Effect<Chunk.Chunk<Out>, never, R>
 >(3, (self, now, input) =>
   pipe(
     runLoop(self, now, Chunk.fromIterable(input), self.initial, Chunk.empty()),
@@ -1331,7 +1278,7 @@ export const run = dual<
 
 /** @internal */
 const runLoop = <Env, In, Out>(
-  self: Schedule.Schedule<Env, In, Out>,
+  self: Schedule.Schedule<Out, In, Env>,
   now: number,
   inputs: Chunk.Chunk<In>,
   state: any,
@@ -1357,8 +1304,8 @@ const runLoop = <Env, In, Out>(
 }
 
 /** @internal */
-export const secondOfMinute = (second: number): Schedule.Schedule<never, unknown, number> =>
-  makeWithState<[number, number], never, unknown, number>(
+export const secondOfMinute = (second: number): Schedule.Schedule<number> =>
+  makeWithState<[number, number], unknown, number>(
     [Number.NEGATIVE_INFINITY, 0],
     (now, _, state) => {
       if (!Number.isInteger(second) || second < 0 || 59 < second) {
@@ -1385,24 +1332,23 @@ export const secondOfMinute = (second: number): Schedule.Schedule<never, unknown
   )
 
 /** @internal */
-export const spaced = (duration: Duration.DurationInput): Schedule.Schedule<never, unknown, number> =>
-  addDelay(forever, () => duration)
+export const spaced = (duration: Duration.DurationInput): Schedule.Schedule<number> => addDelay(forever, () => duration)
 
 /** @internal */
-export const succeed = <A>(value: A): Schedule.Schedule<never, unknown, A> => map(forever, () => value)
+export const succeed = <A>(value: A): Schedule.Schedule<A> => map(forever, () => value)
 
 /** @internal */
-export const sync = <A>(evaluate: LazyArg<A>): Schedule.Schedule<never, unknown, A> => map(forever, evaluate)
+export const sync = <A>(evaluate: LazyArg<A>): Schedule.Schedule<A> => map(forever, evaluate)
 
 /** @internal */
 export const tapInput = dual<
-  <Env2, In2, X>(
-    f: (input: In2) => Effect.Effect<X, never, Env2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In & In2, Out>,
-  <Env, In, Out, Env2, In2, X>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (input: In2) => Effect.Effect<X, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In & In2, Out>
+  <In2, X, R2>(
+    f: (input: In2) => Effect.Effect<X, never, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In & In2, R | R2>,
+  <Out, In, R, In2, X, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (input: In2) => Effect.Effect<X, never, R2>
+  ) => Schedule.Schedule<Out, In & In2, R | R2>
 >(2, (self, f) =>
   makeWithState(self.initial, (now, input, state) =>
     core.zipRight(
@@ -1412,13 +1358,13 @@ export const tapInput = dual<
 
 /** @internal */
 export const tapOutput = dual<
-  <Out, XO extends Out, Env2, X>(
-    f: (out: XO) => Effect.Effect<X, never, Env2>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, XO extends Out, Env2, X>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (out: XO) => Effect.Effect<X, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <XO extends Out, X, R2, Out>(
+    f: (out: XO) => Effect.Effect<X, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, XO extends Out, X, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: XO) => Effect.Effect<X, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) =>
   makeWithState(self.initial, (now, input, state) =>
     core.tap(
@@ -1427,7 +1373,7 @@ export const tapOutput = dual<
     )))
 
 /** @internal */
-export const unfold = <A>(initial: A, f: (a: A) => A): Schedule.Schedule<never, unknown, A> =>
+export const unfold = <A>(initial: A, f: (a: A) => A): Schedule.Schedule<A> =>
   makeWithState(initial, (now, _, state) =>
     core.sync(() =>
       [
@@ -1439,42 +1385,26 @@ export const unfold = <A>(initial: A, f: (a: A) => A): Schedule.Schedule<never,
 
 /** @internal */
 export const union = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>
 >(2, (self, that) => unionWith(self, that, Intervals.union))
 
 /** @internal */
 export const unionWith = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals
-  ) => Schedule.Schedule<
-    Env | Env2,
-    In & In2,
-    [Out, Out2]
-  >
+  ) => Schedule.Schedule<[Out, Out2], In & In2, R | R2>
 >(3, (self, that, f) =>
   makeWithState([self.initial, that.initial], (now, input, state) =>
     core.zipWith(
@@ -1514,88 +1444,88 @@ export const unionWith = dual<
 
 /** @internal */
 export const untilInput = dual<
-  <In>(f: Predicate<In>) => <Env, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>, f: Predicate<In>) => Schedule.Schedule<Env, In, Out>
+  <In>(f: Predicate<In>) => <Out, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(self: Schedule.Schedule<Out, In, R>, f: Predicate<In>) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) => check(self, (input, _) => !f(input)))
 
 /** @internal */
 export const untilInputEffect = dual<
-  <In, Env2>(
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ) => <Env, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <In, R2>(
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ) => <Out, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) => checkEffect(self, (input, _) => effect.negate(f(input))))
 
 /** @internal */
 export const untilOutput = dual<
-  <Out>(f: Predicate<Out>) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>, f: Predicate<Out>) => Schedule.Schedule<Env, In, Out>
+  <Out>(f: Predicate<Out>) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(self: Schedule.Schedule<Out, In, R>, f: Predicate<Out>) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) => check(self, (_, out) => !f(out)))
 
 /** @internal */
 export const untilOutputEffect = dual<
-  <Out, Env2>(
-    f: (out: Out) => Effect.Effect<boolean, never, Env2>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<boolean, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <Out, R2>(
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) => checkEffect(self, (_, out) => effect.negate(f(out))))
 
 /** @internal */
 export const upTo = dual<
-  (duration: Duration.DurationInput) => <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>
-  ) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(
-    self: Schedule.Schedule<Env, In, Out>,
+  (duration: Duration.DurationInput) => <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>
+  ) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(
+    self: Schedule.Schedule<Out, In, R>,
     duration: Duration.DurationInput
-  ) => Schedule.Schedule<Env, In, Out>
+  ) => Schedule.Schedule<Out, In, R>
 >(2, (self, duration) => zipLeft(self, recurUpTo(duration)))
 
 /** @internal */
 export const whileInput = dual<
-  <In>(f: Predicate<In>) => <Env, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>, f: Predicate<In>) => Schedule.Schedule<Env, In, Out>
+  <In>(f: Predicate<In>) => <Out, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(self: Schedule.Schedule<Out, In, R>, f: Predicate<In>) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) => check(self, (input, _) => f(input)))
 
 /** @internal */
 export const whileInputEffect = dual<
-  <In, Env2>(
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ) => <Env, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In, Out>,
-  <Env, In, Out, Env2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (input: In) => Effect.Effect<boolean, never, Env2>
-  ) => Schedule.Schedule<Env | Env2, In, Out>
+  <In, R2>(
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ) => <Out, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (input: In) => Effect.Effect<boolean, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) => checkEffect(self, (input, _) => f(input)))
 
 /** @internal */
 export const whileOutput = dual<
-  <Out>(f: Predicate<Out>) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env, In, Out>,
-  <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>, f: Predicate<Out>) => Schedule.Schedule<Env, In, Out>
+  <Out>(f: Predicate<Out>) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R>,
+  <Out, In, R>(self: Schedule.Schedule<Out, In, R>, f: Predicate<Out>) => Schedule.Schedule<Out, In, R>
 >(2, (self, f) => check(self, (_, out) => f(out)))
 
 /** @internal */
 export const whileOutputEffect = dual<
-  <Out, Env1>(
-    f: (out: Out) => Effect.Effect<boolean, never, Env1>
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env1, In, Out>,
-  <Env, In, Out, Env1>(
-    self: Schedule.Schedule<Env, In, Out>,
-    f: (out: Out) => Effect.Effect<boolean, never, Env1>
-  ) => Schedule.Schedule<Env | Env1, In, Out>
+  <Out, R2>(
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R | R2>,
+  <Out, In, R, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<boolean, never, R2>
+  ) => Schedule.Schedule<Out, In, R | R2>
 >(2, (self, f) => checkEffect(self, (_, out) => f(out)))
 
 /** @internal */
-export const windowed = (intervalInput: Duration.DurationInput): Schedule.Schedule<never, unknown, number> => {
+export const windowed = (intervalInput: Duration.DurationInput): Schedule.Schedule<number> => {
   const interval = Duration.decode(intervalInput)
   const millis = Duration.toMillis(interval)
-  return makeWithState<[Option.Option<number>, number], never, unknown, number>(
+  return makeWithState<[Option.Option<number>, number], unknown, number>(
     [Option.none(), 0],
     (now, _, [option, n]) => {
       switch (option._tag) {
@@ -1626,37 +1556,37 @@ export const windowed = (intervalInput: Duration.DurationInput): Schedule.Schedu
 
 /** @internal */
 export const zipLeft = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In & In2, Out>,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => Schedule.Schedule<Env | Env2, In & In2, Out>
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => Schedule.Schedule<Out, In & In2, R | R2>
 >(2, (self, that) => map(intersect(self, that), (out) => out[0]))
 
 /** @internal */
 export const zipRight = dual<
-  <Env2, In2, Out2>(
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => <Env, In, Out>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In & In2, Out2>,
-  <Env, In, Out, Env2, In2, Out2>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>
-  ) => Schedule.Schedule<Env | Env2, In & In2, Out2>
+  <Out2, In2, R2>(
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => <Out, In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out2, In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>
+  ) => Schedule.Schedule<Out2, In & In2, R | R2>
 >(2, (self, that) => map(intersect(self, that), (out) => out[1]))
 
 /** @internal */
 export const zipWith = dual<
-  <Env2, In2, Out2, Out, Out3>(
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  <Out2, In2, R2, Out, Out3>(
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (out: Out, out2: Out2) => Out3
-  ) => <Env, In>(self: Schedule.Schedule<Env, In, Out>) => Schedule.Schedule<Env | Env2, In & In2, Out3>,
-  <Env, In, Out, Env2, In2, Out2, Out3>(
-    self: Schedule.Schedule<Env, In, Out>,
-    that: Schedule.Schedule<Env2, In2, Out2>,
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out3, In & In2, R | R2>,
+  <Out, In, R, Out2, In2, R2, Out3>(
+    self: Schedule.Schedule<Out, In, R>,
+    that: Schedule.Schedule<Out2, In2, R2>,
     f: (out: Out, out2: Out2) => Out3
-  ) => Schedule.Schedule<Env | Env2, In & In2, Out3>
+  ) => Schedule.Schedule<Out3, In & In2, R | R2>
 >(3, (self, that, f) => map(intersect(self, that), ([out, out2]) => f(out, out2)))
 
 // -----------------------------------------------------------------------------
@@ -1860,30 +1790,30 @@ const scheduleDefectRefail = <A, E, R>(self: Effect.Effect<A, E, R>) =>
 /** @internal */
 export const repeat_Effect = dual<
   <R1, A, B>(
-    schedule: Schedule.Schedule<R1, A, B>
+    schedule: Schedule.Schedule<B, A, R1>
   ) => <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R | R1>,
   <A, E, R, R1, B>(
     self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<R1, A, B>
+    schedule: Schedule.Schedule<B, A, R1>
   ) => Effect.Effect<B, E, R | R1>
 >(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail(e)))
 
 /** @internal */
 export const repeat_combined = dual<{
-  <A, O extends Effect.Repeat.Options<A>>(
+  <O extends Effect.Repeat.Options<A>, A>(
     options: O
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Repeat.Return<R, E, A, O>
-  <R1, A, B>(
-    schedule: Schedule.Schedule<R1, A, B>
+  <B, A, R1>(
+    schedule: Schedule.Schedule<B, A, R1>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R | R1>
 }, {
   <A, E, R, O extends Effect.Repeat.Options<A>>(
     self: Effect.Effect<A, E, R>,
     options: O
   ): Effect.Repeat.Return<R, E, A, O>
-  <A, E, R, R1, B>(
+  <A, E, R, B, R1>(
     self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<R1, A, B>
+    schedule: Schedule.Schedule<B, A, R1>
   ): Effect.Effect<B, E, R | R1>
 }>(
   2,
@@ -1922,12 +1852,12 @@ export const repeat_combined = dual<{
 /** @internal */
 export const repeatOrElse_Effect = dual<
   <R2, A, B, E, E2, R3>(
-    schedule: Schedule.Schedule<R2, A, B>,
+    schedule: Schedule.Schedule<B, A, R2>,
     orElse: (error: E, option: Option.Option<B>) => Effect.Effect<B, E2, R3>
   ) => <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2, R | R2 | R3>,
   <A, E, R, R2, B, E2, R3>(
     self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, A, B>,
+    schedule: Schedule.Schedule<B, A, R2>,
     orElse: (error: E, option: Option.Option<B>) => Effect.Effect<B, E2, R3>
   ) => Effect.Effect<B, E2, R | R2 | R3>
 >(3, (self, schedule, orElse) =>
@@ -1940,7 +1870,7 @@ export const repeatOrElse_Effect = dual<
 /** @internal */
 const repeatOrElseEffectLoop = <A, E, R, R1, B, C, E2, R2>(
   self: Effect.Effect<A, E, R>,
-  driver: Schedule.ScheduleDriver<R1, A, B>,
+  driver: Schedule.ScheduleDriver<B, A, R1>,
   orElse: (error: E, option: Option.Option<B>) => Effect.Effect<C, E2, R2>,
   value: A
 ): Effect.Effect<B | C, E2, R | R1 | R2> => {
@@ -1957,11 +1887,11 @@ const repeatOrElseEffectLoop = <A, E, R, R1, B, C, E2, R2>(
 /** @internal */
 export const retry_Effect = dual<
   <R1, E, B>(
-    policy: Schedule.Schedule<R1, E, B>
+    policy: Schedule.Schedule<B, E, R1>
   ) => <R, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | R1>,
   <A, E, R, R1, B>(
     self: Effect.Effect<A, E, R>,
-    policy: Schedule.Schedule<R1, E, B>
+    policy: Schedule.Schedule<B, E, R1>
   ) => Effect.Effect<A, E, R | R1>
 >(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail(e)))
 
@@ -1972,16 +1902,16 @@ export const retry_combined: {
   ): <A, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Retry.Return<R, E, A, O>
-  <R1, E, B>(
-    policy: Schedule.Schedule<R1, Types.NoInfer<E>, B>
+  <B, E, R1>(
+    policy: Schedule.Schedule<B, Types.NoInfer<E>, R1>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R1 | R>
   <A, E, R, O extends Effect.Retry.Options<E>>(
     self: Effect.Effect<A, E, R>,
     options: O
   ): Effect.Retry.Return<R, E, A, O>
-  <R, E, A, R1, B>(
+  <A, E, R, B, R1>(
     self: Effect.Effect<A, E, R>,
-    policy: Schedule.Schedule<R1, E, B>
+    policy: Schedule.Schedule<B, E, R1>
   ): Effect.Effect<A, E, R1 | R>
 } = dual(
   2,
@@ -2018,13 +1948,13 @@ export const retry_combined: {
 
 /** @internal */
 export const retryOrElse_Effect = dual<
-  <R1, E, A1, A2, E2, R2>(
-    policy: Schedule.Schedule<R1, Types.NoInfer<E>, A1>,
+  <A1, E, R1, A2, E2, R2>(
+    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
     orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E | E2, R | R1 | R2>,
   <A, E, R, A1, R1, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    policy: Schedule.Schedule<R1, Types.NoInfer<E>, A1>,
+    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
     orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => Effect.Effect<A | A2, E | E2, R | R1 | R2>
 >(3, (self, policy, orElse) =>
@@ -2036,7 +1966,7 @@ export const retryOrElse_Effect = dual<
 /** @internal */
 const retryOrElse_EffectLoop = <A, E, R, R1, A1, A2, E2, R2>(
   self: Effect.Effect<A, E, R>,
-  driver: Schedule.ScheduleDriver<R1, E, A1>,
+  driver: Schedule.ScheduleDriver<A1, E, R1>,
   orElse: (e: E, out: A1) => Effect.Effect<A2, E2, R2>
 ): Effect.Effect<A | A2, E | E2, R | R1 | R2> => {
   return core.catchAll(
@@ -2057,27 +1987,27 @@ const retryOrElse_EffectLoop = <A, E, R, R1, A1, A2, E2, R2>(
 /** @internal */
 export const schedule_Effect = dual<
   <R2, Out>(
-    schedule: Schedule.Schedule<R2, unknown, Out>
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Out, E, R | R2>,
   <A, E, R, R2, Out>(
     self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, Out>
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ) => Effect.Effect<Out, E, R | R2>
 >(2, <A, E, R, R2, Out>(
   self: Effect.Effect<A, E, R>,
-  schedule: Schedule.Schedule<R2, unknown, Out>
+  schedule: Schedule.Schedule<Out, unknown, R2>
 ) => scheduleFrom_Effect(self, void 0, schedule))
 
 /** @internal */
 export const scheduleFrom_Effect = dual<
   <R2, In, Out>(
     initial: In,
-    schedule: Schedule.Schedule<R2, In, Out>
+    schedule: Schedule.Schedule<Out, In, R2>
   ) => <E, R>(self: Effect.Effect<In, E, R>) => Effect.Effect<Out, E, R | R2>,
   <In, E, R, R2, Out>(
     self: Effect.Effect<In, E, R>,
     initial: In,
-    schedule: Schedule.Schedule<R2, In, Out>
+    schedule: Schedule.Schedule<Out, In, R2>
   ) => Effect.Effect<Out, E, R | R2>
 >(3, (self, initial, schedule) =>
   core.flatMap(
@@ -2089,7 +2019,7 @@ export const scheduleFrom_Effect = dual<
 const scheduleFrom_EffectLoop = <In, E, R, R2, Out>(
   self: Effect.Effect<In, E, R>,
   initial: In,
-  driver: Schedule.ScheduleDriver<R2, In, Out>
+  driver: Schedule.ScheduleDriver<Out, In, R2>
 ): Effect.Effect<Out, E, R | R2> =>
   core.matchEffect(driver.next(initial), {
     onFailure: () => core.orDie(driver.last),
@@ -2097,10 +2027,10 @@ const scheduleFrom_EffectLoop = <In, E, R, R2, Out>(
   })
 
 /** @internal */
-export const count: Schedule.Schedule<never, unknown, number> = unfold(0, (n) => n + 1)
+export const count: Schedule.Schedule<number> = unfold(0, (n) => n + 1)
 
 /** @internal */
-export const elapsed: Schedule.Schedule<never, unknown, Duration.Duration> = makeWithState(
+export const elapsed: Schedule.Schedule<Duration.Duration> = makeWithState(
   Option.none() as Option.Option<number>,
   (now, _, state) => {
     switch (state._tag) {
@@ -2127,10 +2057,10 @@ export const elapsed: Schedule.Schedule<never, unknown, Duration.Duration> = mak
 )
 
 /** @internal */
-export const forever: Schedule.Schedule<never, unknown, number> = unfold(0, (n) => n + 1)
+export const forever: Schedule.Schedule<number> = unfold(0, (n) => n + 1)
 
 /** @internal */
-export const once: Schedule.Schedule<never, unknown, void> = asUnit(recurs(1))
+export const once: Schedule.Schedule<void> = asUnit(recurs(1))
 
 /** @internal */
-export const stop: Schedule.Schedule<never, unknown, void> = asUnit(recurs(0))
+export const stop: Schedule.Schedule<void> = asUnit(recurs(0))
diff --git a/packages/effect/src/internal/stream.ts b/packages/effect/src/internal/stream.ts
index 92bd26e688..64d609be4c 100644
--- a/packages/effect/src/internal/stream.ts
+++ b/packages/effect/src/internal/stream.ts
@@ -133,21 +133,21 @@ export const aggregate = dual<
 
 /** @internal */
 export const aggregateWithin = dual<
-  <B, A, A2, E2, R2, R3, C>(
+  <B, A, A2, E2, R2, C, R3>(
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<B, E2 | E, R2 | R3 | R>,
-  <A, E, R, B, A2, E2, R2, R3, C>(
+  <A, E, R, B, A2, E2, R2, C, R3>(
     self: Stream.Stream<A, E, R>,
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ) => Stream.Stream<B, E2 | E, R2 | R3 | R>
 >(
   3,
-  <A, E, R, B, A2, E2, R2, R3, C>(
+  <A, E, R, B, A2, E2, R2, C, R3>(
     self: Stream.Stream<A, E, R>,
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ): Stream.Stream<B, E2 | E, R2 | R3 | R> =>
     filterMap(
       aggregateWithinEither(self, sink, schedule),
@@ -161,21 +161,21 @@ export const aggregateWithin = dual<
 
 /** @internal */
 export const aggregateWithinEither = dual<
-  <B, A, A2, E2, R2, R3, C>(
+  <B, A, A2, E2, R2, C, R3>(
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Either.Either<B, C>, E2 | E, R2 | R3 | R>,
-  <A, E, R, B, A2, E2, R2, R3, C>(
+  <A, E, R, B, A2, E2, R2, C, R3>(
     self: Stream.Stream<A, E, R>,
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ) => Stream.Stream<Either.Either<B, C>, E2 | E, R2 | R3 | R>
 >(
   3,
-  <A, E, R, B, A2, E2, R2, R3, C>(
+  <A, E, R, B, A2, E2, R2, C, R3>(
     self: Stream.Stream<A, E, R>,
     sink: Sink.Sink<B, A | A2, A2, E2, R2>,
-    schedule: Schedule.Schedule<R3, Option.Option<B>, C>
+    schedule: Schedule.Schedule<C, Option.Option<B>, R3>
   ): Stream.Stream<Either.Either<B, C>, E2 | E, R2 | R3 | R> => {
     const layer = Effect.all([
       Handoff.make<HandoffSignal.HandoffSignal<A, E | E2>>(),
@@ -3017,7 +3017,7 @@ export const fromQueue = <A>(
   )
 
 /** @internal */
-export const fromSchedule = <R, A>(schedule: Schedule.Schedule<R, unknown, A>): Stream.Stream<A, never, R> =>
+export const fromSchedule = <A, R>(schedule: Schedule.Schedule<A, unknown, R>): Stream.Stream<A, never, R> =>
   pipe(
     Schedule.driver(schedule),
     Effect.map((driver) => repeatEffectOption(driver.next(void 0))),
@@ -4805,18 +4805,18 @@ export const refineOrDieWith = dual<
 
 /** @internal */
 export const repeat = dual<
-  <R2, B>(
-    schedule: Schedule.Schedule<R2, unknown, B>
+  <B, R2>(
+    schedule: Schedule.Schedule<B, unknown, R2>
   ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R2 | R>,
-  <R, E, A, R2, B>(
+  <R, E, A, B, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>
+    schedule: Schedule.Schedule<B, unknown, R2>
   ) => Stream.Stream<A, E, R2 | R>
 >(
   2,
-  <R, E, A, R2, B>(
+  <R, E, A, B, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>
+    schedule: Schedule.Schedule<B, unknown, R2>
   ): Stream.Stream<A, E, R | R2> =>
     filterMap(
       repeatEither(self, schedule),
@@ -4855,18 +4855,18 @@ export const repeatEffectOption = <A, E, R>(effect: Effect.Effect<A, Option.Opti
 
 /** @internal */
 export const repeatEither = dual<
-  <R2, B>(
-    schedule: Schedule.Schedule<R2, unknown, B>
+  <B, R2>(
+    schedule: Schedule.Schedule<B, unknown, R2>
   ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Either.Either<A, B>, E, R2 | R>,
-  <R, E, A, R2, B>(
+  <A, E, R, B, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>
+    schedule: Schedule.Schedule<B, unknown, R2>
   ) => Stream.Stream<Either.Either<A, B>, E, R2 | R>
 >(
   2,
-  <R, E, A, R2, B>(
+  <A, E, R, B, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>
+    schedule: Schedule.Schedule<B, unknown, R2>
   ): Stream.Stream<Either.Either<A, B>, E, R2 | R> =>
     repeatWith(self, schedule, {
       onElement: (a): Either.Either<A, B> => Either.right(a),
@@ -4876,18 +4876,18 @@ export const repeatEither = dual<
 
 /** @internal */
 export const repeatElements = dual<
-  <R2, B>(
-    schedule: Schedule.Schedule<R2, unknown, B>
+  <B, R2>(
+    schedule: Schedule.Schedule<B, unknown, R2>
   ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R2 | R>,
-  <R, E, A, R2, B>(
+  <A, E, R, B, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>
+    schedule: Schedule.Schedule<B, unknown, R2>
   ) => Stream.Stream<A, E, R2 | R>
 >(
   2,
-  <R, E, A, R2, B>(
+  <A, E, R, B, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>
+    schedule: Schedule.Schedule<B, unknown, R2>
   ): Stream.Stream<A, E, R | R2> =>
     filterMap(
       repeatElementsWith(self, schedule, { onElement: (a) => Option.some(a), onSchedule: Option.none }),
@@ -4897,16 +4897,16 @@ export const repeatElements = dual<
 
 /** @internal */
 export const repeatElementsWith = dual<
-  <R2, B, A, C>(
-    schedule: Schedule.Schedule<R2, unknown, B>,
+  <B, R2, A, C>(
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
     }
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<C, E, R2 | R>,
-  <R, E, R2, B, A, C>(
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<C, E, R2 | R>,
+  <A, E, R, B, R2, C>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>,
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
@@ -4914,9 +4914,9 @@ export const repeatElementsWith = dual<
   ) => Stream.Stream<C, E, R2 | R>
 >(
   3,
-  <R, E, R2, B, A, C>(
+  <A, E, R, B, R2, C>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>,
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
@@ -4986,16 +4986,16 @@ export const repeatValue = <A>(value: A): Stream.Stream<A> =>
 
 /** @internal */
 export const repeatWith = dual<
-  <R2, B, A, C>(
-    schedule: Schedule.Schedule<R2, unknown, B>,
+  <B, R2, A, C>(
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
     }
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<C, E, R2 | R>,
-  <R, E, R2, B, A, C>(
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<C, E, R2 | R>,
+  <A, E, R, B, R2, C>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>,
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
@@ -5003,9 +5003,9 @@ export const repeatWith = dual<
   ) => Stream.Stream<C, E, R2 | R>
 >(
   3,
-  <R, E, R2, B, A, C>(
+  <A, E, R, B, R2, C>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, B>,
+    schedule: Schedule.Schedule<B, unknown, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
@@ -5039,16 +5039,15 @@ export const repeatWith = dual<
   }
 )
 
-/** @internal */
-export const repeatWithSchedule = <R, A, _>(
+const repeatWithSchedule = <A, R, _>(
   value: A,
-  schedule: Schedule.Schedule<R, A, _>
+  schedule: Schedule.Schedule<_, A, R>
 ): Stream.Stream<A, never, R> => repeatEffectWithSchedule(Effect.succeed(value), schedule)
 
 /** @internal */
-export const repeatEffectWithSchedule = <R, E, A, A0 extends A, R2, _>(
+export const repeatEffectWithSchedule = <A, E, R, _, A0 extends A, R2>(
   effect: Effect.Effect<A, E, R>,
-  schedule: Schedule.Schedule<R2, A0, _>
+  schedule: Schedule.Schedule<_, A0, R2>
 ): Stream.Stream<A, E, R | R2> =>
   flatMap(
     fromEffect(Effect.zip(effect, Schedule.driver(schedule))),
@@ -5065,18 +5064,18 @@ export const repeatEffectWithSchedule = <R, E, A, A0 extends A, R2, _>(
 
 /** @internal */
 export const retry = dual<
-  <R2, E, E0 extends E, _>(
-    schedule: Schedule.Schedule<R2, E0, _>
-  ) => <R, A>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R2 | R>,
-  <R, A, R2, E, E0 extends E, _>(
+  <E0 extends E, R2, E, _>(
+    schedule: Schedule.Schedule<_, E0, R2>
+  ) => <A, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R2 | R>,
+  <A, E, R, _, E0 extends E, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, E0, _>
+    schedule: Schedule.Schedule<_, E0, R2>
   ) => Stream.Stream<A, E, R2 | R>
 >(
   2,
-  <R, A, R2, E, E0 extends E, _>(
+  <A, E, R, _, E0 extends E, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, E0, _>
+    schedule: Schedule.Schedule<_, E0, R2>
   ): Stream.Stream<A, E, R | R2> =>
     unwrap(
       Effect.map(Schedule.driver(schedule), (driver) => {
@@ -5512,18 +5511,18 @@ export const scanReduceEffect = dual<
 
 /** @internal */
 export const schedule = dual<
-  <R2, A, A0 extends A, _>(
-    schedule: Schedule.Schedule<R2, A0, _>
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R2 | R>,
-  <R, E, R2, A, A0 extends A, _>(
+  <_, A0 extends A, R2, A>(
+    schedule: Schedule.Schedule<_, A0, R2>
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R2 | R>,
+  <A, E, R, _, A0 extends A, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, A0, _>
+    schedule: Schedule.Schedule<_, A0, R2>
   ) => Stream.Stream<A, E, R2 | R>
 >(
   2,
-  <R, E, R2, A, A0 extends A, _>(
+  <A, E, R, _, A0 extends A, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, A0, _>
+    schedule: Schedule.Schedule<_, A0, R2>
   ): Stream.Stream<A, E, R | R2> =>
     filterMap(
       scheduleWith(self, schedule, { onElement: Option.some, onSchedule: Option.none }),
@@ -5533,16 +5532,16 @@ export const schedule = dual<
 
 /** @internal */
 export const scheduleWith = dual<
-  <R2, A, A0 extends A, B, C>(
-    schedule: Schedule.Schedule<R2, A0, B>,
+  <B, A0 extends A, R2, A, C>(
+    schedule: Schedule.Schedule<B, A0, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
     }
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<C, E, R2 | R>,
-  <R, E, R2, A, A0 extends A, B, C>(
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<C, E, R2 | R>,
+  <A, E, R, B, A0 extends A, R2, C>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, A0, B>,
+    schedule: Schedule.Schedule<B, A0, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
@@ -5550,16 +5549,16 @@ export const scheduleWith = dual<
   ) => Stream.Stream<C, E, R2 | R>
 >(
   3,
-  <R, E, R2, A, A0 extends A, B, C>(
+  <A, E, R, B, A0 extends A, R2, C>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<R2, A0, B>,
+    schedule: Schedule.Schedule<B, A0, R2>,
     options: {
       readonly onElement: (a: A) => C
       readonly onSchedule: (b: B) => C
     }
   ): Stream.Stream<C, E, R | R2> => {
     const loop = (
-      driver: Schedule.ScheduleDriver<R2, A0, B>,
+      driver: Schedule.ScheduleDriver<B, A0, R2>,
       iterator: Iterator<A>
     ): Channel.Channel<Chunk.Chunk<C>, Chunk.Chunk<A>, E, E, unknown, unknown, R2> => {
       const next = iterator.next()
diff --git a/packages/effect/test/Schedule.test.ts b/packages/effect/test/Schedule.test.ts
index 83a93fc6a7..6d442b52a4 100644
--- a/packages/effect/test/Schedule.test.ts
+++ b/packages/effect/test/Schedule.test.ts
@@ -797,7 +797,7 @@ const failOn0 = (ref: Ref.Ref<number>): Effect.Effect<number, string> => {
 const alwaysFail = (ref: Ref.Ref<number>): Effect.Effect<number, string> => {
   return Ref.updateAndGet(ref, (n) => n + 1).pipe(Effect.flatMap((n) => Effect.fail(`Error: ${n}`)))
 }
-const repeat = <Env, B>(schedule: Schedule.Schedule<Env, number, B>): Effect.Effect<B, never, Env> => {
+const repeat = <Env, B>(schedule: Schedule.Schedule<B, number, Env>): Effect.Effect<B, never, Env> => {
   return Ref.make(0).pipe(
     Effect.flatMap((ref) => ref.pipe(Ref.updateAndGet((n) => n + 1), Effect.repeat(schedule)))
   )
@@ -808,7 +808,7 @@ const roundToNearestHour = (date: Date): number => {
   return date.getMilliseconds()
 }
 const checkDelays = <Env>(
-  schedule: Schedule.Schedule<Env, number, Duration.Duration>
+  schedule: Schedule.Schedule<Duration.Duration, number, Env>
 ): Effect.Effect<
   readonly [
     Chunk.Chunk<Duration.Duration>,
@@ -825,7 +825,7 @@ const checkDelays = <Env>(
     return [actual, expected] as const
   })
 }
-const checkRepetitions = <Env>(schedule: Schedule.Schedule<Env, number, number>): Effect.Effect<
+const checkRepetitions = <Env>(schedule: Schedule.Schedule<number, number, Env>): Effect.Effect<
   readonly [
     Chunk.Chunk<number>,
     Chunk.Chunk<number>
@@ -850,7 +850,7 @@ export const run = <A, E, R>(
   )
 }
 export const runCollect = <Env, In, Out>(
-  schedule: Schedule.Schedule<Env, In, Out>,
+  schedule: Schedule.Schedule<Out, In, Env>,
   input: Iterable<In>
 ): Effect.Effect<Chunk.Chunk<Out>, never, Env> => {
   return run(
@@ -860,7 +860,7 @@ export const runCollect = <Env, In, Out>(
   )
 }
 const runCollectLoop = <Env, In, Out>(
-  driver: Schedule.ScheduleDriver<Env, In, Out>,
+  driver: Schedule.ScheduleDriver<Out, In, Env>,
   input: Chunk.Chunk<In>,
   acc: Chunk.Chunk<Out>
 ): Effect.Effect<Chunk.Chunk<Out>, never, Env> => {
@@ -883,7 +883,7 @@ const runCollectLoop = <Env, In, Out>(
   )
 }
 const runManually = <Env, In, Out>(
-  schedule: Schedule.Schedule<Env, In, Out>,
+  schedule: Schedule.Schedule<Out, In, Env>,
   inputs: Iterable<
     readonly [
       number,
@@ -906,7 +906,7 @@ const runManually = <Env, In, Out>(
   return runManuallyLoop(schedule, schedule.initial, Chunk.fromIterable(inputs), Chunk.empty())
 }
 const runManuallyLoop = <Env, In, Out>(
-  schedule: Schedule.Schedule<Env, In, Out>,
+  schedule: Schedule.Schedule<Out, In, Env>,
   state: unknown,
   inputs: Chunk.Chunk<
     readonly [
diff --git a/packages/effect/test/TReentrantLock.test.ts b/packages/effect/test/TReentrantLock.test.ts
index dea4d971d5..d9d9849255 100644
--- a/packages/effect/test/TReentrantLock.test.ts
+++ b/packages/effect/test/TReentrantLock.test.ts
@@ -11,11 +11,7 @@ import * as STM from "effect/STM"
 import * as TReentrantLock from "effect/TReentrantLock"
 import { assert, describe } from "vitest"
 
-const pollSchedule = <E, A>(): Schedule.Schedule<
-  never,
-  Option.Option<Exit.Exit<E, A>>,
-  Option.Option<Exit.Exit<E, A>>
-> =>
+const pollSchedule = <E, A>(): Schedule.Schedule<Option.Option<Exit.Exit<E, A>>, Option.Option<Exit.Exit<E, A>>> =>
   pipe(
     Schedule.recurs(100),
     Schedule.zipRight(
diff --git a/packages/platform/src/Http/Client.ts b/packages/platform/src/Http/Client.ts
index 7e6838b309..43c74cd67a 100644
--- a/packages/platform/src/Http/Client.ts
+++ b/packages/platform/src/Http/Client.ts
@@ -365,8 +365,8 @@ export const mapInputRequestEffect: {
  * @category error handling
  */
 export const retry: {
-  <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(self: Client<R, E, A>) => Client<R1 | R, E, A>
-  <R, E extends E0, E0, A, R1, B>(self: Client<R, E, A>, policy: Schedule.Schedule<R1, E0, B>): Client<R | R1, E, A>
+  <R1, E extends E0, E0, B>(policy: Schedule.Schedule<B, E0, R1>): <R, A>(self: Client<R, E, A>) => Client<R1 | R, E, A>
+  <R, E extends E0, E0, A, R1, B>(self: Client<R, E, A>, policy: Schedule.Schedule<B, E0, R1>): Client<R | R1, E, A>
 } = internal.retry
 
 /**
diff --git a/packages/platform/src/internal/http/client.ts b/packages/platform/src/internal/http/client.ts
index ab1e117c91..ac4a84822c 100644
--- a/packages/platform/src/internal/http/client.ts
+++ b/packages/platform/src/internal/http/client.ts
@@ -531,17 +531,17 @@ export const mapInputRequestEffect = dual<
 /** @internal */
 export const retry: {
   <R1, E extends E0, E0, B>(
-    policy: Schedule.Schedule<R1, E0, B>
+    policy: Schedule.Schedule<B, E0, R1>
   ): <R, A>(self: Client.Client<R, E, A>) => Client.Client<R1 | R, E, A>
   <R, E extends E0, E0, A, R1, B>(
     self: Client.Client<R, E, A>,
-    policy: Schedule.Schedule<R1, E0, B>
+    policy: Schedule.Schedule<B, E0, R1>
   ): Client.Client<R | R1, E, A>
 } = dual(
   2,
   <R, E extends E0, E0, A, R1, B>(
     self: Client.Client<R, E, A>,
-    policy: Schedule.Schedule<R1, E0, B>
+    policy: Schedule.Schedule<B, E0, R1>
   ): Client.Client<R | R1, E, A> => transformResponse(self, Effect.retry(policy))
 )