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

package/src/Layer.ts

@@ -192,7 +192,7 @@ const MemoMapTypeId = "~effect/Layer/MemoMap"
  *
  * **Example** (Sharing layer construction with a memo map)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -211,6 +211,9 @@ const MemoMapTypeId = "~effect/Layer/MemoMap"
  *
  *   return Context.get(context, Database)
  * })
+ *
+ * const database = Effect.runSync(Effect.scoped(program))
+ * Effect.runSync(database.query("SELECT 1")) // => "result"
  * ```
  *
  * @category models
@@ -251,7 +254,7 @@ const memoMapReuse = <RIn, E, ROut>(
  *
  * **Example** (Checking whether a value is a layer)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -263,11 +266,11 @@ const memoMapReuse = <RIn, E, ROut>(
  * })
  * const notALayer = { someProperty: "value" }
  *
- * console.log(Layer.isLayer(dbLayer)) // true
- * console.log(Layer.isLayer(notALayer)) // false
+ * Layer.isLayer(dbLayer) // => true
+ * Layer.isLayer(notALayer) // => false
  * ```
  *
- * @category getters
+ * @category guards
  * @since 2.0.0
  */
 export const isLayer = (u: unknown): u is Layer<unknown, unknown, unknown> => hasProperty(u, TypeId)
@@ -305,7 +308,7 @@ const fromBuildUnsafe = <ROut, E, RIn>(
  *
  * **Example** (Constructing a layer from a build function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -319,6 +322,9 @@ const fromBuildUnsafe = <ROut, E, RIn>(
  *     })
  *   )
  * )
+ *
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, databaseLayer)) // => "result"
  * ```
  *
  * @category constructors
@@ -349,7 +355,7 @@ export const fromBuild = <ROut, E, RIn>(
  *
  * **Example** (Memoizing layer construction)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -363,6 +369,9 @@ export const fromBuild = <ROut, E, RIn>(
  *     })
  *   )
  * )
+ *
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, databaseLayer)) // => "result"
  * ```
  *
  * @category constructors
