@typed/fx 1.8.2 → 1.9.0

package/src/index.ts

@@ -18,7 +18,7 @@ export const at: {
   2,
   (trace) =>
     <A>(value: A, delay: Duration): Fx<never, never, A> =>
-      internal.at(value, delay).traced(trace),
+      internal.at(value, delay).addTrace(trace),
 )
 
 export const catchAllCause: {
@@ -33,7 +33,7 @@ export const catchAllCause: {
       fx: Fx<R, E, B>,
       f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
     ): Fx<R | R2, E2, B> =>
-      internal.catchAllCause(fx, f).traced(trace),
+      internal.catchAllCause(fx, f).addTrace(trace),
 )
 
 export const catchAllCauseEffect: {
@@ -52,7 +52,7 @@ export const catchAllCauseEffect: {
       fx: Fx<R, E, B>,
       f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
     ): Fx<R | R2, E2, B> =>
-      internal.catchAllCauseEffect(fx, f).traced(trace),
+      internal.catchAllCauseEffect(fx, f).addTrace(trace),
 )
 
 export const catchAll: {
@@ -63,7 +63,7 @@ export const catchAll: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B> =>
-      internal.catchAll(fx, f).traced(trace),
+      internal.catchAll(fx, f).addTrace(trace),
 )
 
 export const catchAllEffect: {
@@ -83,7 +83,7 @@ export const catchAllEffect: {
       fx: Fx<R, E, A>,
       f: (e: E) => Effect.Effect<R2, E2, B>,
     ): Fx<R | R2, E2, A | B> =>
-      internal.catchAllEffect(fx, f).traced(trace),
+      internal.catchAllEffect(fx, f).addTrace(trace),
 )
 
 export const combineAll: <FX extends readonly internal.Fx<any, any, any>[]>(
@@ -95,7 +95,7 @@ export const combineAll: <FX extends readonly internal.Fx<any, any, any>[]>(
 > = methodWithTrace(
   (trace) =>
     (...fx) =>
-      internal.combineAll(...fx).traced(trace),
+      internal.combineAll(...fx).addTrace(trace),
 )
 
 export const combine: {
@@ -104,7 +104,7 @@ export const combine: {
   ) => Fx<R | R2, E | E2, readonly [A, B]>
 
   <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, readonly [A, B]>
-} = dualWithTrace(2, (trace) => (fx, other) => internal.combine(fx, other).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, other) => internal.combine(fx, other).addTrace(trace))
 
 export const continueWith: {
   <R2, E2, B>(f: () => Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
@@ -114,7 +114,7 @@ export const continueWith: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B> =>
-      internal.continueWith(fx, f).traced(trace),
+      internal.continueWith(fx, f).addTrace(trace),
 )
 
 export const continueWithEffect: {
@@ -134,21 +134,21 @@ export const continueWithEffect: {
       fx: Fx<R, E, A>,
       f: () => Effect.Effect<R2, E2, B>,
     ): Fx<R | R2, E | E2, A | B> =>
-      internal.continueWithEffect(fx, f).traced(trace),
+      internal.continueWithEffect(fx, f).addTrace(trace),
 )
 
 export const debounce: {
   (duration: Duration): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, duration: Duration): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, duration) => internal.debounce(fx, duration).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, duration) => internal.debounce(fx, duration).addTrace(trace))
 
 export const delay: {
   (duration: Duration): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, duration: Duration): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, duration) => internal.delay(fx, duration).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, duration) => internal.delay(fx, duration).addTrace(trace))
 
 export const empty: <E = never, A = never>(_: void) => Fx<never, E, A> = methodWithTrace(
-  (trace) => () => internal.empty().traced(trace),
+  (trace) => () => internal.empty().addTrace(trace),
 )
 
 export const exhaustMap: {
@@ -159,7 +159,7 @@ export const exhaustMap: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>) =>
-      internal.exhaustMap(fx, f).traced(trace),
+      internal.exhaustMap(fx, f).addTrace(trace),
 )
 
 export const exhaustMapEffect: {
@@ -176,14 +176,14 @@ export const exhaustMapEffect: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>) =>
-      internal.exhaustMapEffect(fx, f).traced(trace),
+      internal.exhaustMapEffect(fx, f).addTrace(trace),
 )
 
 export const exhaust: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> =
   methodWithTrace(
     (trace) =>
       <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) =>
