effect 3.12.0 → 3.12.2

package/src/internal/logger.ts

@@ -2,20 +2,20 @@ import * as Arr from "../Array.js"
 import * as Context from "../Context.js"
 import * as FiberRefs from "../FiberRefs.js"
 import type { LazyArg } from "../Function.js"
-import { constVoid, dual, pipe } from "../Function.js"
+import { constVoid, dual } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as HashMap from "../HashMap.js"
 import * as Inspectable from "../Inspectable.js"
 import * as List from "../List.js"
 import type * as Logger from "../Logger.js"
 import type * as LogLevel from "../LogLevel.js"
-import * as LogSpan from "../LogSpan.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Cause from "./cause.js"
 import * as defaultServices from "./defaultServices.js"
 import { consoleTag } from "./defaultServices/console.js"
-import * as _fiberId from "./fiberId.js"
+import * as fiberId_ from "./fiberId.js"
+import * as logSpan_ from "./logSpan.js"
 
 /** @internal */
 const LoggerSymbolKey = "effect/Logger"
@@ -162,136 +162,60 @@ export const zipRight = dual<
   ) => Logger.Logger<Message & Message2, Output2>
 >(2, (self, that) => map(zip(self, that), (tuple) => tuple[1]))
 
-/** @internal */
-export const stringLogger: Logger.Logger<unknown, string> = makeLogger(
-  ({ annotations, cause, date, fiberId, logLevel, message, spans }) => {
-    const nowMillis = date.getTime()
-
-    const outputArray = [
-      `timestamp=${date.toISOString()}`,
-      `level=${logLevel.label}`,
-      `fiber=${_fiberId.threadName(fiberId)}`
-    ]
-
-    let output = outputArray.join(" ")
-
-    const messageArr = Arr.ensure(message)
-    for (let i = 0; i < messageArr.length; i++) {
-      const stringMessage = Inspectable.toStringUnknown(messageArr[i])
-      if (stringMessage.length > 0) {
-        output = output + " message="
-        output = appendQuoted(stringMessage, output)
-      }
-    }
-
-    if (cause != null && cause._tag !== "Empty") {
-      output = output + " cause="
-      output = appendQuoted(Cause.pretty(cause, { renderErrorCause: true }), output)
-    }
-
-    if (List.isCons(spans)) {
-      output = output + " "
-
-      let first = true
-      for (const span of spans) {
-        if (first) {
-          first = false
-        } else {
-          output = output + " "
-        }
-        output = output + pipe(span, LogSpan.render(nowMillis))
-      }
-    }
+/**
+ * Match strings that do not contain any whitespace characters, double quotes,
+ * or equal signs.
+ *
+ * @internal
+ */
+const textOnly = /^[^\s"=]*$/
+
+/**
+ * Used by both {@link stringLogger} and {@link logfmtLogger} to render a log
+ * message.
+ *
+ * @internal
+ */
+const format = (quoteValue: (s: string) => string, whitespace?: number | string | undefined) =>
+(
+  { annotations, cause, date, fiberId, logLevel, message, spans }: Logger.Logger.Options<unknown>
+): string => {
+  const formatValue = (value: string): string => value.match(textOnly) ? value : quoteValue(value)
+  const format = (label: string, value: string): string => `${logSpan_.formatLabel(label)}=${formatValue(value)}`
+  const append = (label: string, value: string): string => " " + format(label, value)
+
+  let out = format("timestamp", date.toISOString())
+  out += append("level", logLevel.label)
+  out += append("fiber", fiberId_.threadName(fiberId))
+
+  const messages = Arr.ensure(message)
+  for (let i = 0; i < messages.length; i++) {
+    out += append("message", Inspectable.toStringUnknown(messages[i], whitespace))
+  }
 
-    if (HashMap.size(annotations) > 0) {
-      output = output + " "
-
-      let first = true
-      for (const [key, value] of annotations) {
-        if (first) {
-          first = false
-        } else {
-          output = output + " "
-        }
-        output = output + filterKeyName(key)
-        output = output + "="
-        output = appendQuoted(Inspectable.toStringUnknown(value), output)
-      }
-    }
+  if (!Cause.isEmptyType(cause)) {
+    out += append("cause", Cause.pretty(cause, { renderErrorCause: true }))
+  }
 
-    return output
+  for (const span of spans) {
+    out += " " + logSpan_.render(date.getTime())(span)
   }
-)
 
-/** @internal */
-const escapeDoubleQuotes = (str: string) => `"${str.replace(/\\([\s\S])|(")/g, "\\$1$2")}"`
+  for (const [label, value] of annotations) {
+    out += append(label, Inspectable.toStringUnknown(value, whitespace))
+  }
 
-const textOnly = /^[^\s"=]+$/
+  return out
+}
 
 /** @internal */
-const appendQuoted = (label: string, output: string): string =>
-  output + (label.match(textOnly) ? label : escapeDoubleQuotes(label))
+const escapeDoubleQuotes = (s: string) => `"${s.replace(/\\([\s\S])|(")/g, "\\$1$2")}"`
 
 /** @internal */
-export const logfmtLogger = makeLogger<unknown, string>(
-  ({ annotations, cause, date, fiberId, logLevel, message, spans }) => {
-    const nowMillis = date.getTime()
+export const stringLogger: Logger.Logger<unknown, string> = makeLogger(format(escapeDoubleQuotes))
 
-    const outputArray = [
-      `timestamp=${date.toISOString()}`,
-      `level=${logLevel.label}`,
-      `fiber=${_fiberId.threadName(fiberId)}`
-    ]
-
-    let output = outputArray.join(" ")
-
-    const messageArr = Arr.ensure(message)
-    for (let i = 0; i < messageArr.length; i++) {
-      const stringMessage = Inspectable.toStringUnknown(messageArr[i], 0)
-      if (stringMessage.length > 0) {
-        output = output + " message="
-        output = appendQuotedLogfmt(stringMessage, output)
-      }
-    }
-
-    if (cause != null && cause._tag !== "Empty") {
-      output = output + " cause="
-      output = appendQuotedLogfmt(Cause.pretty(cause, { renderErrorCause: true }), output)
-    }
-
-    if (List.isCons(spans)) {
-      output = output + " "
-
-      let first = true
-      for (const span of spans) {
-        if (first) {
-          first = false
-        } else {
-          output = output + " "
-        }
-        output = output + pipe(span, renderLogSpanLogfmt(nowMillis))
-      }
-    }
-
-    if (HashMap.size(annotations) > 0) {
-      output = output + " "
-
-      let first = true
-      for (const [key, value] of annotations) {
-        if (first) {
-          first = false
-        } else {
-          output = output + " "
-        }
-        output = output + filterKeyName(key)
-        output = output + "="
-        output = appendQuotedLogfmt(Inspectable.toStringUnknown(value, 0), output)
-      }
-    }
-
-    return output
-  }
-)
+/** @internal */
+export const logfmtLogger: Logger.Logger<unknown, string> = makeLogger(format(JSON.stringify, 0))
 
 /** @internal */
 export const structuredLogger = makeLogger<unknown, {
@@ -328,11 +252,12 @@ export const structuredLogger = makeLogger<unknown, {
       cause: Cause.isEmpty(cause) ? undefined : Cause.pretty(cause, { renderErrorCause: true }),
       annotations: annotationsObj,
       spans: spansObj,
-      fiberId: _fiberId.threadName(fiberId)
+      fiberId: fiberId_.threadName(fiberId)
     }
   }
 )
 
+/** @internal */
 export const structuredMessage = (u: unknown): unknown => {
   switch (typeof u) {
     case "bigint":
@@ -349,22 +274,6 @@ export const structuredMessage = (u: unknown): unknown => {
 /** @internal */
 export const jsonLogger = map(structuredLogger, Inspectable.stringifyCircular)
 
-/** @internal */
-const filterKeyName = (key: string) => key.replace(/[\s="]/g, "_")
-
-/** @internal */
-const escapeDoubleQuotesLogfmt = (str: string) => JSON.stringify(str)
-
-/** @internal */
-const appendQuotedLogfmt = (label: string, output: string): string =>
-  output + (label.match(textOnly) ? label : escapeDoubleQuotesLogfmt(label))
-
-/** @internal */
-const renderLogSpanLogfmt = (now: number) => (self: LogSpan.LogSpan): string => {
-  const label = filterKeyName(self.label)
-  return `${label}=${now - self.startTime}ms`
-}
-
 /** @internal */
 export const isLogger = (u: unknown): u is Logger.Logger<unknown, unknown> => {
   return typeof u === "object" && u != null && LoggerTypeId in u
@@ -448,7 +357,7 @@ const prettyLoggerTty = (options: {
   readonly formatDate: (date: Date) => string
 }) => {
   const processIsBun = typeof process === "object" && "isBun" in process && process.isBun === true
-  const color = options.colors && processStdoutIsTTY ? withColor : withColorNoop
+  const color = options.colors ? withColor : withColorNoop
   return makeLogger<unknown, void>(
     ({ annotations, cause, context, date, fiberId, logLevel, message: message_, spans }) => {
       const services = FiberRefs.getOrDefault(context, defaultServices.currentServices)
@@ -459,11 +368,11 @@ const prettyLoggerTty = (options: {
 
       let firstLine = color(`[${options.formatDate(date)}]`, colors.white)
         + ` ${color(logLevel.label, ...logLevelColors[logLevel._tag])}`
-        + ` (${_fiberId.threadName(fiberId)})`
+        + ` (${fiberId_.threadName(fiberId)})`
 
       if (List.isCons(spans)) {
         const now = date.getTime()
-        const render = renderLogSpanLogfmt(now)
+        const render = logSpan_.render(now)
         for (const span of spans) {
           firstLine += " " + render(span)
         }
@@ -519,13 +428,13 @@ const prettyLoggerBrowser = (options: {
       if (options.colors) {
         firstParams.push("color:gray")
       }
-      firstLine += ` ${color}${logLevel.label}${color} (${_fiberId.threadName(fiberId)})`
+      firstLine += ` ${color}${logLevel.label}${color} (${fiberId_.threadName(fiberId)})`
       if (options.colors) {
         firstParams.push(logLevelStyle[logLevel._tag], "")
       }
       if (List.isCons(spans)) {
         const now = date.getTime()
-        const render = renderLogSpanLogfmt(now)
+        const render = logSpan_.render(now)
         for (const span of spans) {
           firstLine += " " + render(span)
         }

package/src/internal/metric.ts

@@ -16,7 +16,7 @@ import type * as MetricRegistry from "../MetricRegistry.js"
 import type * as MetricState from "../MetricState.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Cause from "./cause.js"
-import * as _effect from "./core-effect.js"
+import * as effect_ from "./core-effect.js"
 import * as core from "./core.js"
 import * as metricBoundaries from "./metric/boundaries.js"
 import * as metricKey from "./metric/key.js"
@@ -411,7 +411,7 @@ export const trackDefectWith = dual<
   ) => Effect.Effect<A, E, R>
 >(3, (self, metric, f) => {
   const updater = (defect: unknown) => update(metric, f(defect))
-  return _effect.tapDefect(self, (cause) => core.forEachSequentialDiscard(Cause.defects(cause), updater))
+  return effect_.tapDefect(self, (cause) => core.forEachSequentialDiscard(Cause.defects(cause), updater))
 })
 
 /* @internal */
@@ -477,7 +477,7 @@ export const trackErrorWith = dual<
   f: (error: In2) => In
 ) => {
   const updater = (error: E): Effect.Effect<void> => update(metric, f(error))
-  return _effect.tapError(self, updater)
+  return effect_.tapError(self, updater)
 })
 
 /* @internal */

package/src/internal/reloadable.ts

@@ -7,8 +7,8 @@ import type * as Schedule from "../Schedule.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
-import * as _layer from "./layer.js"
-import * as _schedule from "./schedule.js"
+import * as layer_ from "./layer.js"
+import * as schedule_ from "./schedule.js"
 import * as scopedRef from "./scopedRef.js"
 
 /** @internal */
@@ -32,17 +32,17 @@ export const auto = <Out extends Context.Tag<any, any>, E, In, R>(
     readonly schedule: Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
-  _layer.scoped(
+  layer_.scoped(
     reloadableTag(tag),
     pipe(
-      _layer.build(manual(tag, { layer: options.layer })),
+      layer_.build(manual(tag, { layer: options.layer })),
       core.map(Context.unsafeGet(reloadableTag(tag))),
       core.tap((reloadable) =>
         fiberRuntime.acquireRelease(
           pipe(
             reloadable.reload,
             effect.ignoreLogged,
-            _schedule.schedule_Effect(options.schedule),
+            schedule_.schedule_Effect(options.schedule),
             fiberRuntime.forkDaemon
           ),
           core.interruptFiber
@@ -59,13 +59,13 @@ export const autoFromConfig = <Out extends Context.Tag<any, any>, E, In, R>(
     readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
-  _layer.scoped(
+  layer_.scoped(
     reloadableTag(tag),
     pipe(
       core.context<In>(),
       core.flatMap((env) =>
         pipe(
-          _layer.build(auto(tag, {
+          layer_.build(auto(tag, {
             layer: options.layer,
             schedule: options.scheduleFromConfig(env)
           })),
@@ -91,18 +91,18 @@ export const manual = <Out extends Context.Tag<any, any>, In, E>(
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, In> =>
-  _layer.scoped(
+  layer_.scoped(
     reloadableTag(tag),
     pipe(
       core.context<In>(),
       core.flatMap((env) =>
         pipe(
-          scopedRef.fromAcquire(pipe(_layer.build(options.layer), core.map(Context.unsafeGet(tag)))),
+          scopedRef.fromAcquire(pipe(layer_.build(options.layer), core.map(Context.unsafeGet(tag)))),
           core.map((ref) => ({
             [ReloadableTypeId]: reloadableVariance,
             scopedRef: ref,
             reload: pipe(
-              scopedRef.set(ref, pipe(_layer.build(options.layer), core.map(Context.unsafeGet(tag)))),
+              scopedRef.set(ref, pipe(layer_.build(options.layer), core.map(Context.unsafeGet(tag)))),
               core.provideContext(env)
             )
           }))

package/src/internal/resource.ts

@@ -6,7 +6,7 @@ import type * as Scope from "../Scope.js"
 import * as core from "./core.js"
 import * as effectable from "./effectable.js"
 import * as fiberRuntime from "./fiberRuntime.js"
-import * as _schedule from "./schedule.js"
+import * as schedule_ from "./schedule.js"
 import * as scopedRef from "./scopedRef.js"
 
 /** @internal */
@@ -42,7 +42,7 @@ export const auto = <A, E, R, Out, R2>(
     fiberRuntime.acquireRelease(
       pipe(
         refresh(manual),
-        _schedule.schedule_Effect(policy),
+        schedule_.schedule_Effect(policy),
         core.interruptible,
         fiberRuntime.forkDaemon
       ),

package/src/internal/runtime.ts

@@ -15,8 +15,8 @@ import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
-import * as _scheduler from "../Scheduler.js"
-import * as _scope from "../Scope.js"
+import * as scheduler_ from "../Scheduler.js"
+import * as scope_ from "../Scope.js"
 import * as InternalCause from "./cause.js"
 import * as core from "./core.js"
 import * as executionStrategy from "./executionStrategy.js"
@@ -24,7 +24,7 @@ import * as FiberRuntime from "./fiberRuntime.js"
 import * as fiberScope from "./fiberScope.js"
 import * as OpCodes from "./opCodes/effect.js"
 import * as runtimeFlags from "./runtimeFlags.js"
-import * as _supervisor from "./supervisor.js"
+import * as supervisor_ from "./supervisor.js"
 
 /** @internal */
 export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
@@ -38,7 +38,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
   > = [[core.currentContext, [[fiberId, runtime.context]]]]
 
   if (options?.scheduler) {
-    fiberRefUpdates.push([_scheduler.currentScheduler, [[fiberId, options.scheduler]]])
+    fiberRefUpdates.push([scheduler_.currentScheduler, [[fiberId, options.scheduler]]])
   }
 
   let fiberRefs = FiberRefs.updateManyAs(runtime.fiberRefs, {
@@ -60,7 +60,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
 
   if (options?.scope) {
     effect = core.flatMap(
-      _scope.fork(options.scope, executionStrategy.sequential),
+      scope_.fork(options.scope, executionStrategy.sequential),
       (closeableScope) =>
         core.zipRight(
           core.scopeAddFinalizer(
@@ -69,7 +69,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
               equals(id, fiberRuntime.id()) ? core.void : core.interruptAsFiber(fiberRuntime, id)
             )
           ),
-          core.onExit(self, (exit) => _scope.close(closeableScope, exit))
+          core.onExit(self, (exit) => scope_.close(closeableScope, exit))
         )
     )
   }
@@ -77,7 +77,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
   const supervisor = fiberRuntime.currentSupervisor
 
   // we can compare by reference here as _supervisor.none is wrapped with globalValue
-  if (supervisor !== _supervisor.none) {
+  if (supervisor !== supervisor_.none) {
     supervisor.onStart(runtime.context, effect, Option.none(), fiberRuntime)
 
     fiberRuntime.addObserver((exit) => supervisor.onEnd(exit, fiberRuntime))
@@ -243,7 +243,7 @@ export const unsafeRunSyncExit =
     if (op) {
       return op
     }
-    const scheduler = new _scheduler.SyncScheduler()
+    const scheduler = new scheduler_.SyncScheduler()
     const fiberRuntime = unsafeFork(runtime)(effect, { scheduler })
     scheduler.flush()
     const result = fiberRuntime.unsafePoll()

package/src/internal/scopedCache.ts

@@ -15,7 +15,7 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Scope from "../Scope.js"
 import type * as ScopedCache from "../ScopedCache.js"
-import * as _cache from "./cache.js"
+import * as cache_ from "./cache.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
@@ -27,8 +27,8 @@ import * as fiberRuntime from "./fiberRuntime.js"
  */
 export interface CacheState<in out Key, out Value, out Error = never> {
   map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
-  keys: _cache.KeySet<Key> // mutable by design
-  accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>> // mutable by design
+  keys: cache_.KeySet<Key> // mutable by design
+  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>> // mutable by design
   updating: MutableRef.MutableRef<boolean> // mutable by design
   hits: number // mutable by design
   misses: number // mutable by design
@@ -37,8 +37,8 @@ export interface CacheState<in out Key, out Value, out Error = never> {
 /** @internal */
 export const makeCacheState = <Key, Value, Error = never>(
   map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
-  keys: _cache.KeySet<Key>,
-  accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>>,
+  keys: cache_.KeySet<Key>,
+  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>>,
   updating: MutableRef.MutableRef<boolean>,
   hits: number,
   misses: number
@@ -59,7 +59,7 @@ export const makeCacheState = <Key, Value, Error = never>(
 export const initialCacheState = <Key, Value, Error = never>(): CacheState<Key, Value, Error> =>
   makeCacheState(
     MutableHashMap.empty(),
-    _cache.makeKeySet(),
+    cache_.makeKeySet(),
     MutableQueue.unbounded(),
     MutableRef.make(false),
     0,
@@ -82,7 +82,7 @@ export type MapValue<Key, Value, Error> =
 /** @internal */
 export interface Complete<out Key, out Value, out Error> {
   readonly _tag: "Complete"
-  readonly key: _cache.MapKey<Key>
+  readonly key: cache_.MapKey<Key>
   readonly exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>
   readonly ownerCount: MutableRef.MutableRef<number>
   readonly entryStats: Cache.EntryStats
@@ -92,7 +92,7 @@ export interface Complete<out Key, out Value, out Error> {
 /** @internal */
 export interface Pending<out Key, out Value, out Error> {
   readonly _tag: "Pending"
-  readonly key: _cache.MapKey<Key>
+  readonly key: cache_.MapKey<Key>
   readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 }
 
@@ -105,7 +105,7 @@ export interface Refreshing<out Key, out Value, out Error> {
 
 /** @internal */
 export const complete = <Key, Value, Error = never>(
-  key: _cache.MapKey<Key>,
+  key: cache_.MapKey<Key>,
   exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
   ownerCount: MutableRef.MutableRef<number>,
   entryStats: Cache.EntryStats,
@@ -122,7 +122,7 @@ export const complete = <Key, Value, Error = never>(
 
 /** @internal */
 export const pending = <Key, Value, Error = never>(
-  key: _cache.MapKey<Key>,
+  key: cache_.MapKey<Key>,
   scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 ): Pending<Key, Value, Error> =>
   Data.struct({
@@ -206,7 +206,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
 
   get cacheStats(): Effect.Effect<Cache.CacheStats> {
     return core.sync(() =>
-      _cache.makeCacheStats({
+      cache_.makeCacheStats({
         hits: this.cacheState.hits,
         misses: this.cacheState.misses,
         size: MutableHashMap.size(this.cacheState.map)
@@ -245,13 +245,13 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
       }
       switch (value._tag) {
         case "Complete": {
-          return Option.some(_cache.makeEntryStats(value.entryStats.loadedMillis))
+          return Option.some(cache_.makeEntryStats(value.entryStats.loadedMillis))
         }
         case "Pending": {
           return Option.none()
         }
         case "Refreshing": {
-          return Option.some(_cache.makeEntryStats(value.complete.entryStats.loadedMillis))
+          return Option.some(cache_.makeEntryStats(value.complete.entryStats.loadedMillis))
         }
       }
     })
@@ -263,10 +263,10 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
       effect.memoize,
       core.flatMap((lookupValue) =>
         core.suspend(() => {
-          let k: _cache.MapKey<Key> | undefined = undefined
+          let k: cache_.MapKey<Key> | undefined = undefined
           let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
           if (value === undefined) {
-            k = _cache.makeMapKey(key)
+            k = cache_.makeMapKey(key)
             if (MutableHashMap.has(this.cacheState.map, key)) {
               value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
             } else {
@@ -341,9 +341,9 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
       effect.memoize,
       core.flatMap((scoped) => {
         let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
-        let newKey: _cache.MapKey<Key> | undefined = undefined
+        let newKey: cache_.MapKey<Key> | undefined = undefined
         if (value === undefined) {
-          newKey = _cache.makeMapKey(key)
+          newKey = cache_.makeMapKey(key)
           if (MutableHashMap.has(this.cacheState.map, key)) {
             value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
           } else {
@@ -460,10 +460,10 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
               release
             ])
             const completedResult = complete<Key, Value, Error>(
-              _cache.makeMapKey(key),
+              cache_.makeMapKey(key),
               exitWithFinalizer,
               MutableRef.make(1),
-              _cache.makeEntryStats(now),
+              cache_.makeEntryStats(now),
               expiredAt
             )
             let previousValue: MapValue<Key, Value, Error> | undefined = undefined
@@ -482,10 +482,10 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
           }
           case "Failure": {
             const completedResult = complete<Key, Value, Error>(
-              _cache.makeMapKey(key),
+              cache_.makeMapKey(key),
               exit as Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
               MutableRef.make(0),
-              _cache.makeEntryStats(now),
+              cache_.makeEntryStats(now),
               expiredAt
             )
             let previousValue: MapValue<Key, Value, Error> | undefined = undefined
@@ -524,7 +524,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     this.cacheState.misses = this.cacheState.misses + 1
   }
 
-  trackAccess(key: _cache.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
+  trackAccess(key: cache_.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
     const cleanedKeys: Array<MapValue<Key, Value, Error>> = []
     MutableQueue.offer(this.cacheState.accesses, key)
     if (MutableRef.compareAndSet(this.cacheState.updating, false, true)) {
@@ -575,7 +575,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     }
   }
 
-  ensureMapSizeNotExceeded(key: _cache.MapKey<Key>): Effect.Effect<void> {
+  ensureMapSizeNotExceeded(key: cache_.MapKey<Key>): Effect.Effect<void> {
     return fiberRuntime.forEachConcurrentDiscard(
       this.trackAccess(key),
       (cleanedMapValue) => this.cleanMapValue(cleanedMapValue),