effect 3.12.0 → 3.12.2

package/src/GlobalValue.ts

@@ -14,13 +14,9 @@
  */
 import * as version from "./internal/version.js"
 
-const globalStoreId = Symbol.for(`effect/GlobalValue/globalStoreId/${version.getCurrentVersion()}`)
+const globalStoreId = `effect/GlobalValue/globalStoreId/${version.getCurrentVersion()}`
 
-if (!(globalStoreId in globalThis)) {
-  ;(globalThis as any)[globalStoreId] = new Map()
-}
-
-const globalStore = (globalThis as any)[globalStoreId] as Map<unknown, any>
+let globalStore: Map<unknown, any>
 
 /**
  * Retrieves or computes a global value associated with the given `id`. If the value for this `id`
@@ -46,6 +42,12 @@ const globalStore = (globalThis as any)[globalStoreId] as Map<unknown, any>
  * @since 2.0.0
  */
 export const globalValue = <A>(id: unknown, compute: () => A): A => {
+  if (!globalStore) {
+    // @ts-expect-error
+    globalThis[globalStoreId] ??= new Map()
+    // @ts-expect-error
+    globalStore = globalThis[globalStoreId] as Map<unknown, any>
+  }
   if (!globalStore.has(id)) {
     globalStore.set(id, compute())
   }

package/src/HashMap.ts

@@ -6,7 +6,7 @@ import type { Equal } from "./Equal.js"
 import type { HashSet } from "./HashSet.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as HM from "./internal/hashMap.js"
-import * as _keySet from "./internal/hashMap/keySet.js"
+import * as keySet_ from "./internal/hashMap/keySet.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { NoInfer } from "./Types.js"
@@ -305,7 +305,7 @@ export const keys: <K, V>(self: HashMap<K, V>) => IterableIterator<K> = HM.keys
  * @since 2.0.0
  * @category getter
  */
-export const keySet: <K, V>(self: HashMap<K, V>) => HashSet<K> = _keySet.keySet
+export const keySet: <K, V>(self: HashMap<K, V>) => HashSet<K> = keySet_.keySet
 
 /**
  * Returns an `IterableIterator` of the values within the `HashMap`.

package/src/Layer.ts

@@ -82,9 +82,9 @@ export declare namespace Layer {
    */
   export interface Any {
     readonly [LayerTypeId]: {
-      readonly _ROut: any
-      readonly _E: any
-      readonly _RIn: any
+      readonly _ROut: Types.Contravariant<never>
+      readonly _E: Types.Covariant<any>
+      readonly _RIn: Types.Covariant<any>
     }
   }
   /**

package/src/ManagedRuntime.ts

@@ -40,12 +40,13 @@ export declare namespace ManagedRuntime {
    * @category type-level
    * @since 3.4.0
    */
-  export type Context<T extends ManagedRuntime<any, any>> = [T] extends [ManagedRuntime<infer R, infer _E>] ? R : never
+  export type Context<T extends ManagedRuntime<never, any>> = [T] extends [ManagedRuntime<infer R, infer _E>] ? R
+    : never
   /**
    * @category type-level
    * @since 3.4.0
    */
-  export type Error<T extends ManagedRuntime<any, any>> = [T] extends [ManagedRuntime<infer _R, infer E>] ? E : never
+  export type Error<T extends ManagedRuntime<never, any>> = [T] extends [ManagedRuntime<infer _R, infer E>] ? E : never
 }
 
 /**

package/src/Predicate.ts

@@ -43,7 +43,7 @@ export declare namespace Predicate {
    * @since 3.6.0
    * @category type-level
    */
