effect 3.10.18 → 3.11.0

package/src/DateTime.ts

@@ -1,31 +1,25 @@
 /**
  * @since 3.6.0
  */
-import { IllegalArgumentException } from "./Cause.js"
-import * as Clock from "./Clock.js"
+import type { IllegalArgumentException } from "./Cause.js"
 import * as Context from "./Context.js"
-import * as Duration from "./Duration.js"
+import type * as Duration from "./Duration.js"
 import * as Effect from "./Effect.js"
-import * as Either from "./Either.js"
-import * as Equal from "./Equal.js"
-import * as Equivalence_ from "./Equivalence.js"
-import type { LazyArg } from "./Function.js"
-import { dual, pipe } from "./Function.js"
-import { globalValue } from "./GlobalValue.js"
-import * as Hash from "./Hash.js"
-import * as Inspectable from "./Inspectable.js"
+import type * as Either from "./Either.js"
+import type * as equivalence from "./Equivalence.js"
+import { dual, type LazyArg } from "./Function.js"
+import type { Inspectable } from "./Inspectable.js"
+import * as Internal from "./internal/dateTime.js"
 import * as Layer from "./Layer.js"
-import * as Option from "./Option.js"
-import * as order from "./Order.js"
-import { type Pipeable, pipeArguments } from "./Pipeable.js"
-import * as Predicate from "./Predicate.js"
-import type { Mutable } from "./Types.js"
+import type * as Option from "./Option.js"
+import type * as order from "./Order.js"
+import type { Pipeable } from "./Pipeable.js"
 
 /**
  * @since 3.6.0
  * @category type ids
  */
-export const TypeId: unique symbol = Symbol.for("effect/DateTime")
+export const TypeId: unique symbol = Internal.TypeId
 
 /**
  * @since 3.6.0
@@ -168,7 +162,7 @@ export declare namespace DateTime {
    * @since 3.6.0
    * @category models
    */
-  export interface Proto extends Pipeable, Inspectable.Inspectable {
+  export interface Proto extends Pipeable, Inspectable {
     readonly [TypeId]: TypeId
   }
 }
@@ -177,7 +171,7 @@ export declare namespace DateTime {
  * @since 3.6.0
  * @category type ids
  */
-export const TimeZoneTypeId: unique symbol = Symbol.for("effect/DateTime/TimeZone")
+export const TimeZoneTypeId: unique symbol = Internal.TimeZoneTypeId
 
 /**
  * @since 3.6.0
@@ -200,7 +194,7 @@ export declare namespace TimeZone {
    * @since 3.6.0
    * @category models
    */
-  export interface Proto extends Inspectable.Inspectable {
+  export interface Proto extends Inspectable {
     readonly [TimeZoneTypeId]: TimeZoneTypeId
   }
 
@@ -225,109 +219,6 @@ export declare namespace TimeZone {
   }
 }
 
-const Proto = {
-  [TypeId]: TypeId,
-  pipe() {
-    return pipeArguments(this, arguments)
-  },
-  [Inspectable.NodeInspectSymbol](this: DateTime) {
-    return this.toString()
-  },
-  toJSON(this: DateTime) {
-    return toDateUtc(this).toJSON()
-  }
-}
-
-const ProtoUtc = {
-  ...Proto,
-  _tag: "Utc",
-  [Hash.symbol](this: Utc) {
-    return Hash.cached(this, Hash.number(this.epochMillis))
-  },
-  [Equal.symbol](this: Utc, that: unknown) {
-    return isDateTime(that) && that._tag === "Utc" && this.epochMillis === that.epochMillis
-  },
-  toString(this: Utc) {
-    return `DateTime.Utc(${toDateUtc(this).toJSON()})`
-  }
-}
-
-const ProtoZoned = {
-  ...Proto,
-  _tag: "Zoned",
-  [Hash.symbol](this: Zoned) {
-    return pipe(
-      Hash.number(this.epochMillis),
-      Hash.combine(Hash.hash(this.zone)),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](this: Zoned, that: unknown) {
-    return isDateTime(that) && that._tag === "Zoned" && this.epochMillis === that.epochMillis &&
-      Equal.equals(this.zone, that.zone)
-  },
-  toString(this: Zoned) {
-    return `DateTime.Zoned(${formatIsoZoned(this)})`
-  }
-}
-
-const ProtoTimeZone = {
-  [TimeZoneTypeId]: TimeZoneTypeId,
-  [Inspectable.NodeInspectSymbol](this: TimeZone) {
-    return this.toString()
-  }
-}
-
-const ProtoTimeZoneNamed = {
-  ...ProtoTimeZone,
-  _tag: "Named",
-  [Hash.symbol](this: TimeZone.Named) {
-    return Hash.cached(this, Hash.string(`Named:${this.id}`))
-  },
-  [Equal.symbol](this: TimeZone.Named, that: unknown) {
-    return isTimeZone(that) && that._tag === "Named" && this.id === that.id
-  },
-  toString(this: TimeZone.Named) {
-    return `TimeZone.Named(${this.id})`
-  },
-  toJSON(this: TimeZone.Named) {
-    return {
-      _id: "TimeZone",
-      _tag: "Named",
-      id: this.id
-    }
-  }
-}
-
-const ProtoTimeZoneOffset = {
-  ...ProtoTimeZone,
-  _tag: "Offset",
-  [Hash.symbol](this: TimeZone.Offset) {
-    return Hash.cached(this, Hash.string(`Offset:${this.offset}`))
-  },
-  [Equal.symbol](this: TimeZone.Offset, that: unknown) {
-    return isTimeZone(that) && that._tag === "Offset" && this.offset === that.offset
-  },
-  toString(this: TimeZone.Offset) {
-    return `TimeZone.Offset(${offsetToString(this.offset)})`
-  },
-  toJSON(this: TimeZone.Offset) {
-    return {
-      _id: "TimeZone",
-      _tag: "Offset",
-      offset: this.offset
-    }
-  }
-}
-
-const makeZonedProto = (epochMillis: number, zone: TimeZone, partsUtc?: DateTime.PartsWithWeekday): Zoned => {
-  const self = Object.create(ProtoZoned)
-  self.epochMillis = epochMillis
-  self.zone = zone
-  self.partsUtc = partsUtc
-  return self
-}
-
 // =============================================================================
 // guards
 // =============================================================================
@@ -336,39 +227,37 @@ const makeZonedProto = (epochMillis: number, zone: TimeZone, partsUtc?: DateTime
  * @since 3.6.0
  * @category guards
  */
-export const isDateTime = (u: unknown): u is DateTime => Predicate.hasProperty(u, TypeId)
-
-const isDateTimeArgs = (args: IArguments) => isDateTime(args[0])
+export const isDateTime: (u: unknown) => u is DateTime = Internal.isDateTime
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isTimeZone = (u: unknown): u is TimeZone => Predicate.hasProperty(u, TimeZoneTypeId)
+export const isTimeZone: (u: unknown) => u is TimeZone = Internal.isTimeZone
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isTimeZoneOffset = (u: unknown): u is TimeZone.Offset => isTimeZone(u) && u._tag === "Offset"
+export const isTimeZoneOffset: (u: unknown) => u is TimeZone.Offset = Internal.isTimeZoneOffset
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isTimeZoneNamed = (u: unknown): u is TimeZone.Named => isTimeZone(u) && u._tag === "Named"
+export const isTimeZoneNamed: (u: unknown) => u is TimeZone.Named = Internal.isTimeZoneNamed
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isUtc = (self: DateTime): self is Utc => self._tag === "Utc"
+export const isUtc: (self: DateTime) => self is Utc = Internal.isUtc
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isZoned = (self: DateTime): self is Zoned => self._tag === "Zoned"
+export const isZoned: (self: DateTime) => self is Zoned = Internal.isZoned
 
 // =============================================================================
 // instances
@@ -378,17 +267,13 @@ export const isZoned = (self: DateTime): self is Zoned => self._tag === "Zoned"
  * @since 3.6.0
  * @category instances
  */
-export const Equivalence: Equivalence_.Equivalence<DateTime> = Equivalence_.make((a, b) =>
-  a.epochMillis === b.epochMillis
-)
+export const Equivalence: equivalence.Equivalence<DateTime> = Internal.Equivalence
 
 /**
  * @since 3.6.0
  * @category instances
  */
-export const Order: order.Order<DateTime> = order.make((self, that) =>
-  self.epochMillis < that.epochMillis ? -1 : self.epochMillis > that.epochMillis ? 1 : 0
-)
+export const Order: order.Order<DateTime> = Internal.Order
 
 /**
  * @since 3.6.0
@@ -402,18 +287,12 @@ export const clamp: {
    * @since 3.6.0
    */
   (self: DateTime, options: { minimum: DateTime; maximum: DateTime }): DateTime
-} = order.clamp(Order)
+} = Internal.clamp
 
 // =============================================================================
 // constructors
 // =============================================================================
 
-const makeUtc = (epochMillis: number): Utc => {
-  const self = Object.create(ProtoUtc)
-  self.epochMillis = epochMillis
-  return self
-}
-
 /**
  * Create a `DateTime` from a `Date`.
  *
@@ -422,13 +301,7 @@ const makeUtc = (epochMillis: number): Utc => {
  * @since 3.6.0
  * @category constructors
  */
-export const unsafeFromDate = (date: Date): Utc => {
-  const epochMillis = date.getTime()
-  if (Number.isNaN(epochMillis)) {
-    throw new IllegalArgumentException("Invalid date")
-  }
-  return makeUtc(epochMillis)
-}
+export const unsafeFromDate: (date: Date) => Utc = Internal.unsafeFromDate
 
 /**
  * Create a `DateTime` from one of the following:
@@ -442,6 +315,7 @@ export const unsafeFromDate = (date: Date): Utc => {
  * @since 3.6.0
  * @category constructors
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // from Date
@@ -452,19 +326,9 @@ export const unsafeFromDate = (date: Date): Utc => {
  *
  * // from string
  * DateTime.unsafeMake("2024-01-01")
+ * ```
  */
-export const unsafeMake = <A extends DateTime.Input>(input: A): DateTime.PreserveZone<A> => {
-  if (isDateTime(input)) {
-    return input as DateTime.PreserveZone<A>
-  } else if (input instanceof Date) {
-    return unsafeFromDate(input) as DateTime.PreserveZone<A>
-  } else if (typeof input === "object") {
-    const date = new Date(0)
-    setPartsDate(date, input)
-    return unsafeFromDate(date) as DateTime.PreserveZone<A>
-  }
-  return unsafeFromDate(new Date(input)) as DateTime.PreserveZone<A>
-}
+export const unsafeMake: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone<A> = Internal.unsafeMake
 
 /**
  * Create a `DateTime.Zoned` using `DateTime.unsafeMake` and a time zone.
@@ -476,38 +340,16 @@ export const unsafeMake = <A extends DateTime.Input>(input: A): DateTime.Preserv
  * @since 3.6.0
  * @category constructors
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * DateTime.unsafeMakeZoned(new Date(), { timeZone: "Europe/London" })
+ * ```
  */
-export const unsafeMakeZoned = (input: DateTime.Input, options?: {
+export const unsafeMakeZoned: (input: DateTime.Input, options?: {
   readonly timeZone?: number | string | TimeZone | undefined
   readonly adjustForTimeZone?: boolean | undefined
-}): Zoned => {
-  if (options?.timeZone === undefined && isDateTime(input) && isZoned(input)) {
-    return input
-  }
-  const self = unsafeMake(input)
-  let zone: TimeZone
-  if (options?.timeZone === undefined) {
-    const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1000
-    zone = zoneMakeOffset(offset)
-  } else if (isTimeZone(options?.timeZone)) {
-    zone = options.timeZone
-  } else if (typeof options?.timeZone === "number") {
-    zone = zoneMakeOffset(options.timeZone)
-  } else {
-    const parsedZone = zoneFromString(options.timeZone)
-    if (Option.isNone(parsedZone)) {
-      throw new IllegalArgumentException(`Invalid time zone: ${options.timeZone}`)
-    }
-    zone = parsedZone.value
-  }
-  if (options?.adjustForTimeZone !== true) {
-    return makeZonedProto(self.epochMillis, zone, self.partsUtc)
-  }
-  return makeZonedFromAdjusted(self.epochMillis, zone)
-}
+}) => Zoned = Internal.unsafeMakeZoned
 
 /**
  * Create a `DateTime.Zoned` using `DateTime.make` and a time zone.
@@ -519,9 +361,11 @@ export const unsafeMakeZoned = (input: DateTime.Input, options?: {
  * @since 3.6.0
  * @category constructors
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * DateTime.makeZoned(new Date(), { timeZone: "Europe/London" })
+ * ```
  */
 export const makeZoned: (
   input: DateTime.Input,
@@ -529,7 +373,7 @@ export const makeZoned: (
     readonly timeZone?: number | string | TimeZone | undefined
     readonly adjustForTimeZone?: boolean | undefined
   }
-) => Option.Option<Zoned> = Option.liftThrowable(unsafeMakeZoned)
+) => Option.Option<Zoned> = Internal.makeZoned
 
 /**
  * Create a `DateTime` from one of the following:
@@ -545,6 +389,7 @@ export const makeZoned: (
  * @since 3.6.0
  * @category constructors
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // from Date
@@ -555,11 +400,9 @@ export const makeZoned: (
  *
  * // from string
  * DateTime.make("2024-01-01")
+ * ```
  */
