effect 4.0.0-beta.101 → 4.0.0-beta.103

package/src/testing/TestClock.ts

@@ -44,27 +44,28 @@ import * as Semaphore from "../Semaphore.ts"
  *
  * Tests `Effect.timeout` using `TestClock`.
  *
- * ```ts
- * import { Effect, Fiber, Option, pipe } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Exit, Fiber, pipe } from "effect"
  * import { TestClock } from "effect/testing"
- * import * as assert from "node:assert"
  *
- * Effect.gen(function*() {
+ * const program = Effect.gen(function*() {
  *   const fiber = yield* pipe(
  *     Effect.sleep("5 minutes"),
  *     Effect.timeout("1 minute"),
  *     Effect.forkChild
  *   )
  *   yield* TestClock.adjust("1 minute")
- *   const result = yield* Fiber.join(fiber)
- *   assert.deepStrictEqual(result, Option.none())
+ *   const exit = yield* Fiber.await(fiber)
+ *   Exit.isFailure(exit) // => true
  * })
+ *
+ * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
  * **Example** (Advancing time deterministically)
  *
- * ```ts
- * import { Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Fiber } from "effect"
  * import { TestClock } from "effect/testing"
  *
  * const program = Effect.gen(function*() {
@@ -78,10 +79,13 @@ import * as Semaphore from "../Semaphore.ts"
  *
  *   // Advance the test clock by 1 hour
  *   yield* TestClock.adjust("1 hour")
+ *   yield* Fiber.join(fiber)
  *
  *   // The effect should now be executed
- *   console.log(executed) // true
+ *   executed // => true
  * })
+ *
+ * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
  * @category models
@@ -111,7 +115,7 @@ export interface TestClock extends Clock.Clock {
  *
  * **Example** (Configuring a test clock)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect } from "effect"
  * import { TestClock } from "effect/testing"
  *
@@ -123,8 +127,10 @@ export interface TestClock extends Clock.Clock {
  *
  *   // Access the current state
  *   const currentTime = testClock.currentTimeMillisUnsafe()
- *   console.log(currentTime) // 0 (starts at epoch)
+ *   currentTime // => 0
  * })
+ *
+ * await Effect.runPromise(Effect.scoped(program))
  * ```
  *
  * @since 2.0.0
@@ -137,7 +143,7 @@ export declare namespace TestClock {
    *
    * **Example** (Configuring the warning delay)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect } from "effect"
    * import { TestClock } from "effect/testing"
    *
@@ -149,7 +155,10 @@ export declare namespace TestClock {
    *
    *   // Use the TestClock in your test
    *   yield* testClock.adjust("1 hour")
+   *   testClock.currentTimeMillisUnsafe() // => 3_600_000
    * })
+   *
+   * await Effect.runPromise(Effect.scoped(program))
    * ```
    *
    * @category options
