effect 4.0.0-beta.99 → 4.0.0-rc.108

package/src/Logger.ts

@@ -20,6 +20,7 @@ import * as Formatter from "./Formatter.ts"
 import { dual } from "./Function.ts"
 import { isEffect, withFiber } from "./internal/core.ts"
 import * as effect from "./internal/effect.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Layer from "./Layer.ts"
 import type * as LogLevel from "./LogLevel.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -41,23 +42,20 @@ const TypeId = "~effect/Logger"
  *
  * **Example** (Creating custom loggers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
  *
- * // Create a custom logger that accepts unknown messages and returns void
+ * const messages: Array<string> = []
  * const stringLogger = Logger.make<unknown, void>((options) => {
- *   console.log(`[${options.logLevel}] ${options.message}`)
+ *   messages.push(`[${options.logLevel}] ${options.message}`)
  * })
  *
- * // Create a logger that accepts any message type and returns a formatted string
- * const formattedLogger = Logger.make<unknown, string>((options) =>
- *   `${options.date.toISOString()} [${options.logLevel}] ${options.message}`
- * )
- *
- * // Use the logger in an Effect program
  * const program = Effect.log("Hello World").pipe(
  *   Effect.provide(Logger.layer([stringLogger]))
  * )
+ *
+ * Effect.runSync(program)
+ * messages // => ["[Info] Hello World"]
  * ```
  *
  * @category models
@@ -77,24 +75,24 @@ export interface Logger<in Message, out Output> extends Pipeable {
  *
  * **Example** (Accessing logger options)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
  *
- * // Options interface provides all logging context
+ * const outputs: Array<unknown> = []
  * const detailedLogger = Logger.make((options) => {
- *   const output = {
+ *   outputs.push({
  *     message: options.message,
  *     level: options.logLevel,
- *     timestamp: options.date.toISOString(),
- *     fiberId: options.fiber.id,
- *     hasCause: options.cause !== undefined
- *   }
- *   console.log(JSON.stringify(output))
+ *     hasCause: options.cause.reasons.length > 0
+ *   })
  * })
  *
  * const program = Effect.log("Processing request").pipe(
  *   Effect.provide(Logger.layer([detailedLogger]))
  * )
+ *
+ * Effect.runSync(program)
+ * outputs // => [{ message: ["Processing request"], level: "Info", hasCause: false }]
  * ```
  *
  * @category options
@@ -113,16 +111,14 @@ export interface Options<out Message> {
  *
  * **Example** (Checking logger values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Logger } from "effect"
  *
- * const myLogger = Logger.make((options) => {
- *   console.log(options.message)
- * })
+ * const myLogger = Logger.make(() => undefined)
  *
- * console.log(Logger.isLogger(myLogger)) // true
- * console.log(Logger.isLogger("not a logger")) // false
- * console.log(Logger.isLogger({ log: () => {} })) // false
+ * Logger.isLogger(myLogger) // => true
+ * Logger.isLogger("not a logger") // => false
+ * Logger.isLogger({ log: () => {} }) // => false
  * ```
  *
  * @category guards
@@ -141,26 +137,26 @@ export const isLogger = (u: unknown): u is Logger<unknown, unknown> => Predicate
  *
  * **Example** (Accessing current loggers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
  *
- * // Access current loggers from fiber context
+ * const messages: Array<unknown> = []
+ * const customLogger = Logger.make((options) => {
+ *   messages.push(options.message)
+ * })
  * const program = Effect.gen(function*() {
  *   const currentLoggers = yield* Effect.service(Logger.CurrentLoggers)
- *   console.log(`Number of active loggers: ${currentLoggers.size}`)
- *
- *   // Add a custom logger to the set
- *   const customLogger = Logger.make((options) => {
- *     console.log(`Custom: ${options.message}`)
- *   })
- *
  *   yield* Effect.log("Hello from custom logger").pipe(
  *     Effect.provide(Logger.layer([customLogger]))
  *   )
+ *   return currentLoggers.has(Logger.defaultLogger)
  * })
+ *
+ * Effect.runSync(program) // => true
+ * messages // => [["Hello from custom logger"]]
  * ```
  *
- * @category references
+ * @category services
  * @since 4.0.0
  */
 export const CurrentLoggers: Context.Reference<ReadonlySet<Logger<unknown, any>>> = effect.CurrentLoggers
@@ -183,7 +179,7 @@ export const CurrentLoggers: Context.Reference<ReadonlySet<Logger<unknown, any>>
  * @see {@link consolePretty} for the TTY-mode pretty console logger affected by this reference
  * @see {@link withConsoleError} for routing a specific formatter logger to `console.error`
  *
- * @category references
+ * @category services
  * @since 4.0.0
  */
 export const LogToStderr: Context.Reference<boolean> = effect.LogToStderr
@@ -198,27 +194,24 @@ export const LogToStderr: Context.Reference<boolean> = effect.LogToStderr
  *
  * **Example** (Transforming logger output)
  *
- * ```ts
- * import { Logger } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Logger } from "effect"
  *
- * // Create a logger that outputs objects
+ * const outputs: Array<unknown> = []
  * const structuredLogger = Logger.make((options) => ({
- *   level: options.logLevel,
- *   message: options.message,
- *   timestamp: options.date.toISOString()
+ *   message: options.message
  * }))
  *
- * // Transform the output to JSON strings
- * const jsonStringLogger = Logger.map(
- *   structuredLogger,
- *   (output) => JSON.stringify(output)
- * )
- *
  * // Transform to uppercase messages
  * const uppercaseLogger = Logger.map(
  *   structuredLogger,
  *   (output) => ({ ...output, message: String(output.message).toUpperCase() })
  * )
+ *
+ * const collector = Logger.make((options) => outputs.push(uppercaseLogger.log(options)))
+ * const program = Effect.log("hello").pipe(Effect.provide(Logger.layer([collector])))
+ * Effect.runSync(program)
+ * outputs // => [{ message: "HELLO" }]
  * ```
  *
  * @category mapping
@@ -235,27 +228,24 @@ export const map = dual<
    *
    * **Example** (Transforming logger output)
    *
-   * ```ts
-   * import { Logger } from "effect"
+   * ```ts import.meta.vitest
+   * import { Effect, Logger } from "effect"
    *
-   * // Create a logger that outputs objects
+   * const outputs: Array<unknown> = []
    * const structuredLogger = Logger.make((options) => ({
-   *   level: options.logLevel,
-   *   message: options.message,
-   *   timestamp: options.date.toISOString()
+   *   message: options.message
    * }))
    *
-   * // Transform the output to JSON strings
-   * const jsonStringLogger = Logger.map(
-   *   structuredLogger,
-   *   (output) => JSON.stringify(output)
-   * )
-   *
    * // Transform to uppercase messages
    * const uppercaseLogger = Logger.map(
    *   structuredLogger,
    *   (output) => ({ ...output, message: String(output.message).toUpperCase() })
    * )
+   *
+   * const collector = Logger.make((options) => outputs.push(uppercaseLogger.log(options)))
+   * const program = Effect.log("hello").pipe(Effect.provide(Logger.layer([collector])))
+   * Effect.runSync(program)
+   * outputs // => [{ message: "HELLO" }]
    * ```
    *
    * @category mapping
@@ -274,27 +264,24 @@ export const map = dual<
    *
    * **Example** (Transforming logger output)
    *
-   * ```ts
-   * import { Logger } from "effect"
+   * ```ts import.meta.vitest
+   * import { Effect, Logger } from "effect"
    *
-   * // Create a logger that outputs objects
+   * const outputs: Array<unknown> = []
    * const structuredLogger = Logger.make((options) => ({
-   *   level: options.logLevel,
-   *   message: options.message,
-   *   timestamp: options.date.toISOString()
+   *   message: options.message
    * }))
    *
-   * // Transform the output to JSON strings
-   * const jsonStringLogger = Logger.map(
-   *   structuredLogger,
-   *   (output) => JSON.stringify(output)
-   * )
-   *
    * // Transform to uppercase messages
    * const uppercaseLogger = Logger.map(
    *   structuredLogger,
    *   (output) => ({ ...output, message: String(output.message).toUpperCase() })
    * )
+   *
+   * const collector = Logger.make((options) => outputs.push(uppercaseLogger.log(options)))
+   * const program = Effect.log("hello").pipe(Effect.provide(Logger.layer([collector])))
+   * Effect.runSync(program)
+   * outputs // => [{ message: "HELLO" }]
    * ```
    *
    * @category mapping
@@ -314,20 +301,23 @@ export const map = dual<
  *
  * **Example** (Writing logger output with console.log)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
+ * import { TestConsole } from "effect/testing"
  *
  * // Create a custom formatter
  * const customFormatter = Logger.make((options) =>
- *   `[${options.date.toISOString()}] ${options.logLevel}: ${options.message}`
+ *   `${options.logLevel}: ${options.message}`
  * )
  *
- * // Route to console
  * const consoleLogger = Logger.withConsoleLog(customFormatter)
  *
- * const program = Effect.log("Hello World").pipe(
- *   Effect.provide(Logger.layer([consoleLogger]))
- * )
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("Hello World").pipe(Effect.provide(Logger.layer([consoleLogger])))
+ *   return yield* TestConsole.logLines
+ * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program) // => ["Info: Hello World"]
  * ```
  *
  * @category logging
@@ -351,20 +341,23 @@ export const withConsoleLog = <Message, Output>(
  *
  * **Example** (Writing logger output with console.error)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
+ * import { TestConsole } from "effect/testing"
  *
  * // Create an error-specific formatter
  * const errorFormatter = Logger.make((options) =>
- *   `ERROR [${options.date.toISOString()}]: ${options.message}`
+ *   `ERROR: ${options.message}`
  * )
  *
- * // Route to console.error
  * const errorLogger = Logger.withConsoleError(errorFormatter)
  *
- * const program = Effect.logError("Database connection failed").pipe(
- *   Effect.provide(Logger.layer([errorLogger]))
- * )
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.logError("Database connection failed").pipe(Effect.provide(Logger.layer([errorLogger])))
+ *   return yield* TestConsole.errorLines
+ * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program) // => ["ERROR: Database connection failed"]
  * ```
  *
  * @category logging
@@ -392,9 +385,15 @@ export const withConsoleError = <Message, Output>(
  *
  * **Example** (Writing logs with level-based console methods)
  *
- * ```ts
- * import { Effect, Logger } from "effect"
+ * ```ts import.meta.vitest
+ * import { Console, Effect, Logger } from "effect"
  *
+ * const messages: Array<ReadonlyArray<unknown>> = []
+ * const testConsole: Console.Console = Object.assign(Object.create(console), {
+ *   info: (message: unknown) => messages.push(["info", message]),
+ *   warn: (message: unknown) => messages.push(["warn", message]),
+ *   error: (message: unknown) => messages.push(["error", message])
+ * })
  * const formatter = Logger.make((options) =>
  *   `[${options.logLevel}] ${options.message}`
  * )
@@ -405,10 +404,14 @@ export const withConsoleError = <Message, Output>(
  *   yield* Effect.logInfo("Info message") // -> console.info
  *   yield* Effect.logWarning("Warning") // -> console.warn
  *   yield* Effect.logError("Error occurred") // -> console.error
- *   yield* Effect.logDebug("Debug info") // -> console.debug
- * }).pipe(
- *   Effect.provide(Logger.layer([leveledLogger]))
- * )
+ * }).pipe(Effect.provide(Logger.layer([leveledLogger])))
+ * Effect.runSync(Effect.provideService(program, Console.Console, testConsole))
+ * const expected = [
+ *   ["info", "[Info] Info message"],
+ *   ["warn", "[Warn] Warning"],
+ *   ["error", "[Error] Error occurred"]
+ * ]
+ * messages // => expected
  * ```
  *
  * @category logging
@@ -471,7 +474,7 @@ const format = (
   const append = (label: string, value: string): string => " " + format(label, value)
 
   let out = format("timestamp", date.toISOString())
-  out += append("level", logLevel)
+  out += append("level", logLevel.toUpperCase())
   out += append("fiber", formatFiberId(fiber.id))
 
   const messages = Array.ensure(message)
@@ -507,34 +510,20 @@ const format = (
  *
  * **Example** (Creating loggers from functions)
  *
- * ```ts
- * import { Effect, Logger, References } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Logger } from "effect"
  *