@@ -451,7 +460,7 @@ class MemoMapImpl implements MemoMap {
  *
  * **Example** (Creating a memo map unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -470,9 +479,12 @@ class MemoMapImpl implements MemoMap {
  *
  *   return Context.get(context, Database)
  * })
+ *
+ * const database = Effect.runSync(Effect.scoped(program))
+ * Effect.runSync(database.query("SELECT 1")) // => "result"
  * ```
  *
- * @category memo map
+ * @category constructors
  * @since 4.0.0
  */
 export const makeMemoMapUnsafe = (): MemoMap => new MemoMapImpl()
@@ -491,7 +503,7 @@ export const makeMemoMapUnsafe = (): MemoMap => new MemoMapImpl()
  * @see {@link forkMemoMap} for allocating the child memo map inside `Effect`
  * @see {@link makeMemoMapUnsafe} for creating a root memo map without a parent
  *
- * @category memo map
+ * @category constructors
  * @since 4.0.0
  */
 export const forkMemoMapUnsafe = (parent: MemoMap): MemoMap => new MemoMapImpl(parent)
@@ -501,7 +513,7 @@ export const forkMemoMapUnsafe = (parent: MemoMap): MemoMap => new MemoMapImpl(p
  *
  * **Example** (Creating a memo map in an effect)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -520,9 +532,12 @@ export const forkMemoMapUnsafe = (parent: MemoMap): MemoMap => new MemoMapImpl(p
  *
  *   return Context.get(context, Database)
  * })
+ *
+ * const database = Effect.runSync(Effect.scoped(program))
+ * Effect.runSync(database.query("SELECT 1")) // => "result"
  * ```
  *
- * @category memo map
+ * @category constructors
  * @since 2.0.0
  */
 export const makeMemoMap: Effect<MemoMap> = internalEffect.sync(makeMemoMapUnsafe)
@@ -541,7 +556,7 @@ export const makeMemoMap: Effect<MemoMap> = internalEffect.sync(makeMemoMapUnsaf
  * @see {@link forkMemoMapUnsafe} for the synchronous constructor variant
  * @see {@link buildWithMemoMap} for building layers with an explicit memo map
  *
- * @category memo map
+ * @category constructors
  * @since 4.0.0
  */
 export const forkMemoMap = (parent: MemoMap): Effect<MemoMap> => internalEffect.sync(() => forkMemoMapUnsafe(parent))
@@ -561,7 +576,7 @@ export const forkMemoMap = (parent: MemoMap): Effect<MemoMap> => internalEffect.
  *
  * @see {@link MemoMap} the memoization map type wrapped by this service
  *
- * @category models
+ * @category services
  * @since 3.13.0
  */
 export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("effect/Layer/CurrentMemoMap") {
@@ -577,7 +592,7 @@ export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("
  *
  * **Example** (Building layers with an explicit memo map)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -588,6 +603,8 @@ export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
+ * const logs: Array<string> = []
+ *
  * // Build layers with explicit memoization control
  * const program = Effect.gen(function*() {
  *   const memoMap = yield* Layer.makeMemoMap
@@ -601,7 +618,7 @@ export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("
  *
  *   // Build logger layer with same memoization (reuses memo if same layer)
  *   const loggerLayer = Layer.succeed(Logger, {
- *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+ *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(msg)))
  *   })
  *   const loggerContext = yield* Layer.buildWithMemoMap(
  *     loggerLayer,
@@ -614,9 +631,13 @@ export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("
  *     logger: Context.get(loggerContext, Logger)
  *   }
  * })
+ *
+ * const services = Effect.runSync(Effect.scoped(program))
+ * Effect.runSync(services.logger.log("ready"))
+ * logs // => ["ready"]
  * ```
  *
- * @category memo map
+ * @category destructors
  * @since 2.0.0
  */
 export const buildWithMemoMap: {
@@ -626,7 +647,7 @@ export const buildWithMemoMap: {
    *
    * **Example** (Building layers with an explicit memo map)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -637,6 +658,8 @@ export const buildWithMemoMap: {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Build layers with explicit memoization control
    * const program = Effect.gen(function*() {
    *   const memoMap = yield* Layer.makeMemoMap
@@ -650,7 +673,7 @@ export const buildWithMemoMap: {
    *
    *   // Build logger layer with same memoization (reuses memo if same layer)
    *   const loggerLayer = Layer.succeed(Logger, {
-   *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(msg)))
    *   })
    *   const loggerContext = yield* Layer.buildWithMemoMap(
    *     loggerLayer,
@@ -663,9 +686,13 @@ export const buildWithMemoMap: {
    *     logger: Context.get(loggerContext, Logger)
    *   }
    * })
+   *
+   * const services = Effect.runSync(Effect.scoped(program))
+   * Effect.runSync(services.logger.log("ready"))
+   * logs // => ["ready"]
    * ```
    *
-   * @category memo map
+   * @category destructors
    * @since 2.0.0
    */
   (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<Context.Context<ROut>, E, RIn>
@@ -675,7 +702,7 @@ export const buildWithMemoMap: {
    *
    * **Example** (Building layers with an explicit memo map)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -686,6 +713,8 @@ export const buildWithMemoMap: {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Build layers with explicit memoization control
    * const program = Effect.gen(function*() {
    *   const memoMap = yield* Layer.makeMemoMap
@@ -699,7 +728,7 @@ export const buildWithMemoMap: {
    *
    *   // Build logger layer with same memoization (reuses memo if same layer)
    *   const loggerLayer = Layer.succeed(Logger, {
-   *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(msg)))
    *   })
    *   const loggerContext = yield* Layer.buildWithMemoMap(
    *     loggerLayer,
@@ -712,9 +741,13 @@ export const buildWithMemoMap: {
    *     logger: Context.get(loggerContext, Logger)
    *   }
    * })
+   *
+   * const services = Effect.runSync(Effect.scoped(program))
+   * Effect.runSync(services.logger.log("ready"))
+   * logs // => ["ready"]
    * ```
    *
-   * @category memo map
+   * @category destructors
    * @since 2.0.0
    */
   <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap, scope: Scope.Scope): Effect<Context.Context<ROut>, E, RIn>
@@ -734,7 +767,7 @@ export const buildWithMemoMap: {
  *
  * **Example** (Building a layer into a context)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -755,6 +788,8 @@ export const buildWithMemoMap: {
  *
  *   return yield* database.query("SELECT * FROM users")
  * })
+ *
+ * Effect.runSync(Effect.scoped(program)) // => "result"
  * ```
  *
  * @category destructors
@@ -786,22 +821,24 @@ export const build = <RIn, E, ROut>(
  *
  * **Example** (Building a layer with an explicit scope)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer, Scope } from "effect"
  *
  * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
+ * const logs: Array<string> = []
+ *
  * // Build a layer with explicit scope control
  * const program = Effect.gen(function*() {
  *   const scope = yield* Effect.scope
  *
  *   const dbLayer = Layer.effect(Database, Effect.gen(function*() {
- *     console.log("Initializing database...")
+ *     logs.push("Initializing database...")
  *     yield* Scope.addFinalizer(
  *       scope,
- *       Effect.sync(() => console.log("Database closed"))
+ *       Effect.sync(() => logs.push("Database closed"))
  *     )
  *     return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
  *   }))
@@ -813,6 +850,9 @@ export const build = <RIn, E, ROut>(
  *   return yield* database.query("SELECT * FROM users")
  *   // Database will be closed when scope is closed
  * })
+ *
+ * Effect.runSync(Effect.scoped(program)) // => "Result: SELECT * FROM users"
+ * logs // => ["Initializing database...", "Database closed"]
  * ```
  *
  * @category destructors
@@ -834,22 +874,24 @@ export const buildWithScope: {
    *
    * **Example** (Building a layer with an explicit scope)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer, Scope } from "effect"
    *
    * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Build a layer with explicit scope control
    * const program = Effect.gen(function*() {
    *   const scope = yield* Effect.scope
    *
    *   const dbLayer = Layer.effect(Database, Effect.gen(function*() {
-   *     console.log("Initializing database...")
+   *     logs.push("Initializing database...")
    *     yield* Scope.addFinalizer(
    *       scope,
-   *       Effect.sync(() => console.log("Database closed"))
+   *       Effect.sync(() => logs.push("Database closed"))
    *     )
    *     return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
    *   }))
@@ -861,6 +903,9 @@ export const buildWithScope: {
    *   return yield* database.query("SELECT * FROM users")
    *   // Database will be closed when scope is closed
    * })
+   *
+   * Effect.runSync(Effect.scoped(program)) // => "Result: SELECT * FROM users"
+   * logs // => ["Initializing database...", "Database closed"]
    * ```
    *
    * @category destructors
@@ -882,22 +927,24 @@ export const buildWithScope: {
    *
    * **Example** (Building a layer with an explicit scope)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer, Scope } from "effect"
    *
    * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Build a layer with explicit scope control
    * const program = Effect.gen(function*() {
    *   const scope = yield* Effect.scope
    *
    *   const dbLayer = Layer.effect(Database, Effect.gen(function*() {
-   *     console.log("Initializing database...")
+   *     logs.push("Initializing database...")
    *     yield* Scope.addFinalizer(
    *       scope,
-   *       Effect.sync(() => console.log("Database closed"))
+   *       Effect.sync(() => logs.push("Database closed"))
    *     )
    *     return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
    *   }))
@@ -909,6 +956,9 @@ export const buildWithScope: {
    *   return yield* database.query("SELECT * FROM users")
    *   // Database will be closed when scope is closed
    * })
+   *
+   * Effect.runSync(Effect.scoped(program)) // => "Result: SELECT * FROM users"
+   * logs // => ["Initializing database...", "Database closed"]
    * ```
    *
    * @category destructors
@@ -938,7 +988,7 @@ export const buildWithScope: {
  *
  * **Example** (Creating a layer from a service implementation)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -948,6 +998,8 @@ export const buildWithScope: {
  * const DatabaseLive = Layer.succeed(Database, {
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Query result: ${sql}`))
  * })
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, DatabaseLive)) // => "Query result: SELECT 1"
  * ```
  *
  * @see {@link sync} for constructing layers from lazy values
@@ -967,7 +1019,7 @@ export const succeed: {
    *
    * **Example** (Creating a layer from a service implementation)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -977,6 +1029,8 @@ export const succeed: {
    * const DatabaseLive = Layer.succeed(Database, {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Query result: ${sql}`))
    * })
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, DatabaseLive)) // => "Query result: SELECT 1"
    * ```
    *
    * @see {@link sync} for constructing layers from lazy values
@@ -996,7 +1050,7 @@ export const succeed: {
    *
    * **Example** (Creating a layer from a service implementation)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1006,6 +1060,8 @@ export const succeed: {
    * const DatabaseLive = Layer.succeed(Database, {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Query result: ${sql}`))
    * })
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, DatabaseLive)) // => "Query result: SELECT 1"
    * ```
    *
    * @see {@link sync} for constructing layers from lazy values
@@ -1037,7 +1093,7 @@ export const succeed: {
  *
  * **Example** (Providing multiple services from a context)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1048,15 +1104,19 @@ export const succeed: {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
+ * const logs: Array<string> = []
  * const context = Context.make(Database, {
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * }).pipe(
  *   Context.add(Logger, {
- *     log: (msg: string) => Effect.sync(() => console.log(msg))
+ *     log: (msg: string) => Effect.sync(() => logs.push(msg))
  *   })
  * )
  *
  * const layer = Layer.succeedContext(context)
+ * const program = Logger.use((logger) => logger.log("ready"))
+ * Effect.runSync(Effect.provide(program, layer))
+ * logs // => ["ready"]
  * ```
  *
  * @see {@link succeed} for providing a single service from a value
@@ -1077,14 +1137,12 @@ export const succeedContext = <A>(context: Context.Context<A>): Layer<A> =>
  *
  * **Example** (Disabling optional lifecycle work)
  *
- * ```ts
- * import { Console, Layer } from "effect"
- *
- * declare const flag: boolean
+ * ```ts import.meta.vitest
+ * import { Context, Effect, Layer, Option } from "effect"
  *
