effect 3.12.0 → 3.12.2

package/src/internal/effect/circular.ts

@@ -32,7 +32,7 @@ import * as internalFiber from "../fiber.js"
 import * as fiberRuntime from "../fiberRuntime.js"
 import { globalScope } from "../fiberScope.js"
 import * as internalRef from "../ref.js"
-import * as _schedule from "../schedule.js"
+import * as schedule_ from "../schedule.js"
 import * as supervisor from "../supervisor.js"
 
 /** @internal */
@@ -480,7 +480,7 @@ export const scheduleForked = dual<
     self: Effect.Effect<A, E, R>,
     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))
+>(2, (self, schedule) => pipe(self, schedule_.schedule_Effect(schedule), forkScoped))
 
 /** @internal */
 export const supervised = dual<
@@ -583,58 +583,63 @@ export const timeoutTo = dual<
       readonly duration: Duration.DurationInput
     }
   ) => Effect.Effect<B | B1, E, R>
->(2, (self, { duration, onSuccess, onTimeout }) =>
-  core.fiberIdWith((parentFiberId) =>
-    fiberRuntime.raceFibersWith(
-      self,
-      core.interruptible(effect.sleep(duration)),
-      {
-        onSelfWin: (winner, loser) =>
-          core.flatMap(
-            winner.await,
-            (exit) => {
-              if (exit._tag === "Success") {
-                return core.flatMap(
-                  winner.inheritAll,
-                  () =>
-                    core.as(
+>(
+  2,
+  (self, { duration, onSuccess, onTimeout }) =>
+    core.fiberIdWith((parentFiberId) =>
+      core.uninterruptibleMask((restore) =>
+        fiberRuntime.raceFibersWith(
+          restore(self),
+          core.interruptible(effect.sleep(duration)),
+          {
+            onSelfWin: (winner, loser) =>
+              core.flatMap(
+                winner.await,
+                (exit) => {
+                  if (exit._tag === "Success") {
+                    return core.flatMap(
+                      winner.inheritAll,
+                      () =>
+                        core.as(
+                          core.interruptAsFiber(loser, parentFiberId),
+                          onSuccess(exit.value)
+                        )
+                    )
+                  } else {
+                    return core.flatMap(
                       core.interruptAsFiber(loser, parentFiberId),
-                      onSuccess(exit.value)
+                      () => core.exitFailCause(exit.cause)
                     )
-                )
-              } else {
-                return core.flatMap(
-                  core.interruptAsFiber(loser, parentFiberId),
-                  () => core.exitFailCause(exit.cause)
-                )
-              }
-            }
-          ),
-        onOtherWin: (winner, loser) =>
-          core.flatMap(
-            winner.await,
-            (exit) => {
-              if (exit._tag === "Success") {
-                return core.flatMap(
-                  winner.inheritAll,
-                  () =>
-                    core.as(
+                  }
+                }
+              ),
+            onOtherWin: (winner, loser) =>
+              core.flatMap(
+                winner.await,
+                (exit) => {
+                  if (exit._tag === "Success") {
+                    return core.flatMap(
+                      winner.inheritAll,
+                      () =>
+                        core.as(
+                          core.interruptAsFiber(loser, parentFiberId),
+                          onTimeout()
+                        )
+                    )
+                  } else {
+                    return core.flatMap(
                       core.interruptAsFiber(loser, parentFiberId),
-                      onTimeout()
+                      () => core.exitFailCause(exit.cause)
                     )
-                )
-              } else {
-                return core.flatMap(
-                  core.interruptAsFiber(loser, parentFiberId),
-                  () => core.exitFailCause(exit.cause)
-                )
-              }
-            }
-          ),
-        otherScope: globalScope
-      }
+                  }
+                }
+              ),
+            otherScope: globalScope
+          }
+        )
+      )
     )
-  ))
+)
 
 // circular with Synchronized
 

package/src/internal/fiberRefs/patch.ts

@@ -4,7 +4,7 @@ import type * as FiberId from "../../FiberId.js"
 import type * as FiberRefs from "../../FiberRefs.js"
 import type * as FiberRefsPatch from "../../FiberRefsPatch.js"
 import { dual } from "../../Function.js"
-import * as _fiberRefs from "../fiberRefs.js"
+import * as fiberRefs_ from "../fiberRefs.js"
 
 /** @internal */
 export const OP_EMPTY = "Empty" as const
@@ -111,7 +111,7 @@ export const patch = dual<
         break
       }
       case OP_ADD: {
-        fiberRefs = _fiberRefs.updateAs(fiberRefs, {
+        fiberRefs = fiberRefs_.updateAs(fiberRefs, {
           fiberId,
           fiberRef: head.fiberRef,
           value: head.value
@@ -120,13 +120,13 @@ export const patch = dual<
         break
       }
       case OP_REMOVE: {
-        fiberRefs = _fiberRefs.delete_(fiberRefs, head.fiberRef)
+        fiberRefs = fiberRefs_.delete_(fiberRefs, head.fiberRef)
         patches = tail
         break
       }
       case OP_UPDATE: {
-        const value = _fiberRefs.getOrDefault(fiberRefs, head.fiberRef)
-        fiberRefs = _fiberRefs.updateAs(fiberRefs, {
+        const value = fiberRefs_.getOrDefault(fiberRefs, head.fiberRef)
+        fiberRefs = fiberRefs_.updateAs(fiberRefs, {
           fiberId,
           fiberRef: head.fiberRef,
           value: head.fiberRef.patch(head.patch)(value)

package/src/internal/fiberRuntime.ts

@@ -45,7 +45,7 @@ import type * as Supervisor from "../Supervisor.js"
 import type * as Tracer from "../Tracer.js"
 import type { Concurrency, NoInfer } from "../Types.js"
 import { internalCall, yieldWrapGet } from "../Utils.js"
-import * as _RequestBlock from "./blockedRequests.js"
+import * as RequestBlock_ from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as clock from "./clock.js"
 import { currentRequestMap } from "./completedRequestMap.js"
@@ -67,7 +67,7 @@ import * as metricLabel from "./metric/label.js"
 import * as OpCodes from "./opCodes/effect.js"
 import { randomTag } from "./random.js"
 import { complete } from "./request.js"
-import * as _runtimeFlags from "./runtimeFlags.js"
+import * as runtimeFlags_ from "./runtimeFlags.js"
 import { OpSupervision } from "./runtimeFlags.js"
 import * as supervisor from "./supervisor.js"
 import * as SupervisorPatch from "./supervisor/patch.js"
@@ -171,7 +171,7 @@ const contOpSuccess = {
     value: unknown
   ) => {
     self.patchRuntimeFlags(self.currentRuntimeFlags, cont.patch)
-    if (_runtimeFlags.interruptible(self.currentRuntimeFlags) && self.isInterrupted()) {
+    if (runtimeFlags_.interruptible(self.currentRuntimeFlags) && self.isInterrupted()) {
       return core.exitFailCause(self.getInterruptedCause())
     } else {
       return core.exitSucceed(value)
@@ -210,7 +210,7 @@ const drainQueueWhileRunningTable = {
     message: FiberMessage.FiberMessage & { _tag: FiberMessage.OP_INTERRUPT_SIGNAL }
   ) => {
     self.processNewInterruptSignal(message.cause)
-    return _runtimeFlags.interruptible(runtimeFlags) ? core.exitFailCause(message.cause) : cur
+    return runtimeFlags_.interruptible(runtimeFlags) ? core.exitFailCause(message.cause) : cur
   },
   [FiberMessage.OP_RESUME]: (
     _self: FiberRuntime<any, any>,
@@ -244,10 +244,10 @@ const drainQueueWhileRunningTable = {
  */
 const runBlockedRequests = (self: RequestBlock.RequestBlock) =>
   core.forEachSequentialDiscard(
-    _RequestBlock.flatten(self),
+    RequestBlock_.flatten(self),
     (requestsByRequestResolver) =>
       forEachConcurrentDiscard(
-        _RequestBlock.sequentialCollectionToChunk(requestsByRequestResolver),
+        RequestBlock_.sequentialCollectionToChunk(requestsByRequestResolver),
         ([dataSource, sequential]) => {
           const map = new Map<Request<any, any>, Entry<any>>()
           const arr: Array<Array<Entry<any>>> = []
@@ -278,6 +278,8 @@ export interface Snapshot {
   flags: RuntimeFlags.RuntimeFlags
 }
 
+const _version = version.getCurrentVersion()
+
 /** @internal */
 export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A, E>
   implements Fiber.RuntimeFiber<A, E>
@@ -315,7 +317,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     this.currentRuntimeFlags = runtimeFlags0
     this._fiberId = fiberId
     this._fiberRefs = fiberRefs0
-    if (_runtimeFlags.runtimeMetrics(runtimeFlags0)) {
+    if (runtimeFlags_.runtimeMetrics(runtimeFlags0)) {
       const tags = this.getFiberRef(core.currentMetricLabels)
       fiberStarted.unsafeUpdate(1, tags)
       fiberActive.unsafeUpdate(1, tags)
@@ -472,10 +474,10 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
       const updatedRuntimeFlags = parentFiber.getFiberRef(currentRuntimeFlags)
 
       const patch = pipe(
-        _runtimeFlags.diff(parentRuntimeFlags, updatedRuntimeFlags),
+        runtimeFlags_.diff(parentRuntimeFlags, updatedRuntimeFlags),
         // Do not inherit WindDown or Interruption!
-        RuntimeFlagsPatch.exclude(_runtimeFlags.Interruption),
-        RuntimeFlagsPatch.exclude(_runtimeFlags.WindDown)
+        RuntimeFlagsPatch.exclude(runtimeFlags_.Interruption),
+        RuntimeFlagsPatch.exclude(runtimeFlags_.WindDown)
       )
 
       return core.updateRuntimeFlags(patch)
@@ -802,7 +804,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
   }
 
   reportExitValue(exit: Exit.Exit<A, E>) {
-    if (_runtimeFlags.runtimeMetrics(this.currentRuntimeFlags)) {
+    if (runtimeFlags_.runtimeMetrics(this.currentRuntimeFlags)) {
       const tags = this.getFiberRef(core.currentMetricLabels)
       const startTimeMillis = this.id().startTimeMillis
       const endTimeMillis = Date.now()
@@ -926,7 +928,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     this.currentSupervisor.onResume(this)
     try {
       let effect: Effect.Effect<any, any, any> | null =
-        _runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted() ?
+        runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted() ?
           core.exitFailCause(this.getInterruptedCause()) :
           effect0
       while (effect !== null) {
@@ -936,7 +938,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
           const op = yieldedOpChannel.currentOp!
           yieldedOpChannel.currentOp = null
           if (op._op === OpCodes.OP_YIELD) {
-            if (_runtimeFlags.cooperativeYielding(this.currentRuntimeFlags)) {
+            if (runtimeFlags_.cooperativeYielding(this.currentRuntimeFlags)) {
               this.tell(FiberMessage.yieldNow())
               this.tell(FiberMessage.resume(core.exitVoid))
               effect = null
@@ -948,7 +950,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
             effect = null
           }
         } else {
-          this.currentRuntimeFlags = pipe(this.currentRuntimeFlags, _runtimeFlags.enable(_runtimeFlags.WindDown))
+          this.currentRuntimeFlags = pipe(this.currentRuntimeFlags, runtimeFlags_.enable(runtimeFlags_.WindDown))
           const interruption = this.interruptAllChildren()
           if (interruption !== null) {
             effect = core.flatMap(interruption, () => exit)
@@ -1020,7 +1022,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
    * **NOTE**: This method must be invoked by the fiber itself.
    */
   patchRuntimeFlags(oldRuntimeFlags: RuntimeFlags.RuntimeFlags, patch: RuntimeFlagsPatch.RuntimeFlagsPatch) {
-    const newRuntimeFlags = _runtimeFlags.patch(oldRuntimeFlags, patch)
+    const newRuntimeFlags = runtimeFlags_.patch(oldRuntimeFlags, patch)
     ;(globalThis as any)[internalFiber.currentFiberURI] = this
     this.currentRuntimeFlags = newRuntimeFlags
     return newRuntimeFlags
@@ -1044,7 +1046,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
         this.tell(FiberMessage.resume(effect))
       }
     }
-    if (_runtimeFlags.interruptible(runtimeFlags)) {
+    if (runtimeFlags_.interruptible(runtimeFlags)) {
       this._asyncInterruptor = callback
     }
     try {
@@ -1180,14 +1182,14 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
       switch (cont._op) {
         case OpCodes.OP_ON_FAILURE:
         case OpCodes.OP_ON_SUCCESS_AND_FAILURE: {
-          if (!(_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
+          if (!(runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
             return internalCall(() => cont.effect_instruction_i1(cause))
           } else {
             return core.exitFailCause(internalCause.stripFailures(cause))
           }
         }
         case "OnStep": {
-          if (!(_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
+          if (!(runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
             return core.exitSucceed(core.exitFailCause(cause))
           } else {
             return core.exitFailCause(internalCause.stripFailures(cause))
@@ -1195,7 +1197,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
         }
         case OpCodes.OP_REVERT_FLAGS: {
           this.patchRuntimeFlags(this.currentRuntimeFlags, cont.patch)
-          if (_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted()) {
+          if (runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted()) {
             return core.exitFailCause(internalCause.sequential(cause, this.getInterruptedCause()))
           } else {
             return core.exitFailCause(cause)
@@ -1234,7 +1236,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
       this.setFiberRefs(snap.refs)
       this.currentRuntimeFlags = snap.flags
       const patchRefs = FiberRefsPatch.diff(snap.refs, refs)
-      const patchFlags = _runtimeFlags.diff(snap.flags, flags)
+      const patchFlags = runtimeFlags_.diff(snap.flags, flags)
       return core.exitSucceed(core.blocked(
         op.effect_instruction_i0,
         core.withFiberRuntime<unknown, unknown>((newFiber) => {
@@ -1244,7 +1246,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
           newFiber.setFiberRefs(
             FiberRefsPatch.patch(newFiber.id(), newFiber.getFiberRefs())(patchRefs)
           )
-          newFiber.currentRuntimeFlags = _runtimeFlags.patch(patchFlags)(newFiber.currentRuntimeFlags)
+          newFiber.currentRuntimeFlags = runtimeFlags_.patch(patchFlags)(newFiber.currentRuntimeFlags)
           return op.effect_instruction_i1
         })
       ))
@@ -1264,19 +1266,19 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
   [OpCodes.OP_UPDATE_RUNTIME_FLAGS](op: core.Primitive & { _op: OpCodes.OP_UPDATE_RUNTIME_FLAGS }) {
     const updateFlags = op.effect_instruction_i0
     const oldRuntimeFlags = this.currentRuntimeFlags
-    const newRuntimeFlags = _runtimeFlags.patch(oldRuntimeFlags, updateFlags)
+    const newRuntimeFlags = runtimeFlags_.patch(oldRuntimeFlags, updateFlags)
     // One more chance to short circuit: if we're immediately going
     // to interrupt. Interruption will cause immediate reversion of
     // the flag, so as long as we "peek ahead", there's no need to
     // set them to begin with.
-    if (_runtimeFlags.interruptible(newRuntimeFlags) && this.isInterrupted()) {
+    if (runtimeFlags_.interruptible(newRuntimeFlags) && this.isInterrupted()) {
       return core.exitFailCause(this.getInterruptedCause())
     } else {
       // Impossible to short circuit, so record the changes
       this.patchRuntimeFlags(this.currentRuntimeFlags, updateFlags)
       if (op.effect_instruction_i1) {
         // Since we updated the flags, we need to revert them
-        const revertFlags = _runtimeFlags.diff(newRuntimeFlags, oldRuntimeFlags)
+        const revertFlags = runtimeFlags_.diff(newRuntimeFlags, oldRuntimeFlags)
         this.pushStack(new core.RevertFlags(revertFlags, op))
         return internalCall(() => op.effect_instruction_i1!(oldRuntimeFlags))
       } else {
@@ -1367,7 +1369,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
         // @ts-expect-error
         cur = this.currentTracer.context(
           () => {
-            if (version.getCurrentVersion() !== (cur as core.Primitive)[core.EffectTypeId]._V) {
+            if (_version !== (cur as core.Primitive)[core.EffectTypeId]._V) {
               return core.dieMessage(
                 `Cannot execute an Effect versioned ${
                   (cur as core.Primitive)[core.EffectTypeId]._V
@@ -1400,8 +1402,6 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
       } catch (e) {
         if (cur !== YieldedOp && !Predicate.hasProperty(cur, "_op") || !((cur as core.Primitive)._op in this)) {
           cur = core.dieMessage(`Not a valid effect: ${Inspectable.toStringUnknown(cur)}`)
-        } else if (core.isEffectError(e)) {
-          cur = core.exitFailCause(e.cause)
         } else if (core.isInterruptedException(e)) {
           cur = core.exitFailCause(
             internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none))
@@ -1676,7 +1676,7 @@ export const addFinalizer = <X, R>(
             const preRefs = runtimeFinalizer.getFiberRefs()
             const preFlags = runtimeFinalizer.currentRuntimeFlags
             const patchRefs = FiberRefsPatch.diff(preRefs, acquireRefs)
-            const patchFlags = _runtimeFlags.diff(preFlags, acquireFlags)
+            const patchFlags = runtimeFlags_.diff(preFlags, acquireFlags)
             const inverseRefs = FiberRefsPatch.diff(acquireRefs, preRefs)
             runtimeFinalizer.setFiberRefs(
               FiberRefsPatch.patch(patchRefs, runtimeFinalizer.id(), acquireRefs)
@@ -1847,7 +1847,8 @@ const allValidate = (
   return core.flatMap(
     forEach(eitherEffects, identity, {
       concurrency: options?.concurrency,
-      batching: options?.batching
+      batching: options?.batching,
+      concurrentFinalizers: options?.concurrentFinalizers
     }),
     (eithers) => {
       const none = Option.none()
@@ -1899,14 +1900,16 @@ const allEither = (
     return forEach(eitherEffects, identity, {
       concurrency: options?.concurrency,
       batching: options?.batching,
-      discard: true
+      discard: true,
+      concurrentFinalizers: options?.concurrentFinalizers
     })
   }
 
   return core.map(
     forEach(eitherEffects, identity, {
       concurrency: options?.concurrency,
-      batching: options?.batching
+      batching: options?.batching,
+      concurrentFinalizers: options?.concurrentFinalizers
     }),
     (eithers) =>
       reconcile._tag === "Some" ?
@@ -2271,7 +2274,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                       () => core.exitVoid
                     )))
                   } else if (residual.length + results.length === target) {
-                    const requests = residual.map((blocked) => blocked.effect_instruction_i0).reduce(_RequestBlock.par)
+                    const requests = residual.map((blocked) => blocked.effect_instruction_i0).reduce(RequestBlock_.par)
                     resume(core.succeed(core.blocked(
                       requests,
                       forEachConcurrentDiscard(
@@ -2535,7 +2538,7 @@ export const validateAll = dual<
         readonly discard?: false | undefined
         readonly concurrentFinalizers?: boolean | undefined
       }
-    ): (elements: Iterable<A>) => Effect.Effect<Array<B>, Array<E>, R>
+    ): (elements: Iterable<A>) => Effect.Effect<Array<B>, RA.NonEmptyArray<E>, R>
     <A, B, E, R>(
       f: (a: A, i: number) => Effect.Effect<B, E, R>,
       options: {
@@ -2544,7 +2547,7 @@ export const validateAll = dual<
         readonly discard: true
         readonly concurrentFinalizers?: boolean | undefined
       }
-    ): (elements: Iterable<A>) => Effect.Effect<void, Array<E>, R>
+    ): (elements: Iterable<A>) => Effect.Effect<void, RA.NonEmptyArray<E>, R>
   },
   {
     <A, B, E, R>(
@@ -2556,7 +2559,7 @@ export const validateAll = dual<
         readonly discard?: false | undefined
         readonly concurrentFinalizers?: boolean | undefined
       }
-    ): Effect.Effect<Array<B>, Array<E>, R>
+    ): Effect.Effect<Array<B>, RA.NonEmptyArray<E>, R>
     <A, B, E, R>(
       elements: Iterable<A>,
       f: (a: A, i: number) => Effect.Effect<B, E, R>,
@@ -2566,7 +2569,7 @@ export const validateAll = dual<
         readonly discard: true
         readonly concurrentFinalizers?: boolean | undefined
       }
-    ): Effect.Effect<void, Array<E>, R>
+    ): Effect.Effect<void, RA.NonEmptyArray<E>, R>
   }
 >(
   (args) => Predicate.isIterable(args[0]),
@@ -2575,16 +2578,19 @@ export const validateAll = dual<
     readonly batching?: boolean | "inherit" | undefined
     readonly discard?: boolean | undefined
     readonly concurrentFinalizers?: boolean | undefined
-  }): Effect.Effect<any, Array<E>, R> =>
+  }): Effect.Effect<any, RA.NonEmptyArray<E>, R> =>
     core.flatMap(
       partition(elements, f, {
         concurrency: options?.concurrency,
-        batching: options?.batching
+        batching: options?.batching,
+        concurrentFinalizers: options?.concurrentFinalizers
       }),
       ([es, bs]) =>
-        es.length === 0
-          ? options?.discard ? core.void : core.succeed(bs)
-          : core.fail(es)
+        RA.isNonEmptyArray(es)
+          ? core.fail(es)
+          : options?.discard
+          ? core.void
+          : core.succeed(bs)
     )
 )
 
@@ -3012,16 +3018,16 @@ export const validateFirst = dual<
 )
 
 /* @internal */
-export const withClockScoped = <A extends Clock.Clock>(value: A) =>
-  fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(clock.clockTag, value))
+export const withClockScoped = <C extends Clock.Clock>(c: C) =>
+  fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(clock.clockTag, c))
 
 /* @internal */
 export const withRandomScoped = <A extends Random.Random>(value: A) =>
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(randomTag, value))
 
 /* @internal */
-export const withConfigProviderScoped = (value: ConfigProvider) =>
-  fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(configProviderTag, value))
+export const withConfigProviderScoped = (provider: ConfigProvider) =>
+  fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(configProviderTag, provider))
 
 /* @internal */
 export const withEarlyRelease = <A, E, R>(
@@ -3181,8 +3187,8 @@ export const withRuntimeFlagsScoped = (
   return pipe(
     core.runtimeFlags,
     core.flatMap((runtimeFlags) => {
-      const updatedRuntimeFlags = _runtimeFlags.patch(runtimeFlags, update)
-      const revertRuntimeFlags = _runtimeFlags.diff(updatedRuntimeFlags, runtimeFlags)
+      const updatedRuntimeFlags = runtimeFlags_.patch(runtimeFlags, update)
+      const revertRuntimeFlags = runtimeFlags_.diff(updatedRuntimeFlags, runtimeFlags)
       return pipe(
         core.updateRuntimeFlags(update),
         core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))),
@@ -3407,7 +3413,7 @@ export const fiberRefMakeRuntimeFlags = (
 
 /** @internal */
 export const currentRuntimeFlags: FiberRef.FiberRef<RuntimeFlags.RuntimeFlags> = core.fiberRefUnsafeMakeRuntimeFlags(
-  _runtimeFlags.none
+  runtimeFlags_.none
 )
 
 /** @internal */

package/src/internal/fiberScope.ts

@@ -3,7 +3,6 @@ import { globalValue } from "../GlobalValue.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as FiberMessage from "./fiberMessage.js"
 import type * as FiberRuntime from "./fiberRuntime.js"
-import * as _runtimeFlags from "./runtimeFlags.js"
 
 /** @internal */
 const FiberScopeSymbolKey = "effect/FiberScope"

package/src/internal/layer/circular.ts

@@ -15,7 +15,7 @@ import * as fiberRuntime from "../fiberRuntime.js"
 import * as layer from "../layer.js"
 import * as runtimeFlags from "../runtimeFlags.js"
 import * as runtimeFlagsPatch from "../runtimeFlagsPatch.js"
-import * as _supervisor from "../supervisor.js"
+import * as supervisor_ from "../supervisor.js"
 import * as tracer from "../tracer.js"
 
 // circular with Logger
@@ -106,7 +106,7 @@ export const addSupervisor = <A>(supervisor: Supervisor.Supervisor<A>): Layer.La
   layer.scopedDiscard(
     fiberRuntime.fiberRefLocallyScopedWith(
       fiberRuntime.currentSupervisor,
-      (current) => new _supervisor.Zip(current, supervisor)
+      (current) => new supervisor_.Zip(current, supervisor)
     )
   )
 

package/src/internal/logSpan.ts

@@ -6,8 +6,15 @@ export const make = (label: string, startTime: number): LogSpan.LogSpan => ({
   startTime
 })
 
+/**
+ * Sanitize a given string by replacing spaces, equal signs, and double quotes with underscores.
+ *
+ * @internal
+ */
+export const formatLabel = (key: string) => key.replace(/[\s="]/g, "_")
+
 /** @internal */
 export const render = (now: number) => (self: LogSpan.LogSpan): string => {
-  const label = self.label.replace(/[\s="]/g, "_")
+  const label = formatLabel(self.label)
   return `${label}=${now - self.startTime}ms`
 }

package/src/internal/logger-circular.ts

@@ -4,7 +4,7 @@ import * as HashMap from "../HashMap.js"
 import * as List from "../List.js"
 import type * as Logger from "../Logger.js"
 import * as core from "./core.js"
-import * as _fiberId from "./fiberId.js"
+import * as fiberId_ from "./fiberId.js"
 import * as fiberRefs from "./fiberRefs.js"
 
 /** @internal */
@@ -13,7 +13,7 @@ export const test = dual<
   <Message, Output>(self: Logger.Logger<Message, Output>, input: Message) => Output
 >(2, (self, input) =>
   self.log({
-    fiberId: _fiberId.none,
+    fiberId: fiberId_.none,
     logLevel: core.logLevelInfo,
     message: input,
     cause: Cause.empty,