effect 2.4.18 → 3.0.0

package/src/Subscribable.ts

@@ -0,0 +1,99 @@
+/**
+ * @since 2.0.0
+ */
+import * as Effect from "./Effect.js"
+import { dual } from "./Function.js"
+import { pipeArguments } from "./Pipeable.js"
+import { hasProperty } from "./Predicate.js"
+import * as Readable from "./Readable.js"
+import * as Stream from "./Stream.js"
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("effect/Subscribable")
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R> {
+  readonly [TypeId]: TypeId
+  readonly changes: Stream.Stream<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+const Proto: Omit<Subscribable<any>, "get" | "changes"> = {
+  [Readable.TypeId]: Readable.TypeId,
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <A, E, R>(options: {
+  readonly get: Effect.Effect<A, E, R>
+  readonly changes: Stream.Stream<A, E, R>
+}): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E, R>
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
+} = dual(2, <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
+  make({
+    get: Effect.map(self.get, f),
+    changes: Stream.map(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): Subscribable<B, E | E2, R | R2>
+} = dual(2, <A, E, R, B, E2, R2>(
+  self: Subscribable<A, E, R>,
+  f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+): Subscribable<B, E | E2, R | R2> =>
+  make({
+    get: Effect.flatMap(self.get, f),
+    changes: Stream.mapEffect(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>
+): Subscribable<A, E | E1, R | R1> =>
+  make({
+    get: Effect.flatMap(effect, (s) => s.get),
+    changes: Stream.unwrap(Effect.map(effect, (s) => s.changes))
+  })

package/src/SubscriptionRef.ts

@@ -4,10 +4,10 @@
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/subscriptionRef.js"
 import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
 import type * as PubSub from "./PubSub.js"
 import * as Ref from "./Ref.js"
 import type * as Stream from "./Stream.js"
+import type { Subscribable } from "./Subscribable.js"
 import * as Synchronized from "./SynchronizedRef.js"
 import type * as Types from "./Types.js"
 
@@ -31,7 +31,7 @@ export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId
  * @category models
  */
 export interface SubscriptionRef<in out A>
-  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Pipeable
+  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Subscribable<A>
 {
   /** @internal */
   readonly ref: Ref.Ref<A>

package/src/TestAnnotation.ts

@@ -8,6 +8,7 @@ import type * as Fiber from "./Fiber.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import * as HashSet from "./HashSet.js"
+import { getBugErrorMessage } from "./internal/errors.js"
 import type * as MutableRef from "./MutableRef.js"
 import { hasProperty } from "./Predicate.js"
 import type * as SortedSet from "./SortedSet.js"
@@ -96,7 +97,7 @@ export const compose = <A>(
   if (Either.isLeft(left) && Either.isRight(right)) {
     return right
   }
-  throw new Error("BUG: TestAnnotation.compose - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("TestAnnotation.compose"))
 }
 
 /**

package/src/TestAnnotations.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import * as RA from "./Array.js"
 import * as Context from "./Context.js"
 import type * as Effect from "./Effect.js"
 import * as Equal from "./Equal.js"
@@ -11,7 +12,6 @@ import * as core from "./internal/core.js"
 import * as fiber from "./internal/fiber.js"
 import * as MutableRef from "./MutableRef.js"
 import { hasProperty } from "./Predicate.js"
-import * as RA from "./ReadonlyArray.js"
 import * as Ref from "./Ref.js"
 import * as SortedSet from "./SortedSet.js"
 import * as TestAnnotation from "./TestAnnotation.js"

package/src/TestClock.ts

@@ -209,7 +209,7 @@ export class TestClockImpl implements TestClock {
         core.flatMap((shouldAwait) =>
           shouldAwait ?
             pipe(this.warningStart(), core.zipRight(core.deferredAwait(deferred))) :
-            pipe(core.deferredSucceed(deferred, void 0), core.asUnit)
+            pipe(core.deferredSucceed(deferred, void 0), core.asVoid)
         )
       ))
   }
@@ -250,7 +250,7 @@ export class TestClockImpl implements TestClock {
   }
   /**
    * Captures a "snapshot" of the identifier and status of all fibers in this
-   * test other than the current fiber. Fails with the `Unit` value if any of
+   * test other than the current fiber. Fails with the `void` value if any of
    * these fibers are not done or suspended. Note that because we cannot
    * synchronize on the status of multiple fibers at the same time this
    * snapshot may not be fully consistent.
@@ -409,7 +409,7 @@ export class TestClockImpl implements TestClock {
         core.flatMap((option) => {
           switch (option._tag) {
             case "None": {
-              return core.unit
+              return core.void
             }
             case "Some": {
               const [end, deferred] = option.value

package/src/Tracer.ts

@@ -26,7 +26,7 @@ export interface Tracer {
   readonly [TracerTypeId]: TracerTypeId
   span(
     name: string,
-    parent: Option.Option<ParentSpan>,
+    parent: Option.Option<AnySpan>,
     context: Context.Context<never>,
     links: ReadonlyArray<SpanLink>,
     startTime: bigint
@@ -52,13 +52,21 @@ export type SpanStatus = {
  * @since 2.0.0
  * @category models
  */
-export type ParentSpan = Span | ExternalSpan
+export type AnySpan = Span | ExternalSpan
 
 /**
  * @since 2.0.0
  * @category tags
  */
-export const ParentSpan: Context.Tag<ParentSpan, ParentSpan> = internal.spanTag
+export interface ParentSpan {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 2.0.0
+ * @category tags
+ */
+export const ParentSpan: Context.Tag<ParentSpan, AnySpan> = internal.spanTag
 
 /**
  * @since 2.0.0
@@ -81,7 +89,7 @@ export interface Span {
   readonly name: string
   readonly spanId: string
   readonly traceId: string
-  readonly parent: Option.Option<ParentSpan>
+  readonly parent: Option.Option<AnySpan>
   readonly context: Context.Context<never>
   readonly status: SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
@@ -98,7 +106,7 @@ export interface Span {
  */
 export interface SpanLink {
   readonly _tag: "SpanLink"
-  readonly span: ParentSpan
+  readonly span: AnySpan
   readonly attributes: Readonly<Record<string, unknown>>
 }
 

package/src/Trie.ts

@@ -20,7 +20,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as TR from "./internal/trie.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant } from "./Types.js"
 
 const TypeId: unique symbol = TR.TrieTypeId as TypeId
 

package/src/Types.ts

@@ -170,14 +170,6 @@ export type Mutable<T> = {
   -readonly [P in keyof T]: T[P]
 }
 
-/**
- * Avoid inference on a specific parameter
- *
- * @since 2.0.0
- * @category models
- */
-export type NoInfer<A> = [A][A extends any ? 0 : never]
-
 /**
  * Invariant helper.
  *

package/src/index.ts

@@ -29,6 +29,13 @@ export {
   unsafeCoerce
 } from "./Function.js"
 
+/**
+ * This module provides utility functions for working with arrays in TypeScript.
+ *
+ * @since 2.0.0
+ */
+export * as Array from "./Array.js"
+
 /**
  * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
  * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
@@ -255,6 +262,11 @@ export * as Exit from "./Exit.js"
  */
 export * as Fiber from "./Fiber.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as FiberHandle from "./FiberHandle.js"
+
 /**
  * @since 2.0.0
  */
@@ -571,18 +583,16 @@ export * as Random from "./Random.js"
 export * as RateLimiter from "./RateLimiter.js"
 
 /**
- * This module provides utility functions for working with arrays in TypeScript.
- *
  * @since 2.0.0
  */
-export * as ReadonlyArray from "./ReadonlyArray.js"
+export * as Readable from "./Readable.js"
 
 /**
  * This module provides utility functions for working with records in TypeScript.
  *
  * @since 2.0.0
  */
-export * as ReadonlyRecord from "./ReadonlyRecord.js"
+export * as Record from "./Record.js"
 
 /**
  * @since 2.0.0
@@ -594,6 +604,13 @@ export * as RedBlackTree from "./RedBlackTree.js"
  */
 export * as Ref from "./Ref.js"
 
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+export * as RegExp from "./RegExp.js"
+
 /**
  * @since 2.0.0
  */
@@ -740,6 +757,11 @@ export * as String from "./String.js"
  */
 export * as Struct from "./Struct.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as Subscribable from "./Subscribable.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/{readonlyArray.ts → array.ts}

@@ -2,7 +2,7 @@
  * @since 2.0.0
  */
 
-import type { NonEmptyArray } from "../ReadonlyArray.js"
+import type { NonEmptyArray } from "../Array.js"
 
 /** @internal */
 export const isNonEmptyArray = <A>(self: ReadonlyArray<A>): self is NonEmptyArray<A> => self.length > 0

package/src/internal/cache.ts

@@ -29,13 +29,13 @@ import * as fiberRuntime from "./fiberRuntime.js"
  *
  * @internal
  */
-export type MapValue<Key, Error, Value> =
-  | Complete<Key, Error, Value>
-  | Pending<Key, Error, Value>
-  | Refreshing<Key, Error, Value>
+export type MapValue<Key, Value, Error> =
+  | Complete<Key, Value, Error>
+  | Pending<Key, Value, Error>
+  | Refreshing<Key, Value, Error>
 
 /** @internal */
-export interface Complete<out Key, out Error, out Value> {
+export interface Complete<out Key, out Value, out Error> {
   readonly _tag: "Complete"
   readonly key: MapKey<Key>
   readonly exit: Exit.Exit<Value, Error>
@@ -44,26 +44,26 @@ export interface Complete<out Key, out Error, out Value> {
 }
 
 /** @internal */
-export interface Pending<out Key, in out Error, in out Value> {
+export interface Pending<out Key, in out Value, in out Error> {
   readonly _tag: "Pending"
   readonly key: MapKey<Key>
   readonly deferred: Deferred.Deferred<Value, Error>
 }
 
 /** @internal */
-export interface Refreshing<out Key, in out Error, in out Value> {
+export interface Refreshing<out Key, in out Value, in out Error> {
   readonly _tag: "Refreshing"
   readonly deferred: Deferred.Deferred<Value, Error>
-  readonly complete: Complete<Key, Error, Value>
+  readonly complete: Complete<Key, Value, Error>
 }
 
 /** @internal */
-export const complete = <Key, Error, Value>(
+export const complete = <Key, Value, Error>(
   key: MapKey<Key>,
   exit: Exit.Exit<Value, Error>,
   entryStats: Cache.EntryStats,
   timeToLiveMillis: number
-): MapValue<Key, Error, Value> =>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Complete" as const,
     key,
@@ -73,10 +73,10 @@ export const complete = <Key, Error, Value>(
   })
 
 /** @internal */
-export const pending = <Key, Error, Value>(
+export const pending = <Key, Value, Error>(
   key: MapKey<Key>,
   deferred: Deferred.Deferred<Value, Error>
-): MapValue<Key, Error, Value> =>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Pending" as const,
     key,
@@ -84,10 +84,10 @@ export const pending = <Key, Error, Value>(
   })
 
 /** @internal */
-export const refreshing = <Key, Error, Value>(
+export const refreshing = <Key, Value, Error>(
   deferred: Deferred.Deferred<Value, Error>,
-  complete: Complete<Key, Error, Value>
-): MapValue<Key, Error, Value> =>
+  complete: Complete<Key, Value, Error>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Refreshing" as const,
     deferred,
@@ -216,8 +216,8 @@ export const makeKeySet = <K>(): KeySet<K> => new KeySetImpl<K>()
  *
  * @internal
  */
-export interface CacheState<in out Key, in out Error, in out Value> {
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
+export interface CacheState<in out Key, in out Value, in out Error> {
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
   keys: KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<MapKey<Key>> // mutable by design
   updating: MutableRef.MutableRef<boolean> // mutable by design
@@ -230,14 +230,14 @@ export interface CacheState<in out Key, in out Error, in out Value> {
  *
  * @internal
  */
-export const makeCacheState = <Key, Error, Value>(
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>>,
+export const makeCacheState = <Key, Value, Error>(
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
   keys: KeySet<Key>,
   accesses: MutableQueue.MutableQueue<MapKey<Key>>,
   updating: MutableRef.MutableRef<boolean>,
   hits: number,
   misses: number
-): CacheState<Key, Error, Value> => ({
+): CacheState<Key, Value, Error> => ({
   map,
   keys,
   accesses,
@@ -251,7 +251,7 @@ export const makeCacheState = <Key, Error, Value>(
  *
  * @internal
  */
-export const initialCacheState = <Key, Error, Value>(): CacheState<Key, Error, Value> =>
+export const initialCacheState = <Key, Value, Error>(): CacheState<Key, Value, Error> =>
   makeCacheState(
     MutableHashMap.empty(),
     makeKeySet(),
@@ -292,14 +292,14 @@ export const makeEntryStats = (loadedMillis: number): Cache.EntryStats => ({
   loadedMillis
 })
 
-class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<Key, Error, Value> {
+class CacheImpl<in out Key, in out Value, in out Error> implements Cache.Cache<Key, Value, Error> {
   readonly [CacheTypeId] = cacheVariance
-  readonly cacheState: CacheState<Key, Error, Value>
+  readonly cacheState: CacheState<Key, Value, Error>
   constructor(
     readonly capacity: number,
     readonly context: Context.Context<any>,
     readonly fiberId: FiberId.FiberId,
-    readonly lookup: Cache.Lookup<Key, any, Error, Value>,
+    readonly lookup: Cache.Lookup<Key, Value, Error, any>,
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   ) {
     this.cacheState = initialCacheState()
@@ -443,7 +443,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
           }
         }
         if (value === undefined) {
-          return core.asUnit(this.lookupValueOf(key, deferred))
+          return core.asVoid(this.lookupValueOf(key, deferred))
         } else {
           switch (value._tag) {
             case "Complete": {
@@ -452,7 +452,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
                 if (Equal.equals(found, value)) {
                   MutableHashMap.remove(this.cacheState.map, k)
                 }
-                return core.asUnit(this.get(key))
+                return core.asVoid(this.get(key))
               }
               // Only trigger the lookup if we're still the current value, `completedResult`
               return pipe(
@@ -460,13 +460,13 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
                 effect.when(() => {
                   const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
                   if (Equal.equals(current, value)) {
-                    const mapValue = refreshing(deferred, value as Complete<Key, Error, Value>)
+                    const mapValue = refreshing(deferred, value as Complete<Key, Value, Error>)
                     MutableHashMap.set(this.cacheState.map, k, mapValue)
                     return true
                   }
                   return false
                 }),
-                core.asUnit
+                core.asVoid
               )
             }
             case "Pending": {
@@ -496,7 +496,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
         MutableHashMap.set(
           this.cacheState.map,
           k,
-          mapValue as Complete<Key, Error, Value>
+          mapValue as Complete<Key, Value, Error>
         )
       })
     )
@@ -545,7 +545,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
   }
 
   resolveMapValue(
-    value: MapValue<Key, Error, Value>,
+    value: MapValue<Key, Value, Error>,
     ignorePending = false
   ): Effect.Effect<Option.Option<Value>, Error> {
     return effect.clockWith((clock) => {
@@ -665,13 +665,13 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
 }
 
 /** @internal */
-export const make = <Key, Environment, Error, Value>(
+export const make = <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
-    readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: Cache.Lookup<Key, Value, Error, Environment>
   }
-): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> => {
+): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> => {
   const timeToLive = Duration.decode(options.timeToLive)
   return makeWith({
     capacity: options.capacity,
@@ -681,13 +681,13 @@ export const make = <Key, Environment, Error, Value>(
 }
 
 /** @internal */
-export const makeWith = <Key, Environment, Error, Value>(
+export const makeWith = <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: Cache.Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> =>
+): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> =>
   core.map(
     fiberRuntime.all([core.context<Environment>(), core.fiberId]),
     ([context, fiberId]) =>
@@ -701,12 +701,12 @@ export const makeWith = <Key, Environment, Error, Value>(
   )
 
 /** @internal */
-export const unsafeMakeWith = <Key, Error, Value>(
+export const unsafeMakeWith = <Key, Value, Error = never>(
   capacity: number,
-  lookup: Cache.Lookup<Key, never, Error, Value>,
+  lookup: Cache.Lookup<Key, Value, Error>,
   timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
-): Cache.Cache<Key, Error, Value> =>
-  new CacheImpl<Key, Error, Value>(
+): Cache.Cache<Key, Value, Error> =>
+  new CacheImpl<Key, Value, Error>(
     capacity,
     Context.empty() as Context.Context<any>,
     none,

package/src/internal/cause.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Either from "../Either.js"
@@ -11,9 +12,8 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, isFunction } from "../Predicate.js"
 import type { Predicate, Refinement } from "../Predicate.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
-import type { ParentSpan, Span } from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
+import type { AnySpan, Span } from "../Tracer.js"
+import { getBugErrorMessage } from "./errors.js"
 import * as OpCodes from "./opCodes/cause.js"
 
 // -----------------------------------------------------------------------------
@@ -584,7 +584,7 @@ const flattenCauseLoop = (
   while (1) {
     const [parallel, sequential] = pipe(
       causes,
-      ReadonlyArray.reduce(
+      Array.reduce(
         [HashSet.empty<unknown>(), Chunk.empty<Cause.Cause<unknown>>()] as const,
         ([parallel, sequential], cause) => {
           const [par, seq] = evaluateCause(cause)
@@ -604,7 +604,7 @@ const flattenCauseLoop = (
     causes = sequential
     flattened = updated
   }
-  throw new Error("BUG: Cause.flattenCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"))
 }
 
 // -----------------------------------------------------------------------------
@@ -740,7 +740,7 @@ const evaluateCause = (
       }
     }
   }
-  throw new Error("BUG: Cause.evaluateCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"))
 }
 
 // -----------------------------------------------------------------------------
@@ -990,7 +990,7 @@ export const pretty = <E>(cause: Cause.Cause<E>): string => {
       message += `\r\n${filterStack(e.stack)}`
     }
     if (e.span) {
-      let current: Span | ParentSpan | undefined = e.span
+      let current: Span | AnySpan | undefined = e.span
       let i = 0
       while (current && current._tag === "Span" && i < 10) {
         message += `\r\n    at ${current.name}`
@@ -1046,7 +1046,7 @@ export const prettyErrorMessage = (u: unknown): string => {
       hasProperty(u, "toString") &&
       isFunction(u["toString"]) &&
       u["toString"] !== Object.prototype.toString &&
-      u["toString"] !== Array.prototype.toString
+      u["toString"] !== globalThis.Array.prototype.toString
     ) {
       return u["toString"]()
     }