effect 2.3.5 → 2.3.6

package/dist/esm/internal/tracer.js.map

@@ -1 +1 @@
-{"version":3,"file":"tracer.js","names":["Context","globalValue","MutableRef","TracerTypeId","Symbol","for","make","options","tracerTag","GenericTag","spanTag","ids","NativeSpan","name","parent","context","links","startTime","_tag","spanId","traceId","sampled","status","attributes","events","constructor","Map","incrementAndGet","end","endTime","exit","attribute","key","value","set","event","push","nativeTracer","span","f","externalSpan","empty"],"sources":["../../../src/internal/tracer.ts"],"sourcesContent":[null],"mappings":"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"}
+{"version":3,"file":"tracer.js","names":["Context","TracerTypeId","Symbol","for","make","options","tracerTag","GenericTag","spanTag","randomString","characters","charactersLength","length","result","i","charAt","Math","floor","random","NativeSpan","name","parent","context","links","startTime","_tag","spanId","traceId","sampled","status","attributes","events","constructor","Map","end","endTime","exit","attribute","key","value","set","event","push","nativeTracer","span","f","externalSpan","empty"],"sources":["../../../src/internal/tracer.ts"],"sourcesContent":[null],"mappings":"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"}

package/dist/esm/internal/version.js

@@ -1,2 +1,2 @@
-export const moduleVersion = "2.3.5";
+export const moduleVersion = "2.3.6";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.3.5",
+  "version": "2.3.6",
   "description": "Functional programming in TypeScript",
   "license": "MIT",
   "repository": {

package/src/Effect.ts

@@ -2817,8 +2817,8 @@ export const withClockScoped: <A extends Clock.Clock>(value: A) => Effect<void,
  * @category clock
  */
 export const withClock: {
-  <A extends Clock.Clock>(value: A): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>
-  <R, E, A extends Clock.Clock>(effect: Effect<A, E, R>, value: A): Effect<A, E, R>
+  <X extends Clock.Clock>(value: X): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>
+  <X extends Clock.Clock, A, E, R>(effect: Effect<A, E, R>, value: X): Effect<A, E, R>
 } = defaultServices.withClock
 
 // -------------------------------------------------------------------------------------
@@ -4087,11 +4087,11 @@ export const schedule: {
 export const scheduleForked: {
   <R2, Out>(
     schedule: Schedule.Schedule<R2, unknown, Out>
-  ): <A, E, R>(self: Effect<A, E, R>) => Effect<Scope.Scope | R2 | R, never, Fiber.RuntimeFiber<Out, E>>
+  ): <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<Out, E>, never, Scope.Scope | R2 | R>
   <R, E, A, R2, Out>(
     self: Effect<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, Out>
-  ): Effect<Scope.Scope | R | R2, never, Fiber.RuntimeFiber<Out, E>>
+  ): Effect<Fiber.RuntimeFiber<Out, E>, never, Scope.Scope | R | R2>
 } = circular.scheduleForked
 
 /**
@@ -4524,6 +4524,28 @@ export const random: Effect<Random.Random> = effect.random
 export const randomWith: <A, E, R>(f: (random: Random.Random) => Effect<A, E, R>) => Effect<A, E, R> =
   defaultServices.randomWith
 
+/**
+ * Executes the specified workflow with the specified implementation of the
+ * random service.
+ *
+ * @since 2.0.0
+ * @category random
+ */
+export const withRandom: {
+  <X extends Random.Random>(value: X): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>
+  <X extends Random.Random, A, E, R>(effect: Effect<A, E, R>, value: X): Effect<A, E, R>
+} = defaultServices.withRandom
+
+/**
+ * Sets the implementation of the random service to the specified value and
+ * restores it to its original value when the scope is closed.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const withRandomScoped: <A extends Random.Random>(value: A) => Effect<void, never, Scope.Scope> =
+  fiberRuntime.withRandomScoped
+
 // -------------------------------------------------------------------------------------
 // runtime
 // -------------------------------------------------------------------------------------

package/src/FiberId.ts

@@ -23,7 +23,13 @@ export type FiberIdTypeId = typeof FiberIdTypeId
  * @since 2.0.0
  * @category models
  */
