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

package/dist/DateTime.d.ts

@@ -313,21 +313,21 @@ export declare namespace TimeZone {
  *
  * **Example** (Resolving ambiguous local times)
  *
- * ```ts
- * import { DateTime } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime, Option } from "effect"
  *
  * // Fall-back example: 01:30 on Nov 2, 2025 in New York happens twice
- * const ambiguousTime = { year: 2025, month: 11, day: 2, hours: 1, minutes: 30 }
+ * const ambiguousTime = { year: 2025, month: 11, day: 2, hour: 1, minute: 30 }
  * const timeZone = DateTime.zoneMakeNamedUnsafe("America/New_York")
  *
- * DateTime.makeZoned(ambiguousTime, {
+ * const earlier = DateTime.makeZoned(ambiguousTime, {
  *   timeZone,
  *   adjustForTimeZone: true,
  *   disambiguation: "earlier"
  * })
  * // Earlier occurrence (DST time): 2025-11-02T05:30:00.000Z
  *
- * DateTime.makeZoned(ambiguousTime, {
+ * const later = DateTime.makeZoned(ambiguousTime, {
  *   timeZone,
  *   adjustForTimeZone: true,
  *   disambiguation: "later"
@@ -335,21 +335,26 @@ export declare namespace TimeZone {
  * // Later occurrence (standard time): 2025-11-02T06:30:00.000Z
  *
  * // Gap example: 02:30 on Mar 9, 2025 in New York doesn't exist
- * const gapTime = { year: 2025, month: 3, day: 9, hours: 2, minutes: 30 }
+ * const gapTime = { year: 2025, month: 3, day: 9, hour: 2, minute: 30 }
  *
- * DateTime.makeZoned(gapTime, {
+ * const beforeGap = DateTime.makeZoned(gapTime, {
  *   timeZone,
  *   adjustForTimeZone: true,
  *   disambiguation: "earlier"
  * })
  * // Time before gap: 2025-03-09T06:30:00.000Z (01:30 EST)
  *
- * DateTime.makeZoned(gapTime, {
+ * const afterGap = DateTime.makeZoned(gapTime, {
  *   timeZone,
  *   adjustForTimeZone: true,
  *   disambiguation: "later"
  * })
  * // Time after gap: 2025-03-09T07:30:00.000Z (03:30 EDT)
+ *
+ * earlier.pipe(Option.getOrThrow, DateTime.formatIso) // => "2025-11-02T05:30:00.000Z"
+ * later.pipe(Option.getOrThrow, DateTime.formatIso) // => "2025-11-02T06:30:00.000Z"
+ * beforeGap.pipe(Option.getOrThrow, DateTime.formatIso) // => "2025-03-09T06:30:00.000Z"
+ * afterGap.pipe(Option.getOrThrow, DateTime.formatIso) // => "2025-03-09T07:30:00.000Z"
  * ```
  *
  * @category models
@@ -455,7 +460,7 @@ export declare const isZoned: (self: DateTime) => self is Zoned;
  *
  * **Example** (Comparing DateTime values for equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const utc = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
@@ -463,7 +468,7 @@ export declare const isZoned: (self: DateTime) => self is Zoned;
  *   timeZone: "Europe/London"
  * })
  *
- * console.log(DateTime.Equivalence(utc, zoned)) // true
+ * DateTime.Equivalence(utc, zoned) // => true
  * ```
  *
  * @category instances
@@ -480,7 +485,7 @@ export declare const Equivalence: Equ.Equivalence<DateTime>;
  *
  * **Example** (Sorting DateTime values chronologically)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, DateTime } from "effect"
  *
  * const dates = [
@@ -489,8 +494,7 @@ export declare const Equivalence: Equ.Equivalence<DateTime>;
  *   DateTime.makeUnsafe("2024-02-01")
  * ]
  *
- * const sorted = Array.sort(dates, DateTime.Order)
- * // Results in chronological order: 2024-01-01, 2024-02-01, 2024-03-01
+ * Array.sort(dates, DateTime.Order).map(DateTime.formatIsoDateUtc) // => ["2024-01-01", "2024-02-01", "2024-03-01"]
  * ```
  *
  * @category instances