@@ -199,7 +208,7 @@ const SleepOrder = Order.flip(Order.Struct({
  *
  * **Example** (Creating a test clock)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect } from "effect"
  * import { TestClock } from "effect/testing"
  *
@@ -215,8 +224,10 @@ const SleepOrder = Order.flip(Order.Struct({
  *   // Use the TestClock to control time in tests
  *   yield* testClock.adjust("1 hour")
  *   const currentTime = testClock.currentTimeMillisUnsafe()
- *   console.log(currentTime) // Time advanced by 1 hour
+ *   currentTime // => 3_600_000
  * })
+ *
+ * await Effect.runPromise(Effect.scoped(program))
  * ```
  *
  * @category constructors
@@ -225,7 +236,7 @@ const SleepOrder = Order.flip(Order.Struct({
 export const make = Effect.fnUntraced(function*(
   options?: TestClock.Options
 ) {
-  const config = Object.assign({}, defaultOptions, options)
+  const config = { ...defaultOptions, ...options }
   let sequence = 0
   const sleeps: Array<{
     readonly sequence: number
@@ -236,6 +247,7 @@ export const make = Effect.fnUntraced(function*(
   const warningSemaphore = yield* Semaphore.make(1)
 
   let currentTimestamp: number = new Date(0).getTime()
+  let currentMonotonicNanos = BigInt(0)
   let warningState: WarningState = WarningState.Start()
 
   function currentTimeMillisUnsafe(): number {
@@ -246,8 +258,13 @@ export const make = Effect.fnUntraced(function*(
     return BigInt(Math.floor(currentTimestamp * 1000000))
   }
 
+  function monotonicTimeNanosUnsafe(): bigint {
+    return currentMonotonicNanos
+  }
+
   const currentTimeMillis = Effect.sync(currentTimeMillisUnsafe)
   const currentTimeNanos = Effect.sync(currentTimeNanosUnsafe)
+  const monotonicTimeNanos = Effect.sync(monotonicTimeNanosUnsafe)
 
   function withLive<A, E, R>(effect: Effect.Effect<A, E, R>) {
     return Effect.provideService(effect, Clock.Clock, liveClock)
@@ -317,14 +334,21 @@ export const make = Effect.fnUntraced(function*(
   const run = Effect.fnUntraced(function*(step: (currentTimestamp: number) => number) {
     yield* Fiber.await(yield* Effect.forkChild(Effect.yieldNow))
     const endTimestamp = step(currentTimestamp)
+    const advanceTo = (timestamp: number) => {
+      const deltaMillis = timestamp - currentTimestamp
+      if (deltaMillis > 0 && Number.isFinite(deltaMillis)) {
+        currentMonotonicNanos += BigInt(Math.round(deltaMillis * 1_000_000))
+      }
+      currentTimestamp = timestamp
+    }
     while (Arr.isArrayNonEmpty(sleeps)) {
       if (Arr.lastNonEmpty(sleeps).timestamp > endTimestamp) break
       const entry = sleeps.pop()!
-      currentTimestamp = entry.timestamp
+      advanceTo(entry.timestamp)
       entry.latch.openUnsafe()
       yield* Effect.yieldNow
     }
-    currentTimestamp = endTimestamp
+    advanceTo(endTimestamp)
   }, runSemaphore.withPermits(1))
 
   function adjust(duration: Duration.Input) {
@@ -341,8 +365,10 @@ export const make = Effect.fnUntraced(function*(
   return {
     currentTimeMillisUnsafe,
     currentTimeNanosUnsafe,
+    monotonicTimeNanosUnsafe,
     currentTimeMillis,
     currentTimeNanos,
+    monotonicTimeNanos,
     adjust,
     setTime,
     sleep,
@@ -355,7 +381,7 @@ export const make = Effect.fnUntraced(function*(
  *
  * **Example** (Providing a test clock layer)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect } from "effect"
  * import { TestClock } from "effect/testing"
  *
@@ -370,7 +396,13 @@ export const make = Effect.fnUntraced(function*(
  * const program = Effect.gen(function*() {
  *   // Use the layer in your program
  *   yield* TestClock.adjust("1 hour")
- * }).pipe(Effect.provide(testClockLayer))
+ *   return yield* TestClock.testClockWith((testClock) =>
+ *     Effect.succeed(testClock.currentTimeMillisUnsafe())
+ *   )
+ * })
+ *
+ * await Effect.runPromise(Effect.provide(program, testClockLayer)) // => 3_600_000
+ * await Effect.runPromise(Effect.provide(program, customTestClockLayer)) // => 3_600_000
  * ```
  *
  * @category layers
@@ -387,7 +419,7 @@ export const layer: (options?: TestClock.Options) => Layer.Layer<TestClock> = fl
  *
  * **Example** (Accessing the test clock)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect } from "effect"
  * import { TestClock } from "effect/testing"
  *
@@ -400,8 +432,10 @@ export const layer: (options?: TestClock.Options) => Layer.Layer<TestClock> = fl
  *   // Adjust time using the TestClock instance
  *   yield* TestClock.testClockWith((testClock) => testClock.adjust("2 hours"))
  *
- *   console.log(currentTime) // Initial time
+ *   currentTime // => 0
  * })
+ *
+ * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
  * @category testing
