@typed/fx 0.0.3 → 0.0.6

package/src/Stream/scan.test.ts

@@ -0,0 +1,28 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collectAll } from './_internal.test.js'
+import { continueWith } from './continueWith.js'
+import { flatMap } from './flatMap.js'
+import { now } from './fromFx.js'
+import { scan } from './scan.js'
+
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(scan.name, () => {
+    const stream = pipe(
+      now(1),
+      continueWith(() => now(2)),
+      flatMap((n) => now(n + 1)),
+      scan((acc, n) => acc + n, 0),
+    )
+
+    it('accumulates values', async () => {
+      const values = await collectAll(stream)
+
+      deepStrictEqual(values, [2, 5])
+    })
+  })
+})

package/src/Stream/scan.ts

@@ -0,0 +1,46 @@
+import { Stream } from './Stream.js'
+
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { Live } from '@/FiberId/FiberId.js'
+import { lazy } from '@/Fx/index.js'
+import { Scheduler } from '@/Scheduler/index.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
+
+export function scan<A, B>(f: (b: B, a: A) => B, b: B, __trace?: string) {
+  return <R, E>(stream: Stream<R, E, A>) => ScanStream.make(stream, f, b, __trace)
+}
+
+export class ScanStream<R, E, A, B> implements Stream<R, E, B> {
+  protected state: B
+
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: (b: B, a: A) => B,
+    readonly b: B,
+    readonly __trace?: string,
+  ) {
+    this.state = b
+  }
+
+  readonly fork = <E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) =>
+    this.stream.fork(
+      addTrace(
+        {
+          ...sink,
+          event: (a) => lazy(() => sink.event((this.state = this.f(this.state, a)))),
+        },
+        this.__trace,
+      ),
+      scheduler,
+      context,
+    )
+
+  static make<R, E, A, B>(
+    stream: Stream<R, E, A>,
+    f: (b: B, a: A) => B,
+    b: B,
+    __trace?: string,
+  ): Stream<R, E, B> {
+    return new ScanStream(stream, f, b, __trace)
+  }
+}

package/src/Stream/scheduled.test.ts

@@ -0,0 +1,42 @@
+import { deepStrictEqual } from 'assert'
+
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { collectAll } from './_internal.test.js'
+import { at, scheduled } from './scheduled.js'
+
+import * as Fx from '@/Fx/index.js'
+import * as Schedule from '@/Schedule/index.js'
+import { Delay } from '@/Time/index.js'
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(scheduled.name, () => {
+    it('runs Fx on Schedule', async () => {
+      const value = Math.random()
+
+      deepStrictEqual(await collectAll(scheduled(Schedule.once)(Fx.now(value))), [value])
+
+      deepStrictEqual(await collectAll(scheduled(Schedule.delayed(Delay(1)))(Fx.now(value))), [
+        value,
+      ])
+
+      deepStrictEqual(
+        await collectAll(
+          scheduled(Schedule.periodic(Delay(1)).and(Schedule.retries(NonNegativeInteger(1))))(
+            Fx.now(value),
+          ),
+        ),
+        [value, value],
+      )
+    })
+  })
+
+  describe(at.name, () => {
+    it('runs Fx at a given time', async () => {
+      const value = Math.random()
+
+      deepStrictEqual(await collectAll(at(Delay(5))(value)), [value])
+    })
+  })
+})

package/src/Stream/scheduled.ts

@@ -0,0 +1,55 @@
+import { pipe } from 'hkt-ts'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Stream } from './Stream.js'
+
+import { Env } from '@/Env/Env.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import * as Fx from '@/Fx/index.js'
+import * as Schedule from '@/Schedule/Schedule.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+import { Delay } from '@/Time/index.js'
+import { FiberId } from '@/index.js'
+
+export function scheduled(schedule: Schedule.Schedule, __trace?: string) {
+  return <R, E, A>(fx: Fx.Fx<R, E, A>): Stream<R, E, A> =>
+    Stream(<E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) =>
+      pipe(
+        Fx.asksEnv(
+          (env: Env<R>) =>
+            scheduler.schedule(
+              Fx.matchCause(sink.error, sink.event, __trace)(fx),
+              env,
+              schedule,
+              context,
+              () => sink.end,
+            ),
+          __trace,
+        ),
+      ),
+    )
+}
+
+export function at(delay: Delay, __trace?: string) {
+  return <A>(value: A): Stream<never, never, A> =>
+    scheduled(Schedule.delayed(delay), __trace)(Fx.now(value))
+}
+
+export function repeated(period: Delay, __trace?: string) {
+  return <A>(value: A): Stream<never, never, A> =>
+    scheduled(Schedule.periodic(period), __trace)(Fx.now(value))
+}
+
+export const exponential = (delay: Delay, __trace?: string) =>
+  scheduled(Schedule.exponential(delay), __trace)
+
+export const forever = scheduled(Schedule.forever, 'Scheduled.forever')
+
+export const recurring = (amount: NonNegativeInteger, __trace?: string) =>
+  scheduled(Schedule.recurring(amount), __trace)
+
+export const retries = (amount: NonNegativeInteger, __trace?: string) =>
+  scheduled(Schedule.retries(amount), __trace)
+
+export const spaced = (delay: Delay, __trace?: string) => scheduled(Schedule.spaced(delay), __trace)