- * const StartupLogLive = flag
- *   ? Layer.effectDiscard(Console.log("application starting"))
- *   : Layer.empty
+ * const Service = Context.Service<string>("Service")
+ * const context = Effect.runSync(Effect.scoped(Layer.build(Layer.empty)))
+ * Context.getOption(context, Service) // => Option.none()
  * ```
  *
  * @see {@link effectDiscard} for running an effect while providing no services
@@ -1109,7 +1167,7 @@ export const empty: Layer<never> = succeedContext(Context.empty())
  *
  * **Example** (Lazily providing a service)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1119,6 +1177,8 @@ export const empty: Layer<never> = succeedContext(Context.empty())
  * const layer = Layer.sync(Database, () => ({
  *   query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  * }))
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
  * ```
  *
  * @see {@link succeed} for constructing layers from static values
@@ -1142,7 +1202,7 @@ export const sync: {
    *
    * **Example** (Lazily providing a service)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1152,6 +1212,8 @@ export const sync: {
    * const layer = Layer.sync(Database, () => ({
    *   query: (sql: string) => Effect.succeed(`Query: ${sql}`)
    * }))
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
    * ```
    *
    * @see {@link succeed} for constructing layers from static values
@@ -1175,7 +1237,7 @@ export const sync: {
    *
    * **Example** (Lazily providing a service)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1185,6 +1247,8 @@ export const sync: {
    * const layer = Layer.sync(Database, () => ({
    *   query: (sql: string) => Effect.succeed(`Query: ${sql}`)
    * }))
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
    * ```
    *
    * @see {@link succeed} for constructing layers from static values
@@ -1215,7 +1279,7 @@ export const sync: {
  *
  * **Example** (Lazily providing a context)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1227,6 +1291,8 @@ export const sync: {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   })
  * )
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
  * ```
  *
  * @see {@link sync} for lazily providing a single service
@@ -1254,7 +1320,7 @@ export const syncContext = <A>(evaluate: LazyArg<Context.Context<A>>): Layer<A>
  *
  * **Example** (Creating a layer from an effect)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1266,6 +1332,8 @@ export const syncContext = <A>(evaluate: LazyArg<Context.Context<A>>): Layer<A>
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   }))
  * )
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
  * ```
  *
  * @see {@link effectContext} for effectfully providing multiple services
@@ -1291,7 +1359,7 @@ export const effect: {
    *
    * **Example** (Creating a layer from an effect)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1303,6 +1371,8 @@ export const effect: {
    *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
    *   }))
    * )
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
    * ```
    *
    * @see {@link effectContext} for effectfully providing multiple services
@@ -1330,7 +1400,7 @@ export const effect: {
    *
    * **Example** (Creating a layer from an effect)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1342,6 +1412,8 @@ export const effect: {
    *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
    *   }))
    * )
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
    * ```
    *
    * @see {@link effectContext} for effectfully providing multiple services
@@ -1380,7 +1452,7 @@ const effectImpl = <I, S, E, R>(
  *
  * **Example** (Creating a layer from an effectful context)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<
@@ -1393,6 +1465,8 @@ const effectImpl = <I, S, E, R>(
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   }))
  * )
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, layer)) // => "Query: SELECT 1"
  * ```
  *
  * @see {@link effect} for effectfully providing a single service
@@ -1415,14 +1489,17 @@ export const effectContext = <A, E, R>(
  *
  * **Example** (Running an effect during layer construction)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Layer } from "effect"
  *
+ * const logs: Array<string> = []
  * const initLayer = Layer.effectDiscard(
  *   Effect.sync(() => {
- *     console.log("Initializing application...")
+ *     logs.push("Initializing application...")
  *   })
  * )
+ * Effect.runSync(Effect.scoped(Layer.build(initLayer)))
+ * logs // => ["Initializing application..."]
  * ```
  *
  * @see {@link empty} for a no-op layer that performs no construction work
@@ -1443,8 +1520,8 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
  *
  * **Example** (Choosing a layer lazily)
  *
- * ```ts
- * import { Context, Layer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Effect, Layer } from "effect"
  *
  * class Config extends Context.Service<Config, string>()("Config") {}
  *
@@ -1455,6 +1532,7 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
  *     ? Layer.succeed(Config, "https://api.example.com")
  *     : Layer.succeed(Config, "http://localhost:3000")
  * )
+ * Effect.runSync(Effect.provide(Config, layer)) // => "https://api.example.com"
  * ```
  *
  * @category constructors
@@ -1478,7 +1556,7 @@ export const suspend = <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>): Layer<A, E,
  *
  * **Example** (Unwrapping an effectful layer)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1490,6 +1568,8 @@ export const suspend = <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>): Layer<A, E,
  * )
  *
  * const unwrappedLayer = Layer.unwrap(layerEffect)
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, unwrappedLayer)) // => "result"
  * ```
  *
  * @category converting
@@ -1537,7 +1617,7 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
  *
  * **Example** (Merging independent layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1551,11 +1631,15 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
  * const dbLayer = Layer.succeed(Database, {
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
+ * const logs: Array<string> = []
  * const loggerLayer = Layer.succeed(Logger, {
- *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(msg)))
  * })
  *
  * const mergedLayer = Layer.mergeAll(dbLayer, loggerLayer)
+ * const program = Logger.use((logger) => logger.log("ready"))
+ * Effect.runSync(Effect.provide(program, mergedLayer))
+ * logs // => ["ready"]
  * ```
  *
  * @see {@link merge} for merging one layer with another layer or array
@@ -1588,7 +1672,7 @@ export const mergeAll = <Layers extends [Layer<never, any, any>, ...Array<Layer<
  *
  * **Example** (Merging two layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1603,10 +1687,12 @@ export const mergeAll = <Layers extends [Layer<never, any, any>, ...Array<Layer<
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  * const loggerLayer = Layer.succeed(Logger, {
- *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+ *   log: Effect.fn("Logger.log")((_msg: string) => Effect.void)
  * })
  *
  * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, mergedLayer)) // => "result"
  * ```
  *
  * @see {@link mergeAll} for merging several layers at once
@@ -1632,7 +1718,7 @@ export const merge: {
    *
    * **Example** (Merging two layers)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1647,10 +1733,12 @@ export const merge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
    * })
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *   log: Effect.fn("Logger.log")((_msg: string) => Effect.void)
    * })
    *
    * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, mergedLayer)) // => "result"
    * ```
    *
    * @see {@link mergeAll} for merging several layers at once
@@ -1676,7 +1764,7 @@ export const merge: {
    *
    * **Example** (Merging two layers)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1691,10 +1779,12 @@ export const merge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
    * })
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *   log: Effect.fn("Logger.log")((_msg: string) => Effect.void)
    * })
    *
    * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, mergedLayer)) // => "result"
    * ```
    *
    * @see {@link mergeAll} for merging several layers at once
@@ -1727,7 +1817,7 @@ export const merge: {
    *
    * **Example** (Merging two layers)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1742,10 +1832,12 @@ export const merge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
    * })
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *   log: Effect.fn("Logger.log")((_msg: string) => Effect.void)
    * })
    *
    * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, mergedLayer)) // => "result"
    * ```
    *
    * @see {@link mergeAll} for merging several layers at once
@@ -1771,7 +1863,7 @@ export const merge: {
    *
    * **Example** (Merging two layers)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1786,10 +1878,12 @@ export const merge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
    * })
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *   log: Effect.fn("Logger.log")((_msg: string) => Effect.void)
    * })
    *
    * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