@@ -418,8 +452,8 @@ export const testClockWith = <A, E, R>(
  *
  * **Example** (Advancing the test clock)
  *
- * ```ts
- * import { Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Fiber } from "effect"
  * import { TestClock } from "effect/testing"
  *
  * const program = Effect.gen(function*() {
@@ -433,10 +467,13 @@ export const testClockWith = <A, E, R>(
  *
  *   // Advance the clock by 30 minutes
  *   yield* TestClock.adjust("30 minutes")
+ *   yield* Fiber.join(fiber)
  *
  *   // The effect should now be executed
- *   console.log(executed) // true
+ *   executed // => true
  * })
+ *
+ * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
  * @category testing
@@ -451,8 +488,8 @@ export const adjust = (duration: Duration.Input): Effect.Effect<void> =>
  *
  * **Example** (Setting the test clock time)
  *
- * ```ts
- * import { Duration, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Duration, Effect, Fiber } from "effect"
  * import { TestClock } from "effect/testing"
  *
  * const program = Effect.gen(function*() {
@@ -467,10 +504,13 @@ export const adjust = (duration: Duration.Input): Effect.Effect<void> =>
  *   // Set the clock to a specific timestamp (2 hours from epoch)
  *   const targetTime = Duration.toMillis(Duration.hours(2))
  *   yield* TestClock.setTime(targetTime)
+ *   yield* Fiber.join(fiber)
  *
  *   // The effect should now be executed
- *   console.log(executed) // true
+ *   executed // => true
  * })
+ *
+ * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
  * @category testing
@@ -485,26 +525,28 @@ export const setTime = (timestamp: number): Effect.Effect<void> =>
  *
  * **Example** (Running with the live clock)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Clock, Effect } from "effect"
  * import { TestClock } from "effect/testing"
  *
  * const program = Effect.gen(function*() {
  *   // Get the current test time (starts at epoch)
  *   const testTime = yield* Clock.currentTimeMillis
- *   console.log(testTime) // 0
+ *   testTime // => 0
  *
  *   // Get the actual system time using withLive
  *   const realTime = yield* TestClock.withLive(Clock.currentTimeMillis)
- *   console.log(realTime) // Actual system timestamp
+ *   Number.isFinite(realTime) // => true
  *
  *   // Advance test time
  *   yield* TestClock.adjust("1 hour")
  *
  *   // Test time is now 1 hour ahead
  *   const newTestTime = yield* Clock.currentTimeMillis
- *   console.log(newTestTime) // 3600000 (1 hour in milliseconds)
+ *   newTestTime // => 3_600_000
  * })
+ *
+ * await Effect.runPromise(Effect.provide(program, TestClock.layer()))
  * ```
  *
  * @category testing

package/src/testing/TestConsole.ts

@@ -31,7 +31,7 @@ import * as Layer from "../Layer.ts"
  *
  * **Example** (Capturing console output in tests)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Console, Effect } from "effect"
  * import { TestConsole } from "effect/testing"
  *
@@ -42,9 +42,11 @@ import * as Layer from "../Layer.ts"
  *   const logs = yield* TestConsole.logLines
  *   const errors = yield* TestConsole.errorLines
  *
- *   console.log(logs) // [["Hello, World!"]]
- *   console.log(errors) // [["An error occurred"]]
+ *   logs // => ["Hello, World!"]
+ *   errors // => ["An error occurred"]
  * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program)
  * ```
  *
  * @see {@link layer} for providing `TestConsole` to an effect