package/src/Stream/setFiberRefLocally.ts

@@ -0,0 +1,44 @@
+import { pipe } from 'hkt-ts'
+
+import { Stream } from './Stream.js'
+
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { FiberRef } from '@/FiberRef/FiberRef.js'
+import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
+import { flatMap, fromLazy } from '@/Fx/Fx.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+
+export function setFiberRefLocally<R, E, A>(fiberRef: FiberRef<R, E, A>, value: () => A) {
+  return <R2, E2, A2>(fx: Stream<R2, E2, A2>) => new SetFiberRefLocallyStream(fx, fiberRef, value)
+}
+
+export class SetFiberRefLocallyStream<R, E, A, R2, E2, A2> implements Stream<R2, E2, A2> {
+  constructor(
+    readonly stream: Stream<R2, E2, A2>,
+    readonly fiberRef: FiberRef<R, E, A>,
+    readonly value: () => A,
+  ) {}
+
+  fork<E3>(sink: Sink<E2, A2, E3>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) {
+    return pipe(
+      fromLazy(() => FiberRefs.setFiberRefLocally(this.fiberRef, this.value())(context.fiberRefs)),
+      flatMap(() =>
+        this.stream.fork(
+          {
+            ...sink,
+            end: pipe(
+              sink.end,
+              flatMap(() =>
+                fromLazy(() => FiberRefs.popLocalFiberRef(this.fiberRef)(context.fiberRefs)),
+              ),
+            ),
+          },
+          scheduler,
+          context,
+        ),
+      ),
+    )
+  }
+}

package/src/Stream/switchMap.test.ts

@@ -0,0 +1,43 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collectAll } from './_internal.test.js'
+import { now } from './fromFx.js'
+import { merge } from './merge.js'
+import { at } from './scheduled.js'
+import { switchMap } from './switchMap.js'
+
+import { Delay } from '@/Time/index.js'
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(switchMap.name, () => {
+    const value = Math.random()
+    const stream = pipe(
+      now(value),
+      switchMap((a) => now(a + 1)),
+    )
+
+    it('is collectable', async () => {
+      const events = await collectAll(stream)
+      deepStrictEqual(events, [value + 1])
+    })
+
+    it('is collectable with multiple subscribers', async () => {
+      const events = await Promise.all([collectAll(stream), collectAll(stream)])
+      deepStrictEqual(events, [[value + 1], [value + 1]])
+    })
+
+    it('cancels the previous stream', async () => {
+      const stream = pipe(
+        at(Delay(0))(1),
+        merge(at(Delay(50))(5)),
+        switchMap((a) => pipe(now(a), merge(at(Delay(100))(a + 1)))),
+      )
+
+      const events = await collectAll(stream)
+      deepStrictEqual(events, [1, 5, 6])
+    })
+  })
+})

package/src/Stream/switchMap.ts