-export const make: <A extends DateTime.Input>(input: A) => Option.Option<DateTime.PreserveZone<A>> = Option
-  .liftThrowable(unsafeMake)
-
-const zonedStringRegex = /^(.{17,35})\[(.+)\]$/
+export const make: <A extends DateTime.Input>(input: A) => Option.Option<DateTime.PreserveZone<A>> = Internal.make
 
 /**
  * Create a `DateTime.Zoned` from a string.
@@ -569,15 +412,7 @@ const zonedStringRegex = /^(.{17,35})\[(.+)\]$/
  * @since 3.6.0
  * @category constructors
  */
-export const makeZonedFromString = (input: string): Option.Option<Zoned> => {
-  const match = zonedStringRegex.exec(input)
-  if (match === null) {
-    const offset = parseOffset(input)
-    return offset !== null ? makeZoned(input, { timeZone: offset }) : Option.none()
-  }
-  const [, isoString, timeZone] = match
-  return makeZoned(isoString, { timeZone })
-}
+export const makeZonedFromString: (input: string) => Option.Option<Zoned> = Internal.makeZonedFromString
 
 /**
  * Get the current time using the `Clock` service and convert it to a `DateTime`.
@@ -585,13 +420,15 @@ export const makeZonedFromString = (input: string): Option.Option<Zoned> => {
  * @since 3.6.0
  * @category constructors
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
  *   const now = yield* DateTime.now
  * })
+ * ```
  */
-export const now: Effect.Effect<Utc> = Effect.map(Clock.currentTimeMillis, makeUtc)
+export const now: Effect.Effect<Utc> = Internal.now
 
 /**
  * Get the current time using `Date.now`.
@@ -599,7 +436,7 @@ export const now: Effect.Effect<Utc> = Effect.map(Clock.currentTimeMillis, makeU
  * @since 3.6.0
  * @category constructors
  */
-export const unsafeNow: LazyArg<Utc> = () => makeUtc(Date.now())
+export const unsafeNow: LazyArg<Utc> = Internal.unsafeNow
 
 // =============================================================================
 // time zones
@@ -611,6 +448,7 @@ export const unsafeNow: LazyArg<Utc> = () => makeUtc(Date.now())
  * @since 3.6.0
  * @category time zones
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -620,6 +458,7 @@ export const unsafeNow: LazyArg<Utc> = () => makeUtc(Date.now())
  *   // set the time zone
  *   const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
  * })
+ * ```
  */
 export const setZone: {
   // =============================================================================
@@ -632,6 +471,7 @@ export const setZone: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -641,6 +481,7 @@ export const setZone: {
    *   // set the time zone
    *   const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
    * })
+   * ```
    */
   (
     zone: TimeZone,
@@ -658,6 +499,7 @@ export const setZone: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -667,6 +509,7 @@ export const setZone: {
    *   // set the time zone
    *   const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
    * })
