effect 4.0.0-beta.102 → 4.0.0-beta.104

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
@@ -438,11 +447,13 @@ class MemoMapImpl implements MemoMap {
     scope: Scope.Scope,
     build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>
   ): Effect<Context.Context<ROut>, E, RIn> {
-    const existing = this.get(layer, scope)
-    if (existing) {
-      return existing
-    }
-    return memoMapBuild(this, layer, scope, build)
+    return internalEffect.suspend(() => {
+      const existing = this.get(layer, scope)
+      if (existing) {
+        return existing
+      }
+      return memoMapBuild(this, layer, scope, build)
+    })
   }
 }
 
@@ -451,7 +462,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 +481,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 +505,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 +515,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 +534,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 +558,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 +578,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 +594,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 +605,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 +620,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 +633,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 +649,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 +660,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 +675,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 +688,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 +704,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 +715,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 +730,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 +743,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 +769,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 +790,8 @@ export const buildWithMemoMap: {
  *
  *   return yield* database.query("SELECT * FROM users")
  * })
+ *
+ * Effect.runSync(Effect.scoped(program)) // => "result"
  * ```
  *
  * @category destructors
@@ -786,22 +823,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 +852,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 +876,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 +905,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 +929,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 +958,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 +990,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 +1000,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 +1021,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 +1031,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 +1052,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 +1062,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 +1095,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 +1106,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 +1139,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 +1169,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 +1179,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 +1204,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 +1214,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 +1239,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 +1249,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 +1281,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 +1293,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 +1322,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 +1334,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 +1361,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 +1373,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 +1402,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 +1414,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 +1454,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 +1467,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 +1491,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 +1522,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 +1534,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 +1558,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 +1570,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 +1619,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 +1633,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 +1674,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 +1689,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 +1720,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 +1735,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 +1766,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 +1781,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 +1819,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 +1834,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 +1865,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 +1880,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 +1940,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 +1963,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 +1996,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 +2021,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 +2044,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 +2077,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 +2102,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 +2125,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 +2158,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 +2190,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 +2213,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 +2246,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 +2271,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 +2294,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 +2327,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 +2362,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 +2385,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 +2424,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 +2449,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 +2472,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 +2511,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 +2536,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 +2559,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 +2598,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 +2630,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 +2653,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 +2692,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 +2717,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 +2740,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 +2779,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 +2809,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 +2825,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 +2850,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 +2872,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 +2885,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 +2901,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 +2926,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 +2948,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 +2961,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 +2977,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 +3002,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 +3024,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 +3289,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 +3301,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 +3318,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 +3373,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 +3389,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 +3408,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 +3424,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 +3454,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 +3470,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 +3534,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 +3559,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 +3590,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 +3615,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 +3646,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 +3671,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 +3784,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 +3809,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 +3820,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 +3828,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 +3836,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 +3865,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 +3949,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 +3977,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 +4007,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 +4035,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 +4065,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 +4093,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 +4175,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 +4204,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 +4232,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 +4300,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 +4363,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 +4375,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 +4386,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 +4409,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 +4420,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 +4432,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 +4450,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 +4470,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 +4481,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 +4493,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 +4511,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 +4533,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 +4544,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 +4556,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 +4574,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 +4630,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 +4643,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 +4674,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 +4697,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 +4710,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 +4741,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 +4766,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 +4779,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 +4810,7 @@ export const withParentSpan: {
    *     return { dbResult, cacheResult }
    *   })
    * )
+   * Effect.runSync(Effect.scoped(program)) // => { dbResult: "DB: SELECT * FROM users", cacheResult: "Cache: user:123" }
    * ```
    *
    * @category tracing