-  export type Any = Predicate<any>
+  export type Any = Predicate<never>
 }
 
 /**
@@ -1080,7 +1080,7 @@ export const struct: {
   const keys = Object.keys(fields)
   return (a: Record<string, unknown>) => {
     for (const key of keys) {
-      if (!fields[key](a[key])) {
+      if (!fields[key](a[key] as never)) {
         return false
       }
     }

package/src/Request.ts

@@ -8,7 +8,7 @@ import type { DurationInput } from "./Duration.js"
 import type * as Effect from "./Effect.js"
 import type * as Exit from "./Exit.js"
 import type { FiberId } from "./FiberId.js"
-import * as _RequestBlock from "./internal/blockedRequests.js"
+import * as RequestBlock_ from "./internal/blockedRequests.js"
 import * as cache from "./internal/cache.js"
 import * as core from "./internal/core.js"
 import * as fiberRuntime from "./internal/fiberRuntime.js"
@@ -414,10 +414,10 @@ export declare namespace Entry {
  * @since 2.0.0
  * @category guards
  */
-export const isEntry = _RequestBlock.isEntry
+export const isEntry = RequestBlock_.isEntry
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const makeEntry = _RequestBlock.makeEntry
+export const makeEntry = RequestBlock_.makeEntry

package/src/RequestBlock.ts

@@ -1,7 +1,7 @@
 /**
  * @since 2.0.0
  */
-import * as _RequestBlock from "./internal/blockedRequests.js"
+import * as RequestBlock_ from "./internal/blockedRequests.js"
 import type * as Request from "./Request.js"
 import type * as RequestResolver from "./RequestResolver.js"
 
@@ -82,13 +82,13 @@ export interface Single {
 export const single: <A>(
   dataSource: RequestResolver.RequestResolver<A>,
   blockedRequest: Request.Entry<A>
-) => RequestBlock = _RequestBlock.single
+) => RequestBlock = RequestBlock_.single
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const empty: RequestBlock = _RequestBlock.empty
+export const empty: RequestBlock = RequestBlock_.empty
 
 /**
  * @since 2.0.0
@@ -97,22 +97,22 @@ export const empty: RequestBlock = _RequestBlock.empty
 export const mapRequestResolvers: <A>(
   self: RequestBlock,
   f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
-) => RequestBlock = _RequestBlock.mapRequestResolvers
+) => RequestBlock = RequestBlock_.mapRequestResolvers
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const parallel: (self: RequestBlock, that: RequestBlock) => RequestBlock = _RequestBlock.par
+export const parallel: (self: RequestBlock, that: RequestBlock) => RequestBlock = RequestBlock_.par
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const reduce: <Z>(self: RequestBlock, reducer: RequestBlock.Reducer<Z>) => Z = _RequestBlock.reduce
+export const reduce: <Z>(self: RequestBlock, reducer: RequestBlock.Reducer<Z>) => Z = RequestBlock_.reduce
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const sequential: (self: RequestBlock, that: RequestBlock) => RequestBlock = _RequestBlock.seq
+export const sequential: (self: RequestBlock, that: RequestBlock) => RequestBlock = RequestBlock_.seq

package/src/Runtime.ts

@@ -60,7 +60,7 @@ export declare namespace Runtime {
    * @since 3.12.0
    * @category Type Extractors
    */