@@ -508,15 +512,14 @@ export declare const Order: order.Order<DateTime>;
  *
  * **Example** (Clamping DateTime values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const min = DateTime.makeUnsafe("2024-01-01")
  * const max = DateTime.makeUnsafe("2024-12-31")
  * const date = DateTime.makeUnsafe("2025-06-15")
  *
- * const clamped = DateTime.clamp(date, { minimum: min, maximum: max })
- * // clamped equals max (2024-12-31)
+ * DateTime.clamp(date, { minimum: min, maximum: max }) // => DateTime.makeUnsafe("2024-12-31")
  * ```
  *
  * @category ordering
@@ -534,15 +537,14 @@ export declare const clamp: {
      *
      * **Example** (Clamping DateTime values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const min = DateTime.makeUnsafe("2024-01-01")
      * const max = DateTime.makeUnsafe("2024-12-31")
      * const date = DateTime.makeUnsafe("2025-06-15")
      *
-     * const clamped = DateTime.clamp(date, { minimum: min, maximum: max })
-     * // clamped equals max (2024-12-31)
+     * DateTime.clamp(date, { minimum: min, maximum: max }) // => DateTime.makeUnsafe("2024-12-31")
      * ```
      *
      * @category ordering
@@ -563,15 +565,14 @@ export declare const clamp: {
      *
      * **Example** (Clamping DateTime values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const min = DateTime.makeUnsafe("2024-01-01")
      * const max = DateTime.makeUnsafe("2024-12-31")
      * const date = DateTime.makeUnsafe("2025-06-15")
      *
-     * const clamped = DateTime.clamp(date, { minimum: min, maximum: max })
-     * // clamped equals max (2024-12-31)
+     * DateTime.clamp(date, { minimum: min, maximum: max }) // => DateTime.makeUnsafe("2024-12-31")
      * ```
      *
      * @category ordering
@@ -591,13 +592,10 @@ export declare const clamp: {
  *
  * **Example** (Creating DateTime values from Dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
- * const date = new Date("2024-01-01T12:00:00Z")
- * const dateTime = DateTime.fromDateUnsafe(date)
- *
- * console.log(DateTime.formatIso(dateTime)) // "2024-01-01T12:00:00.000Z"
+ * DateTime.fromDateUnsafe(new Date("2024-01-01T12:00:00Z")) // => DateTime.makeUnsafe("2024-01-01T12:00:00Z")
  * ```
  *
  * @category constructors
@@ -622,26 +620,38 @@ export declare const fromDateUnsafe: (date: Date) => Utc;
  *
  * **Example** (Creating DateTime values unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // from Date
- * const fromDate = DateTime.makeUnsafe(new Date("2024-01-01T12:00:00Z"))
- * console.log(DateTime.formatIso(fromDate)) // "2024-01-01T12:00:00.000Z"
+ * DateTime.makeUnsafe(new Date("2024-01-01T12:00:00Z")) // => DateTime.makeUnsafe("2024-01-01T12:00:00Z")
  *
  * // from parts
- * const fromParts = DateTime.makeUnsafe({ year: 2024 })
- * console.log(DateTime.formatIso(fromParts)) // "2024-01-01T00:00:00.000Z"
+ * DateTime.makeUnsafe({ year: 2024 }) // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
  *
  * // from string
- * const fromString = DateTime.makeUnsafe("2024-01-01")
- * console.log(DateTime.formatIso(fromString)) // "2024-01-01T00:00:00.000Z"
+ * DateTime.makeUnsafe("2024-01-01") // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
 export declare const makeUnsafe: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone<A>;
+/**
+ * Creates a `DateTime.Utc` from the number of seconds since the Unix epoch.
+ *
+ * **Example** (Creating from epoch seconds)
+ *
+ * ```ts import.meta.vitest
+ * import { DateTime } from "effect"
+ *
+ * DateTime.fromEpochSeconds(1704067200).toJSON() // => "2024-01-01T00:00:00.000Z"
+ * ```
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromEpochSeconds: (seconds: number) => Utc;
 /**
  * Create a `DateTime.Zoned` using `DateTime.makeUnsafe` and a time zone.
  *
@@ -665,14 +675,14 @@ export declare const makeUnsafe: <A extends DateTime.Input>(input: A) => DateTim
  *
  * **Example** (Creating zoned DateTime values unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
  *   timeZone: "Europe/London"
  * })
  *
- * console.log(DateTime.formatIsoZoned(zoned)) // "2024-06-15T15:30:00.000+01:00[Europe/London]"
+ * DateTime.formatIsoZoned(zoned) // => "2024-06-15T15:30:00.000+01:00[Europe/London]"
  * ```
  *
  * @category constructors
@@ -706,17 +716,14 @@ export declare const makeZonedUnsafe: (input: DateTime.Input, options?: {
  *
  * **Example** (Creating optional zoned DateTime values)
  *
- * ```ts
- * import { DateTime } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime, Option } from "effect"
  *
  * const result = DateTime.makeZoned("2024-06-15T14:30:00Z", {
  *   timeZone: "Europe/London"
  * })
  *
- * console.log(result._tag) // "Some"
- * if (result._tag === "Some") {
- *   console.log(DateTime.formatIsoZoned(result.value)) // "2024-06-15T15:30:00.000+01:00[Europe/London]"
- * }
+ * result.pipe(Option.map(DateTime.formatIsoZoned)) // => Option.some("2024-06-15T15:30:00.000+01:00[Europe/London]")
  * ```
  *
  * @category constructors
@@ -744,23 +751,19 @@ export declare const makeZoned: (input: DateTime.Input, options?: {
  *
  * **Example** (Creating optional DateTime values)
  *
- * ```ts
- * import { DateTime } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime, Option } from "effect"
  *
  * // from Date
- * const fromDate = DateTime.make(new Date("2024-01-01T12:00:00Z"))
- * console.log(fromDate._tag) // "Some"
+ * DateTime.make(new Date("2024-01-01T12:00:00Z")) // => Option.some(DateTime.makeUnsafe("2024-01-01T12:00:00Z"))
  *
  * // from parts
- * const fromParts = DateTime.make({ year: 2024 })
- * console.log(fromParts._tag) // "Some"
+ * DateTime.make({ year: 2024 }) // => Option.some(DateTime.makeUnsafe("2024-01-01T00:00:00Z"))
  *
  * // from string
- * const fromString = DateTime.make("2024-01-01")
- * console.log(fromString._tag) // "Some"
+ * DateTime.make("2024-01-01") // => Option.some(DateTime.makeUnsafe("2024-01-01T00:00:00Z"))
  *
- * const invalid = DateTime.make("not a date")
- * console.log(invalid._tag) // "None"
+ * DateTime.make("not a date") // => Option.none()
  * ```
  *
  * @category constructors
@@ -779,19 +782,15 @@ export declare const make: <A extends DateTime.Input>(input: A) => Option.Option
  *
  * **Example** (Parsing zoned DateTime strings)
  *
- * ```ts
- * import { DateTime } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime, Option } from "effect"
  *
- * const result1 = DateTime.makeZonedFromString(
+ * DateTime.makeZonedFromString(
  *   "2024-01-01T12:00:00+02:00[Europe/Berlin]"
- * )
- * console.log(result1._tag === "Some") // true
- *
- * const result2 = DateTime.makeZonedFromString("2024-01-01T12:00:00Z")
- * console.log(result2._tag === "Some") // true
+ * ).pipe(Option.map(DateTime.formatIsoZoned)) // => Option.some("2024-01-01T11:00:00.000+01:00[Europe/Berlin]")
  *
- * const invalid = DateTime.makeZonedFromString("invalid")
- * console.log(invalid._tag === "None") // true
+ * DateTime.makeZonedFromString("2024-01-01T12:00:00Z") // => Option.none()
+ * DateTime.makeZonedFromString("invalid") // => Option.none()
  * ```
  *
  * @category constructors
@@ -799,17 +798,15 @@ export declare const make: <A extends DateTime.Input>(input: A) => Option.Option
  */
 export declare const makeZonedFromString: (input: string) => Option.Option<Zoned>;
 /**
- * Gets the current time using the `Clock` service and convert it to a `DateTime`.
+ * Gets the current time using the `Clock` service and converts it to a `DateTime`.
  *
  * **Example** (Getting the current DateTime)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
+ * import { TestClock } from "effect/testing"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.nowAsDate
- *   console.log(now instanceof Date) // true
- * })
+ * await Effect.runPromise(Effect.map(DateTime.now, DateTime.isDateTime)) // => true
  * ```
  *
  * @category constructors
@@ -822,12 +819,11 @@ export declare const now: Effect.Effect<Utc>;
  *
  * **Example** (Getting the current Date)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
+ * import { TestClock } from "effect/testing"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- * })
+ * await Effect.runPromise(Effect.map(DateTime.nowAsDate, (now) => now instanceof Date)) // => true
  * ```
  *
  * @category constructors
@@ -849,11 +845,10 @@ export declare const nowAsDate: Effect.Effect<Date>;
  *
  * **Example** (Getting the current DateTime unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
- * const now = DateTime.nowUnsafe()
- * console.log(DateTime.formatIso(now))
+ * Number.isFinite(DateTime.toEpochMillis(DateTime.nowUnsafe())) // => true
  * ```
  *
  * @category constructors
@@ -874,7 +869,7 @@ export declare const nowUnsafe: LazyArg<Utc>;
  *
  * **Example** (Converting DateTime values to UTC)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const now = DateTime.makeZonedUnsafe({ year: 2024 }, {
@@ -883,9 +878,10 @@ export declare const nowUnsafe: LazyArg<Utc>;
  *
  * // set as UTC
  * const utc: DateTime.Utc = DateTime.toUtc(now)
+ * utc // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
  * ```
  *
- * @category time zones
+ * @category converting
  * @since 3.13.0
  */
 export declare const toUtc: (self: DateTime) => Utc;
@@ -894,19 +890,16 @@ export declare const toUtc: (self: DateTime) => Utc;
  *
  * **Example** (Setting time zones)
  *
- * ```ts
- * import { DateTime, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime } from "effect"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- *   const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
+ * const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
+ * const zoned: DateTime.Zoned = DateTime.setZone(DateTime.makeUnsafe("2024-01-01"), zone)
  *
- *   // set the time zone
- *   const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
- * })
+ * DateTime.isZoned(zoned) // => true
  * ```
  *
- * @category time zones
+ * @category transforming
  * @since 3.6.0
  */
 export declare const setZone: {
@@ -915,19 +908,16 @@ export declare const setZone: {
      *
      * **Example** (Setting time zones)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
+     * const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
+     * const zoned: DateTime.Zoned = DateTime.setZone(DateTime.makeUnsafe("2024-01-01"), zone)
      *
-     *   // set the time zone
-     *   const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
-     * })
+     * DateTime.isZoned(zoned) // => true
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 3.6.0
      */
     (zone: TimeZone, options?: {
@@ -939,19 +929,16 @@ export declare const setZone: {
      *
      * **Example** (Setting time zones)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
+     * const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
+     * const zoned: DateTime.Zoned = DateTime.setZone(DateTime.makeUnsafe("2024-01-01"), zone)
      *
-     *   // set the time zone
-     *   const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
-     * })
+     * DateTime.isZoned(zoned) // => true
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 3.6.0
      */
     (self: DateTime, zone: TimeZone, options?: {
@@ -968,18 +955,16 @@ export declare const setZone: {
  *
  * **Example** (Setting fixed-offset time zones)
  *
- * ```ts
- * import { DateTime, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime } from "effect"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
+ * const dateTime = DateTime.makeUnsafe("2024-01-01")
+ * const zoned: DateTime.Zoned = DateTime.setZoneOffset(dateTime, 3 * 60 * 60 * 1000)
  *
- *   // set the offset time zone in milliseconds
- *   const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
- * })
+ * DateTime.zoneToString(zoned.zone) // => "+03:00"
  * ```
  *
- * @category time zones
+ * @category transforming
  * @since 3.6.0
  */
 export declare const setZoneOffset: {
@@ -992,18 +977,16 @@ export declare const setZoneOffset: {
      *
      * **Example** (Setting fixed-offset time zones)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
+     * const dateTime = DateTime.makeUnsafe("2024-01-01")
+     * const zoned: DateTime.Zoned = DateTime.setZoneOffset(dateTime, 3 * 60 * 60 * 1000)
      *
-     *   // set the offset time zone in milliseconds
-     *   const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
-     * })
+     * DateTime.zoneToString(zoned.zone) // => "+03:00"
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 3.6.0
      */
     (offset: number, options?: {
@@ -1019,18 +1002,16 @@ export declare const setZoneOffset: {
      *
      * **Example** (Setting fixed-offset time zones)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
+     * const dateTime = DateTime.makeUnsafe("2024-01-01")
+     * const zoned: DateTime.Zoned = DateTime.setZoneOffset(dateTime, 3 * 60 * 60 * 1000)
      *
-     *   // set the offset time zone in milliseconds
-     *   const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
-     * })
+     * DateTime.zoneToString(zoned.zone) // => "+03:00"
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 3.6.0
      */
     (self: DateTime, offset: number, options?: {
@@ -1052,20 +1033,17 @@ export declare const setZoneOffset: {
  *
  * **Example** (Creating named time zones unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
- * const londonZone = DateTime.zoneMakeNamedUnsafe("Europe/London")
- * console.log(DateTime.zoneToString(londonZone)) // "Europe/London"
- *
- * const tokyoZone = DateTime.zoneMakeNamedUnsafe("Asia/Tokyo")
- * console.log(DateTime.zoneToString(tokyoZone)) // "Asia/Tokyo"
+ * DateTime.zoneToString(DateTime.zoneMakeNamedUnsafe("Europe/London")) // => "Europe/London"
+ * DateTime.zoneToString(DateTime.zoneMakeNamedUnsafe("Asia/Tokyo")) // => "Asia/Tokyo"
  *
  * // This would throw an IllegalArgumentError:
  * // DateTime.zoneMakeNamedUnsafe("Invalid/Zone")
  * ```
  *
- * @category time zones
+ * @category constructors
  * @since 4.0.0
  */
 export declare const zoneMakeNamedUnsafe: (zoneId: string) => TimeZone.Named;
@@ -1079,7 +1057,7 @@ export declare const zoneMakeNamedUnsafe: (zoneId: string) => TimeZone.Named;
  *
  * **Example** (Creating fixed-offset time zones)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // Create a time zone with +3 hours offset
@@ -1088,9 +1066,10 @@ export declare const zoneMakeNamedUnsafe: (zoneId: string) => TimeZone.Named;
  * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
  *   timeZone: zone
  * })
+ * DateTime.formatIsoZoned(dt) // => "2024-01-01T15:00:00.000+03:00"
  * ```
  *
- * @category time zones
+ * @category constructors
  * @since 3.6.0
  */
 export declare const zoneMakeOffset: (offset: number) => TimeZone.Offset;
@@ -1103,17 +1082,14 @@ export declare const zoneMakeOffset: (offset: number) => TimeZone.Offset;
  *
  * **Example** (Creating optional named time zones)
  *
- * ```ts
- * import { DateTime } from "effect"
- *
- * const validZone = DateTime.zoneMakeNamed("Europe/London")
- * console.log(validZone._tag === "Some") // true
+ * ```ts import.meta.vitest
+ * import { DateTime, Option } from "effect"
  *
- * const invalidZone = DateTime.zoneMakeNamed("Invalid/Zone")
- * console.log(invalidZone._tag === "None") // true
+ * DateTime.zoneMakeNamed("Europe/London").pipe(Option.map(DateTime.zoneToString)) // => Option.some("Europe/London")
+ * DateTime.zoneMakeNamed("Invalid/Zone") // => Option.none()
  * ```
  *
- * @category time zones
+ * @category constructors
  * @since 3.6.0
  */
 export declare const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named>;
@@ -1127,7 +1103,7 @@ export declare const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.N
  *
  * **Example** (Creating named time zones effectfully)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1135,9 +1111,11 @@ export declare const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.N
  *   const now = yield* DateTime.now
  *   return DateTime.setZone(now, zone)
  * })
+ *
+ * DateTime.zoneToString((await Effect.runPromise(program)).zone) // => "Europe/London"
  * ```
  *
- * @category time zones
+ * @category constructors
  * @since 3.6.0
  */
 export declare const zoneMakeNamedEffect: (zoneId: string) => Effect.Effect<TimeZone.Named, IllegalArgumentError>;
@@ -1151,14 +1129,13 @@ export declare const zoneMakeNamedEffect: (zoneId: string) => Effect.Effect<Time
  *
  * **Example** (Creating local time zones)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
- * const localZone = DateTime.zoneMakeLocal()
- * console.log(DateTime.zoneToString(localZone)) // Output depends on system time zone
+ * DateTime.isTimeZoneNamed(DateTime.zoneMakeLocal()) // => true
  * ```
  *
- * @category time zones
+ * @category constructors
  * @since 3.6.0
  */
 export declare const zoneMakeLocal: () => TimeZone.Named;
@@ -1171,19 +1148,15 @@ export declare const zoneMakeLocal: () => TimeZone.Named;
  *
  * **Example** (Parsing time zones)
  *
- * ```ts
- * import { DateTime } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime, Option } from "effect"
  *
- * const namedZone = DateTime.zoneFromString("Europe/London")
- * const offsetZone = DateTime.zoneFromString("+03:00")
- * const invalid = DateTime.zoneFromString("invalid")
- *
- * console.log(namedZone._tag === "Some") // true
- * console.log(offsetZone._tag === "Some") // true
- * console.log(invalid._tag === "None") // true
+ * DateTime.zoneFromString("Europe/London").pipe(Option.map(DateTime.zoneToString)) // => Option.some("Europe/London")
+ * DateTime.zoneFromString("+03:00").pipe(Option.map(DateTime.zoneToString)) // => Option.some("+03:00")
+ * DateTime.zoneFromString("invalid") // => Option.none()
  * ```
  *
- * @category time zones
+ * @category decoding
  * @since 3.6.0
  */
 export declare const zoneFromString: (zone: string) => Option.Option<TimeZone>;
@@ -1192,17 +1165,14 @@ export declare const zoneFromString: (zone: string) => Option.Option<TimeZone>;
  *
  * **Example** (Formatting time zones)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
- * // Outputs "+03:00"
- * DateTime.zoneToString(DateTime.zoneMakeOffset(3 * 60 * 60 * 1000))
- *
- * // Outputs "Europe/London"
- * DateTime.zoneToString(DateTime.zoneMakeNamedUnsafe("Europe/London"))
+ * DateTime.zoneToString(DateTime.zoneMakeOffset(3 * 60 * 60 * 1000)) // => "+03:00"
+ * DateTime.zoneToString(DateTime.zoneMakeNamedUnsafe("Europe/London")) // => "Europe/London"
  * ```
  *
- * @category time zones
+ * @category encoding
  * @since 3.6.0
  */
 export declare const zoneToString: (self: TimeZone) => string;
@@ -1212,17 +1182,16 @@ export declare const zoneToString: (self: TimeZone) => string;
  *
  * **Example** (Setting named time zones safely)
  *
- * ```ts
- * import { DateTime, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime, Option } from "effect"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- *   // set the time zone, returns an Option
- *   DateTime.setZoneNamed(now, "Europe/London")
- * })
+ * const dateTime = DateTime.makeUnsafe("2024-01-01")
+ * const result = DateTime.setZoneNamed(dateTime, "Europe/London").pipe(Option.map(DateTime.formatIsoZoned))
+ *
+ * result // => Option.some("2024-01-01T00:00:00.000+00:00[Europe/London]")
  * ```
  *
- * @category time zones
+ * @category transforming
  * @since 3.6.0
  */
 export declare const setZoneNamed: {
@@ -1232,17 +1201,16 @@ export declare const setZoneNamed: {
      *
      * **Example** (Setting named time zones safely)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime, Option } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   // set the time zone, returns an Option
-     *   DateTime.setZoneNamed(now, "Europe/London")
-     * })
+     * const dateTime = DateTime.makeUnsafe("2024-01-01")
+     * const result = DateTime.setZoneNamed(dateTime, "Europe/London").pipe(Option.map(DateTime.formatIsoZoned))
+     *
+     * result // => Option.some("2024-01-01T00:00:00.000+00:00[Europe/London]")
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 3.6.0
      */
     (zoneId: string, options?: {
@@ -1255,17 +1223,16 @@ export declare const setZoneNamed: {
      *
      * **Example** (Setting named time zones safely)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime, Option } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   // set the time zone, returns an Option
-     *   DateTime.setZoneNamed(now, "Europe/London")
-     * })
+     * const dateTime = DateTime.makeUnsafe("2024-01-01")
+     * const result = DateTime.setZoneNamed(dateTime, "Europe/London").pipe(Option.map(DateTime.formatIsoZoned))
+     *
+     * result // => Option.some("2024-01-01T00:00:00.000+00:00[Europe/London]")
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 3.6.0
      */
     (self: DateTime, zoneId: string, options?: {
@@ -1279,17 +1246,16 @@ export declare const setZoneNamed: {
  *
  * **Example** (Setting named time zones unsafely)
  *
- * ```ts
- * import { DateTime, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime } from "effect"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- *   // set the time zone
- *   DateTime.setZoneNamedUnsafe(now, "Europe/London")
- * })
+ * const dateTime = DateTime.makeUnsafe("2024-01-01")
+ * const zoned = DateTime.setZoneNamedUnsafe(dateTime, "Europe/London")
+ *
+ * DateTime.zoneToString(zoned.zone) // => "Europe/London"
  * ```
  *
- * @category time zones
+ * @category transforming
  * @since 4.0.0
  */
 export declare const setZoneNamedUnsafe: {
@@ -1299,17 +1265,16 @@ export declare const setZoneNamedUnsafe: {
      *
      * **Example** (Setting named time zones unsafely)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   // set the time zone
-     *   DateTime.setZoneNamedUnsafe(now, "Europe/London")
-     * })
+     * const dateTime = DateTime.makeUnsafe("2024-01-01")
+     * const zoned = DateTime.setZoneNamedUnsafe(dateTime, "Europe/London")
+     *
+     * DateTime.zoneToString(zoned.zone) // => "Europe/London"
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 4.0.0
      */
     (zoneId: string, options?: {
@@ -1322,17 +1287,16 @@ export declare const setZoneNamedUnsafe: {
      *
      * **Example** (Setting named time zones unsafely)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   // set the time zone
-     *   DateTime.setZoneNamedUnsafe(now, "Europe/London")
-     * })
+     * const dateTime = DateTime.makeUnsafe("2024-01-01")
+     * const zoned = DateTime.setZoneNamedUnsafe(dateTime, "Europe/London")
+     *
+     * DateTime.zoneToString(zoned.zone) // => "Europe/London"
      * ```
      *
-     * @category time zones
+     * @category transforming
      * @since 4.0.0
      */
     (self: DateTime, zoneId: string, options?: {
@@ -1352,16 +1316,13 @@ export declare const setZoneNamedUnsafe: {
  *
  * **Example** (Measuring distance between DateTime values)
  *
- * ```ts
- * import { DateTime, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { DateTime, Duration } from "effect"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- *   const other = DateTime.add(now, { minutes: 1 })
+ * const start = DateTime.makeUnsafe("2024-01-01T00:00:00Z")
+ * const end = DateTime.add(start, { minutes: 1 })
  *
- *   // returns Duration.minutes(1)
- *   DateTime.distance(now, other)
- * })
+ * DateTime.distance(start, end) // => Duration.minutes(1)
  * ```
  *
  * @category comparisons
@@ -1380,16 +1341,13 @@ export declare const distance: {
      *
      * **Example** (Measuring distance between DateTime values)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime, Duration } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   const other = DateTime.add(now, { minutes: 1 })
+     * const start = DateTime.makeUnsafe("2024-01-01T00:00:00Z")
+     * const end = DateTime.add(start, { minutes: 1 })
      *
-     *   // returns Duration.minutes(1)
-     *   DateTime.distance(now, other)
-     * })
+     * DateTime.distance(start, end) // => Duration.minutes(1)
      * ```
      *
      * @category comparisons
@@ -1408,16 +1366,13 @@ export declare const distance: {
      *
      * **Example** (Measuring distance between DateTime values)
      *
-     * ```ts
-     * import { DateTime, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { DateTime, Duration } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.now
-     *   const other = DateTime.add(now, { minutes: 1 })
+     * const start = DateTime.makeUnsafe("2024-01-01T00:00:00Z")
+     * const end = DateTime.add(start, { minutes: 1 })
      *
-     *   // returns Duration.minutes(1)
-     *   DateTime.distance(now, other)
-     * })
+     * DateTime.distance(start, end) // => Duration.minutes(1)
      * ```
      *
      * @category comparisons
@@ -1430,14 +1385,13 @@ export declare const distance: {
  *
  * **Example** (Selecting the earlier DateTime)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const date1 = DateTime.makeUnsafe("2024-01-01")
  * const date2 = DateTime.makeUnsafe("2024-02-01")
  *
- * const earlier = DateTime.min(date1, date2)
- * // earlier equals date1 (2024-01-01)
+ * DateTime.min(date1, date2) // => DateTime.makeUnsafe("2024-01-01")
  * ```
  *
  * @category comparisons
@@ -1449,14 +1403,13 @@ export declare const min: {
      *
      * **Example** (Selecting the earlier DateTime)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-02-01")
      *
-     * const earlier = DateTime.min(date1, date2)
-     * // earlier equals date1 (2024-01-01)
+     * DateTime.min(date1, date2) // => DateTime.makeUnsafe("2024-01-01")
      * ```
      *
      * @category comparisons
@@ -1468,14 +1421,13 @@ export declare const min: {
      *
      * **Example** (Selecting the earlier DateTime)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-02-01")
      *
-     * const earlier = DateTime.min(date1, date2)
-     * // earlier equals date1 (2024-01-01)
+     * DateTime.min(date1, date2) // => DateTime.makeUnsafe("2024-01-01")
      * ```
      *
      * @category comparisons
@@ -1488,14 +1440,13 @@ export declare const min: {
  *
  * **Example** (Selecting the later DateTime)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const date1 = DateTime.makeUnsafe("2024-01-01")
  * const date2 = DateTime.makeUnsafe("2024-02-01")
  *
- * const later = DateTime.max(date1, date2)
- * // later equals date2 (2024-02-01)
+ * DateTime.max(date1, date2) // => DateTime.makeUnsafe("2024-02-01")
  * ```
  *
  * @category comparisons
@@ -1507,14 +1458,13 @@ export declare const max: {
      *
      * **Example** (Selecting the later DateTime)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-02-01")
      *
-     * const later = DateTime.max(date1, date2)
-     * // later equals date2 (2024-02-01)
+     * DateTime.max(date1, date2) // => DateTime.makeUnsafe("2024-02-01")
      * ```
      *
      * @category comparisons
@@ -1526,14 +1476,13 @@ export declare const max: {
      *
      * **Example** (Selecting the later DateTime)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-02-01")
      *
-     * const later = DateTime.max(date1, date2)
-     * // later equals date2 (2024-02-01)
+     * DateTime.max(date1, date2) // => DateTime.makeUnsafe("2024-02-01")
      * ```
      *
      * @category comparisons
@@ -1546,14 +1495,14 @@ export declare const max: {
  *
  * **Example** (Checking whether a DateTime is later)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const date1 = DateTime.makeUnsafe("2024-02-01")
  * const date2 = DateTime.makeUnsafe("2024-01-01")
  *
- * console.log(DateTime.isGreaterThan(date1, date2)) // true
- * console.log(DateTime.isGreaterThan(date2, date1)) // false
+ * DateTime.isGreaterThan(date1, date2) // => true
+ * DateTime.isGreaterThan(date2, date1) // => false
  * ```
  *
  * @category comparisons
@@ -1565,14 +1514,14 @@ export declare const isGreaterThan: {
      *
      * **Example** (Checking whether a DateTime is later)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-02-01")
      * const date2 = DateTime.makeUnsafe("2024-01-01")
      *
-     * console.log(DateTime.isGreaterThan(date1, date2)) // true
-     * console.log(DateTime.isGreaterThan(date2, date1)) // false
+     * DateTime.isGreaterThan(date1, date2) // => true
+     * DateTime.isGreaterThan(date2, date1) // => false
      * ```
      *
      * @category comparisons
@@ -1584,14 +1533,14 @@ export declare const isGreaterThan: {
      *
      * **Example** (Checking whether a DateTime is later)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-02-01")
      * const date2 = DateTime.makeUnsafe("2024-01-01")
      *
-     * console.log(DateTime.isGreaterThan(date1, date2)) // true
-     * console.log(DateTime.isGreaterThan(date2, date1)) // false
+     * DateTime.isGreaterThan(date1, date2) // => true
+     * DateTime.isGreaterThan(date2, date1) // => false
      * ```
      *
      * @category comparisons
@@ -1604,16 +1553,16 @@ export declare const isGreaterThan: {
  *
  * **Example** (Checking whether a DateTime is later or equal)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const date1 = DateTime.makeUnsafe("2024-01-01")
  * const date2 = DateTime.makeUnsafe("2024-01-01")
  * const date3 = DateTime.makeUnsafe("2024-02-01")
  *
- * console.log(DateTime.isGreaterThanOrEqualTo(date1, date2)) // true
- * console.log(DateTime.isGreaterThanOrEqualTo(date3, date1)) // true
- * console.log(DateTime.isGreaterThanOrEqualTo(date1, date3)) // false
+ * DateTime.isGreaterThanOrEqualTo(date1, date2) // => true
+ * DateTime.isGreaterThanOrEqualTo(date3, date1) // => true
+ * DateTime.isGreaterThanOrEqualTo(date1, date3) // => false
  * ```
  *
  * @category comparisons
@@ -1625,16 +1574,16 @@ export declare const isGreaterThanOrEqualTo: {
      *
      * **Example** (Checking whether a DateTime is later or equal)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-01-01")
      * const date3 = DateTime.makeUnsafe("2024-02-01")
      *
-     * console.log(DateTime.isGreaterThanOrEqualTo(date1, date2)) // true
-     * console.log(DateTime.isGreaterThanOrEqualTo(date3, date1)) // true
-     * console.log(DateTime.isGreaterThanOrEqualTo(date1, date3)) // false
+     * DateTime.isGreaterThanOrEqualTo(date1, date2) // => true
+     * DateTime.isGreaterThanOrEqualTo(date3, date1) // => true
+     * DateTime.isGreaterThanOrEqualTo(date1, date3) // => false
      * ```
      *
      * @category comparisons
@@ -1646,16 +1595,16 @@ export declare const isGreaterThanOrEqualTo: {
      *
      * **Example** (Checking whether a DateTime is later or equal)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-01-01")
      * const date3 = DateTime.makeUnsafe("2024-02-01")
      *
-     * console.log(DateTime.isGreaterThanOrEqualTo(date1, date2)) // true
-     * console.log(DateTime.isGreaterThanOrEqualTo(date3, date1)) // true
-     * console.log(DateTime.isGreaterThanOrEqualTo(date1, date3)) // false
+     * DateTime.isGreaterThanOrEqualTo(date1, date2) // => true
+     * DateTime.isGreaterThanOrEqualTo(date3, date1) // => true
+     * DateTime.isGreaterThanOrEqualTo(date1, date3) // => false
      * ```
      *
      * @category comparisons
@@ -1668,14 +1617,14 @@ export declare const isGreaterThanOrEqualTo: {
  *
  * **Example** (Checking whether a DateTime is earlier)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const date1 = DateTime.makeUnsafe("2024-01-01")
  * const date2 = DateTime.makeUnsafe("2024-02-01")
  *
- * console.log(DateTime.isLessThan(date1, date2)) // true
- * console.log(DateTime.isLessThan(date2, date1)) // false
+ * DateTime.isLessThan(date1, date2) // => true
+ * DateTime.isLessThan(date2, date1) // => false
  * ```
  *
  * @category comparisons
@@ -1687,14 +1636,14 @@ export declare const isLessThan: {
      *
      * **Example** (Checking whether a DateTime is earlier)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-02-01")
      *
-     * console.log(DateTime.isLessThan(date1, date2)) // true
-     * console.log(DateTime.isLessThan(date2, date1)) // false
+     * DateTime.isLessThan(date1, date2) // => true
+     * DateTime.isLessThan(date2, date1) // => false
      * ```
      *
      * @category comparisons
@@ -1706,14 +1655,14 @@ export declare const isLessThan: {
      *
      * **Example** (Checking whether a DateTime is earlier)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-02-01")
      *
-     * console.log(DateTime.isLessThan(date1, date2)) // true
-     * console.log(DateTime.isLessThan(date2, date1)) // false
+     * DateTime.isLessThan(date1, date2) // => true
+     * DateTime.isLessThan(date2, date1) // => false
      * ```
      *
      * @category comparisons
@@ -1726,16 +1675,16 @@ export declare const isLessThan: {
  *
  * **Example** (Checking whether a DateTime is earlier or equal)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const date1 = DateTime.makeUnsafe("2024-01-01")
  * const date2 = DateTime.makeUnsafe("2024-01-01")
  * const date3 = DateTime.makeUnsafe("2024-02-01")
  *
- * console.log(DateTime.isLessThanOrEqualTo(date1, date2)) // true
- * console.log(DateTime.isLessThanOrEqualTo(date1, date3)) // true
- * console.log(DateTime.isLessThanOrEqualTo(date3, date1)) // false
+ * DateTime.isLessThanOrEqualTo(date1, date2) // => true
+ * DateTime.isLessThanOrEqualTo(date1, date3) // => true
+ * DateTime.isLessThanOrEqualTo(date3, date1) // => false
  * ```
  *
  * @category comparisons
@@ -1747,16 +1696,16 @@ export declare const isLessThanOrEqualTo: {
      *
      * **Example** (Checking whether a DateTime is earlier or equal)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-01-01")
      * const date3 = DateTime.makeUnsafe("2024-02-01")
      *
-     * console.log(DateTime.isLessThanOrEqualTo(date1, date2)) // true
-     * console.log(DateTime.isLessThanOrEqualTo(date1, date3)) // true
-     * console.log(DateTime.isLessThanOrEqualTo(date3, date1)) // false
+     * DateTime.isLessThanOrEqualTo(date1, date2) // => true
+     * DateTime.isLessThanOrEqualTo(date1, date3) // => true
+     * DateTime.isLessThanOrEqualTo(date3, date1) // => false
      * ```
      *
      * @category comparisons
@@ -1768,16 +1717,16 @@ export declare const isLessThanOrEqualTo: {
      *
      * **Example** (Checking whether a DateTime is earlier or equal)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const date1 = DateTime.makeUnsafe("2024-01-01")
      * const date2 = DateTime.makeUnsafe("2024-01-01")
      * const date3 = DateTime.makeUnsafe("2024-02-01")
      *
-     * console.log(DateTime.isLessThanOrEqualTo(date1, date2)) // true
-     * console.log(DateTime.isLessThanOrEqualTo(date1, date3)) // true
-     * console.log(DateTime.isLessThanOrEqualTo(date3, date1)) // false
+     * DateTime.isLessThanOrEqualTo(date1, date2) // => true
+     * DateTime.isLessThanOrEqualTo(date1, date3) // => true
+     * DateTime.isLessThanOrEqualTo(date3, date1) // => false
      * ```
      *
      * @category comparisons
@@ -1790,14 +1739,14 @@ export declare const isLessThanOrEqualTo: {
  *
  * **Example** (Checking whether a DateTime is within bounds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const min = DateTime.makeUnsafe("2024-01-01")
  * const max = DateTime.makeUnsafe("2024-12-31")
  * const date = DateTime.makeUnsafe("2024-06-15")
  *
- * console.log(DateTime.between(date, { minimum: min, maximum: max })) // true
+ * DateTime.between(date, { minimum: min, maximum: max }) // => true
  * ```
  *
  * @category comparisons
@@ -1809,14 +1758,14 @@ export declare const between: {
      *
      * **Example** (Checking whether a DateTime is within bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const min = DateTime.makeUnsafe("2024-01-01")
      * const max = DateTime.makeUnsafe("2024-12-31")
      * const date = DateTime.makeUnsafe("2024-06-15")
      *
-     * console.log(DateTime.between(date, { minimum: min, maximum: max })) // true
+     * DateTime.between(date, { minimum: min, maximum: max }) // => true
      * ```
      *
      * @category comparisons
@@ -1831,14 +1780,14 @@ export declare const between: {
      *
      * **Example** (Checking whether a DateTime is within bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const min = DateTime.makeUnsafe("2024-01-01")
      * const max = DateTime.makeUnsafe("2024-12-31")
      * const date = DateTime.makeUnsafe("2024-06-15")
      *
-     * console.log(DateTime.between(date, { minimum: min, maximum: max })) // true
+     * DateTime.between(date, { minimum: min, maximum: max }) // => true
      * ```
      *
      * @category comparisons
@@ -1858,14 +1807,12 @@ export declare const between: {
  *
  * **Example** (Checking future DateTime values effectfully)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
+ * import { TestClock } from "effect/testing"
  *
- * const program = Effect.gen(function*() {
- *   const futureDate = DateTime.add(yield* DateTime.now, { hours: 1 })
- *   const isFuture = yield* DateTime.isFuture(futureDate)
- *   console.log(isFuture) // true
- * })
+ * const futureDate = DateTime.makeUnsafe(1)
+ * await Effect.runPromise(Effect.provide(DateTime.isFuture(futureDate), TestClock.layer())) // => true
  * ```
  *
  * @category comparisons
@@ -1889,11 +1836,8 @@ export declare const isFuture: (self: DateTime) => Effect.Effect<boolean>;
  * ```ts
  * import { DateTime } from "effect"
  *
- * const now = DateTime.nowUnsafe()
- * const futureDate = DateTime.add(now, { hours: 1 })
- *
- * console.log(DateTime.isFutureUnsafe(futureDate)) // true
- * console.log(DateTime.isFutureUnsafe(now)) // false
+ * const oneHourFromNow = DateTime.add(DateTime.nowUnsafe(), { hours: 1 })
+ * DateTime.isFutureUnsafe(oneHourFromNow)
  * ```
  *
  * @category comparisons
@@ -1909,14 +1853,12 @@ export declare const isFutureUnsafe: (self: DateTime) => boolean;
  *
  * **Example** (Checking past DateTime values effectfully)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
+ * import { TestClock } from "effect/testing"
  *
- * const program = Effect.gen(function*() {
- *   const pastDate = DateTime.subtract(yield* DateTime.now, { hours: 1 })
- *   const isPast = yield* DateTime.isPast(pastDate)
- *   console.log(isPast) // true
- * })
+ * const pastDate = DateTime.makeUnsafe(-1)
+ * await Effect.runPromise(Effect.provide(DateTime.isPast(pastDate), TestClock.layer())) // => true
  * ```
  *
  * @category comparisons
@@ -1940,11 +1882,8 @@ export declare const isPast: (self: DateTime) => Effect.Effect<boolean>;
  * ```ts
  * import { DateTime } from "effect"
  *
- * const now = DateTime.nowUnsafe()
- * const pastDate = DateTime.subtract(now, { hours: 1 })
- *
- * console.log(DateTime.isPastUnsafe(pastDate)) // true
- * console.log(DateTime.isPastUnsafe(now)) // false
+ * const oneHourAgo = DateTime.subtract(DateTime.nowUnsafe(), { hours: 1 })
+ * DateTime.isPastUnsafe(oneHourAgo)
  * ```
  *
  * @category comparisons
@@ -1960,15 +1899,14 @@ export declare const isPastUnsafe: (self: DateTime) => boolean;
  *
  * **Example** (Converting DateTime values to UTC Dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
  *   timeZone: "Europe/London"
  * })
  *
- * const utcDate = DateTime.toDateUtc(dt)
- * console.log(utcDate.toISOString()) // "2024-01-01T12:00:00.000Z"
+ * DateTime.toDateUtc(dt).toISOString() // => "2024-01-01T12:00:00.000Z"
  * ```
  *
  * @category converting
@@ -1985,7 +1923,7 @@ export declare const toDateUtc: (self: DateTime) => Date;
  *
  * **Example** (Converting DateTime values to Dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const utc = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
@@ -1993,8 +1931,8 @@ export declare const toDateUtc: (self: DateTime) => Date;
  *   timeZone: "Europe/London"
  * })
  *
- * console.log(DateTime.toDate(utc).toISOString())
- * console.log(DateTime.toDate(zoned).toISOString())
+ * DateTime.toDate(utc).toISOString() // => "2024-01-01T12:00:00.000Z"
+ * DateTime.toDate(zoned).toISOString() // => "2024-01-01T12:00:00.000Z"
  * ```
  *
  * @category converting
@@ -2011,15 +1949,14 @@ export declare const toDate: (self: DateTime) => Date;
  *
  * **Example** (Reading zoned offsets)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
  *   timeZone: "Europe/London"
  * })
  *
- * const offset = DateTime.zonedOffset(zoned)
- * console.log(offset) // 0 (London is UTC+0 in winter)
+ * DateTime.zonedOffset(zoned) // => 0
  * ```
  *
  * @category converting
@@ -2035,15 +1972,14 @@ export declare const zonedOffset: (self: Zoned) => number;
  *
  * **Example** (Formatting zoned offsets)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
  *   timeZone: DateTime.zoneMakeOffset(3 * 60 * 60 * 1000) // +3 hours
  * })
  *
- * const offsetString = DateTime.zonedOffsetIso(zoned)
- * console.log(offsetString) // "+03:00"
+ * DateTime.zonedOffsetIso(zoned) // => "+03:00"
  * ```
  *
  * @category converting
@@ -2059,26 +1995,45 @@ export declare const zonedOffsetIso: (self: Zoned) => string;
  *
  * **Example** (Reading epoch milliseconds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-01-01T00:00:00Z")
- * const epochMillis = DateTime.toEpochMillis(dt)
- *
- * console.log(epochMillis) // 1704067200000
+ * DateTime.toEpochMillis(dt) // => 1704067200000
  * ```
  *
  * @category converting
  * @since 3.6.0
  */
 export declare const toEpochMillis: (self: DateTime) => number;
+/**
+ * Converts a `DateTime` to the number of seconds since the Unix epoch.
+ *
+ * **Details**
+ *
+ * This returns the UTC timestamp regardless of any time zone information.
+ * The result is floored to the nearest second.
+ *
+ * **Example** (Reading epoch seconds)
+ *
+ * ```ts import.meta.vitest
+ * import { DateTime } from "effect"
+ *
+ * const dt = DateTime.makeUnsafe("2024-01-01T00:00:00Z")
+ * DateTime.toEpochSeconds(dt) // => 1704067200
+ * ```
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const toEpochSeconds: (self: DateTime) => number;
 /**
  * Removes the time aspect of a `DateTime`, first adjusting for the time
  * zone. It will return a `DateTime.Utc` only containing the date.
  *
  * **Example** (Removing time components)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-01T00:00:00Z"
@@ -2088,7 +2043,7 @@ export declare const toEpochMillis: (self: DateTime) => number;
  * }).pipe(
  *   DateTime.removeTime,
  *   DateTime.formatIso
- * )
+ * ) // => "2024-01-01T00:00:00.000Z"
  * ```
  *
  * @category converting
@@ -2104,26 +2059,16 @@ export declare const removeTime: (self: DateTime) => Utc;
  *
  * **Example** (Reading DateTime parts)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-01-01T12:30:45.123Z")
  * const parts = DateTime.toParts(dt)
  *
- * console.log(parts)
- * // {
- * //   year: 2024,
- * //   month: 1,
- * //   day: 1,
- * //   hours: 12,
- * //   minutes: 30,
- * //   seconds: 45,
- * //   millis: 123,
- * //   weekDay: 1 // Monday
- * // }
+ * const selectedParts = [parts.year, parts.month, parts.day, parts.hour] // => [2024, 1, 1, 12]
  * ```
  *
- * @category parts
+ * @category getters
  * @since 3.6.0
  */
 export declare const toParts: (self: DateTime) => DateTime.PartsWithWeekday;
@@ -2136,7 +2081,7 @@ export declare const toParts: (self: DateTime) => DateTime.PartsWithWeekday;
  *
  * **Example** (Reading UTC DateTime parts)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-01-01T12:30:45.123Z", {
@@ -2144,11 +2089,10 @@ export declare const toParts: (self: DateTime) => DateTime.PartsWithWeekday;
  * })
  * const parts = DateTime.toPartsUtc(zoned)
  *
- * console.log(parts)
- * // Always returns UTC parts regardless of time zone
+ * const selectedParts = [parts.year, parts.month, parts.day, parts.hour] // => [2024, 1, 1, 12]
  * ```
  *
- * @category parts
+ * @category getters
  * @since 3.6.0
  */
 export declare const toPartsUtc: (self: DateTime) => DateTime.PartsWithWeekday;
@@ -2161,15 +2105,14 @@ export declare const toPartsUtc: (self: DateTime) => DateTime.PartsWithWeekday;
  *
  * **Example** (Reading UTC DateTime parts by key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dateTime = DateTime.makeUnsafe({ year: 2024 })
- * const year = DateTime.getPartUtc(dateTime, "year")
- * console.log(year) // 2024
+ * DateTime.getPartUtc(dateTime, "year") // => 2024
  * ```
  *
- * @category parts
+ * @category getters
  * @since 3.6.0
  */
 export declare const getPartUtc: {
@@ -2182,15 +2125,14 @@ export declare const getPartUtc: {
      *
      * **Example** (Reading UTC DateTime parts by key)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dateTime = DateTime.makeUnsafe({ year: 2024 })
-     * const year = DateTime.getPartUtc(dateTime, "year")
-     * console.log(year) // 2024
+     * DateTime.getPartUtc(dateTime, "year") // => 2024
      * ```
      *
-     * @category parts
+     * @category getters
      * @since 3.6.0
      */
     (part: keyof DateTime.PartsWithWeekday): (self: DateTime) => number;
@@ -2203,15 +2145,14 @@ export declare const getPartUtc: {
      *
      * **Example** (Reading UTC DateTime parts by key)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dateTime = DateTime.makeUnsafe({ year: 2024 })
-     * const year = DateTime.getPartUtc(dateTime, "year")
-     * console.log(year) // 2024
+     * DateTime.getPartUtc(dateTime, "year") // => 2024
      * ```
      *
-     * @category parts
+     * @category getters
      * @since 3.6.0
      */
     (self: DateTime, part: keyof DateTime.PartsWithWeekday): number;
@@ -2225,17 +2166,16 @@ export declare const getPartUtc: {
  *
  * **Example** (Reading DateTime parts by key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dateTime = DateTime.makeZonedUnsafe({ year: 2024 }, {
  *   timeZone: "Europe/London"
  * })
- * const year = DateTime.getPart(dateTime, "year")
- * console.log(year) // 2024
+ * DateTime.getPart(dateTime, "year") // => 2024
  * ```
  *
- * @category parts
+ * @category getters
  * @since 3.6.0
  */
 export declare const getPart: {
@@ -2248,17 +2188,16 @@ export declare const getPart: {
      *
      * **Example** (Reading DateTime parts by key)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dateTime = DateTime.makeZonedUnsafe({ year: 2024 }, {
      *   timeZone: "Europe/London"
      * })
-     * const year = DateTime.getPart(dateTime, "year")
-     * console.log(year) // 2024
+     * DateTime.getPart(dateTime, "year") // => 2024
      * ```
      *
-     * @category parts
+     * @category getters
      * @since 3.6.0
      */
     (part: keyof DateTime.PartsWithWeekday): (self: DateTime) => number;
@@ -2271,17 +2210,16 @@ export declare const getPart: {
      *
      * **Example** (Reading DateTime parts by key)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dateTime = DateTime.makeZonedUnsafe({ year: 2024 }, {
      *   timeZone: "Europe/London"
      * })
-     * const year = DateTime.getPart(dateTime, "year")
-     * console.log(year) // 2024
+     * DateTime.getPart(dateTime, "year") // => 2024
      * ```
      *
-     * @category parts
+     * @category getters
      * @since 3.6.0
      */
     (self: DateTime, part: keyof DateTime.PartsWithWeekday): number;
@@ -2295,20 +2233,20 @@ export declare const getPart: {
  *
  * **Example** (Updating DateTime parts)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
- * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
+ * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", { timeZone: "UTC" })
  * const updated = DateTime.setParts(dt, {
  *   year: 2025,
  *   month: 6,
  *   day: 15
  * })
  *
- * console.log(DateTime.formatIso(updated)) // "2025-06-15T12:00:00.000Z"
+ * updated // => DateTime.makeZonedUnsafe("2025-06-15T12:00:00Z", { timeZone: "UTC" })
  * ```
  *
- * @category parts
+ * @category transforming
  * @since 3.6.0
  */
 export declare const setParts: {
@@ -2321,20 +2259,20 @@ export declare const setParts: {
      *
      * **Example** (Updating DateTime parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
-     * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
+     * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", { timeZone: "UTC" })
      * const updated = DateTime.setParts(dt, {
      *   year: 2025,
      *   month: 6,
      *   day: 15
      * })
      *
-     * console.log(DateTime.formatIso(updated)) // "2025-06-15T12:00:00.000Z"
+     * updated // => DateTime.makeZonedUnsafe("2025-06-15T12:00:00Z", { timeZone: "UTC" })
      * ```
      *
-     * @category parts
+     * @category transforming
      * @since 3.6.0
      */
     (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => A;
@@ -2347,20 +2285,20 @@ export declare const setParts: {
      *
      * **Example** (Updating DateTime parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
-     * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
+     * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", { timeZone: "UTC" })
      * const updated = DateTime.setParts(dt, {
      *   year: 2025,
      *   month: 6,
      *   day: 15
      * })
      *
-     * console.log(DateTime.formatIso(updated)) // "2025-06-15T12:00:00.000Z"
+     * updated // => DateTime.makeZonedUnsafe("2025-06-15T12:00:00Z", { timeZone: "UTC" })
      * ```
      *
-     * @category parts
+     * @category transforming
      * @since 3.6.0
      */
     <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): A;
@@ -2374,7 +2312,7 @@ export declare const setParts: {
  *
  * **Example** (Updating UTC DateTime parts)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
@@ -2383,10 +2321,10 @@ export declare const setParts: {
  *   hour: 18
  * })
  *
- * console.log(DateTime.formatIso(updated)) // "2025-01-01T18:00:00.000Z"
+ * updated // => DateTime.makeUnsafe("2025-01-01T18:00:00Z")
  * ```
  *
- * @category parts
+ * @category transforming
  * @since 3.6.0
  */
 export declare const setPartsUtc: {
@@ -2399,7 +2337,7 @@ export declare const setPartsUtc: {
      *
      * **Example** (Updating UTC DateTime parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
@@ -2408,10 +2346,10 @@ export declare const setPartsUtc: {
      *   hour: 18
      * })
      *
-     * console.log(DateTime.formatIso(updated)) // "2025-01-01T18:00:00.000Z"
+     * updated // => DateTime.makeUnsafe("2025-01-01T18:00:00Z")
      * ```
      *
-     * @category parts
+     * @category transforming
      * @since 3.6.0
      */
     (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => A;
@@ -2424,7 +2362,7 @@ export declare const setPartsUtc: {
      *
      * **Example** (Updating UTC DateTime parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
@@ -2433,10 +2371,10 @@ export declare const setPartsUtc: {
      *   hour: 18
      * })
      *
-     * console.log(DateTime.formatIso(updated)) // "2025-01-01T18:00:00.000Z"
+     * updated // => DateTime.makeUnsafe("2025-01-01T18:00:00Z")
      * ```
      *
-     * @category parts
+     * @category transforming
      * @since 3.6.0
      */
     <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): A;
@@ -2454,21 +2392,19 @@ declare const CurrentTimeZone_base: Context.ServiceClass<CurrentTimeZone, "effec
  *
  * **Example** (Accessing the current time zone service)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // Access the current time zone service
- *   const zone = yield* DateTime.CurrentTimeZone
- *   console.log(DateTime.zoneToString(zone))
+ *   return DateTime.zoneToString(yield* DateTime.CurrentTimeZone)
  * })
  *
  * // Provide a time zone
  * const layer = DateTime.layerCurrentZoneNamed("Europe/London")
- * Effect.provide(program, layer)
+ * await Effect.runPromise(Effect.provide(program, layer)) // => "Europe/London"
  * ```
  *
- * @category current time zone
+ * @category services
  * @since 3.11.0
  */
 export declare class CurrentTimeZone extends CurrentTimeZone_base {
@@ -2479,18 +2415,16 @@ export declare class CurrentTimeZone extends CurrentTimeZone_base {
  *
  * **Example** (Setting the current time zone)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- *
- *   // set the time zone to "Europe/London"
- *   const zoned = yield* DateTime.setZoneCurrent(now)
- * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+ * await Effect.runPromise(Effect.gen(function*() {
+ *   const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe("2024-01-01"))
+ *   return DateTime.zoneToString(zoned.zone)
+ * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))) // => "Europe/London"
  * ```
  *
- * @category current time zone
+ * @category accessors
  * @since 3.6.0
  */
 export declare const setZoneCurrent: (self: DateTime) => Effect.Effect<Zoned, never, CurrentTimeZone>;
@@ -2499,17 +2433,18 @@ export declare const setZoneCurrent: (self: DateTime) => Effect.Effect<Zoned, ne
  *
  * **Example** (Providing the current time zone)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
  * const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
  *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZone(zone))
+ * await Effect.runPromise(Effect.gen(function*() {
+ *   const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe("2024-01-01"))
+ *   return DateTime.zoneToString(zoned.zone)
+ * }).pipe(DateTime.withCurrentZone(zone))) // => "Europe/London"
  * ```
  *
- * @category current time zone
+ * @category providing services
  * @since 3.6.0
  */
 export declare const withCurrentZone: {
@@ -2518,17 +2453,18 @@ export declare const withCurrentZone: {
      *
      * **Example** (Providing the current time zone)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime, Effect } from "effect"
      *
      * const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.nowInCurrentZone
-     * }).pipe(DateTime.withCurrentZone(zone))
+     * await Effect.runPromise(Effect.gen(function*() {
+     *   const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe("2024-01-01"))
+     *   return DateTime.zoneToString(zoned.zone)
+     * }).pipe(DateTime.withCurrentZone(zone))) // => "Europe/London"
      * ```
      *
-     * @category current time zone
+     * @category providing services
      * @since 3.6.0
      */
     (value: TimeZone): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>;
@@ -2537,17 +2473,18 @@ export declare const withCurrentZone: {
      *
      * **Example** (Providing the current time zone)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime, Effect } from "effect"
      *
      * const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
      *
-     * Effect.gen(function*() {
-     *   const now = yield* DateTime.nowInCurrentZone
-     * }).pipe(DateTime.withCurrentZone(zone))
+     * await Effect.runPromise(Effect.gen(function*() {
+     *   const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe("2024-01-01"))
+     *   return DateTime.zoneToString(zoned.zone)
+     * }).pipe(DateTime.withCurrentZone(zone))) // => "Europe/London"
      * ```
      *
-     * @category current time zone
+     * @category providing services
      * @since 3.6.0
      */
     <A, E, R>(self: Effect.Effect<A, E, R>, value: TimeZone): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>;
@@ -2558,16 +2495,15 @@ export declare const withCurrentZone: {
  *
  * **Example** (Providing the local time zone)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
- * Effect.gen(function*() {
- *   // will use the system's local time zone
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZoneLocal)
+ * await Effect.runPromise(Effect.gen(function*() {
+ *   return DateTime.isZoned(yield* DateTime.nowInCurrentZone)
+ * }).pipe(DateTime.withCurrentZoneLocal)) // => true
  * ```
  *
- * @category current time zone
+ * @category providing services
  * @since 3.6.0
  */
 export declare const withCurrentZoneLocal: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>;
@@ -2576,16 +2512,17 @@ export declare const withCurrentZoneLocal: <A, E, R>(effect: Effect.Effect<A, E,
  *
  * **Example** (Providing a fixed-offset time zone)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
- * Effect.gen(function*() {
- *   const zone = yield* DateTime.CurrentTimeZone
- *   console.log(DateTime.zoneToString(zone)) // "+03:00"
+ * const program = Effect.gen(function*() {
+ *   return DateTime.zoneToString(yield* DateTime.CurrentTimeZone)
  * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
+ *
+ * await Effect.runPromise(program) // => "+03:00"
  * ```
  *
- * @category current time zone
+ * @category providing services
  * @since 3.6.0
  */
 export declare const withCurrentZoneOffset: {
@@ -2594,16 +2531,17 @@ export declare const withCurrentZoneOffset: {
      *
      * **Example** (Providing a fixed-offset time zone)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime, Effect } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const zone = yield* DateTime.CurrentTimeZone
-     *   console.log(DateTime.zoneToString(zone)) // "+03:00"
+     * const program = Effect.gen(function*() {
+     *   return DateTime.zoneToString(yield* DateTime.CurrentTimeZone)
      * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
+     *
+     * await Effect.runPromise(program) // => "+03:00"
      * ```
      *
-     * @category current time zone
+     * @category providing services
      * @since 3.6.0
      */
     (offset: number): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>;
@@ -2612,16 +2550,17 @@ export declare const withCurrentZoneOffset: {
      *
      * **Example** (Providing a fixed-offset time zone)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime, Effect } from "effect"
      *
-     * Effect.gen(function*() {
-     *   const zone = yield* DateTime.CurrentTimeZone
-     *   console.log(DateTime.zoneToString(zone)) // "+03:00"
+     * const program = Effect.gen(function*() {
+     *   return DateTime.zoneToString(yield* DateTime.CurrentTimeZone)
      * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
+     *
+     * await Effect.runPromise(program) // => "+03:00"
      * ```
      *
-     * @category current time zone
+     * @category providing services
      * @since 3.6.0
      */
     <A, E, R>(effect: Effect.Effect<A, E, R>, offset: number): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>;
@@ -2636,16 +2575,16 @@ export declare const withCurrentZoneOffset: {
  *
  * **Example** (Providing a named time zone)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
- * Effect.gen(function*() {
- *   // will use the "Europe/London" time zone
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+ * await Effect.runPromise(Effect.gen(function*() {
+ *   const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe("2024-01-01"))
+ *   return DateTime.zoneToString(zoned.zone)
+ * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))) // => "Europe/London"
  * ```
  *
- * @category current time zone
+ * @category providing services
  * @since 3.6.0
  */
 export declare const withCurrentZoneNamed: {
@@ -2659,16 +2598,16 @@ export declare const withCurrentZoneNamed: {
      *
      * **Example** (Providing a named time zone)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime, Effect } from "effect"
      *
-     * Effect.gen(function*() {
-     *   // will use the "Europe/London" time zone
-     *   const now = yield* DateTime.nowInCurrentZone
-     * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+     * await Effect.runPromise(Effect.gen(function*() {
+     *   const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe("2024-01-01"))
+     *   return DateTime.zoneToString(zoned.zone)
+     * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))) // => "Europe/London"
      * ```
      *
-     * @category current time zone
+     * @category providing services
      * @since 3.6.0
      */
     (zone: string): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | IllegalArgumentError, Exclude<R, CurrentTimeZone>>;
@@ -2682,16 +2621,16 @@ export declare const withCurrentZoneNamed: {
      *
      * **Example** (Providing a named time zone)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime, Effect } from "effect"
      *
-     * Effect.gen(function*() {
-     *   // will use the "Europe/London" time zone
-     *   const now = yield* DateTime.nowInCurrentZone
-     * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+     * await Effect.runPromise(Effect.gen(function*() {
+     *   const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe("2024-01-01"))
+     *   return DateTime.zoneToString(zoned.zone)
+     * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))) // => "Europe/London"
      * ```
      *
-     * @category current time zone
+     * @category providing services
      * @since 3.6.0
      */
     <A, E, R>(effect: Effect.Effect<A, E, R>, zone: string): Effect.Effect<A, E | IllegalArgumentError, Exclude<R, CurrentTimeZone>>;
@@ -2701,16 +2640,15 @@ export declare const withCurrentZoneNamed: {
  *
  * **Example** (Getting the current time in the current zone)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
- * Effect.gen(function*() {
- *   // will use the "Europe/London" time zone
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+ * await Effect.runPromise(Effect.gen(function*() {
+ *   return DateTime.zoneToString((yield* DateTime.nowInCurrentZone).zone)
+ * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))) // => "Europe/London"
  * ```
  *
- * @category current time zone
+ * @category accessors
  * @since 3.6.0
  */
 export declare const nowInCurrentZone: Effect.Effect<Zoned, never, CurrentTimeZone>;
@@ -2731,17 +2669,15 @@ export declare const nowInCurrentZone: Effect.Effect<Zoned, never, CurrentTimeZo
  *
  * **Example** (Mutating DateTime values with Dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
  *
- * const modified = DateTime.mutate(dt, (date) => {
+ * DateTime.mutate(dt, (date) => {
  *   date.setHours(15) // Set to 3 PM
  *   date.setMinutes(30) // Set to 30 minutes
  * })
- *
- * console.log(DateTime.formatIso(modified)) // "2024-01-01T15:30:00.000Z"
  * ```
  *
  * @category mapping
@@ -2765,17 +2701,15 @@ export declare const mutate: {
      *
      * **Example** (Mutating DateTime values with Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
      *
-     * const modified = DateTime.mutate(dt, (date) => {
+     * DateTime.mutate(dt, (date) => {
      *   date.setHours(15) // Set to 3 PM
      *   date.setMinutes(30) // Set to 30 minutes
      * })
-     *
-     * console.log(DateTime.formatIso(modified)) // "2024-01-01T15:30:00.000Z"
      * ```
      *
      * @category mapping
@@ -2801,17 +2735,15 @@ export declare const mutate: {
      *
      * **Example** (Mutating DateTime values with Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
      *
-     * const modified = DateTime.mutate(dt, (date) => {
+     * DateTime.mutate(dt, (date) => {
      *   date.setHours(15) // Set to 3 PM
      *   date.setMinutes(30) // Set to 30 minutes
      * })
-     *
-     * console.log(DateTime.formatIso(modified)) // "2024-01-01T15:30:00.000Z"
      * ```
      *
      * @category mapping
@@ -2831,7 +2763,7 @@ export declare const mutate: {
  *
  * **Example** (Mutating DateTime values with UTC Dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
@@ -2842,7 +2774,7 @@ export declare const mutate: {
  *   date.setUTCHours(18) // Set UTC time to 6 PM
  * })
  *
- * console.log(DateTime.formatIso(modified)) // "2024-01-01T18:00:00.000Z"
+ * modified // => DateTime.makeZonedUnsafe("2024-01-01T18:00:00Z", { timeZone: "Europe/London" })
  * ```
  *
  * @category mapping
@@ -2859,7 +2791,7 @@ export declare const mutateUtc: {
      *
      * **Example** (Mutating DateTime values with UTC Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
@@ -2870,7 +2802,7 @@ export declare const mutateUtc: {
      *   date.setUTCHours(18) // Set UTC time to 6 PM
      * })
      *
-     * console.log(DateTime.formatIso(modified)) // "2024-01-01T18:00:00.000Z"
+     * modified // => DateTime.makeZonedUnsafe("2024-01-01T18:00:00Z", { timeZone: "Europe/London" })
      * ```
      *
      * @category mapping
@@ -2887,7 +2819,7 @@ export declare const mutateUtc: {
      *
      * **Example** (Mutating DateTime values with UTC Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
@@ -2898,7 +2830,7 @@ export declare const mutateUtc: {
      *   date.setUTCHours(18) // Set UTC time to 6 PM
      * })
      *
-     * console.log(DateTime.formatIso(modified)) // "2024-01-01T18:00:00.000Z"
+     * modified // => DateTime.makeZonedUnsafe("2024-01-01T18:00:00Z", { timeZone: "Europe/London" })
      * ```
      *
      * @category mapping
@@ -2912,13 +2844,14 @@ export declare const mutateUtc: {
  *
  * **Example** (Mapping epoch milliseconds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // add 10 milliseconds
- * DateTime.makeUnsafe(0).pipe(
+ * const result = DateTime.makeUnsafe(0).pipe(
  *   DateTime.mapEpochMillis((millis) => millis + 10)
  * )
+ * result // => DateTime.makeUnsafe(10)
  * ```
  *
  * @category mapping
@@ -2931,13 +2864,14 @@ export declare const mapEpochMillis: {
      *
      * **Example** (Mapping epoch milliseconds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // add 10 milliseconds
-     * DateTime.makeUnsafe(0).pipe(
+     * const result = DateTime.makeUnsafe(0).pipe(
      *   DateTime.mapEpochMillis((millis) => millis + 10)
      * )
+     * result // => DateTime.makeUnsafe(10)
      * ```
      *
      * @category mapping
@@ -2950,13 +2884,14 @@ export declare const mapEpochMillis: {
      *
      * **Example** (Mapping epoch milliseconds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // add 10 milliseconds
-     * DateTime.makeUnsafe(0).pipe(
+     * const result = DateTime.makeUnsafe(0).pipe(
      *   DateTime.mapEpochMillis((millis) => millis + 10)
      * )
+     * result // => DateTime.makeUnsafe(10)
      * ```
      *
      * @category mapping
@@ -2976,13 +2911,13 @@ export declare const mapEpochMillis: {
  *
  * **Example** (Applying time zone adjusted Dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // get the time zone adjusted date in milliseconds
  * DateTime.makeZonedUnsafe(0, { timeZone: "Europe/London" }).pipe(
  *   DateTime.withDate((date) => date.getTime())
- * )
+ * ) // => 3600000
  * ```
  *
  * @category mapping
@@ -3001,13 +2936,13 @@ export declare const withDate: {
      *
      * **Example** (Applying time zone adjusted Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // get the time zone adjusted date in milliseconds
      * DateTime.makeZonedUnsafe(0, { timeZone: "Europe/London" }).pipe(
      *   DateTime.withDate((date) => date.getTime())
-     * )
+     * ) // => 3600000
      * ```
      *
      * @category mapping
@@ -3026,13 +2961,13 @@ export declare const withDate: {
      *
      * **Example** (Applying time zone adjusted Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // get the time zone adjusted date in milliseconds
      * DateTime.makeZonedUnsafe(0, { timeZone: "Europe/London" }).pipe(
      *   DateTime.withDate((date) => date.getTime())
-     * )
+     * ) // => 3600000
      * ```
      *
      * @category mapping
@@ -3051,13 +2986,13 @@ export declare const withDate: {
  *
  * **Example** (Applying UTC Dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // get the date in milliseconds
  * DateTime.makeUnsafe(0).pipe(
  *   DateTime.withDateUtc((date) => date.getTime())
- * )
+ * ) // => 0
  * ```
  *
  * @category mapping
@@ -3075,13 +3010,13 @@ export declare const withDateUtc: {
      *
      * **Example** (Applying UTC Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // get the date in milliseconds
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.withDateUtc((date) => date.getTime())
-     * )
+     * ) // => 0
      * ```
      *
      * @category mapping
@@ -3099,13 +3034,13 @@ export declare const withDateUtc: {
      *
      * **Example** (Applying UTC Dates)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // get the date in milliseconds
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.withDateUtc((date) => date.getTime())
-     * )
+     * ) // => 0
      * ```
      *
      * @category mapping
@@ -3118,7 +3053,7 @@ export declare const withDateUtc: {
  *
  * **Example** (Pattern matching DateTime variants)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt1 = DateTime.makeUnsafe("2024-01-01T12:00:00Z") // Utc
@@ -3136,8 +3071,8 @@ export declare const withDateUtc: {
  *   onZoned: (zoned) => `Zoned: ${DateTime.formatIsoZoned(zoned)}`
  * })
  *
- * console.log(result1) // "UTC: 2024-01-01T12:00:00.000Z"
- * console.log(result2) // "Zoned: 2024-06-15T15:30:00.000+01:00[Europe/London]"
+ * result1 // => "UTC: 2024-01-01T12:00:00.000Z"
+ * result2 // => "Zoned: 2024-06-15T15:30:00.000+01:00[Europe/London]"
  * ```
  *
  * @category mapping
@@ -3149,7 +3084,7 @@ export declare const match: {
      *
      * **Example** (Pattern matching DateTime variants)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt1 = DateTime.makeUnsafe("2024-01-01T12:00:00Z") // Utc
@@ -3167,8 +3102,8 @@ export declare const match: {
      *   onZoned: (zoned) => `Zoned: ${DateTime.formatIsoZoned(zoned)}`
      * })
      *
-     * console.log(result1) // "UTC: 2024-01-01T12:00:00.000Z"
-     * console.log(result2) // "Zoned: 2024-06-15T15:30:00.000+01:00[Europe/London]"
+     * result1 // => "UTC: 2024-01-01T12:00:00.000Z"
+     * result2 // => "Zoned: 2024-06-15T15:30:00.000+01:00[Europe/London]"
      * ```
      *
      * @category mapping
@@ -3183,7 +3118,7 @@ export declare const match: {
      *
      * **Example** (Pattern matching DateTime variants)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt1 = DateTime.makeUnsafe("2024-01-01T12:00:00Z") // Utc
@@ -3201,8 +3136,8 @@ export declare const match: {
      *   onZoned: (zoned) => `Zoned: ${DateTime.formatIsoZoned(zoned)}`
      * })
      *
-     * console.log(result1) // "UTC: 2024-01-01T12:00:00.000Z"
-     * console.log(result2) // "Zoned: 2024-06-15T15:30:00.000+01:00[Europe/London]"
+     * result1 // => "UTC: 2024-01-01T12:00:00.000Z"
+     * result2 // => "Zoned: 2024-06-15T15:30:00.000+01:00[Europe/London]"
      * ```
      *
      * @category mapping
@@ -3234,13 +3169,13 @@ export declare const match: {
  *
  * **Example** (Adding durations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // add 5 minutes
  * DateTime.makeUnsafe(0).pipe(
  *   DateTime.addDuration("5 minutes")
- * )
+ * ) // => DateTime.makeUnsafe(300000)
  * ```
  *
  * @see {@link add} for calendar-aware date/time part arithmetic
@@ -3271,13 +3206,13 @@ export declare const addDuration: {
      *
      * **Example** (Adding durations)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // add 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.addDuration("5 minutes")
-     * )
+     * ) // => DateTime.makeUnsafe(300000)
      * ```
      *
      * @see {@link add} for calendar-aware date/time part arithmetic
@@ -3308,13 +3243,13 @@ export declare const addDuration: {
      *
      * **Example** (Adding durations)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // add 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.addDuration("5 minutes")
-     * )
+     * ) // => DateTime.makeUnsafe(300000)
      * ```
      *
      * @see {@link add} for calendar-aware date/time part arithmetic
@@ -3330,13 +3265,13 @@ export declare const addDuration: {
  *
  * **Example** (Subtracting durations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // subtract 5 minutes
  * DateTime.makeUnsafe(0).pipe(
  *   DateTime.subtractDuration("5 minutes")
- * )
+ * ) // => DateTime.makeUnsafe(-300000)
  * ```
  *
  * @category math
@@ -3348,13 +3283,13 @@ export declare const subtractDuration: {
      *
      * **Example** (Subtracting durations)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // subtract 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.subtractDuration("5 minutes")
-     * )
+     * ) // => DateTime.makeUnsafe(-300000)
      * ```
      *
      * @category math
@@ -3366,13 +3301,13 @@ export declare const subtractDuration: {
      *
      * **Example** (Subtracting durations)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // subtract 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.subtractDuration("5 minutes")
-     * )
+     * ) // => DateTime.makeUnsafe(-300000)
      * ```
      *
      * @category math
@@ -3390,13 +3325,13 @@ export declare const subtractDuration: {
  *
  * **Example** (Adding date and time parts)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // add 5 minutes
  * DateTime.makeUnsafe(0).pipe(
  *   DateTime.add({ minutes: 5 })
- * )
+ * ) // => DateTime.makeUnsafe(300000)
  * ```
  *
  * @category math
@@ -3413,13 +3348,13 @@ export declare const add: {
      *
      * **Example** (Adding date and time parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // add 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.add({ minutes: 5 })
-     * )
+     * ) // => DateTime.makeUnsafe(300000)
      * ```
      *
      * @category math
@@ -3436,13 +3371,13 @@ export declare const add: {
      *
      * **Example** (Adding date and time parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // add 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.add({ minutes: 5 })
-     * )
+     * ) // => DateTime.makeUnsafe(300000)
      * ```
      *
      * @category math
@@ -3455,13 +3390,13 @@ export declare const add: {
  *
  * **Example** (Subtracting date and time parts)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // subtract 5 minutes
  * DateTime.makeUnsafe(0).pipe(
  *   DateTime.subtract({ minutes: 5 })
- * )
+ * ) // => DateTime.makeUnsafe(-300000)
  * ```
  *
  * @category math
@@ -3473,13 +3408,13 @@ export declare const subtract: {
      *
      * **Example** (Subtracting date and time parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // subtract 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.subtract({ minutes: 5 })
-     * )
+     * ) // => DateTime.makeUnsafe(-300000)
      * ```
      *
      * @category math
@@ -3491,13 +3426,13 @@ export declare const subtract: {
      *
      * **Example** (Subtracting date and time parts)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // subtract 5 minutes
      * DateTime.makeUnsafe(0).pipe(
      *   DateTime.subtract({ minutes: 5 })
-     * )
+     * ) // => DateTime.makeUnsafe(-300000)
      * ```
      *
      * @category math
@@ -3515,14 +3450,13 @@ export declare const subtract: {
  *
  * **Example** (Rounding down DateTime values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-01T00:00:00Z"
  * DateTime.makeUnsafe("2024-01-01T12:00:00Z").pipe(
  *   DateTime.startOf("day"),
- *   DateTime.formatIso
- * )
+ * ) // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
  * ```
  *
  * @category math
@@ -3539,14 +3473,13 @@ export declare const startOf: {
      *
      * **Example** (Rounding down DateTime values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // returns "2024-01-01T00:00:00Z"
      * DateTime.makeUnsafe("2024-01-01T12:00:00Z").pipe(
      *   DateTime.startOf("day"),
-     *   DateTime.formatIso
-     * )
+     * ) // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
      * ```
      *
      * @category math
@@ -3565,14 +3498,13 @@ export declare const startOf: {
      *
      * **Example** (Rounding down DateTime values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // returns "2024-01-01T00:00:00Z"
      * DateTime.makeUnsafe("2024-01-01T12:00:00Z").pipe(
      *   DateTime.startOf("day"),
-     *   DateTime.formatIso
-     * )
+     * ) // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
      * ```
      *
      * @category math
@@ -3592,14 +3524,13 @@ export declare const startOf: {
  *
  * **Example** (Rounding up DateTime values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-01T23:59:59.999Z"
  * DateTime.makeUnsafe("2024-01-01T12:00:00Z").pipe(
  *   DateTime.endOf("day"),
- *   DateTime.formatIso
- * )
+ * ) // => DateTime.makeUnsafe("2024-01-01T23:59:59.999Z")
  * ```
  *
  * @category math
@@ -3616,14 +3547,13 @@ export declare const endOf: {
      *
      * **Example** (Rounding up DateTime values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // returns "2024-01-01T23:59:59.999Z"
      * DateTime.makeUnsafe("2024-01-01T12:00:00Z").pipe(
      *   DateTime.endOf("day"),
-     *   DateTime.formatIso
-     * )
+     * ) // => DateTime.makeUnsafe("2024-01-01T23:59:59.999Z")
      * ```
      *
      * @category math
@@ -3642,14 +3572,13 @@ export declare const endOf: {
      *
      * **Example** (Rounding up DateTime values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // returns "2024-01-01T23:59:59.999Z"
      * DateTime.makeUnsafe("2024-01-01T12:00:00Z").pipe(
      *   DateTime.endOf("day"),
-     *   DateTime.formatIso
-     * )
+     * ) // => DateTime.makeUnsafe("2024-01-01T23:59:59.999Z")
      * ```
      *
      * @category math
@@ -3669,14 +3598,13 @@ export declare const endOf: {
  *
  * **Example** (Rounding DateTime values to nearest units)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-02T00:00:00Z"
  * DateTime.makeUnsafe("2024-01-01T12:01:00Z").pipe(
  *   DateTime.nearest("day"),
- *   DateTime.formatIso
- * )
+ * ) // => DateTime.makeUnsafe("2024-01-02T00:00:00Z")
  * ```
  *
  * @category math
@@ -3693,14 +3621,13 @@ export declare const nearest: {
      *
      * **Example** (Rounding DateTime values to nearest units)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // returns "2024-01-02T00:00:00Z"
      * DateTime.makeUnsafe("2024-01-01T12:01:00Z").pipe(
      *   DateTime.nearest("day"),
-     *   DateTime.formatIso
-     * )
+     * ) // => DateTime.makeUnsafe("2024-01-02T00:00:00Z")
      * ```
      *
      * @category math
@@ -3719,14 +3646,13 @@ export declare const nearest: {
      *
      * **Example** (Rounding DateTime values to nearest units)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * // returns "2024-01-02T00:00:00Z"
      * DateTime.makeUnsafe("2024-01-01T12:01:00Z").pipe(
      *   DateTime.nearest("day"),
-     *   DateTime.formatIso
-     * )
+     * ) // => DateTime.makeUnsafe("2024-01-02T00:00:00Z")
      * ```
      *
      * @category math
@@ -3750,20 +3676,18 @@ export declare const nearest: {
  *
  * **Example** (Formatting DateTime values with Intl options)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
  *   timeZone: "Europe/London"
  * })
  *
- * const formatted = DateTime.format(dt, {
+ * DateTime.format(dt, {
  *   dateStyle: "full",
  *   timeStyle: "short",
  *   locale: "en-US"
- * })
- *
- * console.log(formatted) // "Saturday, June 15, 2024 at 3:30 PM"
+ * }) // => "Saturday, June 15, 2024 at 3:30 PM"
  * ```
  *
  * @category formatting
@@ -3784,20 +3708,18 @@ export declare const format: {
      *
      * **Example** (Formatting DateTime values with Intl options)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
      *   timeZone: "Europe/London"
      * })
      *
-     * const formatted = DateTime.format(dt, {
+     * DateTime.format(dt, {
      *   dateStyle: "full",
      *   timeStyle: "short",
      *   locale: "en-US"
-     * })
-     *
-     * console.log(formatted) // "Saturday, June 15, 2024 at 3:30 PM"
+     * }) // => "Saturday, June 15, 2024 at 3:30 PM"
      * ```
      *
      * @category formatting
@@ -3820,20 +3742,18 @@ export declare const format: {
      *
      * **Example** (Formatting DateTime values with Intl options)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
      *   timeZone: "Europe/London"
      * })
      *
-     * const formatted = DateTime.format(dt, {
+     * DateTime.format(dt, {
      *   dateStyle: "full",
      *   timeStyle: "short",
      *   locale: "en-US"
-     * })
-     *
-     * console.log(formatted) // "Saturday, June 15, 2024 at 3:30 PM"
+     * }) // => "Saturday, June 15, 2024 at 3:30 PM"
      * ```
      *
      * @category formatting
@@ -3849,21 +3769,19 @@ export declare const format: {
  *
  * **Example** (Formatting DateTime values locally)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-06-15T14:30:00Z")
  *
  * // Uses system local time zone and locale
- * const local = DateTime.formatLocal(dt, {
+ * DateTime.formatLocal(dt, {
  *   year: "numeric",
  *   month: "long",
  *   day: "numeric",
  *   hour: "2-digit",
  *   minute: "2-digit"
  * })
- *
- * console.log(local) // Output depends on system locale/timezone
  * ```
  *
  * @category formatting
@@ -3876,21 +3794,19 @@ export declare const formatLocal: {
      *
      * **Example** (Formatting DateTime values locally)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-06-15T14:30:00Z")
      *
      * // Uses system local time zone and locale
-     * const local = DateTime.formatLocal(dt, {
+     * DateTime.formatLocal(dt, {
      *   year: "numeric",
      *   month: "long",
      *   day: "numeric",
      *   hour: "2-digit",
      *   minute: "2-digit"
      * })
-     *
-     * console.log(local) // Output depends on system locale/timezone
      * ```
      *
      * @category formatting
@@ -3905,21 +3821,19 @@ export declare const formatLocal: {
      *
      * **Example** (Formatting DateTime values locally)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-06-15T14:30:00Z")
      *
      * // Uses system local time zone and locale
-     * const local = DateTime.formatLocal(dt, {
+     * DateTime.formatLocal(dt, {
      *   year: "numeric",
      *   month: "long",
      *   day: "numeric",
      *   hour: "2-digit",
      *   minute: "2-digit"
      * })
-     *
-     * console.log(local) // Output depends on system locale/timezone
      * ```
      *
      * @category formatting
@@ -3938,7 +3852,7 @@ export declare const formatLocal: {
  *
  * **Example** (Formatting DateTime values in UTC)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
@@ -3946,7 +3860,7 @@ export declare const formatLocal: {
  * })
  *
  * // Force UTC formatting regardless of time zone
- * const utcFormatted = DateTime.formatUtc(dt, {
+ * DateTime.formatUtc(dt, {
  *   year: "numeric",
  *   month: "2-digit",
  *   day: "2-digit",
@@ -3954,8 +3868,6 @@ export declare const formatLocal: {
  *   minute: "2-digit",
  *   timeZoneName: "short"
  * })
- *
- * console.log(utcFormatted) // "06/15/2024, 02:30 PM UTC"
  * ```
  *
  * @category formatting
@@ -3971,7 +3883,7 @@ export declare const formatUtc: {
      *
      * **Example** (Formatting DateTime values in UTC)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
@@ -3979,7 +3891,7 @@ export declare const formatUtc: {
      * })
      *
      * // Force UTC formatting regardless of time zone
-     * const utcFormatted = DateTime.formatUtc(dt, {
+     * DateTime.formatUtc(dt, {
      *   year: "numeric",
      *   month: "2-digit",
      *   day: "2-digit",
@@ -3987,8 +3899,6 @@ export declare const formatUtc: {
      *   minute: "2-digit",
      *   timeZoneName: "short"
      * })
-     *
-     * console.log(utcFormatted) // "06/15/2024, 02:30 PM UTC"
      * ```
      *
      * @category formatting
@@ -4006,7 +3916,7 @@ export declare const formatUtc: {
      *
      * **Example** (Formatting DateTime values in UTC)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
@@ -4014,7 +3924,7 @@ export declare const formatUtc: {
      * })
      *
      * // Force UTC formatting regardless of time zone
-     * const utcFormatted = DateTime.formatUtc(dt, {
+     * DateTime.formatUtc(dt, {
      *   year: "numeric",
      *   month: "2-digit",
      *   day: "2-digit",
@@ -4022,8 +3932,6 @@ export declare const formatUtc: {
      *   minute: "2-digit",
      *   timeZoneName: "short"
      * })
-     *
-     * console.log(utcFormatted) // "06/15/2024, 02:30 PM UTC"
      * ```
      *
      * @category formatting
@@ -4048,7 +3956,7 @@ export declare const formatUtc: {
  *
  * **Example** (Formatting DateTime values with custom formatters)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-06-15T14:30:00Z")
@@ -4063,8 +3971,7 @@ export declare const formatUtc: {
  *   timeZone: "Europe/Berlin"
  * })
  *
- * const formatted = DateTime.formatIntl(dt, formatter)
- * console.log(formatted.length > 0) // true
+ * DateTime.formatIntl(dt, formatter).length > 0 // => true
  * ```
  *
  * @see {@link formatUtc} for formatting with options forced to UTC
@@ -4089,7 +3996,7 @@ export declare const formatIntl: {
      *
      * **Example** (Formatting DateTime values with custom formatters)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-06-15T14:30:00Z")
@@ -4104,8 +4011,7 @@ export declare const formatIntl: {
      *   timeZone: "Europe/Berlin"
      * })
      *
-     * const formatted = DateTime.formatIntl(dt, formatter)
-     * console.log(formatted.length > 0) // true
+     * DateTime.formatIntl(dt, formatter).length > 0 // => true
      * ```
      *
      * @see {@link formatUtc} for formatting with options forced to UTC
@@ -4130,7 +4036,7 @@ export declare const formatIntl: {
      *
      * **Example** (Formatting DateTime values with custom formatters)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { DateTime } from "effect"
      *
      * const dt = DateTime.makeUnsafe("2024-06-15T14:30:00Z")
@@ -4145,8 +4051,7 @@ export declare const formatIntl: {
      *   timeZone: "Europe/Berlin"
      * })
      *
-     * const formatted = DateTime.formatIntl(dt, formatter)
-     * console.log(formatted.length > 0) // true
+     * DateTime.formatIntl(dt, formatter).length > 0 // => true
      * ```
      *
      * @see {@link formatUtc} for formatting with options forced to UTC
@@ -4166,16 +4071,15 @@ export declare const formatIntl: {
  *
  * **Example** (Formatting DateTime values as ISO strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
- * const dt = DateTime.makeUnsafe("2024-01-01T12:30:45.123Z")
- * console.log(DateTime.formatIso(dt)) // "2024-01-01T12:30:45.123Z"
+ * DateTime.formatIso(DateTime.makeUnsafe("2024-01-01T12:30:45.123Z")) // => "2024-01-01T12:30:45.123Z"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-01-01T12:30:45.123Z", {
  *   timeZone: "Europe/London"
  * })
- * console.log(DateTime.formatIso(zoned)) // "2024-01-01T12:30:45.123Z"
+ * DateTime.formatIso(zoned) // => "2024-01-01T12:30:45.123Z"
  * ```
  *
  * @category formatting
@@ -4191,16 +4095,16 @@ export declare const formatIso: (self: DateTime) => string;
  *
  * **Example** (Formatting DateTime values as ISO dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-01-01T23:30:00Z")
- * console.log(DateTime.formatIsoDate(dt)) // "2024-01-01"
+ * DateTime.formatIsoDate(dt) // => "2024-01-01"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-01-01T23:30:00Z", {
  *   timeZone: "Pacific/Auckland" // UTC+12/13
  * })
- * console.log(DateTime.formatIsoDate(zoned)) // "2024-01-02" (next day in Auckland)
+ * DateTime.formatIsoDate(zoned) // => "2024-01-02"
  * ```
  *
  * @category formatting
@@ -4216,16 +4120,16 @@ export declare const formatIsoDate: (self: DateTime) => string;
  *
  * **Example** (Formatting DateTime values as UTC ISO dates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const dt = DateTime.makeUnsafe("2024-01-01T23:30:00Z")
- * console.log(DateTime.formatIsoDateUtc(dt)) // "2024-01-01"
+ * DateTime.formatIsoDateUtc(dt) // => "2024-01-01"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-01-01T23:30:00Z", {
  *   timeZone: "Pacific/Auckland"
  * })
- * console.log(DateTime.formatIsoDateUtc(zoned)) // "2024-01-01" (always UTC)
+ * DateTime.formatIsoDateUtc(zoned) // => "2024-01-01"
  * ```
  *
  * @category formatting
@@ -4242,16 +4146,16 @@ export declare const formatIsoDateUtc: (self: DateTime) => string;
  *
  * **Example** (Formatting DateTime values with offsets)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const utc = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
- * console.log(DateTime.formatIsoOffset(utc)) // "2024-01-01T12:00:00.000Z"
+ * DateTime.formatIsoOffset(utc) // => "2024-01-01T12:00:00.000Z"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
  *   timeZone: DateTime.zoneMakeOffset(3 * 60 * 60 * 1000)
  * })
- * console.log(DateTime.formatIsoOffset(zoned)) // "2024-01-01T15:00:00.000+03:00"
+ * DateTime.formatIsoOffset(zoned) // => "2024-01-01T15:00:00.000+03:00"
  * ```
  *
  * @category formatting
@@ -4267,22 +4171,20 @@ export declare const formatIsoOffset: (self: DateTime) => string;
  *
  * **Example** (Formatting zoned DateTime values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime } from "effect"
  *
  * const zoned = DateTime.makeZonedUnsafe("2024-06-15T14:30:45.123Z", {
  *   timeZone: "Europe/London"
  * })
  *
- * const formatted = DateTime.formatIsoZoned(zoned)
- * console.log(formatted) // "2024-06-15T15:30:45.123+01:00[Europe/London]"
+ * DateTime.formatIsoZoned(zoned) // => "2024-06-15T15:30:45.123+01:00[Europe/London]"
  *
  * const offsetZone = DateTime.makeZonedUnsafe("2024-06-15T14:30:45.123Z", {
  *   timeZone: DateTime.zoneMakeOffset(3 * 60 * 60 * 1000)
  * })
  *
- * const offsetFormatted = DateTime.formatIsoZoned(offsetZone)
- * console.log(offsetFormatted) // "2024-06-15T17:30:45.123+03:00"
+ * DateTime.formatIsoZoned(offsetZone) // => "2024-06-15T17:30:45.123+03:00"
  * ```
  *
  * @category formatting
@@ -4298,7 +4200,7 @@ export declare const formatIsoZoned: (self: Zoned) => string;
  *
  * **Example** (Providing current time zone layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
  * const zone = DateTime.zoneMakeNamedUnsafe("Europe/London")
@@ -4306,14 +4208,14 @@ export declare const formatIsoZoned: (self: Zoned) => string;
  *
  * const program = Effect.gen(function*() {
  *   const now = yield* DateTime.nowInCurrentZone
- *   return DateTime.formatIsoZoned(now)
+ *   return DateTime.zoneToString(now.zone)
  * })
  *
  * // Use the layer to provide the time zone
- * Effect.provide(program, layer)
+ * await Effect.runPromise(Effect.provide(program, layer)) // => "Europe/London"
  * ```
  *
- * @category current time zone
+ * @category layers
  * @since 3.6.0
  */
 export declare const layerCurrentZone: (resource: NoInfer<TimeZone>) => Layer.Layer<CurrentTimeZone>;
@@ -4326,7 +4228,7 @@ export declare const layerCurrentZone: (resource: NoInfer<TimeZone>) => Layer.La
  *
  * **Example** (Providing fixed-offset time zone layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
  * // Create a layer for UTC+3
@@ -4334,13 +4236,13 @@ export declare const layerCurrentZone: (resource: NoInfer<TimeZone>) => Layer.La
  *
  * const program = Effect.gen(function*() {
  *   const now = yield* DateTime.nowInCurrentZone
- *   return DateTime.formatIsoZoned(now)
+ *   return DateTime.zoneToString(now.zone)
  * })
  *
- * Effect.provide(program, layer)
+ * await Effect.runPromise(Effect.provide(program, layer)) // => "+03:00"
  * ```
  *
- * @category current time zone
+ * @category layers
  * @since 3.6.0
  */
 export declare const layerCurrentZoneOffset: (offset: number) => Layer.Layer<CurrentTimeZone>;
@@ -4354,20 +4256,20 @@ export declare const layerCurrentZoneOffset: (offset: number) => Layer.Layer<Cur
  *
  * **Example** (Providing named time zone layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
  * const layer = DateTime.layerCurrentZoneNamed("Europe/London")
  *
  * const program = Effect.gen(function*() {
  *   const now = yield* DateTime.nowInCurrentZone
- *   return DateTime.formatIsoZoned(now)
+ *   return DateTime.zoneToString(now.zone)
  * })
  *
- * Effect.provide(program, layer)
+ * await Effect.runPromise(Effect.provide(program, layer)) // => "Europe/London"
  * ```
  *
- * @category current time zone
+ * @category layers
  * @since 3.6.0
  */
 export declare const layerCurrentZoneNamed: (zoneId: string) => Layer.Layer<CurrentTimeZone, IllegalArgumentError>;
@@ -4381,19 +4283,19 @@ export declare const layerCurrentZoneNamed: (zoneId: string) => Layer.Layer<Curr
  *
  * **Example** (Providing local time zone layers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { DateTime, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const now = yield* DateTime.nowInCurrentZone
- *   return DateTime.formatIsoZoned(now)
+ *   return DateTime.isZoned(now)
  * })
  *
  * // Use the system's local time zone
- * Effect.provide(program, DateTime.layerCurrentZoneLocal)
+ * await Effect.runPromise(Effect.provide(program, DateTime.layerCurrentZoneLocal)) // => true
  * ```
  *
- * @category current time zone
+ * @category layers
  * @since 3.6.0
  */
 export declare const layerCurrentZoneLocal: Layer.Layer<CurrentTimeZone>;