effect 3.12.11 → 3.13.0

package/src/internal/layer.ts

@@ -20,6 +20,7 @@ import * as Intervals from "../ScheduleIntervals.js"
 import * as Scope from "../Scope.js"
 import type * as Synchronized from "../SynchronizedRef.js"
 import type * as Tracer from "../Tracer.js"
+import type * as Types from "../Types.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as circular from "./effect/circular.js"
@@ -542,15 +543,15 @@ export const fresh = <A, E, R>(self: Layer.Layer<A, E, R>): Layer.Layer<A, E, R>
 
 /** @internal */
 export const fromEffect = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T
+  <I, S>(
+    tag: Context.Tag<I, S>
   ) => <E, R>(
-    effect: Effect.Effect<Context.Tag.Service<T>, E, R>
-  ) => Layer.Layer<Context.Tag.Identifier<T>, E, R>,
-  <T extends Context.Tag<any, any>, E, R>(
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E, R>
-  ) => Layer.Layer<Context.Tag.Identifier<T>, E, R>
+    effect: Effect.Effect<Types.NoInfer<S>, E, R>
+  ) => Layer.Layer<I, E, R>,
+  <I, S, E, R>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E, R>
+  ) => Layer.Layer<I, E, R>
 >(2, (a, b) => {
   const tagFirst = Context.isTag(a)
   const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>
@@ -610,12 +611,11 @@ export const fiberRefLocallyScopedWith = <A>(self: FiberRef<A>, value: (_: A) =>
   scopedDiscard(fiberRuntime.fiberRefLocallyScopedWith(self, value))
 
 /** @internal */
-export const fromFunction = <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(
-  tagA: A,
-  tagB: B,
-  f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>
-): Layer.Layer<Context.Tag.Identifier<B>, never, Context.Tag.Identifier<A>> =>
-  fromEffectContext(core.map(tagA, (a) => Context.make(tagB, f(a))))
+export const fromFunction = <I1, S1, I2, S2>(
+  tagA: Context.Tag<I1, S1>,
+  tagB: Context.Tag<I2, S2>,
+  f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
+): Layer.Layer<I2, never, I1> => fromEffectContext(core.map(tagA, (a) => Context.make(tagB, f(a))))
 
 /** @internal */
 export const launch = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Effect.Effect<never, E, RIn> =>
@@ -761,17 +761,17 @@ export const passthrough = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Laye
 
 /** @internal */
 export const project = dual<
-  <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(
-    tagA: A,
-    tagB: B,
-    f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>
-  ) => <RIn, E>(self: Layer.Layer<Context.Tag.Identifier<A>, E, RIn>) => Layer.Layer<Context.Tag.Identifier<B>, E, RIn>,
-  <RIn, E, A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(
-    self: Layer.Layer<Context.Tag.Identifier<A>, E, RIn>,
-    tagA: A,
-    tagB: B,
-    f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>
-  ) => Layer.Layer<Context.Tag.Identifier<B>, E, RIn>
+  <I1, S1, I2, S2>(
+    tagA: Context.Tag<I1, S1>,
+    tagB: Context.Tag<I2, S2>,
+    f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
+  ) => <RIn, E>(self: Layer.Layer<I1, E, RIn>) => Layer.Layer<I2, E, RIn>,
+  <RIn, E, I1, S1, I2, S2>(
+    self: Layer.Layer<I1, E, RIn>,
+    tagA: Context.Tag<I1, S1>,
+    tagB: Context.Tag<I2, S2>,
+    f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
+  ) => Layer.Layer<I2, E, RIn>
 >(4, (self, tagA, tagB, f) => map(self, (context) => Context.make(tagB, f(Context.unsafeGet(context, tagA)))))
 
 /** @internal */
@@ -842,15 +842,15 @@ const retryUpdate = <X, E, RIn>(
 
 /** @internal */
 export const scoped = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T
+  <I, S>(
+    tag: Context.Tag<I, S>
   ) => <E, R>(
-    effect: Effect.Effect<Context.Tag.Service<T>, E, R>
-  ) => Layer.Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>,
-  <T extends Context.Tag<any, any>, E, R>(
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E, R>
-  ) => Layer.Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>
+    effect: Effect.Effect<Types.NoInfer<S>, E, R>
+  ) => Layer.Layer<I, E, Exclude<R, Scope.Scope>>,
+  <I, S, E, R>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E, R>
+  ) => Layer.Layer<I, E, Exclude<R, Scope.Scope>>
 >(2, (a, b) => {
   const tagFirst = Context.isTag(a)
   const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>
@@ -885,21 +885,21 @@ export const scope: Layer.Layer<Scope.Scope> = scopedContext(
 )
 
 /** @internal */
-export const service = <T extends Context.Tag<any, any>>(
-  tag: T
-): Layer.Layer<Context.Tag.Identifier<T>, never, Context.Tag.Identifier<T>> => fromEffect(tag, tag)
+export const service = <I, S>(
+  tag: Context.Tag<I, S>
+): Layer.Layer<I, never, I> => fromEffect(tag, tag)
 
 /** @internal */
 export const succeed = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T
+  <I, S>(
+    tag: Context.Tag<I, S>
   ) => (
-    resource: Context.Tag.Service<T>
-  ) => Layer.Layer<Context.Tag.Identifier<T>>,
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    resource: Context.Tag.Service<T>
-  ) => Layer.Layer<Context.Tag.Identifier<T>>
+    resource: Types.NoInfer<S>
+  ) => Layer.Layer<I>,
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    resource: Types.NoInfer<S>
+  ) => Layer.Layer<I>
 >(2, (a, b) => {
   const tagFirst = Context.isTag(a)
   const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>
@@ -929,15 +929,15 @@ export const suspend = <RIn, E, ROut>(
 
 /** @internal */
 export const sync = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T
+  <I, S>(
+    tag: Context.Tag<I, S>
   ) => (
-    evaluate: LazyArg<Context.Tag.Service<T>>
-  ) => Layer.Layer<Context.Tag.Identifier<T>>,
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    evaluate: LazyArg<Context.Tag.Service<T>>
-  ) => Layer.Layer<Context.Tag.Identifier<T>>
+    evaluate: LazyArg<Types.NoInfer<S>>
+  ) => Layer.Layer<I>,
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    evaluate: LazyArg<Types.NoInfer<S>>
+  ) => Layer.Layer<I>
 >(2, (a, b) => {
   const tagFirst = Context.isTag(a)
   const tag = (tagFirst ? a : b) as Context.Tag<unknown, unknown>

package/src/internal/rcMap.ts

@@ -32,7 +32,9 @@ declare namespace State {
   interface Entry<A, E> {
     readonly deferred: Deferred.Deferred<A, E>
     readonly scope: Scope.CloseableScope
+    readonly finalizer: Effect<void>
     fiber: RuntimeFiber<void, never> | undefined
+    expiresAt: number
     refCount: number
   }
 }
@@ -121,96 +123,100 @@ export const make: {
 export const get: {
   <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<A, E, Scope.Scope>
   <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<A, E, Scope.Scope>
-} = dual(
-  2,
-  <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K): Effect<A, E, Scope.Scope> => {
-    const self = self_ as RcMapImpl<K, A, E>
-    return core.uninterruptibleMask((restore) =>
-      core.suspend(() => {
-        if (self.state._tag === "Closed") {
-          return core.interrupt
-        }
-        const state = self.state
-        const o = MutableHashMap.get(state.map, key)
-        if (o._tag === "Some") {
-          const entry = o.value
-          entry.refCount++
-          return entry.fiber
-            ? core.as(core.interruptFiber(entry.fiber), entry)
-            : core.succeed(entry)
-        } else if (Number.isFinite(self.capacity) && MutableHashMap.size(self.state.map) >= self.capacity) {
-          return core.fail(
-            new core.ExceededCapacityException(`RcMap attempted to exceed capacity of ${self.capacity}`)
-          ) as Effect<never>
-        }
-        const acquire = self.lookup(key)
-        return fiberRuntime.scopeMake().pipe(
-          coreEffect.bindTo("scope"),
-          coreEffect.bind("deferred", () => core.deferredMake<A, E>()),
-          core.tap(({ deferred, scope }) =>
-            restore(core.fiberRefLocally(
-              acquire as Effect<A, E>,
-              core.currentContext,
-              Context.add(self.context, fiberRuntime.scopeTag, scope)
-            )).pipe(
-              core.exit,
-              core.flatMap((exit) => core.deferredDone(deferred, exit)),
-              circular.forkIn(scope)
-            )
-          ),
-          core.map(({ deferred, scope }) => {
-            const entry: State.Entry<A, E> = {
-              deferred,
-              scope,
-              fiber: undefined,
-              refCount: 1
-            }
-            MutableHashMap.set(state.map, key, entry)
-            return entry
-          })
-        )
-      }).pipe(
-        self.semaphore.withPermits(1),
-        coreEffect.bindTo("entry"),
-        coreEffect.bind("scope", () => fiberRuntime.scopeTag),
-        core.tap(({ entry, scope }) =>
-          scope.addFinalizer(() =>
-            core.suspend(() => {
-              entry.refCount--
-              if (entry.refCount > 0) {
-                return core.void
-              } else if (self.idleTimeToLive === undefined) {
-                if (self.state._tag === "Open") {
-                  MutableHashMap.remove(self.state.map, key)
-                }
-                return core.scopeClose(entry.scope, core.exitVoid)
-              }
-              return coreEffect.sleep(self.idleTimeToLive).pipe(
-                core.interruptible,
-                core.zipRight(core.suspend(() => {
-                  if (self.state._tag === "Open" && entry.refCount === 0) {
-                    MutableHashMap.remove(self.state.map, key)
-                    return core.scopeClose(entry.scope, core.exitVoid)
-                  }
-                  return core.void
-                })),
-                fiberRuntime.ensuring(core.sync(() => {
-                  entry.fiber = undefined
-                })),
-                circular.forkIn(self.scope),
-                core.tap((fiber) => {
-                  entry.fiber = fiber
-                }),
-                self.semaphore.withPermits(1)
-              )
-            })
-          )
-        ),
-        core.flatMap(({ entry }) => restore(core.deferredAwait(entry.deferred)))
-      )
-    )
+} = dual(2, <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K): Effect<A, E, Scope.Scope> => {
+  const self = self_ as RcMapImpl<K, A, E>
+  return core.uninterruptibleMask((restore) => getImpl(self, key, restore as any))
+})
+
+const getImpl = core.fnUntraced(function*<K, A, E>(self: RcMapImpl<K, A, E>, key: K, restore: <A>(a: A) => A) {
+  if (self.state._tag === "Closed") {
+    return yield* core.interrupt
   }
-)
+  const state = self.state
+  const o = MutableHashMap.get(state.map, key)
+  let entry: State.Entry<A, E>
+  if (o._tag === "Some") {
+    entry = o.value
+    entry.refCount++
+  } else if (Number.isFinite(self.capacity) && MutableHashMap.size(self.state.map) >= self.capacity) {
+    return yield* core.fail(
+      new core.ExceededCapacityException(`RcMap attempted to exceed capacity of ${self.capacity}`)
+    ) as Effect<never>
+  } else {
+    entry = yield* self.semaphore.withPermits(1)(acquire(self, key, restore))
+  }
+  const scope = yield* fiberRuntime.scopeTag
+  yield* scope.addFinalizer(() => entry.finalizer)
+  return yield* restore(core.deferredAwait(entry.deferred))
+})
+
+const acquire = core.fnUntraced(function*<K, A, E>(self: RcMapImpl<K, A, E>, key: K, restore: <A>(a: A) => A) {
+  const scope = yield* fiberRuntime.scopeMake()
+  const deferred = yield* core.deferredMake<A, E>()
+  const acquire = self.lookup(key)
+  yield* restore(core.fiberRefLocally(
+    acquire as Effect<A, E>,
+    core.currentContext,
+    Context.add(self.context, fiberRuntime.scopeTag, scope)
+  )).pipe(
+    core.exit,
+    core.flatMap((exit) => core.deferredDone(deferred, exit)),
+    circular.forkIn(scope)
+  )
+  const entry: State.Entry<A, E> = {
+    deferred,
+    scope,
+    finalizer: undefined as any,
+    fiber: undefined,
+    expiresAt: 0,
+    refCount: 1
+  }
+  ;(entry as any).finalizer = release(self, key, entry)
+  if (self.state._tag === "Open") {
+    MutableHashMap.set(self.state.map, key, entry)
+  }
+  return entry
+})
+
+const release = <K, A, E>(self: RcMapImpl<K, A, E>, key: K, entry: State.Entry<A, E>) =>
+  coreEffect.clockWith((clock) => {
+    entry.refCount--
+    if (entry.refCount > 0) {
+      return core.void
+    } else if (
+      self.state._tag === "Closed"
+      || !MutableHashMap.has(self.state.map, key)
+      || self.idleTimeToLive === undefined
+    ) {
+      if (self.state._tag === "Open") {
+        MutableHashMap.remove(self.state.map, key)
+      }
+      return core.scopeClose(entry.scope, core.exitVoid)
+    }
+
+    entry.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(self.idleTimeToLive)
+    if (entry.fiber) return core.void
+
+    return core.interruptibleMask(function loop(restore): Effect<void> {
+      const now = clock.unsafeCurrentTimeMillis()
+      const remaining = entry.expiresAt - now
+      if (remaining <= 0) {
+        if (self.state._tag === "Closed" || entry.refCount > 0) return core.void
+        MutableHashMap.remove(self.state.map, key)
+        return restore(core.scopeClose(entry.scope, core.exitVoid))
+      }
+      return core.flatMap(clock.sleep(Duration.millis(remaining)), () => loop(restore))
+    }).pipe(
+      fiberRuntime.ensuring(core.sync(() => {
+        entry.fiber = undefined
+      })),
+      circular.forkIn(self.scope),
+      core.tap((fiber) => {
+        entry.fiber = fiber
+      }),
+      self.semaphore.withPermits(1)
+    )
+  })
 
 /** @internal */
 export const keys = <K, A, E>(self: RcMap.RcMap<K, A, E>): Effect<Array<K>> => {
@@ -219,3 +225,39 @@ export const keys = <K, A, E>(self: RcMap.RcMap<K, A, E>): Effect<Array<K>> => {
     impl.state._tag === "Closed" ? core.interrupt : core.succeed(MutableHashMap.keys(impl.state.map))
   )
 }
+
+/** @internal */
+export const invalidate: {
+  <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<void>
+  <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<void>
+} = dual(
+  2,
+  core.fnUntraced(function*<K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K) {
+    const self = self_ as RcMapImpl<K, A, E>
+    if (self.state._tag === "Closed") return
+    const o = MutableHashMap.get(self.state.map, key)
+    if (o._tag === "None") return
+    const entry = o.value
+    MutableHashMap.remove(self.state.map, key)
+    if (entry.refCount > 0) return
+    yield* core.scopeClose(entry.scope, core.exitVoid)
+    if (entry.fiber) yield* core.interruptFiber(entry.fiber)
+  })
+)
+
+/** @internal */
+export const touch: {
+  <K>(key: K): <A, E>(self: RcMap.RcMap<K, A, E>) => Effect<void>
+  <K, A, E>(self: RcMap.RcMap<K, A, E>, key: K): Effect<void>
+} = dual(
+  2,
+  <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K) =>
+    coreEffect.clockWith((clock) => {
+      const self = self_ as RcMapImpl<K, A, E>
+      if (!self.idleTimeToLive || self.state._tag === "Closed") return core.void
+      const o = MutableHashMap.get(self.state.map, key)
+      if (o._tag === "None") return core.void
+      o.value.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(self.idleTimeToLive)
+      return core.void
+    })
+)