@@ -99,12 +101,10 @@ export declare namespace TestConsole {
    *
    * **Example** (Typing captured console methods)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { TestConsole } from "effect/testing"
    *
    * const method: TestConsole.TestConsole.Method = "log"
-   *
-   * console.log(method) // "log"
    * ```
    *
    * @category models
@@ -122,7 +122,7 @@ export declare namespace TestConsole {
    *
    * **Example** (Typing captured console entries)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { TestConsole } from "effect/testing"
    *
    * const entry: TestConsole.TestConsole.Entry = {
@@ -130,8 +130,7 @@ export declare namespace TestConsole {
    *   parameters: ["not found"]
    * }
    *
-   * console.log(entry.method) // "error"
-   * console.log(entry.parameters) // ["not found"]
+   * entry // => { method: "error", parameters: ["not found"] }
    * ```
    *
    * @category models
@@ -154,7 +153,7 @@ export declare namespace TestConsole {
  *
  * **Example** (Creating a test console)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Console, Effect } from "effect"
  * import { TestConsole } from "effect/testing"
  *
@@ -165,9 +164,11 @@ export declare namespace TestConsole {
  *   const logs = yield* TestConsole.logLines
  *   const errors = yield* TestConsole.errorLines
  *
- *   console.log("Captured logs:", logs)
- *   console.log("Captured errors:", errors)
+ *   logs // => ["Debug message"]
+ *   errors // => ["Error occurred"]
  * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program)
  * ```
  *
  * @see {@link layer} for providing a `TestConsole` as a `Layer`
@@ -225,7 +226,7 @@ export const make = Effect.gen(function*() {
  *
  * **Example** (Accessing the test console service)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect } from "effect"
  * import { TestConsole } from "effect/testing"
  *
@@ -237,10 +238,12 @@ export const make = Effect.gen(function*() {
  *     const logs = yield* testConsole.logLines
  *     const errors = yield* testConsole.errorLines
  *
- *     console.log("Logs:", logs) // [["Test message"]]
- *     console.log("Errors:", errors) // [["Test error"]]
+ *     logs // => ["Test message"]
+ *     errors // => ["Test error"]
  *   })
  * ).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program)
  * ```
  *
  * @see {@link layer} for providing the test console service
@@ -264,7 +267,7 @@ export const testConsoleWith = <A, E, R>(f: (console: TestConsole) => Effect.Eff
  *
  * **Example** (Providing a test console layer)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Console, Effect } from "effect"
  * import { TestConsole } from "effect/testing"
  *
@@ -275,9 +278,11 @@ export const testConsoleWith = <A, E, R>(f: (console: TestConsole) => Effect.Eff
  *   const logs = yield* TestConsole.logLines
  *   const errors = yield* TestConsole.errorLines
  *
- *   console.log("Captured logs:", logs)
- *   console.log("Captured errors:", errors)
+ *   logs // => ["This will be captured"]
+ *   errors // => ["This error will be captured"]
  * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program)
  * ```
  *
  * @see {@link make} for constructing the service value directly
@@ -299,7 +304,7 @@ export const layer: Layer.Layer<TestConsole> = Layer.effect(Console.Console)(mak
  *
  * **Example** (Reading captured log lines)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Console, Effect } from "effect"
  * import { TestConsole } from "effect/testing"
  *
@@ -310,13 +315,10 @@ export const layer: Layer.Layer<TestConsole> = Layer.effect(Console.Console)(mak
  *
  *   const logs = yield* TestConsole.logLines
  *
- *   console.log(logs)
- *   // [
- *   //   ["First message"],
- *   //   ["Second message", { key: "value" }],
- *   //   ["Third message", 42, true]
- *   // ]
+ *   logs // => ["First message", "Second message", { key: "value" }, "Third message", 42, true]
  * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program)
  * ```
  *
  * @see {@link errorLines} for reading captured `Console.error` output
@@ -340,7 +342,7 @@ export const logLines: Effect.Effect<ReadonlyArray<unknown>, never, never> = tes
  *
  * **Example** (Reading captured error lines)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Console, Effect } from "effect"
  * import { TestConsole } from "effect/testing"
  *
@@ -350,12 +352,11 @@ export const logLines: Effect.Effect<ReadonlyArray<unknown>, never, never> = tes
  *
  *   const errors = yield* TestConsole.errorLines
  *
- *   console.log(errors)
- *   // [
- *   //   ["Error message"],
- *   //   ["Another error", Error: Something went wrong]
- *   // ]
+ *   const messages = [errors[0], errors[1], errors[2] instanceof Error ? errors[2].message : undefined]
+ *   messages // => ["Error message", "Another error", "Something went wrong"]
  * }).pipe(Effect.provide(TestConsole.layer))
+ *
+ * await Effect.runPromise(program)
  * ```
  *
  * @see {@link logLines} for reading captured `Console.log` output

package/src/testing/TestSchema.ts

@@ -30,7 +30,7 @@ import * as FastCheck from "../testing/FastCheck.ts"
  *
  * **Example** (Decoding and encoding a struct)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { TestSchema } from "effect/testing"
  *
@@ -38,10 +38,10 @@ import * as FastCheck from "../testing/FastCheck.ts"
  * const asserts = new TestSchema.Asserts(schema)
  *
  * // decoding
- * await asserts.decoding().succeed({ name: "Alice" })
+ * await asserts.decoding().succeed({ name: "Alice" }) // => undefined
  *
  * // encoding
- * await asserts.encoding().succeed({ name: "Alice" })
+ * await asserts.encoding().succeed({ name: "Alice" }) // => undefined
  * ```
  *
  * @see {@link Decoding}
@@ -64,13 +64,13 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Example** (Comparing struct fields)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const fieldsA = { name: Schema.String }
    * const fieldsB = { name: Schema.String }
-   * TestSchema.Asserts.ast.fields.equals(fieldsA, fieldsB) // no error
+   * TestSchema.Asserts.ast.fields.equals(fieldsA, fieldsB) // => undefined
    * ```
    */
   static ast = {
@@ -104,13 +104,13 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Example** (Testing make)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const schema = Schema.String
    * const asserts = new TestSchema.Asserts(schema)
-   * await asserts.make().succeed("hello")
+   * await asserts.make().succeed("hello") // => undefined
    * ```
    *
    * @see {@link decoding} for assertions against decoded input
