effect 3.12.11 → 3.12.12

package/src/internal/core-effect.ts

@@ -26,7 +26,7 @@ import type * as Random from "../Random.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
+import type * as Types from "../Types.js"
 import type { Unify } from "../Unify.js"
 import { internalCall } from "../Utils.js"
 import * as internalCause from "./cause.js"
@@ -175,17 +175,17 @@ export const catchAllDefect = dual<
 /* @internal */
 export const catchSomeCause: {
   <E, A2, E2, R2>(
-    f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E | E2, R2 | R>
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
   ): Effect.Effect<A2 | A, E | E2, R2 | R>
 } = dual(
   2,
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (cause: Cause.Cause<NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Option.Option<Effect.Effect<A2, E2, R2>>
   ): Effect.Effect<A2 | A, E | E2, R2 | R> =>
     core.matchCauseEffect(self, {
       onFailure: (cause): Effect.Effect<A2, E | E2, R2> => {
@@ -376,14 +376,14 @@ export const Do: Effect.Effect<{}> = core.succeed({})
 export const bind: {
   <N extends string, A extends object, B, E2, R2>(
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+    f: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): <E1, R1>(
     self: Effect.Effect<A, E1, R1>
   ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E1, R2 | R1>
   <A extends object, N extends string, E1, R1, B, E2, R2>(
     self: Effect.Effect<A, E1, R1>,
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+    f: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
 } = doNotation.bind<Effect.EffectTypeLambda>(core.map, core.flatMap)
 
@@ -397,21 +397,21 @@ export const bindTo: {
 export const let_: {
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => B
+    f: (a: Types.NoInfer<A>) => B
   ): <E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
   <A extends object, N extends string, E, R, B>(
     self: Effect.Effect<A, E, R>,
     name: Exclude<N, keyof A>,
-    f: (a: NoInfer<A>) => B
+    f: (a: Types.NoInfer<A>) => B
   ): Effect.Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
 } = doNotation.let_<Effect.EffectTypeLambda>(core.map)
 
 /* @internal */
 export const dropUntil: {
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
@@ -447,7 +447,7 @@ export const dropUntil: {
 /* @internal */
 export const dropWhile: {
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
@@ -506,12 +506,12 @@ export const filterMap = dual<
 /* @internal */
 export const filterOrDie: {
   <A, B extends A>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orDieWith: (a: NoInfer<A>) => unknown
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orDieWith: (a: Types.NoInfer<A>) => unknown
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
   <A>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orDieWith: (a: NoInfer<A>) => unknown
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orDieWith: (a: Types.NoInfer<A>) => unknown
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
@@ -535,11 +535,11 @@ export const filterOrDie: {
 /* @internal */
 export const filterOrDieMessage: {
   <A, B extends A>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
     message: string
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
   <A>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
     message: string
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R, B extends A>(
@@ -557,12 +557,12 @@ export const filterOrDieMessage: {
 /* @internal */
 export const filterOrElse: {
   <A, B extends A, C, E2, R2>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orElse: (a: Types.NoInfer<A>) => Effect.Effect<C, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
   <A, B, E2, R2>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orElse: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orElse: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | B, E2 | E, R2 | R>
   <A, E, R, B extends A, C, E2, R2>(
     self: Effect.Effect<A, E, R>,
@@ -588,12 +588,12 @@ export const filterOrElse: {
 export const liftPredicate = dual<
   {
     <A, B extends A, E>(
-      refinement: Predicate.Refinement<NoInfer<A>, B>,
-      orFailWith: (a: NoInfer<A>) => E
+      refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+      orFailWith: (a: Types.NoInfer<A>) => E
     ): (a: A) => Effect.Effect<B, E>
     <A, E>(
-      predicate: Predicate.Predicate<NoInfer<A>>,
-      orFailWith: (a: NoInfer<A>) => E
+      predicate: Predicate.Predicate<Types.NoInfer<A>>,
+      orFailWith: (a: Types.NoInfer<A>) => E
     ): (a: A) => Effect.Effect<A, E>
   },
   {
@@ -604,34 +604,34 @@ export const liftPredicate = dual<
     ): Effect.Effect<B, E>
     <A, E>(
       self: A,
-      predicate: Predicate.Predicate<NoInfer<A>>,
-      orFailWith: (a: NoInfer<A>) => E
+      predicate: Predicate.Predicate<Types.NoInfer<A>>,
+      orFailWith: (a: Types.NoInfer<A>) => E
     ): Effect.Effect<A, E>
   }
 >(
   3,
   <A, E>(
     self: A,
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orFailWith: (a: Types.NoInfer<A>) => E
   ): Effect.Effect<A, E> => core.suspend(() => predicate(self) ? core.succeed(self) : core.fail(orFailWith(self)))
 )
 
 /* @internal */
 export const filterOrFail: {
   <A, B extends A, E2>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orFailWith: (a: NoInfer<A>) => E2
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+    orFailWith: (a: Types.NoInfer<A>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
   <A, E2>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E2
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orFailWith: (a: Types.NoInfer<A>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
   <A, B extends A>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementException | E, R>
   <A>(
-    predicate: Predicate.Predicate<NoInfer<A>>
+    predicate: Predicate.Predicate<Types.NoInfer<A>>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementException | E, R>
   <A, E, R, B extends A, E2>(
     self: Effect.Effect<A, E, R>,
@@ -666,17 +666,17 @@ export const filterOrFail: {
 /* @internal */
 export const findFirst: {
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Option.Option<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R> =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
@@ -1195,25 +1195,25 @@ export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): E
 
 /* @internal */
 export const provideService = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    service: Context.Tag.Service<T>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>,
-  <A, E, R, T extends Context.Tag<any, any>>(
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, I>>,
+  <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    service: Context.Tag.Service<T>
-  ) => Effect.Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>>
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ) => Effect.Effect<A, E, Exclude<R, I>>
 >(
   3,
-  <A, E, R, T extends Context.Tag<any, any>>(
+  <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    service: Context.Tag.Service<T>
-  ): Effect.Effect<A, E, Exclude<R, Context.Tag.Identifier<T>>> =>
+    tag: Context.Tag<I, S>,
+    service: Types.NoInfer<S>
+  ): Effect.Effect<A, E, Exclude<R, I>> =>
     core.contextWithEffect((env) =>
       core.provideContext(
-        self as Effect.Effect<A, E, Context.Tag.Identifier<T> | Exclude<R, Context.Tag.Identifier<T>>>,
+        self as Effect.Effect<A, E, I | Exclude<R, I>>,
         Context.add(env, tag, service)
       )
     )
@@ -1221,21 +1221,21 @@ export const provideService = dual<
 
 /* @internal */
 export const provideServiceEffect = dual<
-  <T extends Context.Tag<any, any>, E1, R1>(
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>,
-  <A, E, R, T extends Context.Tag<any, any>, E1, R1>(
+  <I, S, E1, R1>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E1, R1 | Exclude<R, I>>,
+  <A, E, R, I, S, E1, R1>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ) => Effect.Effect<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>
->(3, <A, E, R, T extends Context.Tag<any, any>, E1, R1>(
+    tag: Context.Tag<I, S>,
+    effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
+  ) => Effect.Effect<A, E | E1, R1 | Exclude<R, I>>
+>(3, <A, E, R, I, S, E1, R1>(
   self: Effect.Effect<A, E, R>,
-  tag: T,
-  effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
+  tag: Context.Tag<I, S>,
+  effect: Effect.Effect<Types.NoInfer<S>, E1, R1>
 ) =>
-  core.contextWithEffect((env: Context.Context<R1 | Exclude<R, Context.Tag.Identifier<T>>>) =>
+  core.contextWithEffect((env: Context.Context<R1 | Exclude<R, I>>) =>
     core.flatMap(
       effect,
       (service) => core.provideContext(self, pipe(env, Context.add(tag, service)) as Context.Context<R | R1>)
@@ -1426,17 +1426,17 @@ export const labelMetrics = dual<
 /* @internal */
 export const takeUntil: {
   <A, R, E>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Array<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Array<A>, E, R> =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
@@ -1462,15 +1462,15 @@ export const takeUntil: {
 /* @internal */
 export const takeWhile = dual<
   <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ) => (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>,
   <A, E, R>(
     elements: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ) => Effect.Effect<Array<A>, E, R>
 >(
   2,
-  <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>) =>
+  <A, E, R>(elements: Iterable<A>, predicate: (a: Types.NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>) =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
       const builder: Array<A> = []
@@ -1499,8 +1499,8 @@ export const takeWhile = dual<
 export const tapBoth = dual<
   <E, X, E2, R2, A, X1, E3, R3>(
     options: {
-      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<X, E2, R2>
-      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<X1, E3, R3>
+      readonly onFailure: (e: Types.NoInfer<E>) => Effect.Effect<X, E2, R2>
+      readonly onSuccess: (a: Types.NoInfer<A>) => Effect.Effect<X1, E3, R3>
     }
   ) => <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2 | E3, R | R2 | R3>,
   <A, E, R, X, E2, R2, X1, E3, R3>(
@@ -1545,7 +1545,7 @@ export const tapDefect = dual<
 /* @internal */
 export const tapError = dual<
   <E, X, E2, R2>(
-    f: (e: NoInfer<E>) => Effect.Effect<X, E2, R2>
+    f: (e: Types.NoInfer<E>) => Effect.Effect<X, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>,
   <A, E, R, X, E2, R2>(
     self: Effect.Effect<A, E, R>,
@@ -1587,7 +1587,7 @@ export const tapErrorTag = dual<
 /* @internal */
 export const tapErrorCause = dual<
   <E, X, E2, R2>(
-    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<X, E2, R2>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Effect.Effect<X, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>,
   <A, E, R, X, E2, R2>(
     self: Effect.Effect<A, E, R>,
@@ -1768,26 +1768,26 @@ export const updateFiberRefs = (
 
 /* @internal */
 export const updateService = dual<
-  <T extends Context.Tag<any, any>>(
-    tag: T,
-    f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Context.Tag.Identifier<T>>,
-  <A, E, R, T extends Context.Tag<any, any>>(
+  <I, S>(
+    tag: Context.Tag<I, S>,
+    f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | I>,
+  <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    tag: T,
-    f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ) => Effect.Effect<A, E, R | Context.Tag.Identifier<T>>
->(3, <A, E, R, T extends Context.Tag<any, any>>(
+    tag: Context.Tag<I, S>,
+    f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
+  ) => Effect.Effect<A, E, R | I>
+>(3, <A, E, R, I, S>(
   self: Effect.Effect<A, E, R>,
-  tag: T,
-  f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>
+  tag: Context.Tag<I, S>,
+  f: (service: Types.NoInfer<S>) => Types.NoInfer<S>
 ) =>
   core.mapInputContext(self, (context) =>
     Context.add(
       context,
       tag,
       f(Context.unsafeGet(context, tag))
-    )) as Effect.Effect<A, E, R | Context.Tag.Identifier<T>>)
+    )) as Effect.Effect<A, E, R | I>)
 
 /* @internal */
 export const when = dual<

package/src/internal/effect/circular.ts

@@ -371,10 +371,11 @@ export const forkIn = dual<
               core.void :
               core.asVoid(core.interruptFiber(fiber))
           )
-        scopeImpl.state.finalizers.add(finalizer)
+        const key = {}
+        scopeImpl.state.finalizers.set(key, finalizer)
         fiber.addObserver(() => {
           if (scopeImpl.state._tag === "Closed") return
-          scopeImpl.state.finalizers.delete(finalizer)
+          scopeImpl.state.finalizers.delete(key)
         })
       } else {
         fiber.unsafeInterruptAsFork(parent.id())

package/src/internal/fiberRuntime.ts

@@ -3211,7 +3211,7 @@ export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
 export interface ScopeImpl extends Scope.CloseableScope {
   state: {
     readonly _tag: "Open"
-    readonly finalizers: Set<Scope.Scope.Finalizer>
+    readonly finalizers: Map<{}, Scope.Scope.Finalizer>
   } | {
     readonly _tag: "Closed"
     readonly exit: Exit.Exit<unknown, unknown>
@@ -3220,7 +3220,7 @@ export interface ScopeImpl extends Scope.CloseableScope {
 
 const scopeUnsafeAddFinalizer = (scope: ScopeImpl, fin: Scope.Scope.Finalizer): void => {
   if (scope.state._tag === "Open") {
-    scope.state.finalizers.add(fin)
+    scope.state.finalizers.set({}, fin)
   }
 }
 
@@ -3237,12 +3237,13 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
         newScope.state = this.state
         return newScope
       }
+      const key = {}
       const fin = (exit: Exit.Exit<unknown, unknown>) => newScope.close(exit)
-      this.state.finalizers.add(fin)
+      this.state.finalizers.set(key, fin)
       scopeUnsafeAddFinalizer(newScope, (_) =>
         core.sync(() => {
           if (this.state._tag === "Open") {
-            this.state.finalizers.delete(fin)
+            this.state.finalizers.delete(key)
           }
         }))
       return newScope
@@ -3297,7 +3298,7 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
       if (this.state._tag === "Closed") {
         return fin(this.state.exit)
       }
-      this.state.finalizers.add(fin)
+      this.state.finalizers.set({}, fin)
       return core.void
     })
   }
@@ -3308,7 +3309,7 @@ const scopeUnsafeMake = (
 ): ScopeImpl => {
   const scope = Object.create(ScopeImplProto)
   scope.strategy = strategy
-  scope.state = { _tag: "Open", finalizers: new Set() }
+  scope.state = { _tag: "Open", finalizers: new Map() }
   return scope
 }
 

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>