effect 4.0.0-beta.102 → 4.0.0-beta.104

package/src/Unify.ts

@@ -178,7 +178,7 @@ type FilterOut<A> = A extends any ? typeSymbol extends keyof A ? never : A : nev
  *
  * **Example** (Unifying protocol types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Unify } from "effect"
  *
  * // Example of types that can be unified
@@ -196,7 +196,8 @@ type FilterOut<A> = A extends any ? typeSymbol extends keyof A ? never : A : nev
  *
  * // Unify automatically handles the union
  * type Unified = Unify.Unify<UnifiableA | UnifiableB>
- * // Results in a properly unified type
+ *
+ * const witness: Unified = "value"
  * ```
  *
  * @see {@link unify} for applying this normalization to a value or function
@@ -243,27 +244,24 @@ export type Unify<A> = Values<
  *
  * **Example** (Unifying values and function results)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Unify } from "effect"
  *
  * // Unify a simple value
- * const unifiedValue = Unify.unify("hello")
+ * const unifiedValue = Unify.unify("hello") // => "hello"
  * // Type: string
  *
  * // Unify a function result
- * const createUnifiableValue = () => ({
- *   value: "test",
- *   [Unify.typeSymbol]: "string" as const,
- *   [Unify.unifySymbol]: { String: () => "test" as const }
- * })
+ * const createValue = () => ({ value: "test" })
  *
- * const unifiedFunction = Unify.unify(createUnifiableValue)
- * // The result will be properly unified
+ * const unifiedFunction = Unify.unify(createValue)
+ * unifiedFunction().value // => "test"
  *
  * // Unify with curried functions
  * const curriedFunction = (a: string) => (b: number) => ({ result: a + b })
  * const unifiedCurried = Unify.unify(curriedFunction)
  * // Type: (a: string) => (b: number) => Unify<{ result: string }>
+ * unifiedCurried("value-")(1).result // => "value-1"
  * ```
  *
  * @see {@link Unify} for the type-level normalization applied by this helper