+   * ```
    */
   (
     self: DateTime,
@@ -675,12 +518,7 @@ export const setZone: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Zoned
-} = dual(isDateTimeArgs, (self: DateTime, zone: TimeZone, options?: {
-  readonly adjustForTimeZone?: boolean | undefined
-}): Zoned =>
-  options?.adjustForTimeZone === true
-    ? makeZonedFromAdjusted(self.epochMillis, zone)
-    : makeZonedProto(self.epochMillis, zone, self.partsUtc))
+} = Internal.setZone
 
 /**
  * Add a fixed offset time zone to a `DateTime`.
@@ -690,6 +528,7 @@ export const setZone: {
  * @since 3.6.0
  * @category time zones
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -698,6 +537,7 @@ export const setZone: {
  *   // set the offset time zone in milliseconds
  *   const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
  * })
+ * ```
  */
 export const setZoneOffset: {
   /**
@@ -708,6 +548,7 @@ export const setZoneOffset: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -716,6 +557,7 @@ export const setZoneOffset: {
    *   // set the offset time zone in milliseconds
    *   const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
    * })
+   * ```
    */
   (
     offset: number,
@@ -731,6 +573,7 @@ export const setZoneOffset: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -739,6 +582,7 @@ export const setZoneOffset: {
    *   // set the offset time zone in milliseconds
    *   const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
    * })
+   * ```
    */
   (
     self: DateTime,
@@ -747,35 +591,7 @@ export const setZoneOffset: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Zoned
-} = dual(isDateTimeArgs, (self: DateTime, offset: number, options?: {
-  readonly adjustForTimeZone?: boolean | undefined
-}): Zoned => setZone(self, zoneMakeOffset(offset), options))
-
-const validZoneCache = globalValue("effect/DateTime/validZoneCache", () => new Map<string, TimeZone.Named>())
-
-const formatOptions: Intl.DateTimeFormatOptions = {
-  day: "numeric",
-  month: "numeric",
-  year: "numeric",
-  hour: "numeric",
-  minute: "numeric",
-  second: "numeric",
-  timeZoneName: "longOffset",
-  fractionalSecondDigits: 3,
-  hourCycle: "h23"
-}
-
-const zoneMakeIntl = (format: Intl.DateTimeFormat): TimeZone.Named => {
-  const zoneId = format.resolvedOptions().timeZone
-  if (validZoneCache.has(zoneId)) {
-    return validZoneCache.get(zoneId)!
-  }
-  const zone = Object.create(ProtoTimeZoneNamed)
-  zone.id = zoneId
-  zone.format = format
-  validZoneCache.set(zoneId, zone)
-  return zone
-}
+} = Internal.setZoneOffset
 
 /**
  * Attempt to create a named time zone from a IANA time zone identifier.
@@ -785,21 +601,7 @@ const zoneMakeIntl = (format: Intl.DateTimeFormat): TimeZone.Named => {
  * @since 3.6.0
  * @category time zones
  */
-export const zoneUnsafeMakeNamed = (zoneId: string): TimeZone.Named => {
-  if (validZoneCache.has(zoneId)) {
-    return validZoneCache.get(zoneId)!
-  }
-  try {
-    return zoneMakeIntl(
-      new Intl.DateTimeFormat("en-US", {
-        ...formatOptions,
-        timeZone: zoneId
-      })
-    )
-  } catch (_) {
-    throw new IllegalArgumentException(`Invalid time zone: ${zoneId}`)
-  }
-}
+export const zoneUnsafeMakeNamed: (zoneId: string) => TimeZone.Named = Internal.zoneUnsafeMakeNamed
 
 /**
  * Create a fixed offset time zone.
@@ -807,11 +609,7 @@ export const zoneUnsafeMakeNamed = (zoneId: string): TimeZone.Named => {
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeOffset = (offset: number): TimeZone.Offset => {
-  const zone = Object.create(ProtoTimeZoneOffset)
-  zone.offset = offset
-  return zone
-}
+export const zoneMakeOffset: (offset: number) => TimeZone.Offset = Internal.zoneMakeOffset
 
 /**
  * Create a named time zone from a IANA time zone identifier. If the time zone
@@ -820,9 +618,7 @@ export const zoneMakeOffset = (offset: number): TimeZone.Offset => {
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> = Option.liftThrowable(
-  zoneUnsafeMakeNamed
-)
+export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> = Internal.zoneMakeNamed
 
 /**
  * Create a named time zone from a IANA time zone identifier. If the time zone
@@ -831,11 +627,8 @@ export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> =
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeNamedEffect = (zoneId: string): Effect.Effect<TimeZone.Named, IllegalArgumentException> =>
-  Effect.try({
-    try: () => zoneUnsafeMakeNamed(zoneId),
-    catch: (e) => e as IllegalArgumentException
-  })
+export const zoneMakeNamedEffect: (zoneId: string) => Effect.Effect<TimeZone.Named, IllegalArgumentException> =
+  Internal.zoneMakeNamedEffect
 
 /**
  * Create a named time zone from the system's local time zone.
@@ -843,9 +636,7 @@ export const zoneMakeNamedEffect = (zoneId: string): Effect.Effect<TimeZone.Name
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeLocal = (): TimeZone.Named => zoneMakeIntl(new Intl.DateTimeFormat("en-US", formatOptions))
-
-const offsetZoneRegex = /^(?:GMT|[+-])/
+export const zoneMakeLocal: () => TimeZone.Named = Internal.zoneMakeLocal
 
 /**
  * Try parse a TimeZone from a string
@@ -853,13 +644,7 @@ const offsetZoneRegex = /^(?:GMT|[+-])/
  * @since 3.6.0
  * @category time zones
  */
-export const zoneFromString = (zone: string): Option.Option<TimeZone> => {
-  if (offsetZoneRegex.test(zone)) {
-    const offset = parseOffset(zone)
-    return offset === null ? Option.none() : Option.some(zoneMakeOffset(offset))
-  }
-  return zoneMakeNamed(zone)
-}
+export const zoneFromString: (zone: string) => Option.Option<TimeZone> = Internal.zoneFromString
 
 /**
  * Format a `TimeZone` as a string.
@@ -867,6 +652,7 @@ export const zoneFromString = (zone: string): Option.Option<TimeZone> => {
  * @since 3.6.0
  * @category time zones
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * // Outputs "+03:00"
@@ -874,13 +660,9 @@ export const zoneFromString = (zone: string): Option.Option<TimeZone> => {
  *
  * // Outputs "Europe/London"
  * DateTime.zoneToString(DateTime.zoneUnsafeMakeNamed("Europe/London"))
+ * ```
  */
-export const zoneToString = (self: TimeZone): string => {
-  if (self._tag === "Offset") {
-    return offsetToString(self.offset)
-  }
-  return self.id
-}
+export const zoneToString: (self: TimeZone) => string = Internal.zoneToString
 
 /**
  * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
@@ -889,6 +671,7 @@ export const zoneToString = (self: TimeZone): string => {
  * @since 3.6.0
  * @category time zones
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -896,6 +679,7 @@ export const zoneToString = (self: TimeZone): string => {
  *   // set the time zone, returns an Option
  *   DateTime.setZoneNamed(now, "Europe/London")
  * })
+ * ```
  */
 export const setZoneNamed: {
   /**
@@ -905,6 +689,7 @@ export const setZoneNamed: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -912,6 +697,7 @@ export const setZoneNamed: {
    *   // set the time zone, returns an Option
    *   DateTime.setZoneNamed(now, "Europe/London")
    * })
+   * ```
    */
   (
     zoneId: string,
@@ -926,6 +712,7 @@ export const setZoneNamed: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -933,6 +720,7 @@ export const setZoneNamed: {
    *   // set the time zone, returns an Option
    *   DateTime.setZoneNamed(now, "Europe/London")
    * })
+   * ```
    */
   (
     self: DateTime,
@@ -941,12 +729,7 @@ export const setZoneNamed: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Option.Option<Zoned>
-} = dual(
-  isDateTimeArgs,
-  (self: DateTime, zoneId: string, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-  }): Option.Option<Zoned> => Option.map(zoneMakeNamed(zoneId), (zone) => setZone(self, zone, options))
-)
+} = Internal.setZoneNamed
 
 /**
  * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
@@ -955,6 +738,7 @@ export const setZoneNamed: {
  * @since 3.6.0
  * @category time zones
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -962,6 +746,7 @@ export const setZoneNamed: {
  *   // set the time zone
  *   DateTime.unsafeSetZoneNamed(now, "Europe/London")
  * })
+ * ```
  */
 export const unsafeSetZoneNamed: {
   /**
@@ -971,6 +756,7 @@ export const unsafeSetZoneNamed: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -978,6 +764,7 @@ export const unsafeSetZoneNamed: {
    *   // set the time zone
    *   DateTime.unsafeSetZoneNamed(now, "Europe/London")
    * })
+   * ```
    */
   (
     zoneId: string,
@@ -992,6 +779,7 @@ export const unsafeSetZoneNamed: {
    * @since 3.6.0
    * @category time zones
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -999,6 +787,7 @@ export const unsafeSetZoneNamed: {
    *   // set the time zone
    *   DateTime.unsafeSetZoneNamed(now, "Europe/London")
    * })
+   * ```
    */
   (
     self: DateTime,
@@ -1007,9 +796,7 @@ export const unsafeSetZoneNamed: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Zoned
-} = dual(isDateTimeArgs, (self: DateTime, zoneId: string, options?: {
-  readonly adjustForTimeZone?: boolean | undefined
-}): Zoned => setZone(self, zoneUnsafeMakeNamed(zoneId), options))
+} = Internal.unsafeSetZoneNamed
 
 // =============================================================================
 // comparisons
@@ -1024,6 +811,7 @@ export const unsafeSetZoneNamed: {
  * @since 3.6.0
  * @category comparisons
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -1033,6 +821,7 @@ export const unsafeSetZoneNamed: {
  *   // returns 60000
  *   DateTime.distance(now, other)
  * })
+ * ```
  */
 export const distance: {
   // =============================================================================
@@ -1048,6 +837,7 @@ export const distance: {
    * @since 3.6.0
    * @category comparisons
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -1057,6 +847,7 @@ export const distance: {
    *   // returns 60000
    *   DateTime.distance(now, other)
    * })
+   * ```
    */
   (other: DateTime): (self: DateTime) => number
   // =============================================================================
@@ -1072,6 +863,7 @@ export const distance: {
    * @since 3.6.0
    * @category comparisons
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -1081,9 +873,10 @@ export const distance: {
    *   // returns 60000
    *   DateTime.distance(now, other)
    * })
+   * ```
    */
   (self: DateTime, other: DateTime): number
-} = dual(2, (self: DateTime, other: DateTime): number => toEpochMillis(other) - toEpochMillis(self))
+} = Internal.distance
 
 /**
  * Calulate the difference between two `DateTime` values.
@@ -1097,6 +890,7 @@ export const distance: {
  * @since 3.6.0
  * @category comparisons
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -1109,6 +903,7 @@ export const distance: {
  *   // returns Either.left(Duration.minutes(1))
  *   DateTime.distanceDurationEither(other, now)
  * })
+ * ```
  */
 export const distanceDurationEither: {
   /**
@@ -1123,6 +918,7 @@ export const distanceDurationEither: {
    * @since 3.6.0
    * @category comparisons
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -1135,6 +931,7 @@ export const distanceDurationEither: {
    *   // returns Either.left(Duration.minutes(1))
    *   DateTime.distanceDurationEither(other, now)
    * })
+   * ```
    */
   (other: DateTime): (self: DateTime) => Either.Either<Duration.Duration, Duration.Duration>
   /**
@@ -1149,6 +946,7 @@ export const distanceDurationEither: {
    * @since 3.6.0
    * @category comparisons
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -1161,14 +959,10 @@ export const distanceDurationEither: {
    *   // returns Either.left(Duration.minutes(1))
    *   DateTime.distanceDurationEither(other, now)
    * })
+   * ```
    */
   (self: DateTime, other: DateTime): Either.Either<Duration.Duration, Duration.Duration>
-} = dual(2, (self: DateTime, other: DateTime): Either.Either<Duration.Duration, Duration.Duration> => {
-  const diffMillis = distance(self, other)
-  return diffMillis > 0
-    ? Either.right(Duration.millis(diffMillis))
-    : Either.left(Duration.millis(-diffMillis))
-})
+} = Internal.distanceDurationEither
 
 /**
  * Calulate the distance between two `DateTime` values.
@@ -1176,6 +970,7 @@ export const distanceDurationEither: {
  * @since 3.6.0
  * @category comparisons
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -1185,6 +980,7 @@ export const distanceDurationEither: {
  *   // returns Duration.minutes(1)
  *   DateTime.distanceDuration(now, other)
  * })
+ * ```
  */
 export const distanceDuration: {
   /**
@@ -1193,6 +989,7 @@ export const distanceDuration: {
    * @since 3.6.0
    * @category comparisons
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -1202,6 +999,7 @@ export const distanceDuration: {
    *   // returns Duration.minutes(1)
    *   DateTime.distanceDuration(now, other)
    * })
+   * ```
    */
   (other: DateTime): (self: DateTime) => Duration.Duration
   /**
@@ -1210,6 +1008,7 @@ export const distanceDuration: {
    * @since 3.6.0
    * @category comparisons
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
@@ -1219,12 +1018,10 @@ export const distanceDuration: {
    *   // returns Duration.minutes(1)
    *   DateTime.distanceDuration(now, other)
    * })
+   * ```
    */
   (self: DateTime, other: DateTime): Duration.Duration
-} = dual(
-  2,
-  (self: DateTime, other: DateTime): Duration.Duration => Duration.millis(Math.abs(distance(self, other)))
-)
+} = Internal.distanceDuration
 
 /**
  * @since 3.6.0
@@ -1241,7 +1038,7 @@ export const min: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): DateTime
-} = order.min(Order)
+} = Internal.min
 
 /**
  * @since 3.6.0
@@ -1258,7 +1055,7 @@ export const max: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): DateTime
-} = order.max(Order)
+} = Internal.max
 
 /**
  * @since 3.6.0
@@ -1275,7 +1072,7 @@ export const greaterThan: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.greaterThan(Order)
+} = Internal.greaterThan
 
 /**
  * @since 3.6.0
@@ -1292,7 +1089,7 @@ export const greaterThanOrEqualTo: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.greaterThanOrEqualTo(Order)
+} = Internal.greaterThanOrEqualTo
 
 /**
  * @since 3.6.0
@@ -1309,7 +1106,7 @@ export const lessThan: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.lessThan(Order)
+} = Internal.lessThan
 
 /**
  * @since 3.6.0
@@ -1326,7 +1123,7 @@ export const lessThanOrEqualTo: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.lessThanOrEqualTo(Order)
+} = Internal.lessThanOrEqualTo
 
 /**
  * @since 3.6.0
@@ -1343,31 +1140,31 @@ export const between: {
    * @category comparisons
    */
   (self: DateTime, options: { minimum: DateTime; maximum: DateTime }): boolean
-} = order.between(Order)
+} = Internal.between
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const isFuture = (self: DateTime): Effect.Effect<boolean> => Effect.map(now, lessThan(self))
+export const isFuture: (self: DateTime) => Effect.Effect<boolean> = Internal.isFuture
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const unsafeIsFuture = (self: DateTime): boolean => lessThan(unsafeNow(), self)
+export const unsafeIsFuture: (self: DateTime) => boolean = Internal.unsafeIsFuture
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const isPast = (self: DateTime): Effect.Effect<boolean> => Effect.map(now, greaterThan(self))
+export const isPast: (self: DateTime) => Effect.Effect<boolean> = Internal.isPast
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const unsafeIsPast = (self: DateTime): boolean => greaterThan(unsafeNow(), self)
+export const unsafeIsPast: (self: DateTime) => boolean = Internal.unsafeIsPast
 
 // =============================================================================
 // conversions