+   * const program = Database.use((database) => database.query("SELECT 1"))
+   * Effect.runSync(Effect.provide(program, mergedLayer)) // => "result"
    * ```
    *
    * @see {@link mergeAll} for merging several layers at once
@@ -1844,7 +1938,7 @@ const provideWith = (
  *
  * **Example** (Providing layer dependencies)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1867,8 +1961,9 @@ const provideWith = (
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  * })
  *
+ * const logs: Array<string> = []
  * const loggerLayer = Layer.succeed(Logger, {
- *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
  * })
  *
  * // UserService depends on Database and Logger
@@ -1899,6 +1994,8 @@ const provideWith = (
  * }).pipe(
  *   Effect.provide(userServiceWithDependencies)
  * )
+ * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+ * logs // => ["[LOG] Looking up user 123"]
  * ```
  *
  * @see {@link provideMerge} for retaining the dependency services
@@ -1922,7 +2019,7 @@ export const provide: {
    *
    * **Example** (Providing layer dependencies)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -1945,8 +2042,9 @@ export const provide: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -1977,6 +2075,8 @@ export const provide: {
    * }).pipe(
    *   Effect.provide(userServiceWithDependencies)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123"]
    * ```
    *
    * @see {@link provideMerge} for retaining the dependency services
@@ -2000,7 +2100,7 @@ export const provide: {
    *
    * **Example** (Providing layer dependencies)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -2023,8 +2123,9 @@ export const provide: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -2055,6 +2156,8 @@ export const provide: {
    * }).pipe(
    *   Effect.provide(userServiceWithDependencies)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123"]
    * ```
    *
    * @see {@link provideMerge} for retaining the dependency services
@@ -2085,7 +2188,7 @@ export const provide: {
    *
    * **Example** (Providing layer dependencies)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -2108,8 +2211,9 @@ export const provide: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -2140,6 +2244,8 @@ export const provide: {
    * }).pipe(
    *   Effect.provide(userServiceWithDependencies)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123"]
    * ```
    *
    * @see {@link provideMerge} for retaining the dependency services
@@ -2163,7 +2269,7 @@ export const provide: {
    *
    * **Example** (Providing layer dependencies)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -2186,8 +2292,9 @@ export const provide: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -2218,6 +2325,8 @@ export const provide: {
    * }).pipe(
    *   Effect.provide(userServiceWithDependencies)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123"]
    * ```
    *
    * @see {@link provideMerge} for retaining the dependency services
@@ -2251,7 +2360,7 @@ export const provide: {
  *
  * **Example** (Providing dependencies while retaining services)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -2274,8 +2383,9 @@ export const provide: {
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  * })
  *
+ * const logs: Array<string> = []
  * const loggerLayer = Layer.succeed(Logger, {
- *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
  * })
  *
  * // UserService depends on Database and Logger
@@ -2312,6 +2422,8 @@ export const provide: {
  * }).pipe(
  *   Effect.provide(allServicesLayer)
  * )
+ * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+ * logs // => ["[LOG] Looking up user 123", "[LOG] Found user: DB: SELECT * FROM users WHERE id = 123"]
  * ```
  *
  * @see {@link provide} for keeping dependency services private
@@ -2335,7 +2447,7 @@ export const provideMerge: {
    *
    * **Example** (Providing dependencies while retaining services)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -2358,8 +2470,9 @@ export const provideMerge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -2396,6 +2509,8 @@ export const provideMerge: {
    * }).pipe(
    *   Effect.provide(allServicesLayer)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123", "[LOG] Found user: DB: SELECT * FROM users WHERE id = 123"]
    * ```
    *
    * @see {@link provide} for keeping dependency services private
@@ -2419,7 +2534,7 @@ export const provideMerge: {
    *
    * **Example** (Providing dependencies while retaining services)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -2442,8 +2557,9 @@ export const provideMerge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -2480,6 +2596,8 @@ export const provideMerge: {
    * }).pipe(
    *   Effect.provide(allServicesLayer)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123", "[LOG] Found user: DB: SELECT * FROM users WHERE id = 123"]
    * ```
    *
    * @see {@link provide} for keeping dependency services private
@@ -2510,7 +2628,7 @@ export const provideMerge: {
    *
    * **Example** (Providing dependencies while retaining services)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -2533,8 +2651,9 @@ export const provideMerge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -2571,6 +2690,8 @@ export const provideMerge: {
    * }).pipe(
    *   Effect.provide(allServicesLayer)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123", "[LOG] Found user: DB: SELECT * FROM users WHERE id = 123"]
    * ```
    *
    * @see {@link provide} for keeping dependency services private
@@ -2594,7 +2715,7 @@ export const provideMerge: {
    *
    * **Example** (Providing dependencies while retaining services)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -2617,8 +2738,9 @@ export const provideMerge: {
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    * })
    *
+   * const logs: Array<string> = []
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(`[LOG] ${msg}`)))
    * })
    *
    * // UserService depends on Database and Logger
@@ -2655,6 +2777,8 @@ export const provideMerge: {
    * }).pipe(
    *   Effect.provide(allServicesLayer)
    * )
+   * Effect.runSync(program) // => { id: "123", name: "DB: SELECT * FROM users WHERE id = 123" }
+   * logs // => ["[LOG] Looking up user 123", "[LOG] Found user: DB: SELECT * FROM users WHERE id = 123"]
    * ```
    *
    * @see {@link provide} for keeping dependency services private
@@ -2683,7 +2807,7 @@ export const provideMerge: {
  *
  * **Example** (Creating services from layer output)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Config extends Context.Service<Config, {
@@ -2699,6 +2823,8 @@ export const provideMerge: {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
+ * const logs: Array<string> = []
+ *
  * // Base config layer
  * const configLayer = Layer.succeed(Config, {
  *   dbUrl: "postgres://localhost:5432/mydb",
@@ -2722,8 +2848,8 @@ export const provideMerge: {
  *     const loggerLayer = Layer.succeed(Logger, {
  *       log: Effect.fn("Logger.log")((msg: string) =>
  *         config.logLevel === "debug"
- *           ? Effect.sync(() => console.log(`[DEBUG] ${msg}`))
- *           : Effect.sync(() => console.log(msg))
+ *           ? Effect.sync(() => logs.push(`[DEBUG] ${msg}`))
+ *           : Effect.sync(() => logs.push(msg))
  *       )
  *     })
  *
@@ -2744,6 +2870,8 @@ export const provideMerge: {
  * }).pipe(
  *   Effect.provide(dynamicServiceLayer)
  * )
+ * Effect.runSync(program) // => "Querying postgres://localhost:5432/mydb: SELECT * FROM users"
+ * logs // => ["[DEBUG] Starting database query"]
  * ```
  *
  * @category sequencing
