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

package/dist/Layer.d.ts

@@ -171,7 +171,7 @@ declare 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, {
@@ -190,6 +190,9 @@ declare 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
@@ -205,7 +208,7 @@ export interface MemoMap {
  *
  * **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, {
@@ -217,11 +220,11 @@ export interface MemoMap {
  * })
  * 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 declare const isLayer: (u: unknown) => u is Layer<unknown, unknown, unknown>;
@@ -236,7 +239,7 @@ export declare const isLayer: (u: unknown) => u is Layer<unknown, unknown, unkno
  *
  * **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, {
@@ -250,6 +253,9 @@ export declare const isLayer: (u: unknown) => u is Layer<unknown, unknown, unkno
  *     })
  *   )
  * )
+ *
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, databaseLayer)) // => "result"
  * ```
  *
  * @category constructors
@@ -267,7 +273,7 @@ export declare const fromBuild: <ROut, E, RIn>(build: (memoMap: MemoMap, scope:
  *
  * **Example** (Memoizing layer construction)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -281,6 +287,9 @@ export declare const fromBuild: <ROut, E, RIn>(build: (memoMap: MemoMap, scope:
  *     })
  *   )
  * )
+ *
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, databaseLayer)) // => "result"
  * ```
  *
  * @category constructors
@@ -292,7 +301,7 @@ export declare const fromBuildMemo: <ROut, E, RIn>(build: (memoMap: MemoMap, sco
  *
  * **Example** (Creating a memo map unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -311,9 +320,12 @@ export declare const fromBuildMemo: <ROut, E, RIn>(build: (memoMap: MemoMap, sco
  *
  *   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 declare const makeMemoMapUnsafe: () => MemoMap;
@@ -331,7 +343,7 @@ export declare const makeMemoMapUnsafe: () => MemoMap;
  * @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 declare const forkMemoMapUnsafe: (parent: MemoMap) => MemoMap;
@@ -340,7 +352,7 @@ export declare const forkMemoMapUnsafe: (parent: MemoMap) => MemoMap;
  *
  * **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, {
@@ -359,9 +371,12 @@ export declare const forkMemoMapUnsafe: (parent: MemoMap) => 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 2.0.0
  */
 export declare const makeMemoMap: Effect<MemoMap>;
@@ -379,7 +394,7 @@ export declare const makeMemoMap: Effect<MemoMap>;
  * @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 declare const forkMemoMap: (parent: MemoMap) => Effect<MemoMap>;
@@ -399,7 +414,7 @@ declare const CurrentMemoMap_base: Context.ServiceClass<CurrentMemoMap, "effect/
  *
  * @see {@link MemoMap} the memoization map type wrapped by this service
  *
- * @category models
+ * @category services
  * @since 3.13.0
  */
 export declare class CurrentMemoMap extends CurrentMemoMap_base {
@@ -411,7 +426,7 @@ export declare class CurrentMemoMap extends CurrentMemoMap_base {
  *
  * **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, {
@@ -422,6 +437,8 @@ export declare class CurrentMemoMap extends CurrentMemoMap_base {
  *   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
@@ -435,7 +452,7 @@ export declare class CurrentMemoMap extends CurrentMemoMap_base {
  *
  *   // 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,
@@ -448,9 +465,13 @@ export declare class CurrentMemoMap extends CurrentMemoMap_base {
  *     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 declare const buildWithMemoMap: {
@@ -460,7 +481,7 @@ export declare 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, {
@@ -471,6 +492,8 @@ export declare 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
@@ -484,7 +507,7 @@ export declare 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,
@@ -497,9 +520,13 @@ export declare 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>;
@@ -509,7 +536,7 @@ export declare 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, {
@@ -520,6 +547,8 @@ export declare 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
@@ -533,7 +562,7 @@ export declare 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,
@@ -546,9 +575,13 @@ export declare 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>;
@@ -558,7 +591,7 @@ export declare 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, {
@@ -579,6 +612,8 @@ export declare const buildWithMemoMap: {
  *
  *   return yield* database.query("SELECT * FROM users")
  * })
+ *
+ * Effect.runSync(Effect.scoped(program)) // => "result"
  * ```
  *
  * @category destructors
@@ -600,22 +635,24 @@ export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<
  *
  * **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}`)) }
  *   }))
@@ -627,6 +664,9 @@ export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<
  *   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
@@ -648,22 +688,24 @@ export declare 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}`)) }
      *   }))
@@ -675,6 +717,9 @@ export declare 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
@@ -696,22 +741,24 @@ export declare 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}`)) }
      *   }))
@@ -723,6 +770,9 @@ export declare 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
@@ -741,7 +791,7 @@ export declare 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, {
@@ -751,6 +801,8 @@ export declare 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
@@ -770,7 +822,7 @@ export declare 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, {
@@ -780,6 +832,8 @@ export declare 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
@@ -799,7 +853,7 @@ export declare 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, {
@@ -809,6 +863,8 @@ export declare 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
@@ -834,7 +890,7 @@ export declare 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, {
@@ -845,15 +901,19 @@ export declare 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
@@ -872,14 +932,12 @@ export declare 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
@@ -903,7 +961,7 @@ export declare const empty: Layer<never>;
  *
  * **Example** (Lazily providing a service)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -913,6 +971,8 @@ export declare const empty: Layer<never>;
  * 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
@@ -936,7 +996,7 @@ export declare const sync: {
      *
      * **Example** (Lazily providing a service)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -946,6 +1006,8 @@ export declare 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
@@ -969,7 +1031,7 @@ export declare const sync: {
      *
      * **Example** (Lazily providing a service)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -979,6 +1041,8 @@ export declare 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
@@ -1003,7 +1067,7 @@ export declare const sync: {
  *
  * **Example** (Lazily providing a context)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1015,6 +1079,8 @@ export declare 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
@@ -1040,7 +1106,7 @@ export declare const syncContext: <A>(evaluate: LazyArg<Context.Context<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, {
@@ -1052,6 +1118,8 @@ export declare const syncContext: <A>(evaluate: LazyArg<Context.Context<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
@@ -1077,7 +1145,7 @@ export declare 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, {
@@ -1089,6 +1157,8 @@ export declare 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
@@ -1114,7 +1184,7 @@ export declare 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, {
@@ -1126,6 +1196,8 @@ export declare 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
@@ -1152,7 +1224,7 @@ export declare const effect: {
  *
  * **Example** (Creating a layer from an effectful context)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<
@@ -1165,6 +1237,8 @@ export declare 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 effect} for effectfully providing a single service
@@ -1184,14 +1258,17 @@ export declare const effectContext: <A, E, R>(effect: Effect<Context.Context<A>,
  *
  * **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
@@ -1210,8 +1287,8 @@ export declare const effectDiscard: <X, E, R>(effect: Effect<X, E, R>) => Layer<
  *
  * **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") {}
  *
@@ -1222,6 +1299,7 @@ export declare const effectDiscard: <X, E, R>(effect: Effect<X, E, R>) => Layer<
  *     ? 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
@@ -1243,7 +1321,7 @@ export declare const suspend: <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>) => La
  *
  * **Example** (Unwrapping an effectful layer)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1255,6 +1333,8 @@ export declare const suspend: <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>) => La
  * )
  *
  * const unwrappedLayer = Layer.unwrap(layerEffect)
+ * const program = Database.use((database) => database.query("SELECT 1"))
+ * Effect.runSync(Effect.provide(program, unwrappedLayer)) // => "result"
  * ```
  *
  * @category converting
@@ -1279,7 +1359,7 @@ export declare const unwrap: <A, E1, R1, E, R>(self: Effect<Layer<A, E1, R1>, E,
  *
  * **Example** (Merging independent layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1293,11 +1373,15 @@ export declare const unwrap: <A, E1, R1, E, R>(self: Effect<Layer<A, E1, R1>, E,
  * 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
@@ -1323,7 +1407,7 @@ export declare const mergeAll: <Layers extends [Layer<never, any, any>, ...Array
  *
  * **Example** (Merging two layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1338,10 +1422,12 @@ export declare const mergeAll: <Layers extends [Layer<never, any, any>, ...Array
  *   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
@@ -1367,7 +1453,7 @@ export declare const merge: {
      *
      * **Example** (Merging two layers)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1382,10 +1468,12 @@ export declare 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
@@ -1411,7 +1499,7 @@ export declare const merge: {
      *
      * **Example** (Merging two layers)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1426,10 +1514,12 @@ export declare 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
@@ -1455,7 +1545,7 @@ export declare const merge: {
      *
      * **Example** (Merging two layers)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1470,10 +1560,12 @@ export declare 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
@@ -1499,7 +1591,7 @@ export declare const merge: {
      *
      * **Example** (Merging two layers)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1514,10 +1606,12 @@ export declare 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
@@ -1542,7 +1636,7 @@ export declare const merge: {
  *
  * **Example** (Providing layer dependencies)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -1565,8 +1659,9 @@ export declare const merge: {
  *   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
@@ -1597,6 +1692,8 @@ export declare const merge: {
  * }).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
@@ -1620,7 +1717,7 @@ export declare const provide: {
      *
      * **Example** (Providing layer dependencies)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1643,8 +1740,9 @@ export declare 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
@@ -1675,6 +1773,8 @@ export declare 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
@@ -1698,7 +1798,7 @@ export declare const provide: {
      *
      * **Example** (Providing layer dependencies)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1721,8 +1821,9 @@ export declare 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
@@ -1753,6 +1854,8 @@ export declare 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
@@ -1776,7 +1879,7 @@ export declare const provide: {
      *
      * **Example** (Providing layer dependencies)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1799,8 +1902,9 @@ export declare 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
@@ -1831,6 +1935,8 @@ export declare 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
@@ -1854,7 +1960,7 @@ export declare const provide: {
      *
      * **Example** (Providing layer dependencies)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class Database extends Context.Service<Database, {
@@ -1877,8 +1983,9 @@ export declare 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
@@ -1909,6 +2016,8 @@ export declare 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
@@ -1933,7 +2042,7 @@ export declare 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, {
@@ -1956,8 +2065,9 @@ export declare 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
@@ -1994,6 +2104,8 @@ export declare 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
@@ -2017,7 +2129,7 @@ export declare 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, {
@@ -2040,8 +2152,9 @@ export declare 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
@@ -2078,6 +2191,8 @@ export declare 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
@@ -2101,7 +2216,7 @@ export declare 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, {
@@ -2124,8 +2239,9 @@ export declare 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
@@ -2162,6 +2278,8 @@ export declare 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
@@ -2185,7 +2303,7 @@ export declare 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, {
@@ -2208,8 +2326,9 @@ export declare 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
@@ -2246,6 +2365,8 @@ export declare 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
@@ -2269,7 +2390,7 @@ export declare 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, {
@@ -2292,8 +2413,9 @@ export declare 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
@@ -2330,6 +2452,8 @@ export declare 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
@@ -2344,7 +2468,7 @@ export declare 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, {
@@ -2360,6 +2484,8 @@ export declare 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",
@@ -2383,8 +2509,8 @@ export declare 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))
  *       )
  *     })
  *
@@ -2405,6 +2531,8 @@ export declare const provideMerge: {
  * }).pipe(
  *   Effect.provide(dynamicServiceLayer)
  * )
+ * Effect.runSync(program) // => "Querying postgres://localhost:5432/mydb: SELECT * FROM users"
+ * logs // => ["[DEBUG] Starting database query"]
  * ```
  *
  * @category sequencing
@@ -2416,7 +2544,7 @@ export declare 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, {
@@ -2432,6 +2560,8 @@ export declare 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",
@@ -2455,8 +2585,8 @@ export declare 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))
      *       )
      *     })
      *
@@ -2477,6 +2607,8 @@ export declare const flatMap: {
      * }).pipe(
      *   Effect.provide(dynamicServiceLayer)
      * )
+     * Effect.runSync(program) // => "Querying postgres://localhost:5432/mydb: SELECT * FROM users"
+     * logs // => ["[DEBUG] Starting database query"]
      * ```
      *
      * @category sequencing
@@ -2488,7 +2620,7 @@ export declare 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, {
@@ -2504,6 +2636,8 @@ export declare 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",
@@ -2527,8 +2661,8 @@ export declare 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))
      *       )
      *     })
      *
@@ -2549,6 +2683,8 @@ export declare const flatMap: {
      * }).pipe(
      *   Effect.provide(dynamicServiceLayer)
      * )
+     * Effect.runSync(program) // => "Querying postgres://localhost:5432/mydb: SELECT * FROM users"
+     * logs // => ["[DEBUG] Starting database query"]
      * ```
      *
      * @category sequencing
@@ -2762,8 +2898,8 @@ export declare 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
@@ -2774,10 +2910,11 @@ export declare 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)
@@ -2790,8 +2927,7 @@ export declare 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
@@ -2827,7 +2963,7 @@ catch_ as catch };
  *
  * **Example** (Recovering from tagged layer errors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Data, Effect, Layer } from "effect"
  *
  * class ConfigError extends Data.TaggedError("ConfigError") {}
@@ -2843,6 +2979,8 @@ catch_ as catch };
  * 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
@@ -2860,7 +2998,7 @@ export declare 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") {}
@@ -2876,6 +3014,8 @@ export declare 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
@@ -2893,7 +3033,7 @@ export declare 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") {}
@@ -2909,6 +3049,8 @@ export declare 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
@@ -2935,7 +3077,7 @@ export declare 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")<{
@@ -2960,14 +3102,12 @@ export declare 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
@@ -2993,7 +3133,7 @@ export declare 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")<{
@@ -3018,14 +3158,12 @@ export declare 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
@@ -3051,7 +3189,7 @@ export declare 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")<{
@@ -3076,14 +3214,12 @@ export declare 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
@@ -3166,7 +3302,7 @@ export declare 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, {
@@ -3191,10 +3327,10 @@ export declare 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*() {
@@ -3202,7 +3338,6 @@ export declare 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 }
  *   }))
  *
@@ -3211,7 +3346,7 @@ export declare 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(
@@ -3219,15 +3354,12 @@ export declare 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
@@ -3249,50 +3381,30 @@ export declare 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
@@ -3340,7 +3452,7 @@ type AnyEffectOrStream = Effect<any, any, any> | Stream.Stream<any, any, any> |
  *
  * **Example** (Mocking services for tests)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class UserService extends Context.Service<UserService, {
@@ -3368,13 +3480,15 @@ type AnyEffectOrStream = Effect<any, any, any> | Stream.Stream<any, any, any> |
  *
  *   // 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
@@ -3396,7 +3510,7 @@ export declare const mock: {
      *
      * **Example** (Mocking services for tests)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class UserService extends Context.Service<UserService, {
@@ -3424,13 +3538,15 @@ export declare 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
@@ -3452,7 +3568,7 @@ export declare const mock: {
      *
      * **Example** (Mocking services for tests)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Context, Effect, Layer } from "effect"
      *
      * class UserService extends Context.Service<UserService, {
@@ -3480,13 +3596,15 @@ export declare 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
@@ -3504,22 +3622,17 @@ export declare const mock: {
  *
  * **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
@@ -3536,23 +3649,16 @@ export declare const satisfiesSuccessType: <ROut>() => <ROut2 extends ROut, E, R
  *
  * **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
@@ -3569,22 +3675,17 @@ export declare const satisfiesErrorType: <E>() => <ROut, E2 extends E, RIn>(laye
  *
  * **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
@@ -3633,38 +3734,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
@@ -3682,10 +3782,11 @@ export declare const span: (name: string, options?: SpanOptions) => Layer<Tracer
  *
  * **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") {}
  *
@@ -3693,12 +3794,10 @@ export declare const span: (name: string, options?: SpanOptions) => Layer<Tracer
  * 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}`))
  *     }
  *   })
@@ -3706,6 +3805,9 @@ export declare const span: (name: string, options?: SpanOptions) => Layer<Tracer
  *   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
@@ -3724,7 +3826,7 @@ export declare const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSp
  *
  * **Example** (Wrapping a layer with a span)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Context, Effect, Layer } from "effect"
  *
  * class Database extends Context.Service<Database, {
@@ -3735,10 +3837,10 @@ export declare const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSp
  *   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}`))
  *   }
@@ -3747,16 +3849,14 @@ export declare const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSp
  * }))
  *
  * 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}`))
  *   })
  * )
  *
@@ -3767,6 +3867,8 @@ export declare const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSp
  *   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
@@ -3785,7 +3887,7 @@ export declare 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, {
@@ -3796,10 +3898,10 @@ export declare 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}`))
      *   }