@@ -157,12 +157,12 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Example** (Verifying round trips)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
-   * const asserts = new TestSchema.Asserts(Schema.NumberFromString)
-   * await asserts.verifyLosslessTransformation()
+   * const asserts = new TestSchema.Asserts(Schema.String)
+   * await asserts.verifyLosslessTransformation({ params: { seed: 1, numRuns: 20 } }) // => undefined
    * ```
    *
    * @see {@link arbitrary} for checking that generated values satisfy the schema
@@ -200,14 +200,14 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Example** (Decoding assertions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.NumberFromString)
    * const decoding = asserts.decoding()
-   * await decoding.succeed("42", 42)
-   * await decoding.fail(null, "Expected string, got null")
+   * await decoding.succeed("42", 42) // => undefined
+   * await decoding.fail(null, "Expected string") // => undefined
    * ```
    *
    * @see {@link Decoding}
@@ -231,13 +231,13 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Example** (Encoding assertions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.NumberFromString)
    * const encoding = asserts.encoding()
-   * await encoding.succeed(42, "42")
+   * await encoding.succeed(42, "42") // => undefined
    * ```
    *
    * @see {@link Encoding}
@@ -262,12 +262,12 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Example** (Verifying arbitrary generation)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.String)
-   * asserts.arbitrary().verifyGeneration()
+   * asserts.arbitrary().verifyGeneration({ params: { seed: 1, numRuns: 20 } }) // => undefined
    * ```
    *
    * @see {@link verifyLosslessTransformation} for property-based round-trip checks
@@ -300,13 +300,13 @@ export class Asserts<S extends Schema.Constraint> {
  *
  * **Example** (Decoding with service provision)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { TestSchema } from "effect/testing"
  *
  * const asserts = new TestSchema.Asserts(Schema.String)
  * const decoding = asserts.decoding()
- * await decoding.succeed("hello")
+ * await decoding.succeed("hello") // => undefined
  * ```
  *
  * @see {@link Asserts}
@@ -341,12 +341,12 @@ export class Decoding<S extends Schema.Constraint> {
    *
    * **Example** (Testing identity and transformed decoding)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const decoding = new TestSchema.Asserts(Schema.NumberFromString).decoding()
-   * await decoding.succeed("1", 1) // transformed
+   * await decoding.succeed("1", 1) // => undefined
    * ```
    *
    * @see {@link fail} for asserting decoding failures
@@ -384,12 +384,12 @@ export class Decoding<S extends Schema.Constraint> {
    *
    * **Example** (Asserting a decoding failure)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const decoding = new TestSchema.Asserts(Schema.String).decoding()
-   * await decoding.fail(42, "Expected string, got 42")
+   * await decoding.fail(42, "Expected string") // => undefined
    * ```
    *
    * @see {@link succeed} for asserting successful decoding
@@ -440,12 +440,12 @@ export class Decoding<S extends Schema.Constraint> {
  *
  * **Example** (Encoding assertions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import { TestSchema } from "effect/testing"
  *
  * const encoding = new TestSchema.Asserts(Schema.NumberFromString).encoding()
- * await encoding.succeed(42, "42")
+ * await encoding.succeed(42, "42") // => undefined
  * ```
  *
  * @see {@link Asserts}
@@ -481,12 +481,12 @@ export class Encoding<S extends Schema.Constraint> {
    *
    * **Example** (Testing identity and transformed encoding)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const encoding = new TestSchema.Asserts(Schema.NumberFromString).encoding()
-   * await encoding.succeed(1, "1") // transformed
+   * await encoding.succeed(1, "1") // => undefined
    * ```
    *
    * @see {@link fail} for asserting encoding failures
@@ -524,12 +524,12 @@ export class Encoding<S extends Schema.Constraint> {
    *
    * **Example** (Asserting an encoding failure)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    * import { TestSchema } from "effect/testing"
    *
    * const encoding = new TestSchema.Asserts(Schema.NumberFromString).encoding()
-   * await encoding.fail("not-a-number", "Expected number, got \"not-a-number\"")
+   * await encoding.fail("not-a-number", "Expected number") // => undefined
    * ```
    *
    * @see {@link succeed} for asserting successful encoding