-        internal.exhaust<R, E, R2, E2, A>(fx).traced(trace),
+        internal.exhaust<R, E, R2, E2, A>(fx).addTrace(trace),
   )
 
 export const exhaustEffect: <R, E, R2, E2, A>(
@@ -191,7 +191,7 @@ export const exhaustEffect: <R, E, R2, E2, A>(
 ) => Fx<R | R2, E | E2, A> = methodWithTrace(
   (trace) =>
     <R, E, R2, E2, A>(fx: Fx<R, E, Effect.Effect<R2, E2, A>>) =>
-      internal.exhaustEffect<R, E, R2, E2, A>(fx).traced(trace),
+      internal.exhaustEffect<R, E, R2, E2, A>(fx).addTrace(trace),
 )
 
 export const exhaustMapLatest: {
@@ -202,7 +202,7 @@ export const exhaustMapLatest: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>) =>
-      internal.exhaustMapLatest(fx, f).traced(trace),
+      internal.exhaustMapLatest(fx, f).addTrace(trace),
 )
 
 export const exhaustMapLatestEffect: {
@@ -219,7 +219,7 @@ export const exhaustMapLatestEffect: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>) =>
-      internal.exhaustMapLatestEffect(fx, f).traced(trace),
+      internal.exhaustMapLatestEffect(fx, f).addTrace(trace),
 )
 
 export const exhaustLatest: <R, E, R2, E2, A>(
@@ -227,7 +227,7 @@ export const exhaustLatest: <R, E, R2, E2, A>(
 ) => Fx<R | R2, E | E2, A> = methodWithTrace(
   (trace) =>
     <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) =>
-      internal.exhaustLatest<R, E, R2, E2, A>(fx).traced(trace),
+      internal.exhaustLatest<R, E, R2, E2, A>(fx).addTrace(trace),
 )
 
 export const exhaustLatestEffect: <R, E, R2, E2, A>(
@@ -235,7 +235,7 @@ export const exhaustLatestEffect: <R, E, R2, E2, A>(
 ) => Fx<R | R2, E | E2, A> = methodWithTrace(
   (trace) =>
     <R, E, R2, E2, A>(fx: Fx<R, E, Effect.Effect<R2, E2, A>>) =>
-      internal.exhaustLatestEffect<R, E, R2, E2, A>(fx).traced(trace),
+      internal.exhaustLatestEffect<R, E, R2, E2, A>(fx).addTrace(trace),
 )
 
 export const exhaustMapCause: {
@@ -252,7 +252,7 @@ export const exhaustMapCause: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: Cause.Cause<E>) => Fx<R2, E2, B>) =>
-      internal.exhaustMapCause(fx, f).traced(trace),
+      internal.exhaustMapCause(fx, f).addTrace(trace),
 )
 
 export const exhaustMapCauseEffect: {
@@ -269,7 +269,7 @@ export const exhaustMapCauseEffect: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: Cause.Cause<E>) => Effect.Effect<R2, E2, B>) =>
-      internal.exhaustMapCauseEffect(fx, f).traced(trace),
+      internal.exhaustMapCauseEffect(fx, f).addTrace(trace),
 )
 
 export const exhaustMapError: {
@@ -280,7 +280,7 @@ export const exhaustMapError: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>) =>
-      internal.exhaustMapError(fx, f).traced(trace),
+      internal.exhaustMapError(fx, f).addTrace(trace),
 )
 
 export const exhaustMapErrorEffect: {
@@ -297,7 +297,7 @@ export const exhaustMapErrorEffect: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, B>) =>
-      internal.exhaustMapErrorEffect(fx, f).traced(trace),
+      internal.exhaustMapErrorEffect(fx, f).addTrace(trace),
 )
 
 export const exhaustMapLatestCause: {
@@ -314,7 +314,7 @@ export const exhaustMapLatestCause: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: Cause.Cause<E>) => Fx<R2, E2, B>) =>
-      internal.exhaustMapLatestCause(fx, f).traced(trace),
+      internal.exhaustMapLatestCause(fx, f).addTrace(trace),
 )
 
 export const exhaustMapLatestCauseEffect: {
@@ -331,7 +331,7 @@ export const exhaustMapLatestCauseEffect: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: Cause.Cause<E>) => Effect.Effect<R2, E2, B>) =>
-      internal.exhaustMapLatestCauseEffect(fx, f).traced(trace),
+      internal.exhaustMapLatestCauseEffect(fx, f).addTrace(trace),
 )
 
 export const exhaustMapLatestError: {
@@ -342,7 +342,7 @@ export const exhaustMapLatestError: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>) =>
-      internal.exhaustMapLatestError(fx, f).traced(trace),
+      internal.exhaustMapLatestError(fx, f).addTrace(trace),
 )
 
 export const exhaustMapLatestErrorEffect: {
@@ -359,25 +359,25 @@ export const exhaustMapLatestErrorEffect: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, B>) =>
-      internal.exhaustMapLatestErrorEffect(fx, f).traced(trace),
+      internal.exhaustMapLatestErrorEffect(fx, f).addTrace(trace),
 )
 
 export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never> = methodWithTrace(
   (trace) =>
     <E>(cause: Cause.Cause<E>): Fx<never, E, never> =>
-      internal.failCause(cause).traced(trace),
+      internal.failCause(cause).addTrace(trace),
 )
 
 export const fail: <E>(e: E) => Fx<never, E, never> = methodWithTrace(
   (trace) =>
     <E>(e: E): Fx<never, E, never> =>
-      internal.fail(e).traced(trace),
+      internal.fail(e).addTrace(trace),
 )
 
 export const interrupt: (id: FiberId) => Fx<never, never, never> = methodWithTrace(
   (trace) =>
     (id: FiberId): Fx<never, never, never> =>
-      internal.interrupt(id).traced(trace),
+      internal.interrupt(id).addTrace(trace),
 )
 
 export const filter: {
@@ -390,7 +390,7 @@ export const filter: {
   2,
   (trace) =>
     <R, E, A, B extends A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A | B> =>
-      internal.filter(fx, predicate).traced(trace),
+      internal.filter(fx, predicate).addTrace(trace),
 )
 
 export const filterMap: {
@@ -400,13 +400,13 @@ export const filterMap: {
   2,
   (trace) =>
     <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B> =>
-      internal.filterMap(fx, f).traced(trace),
+      internal.filterMap(fx, f).addTrace(trace),
 )
 
 export const compact: <R, E, A>(fx: Fx<R, E, Option.Option<A>>) => Fx<R, E, A> = methodWithTrace(
   (trace) =>
     <R, E, A>(fx: Fx<R, E, Option.Option<A>>): Fx<R, E, A> =>
-      internal.compact(fx).traced(trace),
+      internal.compact(fx).addTrace(trace),
 )
 
 export const flatMap: {
@@ -416,7 +416,7 @@ export const flatMap: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>): Fx<R | R2, E | E2, B> =>
-      internal.flatMap(fx, f).traced(trace),
+      internal.flatMap(fx, f).addTrace(trace),
 )
 
 export const flatMapEffect: {
@@ -435,14 +435,14 @@ export const flatMapEffect: {
       fx: Fx<R, E, A>,
       f: (a: A) => Effect.Effect<R2, E2, B>,
     ): Fx<R | R2, E | E2, B> =>
-      internal.flatMapEffect(fx, f).traced(trace),
+      internal.flatMapEffect(fx, f).addTrace(trace),
 )
 
 export const flatten: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> =
   methodWithTrace(
     (trace) =>
       <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>): Fx<R | R2, E | E2, A> =>
-        internal.flatten<R, E, R2, E2, A>(fx).traced(trace),
+        internal.flatten<R, E, R2, E2, A>(fx).addTrace(trace),
   )
 
 export const flattenEffect: <R, E, R2, E2, A>(
@@ -450,19 +450,19 @@ export const flattenEffect: <R, E, R2, E2, A>(
 ) => Fx<R | R2, E | E2, A> = methodWithTrace(
   (trace) =>
     <R, E, R2, E2, A>(fx: Fx<R, E, Effect.Effect<R2, E2, A>>): Fx<R | R2, E | E2, A> =>
-      internal.flattenEffect(fx).traced(trace),
+      internal.flattenEffect(fx).addTrace(trace),
 )
 
 export const fromArray: <A>(as: ReadonlyArray<A>) => Fx<never, never, A> = methodWithTrace(
   (trace) =>
     <A>(as: ReadonlyArray<A>): Fx<never, never, A> =>
-      internal.fromArray(as).traced(trace),
+      internal.fromArray(as).addTrace(trace),
 )
 
 export const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Fx<R, E, A> = methodWithTrace(
   (trace) =>
     <R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> =>
-      internal.fromEffect(effect).traced(trace),
+      internal.fromEffect(effect).addTrace(trace),
 )
 
 export interface Emitter<E, A> extends internal.Emitter<E, A> {}
@@ -470,13 +470,13 @@ export interface Emitter<E, A> extends internal.Emitter<E, A> {}
 export const fromEmitter: <E, A, R, E2>(
   f: (emitter: internal.Emitter<E, A>) => Effect.Effect<R | Scope.Scope, E2, void>,
 ) => internal.Fx<Exclude<R, Scope.Scope>, E | E2, A> = methodWithTrace(
-  (trace) => (f) => internal.fromEmitter(f).traced(trace),
+  (trace) => (f) => internal.fromEmitter(f).addTrace(trace),
 )
 
 export const fromIterable: <A>(as: Iterable<A>) => Fx<never, never, A> = methodWithTrace(
   (trace) =>
     <A>(as: Iterable<A>): Fx<never, never, A> =>
-      internal.fromIterable(as).traced(trace),
+      internal.fromIterable(as).addTrace(trace),
 )
 
 export const fromFxEffect: <R, E, R2, E2, A>(
@@ -484,7 +484,7 @@ export const fromFxEffect: <R, E, R2, E2, A>(
 ) => Fx<R | R2, E | E2, A> = methodWithTrace(
   (trace) =>
     <R, E, R2, E2, A>(effect: Effect.Effect<R, E, Fx<R2, E2, A>>): Fx<R | R2, E | E2, A> =>
-      internal.fromFxEffect(effect).traced(trace),
+      internal.fromFxEffect(effect).addTrace(trace),
 )
 
 export type EffectGenResources<T> = internal.EffectGenResources<T>
@@ -496,13 +496,13 @@ export type EffectGenOutput<T> = internal.EffectGenOutput<T>
 export const gen: <Y extends Effect.EffectGen<any, any, any>, R, E, A>(
   f: (adaper: Effect.Adapter) => Generator<Y, Fx<R, E, A>, unknown>,
 ) => Fx<R | internal.EffectGenResources<Y>, E | internal.EffectGenErrors<Y>, A> = methodWithTrace(
-  (trace) => (f) => internal.gen(f).traced(trace),
+  (trace) => (f) => internal.gen(f).addTrace(trace),
 )
 
 export const hold: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = methodWithTrace(
   (trace) =>
     <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> =>
-      internal.hold(fx).traced(trace),
+      internal.hold(fx).addTrace(trace),
 )
 
 export const map: {
@@ -512,7 +512,7 @@ export const map: {
   2,
   (trace) =>
     <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> =>
-      internal.map(fx, f).traced(trace),
+      internal.map(fx, f).addTrace(trace),
 )
 
 export const as: {
@@ -522,7 +522,7 @@ export const as: {
   2,
   (trace) =>
     <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, B> =>
-      internal.as(fx, value).traced(trace),
+      internal.as(fx, value).addTrace(trace),
 )
 
 export const mergeAll: <FXS extends ReadonlyArray<Fx<any, any, any>>>(
@@ -534,22 +534,22 @@ export const mergeAll: <FXS extends ReadonlyArray<Fx<any, any, any>>>(
 > = methodWithTrace(
   (trace) =>
     (...fxs) =>
-      internal.mergeAll(...fxs).traced(trace),
+      internal.mergeAll(...fxs).addTrace(trace),
 )
 
 export const merge: {
   <R2, E2, B>(other: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
   <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
-} = dualWithTrace(2, (trace) => (fx, other) => internal.merge(fx, other).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, other) => internal.merge(fx, other).addTrace(trace))
 
 export const multicast: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = methodWithTrace(
   (trace) =>
     <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> =>
-      internal.multicast(fx).traced(trace),
+      internal.multicast(fx).addTrace(trace),
 )
 
 export const never: <E = never, A = never>(_: void) => Fx<never, E, A> = methodWithTrace(
-  (trace) => () => internal.never().traced(trace),
+  (trace) => () => internal.never().addTrace(trace),
 )
 
 export const observe: {
@@ -576,75 +576,78 @@ export const onInterrupt: {
     fx: Fx<R, E, A>,
     f: (interruptors: HashSet<FiberId>) => Effect.Effect<R2, E2, B>,
   ): Fx<R | R2, E | E2, A>
-} = dualWithTrace(2, (trace) => (fx, f) => internal.onInterrupt(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.onInterrupt(fx, f).addTrace(trace))
 
 export const promise: <A>(f: () => Promise<A>) => Fx<never, never, A> = methodWithTrace(
-  (trace) => (f) => internal.promise(f).traced(trace),
+  (trace) => (f) => internal.promise(f).addTrace(trace),
 )
 
 export const promiseInterrupt: <A>(f: (signal: AbortSignal) => Promise<A>) => Fx<never, never, A> =
-  methodWithTrace((trace) => (f) => internal.promiseInterrupt(f).traced(trace))
+  methodWithTrace((trace) => (f) => internal.promiseInterrupt(f).addTrace(trace))
 
 export const tryPromise: <A>(f: () => Promise<A>) => Fx<never, unknown, A> = methodWithTrace(
-  (trace) => (f) => internal.tryPromise(f).traced(trace),
+  (trace) => (f) => internal.tryPromise(f).addTrace(trace),
 )
 
 export const tryPromiseInterrupt: <A>(
   f: (signal: AbortSignal) => Promise<A>,
 ) => Fx<never, unknown, A> = methodWithTrace(
-  (trace) => (f) => internal.tryPromiseInterrupt(f).traced(trace),
+  (trace) => (f) => internal.tryPromiseInterrupt(f).addTrace(trace),
 )
 
 export const tryCatchPromise: <A, E>(
   f: () => Promise<A>,
   g: (error: unknown) => E,
 ) => Fx<never, E, A> = methodWithTrace(
-  (trace) => (f, g) => internal.tryCatchPromise(f, g).traced(trace),
+  (trace) => (f, g) => internal.tryCatchPromise(f, g).addTrace(trace),
 )
 
 export const tryCatchPromiseInterrupt: <A, E>(
   f: (signal: AbortSignal) => Promise<A>,
   g: (error: unknown) => E,
 ) => Fx<never, E, A> = methodWithTrace(
-  (trace) => (f, g) => internal.tryCatchPromiseInterrupt(f, g).traced(trace),
+  (trace) => (f, g) => internal.tryCatchPromiseInterrupt(f, g).addTrace(trace),
 )
 
 export const promiseFx: <R, E, A>(f: () => Promise<Fx<R, E, A>>) => Fx<R, E, A> = methodWithTrace(
-  (trace) => (f) => internal.promiseFx(f).traced(trace),
+  (trace) => (f) => internal.promiseFx(f).addTrace(trace),
 )
 
 export const promiseInterrupFx: <R, E, A>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-) => Fx<R, E, A> = methodWithTrace((trace) => (f) => internal.promiseInterruptFx(f).traced(trace))
+) => Fx<R, E, A> = methodWithTrace((trace) => (f) => internal.promiseInterruptFx(f).addTrace(trace))
 
 export const tryPromiseFx: <R, E, A>(f: () => Promise<Fx<R, E, A>>) => Fx<R, unknown, A> =
-  methodWithTrace((trace) => (f) => internal.tryPromiseFx(f).traced(trace))
+  methodWithTrace((trace) => (f) => internal.tryPromiseFx(f).addTrace(trace))
 
 export const tryPromiseInterruptFx: <R, E, A>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
 ) => Fx<R, unknown, A> = methodWithTrace(
-  (trace) => (f) => internal.tryPromiseInterruptFx(f).traced(trace),
+  (trace) => (f) => internal.tryPromiseInterruptFx(f).addTrace(trace),
 )
 
 export const tryCatchPromiseFx: <R, E, A, E2>(
   f: () => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
 ) => Fx<R, E | E2, A> = methodWithTrace(
-  (trace) => (f, g) => internal.tryCatchPromiseFx(f, g).traced(trace),
+  (trace) => (f, g) => internal.tryCatchPromiseFx(f, g).addTrace(trace),
 )
 
 export const tryCatchPromiseInterruptFx: <R, E, A, E2>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
 ) => Fx<R, E | E2, A> = methodWithTrace(
-  (trace) => (f, g) => internal.tryCatchPromiseInterruptFx(f, g).traced(trace),
+  (trace) => (f, g) => internal.tryCatchPromiseInterruptFx(f, g).addTrace(trace),
 )
 
 export const provideContext: {
   <R>(context: Context.Context<R>): <E, A>(fx: Fx<R, E, A>) => Fx<never, E, A>
 
   <R, E, A>(fx: Fx<R, E, A>, context: Context.Context<R>): Fx<never, E, A>
-} = dualWithTrace(2, (trace) => (fx, context) => internal.provideContext(fx, context).traced(trace))
+} = dualWithTrace(
+  2,
+  (trace) => (fx, context) => internal.provideContext(fx, context).addTrace(trace),
+)
 
 export const provideSomeContext: {
   <S>(context: Context.Context<S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, S>, E, A>
@@ -652,14 +655,14 @@ export const provideSomeContext: {
   <R, E, A, S>(fx: Fx<R, E, A>, context: Context.Context<S>): Fx<Exclude<R, S>, E, A>
 } = dualWithTrace(
   2,
-  (trace) => (fx, context) => internal.provideSomeContext(fx, context).traced(trace),
+  (trace) => (fx, context) => internal.provideSomeContext(fx, context).addTrace(trace),
 )
 
 export const provideLayer: {
   <R2, E2, R>(layer: Layer.Layer<R2, E2, R>): <E, A>(fx: Fx<R, E, A>) => Fx<R2, E | E2, A>
 
   <R, E, A, R2, E2>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, R>): Fx<R2, E | E2, A>
-} = dualWithTrace(2, (trace) => (fx, layer) => internal.provideLayer(fx, layer).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, layer) => internal.provideLayer(fx, layer).addTrace(trace))
 
 export const provideSomeLayer: {
   <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(
@@ -671,7 +674,7 @@ export const provideSomeLayer: {
     E | E2,
     A
   >
-} = dualWithTrace(2, (trace) => (fx, layer) => internal.provideSomeLayer(fx, layer).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, layer) => internal.provideSomeLayer(fx, layer).addTrace(trace))
 
 export const provideService: {
   <I, S>(tag: Context.Tag<I, S>, service: S): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, I>, E, A>
@@ -679,7 +682,7 @@ export const provideService: {
   <R, E, A, I, S>(fx: Fx<R, E, A>, tag: Context.Tag<I, S>, service: S): Fx<Exclude<R, I>, E, A>
 } = dualWithTrace(
   3,
-  (trace) => (fx, tag, service) => internal.provideService(fx, tag, service).traced(trace),
+  (trace) => (fx, tag, service) => internal.provideService(fx, tag, service).addTrace(trace),
 )
 
 export const provideServiceEffect: {
@@ -694,7 +697,7 @@ export const provideServiceEffect: {
   ): Fx<Exclude<R, I> | R2, E | E2, A>
 } = dualWithTrace(
   3,
-  (trace) => (fx, tag, service) => internal.provideServiceEffect(fx, tag, service).traced(trace),
+  (trace) => (fx, tag, service) => internal.provideServiceEffect(fx, tag, service).addTrace(trace),
 )
 
 export const provideServiceFx: {
@@ -709,7 +712,7 @@ export const provideServiceFx: {
   >
 } = dualWithTrace(
   3,
-  (trace) => (fx, tag, service) => internal.provideServiceFx(fx, tag, service).traced(trace),
+  (trace) => (fx, tag, service) => internal.provideServiceFx(fx, tag, service).addTrace(trace),
 )
 
 export const reduce: {
@@ -721,48 +724,87 @@ export const reduce: {
 export const scan: {
   <B, A>(seed: B, f: (b: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
   <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B>
-} = dualWithTrace(3, (trace) => (fx, seed, f) => internal.scan(fx, seed, f).traced(trace))
+} = dualWithTrace(3, (trace) => (fx, seed, f) => internal.scan(fx, seed, f).addTrace(trace))
 
 export const skipRepeatsWith: {
   <A>(eq: Equivalence<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, eq) => internal.skipRepeatsWith(fx, eq).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, eq) => internal.skipRepeatsWith(fx, eq).addTrace(trace))
 
 export const skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = methodWithTrace(
-  (trace) => (fx) => internal.skipRepeats(fx).traced(trace),
+  (trace) => (fx) => internal.skipRepeats(fx).addTrace(trace),
 )
 
 export const skipWhile: {
   <A>(predicate: Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, predicate) => internal.skipWhile(fx, predicate).traced(trace))
+} = dualWithTrace(
+  2,
+  (trace) => (fx, predicate) => internal.skipWhile(fx, predicate).addTrace(trace),
+)
 
 export const skipUntil: {
   <A>(predicate: Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, predicate) => internal.skipUntil(fx, predicate).traced(trace))
+} = dualWithTrace(
+  2,
+  (trace) => (fx, predicate) => internal.skipUntil(fx, predicate).addTrace(trace),
+)
 
 export const slice: {
   (skip: number, take: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A>
-} = dualWithTrace(3, (trace) => (fx, skip, take) => internal.slice(fx, skip, take).traced(trace))
+} = dualWithTrace(3, (trace) => (fx, skip, take) => internal.slice(fx, skip, take).addTrace(trace))
 
 export const skip: {
   (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, n) => internal.skip(fx, n).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, n) => internal.skip(fx, n).addTrace(trace))
 
 export const take: {
   (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, n) => internal.take(fx, n).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, n) => internal.take(fx, n).addTrace(trace))
+
+export const snapshotEffect: {
+  <R2, E2, B, R3, E3, A, C>(sampled: Fx<R2, E2, B>, f: (a: A, b: B) => Effect.Effect<R3, E3, C>): <
+    R,
+    E,
+  >(
+    fx: Fx<R, E, A>,
+  ) => Fx<R | R2 | R3, E | E2 | E3, C>
+
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    sampled: Fx<R2, E2, B>,
+    f: (a: A, b: B) => Effect.Effect<R3, E3, C>,
+  ): Fx<R | R2 | R3, E | E2 | E3, C>
+} = dualWithTrace(
+  3,
+  (trace) => (fx, sampled, f) => internal.snapshotEffect(fx, sampled, f).addTrace(trace),
+)
+
+export const snapshot: {
+  <R2, E2, B, A, C>(sampled: Fx<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(
+    fx: Fx<R, E, A>,
+  ) => Fx<R | R2, E | E2, C>
+
+  <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, sampled: Fx<R2, E2, B>, f: (a: A, b: B) => C): Fx<
+    R | R2,
+    E | E2,
+    C
+  >
+} = dualWithTrace(
+  3,
+  (trace) => (fx, sampled, f) => internal.snapshot(fx, sampled, f).addTrace(trace),
+)
 
 export const succeed: <A>(a: A) => Fx<never, never, A> = methodWithTrace(
-  (trace) => (a) => internal.succeed(a).traced(trace),
+  (trace) => (a) => internal.succeed(a).addTrace(trace),
 )
 
 export const suspend: <R, E, A>(fx: () => Fx<R, E, A>) => Fx<R, E, A> = methodWithTrace(
-  (trace) => (fx) => internal.suspend(fx).traced(trace),
+  (trace) => (fx) => internal.suspend(fx).addTrace(trace),
 )
 
 export const switchMap: {
@@ -772,7 +814,7 @@ export const switchMap: {
   2,
   (trace) =>
     <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>): Fx<R | R2, E | E2, B> =>
-      internal.switchMap(fx, f).traced(trace),
+      internal.switchMap(fx, f).addTrace(trace),
 )
 
 export const switchMapEffect: {
@@ -791,14 +833,14 @@ export const switchMapEffect: {
       fx: Fx<R, E, A>,
       f: (a: A) => Effect.Effect<R2, E2, B>,
     ): Fx<R | R2, E | E2, B> =>
-      internal.switchMapEffect(fx, f).traced(trace),
+      internal.switchMapEffect(fx, f).addTrace(trace),
 )
 
 export const switchLatest: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> =
   methodWithTrace(
     (trace) =>
       <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>): Fx<R | R2, E | E2, A> =>
-        internal.switchLatest<R, E, R2, E2, A>(fx).traced(trace),
+        internal.switchLatest<R, E, R2, E2, A>(fx).addTrace(trace),
   )
 
 export const switchLatestEffect: <R, E, R2, E2, A>(
@@ -806,7 +848,7 @@ export const switchLatestEffect: <R, E, R2, E2, A>(
 ) => Fx<R | R2, E | E2, A> = methodWithTrace(
   (trace) =>
     <R, E, R2, E2, A>(fx: Fx<R, E, Effect.Effect<R2, E2, A>>): Fx<R | R2, E | E2, A> =>
-      internal.switchLatestEffect(fx).traced(trace),
+      internal.switchLatestEffect(fx).addTrace(trace),
 )
 
 export const switchMatchCause: {
@@ -828,7 +870,7 @@ export const switchMatchCause: {
       f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
       g: (a: A) => Fx<R3, E3, C>,
     ): Fx<R | R2 | R3, E2 | E3, B | C> =>
-      internal.switchMatchCause(fx, f, g).traced(trace),
+      internal.switchMatchCause(fx, f, g).addTrace(trace),
 )
 
 export const switchMatchCauseEffect: {
@@ -850,7 +892,7 @@ export const switchMatchCauseEffect: {
       f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
       g: (a: A) => Effect.Effect<R3, E3, C>,
     ): Fx<R | R2 | R3, E2 | E3, B | C> =>
-      internal.switchMatchCauseEffect(fx, f, g).traced(trace),
+      internal.switchMatchCauseEffect(fx, f, g).addTrace(trace),
 )
 
 export const switchMatch: {
@@ -871,7 +913,7 @@ export const switchMatch: {
       f: (error: E) => Fx<R2, E2, B>,
       g: (a: A) => Fx<R3, E3, C>,
     ): Fx<R | R2 | R3, E2 | E3, B | C> =>
-      internal.switchMatch(fx, f, g).traced(trace),
+      internal.switchMatch(fx, f, g).addTrace(trace),
 )
 
 export const switchMatchEffect: {
@@ -885,7 +927,7 @@ export const switchMatchEffect: {
     f: (error: E) => Effect.Effect<R2, E2, B>,
     g: (a: A) => Effect.Effect<R3, E3, C>,
   ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dualWithTrace(3, (trace) => (fx, f, g) => internal.switchMatchEffect(fx, f, g).traced(trace))
+} = dualWithTrace(3, (trace) => (fx, f, g) => internal.switchMatchEffect(fx, f, g).addTrace(trace))
 
 export const switchMapCause: {
   <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>): <R, A>(
@@ -897,7 +939,7 @@ export const switchMapCause: {
     E2,
     B
   >
-} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapCause(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapCause(fx, f).addTrace(trace))
 
 export const switchMapCauseEffect: {
   <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): <R, A>(
@@ -909,13 +951,13 @@ export const switchMapCauseEffect: {
     E2,
     B
   >
-} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapCauseEffect(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapCauseEffect(fx, f).addTrace(trace))
 
 export const switchMapError: {
   <E, R2, E2, B>(f: (error: E) => Fx<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, B>
 
   <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => Fx<R2, E2, B>): Fx<R | R2, E2, B>
-} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapError(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapError(fx, f).addTrace(trace))
 
 export const switchMapErrorEffect: {
   <E, R2, E2, B>(f: (error: E) => Effect.Effect<R2, E2, B>): <R, A>(
@@ -927,17 +969,23 @@ export const switchMapErrorEffect: {
     E2,
     B
   >
-} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapErrorEffect(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.switchMapErrorEffect(fx, f).addTrace(trace))
 
 export const takeWhile: {
   <A>(predicate: Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, predicate) => internal.takeWhile(fx, predicate).traced(trace))
+} = dualWithTrace(
+  2,
+  (trace) => (fx, predicate) => internal.takeWhile(fx, predicate).addTrace(trace),
+)
 
 export const takeUntil: {
   <A>(predicate: Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, predicate) => internal.takeUntil(fx, predicate).traced(trace))
+} = dualWithTrace(
+  2,
+  (trace) => (fx, predicate) => internal.takeUntil(fx, predicate).addTrace(trace),
+)
 
 export const tap: {
   <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(
@@ -949,12 +997,12 @@ export const tap: {
     E | E2,
     A
   >
-} = dualWithTrace(2, (trace) => (fx, f) => internal.tap(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.tap(fx, f).addTrace(trace))
 
 export const tapSync: {
   <A, B>(f: (a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, f) => internal.tapSync(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.tapSync(fx, f).addTrace(trace))
 
 export const tapCause: {
   <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): <R, A>(
@@ -966,12 +1014,12 @@ export const tapCause: {
     E | E2,
     A
   >
-} = dualWithTrace(2, (trace) => (fx, f) => internal.tapCause(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.tapCause(fx, f).addTrace(trace))
 
 export const tapCauseSync: {
   <E, B>(f: (cause: Cause.Cause<E>) => B): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => B): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, f) => internal.tapCauseSync(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.tapCauseSync(fx, f).addTrace(trace))
 
 export const tapError: {
   <E, R2, E2, B>(f: (error: E) => Effect.Effect<R2, E2, B>): <R, A>(
@@ -983,17 +1031,17 @@ export const tapError: {
     E | E2,
     A
   >
-} = dualWithTrace(2, (trace) => (fx, f) => internal.tapError(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.tapError(fx, f).addTrace(trace))
 
 export const tapErrorSync: {
   <E, B>(f: (error: E) => B): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A, B>(fx: Fx<R, E, A>, f: (error: E) => B): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, f) => internal.tapErrorSync(fx, f).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, f) => internal.tapErrorSync(fx, f).addTrace(trace))
 
 export const throttle: {
   (delay: Duration): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, delay: Duration): Fx<R, E, A>
-} = dualWithTrace(2, (trace) => (fx, delay) => internal.throttle(fx, delay).traced(trace))
+} = dualWithTrace(2, (trace) => (fx, delay) => internal.throttle(fx, delay).addTrace(trace))
 
 export const toArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R | Scope.Scope, E, Array<A>> =
   methodWithTrace((trace) => (fx) => internal.toArray(fx).traced(trace))