- * // Simple text logger
+ * const outputs: Array<string> = []
  * const textLogger = Logger.make((options) =>
- *   `${options.date.toISOString()} [${options.logLevel}] ${options.message}`
+ *   `${options.logLevel}: ${options.message}`
  * )
- *
- * // Structured object logger
- * const objectLogger = Logger.make((options) => ({
- *   timestamp: options.date.toISOString(),
- *   level: options.logLevel,
- *   message: options.message,
- *   fiberId: options.fiber.id,
- *   annotations: options.fiber.getRef(References.CurrentLogAnnotations)
- * }))
- *
- * // Custom filtering logger
- * const filteredLogger = Logger.make((options) => {
- *   if (options.logLevel === "Debug") {
- *     return // Skip debug messages
- *   }
- *   return `${options.logLevel}: ${options.message}`
- * })
+ * const collector = Logger.make((options) => outputs.push(textLogger.log(options)))
  *
  * const program = Effect.log("Hello World").pipe(
- *   Effect.provide(Logger.layer([textLogger]))
+ *   Effect.provide(Logger.layer([collector]))
  * )
+ * Effect.runSync(program)
+ * outputs // => ["Info: Hello World"]
  * ```
  *
  * @category constructors
@@ -549,25 +538,10 @@ export const make: <Message, Output>(
  *
  * **Example** (Referencing the default logger)
  *
- * ```ts
- * import { Effect, Logger } from "effect"
- *
- * // Use the default logger (automatically used by Effect runtime)
- * const program = Effect.gen(function*() {
- *   yield* Effect.log("This uses the default logger")
- *   yield* Effect.logInfo("Info message")
- *   yield* Effect.logError("Error message")
- * })
- *
- * // Explicitly use the default logger
- * const withDefaultLogger = Effect.log("Explicit default").pipe(
- *   Effect.provide(Logger.layer([Logger.defaultLogger]))
- * )
+ * ```ts import.meta.vitest
+ * import { Logger } from "effect"
  *
- * // Compare with custom logger
- * const customLogger = Logger.make((options) => {
- *   console.log(`CUSTOM: ${options.message}`)
- * })
+ * Logger.isLogger(Logger.defaultLogger) // => true
  * ```
  *
  * @category constructors