@@ -1379,7 +1176,7 @@ export const unsafeIsPast = (self: DateTime): boolean => greaterThan(unsafeNow()
  * @since 3.6.0
  * @category conversions
  */
-export const toDateUtc = (self: DateTime): Date => new Date(self.epochMillis)
+export const toDateUtc: (self: DateTime) => Date = Internal.toDateUtc
 
 /**
  * Convert a `DateTime` to a `Date`, applying the time zone first.
@@ -1387,30 +1184,7 @@ export const toDateUtc = (self: DateTime): Date => new Date(self.epochMillis)
  * @since 3.6.0
  * @category conversions
  */
-export const toDate = (self: DateTime): Date => {
-  if (self._tag === "Utc") {
-    return new Date(self.epochMillis)
-  } else if (self.zone._tag === "Offset") {
-    return new Date(self.epochMillis + self.zone.offset)
-  } else if (self.adjustedEpochMillis !== undefined) {
-    return new Date(self.adjustedEpochMillis)
-  }
-  const parts = self.zone.format.formatToParts(self.epochMillis).filter((_) => _.type !== "literal")
-  const date = new Date(0)
-  date.setUTCFullYear(
-    Number(parts[2].value),
-    Number(parts[0].value) - 1,
-    Number(parts[1].value)
-  )
-  date.setUTCHours(
-    Number(parts[3].value),
-    Number(parts[4].value),
-    Number(parts[5].value),
-    Number(parts[6].value)
-  )
-  self.adjustedEpochMillis = date.getTime()
-  return date
-}
+export const toDate: (self: DateTime) => Date = Internal.toDate
 
 /**
  * Calculate the time zone offset of a `DateTime.Zoned` in milliseconds.
@@ -1418,17 +1192,7 @@ export const toDate = (self: DateTime): Date => {
  * @since 3.6.0
  * @category conversions
  */
-export const zonedOffset = (self: Zoned): number => {
-  const date = toDate(self)
-  return date.getTime() - toEpochMillis(self)
-}
-
-const offsetToString = (offset: number): string => {
-  const abs = Math.abs(offset)
-  const hours = Math.floor(abs / (60 * 60 * 1000))
-  const minutes = Math.round((abs % (60 * 60 * 1000)) / (60 * 1000))
-  return `${offset < 0 ? "-" : "+"}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`
-}
+export const zonedOffset: (self: Zoned) => number = Internal.zonedOffset
 
 /**
  * Calculate the time zone offset of a `DateTime` in milliseconds.
@@ -1438,7 +1202,7 @@ const offsetToString = (offset: number): string => {
  * @since 3.6.0
  * @category conversions
  */
-export const zonedOffsetIso = (self: Zoned): string => offsetToString(zonedOffset(self))
+export const zonedOffsetIso: (self: Zoned) => string = Internal.zonedOffsetIso
 
 /**
  * Get the milliseconds since the Unix epoch of a `DateTime`.
@@ -1446,7 +1210,7 @@ export const zonedOffsetIso = (self: Zoned): string => offsetToString(zonedOffse
  * @since 3.6.0
  * @category conversions
  */
-export const toEpochMillis = (self: DateTime): number => self.epochMillis
+export const toEpochMillis: (self: DateTime) => number = Internal.toEpochMillis
 
 /**
  * Remove the time aspect of a `DateTime`, first adjusting for the time
@@ -1455,6 +1219,7 @@ export const toEpochMillis = (self: DateTime): number => self.epochMillis
  * @since 3.6.0
  * @category conversions
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-01T00:00:00Z"
@@ -1465,28 +1230,14 @@ export const toEpochMillis = (self: DateTime): number => self.epochMillis
  *   DateTime.removeTime,
  *   DateTime.formatIso
  * )
+ * ```
  */
-export const removeTime = (self: DateTime): Utc =>
-  withDate(self, (date) => {
-    date.setUTCHours(0, 0, 0, 0)
-    return makeUtc(date.getTime())
-  })
+export const removeTime: (self: DateTime) => Utc = Internal.removeTime
 
 // =============================================================================
 // parts
 // =============================================================================
 
-const dateToParts = (date: Date): DateTime.PartsWithWeekday => ({
-  millis: date.getUTCMilliseconds(),
-  seconds: date.getUTCSeconds(),
-  minutes: date.getUTCMinutes(),
-  hours: date.getUTCHours(),
-  day: date.getUTCDate(),
-  weekDay: date.getUTCDay(),
-  month: date.getUTCMonth() + 1,
-  year: date.getUTCFullYear()
-})
-
 /**
  * Get the different parts of a `DateTime` as an object.
  *
@@ -1495,15 +1246,7 @@ const dateToParts = (date: Date): DateTime.PartsWithWeekday => ({
  * @since 3.6.0
  * @category parts
  */
-export const toParts = (self: DateTime): DateTime.PartsWithWeekday => {
-  if (self._tag === "Utc") {
-    return toPartsUtc(self)
-  } else if (self.partsAdjusted !== undefined) {
-    return self.partsAdjusted
-  }
-  self.partsAdjusted = withDate(self, dateToParts)
-  return self.partsAdjusted
-}
+export const toParts: (self: DateTime) => DateTime.PartsWithWeekday = Internal.toParts
 
 /**
  * Get the different parts of a `DateTime` as an object.
@@ -1513,13 +1256,7 @@ export const toParts = (self: DateTime): DateTime.PartsWithWeekday => {
  * @since 3.6.0
  * @category parts
  */
-export const toPartsUtc = (self: DateTime): DateTime.PartsWithWeekday => {
-  if (self.partsUtc !== undefined) {
-    return self.partsUtc
-  }
-  self.partsUtc = withDateUtc(self, dateToParts)
-  return self.partsUtc
-}
+export const toPartsUtc: (self: DateTime) => DateTime.PartsWithWeekday = Internal.toPartsUtc
 
 /**
  * Get a part of a `DateTime` as a number.
@@ -1529,11 +1266,13 @@ export const toPartsUtc = (self: DateTime): DateTime.PartsWithWeekday => {
  * @since 3.6.0
  * @category parts
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * const now = DateTime.unsafeMake({ year: 2024 })
  * const year = DateTime.getPartUtc(now, "year")
  * assert.strictEqual(year, 2024)
+ * ```
  */
 export const getPartUtc: {
   /**
@@ -1544,11 +1283,13 @@ export const getPartUtc: {
    * @since 3.6.0
    * @category parts
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * const now = DateTime.unsafeMake({ year: 2024 })
    * const year = DateTime.getPartUtc(now, "year")
    * assert.strictEqual(year, 2024)
+   * ```
    */
   (part: keyof DateTime.PartsWithWeekday): (self: DateTime) => number
   /**
@@ -1559,14 +1300,16 @@ export const getPartUtc: {
    * @since 3.6.0
    * @category parts
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * const now = DateTime.unsafeMake({ year: 2024 })
    * const year = DateTime.getPartUtc(now, "year")
    * assert.strictEqual(year, 2024)
+   * ```
    */
   (self: DateTime, part: keyof DateTime.PartsWithWeekday): number
-} = dual(2, (self: DateTime, part: keyof DateTime.PartsWithWeekday): number => toPartsUtc(self)[part])
+} = Internal.getPartUtc
 
 /**
  * Get a part of a `DateTime` as a number.
@@ -1576,11 +1319,13 @@ export const getPartUtc: {
  * @since 3.6.0
  * @category parts
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * const now = DateTime.unsafeMakeZoned({ year: 2024 }, { timeZone: "Europe/London" })
  * const year = DateTime.getPart(now, "year")
  * assert.strictEqual(year, 2024)
+ * ```
  */
 export const getPart: {
   /**
@@ -1591,11 +1336,13 @@ export const getPart: {
    * @since 3.6.0
    * @category parts
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * const now = DateTime.unsafeMakeZoned({ year: 2024 }, { timeZone: "Europe/London" })
    * const year = DateTime.getPart(now, "year")
    * assert.strictEqual(year, 2024)
+   * ```
    */
   (part: keyof DateTime.PartsWithWeekday): (self: DateTime) => number
   /**
@@ -1606,42 +1353,16 @@ export const getPart: {
    * @since 3.6.0
    * @category parts
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * const now = DateTime.unsafeMakeZoned({ year: 2024 }, { timeZone: "Europe/London" })
    * const year = DateTime.getPart(now, "year")
    * assert.strictEqual(year, 2024)
+   * ```
    */
   (self: DateTime, part: keyof DateTime.PartsWithWeekday): number
-} = dual(2, (self: DateTime, part: keyof DateTime.PartsWithWeekday): number => toParts(self)[part])
-
-const setPartsDate = (date: Date, parts: Partial<DateTime.PartsWithWeekday>): void => {
-  if (parts.year !== undefined) {
-    date.setUTCFullYear(parts.year)
-  }
-  if (parts.month !== undefined) {
-    date.setUTCMonth(parts.month - 1)
-  }
-  if (parts.day !== undefined) {
-    date.setUTCDate(parts.day)
-  }
-  if (parts.weekDay !== undefined) {
-    const diff = parts.weekDay - date.getUTCDay()
-    date.setUTCDate(date.getUTCDate() + diff)
-  }
-  if (parts.hours !== undefined) {
-    date.setUTCHours(parts.hours)
-  }
-  if (parts.minutes !== undefined) {
-    date.setUTCMinutes(parts.minutes)
-  }
-  if (parts.seconds !== undefined) {
-    date.setUTCSeconds(parts.seconds)
-  }
-  if (parts.millis !== undefined) {
-    date.setUTCMilliseconds(parts.millis)
-  }
-}
+} = Internal.getPart
 
 /**
  * Set the different parts of a `DateTime` as an object.
@@ -1670,11 +1391,7 @@ export const setParts: {
    * @category parts
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, parts: Partial<DateTime.PartsWithWeekday>): DateTime =>
-    mutate(self, (date) => setPartsDate(date, parts))
-)
+} = Internal.setParts
 
 /**
  * Set the different parts of a `DateTime` as an object.
@@ -1697,24 +1414,18 @@ export const setPartsUtc: {
    * @category parts
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, parts: Partial<DateTime.PartsWithWeekday>): DateTime =>
-    mutateUtc(self, (date) => setPartsDate(date, parts))
-)
+} = Internal.setPartsUtc
 
 // =============================================================================
 // current time zone
 // =============================================================================
 
-/**
- * @since 3.6.0
- * @category current time zone
- */
-export class CurrentTimeZone extends Context.Tag("effect/DateTime/CurrentTimeZone")<
-  CurrentTimeZone,
-  TimeZone
->() {}
+// =============================================================================
+// current time zone
+// =============================================================================
+
+/** @internal */
+export class CurrentTimeZone extends Context.Tag("effect/DateTime/CurrentTimeZone")<CurrentTimeZone, TimeZone>() {}
 
 /**
  * Set the time zone of a `DateTime` to the current time zone, which is
@@ -1723,6 +1434,7 @@ export class CurrentTimeZone extends Context.Tag("effect/DateTime/CurrentTimeZon
  * @since 3.6.0
  * @category current time zone
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
@@ -1731,6 +1443,7 @@ export class CurrentTimeZone extends Context.Tag("effect/DateTime/CurrentTimeZon
  *   // set the time zone to "Europe/London"
  *   const zoned = yield* DateTime.setZoneCurrent(now)
  * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+ * ```
  */
 export const setZoneCurrent = (self: DateTime): Effect.Effect<Zoned, never, CurrentTimeZone> =>
   Effect.map(CurrentTimeZone, (zone) => setZone(self, zone))
