effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/RequestResolver.d.ts

@@ -40,14 +40,14 @@ declare const TypeId = "~effect/RequestResolver";
  *
  * **Example** (Defining a request resolver)
  *
- * ```ts
- * import { Effect, Exit, RequestResolver } from "effect"
- * import type { Request } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetUserRequest extends Request.Request<string, Error> {
  *   readonly _tag: "GetUserRequest"
  *   readonly id: number
  * }
+ * const GetUserRequest = Request.tagged<GetUserRequest>("GetUserRequest")
  *
  * // In practice, you would typically use RequestResolver.make() instead
  * const resolver = RequestResolver.make<GetUserRequest>((entries) =>
@@ -57,6 +57,9 @@ declare const TypeId = "~effect/RequestResolver";
  *     }
  *   })
  * )
+ *
+ * const program = Effect.request(GetUserRequest({ id: 1 }), resolver)
+ * await Effect.runPromise(program) // => "User 1"
  * ```
  *
  * @category models
@@ -161,7 +164,7 @@ export declare const makeWith: <A extends Request.Any>(options: {
  *
  * **Example** (Creating a request resolver)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * // Define a request type
@@ -183,6 +186,7 @@ export declare const makeWith: <A extends Request.Any>(options: {
  *
  * // Use the resolver to handle requests
  * const getUserEffect = Effect.request(GetUserRequest({ id: 123 }), UserResolver)
+ * await Effect.runPromise(getUserEffect) // => "User 123"
  * ```
  *
  * @category constructors
@@ -198,7 +202,7 @@ export declare const make: <A extends Request.Any>(runAll: (entries: NonEmptyArr
  *
  * **Example** (Grouping requests by key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetUserByRole extends Request.Request<string, Error> {
@@ -208,12 +212,14 @@ export declare const make: <A extends Request.Any>(runAll: (entries: NonEmptyArr
  * }
  * const GetUserByRole = Request.tagged<GetUserByRole>("GetUserByRole")
  *
+ * const batches: Array<[role: string, size: number]> = []
+ *
  * // Group requests by role for efficient batch processing
  * const UserByRoleResolver = RequestResolver.makeGrouped<GetUserByRole, string>({
  *   key: ({ request }) => request.role,
  *   resolver: (entries, role) =>
  *     Effect.sync(() => {
- *       console.log(`Processing ${entries.length} requests for role: ${role}`)
+ *       batches.push([role, entries.length])
  *       for (const entry of entries) {
  *         entry.completeUnsafe(
  *           Exit.succeed(`User ${entry.request.id} with role ${role}`)
@@ -221,6 +227,15 @@ export declare const make: <A extends Request.Any>(runAll: (entries: NonEmptyArr
  *       }
  *     })
  * })
+ *
+ * const program = Effect.all([
+ *   Effect.request<GetUserByRole>(GetUserByRole({ role: "admin", id: 1 }), UserByRoleResolver),
+ *   Effect.request<GetUserByRole>(GetUserByRole({ role: "admin", id: 2 }), UserByRoleResolver)
+ * ] as const, { concurrency: "unbounded" })
+ * const result = await Effect.runPromise(program)
+ *
+ * batches // => [["admin", 2]]
+ * result // => ["User 1 with role admin", "User 2 with role admin"]
  * ```
  *
  * @category constructors
@@ -235,7 +250,7 @@ export declare const makeGrouped: <A extends Request.Any, K>(options: {
  *
  * **Example** (Creating a resolver from a pure function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Request, RequestResolver } from "effect"
  *
  * interface GetSquareRequest extends Request.Request<number> {
@@ -254,7 +269,7 @@ export declare const makeGrouped: <A extends Request.Any, K>(options: {
  *   GetSquareRequest({ value: 5 }),
  *   SquareResolver
  * )
- * // Will resolve to 25
+ * await Effect.runPromise(getSquareEffect) // => 25
  * ```
  *
  * @category constructors
@@ -268,7 +283,7 @@ export declare const fromFunction: <A extends Request.Any>(f: (entry: Request.En
  *
  * **Example** (Batching pure request handling)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Request, RequestResolver } from "effect"
  *
  * interface GetDoubleRequest extends Request.Request<number> {
@@ -286,7 +301,8 @@ export declare const fromFunction: <A extends Request.Any>(f: (entry: Request.En
  * const effects = [1, 2, 3].map((value) =>
  *   Effect.request(GetDoubleRequest({ value }), DoubleResolver)
  * )
- * const batchedEffect = Effect.all(effects) // [2, 4, 6]
+ * const batchedEffect = Effect.all(effects)
+ * await Effect.runPromise(batchedEffect) // => [2, 4, 6]
  * ```
  *
  * @category constructors
@@ -298,7 +314,7 @@ export declare const fromFunctionBatched: <A extends Request.Any>(f: (entries: N
  *
  * **Example** (Creating a resolver from an effectful function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Request, RequestResolver } from "effect"
  *
  * interface GetUserFromAPIRequest extends Request.Request<string> {
@@ -311,13 +327,7 @@ export declare const fromFunctionBatched: <A extends Request.Any>(f: (entries: N
  *
  * // Create a resolver that uses effects (like HTTP calls)
  * const UserAPIResolver = RequestResolver.fromEffect<GetUserFromAPIRequest>(
- *   (entry) =>
- *     Effect.gen(function*() {
- *       // Simulate an API call
- *       yield* Effect.sleep("100 millis")
- *       // Just return the result without error handling for simplicity
- *       return `User ${entry.request.id} from API`
- *     })
+ *   (entry) => Effect.succeed(`User ${entry.request.id} from API`)
  * )
  *
  * // Usage
@@ -325,6 +335,7 @@ export declare const fromFunctionBatched: <A extends Request.Any>(f: (entries: N
  *   GetUserFromAPIRequest({ id: 123 }),
  *   UserAPIResolver
  * )
+ * await Effect.runPromise(getUserEffect) // => "User 123 from API"
  * ```
  *
  * @category constructors
@@ -339,9 +350,8 @@ export declare const fromEffect: <A extends Request.Any>(f: (entry: Request.Entr
  *
  * **Example** (Handling tagged request batches)
  *
- * ```ts
- * import { Effect, RequestResolver } from "effect"
- * import type { Request } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Request, RequestResolver } from "effect"
  *
  * interface GetUser extends Request.Request<string, Error> {
  *   readonly _tag: "GetUser"
@@ -354,6 +364,8 @@ export declare const fromEffect: <A extends Request.Any>(f: (entry: Request.Entr
  * }
  *
  * type MyRequest = GetUser | GetPost
+ * const GetUser = Request.tagged<GetUser>("GetUser")
+ * const GetPost = Request.tagged<GetPost>("GetPost")
  *
  * // Create a resolver that handles different request types
  * const MyResolver = RequestResolver.fromEffectTagged<MyRequest>()({
@@ -362,6 +374,12 @@ export declare const fromEffect: <A extends Request.Any>(f: (entry: Request.Entr
  *   GetPost: (requests) =>
  *     Effect.succeed(requests.map((req) => `Post ${req.request.id}`))
  * })
+ *
+ * const program = Effect.all([
+ *   Effect.request<GetUser>(GetUser({ id: 1 }), MyResolver),
+ *   Effect.request<GetPost>(GetPost({ id: 2 }), MyResolver)
+ * ] as const)
+ * await Effect.runPromise(program) // => ["User 1", "Post 2"]
  * ```
  *
  * @category constructors
@@ -377,7 +395,7 @@ export declare const fromEffectTagged: <A extends Request.Any & {
  *
  * **Example** (Setting an effectful batch delay)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetDataRequest extends Request.Request<string> {
@@ -393,17 +411,21 @@ export declare const fromEffectTagged: <A extends Request.Any & {
  *   })
  * )
  *
- * // Set a custom delay effect (e.g., with logging)
+ * let delayRan = false
+ *
+ * // Set a custom delay effect
  * const resolverWithCustomDelay = RequestResolver.setDelayEffect(
  *   resolver,
- *   Effect.gen(function*() {
- *     yield* Effect.log("Waiting before processing batch...")
- *     yield* Effect.sleep("50 millis")
+ *   Effect.sync(() => {
+ *     delayRan = true
  *   })
  * )
+ *
+ * await Effect.runPromise(resolverWithCustomDelay.delay)
+ * Array.of(delayRan, RequestResolver.isRequestResolver(resolverWithCustomDelay)) // => [true, true]
  * ```
  *
- * @category delay
+ * @category delays & timeouts
  * @since 4.0.0
  */
 export declare const setDelayEffect: {
@@ -412,7 +434,7 @@ export declare const setDelayEffect: {
      *
      * **Example** (Setting an effectful batch delay)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -428,17 +450,21 @@ export declare const setDelayEffect: {
      *   })
      * )
      *
-     * // Set a custom delay effect (e.g., with logging)
+     * let delayRan = false
+     *
+     * // Set a custom delay effect
      * const resolverWithCustomDelay = RequestResolver.setDelayEffect(
      *   resolver,
-     *   Effect.gen(function*() {
-     *     yield* Effect.log("Waiting before processing batch...")
-     *     yield* Effect.sleep("50 millis")
+     *   Effect.sync(() => {
+     *     delayRan = true
      *   })
      * )
+     *
+     * await Effect.runPromise(resolverWithCustomDelay.delay)
+     * Array.of(delayRan, RequestResolver.isRequestResolver(resolverWithCustomDelay)) // => [true, true]
      * ```
      *
-     * @category delay
+     * @category delays & timeouts
      * @since 4.0.0
      */
     (delay: Effect.Effect<void>): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>;
@@ -447,7 +473,7 @@ export declare const setDelayEffect: {
      *
      * **Example** (Setting an effectful batch delay)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -463,17 +489,21 @@ export declare const setDelayEffect: {
      *   })
      * )
      *
-     * // Set a custom delay effect (e.g., with logging)
+     * let delayRan = false
+     *
+     * // Set a custom delay effect
      * const resolverWithCustomDelay = RequestResolver.setDelayEffect(
      *   resolver,
-     *   Effect.gen(function*() {
-     *     yield* Effect.log("Waiting before processing batch...")
-     *     yield* Effect.sleep("50 millis")
+     *   Effect.sync(() => {
+     *     delayRan = true
      *   })
      * )
+     *
+     * await Effect.runPromise(resolverWithCustomDelay.delay)
+     * Array.of(delayRan, RequestResolver.isRequestResolver(resolverWithCustomDelay)) // => [true, true]
      * ```
      *
-     * @category delay
+     * @category delays & timeouts
      * @since 4.0.0
      */
     <A extends Request.Any>(self: RequestResolver<A>, delay: Effect.Effect<void>): RequestResolver<A>;
@@ -483,7 +513,7 @@ export declare const setDelayEffect: {
  *
  * **Example** (Setting a batch delay)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetDataRequest extends Request.Request<string> {
@@ -502,11 +532,11 @@ export declare const setDelayEffect: {
  * // Add a 100ms delay to batch requests together
  * const delayedResolver = RequestResolver.setDelay(resolver, "100 millis")
  *
- * // Can also use number for milliseconds
- * const delayedResolver2 = RequestResolver.setDelay(resolver, 100)
+ * const program = Effect.request(GetDataRequest(), delayedResolver)
+ * await Effect.runPromise(program) // => "data"
  * ```
  *
- * @category delay
+ * @category delays & timeouts
  * @since 4.0.0
  */
 export declare const setDelay: {
@@ -515,7 +545,7 @@ export declare const setDelay: {
      *
      * **Example** (Setting a batch delay)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -534,11 +564,11 @@ export declare const setDelay: {
      * // Add a 100ms delay to batch requests together
      * const delayedResolver = RequestResolver.setDelay(resolver, "100 millis")
      *
-     * // Can also use number for milliseconds
-     * const delayedResolver2 = RequestResolver.setDelay(resolver, 100)
+     * const program = Effect.request(GetDataRequest(), delayedResolver)
+     * await Effect.runPromise(program) // => "data"
      * ```
      *
-     * @category delay
+     * @category delays & timeouts
      * @since 4.0.0
      */
     (duration: Duration.Input): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>;
@@ -547,7 +577,7 @@ export declare const setDelay: {
      *
      * **Example** (Setting a batch delay)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -566,11 +596,11 @@ export declare const setDelay: {
      * // Add a 100ms delay to batch requests together
      * const delayedResolver = RequestResolver.setDelay(resolver, "100 millis")
      *
-     * // Can also use number for milliseconds
-     * const delayedResolver2 = RequestResolver.setDelay(resolver, 100)
+     * const program = Effect.request(GetDataRequest(), delayedResolver)
+     * await Effect.runPromise(program) // => "data"
      * ```
      *
-     * @category delay
+     * @category delays & timeouts
      * @since 4.0.0
      */
     <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A>;
@@ -580,7 +610,7 @@ export declare const setDelay: {
  *
  * **Example** (Running effects around request resolution)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetDataRequest extends Request.Request<string> {
@@ -588,6 +618,8 @@ export declare const setDelay: {
  * }
  * const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
  *
+ * const events: Array<string> = []
+ *
  * const resolver = RequestResolver.make<GetDataRequest>((entries) =>
  *   Effect.sync(() => {
  *     for (const entry of entries) {
@@ -601,16 +633,20 @@ export declare const setDelay: {
  *   resolver,
  *   (entries) =>
  *     Effect.gen(function*() {
- *       yield* Effect.log(`Starting batch of ${entries.length} requests`)
+ *       events.push(`Starting batch of ${entries.length} requests`)
  *       return entries.length
  *     }),
  *   (entries, initialSize) =>
- *     Effect.gen(function*() {
- *       yield* Effect.log(
- *         `Batch completed with ${entries.length} requests (started with ${initialSize})`
- *       )
+ *     Effect.sync(() => {
+ *       events.push(`Batch completed with ${entries.length} requests (started with ${initialSize})`)
  *     })
  * )
+ *
+ * const program = Effect.request(GetDataRequest(), resolverWithAround)
+ * const result = await Effect.runPromise(program)
+ *
+ * events // => ["Starting batch of 1 requests", "Batch completed with 1 requests (started with 1)"]
+ * result // => "data"
  * ```
  *
  * @category combinators
@@ -622,7 +658,7 @@ export declare const around: {
      *
      * **Example** (Running effects around request resolution)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -630,6 +666,8 @@ export declare const around: {
      * }
      * const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
      *
+     * const events: Array<string> = []
+     *
      * const resolver = RequestResolver.make<GetDataRequest>((entries) =>
      *   Effect.sync(() => {
      *     for (const entry of entries) {
@@ -643,16 +681,20 @@ export declare const around: {
      *   resolver,
      *   (entries) =>
      *     Effect.gen(function*() {
-     *       yield* Effect.log(`Starting batch of ${entries.length} requests`)
+     *       events.push(`Starting batch of ${entries.length} requests`)
      *       return entries.length
      *     }),
      *   (entries, initialSize) =>
-     *     Effect.gen(function*() {
-     *       yield* Effect.log(
-     *         `Batch completed with ${entries.length} requests (started with ${initialSize})`
-     *       )
+     *     Effect.sync(() => {
+     *       events.push(`Batch completed with ${entries.length} requests (started with ${initialSize})`)
      *     })
      * )
+     *
+     * const program = Effect.request(GetDataRequest(), resolverWithAround)
+     * const result = await Effect.runPromise(program)
+     *
+     * events // => ["Starting batch of 1 requests", "Batch completed with 1 requests (started with 1)"]
+     * result // => "data"
      * ```
      *
      * @category combinators
@@ -664,7 +706,7 @@ export declare const around: {
      *
      * **Example** (Running effects around request resolution)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -672,6 +714,8 @@ export declare const around: {
      * }
      * const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
      *
+     * const events: Array<string> = []
+     *
      * const resolver = RequestResolver.make<GetDataRequest>((entries) =>
      *   Effect.sync(() => {
      *     for (const entry of entries) {
@@ -685,16 +729,20 @@ export declare const around: {
      *   resolver,
      *   (entries) =>
      *     Effect.gen(function*() {
-     *       yield* Effect.log(`Starting batch of ${entries.length} requests`)
+     *       events.push(`Starting batch of ${entries.length} requests`)
      *       return entries.length
      *     }),
      *   (entries, initialSize) =>
-     *     Effect.gen(function*() {
-     *       yield* Effect.log(
-     *         `Batch completed with ${entries.length} requests (started with ${initialSize})`
-     *       )
+     *     Effect.sync(() => {
+     *       events.push(`Batch completed with ${entries.length} requests (started with ${initialSize})`)
      *     })
      * )
+     *
+     * const program = Effect.request(GetDataRequest(), resolverWithAround)
+     * const result = await Effect.runPromise(program)
+     *
+     * events // => ["Starting batch of 1 requests", "Batch completed with 1 requests (started with 1)"]
+     * result // => "data"
      * ```
      *
      * @category combinators
@@ -733,7 +781,7 @@ export declare const never: RequestResolver<never>;
  *
  * **Example** (Limiting parallel request batches)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetDataRequest extends Request.Request<string> {
@@ -742,9 +790,11 @@ export declare const never: RequestResolver<never>;
  * }
  * const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
  *
+ * const batchSizes: Array<number> = []
+ *
  * const resolver = RequestResolver.make<GetDataRequest>((entries) =>
  *   Effect.sync(() => {
- *     console.log(`Processing batch of ${entries.length} requests`)
+ *     batchSizes.push(entries.length)
  *     for (const entry of entries) {
  *       entry.completeUnsafe(Exit.succeed(`data-${entry.request.id}`))
  *     }
@@ -759,6 +809,13 @@ export declare const never: RequestResolver<never>;
  *   { length: 12 },
  *   (_, i) => Effect.request(GetDataRequest({ id: i }), limitedResolver)
  * )
+ *
+ * const result = await Effect.runPromise(Effect.all(requests, { concurrency: "unbounded" }))
+ * batchSizes // => [5, 5, 2]
+ *
+ * result.length // => 12
+ *
+ * Array.of(result[0], result[11]) // => ["data-0", "data-11"]
  * ```
  *
  * @category combinators
@@ -777,7 +834,7 @@ export declare const batchN: {
      *
      * **Example** (Limiting parallel request batches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -786,9 +843,11 @@ export declare const batchN: {
      * }
      * const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
      *
+     * const batchSizes: Array<number> = []
+     *
      * const resolver = RequestResolver.make<GetDataRequest>((entries) =>
      *   Effect.sync(() => {
-     *     console.log(`Processing batch of ${entries.length} requests`)
+     *     batchSizes.push(entries.length)
      *     for (const entry of entries) {
      *       entry.completeUnsafe(Exit.succeed(`data-${entry.request.id}`))
      *     }
@@ -803,6 +862,13 @@ export declare const batchN: {
      *   { length: 12 },
      *   (_, i) => Effect.request(GetDataRequest({ id: i }), limitedResolver)
      * )
+     *
+     * const result = await Effect.runPromise(Effect.all(requests, { concurrency: "unbounded" }))
+     * batchSizes // => [5, 5, 2]
+     *
+     * result.length // => 12
+     *
+     * Array.of(result[0], result[11]) // => ["data-0", "data-11"]
      * ```
      *
      * @category combinators
@@ -821,7 +887,7 @@ export declare const batchN: {
      *
      * **Example** (Limiting parallel request batches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -830,9 +896,11 @@ export declare const batchN: {
      * }
      * const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
      *
+     * const batchSizes: Array<number> = []
+     *
      * const resolver = RequestResolver.make<GetDataRequest>((entries) =>
      *   Effect.sync(() => {
-     *     console.log(`Processing batch of ${entries.length} requests`)
+     *     batchSizes.push(entries.length)
      *     for (const entry of entries) {
      *       entry.completeUnsafe(Exit.succeed(`data-${entry.request.id}`))
      *     }
@@ -847,6 +915,13 @@ export declare const batchN: {
      *   { length: 12 },
      *   (_, i) => Effect.request(GetDataRequest({ id: i }), limitedResolver)
      * )
+     *
+     * const result = await Effect.runPromise(Effect.all(requests, { concurrency: "unbounded" }))
+     * batchSizes // => [5, 5, 2]
+     *
+     * result.length // => 12
+     *
+     * Array.of(result[0], result[11]) // => ["data-0", "data-11"]
      * ```
      *
      * @category combinators
@@ -860,7 +935,7 @@ export declare const batchN: {
  *
  * **Example** (Grouping resolver requests)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetUserRequest extends Request.Request<string> {
@@ -870,9 +945,11 @@ export declare const batchN: {
  * }
  * const GetUserRequest = Request.tagged<GetUserRequest>("GetUserRequest")
  *
+ * const batchSizes: Array<number> = []
+ *
  * const resolver = RequestResolver.make<GetUserRequest>((entries) =>
  *   Effect.sync(() => {
- *     console.log(`Processing ${entries.length} users`)
+ *     batchSizes.push(entries.length)
  *     for (const entry of entries) {
  *       entry.completeUnsafe(Exit.succeed(`User ${entry.request.userId}`))
  *     }
@@ -900,6 +977,13 @@ export declare const batchN: {
  *     groupedResolver
  *   )
  * ]
+ *
+ * const result = await Effect.runPromise(Effect.all(requests, { concurrency: "unbounded" }))
+ * batchSizes.sort()
+ *
+ * batchSizes // => [1, 2]
+ *
+ * result // => ["User 1", "User 2", "User 3"]
  * ```
  *
  * @category combinators
@@ -912,7 +996,7 @@ export declare const grouped: {
      *
      * **Example** (Grouping resolver requests)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetUserRequest extends Request.Request<string> {
@@ -922,9 +1006,11 @@ export declare const grouped: {
      * }
      * const GetUserRequest = Request.tagged<GetUserRequest>("GetUserRequest")
      *
+     * const batchSizes: Array<number> = []
+     *
      * const resolver = RequestResolver.make<GetUserRequest>((entries) =>
      *   Effect.sync(() => {
-     *     console.log(`Processing ${entries.length} users`)
+     *     batchSizes.push(entries.length)
      *     for (const entry of entries) {
      *       entry.completeUnsafe(Exit.succeed(`User ${entry.request.userId}`))
      *     }
@@ -952,6 +1038,13 @@ export declare const grouped: {
      *     groupedResolver
      *   )
      * ]
+     *
+     * const result = await Effect.runPromise(Effect.all(requests, { concurrency: "unbounded" }))
+     * batchSizes.sort()
+     *
+     * batchSizes // => [1, 2]
+     *
+     * result // => ["User 1", "User 2", "User 3"]
      * ```
      *
      * @category combinators
@@ -964,7 +1057,7 @@ export declare const grouped: {
      *
      * **Example** (Grouping resolver requests)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetUserRequest extends Request.Request<string> {
@@ -974,9 +1067,11 @@ export declare const grouped: {
      * }
      * const GetUserRequest = Request.tagged<GetUserRequest>("GetUserRequest")
      *
+     * const batchSizes: Array<number> = []
+     *
      * const resolver = RequestResolver.make<GetUserRequest>((entries) =>
      *   Effect.sync(() => {
-     *     console.log(`Processing ${entries.length} users`)
+     *     batchSizes.push(entries.length)
      *     for (const entry of entries) {
      *       entry.completeUnsafe(Exit.succeed(`User ${entry.request.userId}`))
      *     }
@@ -1004,6 +1099,13 @@ export declare const grouped: {
      *     groupedResolver
      *   )
      * ]
+     *
+     * const result = await Effect.runPromise(Effect.all(requests, { concurrency: "unbounded" }))
+     * batchSizes.sort()
+     *
+     * batchSizes // => [1, 2]
+     *
+     * result // => ["User 1", "User 2", "User 3"]
      * ```
      *
      * @category combinators
@@ -1022,7 +1124,7 @@ export declare const grouped: {
  *
  * **Example** (Racing request resolvers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetDataRequest extends Request.Request<string> {
@@ -1053,6 +1155,8 @@ export declare const grouped: {
  *
  * // Race resolvers - will use whichever completes first
  * const racingResolver = RequestResolver.race(fastResolver, slowResolver)
+ * const program = Effect.request(GetDataRequest({ id: 1 }), racingResolver)
+ * await Effect.runPromise(program) // => "fast-1"
  * ```
  *
  * @category combinators
@@ -1070,7 +1174,7 @@ export declare const race: {
      *
      * **Example** (Racing request resolvers)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -1101,6 +1205,8 @@ export declare const race: {
      *
      * // Race resolvers - will use whichever completes first
      * const racingResolver = RequestResolver.race(fastResolver, slowResolver)
+     * const program = Effect.request(GetDataRequest({ id: 1 }), racingResolver)
+     * await Effect.runPromise(program) // => "fast-1"
      * ```
      *
      * @category combinators
@@ -1118,7 +1224,7 @@ export declare const race: {
      *
      * **Example** (Racing request resolvers)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -1149,6 +1255,8 @@ export declare const race: {
      *
      * // Race resolvers - will use whichever completes first
      * const racingResolver = RequestResolver.race(fastResolver, slowResolver)
+     * const program = Effect.request(GetDataRequest({ id: 1 }), racingResolver)
+     * await Effect.runPromise(program) // => "fast-1"
      * ```
      *
      * @category combinators
@@ -1162,7 +1270,7 @@ export declare const race: {
  *
  * **Example** (Adding a tracing span)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Exit, Request, RequestResolver } from "effect"
  *
  * interface GetDataRequest extends Request.Request<string> {
@@ -1193,6 +1301,7 @@ export declare const race: {
  *
  * // Spans will automatically include batch size and request links
  * const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)
+ * await Effect.runPromise(effect) // => "data-123"
  * ```
  *
  * @category combinators
@@ -1205,7 +1314,7 @@ export declare const withSpan: {
      *
      * **Example** (Adding a tracing span)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -1236,6 +1345,7 @@ export declare const withSpan: {
      *
      * // Spans will automatically include batch size and request links
      * const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)
+     * await Effect.runPromise(effect) // => "data-123"
      * ```
      *
      * @category combinators
@@ -1248,7 +1358,7 @@ export declare const withSpan: {
      *
      * **Example** (Adding a tracing span)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Exit, Request, RequestResolver } from "effect"
      *
      * interface GetDataRequest extends Request.Request<string> {
@@ -1279,6 +1389,7 @@ export declare const withSpan: {
      *
      * // Spans will automatically include batch size and request links
      * const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)
+     * await Effect.runPromise(effect) // => "data-123"
      * ```
      *
      * @category combinators
@@ -1487,7 +1598,7 @@ export declare const withCache: {
  * @see {@link withCache} for in-memory resolver caching that does not require persistable request values or a persistence store
  * @see {@link asCache} for exposing resolver results through a `Cache` instead of returning another resolver
  *
- * @category Persistence
+ * @category caching
  * @since 4.0.0
  */
 export declare const persisted: {
@@ -1511,7 +1622,7 @@ export declare const persisted: {
      * @see {@link withCache} for in-memory resolver caching that does not require persistable request values or a persistence store
      * @see {@link asCache} for exposing resolver results through a `Cache` instead of returning another resolver
      *
-     * @category Persistence
+     * @category caching
      * @since 4.0.0
      */
     <A extends Request.Request<any, Persistence.PersistenceError | Schema.SchemaError, any> & Persistable.Any>(options: {
@@ -1539,7 +1650,7 @@ export declare const persisted: {
      * @see {@link withCache} for in-memory resolver caching that does not require persistable request values or a persistence store
      * @see {@link asCache} for exposing resolver results through a `Cache` instead of returning another resolver
      *
-     * @category Persistence
+     * @category caching
      * @since 4.0.0
      */
     <A extends Request.Request<any, Persistence.PersistenceError | Schema.SchemaError, any> & Persistable.Any>(self: RequestResolver<A>, options: {