@@ -585,24 +559,24 @@ export const defaultLogger: Logger<unknown, void> = effect.defaultLogger
  *
  * **Example** (Formatting logs as simple strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
+ * import { TestConsole } from "effect/testing"
  *
  * // Use the simple format logger
- * const simpleLoggerProgram = Effect.log("Hello Simple Format").pipe(
- *   Effect.provide(Logger.layer([Logger.formatSimple]))
+ * const stableSimple = Logger.map(Logger.formatSimple, (output) =>
+ *   output
+ *     .replace(/timestamp=\S+ /, "")
+ *     .replace(/fiber=#\d+ /, "")
  * )
- *
- * // Combine with console output
- * const consoleSimpleLogger = Logger.withConsoleLog(Logger.formatSimple)
- *
  * const program = Effect.gen(function*() {
- *   yield* Effect.log("Application started")
- *   yield* Effect.logInfo("Processing data")
- *   yield* Effect.logWarning("Memory usage high")
- * }).pipe(
- *   Effect.provide(Logger.layer([consoleSimpleLogger]))
- * )
+ *   yield* Effect.log("Application started").pipe(
+ *     Effect.provide(Logger.layer([Logger.withConsoleLog(stableSimple)]))
+ *   )
+ *   return yield* TestConsole.logLines
+ * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program) // => ["level=INFO message=\"Application started\""]
  * ```
  *
  * @category constructors
@@ -621,27 +595,23 @@ export const formatSimple = effect.loggerMake(format(escapeDoubleQuotes))
  *
  * **Example** (Formatting logs as logfmt)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
+ * import { TestConsole } from "effect/testing"
  *
- * // Use the logfmt format logger
- * const logfmtLoggerProgram = Effect.log("Hello LogFmt Format").pipe(
- *   Effect.provide(Logger.layer([Logger.formatLogFmt]))
- * )
- *
- * // Perfect for structured logging systems
- * const structuredProgram = Effect.gen(function*() {
- *   yield* Effect.log("User login", { userId: 123, method: "OAuth" })
- *   yield* Effect.logInfo("Request processed", {
- *     duration: 45,
- *     status: "success"
- *   })
- * }).pipe(
- *   Effect.provide(Logger.layer([Logger.withConsoleLog(Logger.formatLogFmt)]))
+ * const stableLogFmt = Logger.map(Logger.formatLogFmt, (output) =>
+ *   output
+ *     .replace(/timestamp=\S+ /, "")
+ *     .replace(/fiber=#\d+ /, "")
  * )
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("User login").pipe(
+ *     Effect.provide(Logger.layer([Logger.withConsoleLog(stableLogFmt)]))
+ *   )
+ *   return yield* TestConsole.logLines
+ * }).pipe(Effect.provide(TestConsole.layer))
  *
- * // Good for log aggregation systems like Splunk, ELK
- * const productionLogger = Logger.formatLogFmt
+ * await Effect.runPromise(program) // => ["level=INFO message=\"User login\""]
  * ```
  *
  * @category constructors
@@ -661,30 +631,22 @@ export const formatLogFmt = effect.loggerMake(format(JSON.stringify, 0))
  *
  * **Example** (Formatting logs as structured objects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
+ * import { TestConsole } from "effect/testing"
  *
- * // Use the structured format logger
- * const structuredLoggerProgram = Effect.log("Hello Structured Format").pipe(
- *   Effect.provide(Logger.layer([Logger.formatStructured]))
- * )
- *
- * // Perfect for JSON processing and analytics
- * const analyticsProgram = Effect.gen(function*() {
- *   yield* Effect.log("User action", { action: "click", element: "button" })
- *   yield* Effect.logInfo("API call", { endpoint: "/users", duration: 150 })
- * }).pipe(
- *   Effect.annotateLogs("sessionId", "abc123"),
- *   Effect.withLogSpan("request"),
- *   Effect.provide(Logger.layer([Logger.formatStructured]))
- * )
+ * const stableStructured = Logger.map(Logger.formatStructured, (output) => ({
+ *   message: output.message,
+ *   level: output.level
+ * }))
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("User action").pipe(
+ *     Effect.provide(Logger.layer([Logger.withConsoleLog(stableStructured)]))
+ *   )
+ *   return yield* TestConsole.logLines
+ * }).pipe(Effect.provide(TestConsole.layer))
  *
- * // Process structured output
- * const processingLogger = Logger.map(Logger.formatStructured, (output) => {
- *   // Process the structured object
- *   const enhanced = { ...output, processed: true }
- *   return enhanced
- * })
+ * await Effect.runPromise(program) // => [{ message: "User action", level: "INFO" }]
  * ```
  *
  * @category constructors
@@ -704,13 +666,13 @@ export const formatStructured: Logger<unknown, {
 
   const annotations = fiber.getRef(CurrentLogAnnotations)
   for (const [key, value] of Object.entries(annotations)) {
-    annotationsObj[key] = effect.structuredMessage(value)
+    InternalRecord.assignProperty(annotationsObj, key, effect.structuredMessage(value))
   }
 
   const now = date.getTime()
   const spans = fiber.getRef(CurrentLogSpans)
   for (const [label, timestamp] of spans) {
-    spansObj[label] = now - timestamp
+    InternalRecord.assignProperty(spansObj, label, now - timestamp)
   }
 
   const messageArr = Array.ensure(message)
@@ -739,35 +701,22 @@ export const formatStructured: Logger<unknown, {
  *
  * **Example** (Formatting logs as JSON)
  *
- * ```ts
- * import { Effect, Logger } from "effect"
- *
- * // Use the JSON format logger
- * const jsonLoggerProgram = Effect.log("Hello JSON Format").pipe(
- *   Effect.provide(Logger.layer([Logger.formatJson]))
- * )
+ * ```ts import.meta.vitest
+ * import { Effect, Formatter, Logger } from "effect"
+ * import { TestConsole } from "effect/testing"
  *
- * // Perfect for log aggregation and processing systems
- * const productionProgram = Effect.gen(function*() {
- *   yield* Effect.log("Server started", { port: 3000, env: "production" })
- *   yield* Effect.logInfo("Request received", {
- *     method: "GET",
- *     path: "/api/users"
- *   })
- *   yield* Effect.logError("Database error", { error: "Connection timeout" })
- * }).pipe(
- *   Effect.annotateLogs("service", "api-server"),
- *   Effect.withLogSpan("request-processing"),
- *   Effect.provide(Logger.layer([Logger.formatJson]))
- * )
- *
- * // Adapt the JSON string before giving it to an output sink
- * const envelopedJsonLogger = Logger.map(
- *   Logger.formatJson,
- *   (jsonString) => `{"service":"api-server","entry":${jsonString}}`
- * )
+ * const stableJson = Logger.map(Logger.formatJson, (json) => {
+ *   const output = JSON.parse(json)
+ *   return Formatter.formatJson({ message: output.message, level: output.level })
+ * })
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("Server started").pipe(
+ *     Effect.provide(Logger.layer([Logger.withConsoleLog(stableJson)]))
+ *   )
+ *   return yield* TestConsole.logLines
+ * }).pipe(Effect.provide(TestConsole.layer))
  *
- * const envelopedConsoleLogger = Logger.withConsoleLog(envelopedJsonLogger)
+ * await Effect.runPromise(program) // => ["{\"message\":\"Server started\",\"level\":\"INFO\"}"]
  * ```
  *
  * @category constructors
@@ -786,43 +735,26 @@ export const formatJson = map(formatStructured, Formatter.formatJson)
  *
  * **Example** (Batching logger output)
  *
- * ```ts
- * import { Duration, Effect, Logger } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Logger } from "effect"
  *
- * // Create a batched logger that flushes every 5 seconds
- * const batchedLogger = Logger.batched(Logger.formatJson, {
- *   window: Duration.seconds(5),
+ * const flushed: Array<ReadonlyArray<string>> = []
+ * const messageLogger = Logger.make((options) => String(options.message))
+ * const batchedLogger = Logger.batched(messageLogger, {
+ *   window: "1 hour",
  *   flush: (messages) =>
  *     Effect.sync(() => {
- *       console.log(`Flushing ${messages.length} log entries:`)
- *       messages.forEach((msg, i) => console.log(`${i + 1}. ${msg}`))
+ *       flushed.push(messages)
  *     })
  * })
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const logger = yield* batchedLogger
- *
- *   yield* Effect.provide(
- *     Effect.all([
- *       Effect.log("Event 1"),
- *       Effect.log("Event 2"),
- *       Effect.log("Event 3"),
- *       Effect.sleep(Duration.seconds(6)), // Trigger flush
- *       Effect.log("Event 4")
- *     ]),
- *     Logger.layer([logger])
- *   )
- * })
- *
- * // Remote batch logging example
- * const remoteBatchLogger = Logger.batched(Logger.formatStructured, {
- *   window: Duration.seconds(10),
- *   flush: (entries) =>
- *     Effect.sync(() => {
- *       // Send batch to remote logging service
- *       console.log(`Sending ${entries.length} log entries to remote service`)
- *     })
- * })
+ *   yield* Effect.log("Event 1").pipe(Effect.provide(Logger.layer([logger])))
+ *   yield* Effect.log("Event 2").pipe(Effect.provide(Logger.layer([logger])))
+ * }))
+ * await Effect.runPromise(program)
+ * flushed // => [["Event 1", "Event 2"]]
  * ```
  *
  * @category constructors
@@ -840,43 +772,26 @@ export const batched = dual<
    *
    * **Example** (Batching logger output)
    *
-   * ```ts
-   * import { Duration, Effect, Logger } from "effect"
+   * ```ts import.meta.vitest
+   * import { Effect, Logger } from "effect"
    *
-   * // Create a batched logger that flushes every 5 seconds
-   * const batchedLogger = Logger.batched(Logger.formatJson, {
-   *   window: Duration.seconds(5),
+   * const flushed: Array<ReadonlyArray<string>> = []
+   * const messageLogger = Logger.make((options) => String(options.message))
+   * const batchedLogger = Logger.batched(messageLogger, {
+   *   window: "1 hour",
    *   flush: (messages) =>
    *     Effect.sync(() => {
-   *       console.log(`Flushing ${messages.length} log entries:`)
-   *       messages.forEach((msg, i) => console.log(`${i + 1}. ${msg}`))
+   *       flushed.push(messages)
    *     })
    * })
    *
-   * const program = Effect.gen(function*() {
+   * const program = Effect.scoped(Effect.gen(function*() {
    *   const logger = yield* batchedLogger
-   *
-   *   yield* Effect.provide(
-   *     Effect.all([
-   *       Effect.log("Event 1"),
-   *       Effect.log("Event 2"),
-   *       Effect.log("Event 3"),
-   *       Effect.sleep(Duration.seconds(6)), // Trigger flush
-   *       Effect.log("Event 4")
-   *     ]),
-   *     Logger.layer([logger])
-   *   )
-   * })
-   *
-   * // Remote batch logging example
-   * const remoteBatchLogger = Logger.batched(Logger.formatStructured, {
-   *   window: Duration.seconds(10),
-   *   flush: (entries) =>
-   *     Effect.sync(() => {
-   *       // Send batch to remote logging service
-   *       console.log(`Sending ${entries.length} log entries to remote service`)
-   *     })
-   * })
+   *   yield* Effect.log("Event 1").pipe(Effect.provide(Logger.layer([logger])))
+   *   yield* Effect.log("Event 2").pipe(Effect.provide(Logger.layer([logger])))
+   * }))
+   * await Effect.runPromise(program)
+   * flushed // => [["Event 1", "Event 2"]]
    * ```
    *
    * @category constructors
@@ -901,43 +816,26 @@ export const batched = dual<
    *
    * **Example** (Batching logger output)
    *
-   * ```ts
-   * import { Duration, Effect, Logger } from "effect"
+   * ```ts import.meta.vitest
+   * import { Effect, Logger } from "effect"
    *
-   * // Create a batched logger that flushes every 5 seconds
-   * const batchedLogger = Logger.batched(Logger.formatJson, {
-   *   window: Duration.seconds(5),
+   * const flushed: Array<ReadonlyArray<string>> = []
+   * const messageLogger = Logger.make((options) => String(options.message))
+   * const batchedLogger = Logger.batched(messageLogger, {
+   *   window: "1 hour",
    *   flush: (messages) =>
    *     Effect.sync(() => {
-   *       console.log(`Flushing ${messages.length} log entries:`)
-   *       messages.forEach((msg, i) => console.log(`${i + 1}. ${msg}`))
+   *       flushed.push(messages)
    *     })
    * })
    *
-   * const program = Effect.gen(function*() {
+   * const program = Effect.scoped(Effect.gen(function*() {
    *   const logger = yield* batchedLogger
-   *
-   *   yield* Effect.provide(
-   *     Effect.all([
-   *       Effect.log("Event 1"),
-   *       Effect.log("Event 2"),
-   *       Effect.log("Event 3"),
-   *       Effect.sleep(Duration.seconds(6)), // Trigger flush
-   *       Effect.log("Event 4")
-   *     ]),
-   *     Logger.layer([logger])
-   *   )
-   * })
-   *
-   * // Remote batch logging example
-   * const remoteBatchLogger = Logger.batched(Logger.formatStructured, {
-   *   window: Duration.seconds(10),
-   *   flush: (entries) =>
-   *     Effect.sync(() => {
-   *       // Send batch to remote logging service
-   *       console.log(`Sending ${entries.length} log entries to remote service`)
-   *     })
-   * })
+   *   yield* Effect.log("Event 1").pipe(Effect.provide(Logger.layer([logger])))
+   *   yield* Effect.log("Event 2").pipe(Effect.provide(Logger.layer([logger])))
+   * }))
+   * await Effect.runPromise(program)
+   * flushed // => [["Event 1", "Event 2"]]
    * ```
    *
    * @category constructors
@@ -999,35 +897,11 @@ export const batched = dual<
  *
  * **Example** (Logging with pretty console output)
  *
- * ```ts
- * import { Effect, Logger } from "effect"
- *
- * // Use the pretty console logger with default settings
- * const basicPretty = Effect.log("Hello Pretty Format").pipe(
- *   Effect.provide(Logger.layer([Logger.consolePretty()]))
- * )
- *
- * // Configure pretty logger options
- * const customPretty = Logger.consolePretty({
- *   colors: true,
- *   stderr: false,
- *   mode: "tty",
- *   formatDate: (date) => date.toLocaleTimeString()
- * })
- *
- * // Perfect for development environment
- * const developmentProgram = Effect.gen(function*() {
- *   yield* Effect.log("Application starting")
- *   yield* Effect.logInfo("Database connected")
- *   yield* Effect.logWarning("High memory usage detected")
- * }).pipe(
- *   Effect.annotateLogs("environment", "development"),
- *   Effect.withLogSpan("startup"),
- *   Effect.provide(Logger.layer([customPretty]))
- * )
+ * ```ts import.meta.vitest
+ * import { Logger } from "effect"
  *
- * // Disable colors for CI/CD environments
- * const ciLogger = Logger.consolePretty({ colors: false })
+ * const prettyLogger = Logger.consolePretty({ colors: false })
+ * Logger.isLogger(prettyLogger) // => true
  * ```
  *
  * @category constructors
@@ -1053,33 +927,10 @@ export const consolePretty: (
  *
  * **Example** (Logging logfmt output to the console)
  *
- * ```ts
- * import { Effect, Logger } from "effect"
- *
- * // Use the console logfmt logger
- * const logfmtProgram = Effect.log("Hello LogFmt Console").pipe(
- *   Effect.provide(Logger.layer([Logger.consoleLogFmt]))
- * )
- *
- * // Great for production environments
- * const productionProgram = Effect.gen(function*() {
- *   yield* Effect.log("Server started", { port: 8080, version: "1.0.0" })
- *   yield* Effect.logInfo("Request processed", { userId: 123, duration: 45 })
- *   yield* Effect.logError("Validation failed", {
- *     field: "email",
- *     value: "invalid"
- *   })
- * }).pipe(
- *   Effect.annotateLogs("service", "api"),
- *   Effect.withLogSpan("request-handler"),
- *   Effect.provide(Logger.layer([Logger.consoleLogFmt]))
- * )
+ * ```ts import.meta.vitest
+ * import { Logger } from "effect"
  *
- * // Combine with other loggers
- * const multiLoggerLive = Logger.layer([
- *   Logger.consoleLogFmt,
- *   Logger.consolePretty()
- * ])
+ * Logger.isLogger(Logger.consoleLogFmt) // => true
  * ```
  *
  * @category constructors
@@ -1101,41 +952,10 @@ export const consoleLogFmt: Logger<unknown, void> = withConsoleLog(formatLogFmt)
  *
  * **Example** (Logging structured output to the console)
  *
- * ```ts
- * import { Effect, Logger } from "effect"
- *
- * // Use the console structured logger
- * const structuredProgram = Effect.log("Hello Structured Console").pipe(
- *   Effect.provide(Logger.layer([Logger.consoleStructured]))
- * )
- *
- * // Perfect for development debugging
- * const debugProgram = Effect.gen(function*() {
- *   yield* Effect.log("User event", {
- *     userId: 123,
- *     action: "login",
- *     ip: "192.168.1.1"
- *   })
- *   yield* Effect.logInfo("API call", {
- *     endpoint: "/users",
- *     method: "GET",
- *     duration: 120
- *   })
- * }).pipe(
- *   Effect.annotateLogs("requestId", "req-123"),
- *   Effect.withLogSpan("authentication"),
- *   Effect.provide(Logger.layer([Logger.consoleStructured]))
- * )
+ * ```ts import.meta.vitest
+ * import { Logger } from "effect"
  *
- * // Easy to parse and inspect object structure
- * const inspectionProgram = Effect.gen(function*() {
- *   yield* Effect.log("Complex data", {
- *     user: { id: 1, name: "John" },
- *     metadata: { source: "api", version: 2 }
- *   })
- * }).pipe(
- *   Effect.provide(Logger.layer([Logger.consoleStructured]))
- * )
+ * Logger.isLogger(Logger.consoleStructured) // => true
  * ```
  *
  * @category constructors
@@ -1155,46 +975,10 @@ export const consoleStructured: Logger<unknown, void> = withConsoleLog(formatStr
  *
  * **Example** (Logging JSON output to the console)
  *
- * ```ts
- * import { Effect, Logger } from "effect"
- *
- * // Use the console JSON logger
- * const jsonProgram = Effect.log("Hello JSON Console").pipe(
- *   Effect.provide(Logger.layer([Logger.consoleJson]))
- * )
- *
- * // Perfect for production logging and log aggregation
- * const productionProgram = Effect.gen(function*() {
- *   yield* Effect.log("Server started", { port: 3000, env: "production" })
- *   yield* Effect.logInfo("Request", {
- *     method: "POST",
- *     url: "/api/users",
- *     body: { name: "Alice" }
- *   })
- *   yield* Effect.logError("Database error", {
- *     error: "Connection timeout",
- *     retryCount: 3
- *   })
- * }).pipe(
- *   Effect.annotateLogs("service", "user-api"),
- *   Effect.annotateLogs("version", "1.2.3"),
- *   Effect.withLogSpan("request-processing"),
- *   Effect.provide(Logger.layer([Logger.consoleJson]))
- * )
+ * ```ts import.meta.vitest
+ * import { Logger } from "effect"
  *
- * // Easy to pipe to log aggregation services
- * const productionSetup = Logger.layer([
- *   Logger.consoleJson, // For stdout JSON logs
- *   Logger.consolePretty() // For local debugging
- * ])
- *
- * // Ideal for containerized environments (Docker, Kubernetes)
- * const containerProgram = Effect.log("Container ready", {
- *   containerId: "abc123",
- *   image: "myapp:latest"
- * }).pipe(
- *   Effect.provide(Logger.layer([Logger.consoleJson]))
- * )
+ * Logger.isLogger(Logger.consoleJson) // => true
  * ```
  *
  * @category constructors
@@ -1217,40 +1001,14 @@ export const consoleJson: Logger<unknown, void> = withConsoleLog(formatJson)
  *
  * **Example** (Recording logs as trace span events)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
  *
- * // Tracer logger is included by default - logs automatically become span events
- * const defaultProgram = Effect.gen(function*() {
- *   yield* Effect.log("This automatically becomes a span event")
- *   yield* Effect.logInfo("Processing data")
- * })
- *
- * // Explicitly combine tracer logger with other loggers
- * const observabilityProgram = Effect.gen(function*() {
- *   yield* Effect.log("Operation started")
- *   yield* Effect.logInfo("Processing data")
- *   yield* Effect.logError("Error occurred")
- * }).pipe(
- *   Effect.withLogSpan("data-processing"),
- *   Effect.provide(Logger.layer([
- *     Logger.tracerLogger,
- *     Logger.consoleJson
- *   ]))
- * )
- *
- * // Perfect for correlating logs with traces in distributed systems
- * const distributedProgram = Effect.gen(function*() {
- *   yield* Effect.log("Step 1: Fetching user data")
- *   yield* Effect.sleep("100 millis")
- *   yield* Effect.log("Step 2: Processing payment")
- *   yield* Effect.sleep("200 millis")
- *   yield* Effect.log("Step 3: Sending confirmation")
- * }).pipe(
- *   Effect.withLogSpan("payment-workflow"),
- *   Effect.annotateLogs("userId", "user-123"),
+ * const program = Effect.log("span event").pipe(
+ *   Effect.withSpan("operation"),
  *   Effect.provide(Logger.layer([Logger.tracerLogger]))
  * )
+ * Effect.runSync(program)
  * ```
  *
  * @category constructors
@@ -1269,37 +1027,23 @@ export const tracerLogger: Logger<unknown, void> = effect.tracerLogger
  *
  * **Example** (Providing logger layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Logger } from "effect"
  *
- * // Single logger layer
- * const JsonLoggerLive = Logger.layer([Logger.consoleJson])
- *
- * // Multiple loggers layer
- * const MultiLoggerLive = Logger.layer([
- *   Logger.consoleJson,
- *   Logger.consolePretty(),
- *   Logger.formatStructured
- * ])
- *
- * // Merge with existing loggers
- * const AdditionalLoggerLive = Logger.layer(
- *   [Logger.consoleJson],
- *   { mergeWithExisting: true }
- * )
- *
- * // Using multiple logger formats
- * const jsonLogger = Logger.consoleJson
- * const prettyLogger = Logger.consolePretty()
- *
- * const CustomLoggerLive = Logger.layer([jsonLogger, prettyLogger])
+ * const messages: Array<unknown> = []
+ * const customLogger = Logger.make((options) => {
+ *   messages.push(options.message)
+ * })
+ * const CustomLoggerLive = Logger.layer([customLogger])
  *
  * const program = Effect.log("Application started").pipe(
  *   Effect.provide(CustomLoggerLive)
  * )
+ * Effect.runSync(program)
+ * messages // => [["Application started"]]
  * ```
  *
- * @category context
+ * @category layers
  * @since 4.0.0
  */
 export const layer = <
@@ -1337,91 +1081,59 @@ export const layer = <
  *
  * **Example** (Writing JSON logs to a file)
  *
- * ```ts
- * import { Effect, Layer, Logger } from "effect"
- * import { NodeFileSystem, NodeRuntime } from "@effect/platform-node"
- *
- * const fileLogger = Logger.formatJson.pipe(
- *   Logger.toFile("/tmp/log.txt")
- * )
- * const LoggerLive = Logger.layer([fileLogger]).pipe(
- *   Layer.provide(NodeFileSystem.layer)
- * )
+ * ```ts import.meta.vitest
+ * import { Effect, FileSystem, Logger } from "effect"
  *
- * Effect.log("a").pipe(
- *   Effect.andThen(Effect.log("b")),
- *   Effect.andThen(Effect.log("c")),
- *   Effect.provide(LoggerLive),
- *   NodeRuntime.runMain
- * )
+ * const writes: Array<string> = []
+ * const file = {
+ *   write: (buffer: Uint8Array) => Effect.sync(() => {
+ *     writes.push(new TextDecoder().decode(buffer).trim())
+ *     return FileSystem.Size(buffer.length)
+ *   })
+ * } as unknown as FileSystem.File
+ * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
+ * const messageLogger = Logger.make((options) => String(options.message))
+ *
+ * const program = Effect.scoped(Effect.gen(function*() {
+ *   const fileLogger = yield* Logger.toFile(messageLogger, "/tmp/log.txt")
+ *   yield* Effect.log("a").pipe(Effect.provide(Logger.layer([fileLogger])))
+ *   yield* Effect.log("b").pipe(Effect.provide(Logger.layer([fileLogger])))
+ *   yield* Effect.log("c").pipe(Effect.provide(Logger.layer([fileLogger])))
+ * })).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem))
+ *
+ * await Effect.runPromise(program)
+ * writes // => ["a\nb\nc"]
  * ```
  *
  * **Example** (Writing logs to files)
  *
- * ```ts
- * import { Duration, Effect, Logger } from "effect"
- * import { NodeFileSystem } from "@effect/platform-node"
- *
- * // Basic file logging. The scope keeps the file open while logs are emitted
- * // and flushes pending entries when it closes.
- * const basicFileLogger = Effect.scoped(
- *   Effect.gen(function*() {
- *     const fileLogger = yield* Logger.formatJson.pipe(
- *       Logger.toFile("/tmp/app.log")
- *     )
- *
- *     yield* Effect.log("Application started").pipe(
- *       Effect.provide(Logger.layer([fileLogger]))
- *     )
- *   })
- * ).pipe(
- *   Effect.provide(NodeFileSystem.layer)
- * )
+ * ```ts import.meta.vitest
+ * import { Effect, FileSystem, Logger } from "effect"
  *
- * // File logger with custom batch window
- * const batchedFileLogger = Effect.scoped(
- *   Effect.gen(function*() {
- *     const fileLogger = yield* Logger.formatLogFmt.pipe(
- *       Logger.toFile("/var/log/myapp.log", {
- *         flag: "a",
- *         batchWindow: Duration.seconds(5)
- *       })
- *     )
- *
- *     yield* Effect.all([
- *       Effect.log("Event 1"),
- *       Effect.log("Event 2"),
- *       Effect.log("Event 3")
- *     ]).pipe(
- *       Effect.provide(Logger.layer([fileLogger]))
- *     )
+ * const writes: Array<string> = []
+ * const file = {
+ *   write: (buffer: Uint8Array) => Effect.sync(() => {
+ *     writes.push(new TextDecoder().decode(buffer).trim())
+ *     return FileSystem.Size(buffer.length)
  *   })
- * ).pipe(
- *   Effect.provide(NodeFileSystem.layer)
- * )
+ * } as unknown as FileSystem.File
+ * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
+ * const messageLogger = Logger.make((options) => String(options.message))
  *
- * // Multiple loggers: console + file
- * const multiLogger = Effect.scoped(
- *   Effect.gen(function*() {
- *     const fileLogger = yield* Logger.formatJson.pipe(
- *       Logger.toFile("/tmp/production.log")
- *     )
- *
- *     const loggerLive = Logger.layer([
- *       Logger.consolePretty(),
- *       fileLogger
- *     ])
- *
- *     yield* Effect.log("Production event").pipe(
- *       Effect.provide(loggerLive)
- *     )
+ * const program = Effect.scoped(Effect.gen(function*() {
+ *   const fileLogger = yield* Logger.toFile(messageLogger, "/tmp/app.log", {
+ *     batchWindow: "1 hour"
  *   })
- * ).pipe(
- *   Effect.provide(NodeFileSystem.layer)
- * )
+ *   yield* Effect.log("Application started").pipe(
+ *     Effect.provide(Logger.layer([fileLogger]))
+ *   )
+ * })).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem))
+ *
+ * await Effect.runPromise(program)
+ * writes // => ["Application started"]
  * ```
  *
- * @category file
+ * @category logging
  * @since 4.0.0
  */
 export const toFile = dual<
@@ -1436,91 +1148,59 @@ export const toFile = dual<
    *
    * **Example** (Writing JSON logs to a file)
    *
-   * ```ts
-   * import { Effect, Layer, Logger } from "effect"
-   * import { NodeFileSystem, NodeRuntime } from "@effect/platform-node"
-   *
-   * const fileLogger = Logger.formatJson.pipe(
-   *   Logger.toFile("/tmp/log.txt")
-   * )
-   * const LoggerLive = Logger.layer([fileLogger]).pipe(
-   *   Layer.provide(NodeFileSystem.layer)
-   * )
+   * ```ts import.meta.vitest
+   * import { Effect, FileSystem, Logger } from "effect"
    *
-   * Effect.log("a").pipe(
-   *   Effect.andThen(Effect.log("b")),
-   *   Effect.andThen(Effect.log("c")),
-   *   Effect.provide(LoggerLive),
-   *   NodeRuntime.runMain
-   * )
+   * const writes: Array<string> = []
+   * const file = {
+   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *     writes.push(new TextDecoder().decode(buffer).trim())
+   *     return FileSystem.Size(buffer.length)
+   *   })
+   * } as unknown as FileSystem.File
+   * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
+   * const messageLogger = Logger.make((options) => String(options.message))
+   *
+   * const program = Effect.scoped(Effect.gen(function*() {
+   *   const fileLogger = yield* Logger.toFile(messageLogger, "/tmp/log.txt")
+   *   yield* Effect.log("a").pipe(Effect.provide(Logger.layer([fileLogger])))
+   *   yield* Effect.log("b").pipe(Effect.provide(Logger.layer([fileLogger])))
+   *   yield* Effect.log("c").pipe(Effect.provide(Logger.layer([fileLogger])))
+   * })).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem))
+   *
+   * await Effect.runPromise(program)
+   * writes // => ["a\nb\nc"]
    * ```
    *
    * **Example** (Writing logs to files)
    *
-   * ```ts
-   * import { Duration, Effect, Logger } from "effect"
-   * import { NodeFileSystem } from "@effect/platform-node"
+   * ```ts import.meta.vitest
+   * import { Effect, FileSystem, Logger } from "effect"
    *
-   * // Basic file logging. The scope keeps the file open while logs are emitted
-   * // and flushes pending entries when it closes.
-   * const basicFileLogger = Effect.scoped(
-   *   Effect.gen(function*() {
-   *     const fileLogger = yield* Logger.formatJson.pipe(
-   *       Logger.toFile("/tmp/app.log")
-   *     )
-   *
-   *     yield* Effect.log("Application started").pipe(
-   *       Effect.provide(Logger.layer([fileLogger]))
-   *     )
+   * const writes: Array<string> = []
+   * const file = {
+   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *     writes.push(new TextDecoder().decode(buffer).trim())
+   *     return FileSystem.Size(buffer.length)
    *   })
-   * ).pipe(
-   *   Effect.provide(NodeFileSystem.layer)
-   * )
-   *
-   * // File logger with custom batch window
-   * const batchedFileLogger = Effect.scoped(
-   *   Effect.gen(function*() {
-   *     const fileLogger = yield* Logger.formatLogFmt.pipe(
-   *       Logger.toFile("/var/log/myapp.log", {
-   *         flag: "a",
-   *         batchWindow: Duration.seconds(5)
-   *       })
-   *     )
+   * } as unknown as FileSystem.File
+   * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
+   * const messageLogger = Logger.make((options) => String(options.message))
    *
-   *     yield* Effect.all([
-   *       Effect.log("Event 1"),
-   *       Effect.log("Event 2"),
-   *       Effect.log("Event 3")
-   *     ]).pipe(
-   *       Effect.provide(Logger.layer([fileLogger]))
-   *     )
+   * const program = Effect.scoped(Effect.gen(function*() {
+   *   const fileLogger = yield* Logger.toFile(messageLogger, "/tmp/app.log", {
+   *     batchWindow: "1 hour"
    *   })
-   * ).pipe(
-   *   Effect.provide(NodeFileSystem.layer)
-   * )
-   *
-   * // Multiple loggers: console + file
-   * const multiLogger = Effect.scoped(
-   *   Effect.gen(function*() {
-   *     const fileLogger = yield* Logger.formatJson.pipe(
-   *       Logger.toFile("/tmp/production.log")
-   *     )
-   *
-   *     const loggerLive = Logger.layer([
-   *       Logger.consolePretty(),
-   *       fileLogger
-   *     ])
+   *   yield* Effect.log("Application started").pipe(
+   *     Effect.provide(Logger.layer([fileLogger]))
+   *   )
+   * })).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem))
    *
-   *     yield* Effect.log("Production event").pipe(
-   *       Effect.provide(loggerLive)
-   *     )
-   *   })
-   * ).pipe(
-   *   Effect.provide(NodeFileSystem.layer)
-   * )
+   * await Effect.runPromise(program)
+   * writes // => ["Application started"]
    * ```
    *