@@ -1741,6 +1454,7 @@ export const setZoneCurrent = (self: DateTime): Effect.Effect<Zoned, never, Curr
  * @since 3.6.0
  * @category current time zone
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * const zone = DateTime.zoneUnsafeMakeNamed("Europe/London")
@@ -1748,6 +1462,7 @@ export const setZoneCurrent = (self: DateTime): Effect.Effect<Zoned, never, Curr
  * Effect.gen(function* () {
  *   const now = yield* DateTime.nowInCurrentZone
  * }).pipe(DateTime.withCurrentZone(zone))
+ * ```
  */
 export const withCurrentZone: {
   /**
@@ -1756,6 +1471,7 @@ export const withCurrentZone: {
    * @since 3.6.0
    * @category current time zone
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * const zone = DateTime.zoneUnsafeMakeNamed("Europe/London")
@@ -1763,6 +1479,7 @@ export const withCurrentZone: {
    * Effect.gen(function* () {
    *   const now = yield* DateTime.nowInCurrentZone
    * }).pipe(DateTime.withCurrentZone(zone))
+   * ```
    */
   (zone: TimeZone): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
   /**
@@ -1771,6 +1488,7 @@ export const withCurrentZone: {
    * @since 3.6.0
    * @category current time zone
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * const zone = DateTime.zoneUnsafeMakeNamed("Europe/London")
@@ -1778,12 +1496,15 @@ export const withCurrentZone: {
    * Effect.gen(function* () {
    *   const now = yield* DateTime.nowInCurrentZone
    * }).pipe(DateTime.withCurrentZone(zone))
+   * ```
    */
   <A, E, R>(effect: Effect.Effect<A, E, R>, zone: TimeZone): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
 } = dual(
   2,
-  <A, E, R>(effect: Effect.Effect<A, E, R>, zone: TimeZone): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>> =>
-    Effect.provideService(effect, CurrentTimeZone, zone)
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    zone: TimeZone
+  ): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>> => Effect.provideService(effect, CurrentTimeZone, zone)
 )
 
 /**
@@ -1793,12 +1514,14 @@ export const withCurrentZone: {
  * @since 3.6.0
  * @category current time zone
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
  *   // will use the system's local time zone
  *   const now = yield* DateTime.nowInCurrentZone
  * }).pipe(DateTime.withCurrentZoneLocal)
+ * ```
  */
 export const withCurrentZoneLocal = <A, E, R>(
   effect: Effect.Effect<A, E, R>
@@ -1811,12 +1534,14 @@ export const withCurrentZoneLocal = <A, E, R>(
  * @since 3.6.0
  * @category current time zone
  * @example
+ * ```ts
  * import { DateTime, Effect } from "effect"
  *
  * Effect.gen(function* () {
  *   // will use the system's local time zone
  *   const now = yield* DateTime.nowInCurrentZone
  * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
+ * ```
  */
 export const withCurrentZoneOffset: {
   /**
@@ -1825,12 +1550,14 @@ export const withCurrentZoneOffset: {
    * @since 3.6.0
    * @category current time zone
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
    *   // will use the system's local time zone
    *   const now = yield* DateTime.nowInCurrentZone
    * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
+   * ```
    */
   (offset: number): <A, E, R>(
     effect: Effect.Effect<A, E, R>
@@ -1841,12 +1568,14 @@ export const withCurrentZoneOffset: {
    * @since 3.6.0
    * @category current time zone
    * @example
+   * ```ts
    * import { DateTime, Effect } from "effect"
    *
    * Effect.gen(function* () {
    *   // will use the system's local time zone
    *   const now = yield* DateTime.nowInCurrentZone
    * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
+   * ```
    */
   <A, E, R>(effect: Effect.Effect<A, E, R>, offset: number): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
 } = dual(
@@ -1864,12 +1593,14 @@ export const withCurrentZoneOffset: {
  * @since 3.6.0
  * @category current time zone
  * @example
+ * ```ts
  * 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"))
+ * ```
  */
 export const withCurrentZoneNamed: {
   /**
@@ -1881,12 +1612,14 @@ export const withCurrentZoneNamed: {
    * @since 3.6.0
    * @category current time zone
    * @example
+   * ```ts
    * 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"))
+   * ```
    */
   (zone: string): <A, E, R>(
     effect: Effect.Effect<A, E, R>
@@ -1900,12 +1633,14 @@ export const withCurrentZoneNamed: {
    * @since 3.6.0
    * @category current time zone
    * @example
+   * ```ts
    * 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"))
+   * ```
    */
   <A, E, R>(
     effect: Effect.Effect<A, E, R>,
@@ -1926,87 +1661,21 @@ export const withCurrentZoneNamed: {
  * @since 3.6.0
  * @category current time zone
  * @example
+ * ```ts
  * 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"))
+ * ```
  */
-export const nowInCurrentZone: Effect.Effect<Zoned, never, CurrentTimeZone> = Effect.flatMap(
-  now,
-  setZoneCurrent
-)
-
-/**
- * Create a Layer from the given time zone.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZone = (zone: TimeZone): Layer.Layer<CurrentTimeZone> => Layer.succeed(CurrentTimeZone, zone)
-
-/**
- * Create a Layer from the given time zone offset.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneOffset = (offset: number): Layer.Layer<CurrentTimeZone> =>
-  Layer.succeed(CurrentTimeZone, zoneMakeOffset(offset))
-
-/**
- * Create a Layer from the given IANA time zone identifier.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneNamed = (zoneId: string): Layer.Layer<CurrentTimeZone, IllegalArgumentException> =>
-  Layer.effect(CurrentTimeZone, zoneMakeNamedEffect(zoneId))
-
-/**
- * Create a Layer from the systems local time zone.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneLocal: Layer.Layer<CurrentTimeZone> = Layer.sync(
-  CurrentTimeZone,
-  zoneMakeLocal
-)
+export const nowInCurrentZone: Effect.Effect<Zoned, never, CurrentTimeZone> = Effect.flatMap(now, setZoneCurrent)
 
 // =============================================================================
 // mapping
 // =============================================================================
 
-const makeZonedFromAdjusted = (adjustedMillis: number, zone: TimeZone): Zoned => {
-  const offset = zone._tag === "Offset" ? zone.offset : calculateNamedOffset(adjustedMillis, zone)
-  return makeZonedProto(adjustedMillis - offset, zone)
-}
-
-const offsetRegex = /([+-])(\d{2}):(\d{2})$/
-const parseOffset = (offset: string): number | null => {
-  const match = offsetRegex.exec(offset)
-  if (match === null) {
-    return null
-  }
-  const [, sign, hours, minutes] = match
-  return (sign === "+" ? 1 : -1) * (Number(hours) * 60 + Number(minutes)) * 60 * 1000
-}
-
-const calculateNamedOffset = (adjustedMillis: number, zone: TimeZone.Named): number => {
-  const offset = zone.format.formatToParts(adjustedMillis).find((_) => _.type === "timeZoneName")?.value ?? ""
-  if (offset === "GMT") {
-    return 0
-  }
-  const result = parseOffset(offset)
-  if (result === null) {
-    // fallback to using the adjusted date
-    return zonedOffset(makeZonedProto(adjustedMillis, zone))
-  }
-  return result
-}
-
 /**
  * Modify a `DateTime` by applying a function to a cloned `Date` instance.
  *
@@ -2017,6 +1686,10 @@ const calculateNamedOffset = (adjustedMillis: number, zone: TimeZone.Named): num
  * @category mapping
  */
 export const mutate: {
+  // =============================================================================
+  // mapping
+  // =============================================================================
+
   /**
    * Modify a `DateTime` by applying a function to a cloned `Date` instance.
    *
@@ -2027,6 +1700,10 @@ export const mutate: {
    * @category mapping
    */
   (f: (date: Date) => void): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  // =============================================================================
+  // mapping
+  // =============================================================================
+
   /**
    * Modify a `DateTime` by applying a function to a cloned `Date` instance.
    *
@@ -2037,17 +1714,7 @@ export const mutate: {
    * @category mapping
    */
   <A extends DateTime>(self: A, f: (date: Date) => void): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, f: (date: Date) => void): DateTime => {
-  if (self._tag === "Utc") {
-    const date = toDateUtc(self)
-    f(date)
-    return makeUtc(date.getTime())
-  }
-  const adjustedDate = toDate(self)
-  const newAdjustedDate = new Date(adjustedDate.getTime())
-  f(newAdjustedDate)
-  return makeZonedFromAdjusted(newAdjustedDate.getTime(), self.zone)
-})
+} = Internal.mutate
 
 /**
  * Modify a `DateTime` by applying a function to a cloned UTC `Date` instance.
@@ -2070,12 +1737,7 @@ export const mutateUtc: {
    * @category mapping
    */
   <A extends DateTime>(self: A, f: (date: Date) => void): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, f: (date: Date) => void): DateTime =>
-  mapEpochMillis(self, (millis) => {
-    const date = new Date(millis)
-    f(date)
-    return date.getTime()
-  }))
+} = Internal.mutateUtc
 
 /**
  * Transform a `DateTime` by applying a function to the number of milliseconds
@@ -2084,12 +1746,14 @@ export const mutateUtc: {
  * @since 3.6.0
  * @category mapping
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // add 10 milliseconds
  * DateTime.unsafeMake(0).pipe(
  *   DateTime.mapEpochMillis((millis) => millis + 10)
  * )
+ * ```
  */
 export const mapEpochMillis: {
   /**
@@ -2099,12 +1763,14 @@ export const mapEpochMillis: {
    * @since 3.6.0
    * @category mapping
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // add 10 milliseconds
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.mapEpochMillis((millis) => millis + 10)
    * )
+   * ```
    */
   (f: (millis: number) => number): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
   /**
@@ -2114,18 +1780,17 @@ export const mapEpochMillis: {
    * @since 3.6.0
    * @category mapping
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // add 10 milliseconds
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.mapEpochMillis((millis) => millis + 10)
    * )
+   * ```
    */
   <A extends DateTime>(self: A, f: (millis: number) => number): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, f: (millis: number) => number): DateTime => {
-  const millis = f(toEpochMillis(self))
-  return self._tag === "Utc" ? makeUtc(millis) : makeZonedProto(millis, self.zone)
-})
+} = Internal.mapEpochMillis
 
 /**
  * Using the time zone adjusted `Date`, apply a function to the `Date` and
@@ -2134,12 +1799,14 @@ export const mapEpochMillis: {
  * @since 3.6.0
  * @category mapping
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // get the time zone adjusted date in milliseconds
  * DateTime.unsafeMakeZoned(0, { timeZone: "Europe/London" }).pipe(
  *   DateTime.withDate((date) => date.getTime())
  * )
+ * ```
  */
 export const withDate: {
   /**
@@ -2149,12 +1816,14 @@ export const withDate: {
    * @since 3.6.0
    * @category mapping
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // get the time zone adjusted date in milliseconds
    * DateTime.unsafeMakeZoned(0, { timeZone: "Europe/London" }).pipe(
    *   DateTime.withDate((date) => date.getTime())
    * )
+   * ```
    */
   <A>(f: (date: Date) => A): (self: DateTime) => A
   /**
@@ -2164,15 +1833,17 @@ export const withDate: {
    * @since 3.6.0
    * @category mapping
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // get the time zone adjusted date in milliseconds
    * DateTime.unsafeMakeZoned(0, { timeZone: "Europe/London" }).pipe(
    *   DateTime.withDate((date) => date.getTime())
    * )
+   * ```
    */
   <A>(self: DateTime, f: (date: Date) => A): A
-} = dual(2, <A>(self: DateTime, f: (date: Date) => A): A => f(toDate(self)))
+} = Internal.withDate
 
 /**
  * Using the time zone adjusted `Date`, apply a function to the `Date` and
@@ -2181,12 +1852,14 @@ export const withDate: {
  * @since 3.6.0
  * @category mapping
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // get the date in milliseconds
  * DateTime.unsafeMake(0).pipe(
  *   DateTime.withDateUtc((date) => date.getTime())
  * )
+ * ```
  */
 export const withDateUtc: {
   /**
@@ -2196,12 +1869,14 @@ export const withDateUtc: {
    * @since 3.6.0
    * @category mapping
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // get the date in milliseconds
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.withDateUtc((date) => date.getTime())
    * )
+   * ```
    */
   <A>(f: (date: Date) => A): (self: DateTime) => A
   /**
@@ -2211,15 +1886,17 @@ export const withDateUtc: {
    * @since 3.6.0
    * @category mapping
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // get the date in milliseconds
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.withDateUtc((date) => date.getTime())
    * )
+   * ```
    */
   <A>(self: DateTime, f: (date: Date) => A): A
-} = dual(2, <A>(self: DateTime, f: (date: Date) => A): A => f(toDateUtc(self)))
+} = Internal.withDateUtc
 
 /**
  * @since 3.6.0
@@ -2247,10 +1924,7 @@ export const match: {
       readonly onZoned: (_: Zoned) => B
     }
   ): A | B
-} = dual(2, <A, B>(self: DateTime, options: {
-  readonly onUtc: (_: Utc) => A
-  readonly onZoned: (_: Zoned) => B
-}): A | B => self._tag === "Utc" ? options.onUtc(self) : options.onZoned(self))
+} = Internal.match
 
 // =============================================================================
 // math
@@ -2262,12 +1936,14 @@ export const match: {
  * @since 3.6.0
  * @category math
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // add 5 minutes
  * DateTime.unsafeMake(0).pipe(
  *   DateTime.addDuration("5 minutes")
  * )
+ * ```
  */
 export const addDuration: {
   // =============================================================================
@@ -2280,12 +1956,14 @@ export const addDuration: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // add 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.addDuration("5 minutes")
    * )
+   * ```
    */
   (duration: Duration.DurationInput): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
   // =============================================================================
@@ -2298,19 +1976,17 @@ export const addDuration: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // add 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.addDuration("5 minutes")
    * )
+   * ```
    */
   <A extends DateTime>(self: A, duration: Duration.DurationInput): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, duration: Duration.DurationInput): DateTime =>
-    mapEpochMillis(self, (millis) => millis + Duration.toMillis(duration))
-)
+} = Internal.addDuration
 
 /**
  * Subtract the given `Duration` from a `DateTime`.
@@ -2318,12 +1994,14 @@ export const addDuration: {
  * @since 3.6.0
  * @category math
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // subtract 5 minutes
  * DateTime.unsafeMake(0).pipe(
  *   DateTime.subtractDuration("5 minutes")
  * )
+ * ```
  */
 export const subtractDuration: {
   /**
@@ -2332,12 +2010,14 @@ export const subtractDuration: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // subtract 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.subtractDuration("5 minutes")
    * )
+   * ```
    */
   (duration: Duration.DurationInput): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
   /**
@@ -2346,23 +2026,17 @@ export const subtractDuration: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // subtract 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.subtractDuration("5 minutes")
    * )
+   * ```
    */
   <A extends DateTime>(self: A, duration: Duration.DurationInput): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, duration: Duration.DurationInput): DateTime =>