@@ -2755,7 +2883,7 @@ export const flatMap: {
    *
    * **Example** (Creating services from layer output)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Config extends Context.Service<Config, {
@@ -2771,6 +2899,8 @@ export const flatMap: {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Base config layer
    * const configLayer = Layer.succeed(Config, {
    *   dbUrl: "postgres://localhost:5432/mydb",
@@ -2794,8 +2924,8 @@ export const flatMap: {
    *     const loggerLayer = Layer.succeed(Logger, {
    *       log: Effect.fn("Logger.log")((msg: string) =>
    *         config.logLevel === "debug"
-   *           ? Effect.sync(() => console.log(`[DEBUG] ${msg}`))
-   *           : Effect.sync(() => console.log(msg))
+   *           ? Effect.sync(() => logs.push(`[DEBUG] ${msg}`))
+   *           : Effect.sync(() => logs.push(msg))
    *       )
    *     })
    *
@@ -2816,6 +2946,8 @@ export const flatMap: {
    * }).pipe(
    *   Effect.provide(dynamicServiceLayer)
    * )
+   * Effect.runSync(program) // => "Querying postgres://localhost:5432/mydb: SELECT * FROM users"
+   * logs // => ["[DEBUG] Starting database query"]
    * ```
    *
    * @category sequencing
@@ -2827,7 +2959,7 @@ export const flatMap: {
    *
    * **Example** (Creating services from layer output)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Config extends Context.Service<Config, {
@@ -2843,6 +2975,8 @@ export const flatMap: {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Base config layer
    * const configLayer = Layer.succeed(Config, {
    *   dbUrl: "postgres://localhost:5432/mydb",
@@ -2866,8 +3000,8 @@ export const flatMap: {
    *     const loggerLayer = Layer.succeed(Logger, {
    *       log: Effect.fn("Logger.log")((msg: string) =>
    *         config.logLevel === "debug"
-   *           ? Effect.sync(() => console.log(`[DEBUG] ${msg}`))
-   *           : Effect.sync(() => console.log(msg))
+   *           ? Effect.sync(() => logs.push(`[DEBUG] ${msg}`))
+   *           : Effect.sync(() => logs.push(msg))
    *       )
    *     })
    *
@@ -2888,6 +3022,8 @@ export const flatMap: {
    * }).pipe(
    *   Effect.provide(dynamicServiceLayer)
    * )
+   * Effect.runSync(program) // => "Querying postgres://localhost:5432/mydb: SELECT * FROM users"
+   * logs // => ["[DEBUG] Starting database query"]
    * ```
    *
    * @category sequencing
@@ -3151,8 +3287,8 @@ export const tapCause: {
  *
  * **Example** (Converting layer failures to defects)
  *
- * ```ts
- * import { Context, Data, Effect, Layer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Data, Effect, Exit, Layer } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
  *   message: string
@@ -3163,10 +3299,11 @@ export const tapCause: {
  * }>()("Database") {}
  *
  * // Layer that can fail during construction
- * const flakyDatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
- *   console.log("connecting")
- *   return yield* new DatabaseError({ message: "Connection failed" })
- * }))
+ * const error = new DatabaseError({ message: "Connection failed" })
+ * const flakyDatabaseLayer = Layer.effect(
+ *   Database,
+ *   Effect.fail(error)
+ * )
  *
  * // Convert failures to fiber death - removes error from type
  * const reliableDatabaseLayer = flakyDatabaseLayer.pipe(Layer.orDie)
@@ -3179,8 +3316,7 @@ export const tapCause: {
  *   Effect.provide(reliableDatabaseLayer)
  * )
  *
- * // Running the program prints "connecting", then the DatabaseError is
- * // converted into a fiber defect instead of remaining a typed error.
+ * Effect.runSync(Effect.exit(program)) // => Exit.die(error)
  * ```
  *
  * @category error handling
@@ -3235,7 +3371,7 @@ export {
  *
  * **Example** (Recovering from tagged layer errors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Data, Effect, Layer } from "effect"
  *
  * class ConfigError extends Data.TaggedError("ConfigError") {}
@@ -3251,6 +3387,8 @@ export {
  * const recovered = configLayer.pipe(
  *   Layer.catchTag("ConfigError", () => fallbackLayer)
  * )
+ * const program = Config.useSync((config) => config.apiUrl)
+ * Effect.runSync(Effect.provide(program, recovered)) // => "http://localhost"
  * ```
  *
  * @see {@link catchCause} for recovering with access to the full cause
@@ -3268,7 +3406,7 @@ export const catchTag: {
    *
    * **Example** (Recovering from tagged layer errors)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Data, Effect, Layer } from "effect"
    *
    * class ConfigError extends Data.TaggedError("ConfigError") {}
@@ -3284,6 +3422,8 @@ export const catchTag: {
    * const recovered = configLayer.pipe(
    *   Layer.catchTag("ConfigError", () => fallbackLayer)
    * )
+   * const program = Config.useSync((config) => config.apiUrl)
+   * Effect.runSync(Effect.provide(program, recovered)) // => "http://localhost"
    * ```
    *
    * @see {@link catchCause} for recovering with access to the full cause
@@ -3312,7 +3452,7 @@ export const catchTag: {
    *
    * **Example** (Recovering from tagged layer errors)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Data, Effect, Layer } from "effect"
    *
    * class ConfigError extends Data.TaggedError("ConfigError") {}
@@ -3328,6 +3468,8 @@ export const catchTag: {
    * const recovered = configLayer.pipe(
    *   Layer.catchTag("ConfigError", () => fallbackLayer)
    * )
+   * const program = Config.useSync((config) => config.apiUrl)
+   * Effect.runSync(Effect.provide(program, recovered)) // => "http://localhost"
    * ```
    *
    * @see {@link catchCause} for recovering with access to the full cause
@@ -3390,7 +3532,7 @@ export const catchTag: {
  *
  * **Example** (Recovering from layer failures by cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Data, Effect, Layer } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
@@ -3415,14 +3557,12 @@ export const catchTag: {
  *
  * const program = Effect.gen(function*() {
  *   const database = yield* Database
- *   const result = yield* database.query("SELECT * FROM users")
- *   console.log(result)
+ *   return yield* database.query("SELECT * FROM users")
  * }).pipe(
  *   Effect.provide(databaseWithFallback)
  * )
  *
- * Effect.runPromise(program)
- * // Memory: SELECT * FROM users
+ * await Effect.runPromise(program) // => "Memory: SELECT * FROM users"
  * ```
  *
  * @see {@link catchTag} for recovering from specific tagged errors
@@ -3448,7 +3588,7 @@ export const catchCause: {
    *
    * **Example** (Recovering from layer failures by cause)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Data, Effect, Layer } from "effect"
    *
    * class DatabaseError extends Data.TaggedError("DatabaseError")<{
@@ -3473,14 +3613,12 @@ export const catchCause: {
    *
    * const program = Effect.gen(function*() {
    *   const database = yield* Database
-   *   const result = yield* database.query("SELECT * FROM users")
-   *   console.log(result)
+   *   return yield* database.query("SELECT * FROM users")
    * }).pipe(
    *   Effect.provide(databaseWithFallback)
    * )
    *
-   * Effect.runPromise(program)
-   * // Memory: SELECT * FROM users
+   * await Effect.runPromise(program) // => "Memory: SELECT * FROM users"
    * ```
    *
    * @see {@link catchTag} for recovering from specific tagged errors
@@ -3506,7 +3644,7 @@ export const catchCause: {
    *
    * **Example** (Recovering from layer failures by cause)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Data, Effect, Layer } from "effect"
    *
    * class DatabaseError extends Data.TaggedError("DatabaseError")<{
@@ -3531,14 +3669,12 @@ export const catchCause: {
    *
    * const program = Effect.gen(function*() {
    *   const database = yield* Database
-   *   const result = yield* database.query("SELECT * FROM users")
-   *   console.log(result)
+   *   return yield* database.query("SELECT * FROM users")
    * }).pipe(
    *   Effect.provide(databaseWithFallback)
    * )
    *
-   * Effect.runPromise(program)
-   * // Memory: SELECT * FROM users
+   * await Effect.runPromise(program) // => "Memory: SELECT * FROM users"
    * ```
    *
    * @see {@link catchTag} for recovering from specific tagged errors
@@ -3646,7 +3782,7 @@ export const updateService: {
  *
  * **Example** (Creating non-shared layer instances)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer, Ref } from "effect"
  *
  * class Counter extends Context.Service<Counter, {
@@ -3671,10 +3807,10 @@ export const updateService: {
  *   return { counterId: counter.id }
  * }))
  *
- * const showIds = Effect.gen(function*() {
+ * const compareIds = Effect.gen(function*() {
  *   const left = yield* Left
  *   const right = yield* Right
- *   console.log(`same Counter: ${left.counterId === right.counterId}`)
+ *   return left.counterId === right.counterId
  * })
  *
  * const program = Effect.gen(function*() {
@@ -3682,7 +3818,6 @@ export const updateService: {
  *
  *   const counterLayer = Layer.effect(Counter, Effect.gen(function*() {
  *     const id = yield* Ref.updateAndGet(nextId, (n) => n + 1)
- *     console.log("constructed Counter")
  *     return { id }
  *   }))
  *
@@ -3691,7 +3826,7 @@ export const updateService: {
  *     Layer.provide(rightLayer, counterLayer)
  *   )
  *
- *   yield* Effect.provide(showIds, shared)
+ *   const sharedResult = yield* Effect.provide(compareIds, shared)
  *
  *   const freshCounterLayer = Layer.fresh(counterLayer)
  *   const fresh = Layer.merge(
@@ -3699,15 +3834,12 @@ export const updateService: {
  *     Layer.provide(rightLayer, freshCounterLayer)
  *   )
  *
- *   yield* Effect.provide(showIds, fresh)
+ *   const freshResult = yield* Effect.provide(compareIds, fresh)
+ *
+ *   return { shared: sharedResult, fresh: freshResult }
  * })
  *
- * Effect.runPromise(program)
- * // constructed Counter
- * // same Counter: true
- * // constructed Counter
- * // constructed Counter
- * // same Counter: false
+ * await Effect.runPromise(program) // => { shared: true, fresh: false }
  * ```
  *
  * @category layers
@@ -3731,50 +3863,30 @@ export const fresh = <A, E, R>(self: Layer<A, E, R>): Layer<A, E, R> =>
  *
  * **Example** (Launching an application layer)
  *
- * ```ts
- * import { Console, Context, Effect, Layer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Deferred, Effect, Fiber, Layer, Ref } from "effect"
  *
  * class HttpServer extends Context.Service<HttpServer, {
- *   readonly start: () => Effect.Effect<string>
- *   readonly stop: () => Effect.Effect<string>
+ *   readonly port: number
  * }>()("HttpServer") {}
  *
- * class Logger extends Context.Service<Logger, {
- *   readonly log: (msg: string) => Effect.Effect<void>
- * }>()("Logger") {}
- *
- * // Server layer that starts an HTTP server
- * const serverLayer = Layer.effect(HttpServer, Effect.gen(function*() {
- *   yield* Console.log("Starting HTTP server...")
+ * const program = Effect.gen(function*() {
+ *   const events = yield* Ref.make<Array<string>>([])
+ *   const started = yield* Deferred.make<void>()
  *
- *   return {
- *     start: Effect.fn("HttpServer.start")(function*() {
- *         yield* Console.log("Server listening on port 3000")
- *         return "Server started"
- *       }),
- *     stop: Effect.fn("HttpServer.stop")(function*() {
- *         yield* Console.log("Server stopped gracefully")
- *         return "Server stopped"
- *       })
- *   }
- * }))
+ *   const serverLayer = Layer.effect(HttpServer, Effect.gen(function*() {
+ *     yield* Ref.update(events, (events) => [...events, "Starting HTTP server..."])
+ *     yield* Deferred.succeed(started, undefined)
+ *     return { port: 3000 }
+ *   }))
  *
- * const loggerLayer = Layer.succeed(Logger, {
- *   log: Effect.fn("Logger.log")((msg: string) => Console.log(`[LOG] ${msg}`))
+ *   const fiber = yield* Effect.forkChild(Layer.launch(serverLayer))
+ *   yield* Deferred.await(started)
+ *   yield* Fiber.interrupt(fiber)
+ *   return yield* Ref.get(events)
  * })
  *
- * // Application layer combining all services
- * const appLayer = Layer.mergeAll(serverLayer, loggerLayer)
- *
- * // Launch the application - runs until interrupted
- * const application = appLayer.pipe(
- *   Layer.launch,
- *   Effect.tapError((error) => Console.log(`Application failed: ${error}`)),
- *   Effect.tap(() => Console.log("Application completed"))
- * )
- *
- * // This will run forever until externally interrupted
- * // Effect.runFork(application)
+ * await Effect.runPromise(program) // => ["Starting HTTP server..."]
  * ```
  *
  * @category converting
@@ -3835,7 +3947,7 @@ type AnyEffectOrStream =
  *
  * **Example** (Mocking services for tests)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class UserService extends Context.Service<UserService, {
@@ -3863,13 +3975,15 @@ type AnyEffectOrStream =
  *
  *   // This works - we provided an implementation
  *   const user = yield* userService.getUser("123")
- *   console.log(user.name) // "Test User"
  *
  *   // This would throw - we didn't implement deleteUser
  *   // yield* userService.deleteUser("123") // UnimplementedError
+ *
+ *   return user.name
  * }).pipe(
  *   Effect.provide(testUserLayer)
  * )
+ * Effect.runSync(testProgram) // => "Test User"
  * ```
  *
  * @category testing
@@ -3891,7 +4005,7 @@ export const mock: {
    *
    * **Example** (Mocking services for tests)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class UserService extends Context.Service<UserService, {
@@ -3919,13 +4033,15 @@ export const mock: {
    *
    *   // This works - we provided an implementation
    *   const user = yield* userService.getUser("123")
-   *   console.log(user.name) // "Test User"
    *
    *   // This would throw - we didn't implement deleteUser
    *   // yield* userService.deleteUser("123") // UnimplementedError
+   *
+   *   return user.name
    * }).pipe(
    *   Effect.provide(testUserLayer)
    * )
+   * Effect.runSync(testProgram) // => "Test User"
    * ```
    *
    * @category testing
@@ -3947,7 +4063,7 @@ export const mock: {
    *
    * **Example** (Mocking services for tests)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class UserService extends Context.Service<UserService, {
@@ -3975,13 +4091,15 @@ export const mock: {
    *
    *   // This works - we provided an implementation
    *   const user = yield* userService.getUser("123")
-   *   console.log(user.name) // "Test User"
    *
    *   // This would throw - we didn't implement deleteUser
    *   // yield* userService.deleteUser("123") // UnimplementedError
+   *
+   *   return user.name
    * }).pipe(
    *   Effect.provide(testUserLayer)
    * )
+   * Effect.runSync(testProgram) // => "Test User"
    * ```
    *
    * @category testing
@@ -4055,22 +4173,17 @@ const ChannelTypeId: Channel.TypeId = "~effect/Channel"
  *
  * **Example** (Constraining layer success types)
  *
- * ```ts
- * import { Layer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Layer } from "effect"
  *
- * declare const FortyTwoLayer: Layer.Layer<42, never, never>
- * declare const StringLayer: Layer.Layer<string, never, never>
+ * const NumberService = Context.Service<number>("Number")
+ * const numberLayer = Layer.succeed(NumberService, 42)
  *
  * // Define a constraint that the success type must be a number
  * const satisfiesNumber = Layer.satisfiesSuccessType<number>()
  *
  * // This works - Layer<42, never, never> extends Layer<number, never, never>
- * const validLayer = satisfiesNumber(FortyTwoLayer)
- *
- * // This would cause a TypeScript compilation error:
- * // const invalidLayer = satisfiesNumber(StringLayer)
- * //                                     ^^^^^^^^^^^
- * // Type 'string' is not assignable to type 'number'
+ * const validLayer = satisfiesNumber(numberLayer)
  * ```
  *
  * @category utility types
@@ -4089,23 +4202,16 @@ export const satisfiesSuccessType =
  *
  * **Example** (Constraining layer error types)
  *
- * ```ts
- * import { Layer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Layer } from "effect"
  *
- * declare const ErrorLayer: Layer.Layer<never, Error, never>
- * declare const TypeErrorLayer: Layer.Layer<never, TypeError, never>
- * declare const StringLayer: Layer.Layer<never, string, never>
+ * const typeErrorLayer = Layer.effectDiscard(Effect.fail(new TypeError("boom")))
  *
  * // Define a constraint that the error type must be an Error
  * const satisfiesError = Layer.satisfiesErrorType<Error>()
  *
  * // This works - Layer<never, TypeError, never> extends Layer<never, Error, never>
- * const validLayer = satisfiesError(TypeErrorLayer)
- *
- * // This would cause a TypeScript compilation error:
- * // const invalidLayer = satisfiesError(StringLayer)
- * //                                     ^^^^^^^^^^^
- * // Type 'string' is not assignable to type 'Error'
+ * const validLayer = satisfiesError(typeErrorLayer)
  * ```
  *
  * @category utility types
@@ -4124,22 +4230,17 @@ export const satisfiesErrorType =
  *
  * **Example** (Constraining layer service requirements)
  *
- * ```ts
- * import { Layer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Effect, Layer } from "effect"
  *
- * declare const FortyTwoLayer: Layer.Layer<never, never, 42>
- * declare const StringLayer: Layer.Layer<never, never, string>
+ * const NumberService = Context.Service<number>("Number")
+ * const numberLayer = Layer.effectDiscard(Effect.asVoid(NumberService))
  *
  * // Define a constraint that the service requirements must be numbers
  * const satisfiesNumber = Layer.satisfiesServicesType<number>()
  *
  * // This works - Layer<never, never, 42> extends Layer<never, never, number>
- * const validLayer = satisfiesNumber(FortyTwoLayer)
- *
- * // This would cause a TypeScript compilation error:
- * // const invalidLayer = satisfiesNumber(StringLayer)
- * //                                     ^^^^^^^^^^^
- * // Type 'string' is not assignable to type 'number'
+ * const validLayer = satisfiesNumber(numberLayer)
  * ```
  *
  * @category utility types
@@ -4197,38 +4298,37 @@ export interface SpanOptions extends Tracer.SpanOptions {
  *
  * **Example** (Tracing layer construction with a span)
  *
- * ```ts
- * import { Console, Context, Effect, Layer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Effect, Layer } from "effect"
  * import type { Tracer } from "effect"
  *
  * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
+ * const logs: Array<string> = []
+ *
  * // Create a traced layer - all operations performed during construction of
  * // the `Database` service are part of the "database-init" span
  * const databaseLayer = Layer.effect(Database, Effect.gen(function*() {
  *   // These operations are traced under "database-init" span
- *   yield* Effect.log("Connecting to database")
- *   yield* Effect.sleep("100 millis")
- *   yield* Effect.log("Database connected")
+ *   logs.push("Connecting to database")
+ *   logs.push("Database connected")
  *
  *   const parentSpan = yield* Effect.currentParentSpan
- *   yield* Console.log((parentSpan as Tracer.Span).name) // "database-init"
+ *   logs.push((parentSpan as Tracer.Span).name)
  *
  *   return {
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *   }
- * })).pipe(Layer.provide(Layer.span("database-init")))
- *
- * // Can also use the `onEnd` callback to execute logic when the span ends
- * const tracedLayer = Layer.span("service-initialization", {
- *   attributes: { version: "1.0.0" },
+ * })).pipe(Layer.provide(Layer.span("database-init", {
  *   onEnd: (span, exit) =>
- *     Effect.sync(() => {
- *       console.log(`Span ${span.name} ended with:`, exit._tag)
- *     })
- * })
+ *     Effect.sync(() => logs.push(`Span ${span.name} ended with: ${exit._tag}`))
+ * })))
+ *
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, databaseLayer)) // => "Result: SELECT 1"
+ * logs // => ["Connecting to database", "Database connected", "database-init", "Span database-init ended with: Success"]
  * ```
  *
  * @category tracing
@@ -4261,10 +4361,11 @@ export const span = (
  *
  * **Example** (Referencing an existing parent span)
  *
- * ```ts
- * import { Console, Context, Effect, Layer, Tracer } from "effect"
+ * ```ts import.meta.vitest
+ * import { Context, Effect, Layer, Tracer } from "effect"
  *
  * class Database extends Context.Service<Database, {
+ *   readonly spanId: string
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -4272,12 +4373,10 @@ export const span = (
  * const databaseLayer = Layer.effect(
  *   Database,
  *   Effect.gen(function*() {
- *     yield* Effect.log("Initializing database")
- *
  *     const parentSpan = yield* Effect.currentParentSpan
- *     yield* Console.log(parentSpan.spanId) // "42"
  *
  *     return {
+ *       spanId: parentSpan.spanId,
  *       query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *     }
  *   })
@@ -4285,6 +4384,9 @@ export const span = (
  *   spanId: "42",
  *   traceId: "000"
  * }))))
+ * const program = Database.use((database) =>
+ *   Effect.map(database.query("SELECT 1"), (result) => ({ spanId: database.spanId, result })))
+ * Effect.runSync(Effect.provide(program, databaseLayer)) // => { spanId: "42", result: "Result: SELECT 1" }
  * ```
  *
  * @category tracing
@@ -4305,7 +4407,7 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  *
  * **Example** (Wrapping a layer with a span)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -4316,10 +4418,10 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
+ * const logs: Array<string> = []
+ *
  * // Create layers with tracing
  * const databaseLayer = Layer.effect(Database, Effect.gen(function*() {
- *   yield* Effect.log("Connecting to database")
- *   yield* Effect.sleep("100 millis")
  *   return {
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *   }
@@ -4328,16 +4430,14 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  * }))
  *
  * const loggerLayer = Layer.succeed(Logger, {
- *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(msg)))
  * }).pipe(Layer.withSpan("logger-initialization"))
  *
  * // Combine traced layers
  * const appLayer = Layer.mergeAll(databaseLayer, loggerLayer).pipe(
  *   Layer.withSpan("app-initialization", {
  *     onEnd: (span, exit) =>
- *       Effect.sync(() => {
- *         console.log(`Application initialization completed: ${exit._tag}`)
- *       })
+ *       Effect.sync(() => logs.push(`Application initialization completed: ${exit._tag}`))
  *   })
  * )
  *
@@ -4348,6 +4448,8 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  *   yield* logger.log("Application ready")
  *   return yield* database.query("SELECT * FROM users")
  * }).pipe(Effect.provide(appLayer))
+ * Effect.runSync(program) // => "Result: SELECT * FROM users"
+ * logs // => ["Application ready", "Application initialization completed: Success"]
  * ```
  *
  * @category tracing
@@ -4366,7 +4468,7 @@ export const withSpan: {
    *
    * **Example** (Wrapping a layer with a span)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -4377,10 +4479,10 @@ export const withSpan: {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Create layers with tracing
    * const databaseLayer = Layer.effect(Database, Effect.gen(function*() {
-   *   yield* Effect.log("Connecting to database")
-   *   yield* Effect.sleep("100 millis")
    *   return {
    *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
    *   }
@@ -4389,16 +4491,14 @@ export const withSpan: {
    * }))
    *
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(msg)))
    * }).pipe(Layer.withSpan("logger-initialization"))
    *
    * // Combine traced layers
    * const appLayer = Layer.mergeAll(databaseLayer, loggerLayer).pipe(
    *   Layer.withSpan("app-initialization", {
    *     onEnd: (span, exit) =>
-   *       Effect.sync(() => {
-   *         console.log(`Application initialization completed: ${exit._tag}`)
-   *       })
+   *       Effect.sync(() => logs.push(`Application initialization completed: ${exit._tag}`))
    *   })
    * )
    *
@@ -4409,6 +4509,8 @@ export const withSpan: {
    *   yield* logger.log("Application ready")
    *   return yield* database.query("SELECT * FROM users")
    * }).pipe(Effect.provide(appLayer))
+   * Effect.runSync(program) // => "Result: SELECT * FROM users"
+   * logs // => ["Application ready", "Application initialization completed: Success"]
    * ```
    *
    * @category tracing
@@ -4429,7 +4531,7 @@ export const withSpan: {
    *
    * **Example** (Wrapping a layer with a span)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -4440,10 +4542,10 @@ export const withSpan: {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
+   * const logs: Array<string> = []
+   *
    * // Create layers with tracing
    * const databaseLayer = Layer.effect(Database, Effect.gen(function*() {
-   *   yield* Effect.log("Connecting to database")
-   *   yield* Effect.sleep("100 millis")
    *   return {
    *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
    *   }
@@ -4452,16 +4554,14 @@ export const withSpan: {
    * }))
    *
    * const loggerLayer = Layer.succeed(Logger, {
-   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+   *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => logs.push(msg)))
    * }).pipe(Layer.withSpan("logger-initialization"))
    *
    * // Combine traced layers
    * const appLayer = Layer.mergeAll(databaseLayer, loggerLayer).pipe(
    *   Layer.withSpan("app-initialization", {
    *     onEnd: (span, exit) =>
-   *       Effect.sync(() => {
-   *         console.log(`Application initialization completed: ${exit._tag}`)
-   *       })
+   *       Effect.sync(() => logs.push(`Application initialization completed: ${exit._tag}`))
    *   })
    * )
    *
@@ -4472,6 +4572,8 @@ export const withSpan: {
    *   yield* logger.log("Application ready")
    *   return yield* database.query("SELECT * FROM users")
    * }).pipe(Effect.provide(appLayer))
+   * Effect.runSync(program) // => "Result: SELECT * FROM users"
+   * logs // => ["Application ready", "Application initialization completed: Success"]
    * ```
    *
    * @category tracing
@@ -4526,7 +4628,7 @@ export const withSpan: {
  *
  * **Example** (Attaching layers to an existing parent span)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer, Tracer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -4539,14 +4641,12 @@ export const withSpan: {
  *
  * // Create layers
  * const DatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
- *   yield* Effect.log("Connecting to database")
  *   return {
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  *   }
  * }))
  *
  * const CacheLayer = Layer.effect(Cache, Effect.gen(function*() {
- *   yield* Effect.log("Connecting to cache")
  *   return {
  *     get: Effect.fn("Cache.get")((key: string) => Effect.succeed(`Cache: ${key}`))
  *   }
@@ -4572,6 +4672,7 @@ export const withSpan: {
  *     return { dbResult, cacheResult }
  *   })
  * )
+ * Effect.runSync(Effect.scoped(program)) // => { dbResult: "DB: SELECT * FROM users", cacheResult: "Cache: user:123" }
  * ```
  *
  * @category tracing
@@ -4594,7 +4695,7 @@ export const withParentSpan: {
    *
    * **Example** (Attaching layers to an existing parent span)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer, Tracer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -4607,14 +4708,12 @@ export const withParentSpan: {
    *
    * // Create layers
    * const DatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
-   *   yield* Effect.log("Connecting to database")
    *   return {
    *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    *   }
    * }))
    *
    * const CacheLayer = Layer.effect(Cache, Effect.gen(function*() {
-   *   yield* Effect.log("Connecting to cache")
    *   return {
    *     get: Effect.fn("Cache.get")((key: string) => Effect.succeed(`Cache: ${key}`))
    *   }
@@ -4640,6 +4739,7 @@ export const withParentSpan: {
    *     return { dbResult, cacheResult }
    *   })
    * )
+   * Effect.runSync(Effect.scoped(program)) // => { dbResult: "DB: SELECT * FROM users", cacheResult: "Cache: user:123" }
    * ```
    *
    * @category tracing
@@ -4664,7 +4764,7 @@ export const withParentSpan: {
    *
    * **Example** (Attaching layers to an existing parent span)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Context, Effect, Layer, Tracer } from "effect"
    *
    * class Database extends Context.Service<Database, {
@@ -4677,14 +4777,12 @@ export const withParentSpan: {
    *
    * // Create layers
    * const DatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
-   *   yield* Effect.log("Connecting to database")
    *   return {
    *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
    *   }
    * }))
    *
    * const CacheLayer = Layer.effect(Cache, Effect.gen(function*() {
-   *   yield* Effect.log("Connecting to cache")
    *   return {
    *     get: Effect.fn("Cache.get")((key: string) => Effect.succeed(`Cache: ${key}`))
    *   }
@@ -4710,6 +4808,7 @@ export const withParentSpan: {
    *     return { dbResult, cacheResult }
    *   })
    * )
+   * Effect.runSync(Effect.scoped(program)) // => { dbResult: "DB: SELECT * FROM users", cacheResult: "Cache: user:123" }
    * ```
    *
    * @category tracing