-   * @category file
+   * @category logging
    * @since 4.0.0
    */
   (
@@ -1544,91 +1224,59 @@ export const toFile = dual<
    *
    * **Example** (Writing JSON logs to a file)
    *
-   * ```ts
-   * import { Effect, Layer, Logger } from "effect"
-   * import { NodeFileSystem, NodeRuntime } from "@effect/platform-node"
-   *
-   * const fileLogger = Logger.formatJson.pipe(
-   *   Logger.toFile("/tmp/log.txt")
-   * )
-   * const LoggerLive = Logger.layer([fileLogger]).pipe(
-   *   Layer.provide(NodeFileSystem.layer)
-   * )
+   * ```ts import.meta.vitest
+   * import { Effect, FileSystem, Logger } from "effect"
    *
-   * Effect.log("a").pipe(
-   *   Effect.andThen(Effect.log("b")),
-   *   Effect.andThen(Effect.log("c")),
-   *   Effect.provide(LoggerLive),
-   *   NodeRuntime.runMain
-   * )
+   * const writes: Array<string> = []
+   * const file = {
+   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *     writes.push(new TextDecoder().decode(buffer).trim())
+   *     return FileSystem.Size(buffer.length)
+   *   })
+   * } as unknown as FileSystem.File
+   * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
+   * const messageLogger = Logger.make((options) => String(options.message))
+   *
+   * const program = Effect.scoped(Effect.gen(function*() {
+   *   const fileLogger = yield* Logger.toFile(messageLogger, "/tmp/log.txt")
+   *   yield* Effect.log("a").pipe(Effect.provide(Logger.layer([fileLogger])))
+   *   yield* Effect.log("b").pipe(Effect.provide(Logger.layer([fileLogger])))
+   *   yield* Effect.log("c").pipe(Effect.provide(Logger.layer([fileLogger])))
+   * })).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem))
+   *
+   * await Effect.runPromise(program)
+   * writes // => ["a\nb\nc"]
    * ```
    *
    * **Example** (Writing logs to files)
    *
-   * ```ts
-   * import { Duration, Effect, Logger } from "effect"
-   * import { NodeFileSystem } from "@effect/platform-node"
-   *
-   * // Basic file logging. The scope keeps the file open while logs are emitted
-   * // and flushes pending entries when it closes.
-   * const basicFileLogger = Effect.scoped(
-   *   Effect.gen(function*() {
-   *     const fileLogger = yield* Logger.formatJson.pipe(
-   *       Logger.toFile("/tmp/app.log")
-   *     )
+   * ```ts import.meta.vitest
+   * import { Effect, FileSystem, Logger } from "effect"
    *
-   *     yield* Effect.log("Application started").pipe(
-   *       Effect.provide(Logger.layer([fileLogger]))
-   *     )
+   * const writes: Array<string> = []
+   * const file = {
+   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *     writes.push(new TextDecoder().decode(buffer).trim())
+   *     return FileSystem.Size(buffer.length)
    *   })
-   * ).pipe(
-   *   Effect.provide(NodeFileSystem.layer)
-   * )
-   *
-   * // File logger with custom batch window
-   * const batchedFileLogger = Effect.scoped(
-   *   Effect.gen(function*() {
-   *     const fileLogger = yield* Logger.formatLogFmt.pipe(
-   *       Logger.toFile("/var/log/myapp.log", {
-   *         flag: "a",
-   *         batchWindow: Duration.seconds(5)
-   *       })
-   *     )
+   * } as unknown as FileSystem.File
+   * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
+   * const messageLogger = Logger.make((options) => String(options.message))
    *
-   *     yield* Effect.all([
-   *       Effect.log("Event 1"),
-   *       Effect.log("Event 2"),
-   *       Effect.log("Event 3")
-   *     ]).pipe(
-   *       Effect.provide(Logger.layer([fileLogger]))
-   *     )
+   * const program = Effect.scoped(Effect.gen(function*() {
+   *   const fileLogger = yield* Logger.toFile(messageLogger, "/tmp/app.log", {
+   *     batchWindow: "1 hour"
    *   })
-   * ).pipe(
-   *   Effect.provide(NodeFileSystem.layer)
-   * )
-   *
-   * // Multiple loggers: console + file
-   * const multiLogger = Effect.scoped(
-   *   Effect.gen(function*() {
-   *     const fileLogger = yield* Logger.formatJson.pipe(
-   *       Logger.toFile("/tmp/production.log")
-   *     )
-   *
-   *     const loggerLive = Logger.layer([
-   *       Logger.consolePretty(),
-   *       fileLogger
-   *     ])
+   *   yield* Effect.log("Application started").pipe(
+   *     Effect.provide(Logger.layer([fileLogger]))
+   *   )
+   * })).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem))
    *
-   *     yield* Effect.log("Production event").pipe(
-   *       Effect.provide(loggerLive)
-   *     )
-   *   })
-   * ).pipe(
-   *   Effect.provide(NodeFileSystem.layer)
-   * )
+   * await Effect.runPromise(program)
+   * writes // => ["Application started"]
    * ```
    *
-   * @category file
+   * @category logging
    * @since 4.0.0
    */
   <Message>(