-  export type Context<T extends Runtime<any>> = [T] extends [Runtime<infer R>] ? R : never
+  export type Context<T extends Runtime<never>> = [T] extends [Runtime<infer R>] ? R : never
 }
 
 /**
@@ -128,10 +128,7 @@ export interface RunCallbackOptions<in A, in E = never> extends RunForkOptions {
  */
 export const runCallback: <R>(
   runtime: Runtime<R>
-) => <A, E>(
-  effect: Effect.Effect<A, E, R>,
-  options?: RunCallbackOptions<A, E> | undefined
-) => (fiberId?: FiberId.FiberId | undefined, options?: RunCallbackOptions<A, E> | undefined) => void =
+) => <A, E>(effect: Effect.Effect<A, E, R>, options?: RunCallbackOptions<A, E> | undefined) => Cancel<A, E> =
   internal.unsafeRunCallback
 
 /**

package/src/Schema.ts

@@ -102,10 +102,6 @@ export interface SchemaClass<A, I = A, R = never> extends AnnotableClass<SchemaC
  */
 export const make = <A, I = A, R = never>(ast: AST.AST): SchemaClass<A, I, R> => (class SchemaClass {
   [TypeId] = variance
-  static Type: A
-  static Encoded: I
-  static Context: R
-  static [TypeId] = variance
   static ast = ast
   static annotations(annotations: Annotations.GenericSchema<A>) {
     return make<A, I, R>(mergeSchemaAnnotations(this.ast, annotations))
@@ -116,6 +112,10 @@ export const make = <A, I = A, R = never>(ast: AST.AST): SchemaClass<A, I, R> =>
   static toString() {
     return String(ast)
   }
+  static Type: A
+  static Encoded: I
+  static Context: R
+  static [TypeId] = variance
 })
 
 const variance = {
@@ -7418,10 +7418,7 @@ export const OptionFromUndefinedOr = <Value extends Schema.Any>(
  */
 export const OptionFromNonEmptyTrimmedString = transform(String$, OptionFromSelf(NonEmptyTrimmedString), {
   strict: true,
-  decode: (s) => {
-    const out = s.trim()
-    return out.length === 0 ? option_.none() : option_.some(out)
-  },
+  decode: (s) => option_.filter(option_.some(s.trim()), string_.isNonEmpty),
   encode: option_.getOrElse(() => "")
 })
 

package/src/Stream.ts

@@ -13,7 +13,7 @@ import type * as Exit from "./Exit.js"
 import type { LazyArg } from "./Function.js"
 import type * as GroupBy from "./GroupBy.js"
 import type { TypeLambda } from "./HKT.js"
-import * as _groupBy from "./internal/groupBy.js"
+import * as groupBy_ from "./internal/groupBy.js"
 import * as internal from "./internal/stream.js"
 import type * as Layer from "./Layer.js"
 import type * as Option from "./Option.js"
@@ -3754,7 +3754,7 @@ export const groupBy: {
     f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: { readonly bufferSize?: number | undefined } | undefined
   ): GroupBy.GroupBy<K, V, E | E2, R | R2>
-} = _groupBy.groupBy
+} = groupBy_.groupBy
 
 /**
  * Partition a stream using a function and process each stream individually.
@@ -3881,7 +3881,7 @@ export const groupByKey: {
       readonly bufferSize?: number | undefined
     }
   ): GroupBy.GroupBy<K, A, E, R>
-} = _groupBy.groupByKey
+} = groupBy_.groupByKey
 
 /**
  * Partitions the stream with specified `chunkSize`.
@@ -5208,7 +5208,7 @@ export const mapEffect: {
     f: (a: A) => Effect.Effect<A2, E2, R2>,
     options: { readonly key: (a: A) => K; readonly bufferSize?: number | undefined }
   ): Stream<A2, E | E2, R | R2>
-} = _groupBy.mapEffectOptions
+} = groupBy_.mapEffectOptions
 
 /**
  * Transforms the errors emitted by this stream using `f`.
@@ -11453,7 +11453,7 @@ export const bindEffect: {
     f: (_: NoInfer<A>) => Effect.Effect<B, E2, R2>,
     options?: { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
   ): Stream<{ [K in keyof A | N]: K extends keyof A ? A[K] : B }, E | E2, R | R2>
-} = _groupBy.bindEffect
+} = groupBy_.bindEffect
 
 /**
  * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.

package/src/Utils.ts

@@ -40,7 +40,7 @@ export type GenKindTypeId = typeof GenKindTypeId
 export interface GenKind<F extends TypeLambda, R, O, E, A> extends Variance<F, R, O, E> {
   readonly value: Kind<F, R, O, E, A>
 
-  [Symbol.iterator](): Generator<GenKind<F, R, O, E, A>, A>
+  [Symbol.iterator](): IterableIterator<GenKind<F, R, O, E, A>, A>
 }
 
 /**
@@ -97,7 +97,7 @@ export class GenKindImpl<F extends TypeLambda, R, O, E, A> implements GenKind<F,
   /**
    * @since 2.0.0
    */
-  [Symbol.iterator](): Generator<GenKind<F, R, O, E, A>, A> {
+  [Symbol.iterator](): IterableIterator<GenKind<F, R, O, E, A>, A> {
     return new SingleShotGen<GenKind<F, R, O, E, A>, A>(this as any)
   }
 }
@@ -106,7 +106,7 @@ export class GenKindImpl<F extends TypeLambda, R, O, E, A> implements GenKind<F,
  * @category constructors
  * @since 2.0.0
  */
-export class SingleShotGen<T, A> implements Generator<T, A> {
+export class SingleShotGen<T, A> implements IterableIterator<T, A> {
   private called = false
 
   constructor(readonly self: T) {}
@@ -147,7 +147,7 @@ export class SingleShotGen<T, A> implements Generator<T, A> {
   /**
    * @since 2.0.0
    */
-  [Symbol.iterator](): Generator<T, A> {
+  [Symbol.iterator](): IterableIterator<T, A> {
     return new SingleShotGen<T, A>(this.self)
   }
 }

package/src/internal/channel.ts

@@ -27,7 +27,7 @@ import * as executor from "./channel/channelExecutor.js"
 import type * as ChannelState from "./channel/channelState.js"
 import * as mergeDecision from "./channel/mergeDecision.js"
 import * as mergeState from "./channel/mergeState.js"
-import * as _mergeStrategy from "./channel/mergeStrategy.js"
+import * as mergeStrategy_ from "./channel/mergeStrategy.js"
 import * as singleProducerAsyncInput from "./channel/singleProducerAsyncInput.js"
 import * as coreEffect from "./core-effect.js"
 import * as core from "./core-stream.js"
@@ -1086,7 +1086,7 @@ export const mergeAllWith = (
   {
     bufferSize = 16,
     concurrency,
-    mergeStrategy = _mergeStrategy.BackPressure()
+    mergeStrategy = mergeStrategy_.BackPressure()
   }: {
     readonly concurrency: number | "unbounded"
     readonly bufferSize?: number | undefined
@@ -1198,7 +1198,7 @@ export const mergeAllWith = (
                   }
                 ),
               onRight: (channel) =>
-                _mergeStrategy.match(mergeStrategy, {
+                mergeStrategy_.match(mergeStrategy, {
                   onBackPressure: () =>
                     Effect.gen(function*() {
                       const latch = yield* Deferred.make<void>()

package/src/internal/core-effect.ts

@@ -99,13 +99,11 @@ export const try_: {
     evaluate = arg.try
     onFailure = arg.catch
   }
-  return core.sync(() => {
+  return core.suspend(() => {
     try {
-      return evaluate()
+      return core.succeed(internalCall(evaluate))
     } catch (error) {
-      throw core.makeEffectError(internalCause.fail(
-        onFailure ? onFailure(error) : new core.UnknownException(error)
-      ))
+      return core.fail(onFailure ? internalCall(() => onFailure(error)) : new core.UnknownException(error))
     }
   })
 }
@@ -1600,7 +1598,7 @@ export const tapErrorCause = dual<
 /* @internal */
 export const timed = <A, E, R>(
   self: Effect.Effect<A, E, R>
-): Effect.Effect<[Duration.Duration, A], E, R> => timedWith(self, Clock.currentTimeNanos)
+): Effect.Effect<[duration: Duration.Duration, result: A], E, R> => timedWith(self, Clock.currentTimeNanos)
 
 /* @internal */
 export const timedWith = dual<

package/src/internal/core.ts

@@ -38,7 +38,7 @@ import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
 import type { NoInfer, NotFunction } from "../Types.js"
 import { internalCall, YieldWrap } from "../Utils.js"
-import * as _blockedRequests from "./blockedRequests.js"
+import * as blockedRequests_ from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
 import * as internalDiffer from "./differ.js"
@@ -48,39 +48,13 @@ import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
 import * as DeferredOpCodes from "./opCodes/deferred.js"
 import * as OpCodes from "./opCodes/effect.js"
-import * as _runtimeFlags from "./runtimeFlags.js"
+import * as runtimeFlags_ from "./runtimeFlags.js"
 import { SingleShotGen } from "./singleShotGen.js"
 
 // -----------------------------------------------------------------------------
 // Effect
 // -----------------------------------------------------------------------------
 
-/** @internal */
-const EffectErrorSymbolKey = "effect/EffectError"
-
-/** @internal */
-export const EffectErrorTypeId = Symbol.for(EffectErrorSymbolKey)
-
-/** @internal */
-export type EffectErrorTypeId = typeof EffectErrorTypeId
-
-/** @internal */
-export interface EffectError<out E> {
-  readonly [EffectErrorTypeId]: EffectErrorTypeId
-  readonly _tag: "EffectError"
-  readonly cause: Cause.Cause<E>
-}
-
-/** @internal */
-export const isEffectError = (u: unknown): u is EffectError<unknown> => hasProperty(u, EffectErrorTypeId)
-
-/** @internal */
-export const makeEffectError = <E>(cause: Cause.Cause<E>): EffectError<E> => ({
-  [EffectErrorTypeId]: EffectErrorTypeId,
-  _tag: "EffectError",
-  cause
-})
-
 /**
  * @internal
  */
@@ -677,7 +651,7 @@ export const catchSome = dual<
 /* @internal */
 export const checkInterruptible = <A, E, R>(
   f: (isInterruptible: boolean) => Effect.Effect<A, E, R>
-): Effect.Effect<A, E, R> => withFiberRuntime((_, status) => f(_runtimeFlags.interruption(status.runtimeFlags)))
+): Effect.Effect<A, E, R> => withFiberRuntime((_, status) => f(runtimeFlags_.interruption(status.runtimeFlags)))
 
 const spanSymbol = Symbol.for("effect/SpanAnnotation")
 const originalSymbol = Symbol.for("effect/OriginalAnnotation")
@@ -1027,7 +1001,7 @@ export const interruptWith = (fiberId: FiberId.FiberId): Effect.Effect<never> =>
 /* @internal */
 export const interruptible = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-  effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
+  effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(runtimeFlags_.Interruption)
   effect.effect_instruction_i1 = () => self
   return effect
 }
@@ -1038,9 +1012,9 @@ export const interruptibleMask = <A, E, R>(
 ): Effect.Effect<A, E, R> =>
   custom(f, function() {
     const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-    effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
+    effect.effect_instruction_i0 = RuntimeFlagsPatch.enable(runtimeFlags_.Interruption)
     effect.effect_instruction_i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
-      _runtimeFlags.interruption(oldFlags)
+      runtimeFlags_.interruption(oldFlags)
         ? internalCall(() => this.effect_instruction_i0(interruptible))
         : internalCall(() => this.effect_instruction_i0(uninterruptible))
     return effect
@@ -1356,7 +1330,7 @@ export const uninterruptible: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.
   self: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-  effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
+  effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(runtimeFlags_.Interruption)
   effect.effect_instruction_i1 = () => self
   return effect
 }
@@ -1367,9 +1341,9 @@ export const uninterruptibleMask = <A, E, R>(
 ): Effect.Effect<A, E, R> =>
   custom(f, function() {
     const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
-    effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
+    effect.effect_instruction_i0 = RuntimeFlagsPatch.disable(runtimeFlags_.Interruption)
     effect.effect_instruction_i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
-      _runtimeFlags.interruption(oldFlags)
+      runtimeFlags_.interruption(oldFlags)
         ? internalCall(() => this.effect_instruction_i0(interruptible))
         : internalCall(() => this.effect_instruction_i0(uninterruptible))
     return effect
@@ -1904,17 +1878,17 @@ export const requestBlockLocally = <A>(
   self: BlockedRequests.RequestBlock,
   ref: FiberRef.FiberRef<A>,
   value: A
-): BlockedRequests.RequestBlock => _blockedRequests.reduce(self, LocallyReducer(ref, value))
+): BlockedRequests.RequestBlock => blockedRequests_.reduce(self, LocallyReducer(ref, value))
 
 const LocallyReducer = <A>(
   ref: FiberRef.FiberRef<A>,
   value: A
 ): BlockedRequests.RequestBlock.Reducer<BlockedRequests.RequestBlock> => ({
-  emptyCase: () => _blockedRequests.empty,
-  parCase: (left, right) => _blockedRequests.par(left, right),
-  seqCase: (left, right) => _blockedRequests.seq(left, right),
+  emptyCase: () => blockedRequests_.empty,
+  parCase: (left, right) => blockedRequests_.par(left, right),
+  seqCase: (left, right) => blockedRequests_.seq(left, right),
   singleCase: (dataSource, blockedRequest) =>
-    _blockedRequests.single(
+    blockedRequests_.single(
       resolverLocally(dataSource, ref, value),
       blockedRequest as any
     )
@@ -2017,8 +1991,8 @@ export const fiberRefUnsafeMakeRuntimeFlags = (
   initial: RuntimeFlags.RuntimeFlags
 ): FiberRef.FiberRef<RuntimeFlags.RuntimeFlags> =>
   fiberRefUnsafeMakePatch(initial, {
-    differ: _runtimeFlags.differ,
-    fork: _runtimeFlags.differ.empty
+    differ: runtimeFlags_.differ,
+    fork: runtimeFlags_.differ.empty
   })
 
 /** @internal */
@@ -3024,9 +2998,9 @@ export const contextWith = <R0, A>(
 ): Effect.Effect<A, never, R0> => map(context<R0>(), f)
 
 /* @internal */
-export const contextWithEffect = <R0, A, E, R>(
-  f: (context: Context.Context<R0>) => Effect.Effect<A, E, R>
-): Effect.Effect<A, E, R | R0> => flatMap(context<R0>(), f)
+export const contextWithEffect = <R2, A, E, R>(
+  f: (context: Context.Context<R2>) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R | R2> => flatMap(context<R2>(), f)
 
 /* @internal */
 export const provideContext = dual<
@@ -3050,17 +3024,17 @@ export const provideSomeContext = dual<
 
 /* @internal */
 export const mapInputContext = dual<
-  <R0, R>(
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => <A, E>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R0>,
-  <A, E, R, R0>(
+  <R2, R>(
+    f: (context: Context.Context<R2>) => Context.Context<R>
+  ) => <A, E>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R2>,
+  <A, E, R, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => Effect.Effect<A, E, R0>
->(2, <A, E, R, R0>(
+    f: (context: Context.Context<R2>) => Context.Context<R>
+  ) => Effect.Effect<A, E, R2>
+>(2, <A, E, R, R2>(
   self: Effect.Effect<A, E, R>,
-  f: (context: Context.Context<R0>) => Context.Context<R>
-) => contextWithEffect((context: Context.Context<R0>) => provideContext(self, f(context))))
+  f: (context: Context.Context<R2>) => Context.Context<R>
+) => contextWithEffect((context: Context.Context<R2>) => provideContext(self, f(context))))
 
 // -----------------------------------------------------------------------------
 // Tracing

package/src/internal/defaultServices.ts

@@ -64,29 +64,29 @@ export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => cloc
 
 /** @internal */
 export const withClock = dual<
-  <X extends Clock.Clock>(value: X) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <X extends Clock.Clock, A, E, R>(effect: Effect.Effect<A, E, R>, value: X) => Effect.Effect<A, E, R>
->(2, (effect, value) =>
+  <C extends Clock.Clock>(clock: C) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <C extends Clock.Clock, A, E, R>(effect: Effect.Effect<A, E, R>, clock: C) => Effect.Effect<A, E, R>
+>(2, (effect, c) =>
   core.fiberRefLocallyWith(
     currentServices,
-    Context.add(clock.clockTag, value)
+    Context.add(clock.clockTag, c)
   )(effect))
 
 // circular with ConfigProvider
 
 /** @internal */
 export const withConfigProvider = dual<
-  (value: ConfigProvider.ConfigProvider) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(effect: Effect.Effect<A, E, R>, value: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
->(2, (effect, value) =>
+  (provider: ConfigProvider.ConfigProvider) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, provider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
+>(2, (self, provider) =>
   core.fiberRefLocallyWith(
     currentServices,
-    Context.add(configProvider.configProviderTag, value)
-  )(effect))
+    Context.add(configProvider.configProviderTag, provider)
+  )(self))
 
 /** @internal */
 export const configProviderWith = <A, E, R>(
-  f: (configProvider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
+  f: (provider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> =>
   defaultServicesWith((services) => f(services.unsafeMap.get(configProvider.configProviderTag.key)))