@@ -3808,16 +3910,14 @@ export declare 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}`))
      *   })
      * )
      *
@@ -3828,6 +3928,8 @@ export declare 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
@@ -3846,7 +3948,7 @@ export declare 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, {
@@ -3857,10 +3959,10 @@ export declare 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}`))
      *   }
@@ -3869,16 +3971,14 @@ export declare 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}`))
      *   })
      * )
      *
@@ -3889,6 +3989,8 @@ export declare 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
@@ -3912,7 +4014,7 @@ export declare 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, {
@@ -3925,14 +4027,12 @@ export declare 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}`))
  *   }
@@ -3958,6 +4058,7 @@ export declare const withSpan: {
  *     return { dbResult, cacheResult }
  *   })
  * )
+ * Effect.runSync(Effect.scoped(program)) // => { dbResult: "DB: SELECT * FROM users", cacheResult: "Cache: user:123" }
  * ```
  *
  * @category tracing
@@ -3980,7 +4081,7 @@ export declare 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, {
@@ -3993,14 +4094,12 @@ export declare 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}`))
      *   }
@@ -4026,6 +4125,7 @@ export declare const withParentSpan: {
      *     return { dbResult, cacheResult }
      *   })
      * )
+     * Effect.runSync(Effect.scoped(program)) // => { dbResult: "DB: SELECT * FROM users", cacheResult: "Cache: user:123" }
      * ```
      *
      * @category tracing
@@ -4048,7 +4148,7 @@ export declare 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, {
@@ -4061,14 +4161,12 @@ export declare 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}`))
      *   }
@@ -4094,6 +4192,7 @@ export declare const withParentSpan: {
      *     return { dbResult, cacheResult }
      *   })
      * )
+     * Effect.runSync(Effect.scoped(program)) // => { dbResult: "DB: SELECT * FROM users", cacheResult: "Cache: user:123" }
      * ```
      *
      * @category tracing