effect 2.0.0-next.56 → 2.0.0-next.57

package/src/internal/hashMap.ts

@@ -3,7 +3,7 @@ import * as Dual from "../Function.js"
 import { identity, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
 import type * as HM from "../HashMap.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -76,7 +76,7 @@ const HashMapProto: HM.HashMap<unknown, unknown> = {
     return false
   },
   toString<K, V>(this: HashMapImpl<K, V>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {

package/src/internal/hashSet.ts

@@ -3,7 +3,7 @@ import { dual } from "../Function.js"
 import * as Hash from "../Hash.js"
 import type { HashMap } from "../HashMap.js"
 import type * as HS from "../HashSet.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import { hasProperty } from "../Predicate.js"
@@ -37,7 +37,7 @@ const HashSetProto: Omit<HashSetImpl<unknown>, "_keyMap"> = {
     return false
   },
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {

package/src/internal/keyedPool.ts

@@ -28,8 +28,11 @@ const KeyedPoolMapValueSymbol = Symbol.for("effect/KeyedPool/MapValue")
 type KeyedPoolMapValueSymbol = typeof KeyedPoolMapValueSymbol
 
 const keyedPoolVariance = {
+  /* c8 ignore next */
   _K: (_: unknown) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/layer.ts

@@ -38,10 +38,12 @@ export const LayerTypeId: Layer.LayerTypeId = Symbol.for(
   LayerSymbolKey
 ) as Layer.LayerTypeId
 
-/** @internal */
 const layerVariance = {
+  /* c8 ignore next */
   _RIn: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _ROut: (_: unknown) => _
 }
 
@@ -125,7 +127,7 @@ export interface Locally extends
 
 /** @internal */
 export interface ProvideTo extends
-  Op<OpCodes.OP_PROVIDE_TO, {
+  Op<OpCodes.OP_PROVIDE, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
   }>
@@ -133,7 +135,7 @@ export interface ProvideTo extends
 
 /** @internal */
 export interface ZipWith extends
-  Op<OpCodes.OP_ZIP_WITH, {
+  Op<OpCodes.OP_PROVIDE_MERGE, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
     zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
@@ -142,7 +144,7 @@ export interface ZipWith extends
 
 /** @internal */
 export interface ZipWithPar extends
-  Op<OpCodes.OP_ZIP_WITH_PAR, {
+  Op<OpCodes.OP_ZIP_WITH, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
     zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
@@ -351,7 +353,7 @@ const withScope = <RIn, E, ROut>(
     case "FromEffect": {
       return core.sync(() => (_: MemoMap) => op.effect as Effect.Effect<RIn, E, Context.Context<ROut>>)
     }
-    case "ProvideTo": {
+    case "Provide": {
       return core.sync(() => (memoMap: MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
@@ -380,7 +382,7 @@ const withScope = <RIn, E, ROut>(
         )
       )
     }
-    case "ZipWith": {
+    case "ProvideMerge": {
       return core.sync(() => (memoMap: MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
@@ -391,7 +393,7 @@ const withScope = <RIn, E, ROut>(
         )
       )
     }
-    case "ZipWithPar": {
+    case "ZipWith": {
       return core.sync(() => (memoMap: MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
@@ -676,17 +678,17 @@ export const memoize = <RIn, E, ROut>(
 export const merge = dual<
   <RIn2, E2, ROut2>(
     that: Layer.Layer<RIn2, E2, ROut2>
-  ) => <RIn, E, ROut>(self: Layer.Layer<RIn, E, ROut>) => Layer.Layer<
+  ) => <RIn, E1, ROut>(self: Layer.Layer<RIn, E1, ROut>) => Layer.Layer<
     RIn | RIn2,
-    E | E2,
+    E1 | E2,
     ROut | ROut2
   >,
-  <RIn, E, ROut, RIn2, E2, ROut2>(self: Layer.Layer<RIn, E, ROut>, that: Layer.Layer<RIn2, E2, ROut2>) => Layer.Layer<
+  <RIn, E1, ROut, RIn2, E2, ROut2>(self: Layer.Layer<RIn, E1, ROut>, that: Layer.Layer<RIn2, E2, ROut2>) => Layer.Layer<
     RIn | RIn2,
-    E | E2,
+    E1 | E2,
     ROut | ROut2
   >
->(2, (self, that) => zipWithPar(self, that, (a, b) => pipe(a, Context.merge(b))))
+>(2, (self, that) => zipWith(self, that, (a, b) => Context.merge(a, b)))
 
 /** @internal */
 export const mergeAll = <Layers extends [Layer.Layer<any, any, never>, ...Array<Layer.Layer<any, any, never>>]>(
@@ -698,7 +700,7 @@ export const mergeAll = <Layers extends [Layer.Layer<any, any, never>, ...Array<
 > => {
   let final = layers[0]
   for (let i = 1; i < layers.length; i++) {
-    final = merge(layers[i])(final)
+    final = merge(final, layers[i])
   }
   return final as any
 }
@@ -737,56 +739,6 @@ export const project = dual<
   ) => Layer.Layer<RIn, E, Context.Tag.Identifier<B>>
 >(4, (self, tagA, tagB, f) => map(self, (context) => Context.make(tagB, f(Context.unsafeGet(context, tagA)))))
 
-/** @internal */
-export const provide = dual<
-  <RIn2, E2, ROut2>(
-    that: Layer.Layer<RIn2, E2, ROut2>
-  ) => <RIn, E, ROut>(
-    self: Layer.Layer<RIn, E, ROut>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>,
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer.Layer<RIn, E, ROut>,
-    that: Layer.Layer<RIn2, E2, ROut2>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>
->(2, <RIn, E, ROut, RIn2, E2, ROut2>(
-  self: Layer.Layer<RIn, E, ROut>,
-  that: Layer.Layer<RIn2, E2, ROut2>
-) =>
-  suspend(() => {
-    const provideTo = Object.create(proto)
-    provideTo._tag = OpCodes.OP_PROVIDE_TO
-    provideTo.first = Object.create(proto, {
-      _tag: { value: OpCodes.OP_ZIP_WITH, enumerable: true },
-      first: { value: context<Exclude<RIn2, ROut>>(), enumerable: true },
-      second: { value: self },
-      zipK: { value: (a: Context.Context<ROut>, b: Context.Context<ROut2>) => Context.merge(a, b) }
-    })
-    provideTo.second = that
-    return provideTo
-  }))
-
-/** @internal */
-export const provideMerge = dual<
-  <RIn2, E2, ROut2>(that: Layer.Layer<RIn2, E2, ROut2>) => <RIn, E, ROut>(
-    self: Layer.Layer<RIn, E, ROut>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut | ROut2>,
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer.Layer<RIn, E, ROut>,
-    that: Layer.Layer<RIn2, E2, ROut2>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut | ROut2>
->(2, <RIn, E, ROut, RIn2, E2, ROut2>(
-  self: Layer.Layer<RIn, E, ROut>,
-  that: Layer.Layer<RIn2, E2, ROut2>
-) => {
-  const zipWith = Object.create(proto)
-  zipWith._tag = OpCodes.OP_ZIP_WITH
-  zipWith.first = self
-  zipWith.second = pipe(self, provide(that))
-  zipWith.zipK = (a: Context.Context<ROut>, b: Context.Context<ROut2>): Context.Context<ROut | ROut2> =>
-    Context.merge(a, b)
-  return zipWith
-})
-
 /** @internal */
 export const retry = dual<
   <RIn2, E, X>(
@@ -1023,7 +975,7 @@ export const toRuntime = <RIn, E, ROut>(
 }
 
 /** @internal */
-export const use = dual<
+export const provide = dual<
   <RIn, E, ROut>(
     self: Layer.Layer<RIn, E, ROut>
   ) => <RIn2, E2, ROut2>(
@@ -1039,9 +991,9 @@ export const use = dual<
 ) =>
   suspend(() => {
     const provideTo = Object.create(proto)
-    provideTo._tag = OpCodes.OP_PROVIDE_TO
+    provideTo._tag = OpCodes.OP_PROVIDE
     provideTo.first = Object.create(proto, {
-      _tag: { value: OpCodes.OP_ZIP_WITH, enumerable: true },
+      _tag: { value: OpCodes.OP_PROVIDE_MERGE, enumerable: true },
       first: { value: context<Exclude<RIn2, ROut>>(), enumerable: true },
       second: { value: self },
       zipK: { value: (a: Context.Context<ROut>, b: Context.Context<ROut2>) => pipe(a, Context.merge(b)) }
@@ -1051,7 +1003,7 @@ export const use = dual<
   }))
 
 /** @internal */
-export const useMerge = dual<
+export const provideMerge = dual<
   <RIn, E, ROut>(
     self: Layer.Layer<RIn, E, ROut>
   ) => <RIn2, E2, ROut2>(
@@ -1063,9 +1015,9 @@ export const useMerge = dual<
   ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut | ROut2>
 >(2, <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer.Layer<RIn2, E2, ROut2>, self: Layer.Layer<RIn, E, ROut>) => {
   const zipWith = Object.create(proto)
-  zipWith._tag = OpCodes.OP_ZIP_WITH
+  zipWith._tag = OpCodes.OP_PROVIDE_MERGE
   zipWith.first = self
-  zipWith.second = pipe(self, provide(that))
+  zipWith.second = provide(that, self)
   zipWith.zipK = (a: Context.Context<ROut>, b: Context.Context<ROut2>): Context.Context<ROut | ROut2> => {
     return pipe(a, Context.merge(b))
   }
@@ -1073,7 +1025,7 @@ export const useMerge = dual<
 })
 
 /** @internal */
-export const zipWithPar = dual<
+export const zipWith = dual<
   <R2, E2, B, A, C>(
     that: Layer.Layer<R2, E2, B>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
@@ -1085,12 +1037,12 @@ export const zipWithPar = dual<
   ) => Layer.Layer<R | R2, E | E2, C>
 >(3, (self, that, f) =>
   suspend(() => {
-    const zipWithPar = Object.create(proto)
-    zipWithPar._tag = OpCodes.OP_ZIP_WITH_PAR
-    zipWithPar.first = self
-    zipWithPar.second = that
-    zipWithPar.zipK = f
-    return zipWithPar
+    const zipWith = Object.create(proto)
+    zipWith._tag = OpCodes.OP_ZIP_WITH
+    zipWith.first = self
+    zipWith.second = that
+    zipWith.zipK = f
+    return zipWith
   }))
 
 /** @internal */
@@ -1154,7 +1106,7 @@ export const withParentSpan = dual<
     span: Tracer.ParentSpan
   ) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>,
   <R, E, A>(self: Layer.Layer<R, E, A>, span: Tracer.ParentSpan) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>
->(2, (self, span) => provide(succeedContext(Context.make(tracer.spanTag, span)), self))
+>(2, (self, span) => provide(self, succeedContext(Context.make(tracer.spanTag, span))))
 
 // circular with Effect
 

package/src/internal/logger.ts

@@ -18,9 +18,10 @@ export const LoggerTypeId: Logger.LoggerTypeId = Symbol.for(
   LoggerSymbolKey
 ) as Logger.LoggerTypeId
 
-/** @internal */
 const loggerVariance = {
+  /* c8 ignore next */
   _Message: (_: unknown) => _,
+  /* c8 ignore next */
   _Output: (_: never) => _
 }
 

package/src/internal/metric/hook.ts

@@ -20,9 +20,10 @@ export const MetricHookTypeId: MetricHook.MetricHookTypeId = Symbol.for(
   MetricHookSymbolKey
 ) as MetricHook.MetricHookTypeId
 
-/** @internal */
 const metricHookVariance = {
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 

package/src/internal/metric/key.ts

@@ -22,8 +22,8 @@ export const MetricKeyTypeId: MetricKey.MetricKeyTypeId = Symbol.for(
   MetricKeySymbolKey
 ) as MetricKey.MetricKeyTypeId
 
-/** @internal */
 const metricKeyVariance = {
+  /* c8 ignore next */
   _Type: (_: never) => _
 }
 

package/src/internal/metric/keyType.ts

@@ -56,9 +56,10 @@ export const SummaryKeyTypeTypeId: MetricKeyType.SummaryKeyTypeTypeId = Symbol.f
   SummaryKeyTypeSymbolKey
 ) as MetricKeyType.SummaryKeyTypeTypeId
 
-/** @internal */
 const metricKeyTypeVariance = {
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 

package/src/internal/metric/pair.ts

@@ -12,8 +12,8 @@ export const MetricPairTypeId: MetricPair.MetricPairTypeId = Symbol.for(
   MetricPairSymbolKey
 ) as MetricPair.MetricPairTypeId
 
-/** @internal */
 const metricPairVariance = {
+  /* c8 ignore next */
   _Type: (_: never) => _
 }
 

package/src/internal/metric/state.ts

@@ -56,8 +56,8 @@ export const SummaryStateTypeId: MetricState.SummaryStateTypeId = Symbol.for(
   SummaryStateSymbolKey
 ) as MetricState.SummaryStateTypeId
 
-/** @internal */
 const metricStateVariance = {
+  /* c8 ignore next */
   _A: (_: unknown) => _
 }
 

package/src/internal/metric.ts

@@ -33,10 +33,12 @@ export const MetricTypeId: Metric.MetricTypeId = Symbol.for(
   MetricSymbolKey
 ) as Metric.MetricTypeId
 
-/** @internal */
 const metricVariance = {
+  /* c8 ignore next */
   _Type: (_: any) => _,
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 
@@ -281,7 +283,7 @@ export const taggedWithLabels = dual<
 })
 
 /** @internal */
-export const timer = (name: string): Metric.Metric<
+export const timer = (name: string, description?: string): Metric.Metric<
   MetricKeyType.MetricKeyType.Histogram,
   Duration.Duration,
   MetricState.MetricState.Histogram
@@ -291,21 +293,22 @@ export const timer = (name: string): Metric.Metric<
     factor: 2,
     count: 100
   })
-  const base = pipe(histogram(name, boundaries), tagged("time_unit", "milliseconds"))
+  const base = pipe(histogram(name, boundaries, description), tagged("time_unit", "milliseconds"))
   return mapInput(base, Duration.toMillis)
 }
 
 /** @internal */
 export const timerWithBoundaries = (
   name: string,
-  boundaries: Chunk.Chunk<number>
+  boundaries: Chunk.Chunk<number>,
+  description?: string
 ): Metric.Metric<
   MetricKeyType.MetricKeyType.Histogram,
   Duration.Duration,
   MetricState.MetricState.Histogram
 > => {
   const base = pipe(
-    histogram(name, metricBoundaries.fromChunk(boundaries)),
+    histogram(name, metricBoundaries.fromChunk(boundaries), description),
     tagged("time_unit", "milliseconds")
   )
   return mapInput(base, Duration.toMillis)

package/src/internal/opCodes/layer.ts

@@ -35,19 +35,19 @@ export const OP_SUSPEND = "Suspend" as const
 export type OP_SUSPEND = typeof OP_SUSPEND
 
 /** @internal */
-export const OP_PROVIDE_TO = "ProvideTo" as const
+export const OP_PROVIDE = "Provide" as const
 
 /** @internal */
-export type OP_PROVIDE_TO = typeof OP_PROVIDE_TO
+export type OP_PROVIDE = typeof OP_PROVIDE
 
 /** @internal */
-export const OP_ZIP_WITH = "ZipWith" as const
+export const OP_PROVIDE_MERGE = "ProvideMerge" as const
 
 /** @internal */
-export type OP_ZIP_WITH = typeof OP_ZIP_WITH
+export type OP_PROVIDE_MERGE = typeof OP_PROVIDE_MERGE
 
 /** @internal */
-export const OP_ZIP_WITH_PAR = "ZipWithPar" as const
+export const OP_ZIP_WITH = "ZipWith" as const
 
 /** @internal */
-export type OP_ZIP_WITH_PAR = typeof OP_ZIP_WITH_PAR
+export type OP_ZIP_WITH = typeof OP_ZIP_WITH

package/src/internal/option.ts

@@ -4,7 +4,7 @@
 
 import * as Equal from "../Equal.js"
 import * as Hash from "../Hash.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import type * as Option from "../Option.js"
 import { hasProperty } from "../Predicate.js"
 import { EffectPrototype } from "./effectable.js"
@@ -20,7 +20,7 @@ const CommonProto = {
     return this.toJSON()
   },
   toString<A>(this: Option.Option<A>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
 }
 

package/src/internal/pool.ts

@@ -28,7 +28,9 @@ export const PoolTypeId: Pool.PoolTypeId = Symbol.for(
 ) as Pool.PoolTypeId
 
 const poolVariance = {
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/pubsub.ts

@@ -1302,12 +1302,13 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
       core.flatMap(
         core.sync(() => unsafePollAllQueue(this.publishers)),
         (publishers) =>
-          fiberRuntime.forEachParUnboundedDiscard(
+          fiberRuntime.forEachConcurrentDiscard(
             publishers,
             ([_, deferred, last]) =>
               last ?
                 pipe(core.deferredInterruptWith(deferred, fiberId), core.asUnit) :
                 core.unit,
+            false,
             false
           )
       ))

package/src/internal/query.ts

@@ -78,7 +78,7 @@ export const fromRequest = <
                               proxy,
                               (entry) => entry.handle === orNew.left.handle
                             ),
-                            () => fromRequest(proxy, dataSource)
+                            () => fromRequest(proxy, ds)
                           )
                         }
                         return ensuring(

package/src/internal/queue.ts

@@ -40,23 +40,25 @@ export const BackingQueueTypeId: Queue.BackingQueueTypeId = Symbol.for(
   BackingQueueSymbolKey
 ) as Queue.BackingQueueTypeId
 
-/** @internal */
 const queueStrategyVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 
-/** @internal */
 const backingQueueVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 
 /** @internal */
 export const enqueueVariance = {
+  /* c8 ignore next */
   _In: (_: unknown) => _
 }
 
 /** @internal */
 export const dequeueVariance = {
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 
@@ -115,9 +117,10 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
       core.withFiberRuntime<never, never, void>((state) => {
         pipe(this.shutdownFlag, MutableRef.set(true))
         return pipe(
-          fiberRuntime.forEachParUnboundedDiscard(
+          fiberRuntime.forEachConcurrentDiscard(
             unsafePollAll(this.takers),
             (d) => core.deferredInterruptWith(d, state.id()),
+            false,
             false
           ),
           core.zipRight(this.strategy.shutdown),
@@ -544,13 +547,18 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
         pipe(
           core.sync(() => unsafePollAll(this.putters)),
           core.flatMap((putters) =>
-            fiberRuntime.forEachParUnboundedDiscard(putters, ([_, deferred, isLastItem]) =>
-              isLastItem ?
-                pipe(
-                  core.deferredInterruptWith(deferred, fiberId),
-                  core.asUnit
-                ) :
-                core.unit, false)
+            fiberRuntime.forEachConcurrentDiscard(
+              putters,
+              ([_, deferred, isLastItem]) =>
+                isLastItem ?
+                  pipe(
+                    core.deferredInterruptWith(deferred, fiberId),
+                    core.asUnit
+                  ) :
+                  core.unit,
+              false,
+              false
+            )
           )
         )
       )

package/src/internal/redBlackTree.ts

@@ -2,7 +2,7 @@ import * as Chunk from "../Chunk.js"
 import * as Equal from "../Equal.js"
 import { dual, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import type * as Order from "../Order.js"
 import type * as Ordering from "../Ordering.js"
@@ -25,7 +25,9 @@ export interface RedBlackTreeImpl<in out K, out V> extends RBT.RedBlackTree<K, V
 }
 
 const redBlackTreeVariance = {
+  /* c8 ignore next */
   _Key: (_: any) => _,
+  /* c8 ignore next */
   _Value: (_: never) => _
 }
 
@@ -61,7 +63,7 @@ const RedBlackTreeProto: RBT.RedBlackTree<unknown, unknown> = {
     return new RedBlackTreeIterator(this, stack, Direction.Forward)
   },
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {

package/src/internal/ref.ts

@@ -11,6 +11,7 @@ export const RefTypeId: Ref.RefTypeId = Symbol.for("effect/Ref") as Ref.RefTypeI
 
 /** @internal */
 export const refVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/reloadable.ts

@@ -20,8 +20,8 @@ export const ReloadableTypeId: Reloadable.ReloadableTypeId = Symbol.for(
   ReloadableSymbolKey
 ) as Reloadable.ReloadableTypeId
 
-/** @internal */
 const reloadableVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/request.ts

@@ -1,3 +1,4 @@
+import type * as Cause from "../Cause.js"
 import type * as Effect from "../Effect.js"
 import { dual } from "../Function.js"
 import { hasProperty } from "../Predicate.js"
@@ -15,9 +16,10 @@ export const RequestTypeId: Request.RequestTypeId = Symbol.for(
   RequestSymbolKey
 ) as Request.RequestTypeId
 
-/** @internal */
 const requestVariance = {
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 
@@ -119,6 +121,17 @@ export const fail = dual<
   ) => Effect.Effect<never, never, void>
 >(2, (self, error) => complete(self, core.exitFail(error) as any))
 
+/** @internal */
+export const failCause = dual<
+  <A extends Request.Request<any, any>>(
+    cause: Cause.Cause<Request.Request.Error<A>>
+  ) => (self: A) => Effect.Effect<never, never, void>,
+  <A extends Request.Request<any, any>>(
+    self: A,
+    cause: Cause.Cause<Request.Request.Error<A>>
+  ) => Effect.Effect<never, never, void>
+>(2, (self, cause) => complete(self, core.exitFailCause(cause) as any))
+
 /** @internal */
 export const succeed = dual<
   <A extends Request.Request<any, any>>(

package/src/internal/resource.ts

@@ -16,9 +16,10 @@ export const ResourceTypeId: Resource.ResourceTypeId = Symbol.for(
   ResourceSymbolKey
 ) as Resource.ResourceTypeId
 
-/** @internal */
 const resourceVariance = {
+  /* c8 ignore next */
   _E: (_: any) => _,
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/runtime.ts

@@ -7,7 +7,7 @@ import * as FiberId from "../FiberId.js"
 import type * as FiberRef from "../FiberRef.js"
 import * as FiberRefs from "../FiberRefs.js"
 import { pipe } from "../Function.js"
-import { NodeInspectSymbol, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
@@ -177,7 +177,7 @@ export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure =>
     }
   }
   error.toString = () => {
-    return toString(error.toJSON())
+    return format(error.toJSON())
   }
   error[NodeInspectSymbol] = () => {
     return error.toJSON()