@@ -288,27 +286,24 @@ export const unify: {
    *
    * **Example** (Unifying values and function results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Unify } from "effect"
    *
    * // Unify a simple value
-   * const unifiedValue = Unify.unify("hello")
+   * const unifiedValue = Unify.unify("hello") // => "hello"
    * // Type: string
    *
    * // Unify a function result
-   * const createUnifiableValue = () => ({
-   *   value: "test",
-   *   [Unify.typeSymbol]: "string" as const,
-   *   [Unify.unifySymbol]: { String: () => "test" as const }
-   * })
+   * const createValue = () => ({ value: "test" })
    *
-   * const unifiedFunction = Unify.unify(createUnifiableValue)
-   * // The result will be properly unified
+   * const unifiedFunction = Unify.unify(createValue)
+   * unifiedFunction().value // => "test"
    *
    * // Unify with curried functions
    * const curriedFunction = (a: string) => (b: number) => ({ result: a + b })
    * const unifiedCurried = Unify.unify(curriedFunction)
    * // Type: (a: string) => (b: number) => Unify<{ result: string }>
+   * unifiedCurried("value-")(1).result // => "value-1"
    * ```
    *
    * @see {@link Unify} for the type-level normalization applied by this helper
@@ -342,27 +337,24 @@ export const unify: {
    *
    * **Example** (Unifying values and function results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Unify } from "effect"
    *
    * // Unify a simple value
-   * const unifiedValue = Unify.unify("hello")
+   * const unifiedValue = Unify.unify("hello") // => "hello"
    * // Type: string
    *
    * // Unify a function result
-   * const createUnifiableValue = () => ({
-   *   value: "test",
-   *   [Unify.typeSymbol]: "string" as const,
-   *   [Unify.unifySymbol]: { String: () => "test" as const }
-   * })
+   * const createValue = () => ({ value: "test" })
    *
-   * const unifiedFunction = Unify.unify(createUnifiableValue)
-   * // The result will be properly unified
+   * const unifiedFunction = Unify.unify(createValue)
+   * unifiedFunction().value // => "test"
    *
    * // Unify with curried functions
    * const curriedFunction = (a: string) => (b: number) => ({ result: a + b })
    * const unifiedCurried = Unify.unify(curriedFunction)
    * // Type: (a: string) => (b: number) => Unify<{ result: string }>
+   * unifiedCurried("value-")(1).result // => "value-1"
    * ```
    *
    * @see {@link Unify} for the type-level normalization applied by this helper
@@ -395,27 +387,24 @@ export const unify: {
    *
    * **Example** (Unifying values and function results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Unify } from "effect"
    *
    * // Unify a simple value
-   * const unifiedValue = Unify.unify("hello")
+   * const unifiedValue = Unify.unify("hello") // => "hello"
    * // Type: string
    *
    * // Unify a function result
-   * const createUnifiableValue = () => ({
-   *   value: "test",
-   *   [Unify.typeSymbol]: "string" as const,
-   *   [Unify.unifySymbol]: { String: () => "test" as const }
-   * })
+   * const createValue = () => ({ value: "test" })
    *
-   * const unifiedFunction = Unify.unify(createUnifiableValue)
-   * // The result will be properly unified
+   * const unifiedFunction = Unify.unify(createValue)
+   * unifiedFunction().value // => "test"
    *
    * // Unify with curried functions
    * const curriedFunction = (a: string) => (b: number) => ({ result: a + b })
    * const unifiedCurried = Unify.unify(curriedFunction)
    * // Type: (a: string) => (b: number) => Unify<{ result: string }>
+   * unifiedCurried("value-")(1).result // => "value-1"
    * ```
    *
    * @see {@link Unify} for the type-level normalization applied by this helper
@@ -445,27 +434,24 @@ export const unify: {
    *
    * **Example** (Unifying values and function results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Unify } from "effect"
    *
    * // Unify a simple value
-   * const unifiedValue = Unify.unify("hello")
+   * const unifiedValue = Unify.unify("hello") // => "hello"
    * // Type: string
    *
    * // Unify a function result
-   * const createUnifiableValue = () => ({
-   *   value: "test",
-   *   [Unify.typeSymbol]: "string" as const,
-   *   [Unify.unifySymbol]: { String: () => "test" as const }
-   * })
+   * const createValue = () => ({ value: "test" })
    *
-   * const unifiedFunction = Unify.unify(createUnifiableValue)
-   * // The result will be properly unified
+   * const unifiedFunction = Unify.unify(createValue)
+   * unifiedFunction().value // => "test"
    *
    * // Unify with curried functions
    * const curriedFunction = (a: string) => (b: number) => ({ result: a + b })
    * const unifiedCurried = Unify.unify(curriedFunction)
    * // Type: (a: string) => (b: number) => Unify<{ result: string }>
+   * unifiedCurried("value-")(1).result // => "value-1"
    * ```
    *
    * @see {@link Unify} for the type-level normalization applied by this helper
@@ -494,27 +480,24 @@ export const unify: {
    *
    * **Example** (Unifying values and function results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Unify } from "effect"
    *
    * // Unify a simple value
-   * const unifiedValue = Unify.unify("hello")
+   * const unifiedValue = Unify.unify("hello") // => "hello"
    * // Type: string
    *
    * // Unify a function result
-   * const createUnifiableValue = () => ({
-   *   value: "test",
-   *   [Unify.typeSymbol]: "string" as const,
-   *   [Unify.unifySymbol]: { String: () => "test" as const }
-   * })
+   * const createValue = () => ({ value: "test" })
    *
-   * const unifiedFunction = Unify.unify(createUnifiableValue)
-   * // The result will be properly unified
+   * const unifiedFunction = Unify.unify(createValue)
+   * unifiedFunction().value // => "test"
    *
    * // Unify with curried functions
    * const curriedFunction = (a: string) => (b: number) => ({ result: a + b })
    * const unifiedCurried = Unify.unify(curriedFunction)
    * // Type: (a: string) => (b: number) => Unify<{ result: string }>
+   * unifiedCurried("value-")(1).result // => "value-1"
    * ```
    *
    * @see {@link Unify} for the type-level normalization applied by this helper
@@ -542,27 +525,24 @@ export const unify: {
    *
    * **Example** (Unifying values and function results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Unify } from "effect"
    *
    * // Unify a simple value
-   * const unifiedValue = Unify.unify("hello")
+   * const unifiedValue = Unify.unify("hello") // => "hello"
    * // Type: string
    *
    * // Unify a function result
-   * const createUnifiableValue = () => ({
-   *   value: "test",
-   *   [Unify.typeSymbol]: "string" as const,
-   *   [Unify.unifySymbol]: { String: () => "test" as const }
-   * })
+   * const createValue = () => ({ value: "test" })
    *
-   * const unifiedFunction = Unify.unify(createUnifiableValue)
-   * // The result will be properly unified
+   * const unifiedFunction = Unify.unify(createValue)
+   * unifiedFunction().value // => "test"
    *
    * // Unify with curried functions
    * const curriedFunction = (a: string) => (b: number) => ({ result: a + b })
    * const unifiedCurried = Unify.unify(curriedFunction)
    * // Type: (a: string) => (b: number) => Unify<{ result: string }>
+   * unifiedCurried("value-")(1).result // => "value-1"
    * ```
    *
    * @see {@link Unify} for the type-level normalization applied by this helper

package/src/Utils.ts

@@ -31,18 +31,14 @@ import type * as Types from "./Types.ts"
  *
  * **Example** (Yielding a wrapped value in a generator)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Utils } from "effect"
  *
  * const gen = new Utils.SingleShotGen<string, number>("hello")
  *
- * // First call yields the wrapped value
- * console.log(gen.next(0))
- * // { value: "hello", done: false }
+ * gen.next(0) // => { value: "hello", done: false }
  *
- * // Second call signals completion with the provided value
- * console.log(gen.next(42))
- * // { value: 42, done: true }
+ * gen.next(42) // => { value: 42, done: true }
  * ```
  *
  * @see {@link Gen} for the type-level signature that relies on `SingleShotGen`
@@ -113,15 +109,21 @@ export class SingleShotGen<T, A> implements IterableIterator<T, A> {
  *
  * **Example** (Declaring variance for a TypeLambda)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Option, Utils } from "effect"
  *
- * declare const variance: Utils.Variance<
+ * const variance: Utils.Variance<
  *   Option.OptionTypeLambda,
- *   never,
- *   never,
- *   never
- * >
+ *   unknown,
+ *   string,
+ *   string
+ * > = {
+ *   _F: (value) => value,
+ *   _R: () => {},
+ *   _O: () => "output",
+ *   _E: () => "error"
+ * }
+ * Array.of(variance._O(undefined as never), variance._E(undefined as never)) // => ["output", "error"]
  * ```
  *
  * @see {@link Gen} for the type-level signature that uses `Variance`
@@ -152,10 +154,15 @@ export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
  *
  * **Example** (Typing a gen function for Option)
  *
- * ```ts
- * import type { Option, Utils } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option } from "effect"
+ * import type { Utils } from "effect"
  *
- * declare const gen: Utils.Gen<Option.OptionTypeLambda>
+ * const gen: Utils.Gen<Option.OptionTypeLambda> = Option.gen
+ * const result = gen(function*() {
+ *   return yield* Option.some(1)
+ * })
+ * result // => Option.some(1)
  * ```
  *
  * @see {@link Variance} for encoding the variance used for inference

package/src/internal/core.ts

@@ -239,7 +239,7 @@ export abstract class ReasonBase<Tag extends string> implements Cause.Cause.Reas
 }
 
 /** @internal */
-export const constEmptyAnnotations = new Map<string, unknown>()
+export const constEmptyAnnotations: ReadonlyMap<string, unknown> = new Map<string, unknown>()
 
 /** @internal */
 export class Fail<E> extends ReasonBase<"Fail"> implements Cause.Fail<E> {
@@ -471,12 +471,12 @@ export const makeExit = <
   ) => Primitive | Yield
 }): Fn => {
   const Proto = {
-    ...makePrimitiveProto(options),
     [ExitTypeId]: ExitTypeId,
     _tag: options.op,
     get [options.prop](): any {
       return (this as any)[args]
     },
+    ...makePrimitiveProto(options),
     toString(this: any) {
       return `${options.op}(${format(this[args])})`
     },

package/src/internal/dateTime.ts

@@ -221,7 +221,7 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
     return fromDateUnsafe(input) as DateTime.DateTime.PreserveZone<A>
   } else if (typeof input === "object") {
     if ("epochMilliseconds" in input) {
-      return makeUtc(input.epochMilliseconds) as DateTime.DateTime.PreserveZone<A>
+      return fromDateUnsafe(new Date(input.epochMilliseconds)) as DateTime.DateTime.PreserveZone<A>
     }
     const date = new Date(0)
     setPartsDate(date, input)
@@ -600,6 +600,12 @@ export const zonedOffsetIso = (self: DateTime.Zoned): string => offsetToString(z
 /** @internal */
 export const toEpochMillis = (self: DateTime.DateTime): number => self.epochMilliseconds
 
+/** @internal */
+export const toEpochSeconds = (self: DateTime.DateTime): number => Math.floor(self.epochMilliseconds / 1000)
+
+/** @internal */
+export const fromEpochSeconds = (seconds: number): DateTime.Utc => makeUtc(seconds * 1000)
+
 /** @internal */
 export const removeTime = (self: DateTime.DateTime): DateTime.Utc =>
   withDate(self, (date) => {

package/src/internal/effect.ts

@@ -98,7 +98,6 @@ import {
 } from "./references.ts"
 import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.ts"
 import { addSpanStackTrace, makeStackCleaner } from "./tracer.ts"
-import { version } from "./version.ts"
 
 // ----------------------------------------------------------------------------
 // Cause
@@ -269,7 +268,7 @@ export const causeMap: {
     const failures = self.reasons.map((failure) => {
       if (isFailReason(failure)) {
         hasFail = true
-        return new Fail(f(failure.error))
+        return new Fail(f(failure.error), failure.annotations)
       }
       return failure
     })
@@ -490,7 +489,7 @@ const renderErrorCause = (cause: Error, prefix: string) => {
 // ----------------------------------------------------------------------------
 
 /** @internal */
-export const FiberTypeId = `~effect/Fiber/${version}` as const
+export const FiberTypeId = "~effect/Fiber" as const
 
 const fiberVariance = {
   _A: identity,
@@ -556,7 +555,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   }
 
   getRef<X>(ref: Context.Reference<X>): X {
-    return Context.getReferenceUnsafe(this.context, ref)
+    return Context.get(this.context, ref)
   }
   addObserver(cb: (exit: Exit.Exit<A, E>) => void): () => void {
     if (this._exit) {
@@ -707,20 +706,26 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     return pipeArguments(this, arguments)
   }
   setContext(context: Context.Context<never>): void {
+    const previous = this.context
     this.context = context
+    // Every key cached below opts in to Context caching, so contexts related
+    // only by non-caching adds cannot have changed any of them
+    if (previous !== undefined && Context.hasSameCache(previous, context)) return
     const scheduler = this.getRef(Scheduler.Scheduler)
     if (scheduler !== this.currentScheduler) {
       this.currentScheduler = scheduler
       this._dispatcher = undefined
     }
-    this.currentSpan = context.mapUnsafe.get(Tracer.ParentSpanKey)
+    // The string-keyed lookups keep the Tracer key values (and the native
+    // tracer behind Tracer.Tracer's default) out of every bundle
+    this.currentSpan = Context.getOrUndefinedUnsafe(context, Tracer.ParentSpanKey)
     this.currentLogLevel = this.getRef(CurrentLogLevel)
     this.minimumLogLevel = this.getRef(MinimumLogLevel)
-    this.currentStackFrame = context.mapUnsafe.get(CurrentStackFrame.key)
+    this.currentStackFrame = this.getRef(CurrentStackFrame)
     this.maxOpsBeforeYield = this.getRef(Scheduler.MaxOpsBeforeYield)
     this.currentPreventYield = this.getRef(Scheduler.PreventSchedulerYield)
-    this.runtimeMetrics = context.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey)
-    const currentTracer = context.mapUnsafe.get(Tracer.TracerKey)
+    this.runtimeMetrics = Context.getOrUndefinedUnsafe(context, InternalMetric.FiberRuntimeMetricsKey)
+    const currentTracer = Context.getOrUndefinedUnsafe<Tracer.Tracer>(context, Tracer.TracerKey)
     this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined
   }
   get currentSpanLocal(): Tracer.Span | undefined {
@@ -3748,8 +3753,8 @@ export const timed = <A, E, R>(
   self: Effect.Effect<A, E, R>
 ): Effect.Effect<[duration: Duration.Duration, result: A], E, R> =>
   clockWith((clock) => {
-    const start = clock.currentTimeNanosUnsafe()
-    return map(self, (a) => [Duration.nanos(clock.currentTimeNanosUnsafe() - start), a])
+    const start = clock.monotonicTimeNanosUnsafe()
+    return map(self, (a) => [Duration.nanos(clock.monotonicTimeNanosUnsafe() - start), a])
   })
 
 // ----------------------------------------------------------------------------
@@ -4680,7 +4685,6 @@ const forEachSequential = <A, B, E, R>(
 
 type IterateEagerOptions = {
   readonly concurrency?: number | undefined
-  readonly start?: number | undefined
   readonly end?: number | undefined
   readonly orderedStep?: boolean | undefined
 }
@@ -4696,14 +4700,37 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
   const onItem = options.onItem
   const step = options.step
 
+  const runSequential = (
+    state: S,
+    items: ReadonlyArray<A>,
+    index: number,
+    end: number
+  ): Effect.Effect<void, E | E2, R> | undefined => {
+    for (; index < end; index++) {
+      const item = items[index]
+      const effect = onItem(state, item, index)
+      if (!effectIsExit(effect)) {
+        return flatMap(
+          exit(effect),
+          (itemExit) => step(state, item, itemExit, index) ?? runSequential(state, items, index + 1, end) ?? void_
+        )
+      }
+      const terminal = step(state, item, effect, index)
+      if (terminal) return terminal._tag === "Failure" ? terminal : undefined
+    }
+  }
+
   return (
     state: S,
     items: ReadonlyArray<A>,
     opts: IterateEagerOptions | undefined
   ): Effect.Effect<void, E | E2, R> | undefined => {
-    let index = opts?.start ?? 0
+    let index = 0
     const end = opts?.end ?? items.length
     const concurrency = opts?.concurrency ?? 1
+    if (concurrency === 1) {
+      return runSequential(state, items, 0, end)
+    }
     const orderedStep = opts?.orderedStep === true && concurrency > 1
     let done = false
     let parentFiber: Fiber.Fiber<any, any> | undefined
@@ -4750,14 +4777,6 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
           terminal = runStep(item, eff, index)
           if (terminal) break
 
-          // Use flatMap for concurrency of 1
-        } else if (concurrency === 1) {
-          return flatMap(exit(eff), (exit) => {
-            terminal = runStep(item, exit, index)
-            index++
-            return terminal ?? go() ?? void_
-          })
-
           // We have an effect, so enter "async" mode
         } else if (!parentFiber) {
           return callback((cb) => {
@@ -5204,16 +5223,17 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   daemon = false,
   uninterruptible: boolean | "inherit" = false
 ): FiberImpl<A, E> => {
-  const interruptible = uninterruptible === "inherit" ? parent.interruptible : !uninterruptible
-  const child = new FiberImpl<A, E>(parent.context, interruptible)
+  const parentRuntime = parent as FiberImpl<FA, FE>
+  const interruptible = uninterruptible === "inherit" ? parentRuntime.interruptible : !uninterruptible
+  const child = new FiberImpl<A, E>(parentRuntime.context, interruptible)
   if (immediate) {
     child.evaluate(effect as any)
   } else {
-    parent.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
+    parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
   }
   if (!daemon && !child._exit) {
-    parent.children().add(child)
-    child.addObserver(() => parent._children!.delete(child))
+    parentRuntime.children().add(child)
+    child.addObserver(() => parentRuntime._children!.delete(child))
   }
   return child
 }
@@ -5978,9 +5998,13 @@ class ClockImpl implements Clock.Clock {
   }
   readonly currentTimeMillis: Effect.Effect<number> = sync(() => this.currentTimeMillisUnsafe())
   currentTimeNanosUnsafe(): bigint {
-    return processOrPerformanceNow()
+    return wallTimeNanos()
   }
   readonly currentTimeNanos: Effect.Effect<bigint> = sync(() => this.currentTimeNanosUnsafe())
+  monotonicTimeNanosUnsafe(): bigint {
+    return monotonicNowNanos()
+  }
+  readonly monotonicTimeNanos: Effect.Effect<bigint> = sync(() => this.monotonicTimeNanosUnsafe())
   sleep(duration: Duration.Duration): Effect.Effect<void> {
     return this.sleepMillis(Duration.toMillis(duration))
   }
@@ -5997,27 +6021,45 @@ class ClockImpl implements Clock.Clock {
   }
 }
 
-const performanceNowNanos = (function() {
-  const bigint1e6 = BigInt(1_000_000)
-  if (typeof performance === "undefined" || typeof performance.now === "undefined") {
-    return () => BigInt(Date.now()) * bigint1e6
+const nanosPerMilli = BigInt(1_000_000)
+
+const monotonicNowNanos = (function() {
+  const processHrtime = (globalThis as {
+    readonly process?: { readonly hrtime?: { readonly bigint?: () => bigint } }
+  }).process?.hrtime
+  if (typeof processHrtime?.bigint === "function") {
+    return () => processHrtime.bigint!()
+  }
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return () => BigInt(Math.round(performance.now() * 1_000_000))
   }
-  let origin: bigint
+  let previous = BigInt(0)
   return () => {
-    origin ??= (BigInt(Date.now()) * bigint1e6) - BigInt(Math.round(performance.now() * 1_000_000))
-    return origin + BigInt(Math.round(performance.now() * 1_000_000))
+    const current = BigInt(Date.now()) * nanosPerMilli
+    if (current > previous) {
+      previous = current
+    }
+    return previous
   }
 })()
-const processOrPerformanceNow = (function() {
-  const processHrtime =
-    typeof process === "object" && "hrtime" in process && typeof process.hrtime.bigint === "function" ?
-      process.hrtime :
-      undefined
-  if (!processHrtime) {
-    return performanceNowNanos
-  }
-  const origin = (BigInt(Date.now()) * BigInt(1e6)) - processHrtime.bigint()
-  return () => origin + processHrtime.bigint()
+
+const wallTimeNanos = (function() {
+  const reanchorThresholdNanos = BigInt(1_000_000_000)
+  let origin: bigint | undefined
+  return () => {
+    const monotonic = monotonicNowNanos()
+    const wall = BigInt(Date.now()) * nanosPerMilli
+    if (origin === undefined) {
+      origin = wall - monotonic
+    } else {
+      const projected = origin + monotonic
+      const skew = wall > projected ? wall - projected : projected - wall
+      if (skew > reanchorThresholdNanos) {
+        origin = wall - monotonic
+      }
+    }
+    return origin + monotonic
+  }
 })()
 
 /** @internal */
@@ -6034,6 +6076,9 @@ export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clo
 /** @internal */
 export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => clock.currentTimeNanos)
 
+/** @internal */
+export const monotonicTimeNanos: Effect.Effect<bigint> = clockWith((clock) => clock.monotonicTimeNanos)
+
 // ----------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------
@@ -6370,10 +6415,10 @@ export const consolePretty = (options?: {
 }) => {
   // evaluated lazily so the module-level bundle stays free of `process`
   // property accesses, which bundlers must retain as possible side effects
-  const hasProcessStdout = typeof process === "object" &&
-    process !== null &&
-    typeof process.stdout === "object" &&
-    process.stdout !== null
+  const process = (globalThis as {
+    readonly process?: { readonly stdout?: { readonly isTTY?: boolean } }
+  }).process
+  const hasProcessStdout = typeof process?.stdout === "object" && process.stdout !== null
   const processStdoutIsTTY = hasProcessStdout &&
     process.stdout.isTTY === true
   const hasProcessStdoutOrDeno = hasProcessStdout || "Deno" in globalThis
@@ -6391,7 +6436,7 @@ const prettyLoggerTty = (options: {
   readonly colors: boolean
   readonly formatDate: (date: Date) => string
 }) => {
-  const processIsBun = typeof process === "object" && "isBun" in process && process.isBun === true
+  const processIsBun = (globalThis as { readonly process?: { readonly isBun?: boolean } }).process?.isBun === true
   const color = options.colors ? withColor : withColorNoop
   return loggerMake<unknown, void>(
     ({ cause, date, fiber, logLevel, message: message_ }) => {