effect 3.1.6 → 3.2.1

package/src/Stream.ts

@@ -22,6 +22,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type * as PubSub from "./PubSub.js"
 import type * as Queue from "./Queue.js"
+import type { Runtime } from "./Runtime.js"
 import type * as Schedule from "./Schedule.js"
 import type * as Scope from "./Scope.js"
 import type * as Sink from "./Sink.js"
@@ -3859,7 +3860,36 @@ export const toQueueOfElements: {
  * @since 2.0.0
  * @category destructors
  */
-export const toReadableStream: <A, E>(source: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+export const toReadableStream: <A, E>(self: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+
+/**
+ * Converts the stream to a `Effect<ReadableStream>`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadableStreamEffect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<ReadableStream<A>, never, R> =
+  internal.toReadableStreamEffect
+
+/**
+ * Converts the stream to a `ReadableStream` using the provided runtime.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadableStreamRuntime: {
+  <XR>(
+    runtime: Runtime<XR>
+  ): <A, E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>
+  <A, E, XR, R extends XR>(
+    self: Stream<A, E, R>,
+    runtime: Runtime<XR>
+  ): ReadableStream<A>
+} = internal.toReadableStreamRuntime
 
 /**
  * Applies the transducer to the stream and emits its outputs.

package/src/Tracer.ts

@@ -92,6 +92,7 @@ export interface SpanOptions {
   readonly root?: boolean | undefined
   readonly context?: Context.Context<never> | undefined
   readonly kind?: SpanKind | undefined
+  readonly captureStackTrace?: boolean | string | undefined
 }
 
 /**

package/src/internal/cause.ts

@@ -10,8 +10,8 @@ import * as HashSet from "../HashSet.js"
 import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
 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 { hasProperty, isFunction } from "../Predicate.js"
 import type { AnySpan, Span } from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
 import { getBugErrorMessage } from "./errors.js"
@@ -968,53 +968,45 @@ export const reduceWithContext = dual<
 // Pretty Printing
 // -----------------------------------------------------------------------------
 
-const filterStack = (stack: string) => {
-  const lines = stack.split("\n")
-  const out: Array<string> = []
-  for (let i = 0; i < lines.length; i++) {
-    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1"))
-    if (lines[i].includes("effect_instruction_i")) {
-      return out.join("\n")
-    }
-  }
-  return out.join("\n")
-}
-
 /** @internal */
 export const pretty = <E>(cause: Cause.Cause<E>): string => {
   if (isInterruptedOnly(cause)) {
     return "All fibers interrupted without errors."
   }
-  const final = prettyErrors<E>(cause).map((e) => {
-    let message = e.message
-    if (e.stack) {
-      message += `\r\n${filterStack(e.stack)}`
-    }
-    if (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}`
-        current = Option.getOrUndefined(current.parent)
-        i++
+  return prettyErrors<E>(cause).map((e) => e.stack).join("\n")
+}
+
+class PrettyError extends globalThis.Error implements Cause.PrettyError {
+  span: undefined | Span = undefined
+  constructor(originalError: unknown) {
+    const prevLimit = Error.stackTraceLimit
+    Error.stackTraceLimit = 0
+    super(prettyErrorMessage(originalError))
+    Error.stackTraceLimit = prevLimit
+
+    this.name = originalError instanceof Error ? originalError.name : "Error"
+    if (typeof originalError === "object" && originalError !== null) {
+      if (spanSymbol in originalError) {
+        this.span = originalError[spanSymbol] as Span
       }
+      Object.keys(originalError).forEach((key) => {
+        if (!(key in this)) {
+          // @ts-expect-error
+          this[key] = originalError[key]
+        }
+      })
     }
-    return message
-  }).join("\r\n")
-  return final
-}
+    this.stack = prettyErrorStack(
+      this.message,
+      originalError instanceof Error && originalError.stack
+        ? originalError.stack
+        : "",
+      this.span
+    )
+  }
 
-class PrettyError {
-  constructor(
-    readonly message: string,
-    readonly stack: string | undefined,
-    readonly span: Span | undefined
-  ) {}
   toJSON() {
-    const out: any = { message: this.message }
-    if (this.stack) {
-      out.stack = this.stack
-    }
+    const out: any = { message: this.message, stack: this.stack }
     if (this.span) {
       out.span = this.span
     }
@@ -1058,29 +1050,55 @@ export const prettyErrorMessage = (u: unknown): string => {
   return `Error: ${JSON.stringify(u)}`
 }
 
-const spanSymbol = Symbol.for("effect/SpanAnnotation")
+const locationRegex = /\((.*)\)/
+
+const prettyErrorStack = (message: string, stack: string, span?: Span | undefined): string => {
+  const out: Array<string> = [message]
+  const lines = stack.split("\n")
 
-const defaultRenderError = (error: unknown): PrettyError => {
-  const span: any = hasProperty(error, spanSymbol) && error[spanSymbol]
-  if (error instanceof Error) {
-    return new PrettyError(
-      prettyErrorMessage(error),
-      error.stack?.split("\n").filter((_) => _.match(/at (.*)/)).join("\n"),
-      span
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].includes("effect_cutpoint") || lines[i].includes("Generator.next")) {
+      break
+    }
+    out.push(
+      lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>")
     )
+    if (lines[i].includes("effect_instruction_i")) {
+      break
+    }
   }
-  return new PrettyError(prettyErrorMessage(error), void 0, span)
+
+  if (span) {
+    let current: Span | AnySpan | undefined = span
+    let i = 0
+    while (current && current._tag === "Span" && i < 10) {
+      const stack = current.attributes.get("code.stacktrace")
+      if (typeof stack === "string") {
+        const locationMatch = stack.match(locationRegex)
+        const location = locationMatch ? locationMatch[1] : stack.replace(/^at /, "")
+        out.push(`    at ${current.name} (${location})`)
+      } else {
+        out.push(`    at ${current.name}`)
+      }
+      current = Option.getOrUndefined(current.parent)
+      i++
+    }
+  }
+
+  return out.join("\n")
 }
 
+const spanSymbol = Symbol.for("effect/SpanAnnotation")
+
 /** @internal */
-export const prettyErrors = <E>(cause: Cause.Cause<E>): ReadonlyArray<PrettyError> =>
+export const prettyErrors = <E>(cause: Cause.Cause<E>): Array<PrettyError> =>
   reduceWithContext(cause, void 0, {
-    emptyCase: (): ReadonlyArray<PrettyError> => [],
+    emptyCase: (): Array<PrettyError> => [],
     dieCase: (_, unknownError) => {
-      return [defaultRenderError(unknownError)]
+      return [new PrettyError(unknownError)]
     },
     failCase: (_, error) => {
-      return [defaultRenderError(error)]
+      return [new PrettyError(error)]
     },
     interruptCase: () => [],
     parallelCase: (_, l, r) => [...l, ...r],

package/src/internal/channel.ts

@@ -2310,29 +2310,47 @@ export const updateService = dual<
     )))
 
 /** @internal */
-export const withSpan = dual<
+export const withSpan: {
   (
     name: string,
     options?: Tracer.SpanOptions
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>,
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
   <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     name: string,
     options?: Tracer.SpanOptions
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
->(3, (self, name, options) =>
-  unwrapScoped(
-    Effect.flatMap(
-      Effect.context(),
-      (context) =>
-        Effect.map(
-          Effect.makeSpanScoped(name, options),
-          (span) => core.provideContext(self, Context.add(context, tracer.spanTag, span))
-        )
+  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return unwrapScoped(
+      Effect.flatMap(
+        Effect.context(),
+        (context) =>
+          Effect.map(
+            Effect.makeSpanScoped(name, options),
+            (span) => core.provideContext(self, Context.add(context, tracer.spanTag, span))
+          )
+      )
+    )
+  }
+  return (self: Effect.Effect<any, any, any>) =>
+    unwrapScoped(
+      Effect.flatMap(
+        Effect.context(),
+        (context) =>
+          Effect.map(
+            Effect.makeSpanScoped(name, options),
+            (span) => core.provideContext(self, Context.add(context, tracer.spanTag, span))
+          )
+      )
     )
-  ) as any)
+} as any
 
 /** @internal */
 export const writeAll = <OutElem>(

package/src/internal/config.ts

@@ -542,7 +542,7 @@ export const unwrap = <A>(wrapped: Config.Config.Wrap<A>): Config.Config<A> => {
   }
   return struct(
     Object.fromEntries(
-      Object.entries(wrapped).map(([k, a]) => [k, unwrap(a)])
+      Object.entries(wrapped).map(([k, a]) => [k, unwrap(a as any)])
     )
   ) as any
 }

package/src/internal/core-effect.ts

@@ -26,6 +26,7 @@ import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
+import type { Unify } from "../Unify.js"
 import { yieldWrapGet } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
@@ -2011,7 +2012,7 @@ const bigint0 = BigInt(0)
 export const unsafeMakeSpan = <XA, XE>(
   fiber: FiberRuntime<XA, XE>,
   name: string,
-  options?: Tracer.SpanOptions
+  options: Tracer.SpanOptions
 ) => {
   const enabled = fiber.getFiberRef(core.currentTracerEnabled)
   if (enabled === false) {
@@ -2029,34 +2030,38 @@ export const unsafeMakeSpan = <XA, XE>(
   const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
   const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
 
-  const parent = options?.parent
+  const parent = options.parent
     ? Option.some(options.parent)
-    : options?.root
+    : options.root
     ? Option.none()
     : Context.getOption(context, internalTracer.spanTag)
 
   const links = linksFromEnv._tag === "Some" ?
-    options?.links !== undefined ?
+    options.links !== undefined ?
       [
         ...Chunk.toReadonlyArray(linksFromEnv.value),
-        ...(options?.links ?? [])
+        ...(options.links ?? [])
       ] :
       Chunk.toReadonlyArray(linksFromEnv.value) :
-    options?.links ?? Arr.empty()
+    options.links ?? Arr.empty()
 
   const span = tracer.span(
     name,
     parent,
-    options?.context ?? Context.empty(),
+    options.context ?? Context.empty(),
     links,
     timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0,
-    options?.kind ?? "internal"
+    options.kind ?? "internal"
   )
 
+  if (typeof options.captureStackTrace === "string") {
+    span.attribute("code.stacktrace", options.captureStackTrace)
+  }
+
   if (annotationsFromEnv._tag === "Some") {
     HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
   }
-  if (options?.attributes !== undefined) {
+  if (options.attributes !== undefined) {
     Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
   }
 
@@ -2067,7 +2072,10 @@ export const unsafeMakeSpan = <XA, XE>(
 export const makeSpan = (
   name: string,
   options?: Tracer.SpanOptions
-): Effect.Effect<Tracer.Span> => core.withFiberRuntime((fiber) => core.succeed(unsafeMakeSpan(fiber, name, options)))
+): Effect.Effect<Tracer.Span> => {
+  options = internalTracer.addSpanStackTrace(options)
+  return core.withFiberRuntime((fiber) => core.succeed(unsafeMakeSpan(fiber, name, options)))
+}
 
 /* @internal */
 export const spanAnnotations: Effect.Effect<HashMap.HashMap<string, unknown>> = core
@@ -2092,7 +2100,7 @@ export const useSpan: {
     evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>
   ]
 ) => {
-  const options: Tracer.SpanOptions | undefined = args.length === 1 ? undefined : args[0]
+  const options = internalTracer.addSpanStackTrace(args.length === 1 ? undefined : args[0])
   const evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R> = args[args.length - 1]
 
   return core.withFiberRuntime<A, E, R>((fiber) => {
@@ -2118,25 +2126,66 @@ export const withParentSpan = dual<
 >(2, (self, span) => provideService(self, internalTracer.spanTag, span))
 
 /** @internal */
-export const withSpan = dual<
+export const withSpan: {
   (
     name: string,
-    options?: Tracer.SpanOptions
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>,
+    options?: Tracer.SpanOptions | undefined
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
     name: string,
-    options?: Tracer.SpanOptions
-  ) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
->(
-  (args) => typeof args[0] !== "string",
-  (self, name, options) =>
-    useSpan(
-      name,
-      options ?? {},
-      (span) => withParentSpan(self, span)
-    )
-)
+    options?: Tracer.SpanOptions | undefined
+  ): Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = internalTracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return useSpan(name, options, (span) => withParentSpan(self, span))
+  }
+  return (self: Effect.Effect<any, any, any>) => useSpan(name, options, (span) => withParentSpan(self, span))
+} as any
+
+export const functionWithSpan = <Args extends Array<any>, Ret extends Effect.Effect<any, any, any>>(
+  options: {
+    readonly body: (...args: Args) => Ret
+    readonly options: Effect.FunctionWithSpanOptions | ((...args: Args) => Effect.FunctionWithSpanOptions)
+    readonly captureStackTrace?: boolean | undefined
+  }
+): (...args: Args) => Unify<Ret> =>
+  (function(this: any) {
+    let captureStackTrace: string | boolean = options.captureStackTrace ?? false
+    if (options.captureStackTrace !== false) {
+      const limit = Error.stackTraceLimit
+      Error.stackTraceLimit = 2
+      const error = new Error()
+      Error.stackTraceLimit = limit
+      if (error.stack !== undefined) {
+        const stack = error.stack.trim().split("\n")
+        captureStackTrace = stack.slice(2).join("\n").trim()
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this
+    const args = arguments
+    return core.suspend(() => {
+      const opts = typeof options.options === "function"
+        ? options.options.apply(null, arguments as any)
+        : options.options
+
+      return withSpan(
+        core.custom(options.body, function() {
+          return this.effect_instruction_i0.apply(self, args as any)
+        }),
+        opts.name,
+        {
+          ...opts,
+          captureStackTrace
+        }
+      )
+    })
+  }) as any
 
 // -------------------------------------------------------------------------------------
 // optionality

package/src/internal/core.ts

@@ -459,6 +459,10 @@ export const as: {
 /* @internal */
 export const asVoid = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> => as(self, void 0)
 
+function commitCallCutpoint(this: any) {
+  return this.effect_cutpoint()
+}
+
 /* @internal */
 export const custom: {
   <X, A, E, R>(i0: X, body: (this: { effect_instruction_i0: X }) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
@@ -477,23 +481,24 @@ export const custom: {
   ): Effect.Effect<A, E, R>
 } = function() {
   const wrapper = new EffectPrimitive(OpCodes.OP_COMMIT) as any
+  wrapper.commit = commitCallCutpoint
   switch (arguments.length) {
     case 2: {
       wrapper.effect_instruction_i0 = arguments[0]
-      wrapper.commit = arguments[1]
+      wrapper.effect_cutpoint = arguments[1]
       break
     }
     case 3: {
       wrapper.effect_instruction_i0 = arguments[0]
       wrapper.effect_instruction_i1 = arguments[1]
-      wrapper.commit = arguments[2]
+      wrapper.effect_cutpoint = arguments[2]
       break
     }
     case 4: {
       wrapper.effect_instruction_i0 = arguments[0]
       wrapper.effect_instruction_i1 = arguments[1]
       wrapper.effect_instruction_i2 = arguments[2]
-      wrapper.commit = arguments[3]
+      wrapper.effect_cutpoint = arguments[3]
       break
     }
     default: {

package/src/internal/fiberRuntime.ts

@@ -1335,7 +1335,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
             internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none))
           )
         } else {
-          cur = core.exitFailCause(internalCause.die(e))
+          cur = core.die(e)
         }
       }
     }
@@ -3622,8 +3622,9 @@ export const interruptWhenPossible = dual<
 export const makeSpanScoped = (
   name: string,
   options?: Tracer.SpanOptions | undefined
-): Effect.Effect<Tracer.Span, never, Scope.Scope> =>
-  core.uninterruptible(
+): Effect.Effect<Tracer.Span, never, Scope.Scope> => {
+  options = tracer.addSpanStackTrace(options)
+  return core.uninterruptible(
     core.withFiberRuntime((fiber) => {
       const scope = Context.unsafeGet(fiber.getFiberRef(core.currentContext), scopeTag)
       const span = internalEffect.unsafeMakeSpan(fiber, name, options)
@@ -3641,27 +3642,37 @@ export const makeSpanScoped = (
       )
     })
   )
+}
 
 /* @internal */
 export const withTracerScoped = (value: Tracer.Tracer): Effect.Effect<void, never, Scope.Scope> =>
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(tracer.tracerTag, value))
 
 /** @internal */
-export const withSpanScoped = dual<
+export const withSpanScoped: {
   (
     name: string,
     options?: Tracer.SpanOptions
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>,
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Scope.Scope | Exclude<R, Tracer.ParentSpan>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
     name: string,
     options?: Tracer.SpanOptions
-  ) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>
->(
-  (args) => typeof args[0] !== "string",
-  (self, name, options) =>
+  ): Effect.Effect<A, E, Scope.Scope | Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return core.flatMap(
+      makeSpanScoped(name, tracer.addSpanStackTrace(options)),
+      (span) => internalEffect.provideService(self, tracer.spanTag, span)
+    )
+  }
+  return (self: Effect.Effect<any, any, any>) =>
     core.flatMap(
-      makeSpanScoped(name, options),
+      makeSpanScoped(name, tracer.addSpanStackTrace(options)),
       (span) => internalEffect.provideService(self, tracer.spanTag, span)
     )
-)
+} as any

package/src/internal/layer/circular.ts

@@ -196,8 +196,9 @@ export const span = (
       | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
       | undefined
   }
-): Layer.Layer<Tracer.ParentSpan> =>
-  layer.scoped(
+): Layer.Layer<Tracer.ParentSpan> => {
+  options = tracer.addSpanStackTrace(options) as any
+  return layer.scoped(
     tracer.spanTag,
     options?.onEnd
       ? core.tap(
@@ -206,6 +207,7 @@ export const span = (
       )
       : fiberRuntime.makeSpanScoped(name, options)
   )
+}
 
 /** @internal */
 export const setTracer = (tracer: Tracer.Tracer): Layer.Layer<never> =>

package/src/internal/layer.ts

@@ -1113,7 +1113,7 @@ export const unwrapScoped = <A, E1, R1, E, R>(
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const withSpan = dual<
+export const withSpan: {
   (
     name: string,
     options?: Tracer.SpanOptions & {
@@ -1121,7 +1121,7 @@ export const withSpan = dual<
         | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
         | undefined
     }
-  ) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>,
+  ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
   <A, E, R>(
     self: Layer.Layer<A, E, R>,
     name: string,
@@ -1130,19 +1130,42 @@ export const withSpan = dual<
         | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
         | undefined
     }
-  ) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
->((args) => isLayer(args[0]), (self, name, options) =>
-  unwrapScoped(
-    core.map(
-      options?.onEnd
-        ? core.tap(
-          fiberRuntime.makeSpanScoped(name, options),
-          (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
-        )
-        : fiberRuntime.makeSpanScoped(name, options),
-      (span) => withParentSpan(self, span)
+  ): Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]) as Tracer.SpanOptions & {
+    readonly onEnd?:
+      | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
+      | undefined
+  }
+  if (dataFirst) {
+    const self = arguments[0]
+    return unwrapScoped(
+      core.map(
+        options?.onEnd
+          ? core.tap(
+            fiberRuntime.makeSpanScoped(name, options),
+            (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
+          )
+          : fiberRuntime.makeSpanScoped(name, options),
+        (span) => withParentSpan(self, span)
+      )
     )
-  ))
+  }
+  return (self: Layer.Layer<any, any, any>) =>
+    unwrapScoped(
+      core.map(
+        options?.onEnd
+          ? core.tap(
+            fiberRuntime.makeSpanScoped(name, options),
+            (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
+          )
+          : fiberRuntime.makeSpanScoped(name, options),
+        (span) => withParentSpan(self, span)
+      )
+    )
+} as any
 
 /** @internal */
 export const withParentSpan = dual<