@@ -0,0 +1,159 @@
+import { flow, pipe } from 'hkt-ts'
+import { isRight } from 'hkt-ts/Either'
+import { isJust } from 'hkt-ts/Maybe'
+
+import { Stream } from './Stream.js'
+import { MapStream } from './map.js'
+
+import { Cause } from '@/Cause/index.js'
+import { Disposable, Settable, settable } from '@/Disposable/Disposable.js'
+import { Env } from '@/Env/Env.js'
+import { Fiber } from '@/Fiber/Fiber.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { Live } from '@/FiberId/FiberId.js'
+import * as FiberRefs from '@/FiberRefs/index.js'
+import * as Fx from '@/Fx/index.js'
+import { access, lazy, unit } from '@/Fx/index.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Lock } from '@/Semaphore/Semaphore.js'
+import * as Sink from '@/Sink/Sink.js'
+import { None, and } from '@/Supervisor/Supervisor.js'
+
+export function switchMap<A, R2, E2, B>(
+  f: (a: A) => Stream<R2, E2, B>,
+  __trace?: string,
+): <R, E>(stream: Stream<R, E, A>) => Stream<R | R2, E | E2, B> {
+  return (stream) => SwitchMapStream.make(stream, f, __trace)
+}
+
+export function switchLatest<R, E, R2, E2, A>(
+  stream: Stream<R, E, Stream<R2, E2, A>>,
+  __trace?: string,
+): Stream<R | R2, E | E2, A> {
+  return switchMap((a: Stream<R2, E2, A>) => a, __trace)(stream)
+}
+
+export class SwitchMapStream<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2, B> {
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: (a: A) => Stream<R2, E2, B>,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E3>(sink: Sink.Sink<E | E2, B, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
+    const { stream, f } = this
+
+    return access((env: Env<R | R2>) =>
+      stream.fork(
+        new SwitchMapSink(sink, scheduler, context, f, env, this.__trace),
+        scheduler,
+        context,
+      ),
+    )
+  }
+
+  static make<R, E, A, R2, E2, B>(
+    stream: Stream<R, E, A>,
+    f: (a: A) => Stream<R2, E2, B>,
+    __trace?: string,
+  ): Stream<R | R2, E | E2, B> {
+    if (stream instanceof MapStream) {
+      return SwitchMapStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    return new SwitchMapStream(stream, f, __trace)
+  }
+}
+
+class SwitchMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3> {
+  protected _ended = false
+  protected _fibers: Array<Fiber<E3, any>> = []
+  protected _lock = new Lock()
+
+  protected _supervisor = None.extend({
+    onEnd: () => (fiber, exit) => {
+      const parentContext = fiber.context.parent
+
+      // Merge FiberRefs upon successful completion
+      if (isRight(exit) && isJust(parentContext)) {
+        FiberRefs.join(parentContext.value.fiberRefs, fiber.context.fiberRefs)
+      }
+    },
+  })
+
+  constructor(
+    readonly sink: Sink.Sink<E | E2, B, E3>,
+    readonly scheduler: Scheduler,
+    readonly context: FiberContext<Live>,
+    readonly f: (a: A) => Stream<R2, E2, B>,
+    readonly env: Env<R | R2>,
+    readonly __trace?: string,
+  ) {}
+
+  event = (a: A): Fx.IO<E3, unknown> =>
+    Fx.lazy(() => {
+      const forked = this.context.fork({
+        supervisor: and(this._supervisor)(this.context.supervisor),
+      })
+
+      const cleanup: Fx.Of<unknown> = Fx.zipAll(this._fibers.map((f) => f.interruptAs(forked.id)))
+      const disposable = settable()
+      const sink = this.innerSink(disposable)
+
+      return pipe(
+        cleanup, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Fx.flatMap(() => this.f(a).fork(Sink.addTrace(sink, this.__trace), this.scheduler, forked)),
+        Fx.tapLazy((fiber) => {
+          this._fibers.push(fiber)
+
+          disposable.add(
+            Disposable(() => {
+              this._fibers.splice(this._fibers.indexOf(fiber), 1)
+            }),
+          )
+        }),
+        Fx.flatMap((fiber) =>
+          pipe(
+            fiber,
+            Fx.join,
+            Fx.tapLazy(() => disposable.dispose()),
+          ),
+        ),
+        (x) => x,
+        Fx.provide(this.env),
+      )
+    })
+
+  error = (cause: Cause<E | E2>) => {
+    return lazy(() => {
+      this._ended = true
+
+      return this.sink.error(cause)
+    })
+  }
+
+  end = lazy(() => {
+    this._ended = true
+
+    return this.endIfCompleted()
+  })
+
+  protected endIfCompleted() {
+    if (this._ended && this._fibers.length === 0) {
+      return this.sink.end
+    }
+
+    return unit
+  }
+
+  protected innerSink(disposable: Settable): Sink.Sink<E | E2, B, E3> {
+    return {
+      event: this.sink.event,
+      error: this.error,
+      end: lazy(() => {
+        disposable.dispose()
+        return this.endIfCompleted()
+      }),
+    }
+  }
+}

package/src/Stream/tap.ts

@@ -0,0 +1,24 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+import { flatMapFx } from './flatMapFx.js'
+
+import { Fx, fromLazy, map } from '@/Fx/Fx.js'
+
+export const tap =
+  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, __trace?: string) =>
+  <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A> =>
+    pipe(
+      stream,
+      flatMapFx(
+        (a) =>
+          pipe(
+            f(a),
+            map(() => a),
+          ),
+        __trace,
+      ),
+    )
+
+export const tapLazy = <A, B>(f: (a: A) => B, __trace?: string) =>
+  tap((a: A) => fromLazy(() => f(a)), __trace)

package/src/Supervisor/Supervisor.ts

@@ -14,6 +14,20 @@ export class Supervisor<A> {
     readonly onSuspended: (fiber: AnyLiveFiber) => void = constVoid,
     readonly onRunning: (fiber: AnyLiveFiber) => void = constVoid,
   ) {}
+
+  readonly extend = <B = A>(
+    overrides: Partial<{
+      readonly [K in keyof Supervisor<A>]: (parent: Supervisor<A>[K]) => Supervisor<B>[K]
+    }>,
+  ): Supervisor<B> =>
+    new Supervisor(
+      (overrides.value ? overrides.value(this.value) : this.value) as Of<B>,
+      overrides.onStart ? overrides.onStart(this.onStart) : this.onStart,
+      overrides.onEnd ? overrides.onEnd(this.onEnd) : this.onEnd,
+      overrides.onInstruction ? overrides.onInstruction(this.onInstruction) : this.onInstruction,
+      overrides.onSuspended ? overrides.onSuspended(this.onSuspended) : this.onSuspended,
+      overrides.onRunning ? overrides.onRunning(this.onRunning) : this.onRunning,
+    )
 }
 
 export const None = new (class None extends Supervisor<any> {})(unit)

package/src/Supervisor/index.ts

@@ -1 +1,2 @@
 export * from './Supervisor.js'
+export * from './trackIn.js'

package/src/Supervisor/maxFailures.ts

@@ -0,0 +1,86 @@
+import { pipe } from 'hkt-ts'
+import { isRight } from 'hkt-ts/Either'
+import * as Maybe from 'hkt-ts/Maybe'
+import { First } from 'hkt-ts/Typeclass/Associative'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Supervisor } from './Supervisor.js'
+
+import { Atomic, update } from '@/Atomic/Atomic.js'
+import * as Exit from '@/Exit/Exit.js'
+import { AnyLiveFiber } from '@/Fiber/Fiber.js'
+import { FiberId } from '@/FiberId/index.js'
+import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
+import { AnyFx, fromLazy } from '@/Fx/index.js'
+import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
+
+const concatExitSeq = Exit.makeSequentialAssociative<any, any>(First).concat
+
+export interface FiberFailureState {
+  readonly fx: AnyFx
+  readonly fiber: AnyLiveFiber
+  readonly exit: Maybe.Maybe<Exit.AnyExit>
+  readonly failures: NonNegativeInteger
+}
+
+export interface FiberFailuresState extends ImmutableMap<FiberId.Live, FiberFailureState> {}
+
+export function maxFailures(maxFailures: NonNegativeInteger): Supervisor<FiberFailuresState> {
+  const state = Atomic<FiberFailuresState>(ImmutableMap())
+
+  return new Supervisor(
+    fromLazy(state.get),
+    (fiber, fx) => {
+      pipe(
+        state,
+        update((fibers) => {
+          return fibers.has(fiber.id)
+            ? fibers
+            : fibers.set(fiber.id, {
+                fx,
+                fiber,
+                exit: Maybe.Nothing,
+                failures: NonNegativeInteger(0),
+              })
+        }),
+      )
+    },
+    (fiber, exit) => {
+      pipe(
+        state,
+        update((fibers) =>
+          pipe(
+            fibers.get(fiber.id),
+            Maybe.match(
+              () => fibers,
+              (s) => {
+                const nextIteration = NonNegativeInteger(s.failures + 1)
+
+                // If we succeeded, remove the fiber from state.
+                if (isRight(exit) || nextIteration > maxFailures) {
+                  return fibers.remove(fiber.id)
+                }
+
+                // Retry this Fx
+                const nextFiber = new FiberRuntime(s.fx, s.fiber.context.fork())
+
+                nextFiber.startAsync()
+
+                return fibers.set(fiber.id, {
+                  ...s,
+                  exit: pipe(
+                    s.exit,
+                    Maybe.map((e) => concatExitSeq(e, exit)),
+                    Maybe.orElse(() => Maybe.Just(exit)),
+                  ),
+                  fiber: nextFiber,
+                  failures: nextIteration,
+                })
+              },
+            ),
+          ),
+        ),
+      )
+    },
+  )
+}

package/src/Supervisor/trackIn.ts