-    mapEpochMillis(self, (millis) => millis - Duration.toMillis(duration))
-)
-
-const addMillis = (date: Date, amount: number): void => {
-  date.setTime(date.getTime() + amount)
-}
+} = Internal.subtractDuration
 
 /**
  * Add the given `amount` of `unit`'s to a `DateTime`.
@@ -2373,12 +2047,14 @@ const addMillis = (date: Date, amount: number): void => {
  * @since 3.6.0
  * @category math
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // add 5 minutes
  * DateTime.unsafeMake(0).pipe(
  *   DateTime.add({ minutes: 5 })
  * )
+ * ```
  */
 export const add: {
   /**
@@ -2390,12 +2066,14 @@ export const add: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // add 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.add({ minutes: 5 })
    * )
+   * ```
    */
   (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
   /**
@@ -2407,54 +2085,17 @@ export const add: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // add 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.add({ minutes: 5 })
    * )
+   * ```
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, parts: Partial<DateTime.PartsForMath>): DateTime =>
-  mutate(self, (date) => {
-    if (parts.millis) {
-      addMillis(date, parts.millis)
-    }
-    if (parts.seconds) {
-      addMillis(date, parts.seconds * 1000)
-    }
-    if (parts.minutes) {
-      addMillis(date, parts.minutes * 60 * 1000)
-    }
-    if (parts.hours) {
-      addMillis(date, parts.hours * 60 * 60 * 1000)
-    }
-    if (parts.days) {
-      date.setUTCDate(date.getUTCDate() + parts.days)
-    }
-    if (parts.weeks) {
-      date.setUTCDate(date.getUTCDate() + parts.weeks * 7)
-    }
-    if (parts.months) {
-      const day = date.getUTCDate()
-      date.setUTCMonth(date.getUTCMonth() + parts.months + 1, 0)
-      if (day < date.getUTCDate()) {
-        date.setUTCDate(day)
-      }
-    }
-    if (parts.years) {
-      const day = date.getUTCDate()
-      const month = date.getUTCMonth()
-      date.setUTCFullYear(
-        date.getUTCFullYear() + parts.years,
-        month + 1,
-        0
-      )
-      if (day < date.getUTCDate()) {
-        date.setUTCDate(day)
-      }
-    }
-  }))
+} = Internal.add
 
 /**
  * Subtract the given `amount` of `unit`'s from a `DateTime`.
@@ -2462,12 +2103,14 @@ export const add: {
  * @since 3.6.0
  * @category math
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // subtract 5 minutes
  * DateTime.unsafeMake(0).pipe(
  *   DateTime.subtract({ minutes: 5 })
  * )
+ * ```
  */
 export const subtract: {
   /**
@@ -2476,12 +2119,14 @@ export const subtract: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // subtract 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.subtract({ minutes: 5 })
    * )
+   * ```
    */
   (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
   /**
@@ -2490,62 +2135,17 @@ export const subtract: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // subtract 5 minutes
    * DateTime.unsafeMake(0).pipe(
    *   DateTime.subtract({ minutes: 5 })
    * )
+   * ```
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, parts: Partial<DateTime.PartsForMath>): DateTime => {
-  const newParts = {} as Partial<Mutable<DateTime.PartsForMath>>
-  for (const key in parts) {
-    newParts[key as keyof DateTime.PartsForMath] = -1 * parts[key as keyof DateTime.PartsForMath]!
-  }
-  return add(self, newParts)
-})
-
-function startOfDate(date: Date, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}) {
-  switch (part) {
-    case "second": {
-      date.setUTCMilliseconds(0)
-      break
-    }
-    case "minute": {
-      date.setUTCSeconds(0, 0)
-      break
-    }
-    case "hour": {
-      date.setUTCMinutes(0, 0, 0)
-      break
-    }
-    case "day": {
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-    case "week": {
-      const weekStartsOn = options?.weekStartsOn ?? 0
-      const day = date.getUTCDay()
-      const diff = (day - weekStartsOn + 7) % 7
-      date.setUTCDate(date.getUTCDate() - diff)
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-    case "month": {
-      date.setUTCDate(1)
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-    case "year": {
-      date.setUTCMonth(0, 1)
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-  }
-}
+} = Internal.subtract
 
 /**
  * Converts a `DateTime` to the start of the given `part`.
@@ -2556,6 +2156,7 @@ function startOfDate(date: Date, part: DateTime.UnitSingular, options?: {
  * @since 3.6.0
  * @category math
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-01T00:00:00Z"
@@ -2563,6 +2164,7 @@ function startOfDate(date: Date, part: DateTime.UnitSingular, options?: {
  *   DateTime.startOf("day"),
  *   DateTime.formatIso
  * )
+ * ```
  */
 export const startOf: {
   /**
@@ -2574,6 +2176,7 @@ export const startOf: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // returns "2024-01-01T00:00:00Z"
@@ -2581,6 +2184,7 @@ export const startOf: {
    *   DateTime.startOf("day"),
    *   DateTime.formatIso
    * )
+   * ```
    */
   (
     part: DateTime.UnitSingular,
@@ -2597,6 +2201,7 @@ export const startOf: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // returns "2024-01-01T00:00:00Z"
@@ -2604,6 +2209,7 @@ export const startOf: {
    *   DateTime.startOf("day"),
    *   DateTime.formatIso
    * )
+   * ```
    */
   <A extends DateTime>(
     self: A,
@@ -2612,50 +2218,7 @@ export const startOf: {
       readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
     }
   ): DateTime.PreserveZone<A>
-} = dual(isDateTimeArgs, (self: DateTime, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}): DateTime => mutate(self, (date) => startOfDate(date, part, options)))
-
-function endOfDate(date: Date, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}) {
-  switch (part) {
-    case "second": {
-      date.setUTCMilliseconds(999)
-      break
-    }
-    case "minute": {
-      date.setUTCSeconds(59, 999)
-      break
-    }
-    case "hour": {
-      date.setUTCMinutes(59, 59, 999)
-      break
-    }
-    case "day": {
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-    case "week": {
-      const weekStartsOn = options?.weekStartsOn ?? 0
-      const day = date.getUTCDay()
-      const diff = (day - weekStartsOn + 7) % 7
-      date.setUTCDate(date.getUTCDate() - diff + 6)
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-    case "month": {
-      date.setUTCMonth(date.getUTCMonth() + 1, 0)
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-    case "year": {
-      date.setUTCMonth(11, 31)
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-  }
-}
+} = Internal.startOf
 
 /**
  * Converts a `DateTime` to the end of the given `part`.
@@ -2666,6 +2229,7 @@ function endOfDate(date: Date, part: DateTime.UnitSingular, options?: {
  * @since 3.6.0
  * @category math
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-01T23:59:59.999Z"
@@ -2673,6 +2237,7 @@ function endOfDate(date: Date, part: DateTime.UnitSingular, options?: {
  *   DateTime.endOf("day"),
  *   DateTime.formatIso
  * )
+ * ```
  */
 export const endOf: {
   /**
@@ -2684,6 +2249,7 @@ export const endOf: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // returns "2024-01-01T23:59:59.999Z"
@@ -2691,6 +2257,7 @@ export const endOf: {
    *   DateTime.endOf("day"),
    *   DateTime.formatIso
    * )
+   * ```
    */
   (
     part: DateTime.UnitSingular,
@@ -2707,6 +2274,7 @@ export const endOf: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // returns "2024-01-01T23:59:59.999Z"
@@ -2714,6 +2282,7 @@ export const endOf: {
    *   DateTime.endOf("day"),
    *   DateTime.formatIso
    * )
+   * ```
    */
   <A extends DateTime>(
     self: A,
@@ -2722,9 +2291,7 @@ export const endOf: {
       readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
     }
   ): DateTime.PreserveZone<A>
-} = dual(isDateTimeArgs, (self: DateTime, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}): DateTime => mutate(self, (date) => endOfDate(date, part, options)))
+} = Internal.endOf
 
 /**
  * Converts a `DateTime` to the nearest given `part`.
@@ -2735,6 +2302,7 @@ export const endOf: {
  * @since 3.6.0
  * @category math
  * @example
+ * ```ts
  * import { DateTime } from "effect"
  *
  * // returns "2024-01-02T00:00:00Z"
@@ -2742,6 +2310,7 @@ export const endOf: {
  *   DateTime.nearest("day"),
  *   DateTime.formatIso
  * )
+ * ```
  */
 export const nearest: {
   /**
@@ -2753,6 +2322,7 @@ export const nearest: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // returns "2024-01-02T00:00:00Z"
@@ -2760,6 +2330,7 @@ export const nearest: {
    *   DateTime.nearest("day"),
    *   DateTime.formatIso
    * )
+   * ```
    */
   (
     part: DateTime.UnitSingular,
@@ -2776,6 +2347,7 @@ export const nearest: {
    * @since 3.6.0
    * @category math
    * @example
+   * ```ts
    * import { DateTime } from "effect"
    *
    * // returns "2024-01-02T00:00:00Z"
@@ -2783,6 +2355,7 @@ export const nearest: {
    *   DateTime.nearest("day"),
    *   DateTime.formatIso
    * )
+   * ```
    */
   <A extends DateTime>(
     self: A,
@@ -2791,38 +2364,12 @@ export const nearest: {
       readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
     }
   ): DateTime.PreserveZone<A>
-} = dual(isDateTimeArgs, (self: DateTime, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}): DateTime =>
-  mutate(self, (date) => {
-    if (part === "milli") return
-    const millis = date.getTime()
-    const start = new Date(millis)
-    startOfDate(start, part, options)
-    const startMillis = start.getTime()
-    const end = new Date(millis)
-    endOfDate(end, part, options)
-    const endMillis = end.getTime() + 1
-    const diffStart = millis - startMillis
-    const diffEnd = endMillis - millis
-    if (diffStart < diffEnd) {
-      date.setTime(startMillis)
-    } else {
-      date.setTime(endMillis)
-    }
-  }))
+} = Internal.nearest
 
 // =============================================================================
 // formatting
 // =============================================================================
 
-const intlTimeZone = (self: TimeZone): string => {
-  if (self._tag === "Named") {
-    return self.id
-  }
-  return offsetToString(self.offset)
-}
-
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
  *
@@ -2835,6 +2382,10 @@ const intlTimeZone = (self: TimeZone): string => {
  * @category formatting
  */
 export const format: {
+  // =============================================================================
+  // formatting
+  // =============================================================================
+
   /**
    * Format a `DateTime` as a string using the `DateTimeFormat` API.
    *
@@ -2853,6 +2404,10 @@ export const format: {
       }
       | undefined
   ): (self: DateTime) => string
+  // =============================================================================
+  // formatting
+  // =============================================================================
+
   /**
    * Format a `DateTime` as a string using the `DateTimeFormat` API.
    *
@@ -2872,26 +2427,7 @@ export const format: {
       }
       | undefined
   ): string
-} = dual(isDateTimeArgs, (
-  self: DateTime,
-  options?:
-    | Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined
-    }
-    | undefined
-): string => {
-  try {
-    return new Intl.DateTimeFormat(options?.locale, {
-      timeZone: self._tag === "Utc" ? "UTC" : intlTimeZone(self.zone),
-      ...options
-    }).format(self.epochMillis)
-  } catch (_) {
-    return new Intl.DateTimeFormat(options?.locale, {
-      timeZone: "UTC",
-      ...options
-    }).format(toDate(self))
-  }
-})
+} = Internal.format
 
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
@@ -2933,14 +2469,7 @@ export const formatLocal: {
       }
       | undefined
   ): string
-} = dual(isDateTimeArgs, (
-  self: DateTime,
-  options?:
-    | Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined
-    }
-    | undefined
-): string => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMillis))
+} = Internal.formatLocal
 
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
@@ -2982,18 +2511,7 @@ export const formatUtc: {
       }
       | undefined
   ): string
-} = dual(isDateTimeArgs, (
-  self: DateTime,
-  options?:
-    | Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined
-    }
-    | undefined
-): string =>
-  new Intl.DateTimeFormat(options?.locale, {
-    ...options,
-    timeZone: "UTC"
-  }).format(self.epochMillis))
+} = Internal.formatUtc
 
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
@@ -3016,7 +2534,7 @@ export const formatIntl: {
    * @category formatting
    */
   (self: DateTime, format: Intl.DateTimeFormat): string
-} = dual(2, (self: DateTime, format: Intl.DateTimeFormat): string => format.format(self.epochMillis))
+} = Internal.formatIntl
 
 /**
  * Format a `DateTime` as a UTC ISO string.
@@ -3024,7 +2542,7 @@ export const formatIntl: {
  * @since 3.6.0
  * @category formatting
  */
-export const formatIso = (self: DateTime): string => toDateUtc(self).toISOString()
+export const formatIso: (self: DateTime) => string = Internal.formatIso
 
 /**
  * Format a `DateTime` as a time zone adjusted ISO date string.
@@ -3032,7 +2550,7 @@ export const formatIso = (self: DateTime): string => toDateUtc(self).toISOString
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoDate = (self: DateTime): string => toDate(self).toISOString().slice(0, 10)
+export const formatIsoDate: (self: DateTime) => string = Internal.formatIsoDate
 
 /**
  * Format a `DateTime` as a UTC ISO date string.
@@ -3040,7 +2558,7 @@ export const formatIsoDate = (self: DateTime): string => toDate(self).toISOStrin
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoDateUtc = (self: DateTime): string => toDateUtc(self).toISOString().slice(0, 10)
+export const formatIsoDateUtc: (self: DateTime) => string = Internal.formatIsoDateUtc
 
 /**
  * Format a `DateTime.Zoned` as a ISO string with an offset.
@@ -3048,10 +2566,7 @@ export const formatIsoDateUtc = (self: DateTime): string => toDateUtc(self).toIS
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoOffset = (self: DateTime): string => {
-  const date = toDate(self)
-  return self._tag === "Utc" ? date.toISOString() : `${date.toISOString().slice(0, -1)}${zonedOffsetIso(self)}`
-}
+export const formatIsoOffset: (self: DateTime) => string = Internal.formatIsoOffset
 
 /**
  * Format a `DateTime.Zoned` as a string.
@@ -3061,5 +2576,40 @@ export const formatIsoOffset = (self: DateTime): string => {
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoZoned = (self: Zoned): string =>
-  self.zone._tag === "Offset" ? formatIsoOffset(self) : `${formatIsoOffset(self)}[${self.zone.id}]`
+export const formatIsoZoned: (self: Zoned) => string = Internal.formatIsoZoned
+
+/**
+ * Create a Layer from the given time zone.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZone = (zone: TimeZone): Layer.Layer<CurrentTimeZone> => Layer.succeed(CurrentTimeZone, zone)
+
+/**
+ * Create a Layer from the given time zone offset.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZoneOffset = (offset: number): Layer.Layer<CurrentTimeZone> =>
+  Layer.succeed(CurrentTimeZone, Internal.zoneMakeOffset(offset))
+
+/**
+ * Create a Layer from the given IANA time zone identifier.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZoneNamed = (
+  zoneId: string
+): Layer.Layer<CurrentTimeZone, IllegalArgumentException> =>
+  Layer.effect(CurrentTimeZone, Internal.zoneMakeNamedEffect(zoneId))
+
+/**
+ * Create a Layer from the systems local time zone.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZoneLocal: Layer.Layer<CurrentTimeZone> = Layer.sync(CurrentTimeZone, zoneMakeLocal)