effect 4.0.5 → 4.0.6

package/src/ChannelSchema.ts

@@ -293,55 +293,7 @@ export const duplex: {
   InDone,
   R | In["EncodingServices"] | Out["DecodingServices"]
 > =>
-  encode(options.inputSchema)</**
-   * Wraps a channel so callers work with typed input and output chunks while the
-   * wrapped channel uses encoded chunks.
-   *
-   * **When to use**
-   *
-   * Use to expose typed input and output at a bidirectional channel boundary
-   * while the wrapped channel continues to operate on schema-encoded chunks.
-   *
-   * **Details**
-   *
-   * Values sent into the resulting channel are encoded with `inputSchema` before
-   * reaching the wrapped channel. Values emitted by the wrapped channel are
-   * decoded with `outputSchema` before they are emitted downstream. Schema
-   * failures are surfaced as `SchemaError`.
-   *
-   * @see {@link duplexUnknown} for the variant whose encoded side is intentionally untyped
-   * @see {@link encode} for encoding typed chunks at one-way channel boundaries
-   * @see {@link decode} for decoding encoded chunks at one-way channel boundaries
-   *
-   * @stability unstable
-   * @category combinators
-   * @since 4.0.0
-   */
-  InErr, /**
-   * Wraps a channel so callers work with typed input and output chunks while the
-   * wrapped channel uses encoded chunks.
-   *
-   * **When to use**
-   *
-   * Use to expose typed input and output at a bidirectional channel boundary
-   * while the wrapped channel continues to operate on schema-encoded chunks.
-   *
-   * **Details**
-   *
-   * Values sent into the resulting channel are encoded with `inputSchema` before
-   * reaching the wrapped channel. Values emitted by the wrapped channel are
-   * decoded with `outputSchema` before they are emitted downstream. Schema
-   * failures are surfaced as `SchemaError`.
-   *
-   * @see {@link duplexUnknown} for the variant whose encoded side is intentionally untyped
-   * @see {@link encode} for encoding typed chunks at one-way channel boundaries
-   * @see {@link decode} for decoding encoded chunks at one-way channel boundaries
-   *
-   * @stability unstable
-   * @category combinators
-   * @since 4.0.0
-   */
-  InDone>().pipe(
+  encode(options.inputSchema)<InErr, InDone>().pipe(
     Channel.pipeTo(self),
     Channel.pipeTo(decode(options.outputSchema)())
   ))

package/src/Chunk.ts

@@ -561,6 +561,11 @@ export const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, Chunk.Inf
  * Gets the value at an index in a `Chunk` safely, returning `None` when the index is
  * out of bounds.
  *
+ * **Details**
+ *
+ * The index is floored to an integer. `NaN` and infinite indexes are out of
+ * bounds. This never throws.
+ *
  * **Example** (Accessing elements safely)
  *
  * ```ts import.meta.vitest
@@ -585,6 +590,11 @@ export const get: {
    * Gets the value at an index in a `Chunk` safely, returning `None` when the index is
    * out of bounds.
    *
+   * **Details**
+   *
+   * The index is floored to an integer. `NaN` and infinite indexes are out of
+   * bounds. This never throws.
+   *
    * **Example** (Accessing elements safely)
    *
    * ```ts import.meta.vitest
@@ -609,6 +619,11 @@ export const get: {
    * Gets the value at an index in a `Chunk` safely, returning `None` when the index is
    * out of bounds.
    *
+   * **Details**
+   *
+   * The index is floored to an integer. `NaN` and infinite indexes are out of
+   * bounds. This never throws.
+   *
    * **Example** (Accessing elements safely)
    *
    * ```ts import.meta.vitest
@@ -631,8 +646,10 @@ export const get: {
   <A>(self: Chunk<A>, index: number): Option<A>
 } = dual(
   2,
-  <A>(self: Chunk<A>, index: number): Option<A> =>
-    index < 0 || index >= self.length ? O.none() : O.some(getUnsafe(self, index))
+  <A>(self: Chunk<A>, index: number): Option<A> => {
+    const i = Math.floor(index)
+    return i >= 0 && i < self.length ? O.some(getUnchecked(self, i)) : O.none()
+  }
 )
 
 /**
@@ -710,7 +727,8 @@ export const fromNonEmptyArrayUnsafe = <A>(self: NonEmptyReadonlyArray<A>): NonE
  *
  * **Gotchas**
  *
- * Throws if the index is out of bounds.
+ * Throws if the floored index is out of bounds, including for `NaN` and
+ * infinite indexes.
  *
  * **Example** (Accessing elements unsafely)
  *
@@ -741,7 +759,8 @@ export const getUnsafe: {
    *
    * **Gotchas**
    *
-   * Throws if the index is out of bounds.
+   * Throws if the floored index is out of bounds, including for `NaN` and
+   * infinite indexes.
    *
    * **Example** (Accessing elements unsafely)
    *
@@ -772,7 +791,8 @@ export const getUnsafe: {
    *
    * **Gotchas**
    *
-   * Throws if the index is out of bounds.
+   * Throws if the floored index is out of bounds, including for `NaN` and
+   * infinite indexes.
    *
    * **Example** (Accessing elements unsafely)
    *
@@ -795,32 +815,33 @@ export const getUnsafe: {
   <A>(self: Chunk<A>, index: number): A
 } = dual(2, <A>(self: Chunk<A>, index: number): A => {
   const i = Math.floor(index)
+  if (!(i >= 0 && i < self.length)) {
+    throw new Error(`Index out of bounds: ${i}`)
+  }
+  return getUnchecked(self, i)
+})
+
+const getUnchecked = <A>(self: Chunk<A>, i: number): A => {
   switch (self.backing._tag) {
     case "IEmpty": {
       throw new Error(`Index out of bounds: ${i}`)
     }
     case "ISingleton": {
-      if (index !== 0) {
-        throw new Error(`Index out of bounds: ${i}`)
-      }
       return self.backing.a
     }
     case "IArray": {
-      if (i >= self.length || i < 0) {
-        throw new Error(`Index out of bounds: ${i}`)
-      }
       return self.backing.array[i]!
     }
     case "IConcat": {
       return i < self.left.length
-        ? getUnsafe(self.left, i)
-        : getUnsafe(self.right, i - self.left.length)
+        ? getUnchecked(self.left, i)
+        : getUnchecked(self.right, i - self.left.length)
     }
     case "ISlice": {
-      return getUnsafe(self.backing.chunk, i + self.backing.offset)
+      return getUnchecked(self.backing.chunk, i + self.backing.offset)
     }
   }
-})
+}
 
 /**
  * Appends the specified element to the end of the `Chunk`.
@@ -1532,34 +1553,7 @@ export const appendAll: {
   }
   const diff = that.depth - self.depth
   if (Math.abs(diff) <= 1) {
-    return makeChunk</**
-     * Concatenates two chunks, combining their elements.
-     * If either chunk is non-empty, the result is also a non-empty chunk.
-     *
-     * **When to use**
-     *
-     * Use to concatenate two chunks when the second chunk's elements should come
-     * after the first.
-     *
-     * **Example** (Appending all elements)
-     *
-     * ```ts import.meta.vitest
-     * import { Chunk } from "effect"
-     *
-     * Chunk.make(1, 2).pipe(
-     *   Chunk.appendAll(Chunk.make("a", "b")),
-     *   Chunk.toArray
-     * ) // => [1, 2, "a", "b"]
-     * ```
-     *
-     * @see {@link prependAll} for concatenating chunks in the opposite order
-     * @see {@link append} for adding a single element to the end
-     *
-     * @stability stable
-     * @category combining
-     * @since 2.0.0
-     */
-    A | B>({ _tag: "IConcat", left: self, right: that });
+    return makeChunk<A | B>({ _tag: "IConcat", left: self, right: that })
   } else if (diff < -1) {
     if (self.left.depth >= self.right.depth) {
       const nr = appendAll(self.right, that)
@@ -3929,7 +3923,12 @@ export const takeWhile: {
 })
 
 /**
- * Creates a Chunks of unique values, in order, from all given Chunks.
+ * Computes the union of two chunks using Effect equality.
+ *
+ * **Gotchas**
+ *
+ * Each input must already be deduplicated. Use {@link dedupe} to remove
+ * duplicates from an input first.
  *
  * **Example** (Unioning chunks)
  *
@@ -3939,11 +3938,6 @@ export const takeWhile: {
  * const chunk1 = Chunk.make(1, 2, 3)
  * const chunk2 = Chunk.make(3, 4, 5)
  * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
- *
- * // Handles duplicates within the same chunk
- * const withDupes1 = Chunk.make(1, 1, 2)
- * const withDupes2 = Chunk.make(2, 3, 3)
- * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
  * ```
  *
  * @stability stable
@@ -3952,7 +3946,12 @@ export const takeWhile: {
  */
 export const union: {
   /**
-   * Creates a Chunks of unique values, in order, from all given Chunks.
+   * Computes the union of two chunks using Effect equality.
+   *
+   * **Gotchas**
+   *
+   * Each input must already be deduplicated. Use {@link dedupe} to remove
+   * duplicates from an input first.
    *
    * **Example** (Unioning chunks)
    *
@@ -3962,11 +3961,6 @@ export const union: {
    * const chunk1 = Chunk.make(1, 2, 3)
    * const chunk2 = Chunk.make(3, 4, 5)
    * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
-   *
-   * // Handles duplicates within the same chunk
-   * const withDupes1 = Chunk.make(1, 1, 2)
-   * const withDupes2 = Chunk.make(2, 3, 3)
-   * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
    * ```
    *
    * @stability stable
@@ -3975,7 +3969,12 @@ export const union: {
    */
   <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>
   /**
-   * Creates a Chunks of unique values, in order, from all given Chunks.
+   * Computes the union of two chunks using Effect equality.
+   *
+   * **Gotchas**
+   *
+   * Each input must already be deduplicated. Use {@link dedupe} to remove
+   * duplicates from an input first.
    *
    * **Example** (Unioning chunks)
    *
@@ -3985,11 +3984,6 @@ export const union: {
    * const chunk1 = Chunk.make(1, 2, 3)
    * const chunk2 = Chunk.make(3, 4, 5)
    * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
-   *
-   * // Handles duplicates within the same chunk
-   * const withDupes1 = Chunk.make(1, 1, 2)
-   * const withDupes2 = Chunk.make(2, 3, 3)
-   * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
    * ```
    *
    * @stability stable

package/src/Config.ts

@@ -671,50 +671,7 @@ export const orElse: {
    */
   <A, A2>(self: Config<A>, that: (error: ConfigError) => Config<A2>): Config<A | A2>
 } = dual(2, <A, A2>(self: Config<A>, that: (error: ConfigError) => Config<A2>): Config<A | A2> => {
-  return make</**
-   * Provides a fallback config when parsing fails with a `ConfigError`.
-   *
-   * **When to use**
-   *
-   * Use when you need to try an alternative config source after the primary one
-   * fails.
-   *
-   * **Details**
-   *
-   * Unlike {@link withDefault}, this handles both semantic absence and **all**
-   * `ConfigError`s. The fallback function receives the error and returns a new
-   * `Config`.
-   *
-   * **Gotchas**
-   *
-   * The fallback's result replaces the original failure. If the fallback is
-   * absent, an outer {@link withDefault} or {@link option} can recover it. If the
-   * fallback fails, only its error propagates. Defects and interruptions never
-   * reach the fallback; they propagate unchanged.
-   *
-   * **Example** (Trying another port before using a default)
-   *
-   * ```ts import.meta.vitest
-   * import { Config, ConfigProvider, Effect } from "effect"
-   *
-   * const port = Config.Int("PORT").pipe(
-   *   Config.orElse(() => Config.Int("BACKUP_PORT")),
-   *   Config.withDefault(3000)
-   * )
-   * const provider = ConfigProvider.fromUnknown({ PORT: "invalid", BACKUP_PORT: "8080" })
-   * await Effect.runPromise(port.parse(provider)) // => 8080
-   *
-   * const missingBackup = ConfigProvider.fromUnknown({ PORT: "invalid" })
-   * await Effect.runPromise(port.parse(missingBackup)) // => 3000
-   * ```
-   *
-   * @see {@link withDefault} – fallback only on semantic absence
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  A | A2>((provider, pathPrefix) =>
+  return make<A | A2>((provider, pathPrefix) =>
     Effect.matchCauseEffect(evaluateAt(self, provider, pathPrefix), {
       // Only plain failures reach the fallback; defects and interruptions propagate unchanged.
       onFailure: (cause) => {
@@ -728,7 +685,7 @@ export const orElse: {
           ? evaluateAt(that(resolution.failure), provider, pathPrefix)
           : Effect.succeed(resolution)
     })
-  );
+  )
 })
 
 /**
@@ -916,48 +873,12 @@ export const withDefault: {
    */
   <A, const A2>(self: Config<A>, defaultValue: A2): Config<A | A2>
 } = dual(2, <A, const A2>(self: Config<A>, defaultValue: A2): Config<A | A2> => {
-  return make</**
-   * Provides a fallback value when the config is absent.
-   *
-   * **When to use**
-   *
-   * Use when you need to make a config key optional with a sensible default.
-   *
-   * **Gotchas**
-   *
-   * Validation and source errors still propagate. For an {@link all} group, any
-   * absent child causes the default to replace the entire group unless another
-   * child fails. Apply defaults to individual children to preserve other values.
-   *
-   * A schema that successfully decodes absent input keeps its decoded value
-   * instead of using the default. Schema configs first represent a missing or
-   * incompatible provider shape as `undefined`; the default is used only when
-   * the schema rejects that value and no relevant input was found.
-   *
-   * **Example** (Defaulting a missing port)
-   *
-   * ```ts import.meta.vitest
-   * import { Config, ConfigProvider, Effect } from "effect"
-   *
-   * const port = Config.Number("port").pipe(Config.withDefault(3000))
-   *
-   * const provider = ConfigProvider.fromUnknown({})
-   * Effect.runSync(port.parse(provider)) // => 3000
-   * ```
-   *
-   * @see {@link option} – returns `Option` instead of a default value
-   * @see {@link orElse} – catches all errors, not just absent input
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  A | A2>((provider, pathPrefix) =>
+  return make<A | A2>((provider, pathPrefix) =>
     Effect.mapEager(
       evaluateAt(self, provider, pathPrefix),
       (resolution) => Result.isFailure(resolution) ? Result.succeed(defaultValue) : resolution
     )
-  );
+  )
 })
 
 /**
@@ -1171,7 +1092,6 @@ const toConfigCursorAST = memoize((root: SchemaAST.AST): SchemaAST.AST => {
     seen.add(ast)
     switch (ast._tag) {
       case "Objects": {
-        const matchesIndex = ast.indexSignatures.map((is) => SchemaParser._is(is.parameter))
         const materialize = Effect.fnUntraced(function*(cursor: ConfigCursor) {
           if (cursor.node?._tag !== "Record") {
             return undefined
@@ -1181,9 +1101,15 @@ const toConfigCursorAST = memoize((root: SchemaAST.AST): SchemaAST.AST => {
           for (const property of ast.propertySignatures) {
             if (typeof property.name === "string") keys.add(property.name)
           }
-          if (matchesIndex.length > 0) {
+          if (ast.indexSignatures.length > 0) {
+            const input: Record<string, undefined> = {}
             for (const key of node.keys) {
-              if (matchesIndex.some((matches) => matches(key))) keys.add(key)
+              InternalRecord.assignProperty(input, key, undefined)
+            }
+            for (const is of ast.indexSignatures) {
+              for (const key of SchemaAST.getIndexSignatureKeys(input, is.parameter)) {
+                if (typeof key === "string") keys.add(key)
+              }
             }
           }
           const out: Record<string, ConfigCursor> = {}

package/src/ConfigProvider.ts

@@ -1391,11 +1391,12 @@ function interpolate(
   parsed: Record<string, string>,
   seen: ReadonlySet<string>
 ): string {
-  const reference = /(?<!\\)\${?(\w+)/g
+  const reference = /\${?(\w+)/g
   let result = ""
   let cursor = 0
   let match: RegExpExecArray | null
   while ((match = reference.exec(envValue)) != null) {
+    if (match.index > 0 && envValue[match.index - 1] === "\\") continue
     const [, name] = match
     let end = reference.lastIndex
     let defaultValue = ""

package/src/Cron.ts

@@ -815,8 +815,8 @@ export const next = (cron: Cron, now?: DateTime.DateTime.Input): Date => {
  *
  * **Gotchas**
  *
- * The search is strict: if the supplied date/time already matches the schedule,
- * the result is the earlier occurrence.
+ * The search is strict: if the supplied date/time is exactly an occurrence of
+ * the schedule, the result is the earlier occurrence.
  *
  * @see {@link next} for finding the next scheduled occurrence
  *
@@ -866,7 +866,10 @@ const stepCron = (cron: Cron, now: DateTime.DateTime.Input | undefined, directio
     }).epochMilliseconds <= zoned.epochMilliseconds
 
   const result = dateTime.mutate(zoned, (current) => {
-    current.setUTCSeconds(current.getUTCSeconds() + tick, 0)
+    // Start from the nearest whole second strictly past the input in the search
+    // direction. Going backward, a fractional input already has one.
+    const offset = reverse && current.getUTCMilliseconds() > 0 ? 0 : tick
+    current.setUTCSeconds(current.getUTCSeconds() + offset, 0)
 
     for (let i = 0; i < 10_000; i++) {
       if (cron.seconds.size !== 0) {

package/src/Duration.ts

@@ -35,6 +35,10 @@ const bigint60 = BigInt(60)
 const bigint1e3 = BigInt(1_000)
 const bigint1e6 = BigInt(1_000_000)
 const bigint1e9 = BigInt(1_000_000_000)
+const bigintNanosPerMinute = BigInt(60_000_000_000)
+const bigintNanosPerHour = BigInt(3_600_000_000_000)
+const bigintNanosPerDay = BigInt(86_400_000_000_000)
+const bigintNanosPerWeek = BigInt(604_800_000_000_000)
 
 const roundTiesAwayFromZero = (input: number): bigint => BigInt(Math.sign(input) * Math.round(Math.abs(input)))
 
@@ -43,6 +47,14 @@ const roundMillisToNanos = (millis: number): bigint =>
 
 const fromNanosNumber = (nanos: number): Duration => make(Number.isFinite(nanos) ? roundTiesAwayFromZero(nanos) : nanos)
 
+const nanosToUnit = (nanos: bigint, divisor: number): number => {
+  const value = Number(nanos)
+  // Preserve ordinary-input rounding; scale first only when nanoseconds overflow.
+  if (Number.isFinite(value)) return value / divisor
+  const scale = BigInt(divisor)
+  return Number(nanos / scale) + Number(nanos % scale) / divisor
+}
+
 const parseNanos = (input: string, scale: bigint): bigint => {
   const decimalIndex = input.indexOf(".")
   if (decimalIndex === -1) return BigInt(input) * scale
@@ -62,6 +74,14 @@ const divideTiesAwayFromZero = (numerator: bigint, denominator: bigint): bigint
   return numerator < bigint0 ? -rounded : rounded
 }
 
+const fromMillisString = (input: string, scale: number): Duration => {
+  const millis = Number(input) * scale
+  if (!Number.isFinite(millis)) return make(millis)
+  const nanos = parseNanos(input, BigInt(scale) * bigint1e6)
+  // Keep the millisecond representation only when it preserves the exact value.
+  return make(Number.isInteger(millis) && BigInt(millis) * bigint1e6 === nanos ? millis : nanos)
+}
+
 const nanosToHrTime = (nanos: bigint): [seconds: number, nanos: number] => {
   const sign = nanos < bigint0 ? -bigint1 : bigint1
   const absolute = nanos < bigint0 ? -nanos : nanos
@@ -274,26 +294,25 @@ export const fromInputUnsafe = (input: Input): Duration => {
       if (unit === "micro" || unit === "micros") {
         return nanos(parseNanos(valueStr, bigint1e3))
       }
-      const value = Number(valueStr)
       switch (unit) {
         case "milli":
         case "millis":
-          return millis(value)
+          return fromMillisString(valueStr, 1)
         case "second":
         case "seconds":
-          return seconds(value)
+          return fromMillisString(valueStr, 1_000)
         case "minute":
         case "minutes":
-          return minutes(value)
+          return fromMillisString(valueStr, 60_000)
         case "hour":
         case "hours":
-          return hours(value)
+          return fromMillisString(valueStr, 3_600_000)
         case "day":
         case "days":
-          return days(value)
+          return fromMillisString(valueStr, 86_400_000)
         case "week":
         case "weeks":
-          return weeks(value)
+          return fromMillisString(valueStr, 604_800_000)
       }
       break
     }
@@ -313,7 +332,10 @@ export const fromInputUnsafe = (input: Input): Duration => {
         if (input[0] === Infinity || input[1] === Infinity) {
           return infinity
         }
-        return fromNanosNumber(input[0] * 1_000_000_000 + input[1])
+        const nanos = input[0] * 1_000_000_000 + input[1]
+        return Number.isFinite(nanos) && Number.isInteger(input[0]) && Number.isInteger(input[1])
+          ? make(BigInt(input[0]) * bigint1e9 + BigInt(input[1]))
+          : fromNanosNumber(nanos)
       }
       const obj = input as DurationObject
       let millis = 0
@@ -324,13 +346,41 @@ export const fromInputUnsafe = (input: Input): Duration => {
       if (obj.minutes) millis += obj.minutes * 60_000
       if (obj.seconds) millis += obj.seconds * 1_000
       if (obj.milliseconds) millis += obj.milliseconds
-      if (!obj.microseconds && !obj.nanoseconds) return make(millis)
-      return fromNanosNumber(millis * 1_000_000 + (obj.microseconds ?? 0) * 1_000 + (obj.nanoseconds ?? 0))
+      if (!obj.microseconds && !obj.nanoseconds) {
+        if (!Number.isFinite(millis)) return make(millis)
+        const exact = sumObjectNanos(obj)
+        // keep the Millis representation when the numeric total is already exact
+        return exact === undefined || BigInt(millis) * bigint1e6 === exact ? make(millis) : make(exact)
+      }
+      const nanos = millis * 1_000_000 + (obj.microseconds ?? 0) * 1_000 + (obj.nanoseconds ?? 0)
+      const exact = Number.isFinite(nanos) ? sumObjectNanos(obj) : undefined
+      return exact === undefined ? fromNanosNumber(nanos) : make(exact)
     }
   }
   return invalid(input)
 }
 
+const isIntegerOrUnset = (n: number | undefined): boolean => !n || Number.isInteger(n)
+
+// sums the fields exactly, or returns undefined if any field is fractional
+const sumObjectNanos = (obj: DurationObject): bigint | undefined => {
+  if (
+    !isIntegerOrUnset(obj.weeks) || !isIntegerOrUnset(obj.days) || !isIntegerOrUnset(obj.hours) ||
+    !isIntegerOrUnset(obj.minutes) || !isIntegerOrUnset(obj.seconds) || !isIntegerOrUnset(obj.milliseconds) ||
+    !isIntegerOrUnset(obj.microseconds) || !isIntegerOrUnset(obj.nanoseconds)
+  ) return undefined
+  let nanos = bigint0
+  if (obj.weeks) nanos += BigInt(obj.weeks) * bigintNanosPerWeek
+  if (obj.days) nanos += BigInt(obj.days) * bigintNanosPerDay
+  if (obj.hours) nanos += BigInt(obj.hours) * bigintNanosPerHour
+  if (obj.minutes) nanos += BigInt(obj.minutes) * bigintNanosPerMinute
+  if (obj.seconds) nanos += BigInt(obj.seconds) * bigint1e9
+  if (obj.milliseconds) nanos += BigInt(obj.milliseconds) * bigint1e6
+  if (obj.microseconds) nanos += BigInt(obj.microseconds) * bigint1e3
+  if (obj.nanoseconds) nanos += BigInt(obj.nanoseconds)
+  return nanos
+}
+
 const invalid = (input: unknown): never => {
   throw new Error(`Invalid Input: ${input}`)
 }
@@ -817,7 +867,7 @@ export const weeks = (weeks: number): Duration => make(weeks * 604_800_000)
 export const toMillis = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: identity,
-    onNanos: (nanos) => Number(nanos) / 1_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 1_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -841,7 +891,7 @@ export const toMillis = (self: Input): number =>
 export const toSeconds = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 1_000,
-    onNanos: (nanos) => Number(nanos) / 1_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 1_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -865,7 +915,7 @@ export const toSeconds = (self: Input): number =>
 export const toMinutes = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 60_000,
-    onNanos: (nanos) => Number(nanos) / 60_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 60_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -889,7 +939,7 @@ export const toMinutes = (self: Input): number =>
 export const toHours = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 3_600_000,
-    onNanos: (nanos) => Number(nanos) / 3_600_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 3_600_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -913,7 +963,7 @@ export const toHours = (self: Input): number =>
 export const toDays = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 86_400_000,
-    onNanos: (nanos) => Number(nanos) / 86_400_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 86_400_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -937,7 +987,7 @@ export const toDays = (self: Input): number =>
 export const toWeeks = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 604_800_000,
-    onNanos: (nanos) => Number(nanos) / 604_800_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 604_800_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })