effect 2.0.0-next.45 → 2.0.0-next.47

package/internal/queue.esm.js

@@ -1,8 +1,8 @@
-import { head, prepend, filter, isEmpty as isEmpty$1, fromIterable as fromIterable$1, appendAll, append, empty as empty$1 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { head, prepend, filter, isEmpty as isEmpty$2, fromIterable as fromIterable$1, appendAll, append, empty as empty$1 } from '../Chunk/dist/effect-Chunk.esm.js';
 import { pipe, dual } from '../Function/dist/effect-Function.esm.js';
 import { flatMap, sync, map, deferredMake, fiberId, withFiberRuntime, unit, succeed, deferredUnsafeDone, deferredInterruptWith, asUnit, deferredUnsafeMake, onInterrupt, suspend, interrupt, deferredAwait, catchAll, uninterruptible, whenEffect, deferredSucceed, zipRight } from './core.esm.js';
 import { forEachParUnboundedDiscard } from './fiberRuntime.esm.js';
-import { bounded as bounded$1, unbounded as unbounded$1, length, poll as poll$1, EmptyMutableQueue, offer as offer$1, offerAll as offerAll$1, pollUpTo, capacity as capacity$1 } from '../MutableQueue/dist/effect-MutableQueue.esm.js';
+import { bounded as bounded$1, unbounded as unbounded$1, length, isEmpty as isEmpty$1, poll as poll$1, EmptyMutableQueue, offer as offer$1, offerAll as offerAll$1, pollUpTo, capacity as capacity$1 } from '../MutableQueue/dist/effect-MutableQueue.esm.js';
 import { make as make$1, get, set } from '../MutableRef/dist/effect-MutableRef.esm.js';
 import { none, some } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
@@ -162,7 +162,7 @@ class QueueImpl {
       // Not enough takers, offer to the queue
       const surplus = this.queue.offerAll(remaining);
       unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-      return isEmpty$1(surplus) ? succeed(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
+      return isEmpty$2(surplus) ? succeed(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
     });
   }
   take() {
@@ -353,6 +353,16 @@ class BackPressureStrategy {
   surplusSize() {
     return length(this.putters);
   }
+  onCompleteTakersWithEmptyQueue(takers) {
+    while (!isEmpty$1(this.putters) && !isEmpty$1(takers)) {
+      const taker = poll$1(takers, void 0);
+      const putter = poll$1(this.putters, void 0);
+      if (putter[2]) {
+        unsafeCompleteDeferred(putter[1], true);
+      }
+      unsafeCompleteDeferred(taker, putter[0]);
+    }
+  }
   shutdown() {
     return pipe(fiberId, flatMap(fiberId => pipe(sync(() => unsafePollAll(this.putters)), flatMap(putters => forEachParUnboundedDiscard(putters, ([_, deferred, isLastItem]) => isLastItem ? pipe(deferredInterruptWith(deferred, fiberId), asUnit) : unit, false)))));
   }
@@ -385,17 +395,12 @@ class BackPressureStrategy {
     }
   }
   unsafeOffer(iterable, deferred) {
-    const iterator = iterable[Symbol.iterator]();
-    let next = iterator.next();
-    if (!next.done) {
-      // eslint-disable-next-line no-constant-condition
-      while (1) {
-        const value = next.value;
-        next = iterator.next();
-        if (next.done) {
-          pipe(this.putters, offer$1([value, deferred, true]));
-          break;
-        }
+    const stuff = Array.from(iterable);
+    for (let i = 0; i < stuff.length; i++) {
+      const value = stuff[i];
+      if (i === stuff.length - 1) {
+        pipe(this.putters, offer$1([value, deferred, true]));
+      } else {
         pipe(this.putters, offer$1([value, deferred, false]));
       }
     }
@@ -414,6 +419,7 @@ class DroppingStrategy {
   shutdown() {
     return unit;
   }
+  onCompleteTakersWithEmptyQueue() {}
   handleSurplus(_iterable, _queue, _takers, _isShutdown) {
     return succeed(false);
   }
@@ -431,6 +437,7 @@ class SlidingStrategy {
   shutdown() {
     return unit;
   }
+  onCompleteTakersWithEmptyQueue() {}
   handleSurplus(iterable, queue, takers, _isShutdown) {
     return sync(() => {
       this.unsafeOffer(queue, iterable);
@@ -500,6 +507,9 @@ const unsafeCompleteTakers = (strategy, queue, takers) => {
       keepPolling = false;
     }
   }
+  if (keepPolling && queue.length() === 0 && !isEmpty$1(takers)) {
+    strategy.onCompleteTakersWithEmptyQueue(takers);
+  }
 };
 
 export { BackingQueueFromMutableQueue, DequeueTypeId, EnqueueTypeId, QueueStrategyTypeId, awaitShutdown, backPressureStrategy, backingQueueFromMutableQueue, bounded, capacity, dequeueVariance, dropping, droppingStrategy, enqueueVariance, isDequeue, isEmpty, isEnqueue, isFull, isQueue, isShutdown, make, offer, offerAll, poll, shutdown, size, sliding, slidingStrategy, take, takeAll, takeBetween, takeN, takeUpTo, unbounded, unsafeCompleteTakers, unsafeOffer, unsafeRemove };

package/internal/request.esm.js

@@ -1,7 +1,7 @@
-import { struct } from '../Data/dist/effect-Data.esm.js';
 import { dual } from '../Function/dist/effect-Function.esm.js';
 import { currentRequestMap } from './completedRequestMap.esm.js';
 import { fiberRefGetWith, sync, deferredUnsafeDone, matchEffect, exitFail, exitSucceed } from './core.esm.js';
+import { struct } from './Data.esm.js';
 
 /** @internal */
 const RequestSymbolKey = "effect/Request";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.0.0-next.45",
+  "version": "2.0.0-next.47",
   "packageManager": "pnpm@8.7.3",
   "publishConfig": {
     "access": "public"
@@ -67,7 +67,6 @@
     "Encoding",
     "Equal",
     "Equivalence",
-    "Error",
     "ExecutionStrategy",
     "Exit",
     "Fiber",
@@ -385,12 +384,6 @@
       "import": "./Equivalence/dist/effect-Equivalence.cjs.mjs",
       "default": "./Equivalence/dist/effect-Equivalence.cjs.js"
     },
-    "./Error": {
-      "types": "./dist/declarations/src/Error.d.ts",
-      "module": "./Error/dist/effect-Error.esm.js",
-      "import": "./Error/dist/effect-Error.cjs.mjs",
-      "default": "./Error/dist/effect-Error.cjs.js"
-    },
     "./ExecutionStrategy": {
       "types": "./dist/declarations/src/ExecutionStrategy.d.ts",
       "module": "./ExecutionStrategy/dist/effect-ExecutionStrategy.esm.js",
@@ -1055,6 +1048,7 @@
     "@babel/preset-typescript": "^7.23.0",
     "@changesets/changelog-github": "^0.4.8",
     "@changesets/cli": "^2.26.2",
+    "@definitelytyped/dtslint": "^0.0.182",
     "@effect/build-utils": "^0.1.5",
     "@effect/docgen": "^0.1.8",
     "@effect/eslint-plugin": "^0.1.2",
@@ -1066,6 +1060,7 @@
     "@typescript-eslint/parser": "^6.7.4",
     "@vitejs/plugin-react": "^4.1.0",
     "@vitest/coverage-v8": "^0.34.6",
+    "@vitest/expect": "^0.34.6",
     "babel-plugin-annotate-pure-calls": "^0.4.0",
     "eslint": "^8.50.0",
     "eslint-import-resolver-typescript": "^3.6.1",
@@ -1093,6 +1088,7 @@
     "update-version": "changeset version && pnpm install --no-frozen-lockfile",
     "lint": "eslint src test",
     "fix": "preconstruct fix",
-    "docgen": "docgen"
+    "docgen": "docgen",
+    "dtslint": "dtslint --expectOnly dtslint"
   }
 }

package/src/Bigint.ts

@@ -1,13 +1,14 @@
 /**
  * This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
  * It includes functions for basic arithmetic operations, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */
 
 import * as equivalence from "./Equivalence"
 import { dual } from "./Function"
+import * as Option from "./Option"
 import * as order from "./Order"
 import type { Ordering } from "./Ordering"
 import * as predicate from "./Predicate"
@@ -335,6 +336,121 @@ export const max: {
  */
 export const sign = (n: bigint): Ordering => Order(n, 0n)
 
+/**
+ * Determines the absolute value of a given `bigint`.
+ *
+ * @param n - The `bigint` to determine the absolute value of.
+ *
+ * @example
+ * import { abs } from 'effect/Bigint'
+ *
+ * assert.deepStrictEqual(abs(-5n), 5n)
+ * assert.deepStrictEqual(abs(0n), 0n)
+ * assert.deepStrictEqual(abs(5n), 5n)
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const abs = (n: bigint): bigint => (n < 0n ? -n : n)
+
+/**
+ * Determines the greatest common divisor of two `bigint`s.
+ *
+ * @param a - The first `bigint`.
+ * @param b - The second `bigint`.
+ *
+ * @example
+ * import { gcd } from 'effect/Bigint'
+ *
+ * assert.deepStrictEqual(gcd(2n, 3n), 1n)
+ * assert.deepStrictEqual(gcd(2n, 4n), 2n)
+ * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const gcd: {
+  (that: bigint): (self: bigint) => bigint
+  (self: bigint, that: bigint): bigint
+} = dual(2, (self: bigint, that: bigint): bigint => {
+  while (that !== 0n) {
+    const t = that
+    that = self % that
+    self = t
+  }
+  return self
+})
+
+/**
+ * Determines the least common multiple of two `bigint`s.
+ *
+ * @param a - The first `bigint`.
+ * @param b - The second `bigint`.
+ *
+ * @example
+ * import { lcm } from 'effect/Bigint'
+ *
+ * assert.deepStrictEqual(lcm(2n, 3n), 6n)
+ * assert.deepStrictEqual(lcm(2n, 4n), 4n)
+ * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const lcm: {
+  (that: bigint): (self: bigint) => bigint
+  (self: bigint, that: bigint): bigint
+} = dual(2, (self: bigint, that: bigint): bigint => (self * that) / gcd(self, that))
+
+/**
+ * Determines the square root of a given `bigint` unsafely. Throws if the given `bigint` is negative.
+ *
+ * @param n - The `bigint` to determine the square root of.
+ *
+ * @example
+ * import { unsafeSqrt } from 'effect/Bigint'
+ *
+ * assert.deepStrictEqual(unsafeSqrt(4n), 2n)
+ * assert.deepStrictEqual(unsafeSqrt(9n), 3n)
+ * assert.deepStrictEqual(unsafeSqrt(16n), 4n)
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const unsafeSqrt = (n: bigint): bigint => {
+  if (n < 0n) {
+    throw new RangeError("Cannot take the square root of a negative number")
+  }
+  if (n < 2n) {
+    return n
+  }
+  let x = n / 2n
+  while (x * x > n) {
+    x = ((n / x) + x) / 2n
+  }
+  return x
+}
+
+/**
+ * Determines the square root of a given `bigint` safely. Returns `none` if the given `bigint` is negative.
+ *
+ * @param n - The `bigint` to determine the square root of.
+ *
+ * @example
+ * import { sqrt } from 'effect/Bigint'
+ * import * as Option from 'effect/Option'
+ *
+ * assert.deepStrictEqual(sqrt(4n), Option.some(2n))
+ * assert.deepStrictEqual(sqrt(9n), Option.some(3n))
+ * assert.deepStrictEqual(sqrt(16n), Option.some(4n))
+ * assert.deepStrictEqual(sqrt(-1n), Option.none())
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const sqrt = (n: bigint): Option.Option<bigint> =>
+  greaterThanOrEqualTo(n, 0n) ? Option.some(unsafeSqrt(n)) : Option.none<bigint>()
+
 /**
  * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint
  *

package/src/Boolean.ts

@@ -1,7 +1,7 @@
 /**
  * This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
  * It includes functions for basic boolean operations, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */

package/src/Data.ts

@@ -1,8 +1,14 @@
 /**
  * @since 2.0.0
  */
+import type * as Channel from "./Channel"
+import * as Effect from "./Effect"
+import * as Effectable from "./Effectable"
 import type * as Equal from "./Equal"
+import type * as Inspectable from "./Inspectable"
 import * as internal from "./internal/Data"
+import { type Pipeable } from "./Pipeable"
+import type * as Sink from "./Sink"
 import type * as Types from "./Types"
 
 /**
@@ -40,8 +46,7 @@ export declare namespace Case {
  * @category constructors
  * @since 2.0.0
  */
-export const struct = <As extends Readonly<Record<string, any>>>(as: As): Data<As> =>
-  Object.assign(Object.create(internal.StructProto), as)
+export const struct: <As extends Readonly<Record<string, any>>>(as: As) => Data<As> = internal.struct
 
 /**
  * @category constructors
@@ -293,3 +298,70 @@ export const taggedEnum: {
     tag: K
   ) => Case.Constructor<Extract<A, { readonly _tag: K }>, "_tag">
 } = () => tagged as any
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface YieldableError extends Case, Pipeable, Inspectable.Inspectable {
+  readonly [Effectable.EffectTypeId]: Effect.Effect.VarianceStruct<never, this, never>
+  readonly [Effectable.StreamTypeId]: Effect.Effect.VarianceStruct<never, this, never>
+  readonly [Effectable.SinkTypeId]: Sink.Sink.VarianceStruct<never, this, unknown, never, never>
+  readonly [Effectable.ChannelTypeId]: Channel.Channel.VarianceStruct<
+    never,
+    unknown,
+    unknown,
+    unknown,
+    this,
+    never,
+    never
+  >
+}
+
+const YieldableErrorProto = Object.setPrototypeOf(
+  {
+    ...Effectable.StructuralCommitPrototype,
+    toString() {
+      return `${this.name}: ${this.message}`
+    },
+    get message() {
+      return JSON.stringify(this)
+    },
+    commit() {
+      return Effect.fail(this)
+    }
+  },
+  globalThis.Error.prototype
+)
+
+/**
+ * Provides a constructor for a Case Class.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Error: new<A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
+) => YieldableError & A = (function() {
+  function Base(this: any, args: any) {
+    if (args) {
+      Object.assign(this, args)
+    }
+    globalThis.Error.captureStackTrace(this, this.constructor)
+  }
+  Base.prototype = YieldableErrorProto
+  return Base as any
+})()
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
+) => YieldableError & { readonly _tag: Tag } & A => {
+  class Base extends Error<{}> {
+    readonly _tag = tag
+  }
+  return Base as any
+}

package/src/Number.ts

@@ -1,7 +1,7 @@
 /**
  * This module provides utility functions and type class instances for working with the `number` type in TypeScript.
  * It includes functions for basic arithmetic operations, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */

package/src/Queue.ts

@@ -216,6 +216,14 @@ export interface Strategy<A> extends Queue.StrategyVariance<A> {
     isShutdown: MutableRef.MutableRef<boolean>
   ): Effect.Effect<never, never, boolean>
 
+  /**
+   * It is called when the backing queue is empty but there are some
+   * takers that can be completed
+   */
+  onCompleteTakersWithEmptyQueue(
+    takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  ): void
+
   /**
    * Determines the behavior of the `Queue.Strategy` when the `Queue` has empty
    * slots following a `take` operation.

package/src/String.ts

@@ -1,7 +1,7 @@
 /**
  * This module provides utility functions and type class instances for working with the `string` type in TypeScript.
  * It includes functions for basic string manipulation, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */

package/src/index.ts

@@ -32,7 +32,7 @@ export {
 /**
  * This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
  * It includes functions for basic arithmetic operations, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */
@@ -41,7 +41,7 @@ export * as Bigint from "effect/Bigint"
 /**
  * This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
  * It includes functions for basic boolean operations, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */
@@ -253,11 +253,6 @@ export * as Equal from "effect/Equal"
  */
 export * as Equivalence from "effect/Equivalence"
 
-/**
- * @since 2.0.0
- */
-export * as Error from "effect/Error"
-
 /**
  * @since 2.0.0
  */
@@ -476,7 +471,7 @@ export * as NonEmptyIterable from "effect/NonEmptyIterable"
 /**
  * This module provides utility functions and type class instances for working with the `number` type in TypeScript.
  * It includes functions for basic arithmetic operations, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */
@@ -674,7 +669,7 @@ export * as Streamable from "effect/Streamable"
 /**
  * This module provides utility functions and type class instances for working with the `string` type in TypeScript.
  * It includes functions for basic string manipulation, as well as type class instances for
- * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
+ * `Equivalence` and `Order`.
  *
  * @since 2.0.0
  */

package/src/internal/Context.ts

@@ -5,10 +5,10 @@ import { globalValue } from "../GlobalValue"
 import * as Hash from "../Hash"
 import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
 import type * as O from "../Option"
-import * as option from "../Option"
 import { pipeArguments } from "../Pipeable"
 import type * as STM from "../STM"
 import { EffectPrototype, effectVariance } from "./Effectable"
+import * as option from "./Option"
 
 /** @internal */
 export const TagTypeId: C.TagTypeId = Symbol.for("effect/Context/Tag") as C.TagTypeId
@@ -205,7 +205,7 @@ export const getOption = dual<
   <Services, S, I>(self: C.Context<Services>, tag: C.Tag<I, S>) => O.Option<S>
 >(2, (self, tag) => {
   if (!self.unsafeMap.has(tag)) {
-    return option.none()
+    return option.none
   }
   return option.some(self.unsafeMap.get(tag)! as any)
 })

package/src/internal/Data.ts

@@ -49,3 +49,7 @@ export const Structural: new<A>(
   Structural.prototype = StructProto
   return Structural as any
 })()
+
+/** @internal */
+export const struct = <As extends Readonly<Record<string, any>>>(as: As): Data.Data<As> =>
+  Object.assign(Object.create(StructProto), as)

package/src/internal/Differ/ChunkPatch.ts

@@ -1,6 +1,6 @@
 import * as Chunk from "../../Chunk"
-import * as Data from "../../Data"
 import type * as Differ from "../../Differ"
+import * as Data from "../Data"
 
 import * as Equal from "../../Equal"
 import * as Dual from "../../Function"

package/src/internal/Differ/ContextPatch.ts

@@ -1,10 +1,10 @@
 import * as Chunk from "../../Chunk"
 import type { Context, Tag } from "../../Context"
-import { Structural } from "../../Data"
 import type { Differ } from "../../Differ"
 import * as Equal from "../../Equal"
 import * as Dual from "../../Function"
 import { makeContext } from "../../internal/Context"
+import { Structural } from "../Data"
 
 /** @internal */
 export const ContextPatchTypeId: Differ.Context.TypeId = Symbol.for(

package/src/internal/Differ/HashMapPatch.ts

@@ -1,9 +1,9 @@
 import * as Chunk from "../../Chunk"
-import { Structural } from "../../Data"
 import type * as Differ from "../../Differ"
 import * as Equal from "../../Equal"
 import * as Dual from "../../Function"
 import * as HashMap from "../../HashMap"
+import { Structural } from "../Data"
 
 /** @internal */
 export const HashMapPatchTypeId: Differ.Differ.HashMap.TypeId = Symbol.for(

package/src/internal/Differ/HashSetPatch.ts

@@ -1,5 +1,5 @@
 import * as Chunk from "../../Chunk"
-import { Structural } from "../../Data"
+import { Structural } from "../Data"
 
 import type { Differ } from "../../Differ"
 import * as Dual from "../../Function"

package/src/internal/Differ/OrPatch.ts

@@ -1,10 +1,10 @@
 import * as Chunk from "../../Chunk"
-import { Structural } from "../../Data"
 import type { Differ } from "../../Differ"
 import type { Either } from "../../Either"
 import * as E from "../../Either"
 import * as Equal from "../../Equal"
 import * as Dual from "../../Function"
+import { Structural } from "../Data"
 
 /** @internal */
 export const OrPatchTypeId: Differ.Or.TypeId = Symbol.for("effect/DifferOrPatch") as Differ.Or.TypeId

package/src/internal/Effectable.ts

@@ -1,5 +1,4 @@
 import type * as Channel from "../Channel"
-import * as Data from "../Data"
 import type * as Effect from "../Effect"
 import type * as Effectable from "../Effectable"
 import * as Equal from "../Equal"
@@ -7,6 +6,7 @@ import * as Hash from "../Hash"
 import { pipeArguments } from "../Pipeable"
 import type * as Sink from "../Sink"
 import type * as Stream from "../Stream"
+import * as Data from "./Data"
 import * as OpCodes from "./opCodes/effect"
 
 /** @internal */

package/src/internal/cache.ts

@@ -1,7 +1,6 @@
 import type * as Cache from "../Cache"
 import type * as Clock from "../Clock"
 import * as Context from "../Context"
-import * as Data from "../Data"
 import * as Deferred from "../Deferred"
 import * as Duration from "../Duration"
 import type * as Effect from "../Effect"
@@ -17,6 +16,7 @@ import * as MutableRef from "../MutableRef"
 import * as Option from "../Option"
 import * as core from "./core"
 import * as effect from "./core-effect"
+import * as Data from "./Data"
 import { none } from "./fiberId"
 import * as fiberRuntime from "./fiberRuntime"
 

package/src/internal/cause.ts

@@ -1172,21 +1172,6 @@ export const prettyErrorMessage = (u: unknown): string => {
     return u["toString"]()
   }
   // 3)
-  if (typeof u === "object" && u !== null) {
-    if ("message" in u && typeof u["message"] === "string") {
-      const raw = JSON.parse(JSON.stringify(u))
-      const keys = new Set(Object.keys(raw))
-      keys.delete("name")
-      keys.delete("message")
-      keys.delete("_tag")
-      if (keys.size === 0) {
-        const name = "name" in u && typeof u.name === "string" ? u.name : "Error"
-        const tag = "_tag" in u && typeof u["_tag"] === "string" ? `(${u._tag})` : ``
-        return `${name}${tag}: ${u.message}`
-      }
-    }
-  }
-  // 4)
   return `Error: ${JSON.stringify(u)}`
 }
 
@@ -1197,7 +1182,7 @@ const defaultRenderError = (error: unknown): PrettyError => {
   if (typeof error === "object" && error !== null && error instanceof Error) {
     return new PrettyError(
       prettyErrorMessage(error),
-      error.stack?.split("\n").filter((_) => !_.startsWith("Error")).join("\n"),
+      error.stack?.split("\n").filter((_) => _.match(/at (.*)/)).join("\n"),
       span
     )
   }

package/src/internal/core-effect.ts

@@ -1631,7 +1631,7 @@ export const tryPromise: {
           promise
             .then((a) => resolve(core.exitSucceed(a)))
             .catch((e) =>
-              resolve(core.exitFail(
+              resolve(core.fail(
                 catcher ? catcher(e) : e
               ))
             )
@@ -1652,7 +1652,7 @@ export const tryPromise: {
         promise
           .then((a) => resolve(core.exitSucceed(a)))
           .catch((e) =>
-            resolve(core.exitFail(
+            resolve(core.fail(
               catcher ? catcher(e) : e
             ))
           )

package/src/internal/fiberRuntime.ts

@@ -1038,11 +1038,11 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
   }
 
   ["Left"](op: core.Primitive & { _op: "Left" }) {
-    return core.exitFail(op.left)
+    return core.fail(op.left)
   }
 
   ["None"](_: core.Primitive & { _op: "None" }) {
-    return core.exitFail(internalCause.NoSuchElementException())
+    return core.fail(internalCause.NoSuchElementException())
   }
 
   ["Right"](op: core.Primitive & { _op: "Right" }) {

package/src/internal/layer.ts

@@ -1135,7 +1135,7 @@ export const withSpan = dual<
     readonly root?: boolean
     readonly context?: Context.Context<never>
   }) => Layer.Layer<R, E, A>
->(2, (self, name, options) =>
+>((args) => isLayer(args[0]), (self, name, options) =>
   unwrapScoped(
     core.map(
       fiberRuntime.useSpanScoped(name, options),