package/src/internal/reloadable.ts

@@ -25,13 +25,13 @@ const reloadableVariance = {
 }
 
 /** @internal */
-export const auto = <Out extends Context.Tag<any, any>, E, In, R>(
-  tag: Out,
+export const auto = <I, S, E, In, R>(
+  tag: Context.Tag<I, S>,
   options: {
-    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
+    readonly layer: Layer.Layer<I, E, In>
     readonly schedule: Schedule.Schedule<unknown, unknown, R>
   }
-): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
+): Layer.Layer<Reloadable.Reloadable<I>, E, R | In> =>
   layer_.scoped(
     reloadableTag(tag),
     pipe(
@@ -52,13 +52,13 @@ export const auto = <Out extends Context.Tag<any, any>, E, In, R>(
   )
 
 /** @internal */
-export const autoFromConfig = <Out extends Context.Tag<any, any>, E, In, R>(
-  tag: Out,
+export const autoFromConfig = <I, S, E, In, R>(
+  tag: Context.Tag<I, S>,
   options: {
-    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
+    readonly layer: Layer.Layer<I, E, In>
     readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
   }
-): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
+): Layer.Layer<Reloadable.Reloadable<I>, E, R | In> =>
   layer_.scoped(
     reloadableTag(tag),
     pipe(
@@ -76,21 +76,21 @@ export const autoFromConfig = <Out extends Context.Tag<any, any>, E, In, R>(
   )
 
 /** @internal */
-export const get = <T extends Context.Tag<any, any>>(
-  tag: T
-): Effect.Effect<Context.Tag.Service<T>, never, Reloadable.Reloadable<Context.Tag.Identifier<T>>> =>
+export const get = <I, S>(
+  tag: Context.Tag<I, S>
+): Effect.Effect<S, never, Reloadable.Reloadable<I>> =>
   core.flatMap(
     reloadableTag(tag),
     (reloadable) => scopedRef.get(reloadable.scopedRef)
   )
 
 /** @internal */
-export const manual = <Out extends Context.Tag<any, any>, In, E>(
-  tag: Out,
+export const manual = <I, S, In, E>(
+  tag: Context.Tag<I, S>,
   options: {
-    readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
+    readonly layer: Layer.Layer<I, E, In>
   }
-): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, In> =>
+): Layer.Layer<Reloadable.Reloadable<I>, E, In> =>
   layer_.scoped(
     reloadableTag(tag),
     pipe(
@@ -112,28 +112,25 @@ export const manual = <Out extends Context.Tag<any, any>, In, E>(
   )
 
 /** @internal */
-export const reloadableTag = <T extends Context.Tag<any, any>>(
-  tag: T
-): Context.Tag<Reloadable.Reloadable<Context.Tag.Identifier<T>>, Reloadable.Reloadable<Context.Tag.Service<T>>> => {
-  return Context.GenericTag<
-    Reloadable.Reloadable<Context.Tag.Identifier<T>>,
-    Reloadable.Reloadable<Context.Tag.Service<T>>
-  >(`effect/Reloadable<${tag.key}>`)
+export const reloadableTag = <I, S>(
+  tag: Context.Tag<I, S>
+): Context.Tag<Reloadable.Reloadable<I>, Reloadable.Reloadable<S>> => {
+  return Context.GenericTag<Reloadable.Reloadable<I>, Reloadable.Reloadable<S>>(`effect/Reloadable<${tag.key}>`)
 }
 
 /** @internal */
-export const reload = <T extends Context.Tag<any, any>>(
-  tag: T
-): Effect.Effect<void, unknown, Reloadable.Reloadable<Context.Tag.Identifier<T>>> =>
+export const reload = <I, S>(
+  tag: Context.Tag<I, S>
+): Effect.Effect<void, unknown, Reloadable.Reloadable<I>> =>
   core.flatMap(
     reloadableTag(tag),
     (reloadable) => reloadable.reload
   )
 
 /** @internal */
-export const reloadFork = <T extends Context.Tag<any, any>>(
-  tag: T
-): Effect.Effect<void, unknown, Reloadable.Reloadable<Context.Tag.Identifier<T>>> =>
+export const reloadFork = <I, S>(
+  tag: Context.Tag<I, S>
+): Effect.Effect<void, unknown, Reloadable.Reloadable<I>> =>
   core.flatMap(reloadableTag(tag), (reloadable) =>
     pipe(
       reloadable.reload,

package/src/internal/schedule.ts

@@ -1116,22 +1116,22 @@ export const provideContext = dual<
 
 /** @internal */
 export const provideService = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    service: Context.Tag.Service<T>
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
   ) => <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>>(
+  ) => Schedule.Schedule<Out, In, Exclude<R, I>>,
+  <Out, In, R, I, S>(
     self: Schedule.Schedule<Out, In, R>,
-    tag: T,
-    service: Context.Tag.Service<T>
-  ) => Schedule.Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>>
->(3, <Out, In, R, T extends Context.Tag<any, any>>(
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => Schedule.Schedule<Out, In, Exclude<R, I>>
+>(3, <Out, In, R, I, S>(
   self: Schedule.Schedule<Out, In, R>,
-  tag: T,
-  service: Context.Tag.Service<T>
-): Schedule.Schedule<Out, In, Exclude<R, Context.Tag.Identifier<T>>> =>
+  tag: Context.Tag<I, S>,
+  service: Types.NoInfer<S>
+): Schedule.Schedule<Out, In, Exclude<R, I>> =>
   makeWithState(self.initial, (now, input, state) =>
     core.contextWithEffect((env) =>
       core.provideContext(
@@ -1362,19 +1362,25 @@ export const tapInput = dual<
 
 /** @internal */
 export const tapOutput = dual<
-  <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>(
+  <X, R2, Out>(
+    f: (out: Types.NoInfer<Out>) => Effect.Effect<X, never, R2>
+  ) => <In, R>(self: Schedule.Schedule<Out, In, R>) => Schedule.Schedule<Out, In, R2 | R>,
+  <Out, In, R, X, R2>(
     self: Schedule.Schedule<Out, In, R>,
-    f: (out: XO) => Effect.Effect<X, never, R2>
+    f: (out: Out) => Effect.Effect<X, never, R2>
   ) => Schedule.Schedule<Out, In, R | R2>
->(2, (self, f) =>
-  makeWithState(self.initial, (now, input, state) =>
-    core.tap(
-      self.step(now, input, state),
-      ([, out]) => f(out as any)
-    )))
+>(
+  2,
+  <Out, In, R, X, R2>(
+    self: Schedule.Schedule<Out, In, R>,
+    f: (out: Out) => Effect.Effect<X, never, R2>
+  ): Schedule.Schedule<Out, In, R | R2> =>
+    makeWithState(self.initial, (now, input, state) =>
+      core.tap(
+        self.step(now, input, state),
+        ([, out]) => f(out)
+      ))
+)
 
 /** @internal */
 export const unfold = <A>(initial: A, f: (a: A) => A): Schedule.Schedule<A> =>

package/src/internal/sink.ts

@@ -21,6 +21,7 @@ import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
 import * as Scope from "../Scope.js"
 import type * as Sink from "../Sink.js"
+import type * as Types from "../Types.js"
 import * as channel from "./channel.js"
 import * as mergeDecision from "./channel/mergeDecision.js"
 import * as core from "./core-stream.js"
@@ -1739,27 +1740,27 @@ export const refineOrDieWith = dual<
 )
 
 /** @internal */
-export const service = <T extends Context.Tag<any, any>>(
-  tag: T
-): Sink.Sink<Context.Tag.Service<T>, unknown, never, never, Context.Tag.Identifier<T>> => serviceWith(tag, identity)
+export const service = <I, S>(
+  tag: Context.Tag<I, S>
+): Sink.Sink<S, unknown, never, never, I> => serviceWith(tag, identity)
 
 /** @internal */
-export const serviceWith = <T extends Context.Tag<any, any>, Z>(
-  tag: T,
-  f: (service: Context.Tag.Service<T>) => Z
-): Sink.Sink<Z, unknown, never, never, Context.Tag.Identifier<T>> => fromEffect(Effect.map(tag, f))
+export const serviceWith = <I, S, Z>(
+  tag: Context.Tag<I, S>,
+  f: (service: Types.NoInfer<S>) => Z
+): Sink.Sink<Z, unknown, never, never, I> => fromEffect(Effect.map(tag, f))
 
 /** @internal */
-export const serviceWithEffect = <T extends Context.Tag<any, any>, R, E, Z>(
-  tag: T,
-  f: (service: Context.Tag.Service<T>) => Effect.Effect<Z, E, R>
-): Sink.Sink<Z, unknown, never, E, R | Context.Tag.Identifier<T>> => fromEffect(Effect.flatMap(tag, f))
+export const serviceWithEffect = <I, S, R, E, Z>(
+  tag: Context.Tag<I, S>,
+  f: (service: Types.NoInfer<S>) => Effect.Effect<Z, E, R>
+): Sink.Sink<Z, unknown, never, E, R | I> => fromEffect(Effect.flatMap(tag, f))
 
 /** @internal */
-export const serviceWithSink = <T extends Context.Tag<any, any>, R, E, In, L, Z>(
-  tag: T,
-  f: (service: Context.Tag.Service<T>) => Sink.Sink<Z, In, L, E, R>
-): Sink.Sink<Z, In, L, E, R | Context.Tag.Identifier<T>> =>
+export const serviceWithSink = <I, S, R, E, In, L, Z>(
+  tag: Context.Tag<I, S>,
+  f: (service: Types.NoInfer<S>) => Sink.Sink<Z, In, L, E, R>
+): Sink.Sink<Z, In, L, E, R | I> =>
   new SinkImpl(pipe(Effect.map(tag, (service) => toChannel(f(service))), channel.unwrap))
 
 /** @internal */