-export type FiberId = None | Runtime | Composite
+export type Single = None | Runtime
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type FiberId = Single | Composite
 
 /**
  * @since 2.0.0
@@ -32,6 +38,8 @@ export type FiberId = None | Runtime | Composite
 export interface None extends Equal.Equal, Inspectable {
   readonly [FiberIdTypeId]: FiberIdTypeId
   readonly _tag: "None"
+  readonly id: -1
+  readonly startTimeMillis: -1
 }
 
 /**
@@ -60,19 +68,19 @@ export interface Composite extends Equal.Equal, Inspectable {
  * @since 2.0.0
  * @category constructors
  */
-export const none: FiberId = internal.none
+export const none: None = internal.none
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const runtime: (id: number, startTimeMillis: number) => FiberId = internal.runtime
+export const runtime: (id: number, startTimeMillis: number) => Runtime = internal.runtime
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const composite: (left: FiberId, right: FiberId) => FiberId = internal.composite
+export const composite: (left: FiberId, right: FiberId) => Composite = internal.composite
 
 /**
  * Returns `true` if the specified unknown value is a `FiberId`, `false`

package/src/FiberRefs.ts

@@ -33,7 +33,7 @@ export type FiberRefsSym = typeof FiberRefsSym
  */
 export interface FiberRefs extends Pipeable {
   readonly [FiberRefsSym]: FiberRefsSym
-  readonly locals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>>
+  readonly locals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>
 }
 
 const delete_: {
@@ -68,8 +68,8 @@ export const fiberRefs: (self: FiberRefs) => HashSet.HashSet<FiberRef.FiberRef<a
  * @category utils
  */
 export const forkAs: {
-  (childId: FiberId.Runtime): (self: FiberRefs) => FiberRefs
-  (self: FiberRefs, childId: FiberId.Runtime): FiberRefs
+  (childId: FiberId.Single): (self: FiberRefs) => FiberRefs
+  (self: FiberRefs, childId: FiberId.Single): FiberRefs
 } = internal.forkAs
 
 /**
@@ -105,8 +105,8 @@ export const getOrDefault: {
  * @category utils
  */
 export const joinAs: {
-  (fiberId: FiberId.Runtime, that: FiberRefs): (self: FiberRefs) => FiberRefs
-  (self: FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs): FiberRefs
+  (fiberId: FiberId.Single, that: FiberRefs): (self: FiberRefs) => FiberRefs
+  (self: FiberRefs, fiberId: FiberId.Single, that: FiberRefs): FiberRefs
 } = internal.joinAs
 
 /**
@@ -126,7 +126,7 @@ export const setAll: (self: FiberRefs) => Effect.Effect<void> = internal.setAll
 export const updateAs: {
   <A>(
     options: {
-      readonly fiberId: FiberId.Runtime
+      readonly fiberId: FiberId.Single
       readonly fiberRef: FiberRef.FiberRef<A>
       readonly value: A
     }
@@ -134,7 +134,7 @@ export const updateAs: {
   <A>(
     self: FiberRefs,
     options: {
-      readonly fiberId: FiberId.Runtime
+      readonly fiberId: FiberId.Single
       readonly fiberRef: FiberRef.FiberRef<A>
       readonly value: A
     }
@@ -150,16 +150,16 @@ export const updateAs: {
 export const updateManyAs: {
   (
     options: {
-      readonly forkAs?: FiberId.Runtime | undefined
+      readonly forkAs?: FiberId.Single | undefined
       readonly entries: readonly [
         readonly [
           FiberRef.FiberRef<any>,
-          readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+          readonly [readonly [FiberId.Single, any], ...Array<readonly [FiberId.Single, any]>]
         ],
         ...Array<
           readonly [
             FiberRef.FiberRef<any>,
-            readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+            readonly [readonly [FiberId.Single, any], ...Array<readonly [FiberId.Single, any]>]
           ]
         >
       ]
@@ -168,16 +168,16 @@ export const updateManyAs: {
   (
     self: FiberRefs,
     options: {
-      readonly forkAs?: FiberId.Runtime | undefined
+      readonly forkAs?: FiberId.Single | undefined
       readonly entries: readonly [
         readonly [
           FiberRef.FiberRef<any>,
-          readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+          readonly [readonly [FiberId.Single, any], ...Array<readonly [FiberId.Single, any]>]
         ],
         ...Array<
           readonly [
             FiberRef.FiberRef<any>,
-            readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+            readonly [readonly [FiberId.Single, any], ...Array<readonly [FiberId.Single, any]>]
           ]
         >
       ]
@@ -192,7 +192,7 @@ export const updateManyAs: {
  * @category unsafe
  */
 export const unsafeMake: (
-  fiberRefLocals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>>
+  fiberRefLocals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>
 ) => FiberRefs = internal.unsafeMake
 
 /**

package/src/Function.ts

@@ -202,6 +202,25 @@ export interface FunctionN<A extends ReadonlyArray<unknown>, B> {
  */
 export const identity = <A>(a: A): A => a
 
+/**
+ * A function that ensures that the type of an expression matches some type,
+ * without changing the resulting type of that expression.
+ *
+ * @example
+ * import { satisfies } from "effect/Function"
+ *
+ * const test1 = satisfies<number>()(5 as const)
+ *     //^? const test: 5
+ *     // @ts-expect-error
+ * const test2 = satisfies<string>()(5)
+ *     //^? Argument of type 'number' is not assignable to parameter of type 'string'
+ *
+ * assert.deepStrictEqual(satisfies<number>()(5), 5)
+ *
+ * @since 2.0.0
+ */
+export const satisfies = <A>() => <B extends A>(b: B) => b
+
 /**
  * Casts the result to the specified type.
  *

package/src/Random.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import type * as Chunk from "./Chunk.js"
+import type * as Context from "./Context.js"
 import type * as Effect from "./Effect.js"
 import * as defaultServices from "./internal/defaultServices.js"
 import * as internal from "./internal/random.js"
@@ -111,3 +112,9 @@ export const shuffle: <A>(elements: Iterable<A>) => Effect.Effect<Chunk.Chunk<A>
  */
 export const randomWith: <A, E, R>(f: (random: Random) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
   defaultServices.randomWith
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const Random: Context.Tag<Random, Random> = internal.randomTag

package/src/RequestResolver.ts

@@ -160,6 +160,43 @@ export const around: {
   ): RequestResolver<A, R | R2 | R3>
 } = internal.around
 
+/**
+ * A data source aspect that executes requests between two effects, `before`
+ * and `after`, where the result of `before` can be used by `after`.
+ *
+ * The `before` and `after` effects are provided with the requests being executed.
+ *
+ * @since 2.0.0
+ * @category combinators
+ * @example
+ * import { Effect, Request, RequestResolver } from "effect"
+ *
+ * interface GetUserById extends Request.Request<unknown> {
+ *   readonly id: number
+ * }
+ *
+ * const resolver = RequestResolver.fromFunction(
+ *   (request: GetUserById) => ({ id: request.id, name: "John" })
+ * )
+ *
+ * RequestResolver.aroundRequests(
+ *   resolver,
+ *   (requests) => Effect.log(`got ${requests.length} requests`),
+ *   (requests, _) => Effect.log(`finised running ${requests.length} requests`)
+ * )
+ */
+export const aroundRequests: {
+  <A, R2, A2, R3, _>(
+    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+  ): <R>(self: RequestResolver<A, R>) => RequestResolver<A, R2 | R3 | R>
+  <R, A, R2, A2, R3, _>(
+    self: RequestResolver<A, R>,
+    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+  ): RequestResolver<A, R | R2 | R3>
+} = internal.aroundRequests
+
 /**
  * Returns a data source that executes at most `n` requests in parallel.
  *

package/src/Runtime.ts

@@ -7,6 +7,7 @@ import type * as Effect from "./Effect.js"
 import type * as Exit from "./Exit.js"
 import type * as Fiber from "./Fiber.js"
 import type * as FiberId from "./FiberId.js"
+import type * as FiberRef from "./FiberRef.js"
 import type * as FiberRefs from "./FiberRefs.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as internal from "./internal/runtime.js"
@@ -277,3 +278,53 @@ export const provideService: {
   <I, S>(tag: Context.Tag<I, S>, service: S): <R>(self: Runtime<R>) => Runtime<I | R>
   <R, I, S>(self: Runtime<R>, tag: Context.Tag<I, S>, service: S): Runtime<R | I>
 } = internal.provideService
+
+/**
+ * @since 2.0.0
+ * @category fiber refs
+ */
+export const updateFiberRefs: {
+  (f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): <R>(self: Runtime<R>) => Runtime<R>
+  <R>(self: Runtime<R>, f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): Runtime<R>
+} = internal.updateFiberRefs
+
+/**
+ * @since 2.0.0
+ * @category fiber refs
+ * @example
+ * import { Effect, FiberRef, Runtime } from "effect"
+ *
+ * const ref = FiberRef.unsafeMake(0)
+ *
+ * const updatedRuntime = Runtime.defaultRuntime.pipe(
+ *   Runtime.setFiberRef(ref, 1)
+ * )
+ *
+ * // returns 1
+ * const result = Runtime.runSync(updatedRuntime)(FiberRef.get(ref))
+ */
+export const setFiberRef: {
+  <A>(fiberRef: FiberRef.FiberRef<A>, value: A): <R>(self: Runtime<R>) => Runtime<R>
+  <R, A>(self: Runtime<R>, fiberRef: FiberRef.FiberRef<A>, value: A): Runtime<R>
+} = internal.setFiberRef
+
+/**
+ * @since 2.0.0
+ * @category fiber refs
+ * @example
+ * import { Effect, FiberRef, Runtime } from "effect"
+ *
+ * const ref = FiberRef.unsafeMake(0)
+ *
+ * const updatedRuntime = Runtime.defaultRuntime.pipe(
+ *   Runtime.setFiberRef(ref, 1),
+ *   Runtime.deleteFiberRef(ref)
+ * )
+ *
+ * // returns 0
+ * const result = Runtime.runSync(updatedRuntime)(FiberRef.get(ref))
+ */
+export const deleteFiberRef: {
+  <A>(fiberRef: FiberRef.FiberRef<A>): <R>(self: Runtime<R>) => Runtime<R>
+  <R, A>(self: Runtime<R>, fiberRef: FiberRef.FiberRef<A>): Runtime<R>
+} = internal.deleteFiberRef

package/src/TestAnnotation.ts

@@ -12,6 +12,7 @@ import type * as MutableRef from "./MutableRef.js"
 import { hasProperty } from "./Predicate.js"
 import type * as SortedSet from "./SortedSet.js"
 import type * as Types from "./Types.js"
+
 /** @internal */
 const TestAnnotationSymbolKey = "effect/TestAnnotation"
 

package/src/TestAnnotationMap.ts

@@ -1,7 +1,8 @@
 /**
  * @since 2.0.0
  */
-import { dual, pipe } from "./Function.js"
+import { dual } from "./Function.js"
+import * as HashMap from "./HashMap.js"
 import { hasProperty } from "./Predicate.js"
 import type * as TestAnnotation from "./TestAnnotation.js"
 
@@ -23,13 +24,13 @@ export type TestAnnotationMapTypeId = typeof TestAnnotationMapTypeId
 export interface TestAnnotationMap {
   readonly [TestAnnotationMapTypeId]: TestAnnotationMapTypeId
   /** @internal */
-  readonly map: ReadonlyMap<TestAnnotation.TestAnnotation<unknown>, unknown>
+  readonly map: HashMap.HashMap<TestAnnotation.TestAnnotation<any>, any>
 }
 
 /** @internal */
 class TestAnnotationMapImpl implements TestAnnotationMap {
   readonly [TestAnnotationMapTypeId]: TestAnnotationMapTypeId = TestAnnotationMapTypeId
-  constructor(readonly map: ReadonlyMap<TestAnnotation.TestAnnotation<unknown>, unknown>) {
+  constructor(readonly map: HashMap.HashMap<TestAnnotation.TestAnnotation<any>, any>) {
   }
 }
 
@@ -41,12 +42,12 @@ export const isTestAnnotationMap = (u: unknown): u is TestAnnotationMap => hasPr
 /**
  * @since 2.0.0
  */
-export const empty: (_: void) => TestAnnotationMap = () => new TestAnnotationMapImpl(new Map())
+export const empty: (_: void) => TestAnnotationMap = () => new TestAnnotationMapImpl(HashMap.empty())
 
 /**
  * @since 2.0.0
  */
-export const make = (map: ReadonlyMap<TestAnnotation.TestAnnotation<unknown>, unknown>): TestAnnotationMap => {
+export const make = (map: HashMap.HashMap<TestAnnotation.TestAnnotation<any>, any>): TestAnnotationMap => {
   return new TestAnnotationMapImpl(map)
 }
 
@@ -56,11 +57,7 @@ export const make = (map: ReadonlyMap<TestAnnotation.TestAnnotation<unknown>, un
 export const overwrite = dual<
   <A>(key: TestAnnotation.TestAnnotation<A>, value: A) => (self: TestAnnotationMap) => TestAnnotationMap,
   <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, value: A) => TestAnnotationMap
->(3, (self, key, value) =>
-  make(
-    (self.map as Map<TestAnnotation.TestAnnotation<unknown>, unknown>)
-      .set(key as TestAnnotation.TestAnnotation<unknown>, value)
-  ))
+>(3, (self, key, value) => make(HashMap.set(self.map, key, value)))
 
 /**
  * @since 2.0.0
@@ -69,11 +66,11 @@ export const update = dual<
   <A>(key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => (self: TestAnnotationMap) => TestAnnotationMap,
   <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => TestAnnotationMap
 >(3, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => {
-  let value = self.map.get(key as TestAnnotation.TestAnnotation<unknown>)
-  if (value === undefined) {
-    value = key.initial
+  let value = key.initial
+  if (HashMap.has(self.map, key.identifier)) {
+    value = HashMap.unsafeGet(self.map, key.identifier) as A
   }
-  return pipe(self, overwrite(key, f(value as A)))
+  return overwrite(self, key, f(value))
 })
 
 /**
@@ -86,11 +83,10 @@ export const get = dual<
   <A>(key: TestAnnotation.TestAnnotation<A>) => (self: TestAnnotationMap) => A,
   <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => A
 >(2, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => {
-  const value = self.map.get(key as TestAnnotation.TestAnnotation<unknown>)
-  if (value === undefined) {
-    return key.initial as A
+  if (HashMap.has(self.map, key.identifier)) {
+    return HashMap.unsafeGet(self.map, key.identifier) as A
   }
-  return value as A
+  return key.initial
 })
 
 /**
@@ -110,13 +106,13 @@ export const combine = dual<
   (that: TestAnnotationMap) => (self: TestAnnotationMap) => TestAnnotationMap,
   (self: TestAnnotationMap, that: TestAnnotationMap) => TestAnnotationMap
 >(2, (self, that) => {
-  const result = new Map<TestAnnotation.TestAnnotation<unknown>, unknown>(self.map)
+  let result = self.map
   for (const entry of that.map) {
-    if (result.has(entry[0])) {
-      const value = result.get(entry[0])!
-      result.set(entry[0], entry[0].combine(value, entry[1]))
+    if (HashMap.has(result, entry[0])) {
+      const value = HashMap.get(result, entry[0])!
+      result = HashMap.set(result, entry[0], entry[0].combine(value, entry[1]))
     } else {
-      result.set(entry[0], entry[1])
+      result = HashMap.set(result, entry[0], entry[1])
     }
   }
   return make(result)

package/src/TestAnnotations.ts

@@ -40,6 +40,9 @@ export type TestAnnotationsTypeId = typeof TestAnnotationsTypeId
 export interface TestAnnotations {
   readonly [TestAnnotationsTypeId]: TestAnnotationsTypeId
 
+  /**
+   * A ref containing the bacnking map for all annotations
+   */
   readonly ref: Ref.Ref<TestAnnotationMap.TestAnnotationMap>
 
   /**

package/src/internal/cause.ts

@@ -1040,12 +1040,17 @@ export const prettyErrorMessage = (u: unknown): string => {
     return `Error: ${u}`
   }
   // 2)
-  if (
-    hasProperty(u, "toString") &&
-    isFunction(u["toString"]) &&
-    u["toString"] !== Object.prototype.toString
-  ) {
-    return u["toString"]()
+  try {
+    if (
+      hasProperty(u, "toString") &&
+      isFunction(u["toString"]) &&
+      u["toString"] !== Object.prototype.toString &&
+      u["toString"] !== Array.prototype.toString
+    ) {
+      return u["toString"]()
+    }
+  } catch {
+    // something's off, rollback to json
   }
   // 3)
   return `Error: ${JSON.stringify(u)}`

package/src/internal/dataSource.ts

@@ -7,6 +7,7 @@ import { dual, pipe } from "../Function.js"
 import * as RA from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as RequestResolver from "../RequestResolver.js"
+import type { NoInfer } from "../Types.js"
 import * as core from "./core.js"
 import { invokeWithInterrupt, zipWithOptions } from "./fiberRuntime.js"
 import { complete } from "./request.js"
@@ -71,6 +72,32 @@ export const around = dual<
     Chunk.make("Around", self, before, after)
   ))
 
+/** @internal */
+export const aroundRequests = dual<
+  <A, R2, A2, R3, _>(
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+  ) => <R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
+  <R, A, R2, A2, R3, _>(
+    self: RequestResolver.RequestResolver<A, R>,
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>
+>(3, (self, before, after) =>
+  new core.RequestResolverImpl(
+    (requests) => {
+      const flatRequests = requests.flatMap((chunk) => chunk.map((entry) => entry.request))
+      return core.acquireUseRelease(
+        before(flatRequests),
+        () => self.runAll(requests),
+        (a2) => after(flatRequests, a2)
+      )
+    },
+    Chunk.make("AroundRequests", self, before, after)
+  ))
+
 /** @internal */
 export const batchN = dual<
   (n: number) => <R, A>(

package/src/internal/defaultServices.ts

@@ -58,8 +58,8 @@ export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => cloc
 
 /** @internal */
 export const withClock = dual<
-  <A extends Clock.Clock>(value: A) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A extends Clock.Clock, E, R>(effect: Effect.Effect<A, E, R>, value: A) => Effect.Effect<A, E, R>
+  <X extends Clock.Clock>(value: X) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <X extends Clock.Clock, A, E, R>(effect: Effect.Effect<A, E, R>, value: X) => Effect.Effect<A, E, R>
 >(2, (effect, value) =>
   core.fiberRefLocallyWith(
     currentServices,
@@ -102,6 +102,16 @@ export const randomWith = <A, E, R>(f: (random: Random.Random) => Effect.Effect<
     (services) => f(Context.get(services, random.randomTag))
   )
 
+/** @internal */
+export const withRandom = dual<
+  <X extends Random.Random>(value: X) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <X extends Random.Random, A, E, R>(effect: Effect.Effect<A, E, R>, value: X) => Effect.Effect<A, E, R>
+>(2, (effect, value) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(random.randomTag, value)
+  )(effect))
+
 /** @internal */
 export const next: Effect.Effect<number> = randomWith((random) => random.next)
 

package/src/internal/fiberId.ts

@@ -40,7 +40,9 @@ const emptyHash = Hash.string(`${FiberIdSymbolKey}-${OP_NONE}`)
 /** @internal */
 class None implements FiberId.None {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
-  readonly _tag = OP_NONE;
+  readonly _tag = OP_NONE
+  readonly id = -1
+  readonly startTimeMillis = -1;
   [Hash.symbol](): number {
     return emptyHash
   }
@@ -141,15 +143,15 @@ class Composite implements FiberId.Composite {
 }
 
 /** @internal */
-export const none: FiberId.FiberId = new None()
+export const none: FiberId.None = new None()
 
 /** @internal */
-export const runtime = (id: number, startTimeMillis: number): FiberId.FiberId => {
+export const runtime = (id: number, startTimeMillis: number): FiberId.Runtime => {
   return new Runtime(id, startTimeMillis)
 }
 
 /** @internal */
-export const composite = (left: FiberId.FiberId, right: FiberId.FiberId): FiberId.FiberId => {
+export const composite = (left: FiberId.FiberId, right: FiberId.FiberId): FiberId.Composite => {
   return new Composite(left, right)
 }