@@ -0,0 +1,33 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Supervisor } from './Supervisor.js'
+
+import { Atomic, update } from '@/Atomic/Atomic.js'
+import { AnyLiveFiber } from '@/Fiber/Fiber.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { fromLazy } from '@/Fx/Fx.js'
+
+export function trackIn(
+  fibers: Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>> = Atomic<
+    ReadonlyMap<FiberId.Live, AnyLiveFiber>
+  >(new Map()),
+): Supervisor<ReadonlyMap<FiberId.Live, AnyLiveFiber>> {
+  return new Supervisor(
+    fromLazy(() => fibers.get()),
+    (fiber) => {
+      pipe(
+        fibers,
+        update((fibers) => new Map([...fibers, [fiber.id, fiber]])),
+      )
+    },
+    (fiber) => {
+      pipe(
+        fibers,
+        update(
+          (fibers) =>
+            new Map([...fibers].filter(([id]) => id.sequenceNumber !== fiber.id.sequenceNumber)),
+        ),
+      )
+    },
+  )
+}

package/src/Timeline/index.ts

@@ -51,6 +51,7 @@ class TimelineImpl<A> implements Timeline<A> {
 
   readonly add = (time: UnixTime, a: A): Disposable => {
     insertByTime(time, a, this.timeSlots)
+
     this.onUpdated?.()
 
     return Disposable(() => this.remove(time, a))

package/src/Trace/Trace.ts

@@ -1,5 +1,6 @@
 import { pipe } from 'hkt-ts'
 import * as A from 'hkt-ts/Array'
+import { not } from 'hkt-ts/Predicate'
 import * as ASSOC from 'hkt-ts/Typeclass/Associative'
 import * as D from 'hkt-ts/Typeclass/Debug'
 import * as E from 'hkt-ts/Typeclass/Eq'
@@ -123,10 +124,7 @@ export function trimOverlappingTraces(current: Trace, incoming: Trace): Trace {
     return current
   }
 
-  const frames = trimOverlappingFrames(
-    current.frames.slice(0, incoming.frames.length), // Only compare the same amount of values
-    incoming.frames,
-  )
+  const frames = trimOverlappingFrames(current.frames, incoming.frames)
 
   return frames.length === 0
     ? EmptyTrace
@@ -137,46 +135,9 @@ function trimOverlappingFrames(
   current: ReadonlyArray<StackFrame.StackFrame>,
   incoming: ReadonlyArray<StackFrame.StackFrame>,
 ): ReadonlyArray<StackFrame.StackFrame> {
-  // Clone our Array for mutation
-  const outgoing: Array<StackFrame.StackFrame> = [...incoming]
+  const intersected = A.intersection(E.DeepEquals)(incoming)(current.slice(0, incoming.length))
 
-  let cIndex = current.length - 1
-  let iIndex = 0
-  let deleted = 0
-
-  for (; cIndex > -1 && iIndex < incoming.length; ) {
-    const c = current[cIndex]
-    const i = incoming[iIndex]
-
-    // If neither are Runtime instructions, lets just break early
-    if (!(c.tag === 'Runtime' || i.tag === 'Runtime')) {
-      break
-    }
-
-    // Skip over custom/instrumented traces
-    if (c.tag !== 'Runtime') {
-      cIndex--
-
-      continue
-    }
-    if (i.tag !== 'Runtime') {
-      iIndex++
-
-      continue
-    }
-
-    // If we don't have a match, just break
-    if (!StackFrame.Eq.equals(c, i)) {
-      break
-    }
-
-    // Remove this Trace
-    outgoing.splice(iIndex - deleted++, 1)
-    cIndex--
-    iIndex++
-  }
-
-  return outgoing
+  return incoming.filter(not((a) => A.contains(E.DeepEquals)(a)(intersected)))
 }
 
 export interface StackTrace extends Stack<Trace> {}
@@ -198,12 +159,17 @@ export function getTraceUpTo(trace: StackTrace, amount: number): Trace {
   return frames.length > 0 ? new StackFrameTrace(frames) : EmptyTrace
 }
 
-export function getTrimmedTrace<E>(cause: Cause<E>, stackTrace: StackTrace) {
+export function getTrimmedTrace<E>(
+  cause: Cause<E>,
+  stackTrace: StackTrace,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  targetObject?: Function,
+) {
   const error =
     (cause.tag === 'Unexpected' || cause.tag === 'Expected') && cause.error instanceof Error
       ? cause.error
       : new Error()
-  const trace = Trace.runtime(error, getTrimmedTrace)
+  const trace = Trace.runtime(error, targetObject)
   const toCompare = getTraceUpTo(stackTrace, trace.frames.length)
 
   return trimOverlappingTraces(toCompare, trace)