@typed/fx 1.5.8 → 1.6.0

package/src/internal/operator/mapCause.ts

@@ -0,0 +1,32 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Effect, Cause, Scope } from '@typed/fx/internal/_externals'
+
+export const mapCause: {
+  <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Fx<R, E, A>) => Fx<R, E2, A>
+  <R, E, A, E2>(self: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Fx<R, E2, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    function mapCause<R, E, A, E2>(
+      self: Fx<R, E, A>,
+      f: (cause: Cause.Cause<E>) => Cause.Cause<E2>,
+    ): Fx<R, E2, A> {
+      return new MapCauseFx(self, f).traced(trace)
+    },
+)
+
+export class MapCauseFx<R, E, A, E2> extends BaseFx<R, E2, A> {
+  readonly name = 'MapCause'
+
+  constructor(readonly self: Fx<R, E, A>, readonly f: (cause: Cause.Cause<E>) => Cause.Cause<E2>) {
+    super()
+  }
+
+  run(sink: Sink<E2, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
+    return this.self.run(Sink(sink.event, (cause) => sink.error(this.f(cause)), sink.end))
+  }
+}

package/src/internal/operator/mapEither.ts

@@ -0,0 +1,21 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Either } from '@typed/fx/internal/_externals'
+import { map } from '@typed/fx/internal/operator/map'
+
+export const mapEither: {
+  <A, B>(f: (a: A) => B): <R, E, E2>(
+    self: Fx<R, E, Either.Either<E2, A>>,
+  ) => Fx<R, E, Either.Either<E2, B>>
+  <R, E, E2, A, B>(self: Fx<R, E, Either.Either<E2, A>>, f: (a: A) => B): Fx<
+    R,
+    E,
+    Either.Either<E2, B>
+  >
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, E2, A, B>(self: Fx<R, E, Either.Either<E2, A>>, f: (a: A) => B) =>
+      map(self, Either.map(f)).traced(trace),
+)

package/src/internal/operator/mapError.ts

@@ -0,0 +1,15 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Cause } from '@typed/fx/internal/_externals'
+import { mapCause } from '@typed/fx/internal/operator/mapCause'
+
+export const mapError: {
+  <E, E2>(f: (e: E) => E2): <R, A>(self: Fx<R, E, A>) => Fx<R, E2, A>
+  <R, E, A, E2>(self: Fx<R, E, A>, f: (e: E) => E2): Fx<R, E2, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, E2>(self: Fx<R, E, A>, f: (e: E) => E2) =>
+      mapCause(self, Cause.map(f)).traced(trace),
+)

package/src/internal/operator/mapSome.ts

@@ -0,0 +1,15 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Option } from '@typed/fx/internal/_externals'
+import { map } from '@typed/fx/internal/operator/map'
+
+export const mapSome: {
+  <A, B>(f: (a: A) => B): <R, E>(self: Fx<R, E, Option.Option<A>>) => Fx<R, E, Option.Option<B>>
+  <R, E, A, B>(self: Fx<R, E, Option.Option<A>>, f: (a: A) => B): Fx<R, E, Option.Option<B>>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, B>(self: Fx<R, E, Option.Option<A>>, f: (a: A) => B) =>
+      map(self, Option.map(f)).traced(trace),
+)

package/src/internal/operator/merge.ts

@@ -0,0 +1,68 @@
+import { dualWithTrace, methodWithTrace } from '@effect/data/Debug'
+import { pipe } from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Sink } from '@typed/fx/internal/Fx'
+import { withRefCounter } from '@typed/fx/internal/RefCounter'
+import { Scope } from '@typed/fx/internal/_externals'
+
+export const mergeAll: <const Streams extends ReadonlyArray<Fx<any, any, any>>>(
+  ...streams: Streams
+) => Fx<
+  Fx.ResourcesOf<Streams[number]>,
+  Fx.ErrorsOf<Streams[number]>,
+  Fx.OutputOf<Streams[number]>
+> = methodWithTrace(
+  (trace) =>
+    <Streams extends ReadonlyArray<Fx<any, any, any>>>(...streams: Streams) =>
+      new MergeAllFx(streams).traced(trace),
+)
+
+export const merge: {
+  <R, E, A, R2, E2, B>(first: Fx<R, E, A>, second: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
+  <R2, E2, B>(second: Fx<R2, E2, B>): <R, E, A>(first: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(first: Fx<R, E, A>, second: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B> =>
+      mergeAll(first, second).traced(trace),
+)
+
+export class MergeAllFx<Streams extends ReadonlyArray<Fx<any, any, any>>> extends BaseFx<
+  Fx.ResourcesOf<Streams[number]>,
+  Fx.ErrorsOf<Streams[number]>,
+  Fx.OutputOf<Streams[number]>
+> {
+  readonly name = 'MergeAll' as const
+
+  constructor(readonly streams: Streams) {
+    super()
+  }
+
+  run(
+    sink: Sink<Fx.ErrorsOf<Streams[number]>, Fx.OutputOf<Streams[number]>>,
+  ): Effect.Effect<Fx.ResourcesOf<Streams[number]> | Scope.Scope, never, unknown> {
+    return withRefCounter(
+      this.streams.length,
+      (counter, scope) => {
+        const end = Effect.provideService(counter.decrement, Scope.Scope, scope)
+
+        return pipe(
+          this.streams,
+          Effect.forEachParDiscard((s) =>
+            s.run(
+              Sink(
+                sink.event,
+                (cause) => Effect.zipLeft(sink.error(cause), end),
+                () => end,
+              ),
+            ),
+          ),
+        )
+      },
+      sink.end,
+    )
+  }
+}

package/src/internal/operator/mergeRace.ts

@@ -0,0 +1,52 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import { pipe } from '@effect/data/Function'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Sink } from '@typed/fx/internal/Fx'
+import { Cause, Effect, Fiber, Scope } from '@typed/fx/internal/_externals'
+import { tap } from '@typed/fx/internal/operator/tap'
+
+export const mergeRace: {
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, raced: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
+  <R2, E2, B>(raced: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, raced: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B> =>
+      new MergeRaceFx(fx, raced).traced(trace),
+)
+
+export class MergeRaceFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A | B> {
+  readonly name = 'MergeRace' as const
+
+  constructor(readonly fx: Fx<R, E, A>, readonly raced: Fx<R2, E2, B>) {
+    super()
+  }
+
+  run(sink: Sink<E | E2, A | B>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
+    const { fx, raced } = this
+
+    return Effect.gen(function* ($) {
+      let interrupted = false
+      const racedFiber = yield* $(
+        pipe(
+          raced.run(
+            Sink(
+              sink.event,
+              (cause) => (Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause)),
+              Effect.unit,
+            ),
+          ),
+          Effect.forkScoped,
+        ),
+      )
+
+      return yield* $(
+        tap(fx, () =>
+          interrupted ? Effect.unit() : ((interrupted = true), Fiber.interruptFork(racedFiber)),
+        ).run(sink),
+      )
+    })
+  }
+}

package/src/internal/operator/multicast.ts

@@ -0,0 +1,133 @@
+import { methodWithTrace } from '@effect/data/Debug'
+import { pipe } from '@effect/data/Function'
+import type { Cause } from '@effect/io/Cause'
+import * as Deferred from '@effect/io/Deferred'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import type { RuntimeFiber } from '@effect/io/Fiber'
+import type { Scope } from '@effect/io/Scope'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx, Sink } from '@typed/fx/internal/Fx'
+import { asap } from '@typed/fx/internal/RefCounter'
+
+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> =>
+      new MulticastFx(fx, 'Multicast', false).traced(trace),
+)
+
+export class MulticastFx<R, E, A, Name extends string>
+  extends BaseFx<R, E, A>
+  implements Sink<E, A>
+{
+  readonly observers: Array<MulticastObserver<E, A>> = []
+  protected fiber: RuntimeFiber<never, unknown> | undefined
+  protected start: Effect.Effect<R | Scope, never, Fiber.RuntimeFiber<never, unknown>>
+
+  constructor(readonly fx: Fx<R, E, A>, readonly name: Name, readonly sync: boolean) {
+    super()
+    this.event = this.event.bind(this)
+    this.error = this.error.bind(this)
+    this.end = this.end.bind(this)
+
+    this.start = sync ? Effect.forkScoped(fx.run(this)) : Effect.scheduleForked(fx.run(this), asap)
+  }
+
+  run(sink: Sink<E, A>): Effect.Effect<R | Scope, never, void> {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const { observers, start } = this
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+
+    return Effect.gen(function* ($) {
+      const deferred = yield* $(Deferred.make<never, void>())
+      const observer: MulticastObserver<E, A> = {
+        sink,
+        deferred,
+      }
+
+      const total = observers.push(observer)
+
+      if (total === 1) {
+        that.fiber = yield* $(start)
+      }
+
+      yield* $(Deferred.await(deferred))
+
+      if (observers.length === 0) {
+        yield* $(that.cleanup())
+      }
+    })
+  }
+
+  event(a: A) {
+    return Effect.suspend(() =>
+      Effect.forEachParDiscard(this.observers.slice(0), (observer) => this.runEvent(a, observer)),
+    )
+  }
+
+  error(cause: Cause<E>) {
+    return Effect.suspend(() =>
+      pipe(
+        Effect.forEachParDiscard(this.observers.slice(0), (observer) =>
+          this.runError(cause, observer),
+        ),
+        Effect.tap(() => this.cleanup()),
+      ),
+    )
+  }
+
+  end() {
+    return Effect.suspend(() =>
+      pipe(
+        Effect.forEachParDiscard(this.observers.slice(0), (observer) => this.runEnd(observer)),
+        Effect.tap(() => this.cleanup()),
+      ),
+    )
+  }
+
+  protected runEvent(a: A, observer: MulticastObserver<E, A>) {
+    return observer.sink.event(a)
+  }
+
+  protected runError(cause: Cause<E>, observer: MulticastObserver<E, A>) {
+    return pipe(
+      observer.sink.error(cause),
+      Effect.tap(() => Effect.sync(() => this.removeObserver(observer))),
+      Effect.intoDeferred(observer.deferred),
+    )
+  }
+
+  protected runEnd(observer: MulticastObserver<E, A>) {
+    return pipe(
+      observer.sink.end(),
+      Effect.tap(() => Effect.sync(() => this.removeObserver(observer))),
+      Effect.intoDeferred(observer.deferred),
+    )
+  }
+
+  protected removeObserver(observer: MulticastObserver<E, A>) {
+    const { observers } = this
+    const index = observers.indexOf(observer)
+
+    if (index > -1) {
+      observers.splice(index, 1)
+    }
+  }
+
+  protected cleanup() {
+    return this.fiber
+      ? pipe(
+          Fiber.interrupt(this.fiber),
+          Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
+        )
+      : Effect.unit()
+  }
+}
+
+export interface MulticastObserver<E, A> {
+  readonly sink: Sink<E, A>
+  readonly deferred: Deferred.Deferred<never, unknown>
+}

package/src/internal/operator/onDone.ts

@@ -0,0 +1,32 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Cause, Effect, Either, pipe } from '@typed/fx/internal/_externals'
+import { onDoneCause } from '@typed/fx/internal/operator/onDoneCause'
+
+export const onDone: {
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    self: Fx<R, E, A>,
+    onFailure: (error: E) => Effect.Effect<R2, E2, B>,
+    onSuccess: (value: unknown) => Effect.Effect<R3, E3, C>,
+  ): Fx<R | R2 | R3, E | E2 | E3, A>
+
+  <E, R2, E2, B, R3, E3, C>(
+    onFailure: (error: E) => Effect.Effect<R2, E2, B>,
+    onSuccess: (value: unknown) => Effect.Effect<R3, E3, C>,
+  ): <R, A>(self: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, A>
+} = dualWithTrace(
+  3,
+  (trace) =>
+    <R, E, A, R2, E2, B, R3, E3, C>(
+      self: Fx<R, E, A>,
+      onFailure: (error: E) => Effect.Effect<R2, E2, B>,
+      onSuccess: (value: unknown) => Effect.Effect<R3, E3, C>,
+    ) =>
+      onDoneCause(
+        self,
+        (cause): Effect.Effect<R2, E2, B> =>
+          pipe(cause, Cause.failureOrCause, Either.match(onFailure, Effect.failCause)),
+        onSuccess,
+      ).traced(trace),
+)

package/src/internal/operator/onDoneCause.ts

@@ -0,0 +1,53 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import { pipe } from '@effect/data/Function'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx, Sink } from '@typed/fx/internal/Fx'
+import type { Cause, Scope } from '@typed/fx/internal/_externals'
+import { Effect } from '@typed/fx/internal/_externals'
+
+export const onDoneCause: {
+  <R, E, A, R2, E2, B, R3, E3, C>(
+    self: Fx<R, E, A>,
+    onFailure: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    onSuccess: (value: unknown) => Effect.Effect<R3, E3, C>,
+  ): Fx<R | R2 | R3, E | E2 | E3, A>
+
+  <E, R2, E2, B, R3, E3, C>(
+    onFailure: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    onSuccess: (value: unknown) => Effect.Effect<R3, E3, C>,
+  ): <R, A>(self: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, A>
+} = dualWithTrace(
+  3,
+  (trace) => (self, onFailure, onSuccess) =>
+    new OnDoneCause(self, onFailure, onSuccess).traced(trace),
+)
+
+export class OnDoneCause<R, E, A, R2, E2, B, R3, E3, C> extends BaseFx<
+  R | R2 | R3,
+  E | E2 | E3,
+  A
+> {
+  readonly name = 'OnDoneCause' as const
+
+  constructor(
+    readonly self: Fx<R, E, A>,
+    readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    readonly onSuccess: (value: unknown) => Effect.Effect<R3, E3, C>,
+  ) {
+    super()
+  }
+
+  run(sink: Sink<E | E2 | E3, A>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+    const { onFailure, onSuccess, self } = this
+
+    return pipe(
+      self.observe(() => Effect.unit()),
+      Effect.matchCauseEffect(
+        (cause) => Effect.flatMap(onFailure(cause), () => sink.error(cause)),
+        (value) => Effect.flatMap(onSuccess(value), sink.end),
+      ),
+      Effect.catchAllCause(sink.error),
+    )
+  }
+}

package/src/internal/operator/onError.ts

@@ -0,0 +1,25 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Effect } from '@typed/fx/internal/_externals'
+import { onDone } from '@typed/fx/internal/operator/onDone'
+
+export const onError: {
+  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, onFailure: (error: E) => Effect.Effect<R2, E2, B>): Fx<
+    R | R2,
+    E | E2,
+    A
+  >
+
+  <E, R2, E2, B>(onFailure: (error: E) => Effect.Effect<R2, E2, B>): <R, A>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R2, E | E2, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(
+      self: Fx<R, E, A>,
+      onFailure: (error: E) => Effect.Effect<R2, E2, B>,
+    ): Fx<R | R2, E | E2, A> =>
+      onDone(self, onFailure, () => Effect.unit()).traced(trace),
+)

package/src/internal/operator/onErrorCause.ts

@@ -0,0 +1,25 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Effect } from '@typed/fx/internal/_externals'
+import type { Cause } from '@typed/fx/internal/_externals'
+import { onDoneCause } from '@typed/fx/internal/operator/onDoneCause'
+
+export const onErrorCause: {
+  <R, E, A, R2, E2, B>(
+    self: Fx<R, E, A>,
+    onFailure: (error: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+  ): Fx<R | R2, E | E2, A>
+
+  <E, R2, E2, B>(onFailure: (error: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): <R, A>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R2, E | E2, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(
+      self: Fx<R, E, A>,
+      onFailure: (error: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    ): Fx<R | R2, E | E2, A> =>
+      onDoneCause(self, onFailure, () => Effect.unit()).traced(trace),
+)

package/src/internal/operator/onExit.ts

@@ -0,0 +1,56 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Sink } from '@typed/fx/internal/Fx'
+import { Effect, Exit } from '@typed/fx/internal/_externals'
+import type { Context, Scope } from '@typed/fx/internal/_externals'
+
+export const onExit: {
+  <R, E, A, R2, B>(
+    self: Fx<R, E, A>,
+    f: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, B>,
+  ): Fx<R | R2, E, A>
+  <E, R2, B>(f: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, B>): <R, A>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R2, E, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, B>(
+      self: Fx<R, E, A>,
+      f: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, B>,
+    ) =>
+      new OnExitFx(self, f).traced(trace),
+)
+
+export class OnExitFx<R, E, A, R2, B> extends BaseFx<R | R2, E, A> {
+  readonly name = 'OnExit'
+
+  constructor(
+    readonly self: Fx<R, E, A>,
+    readonly f: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, B>,
+  ) {
+    super()
+  }
+
+  run(sink: Sink<E, A>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
+    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope.Scope>) =>
+      this.self.run(
+        Sink(
+          sink.event,
+          (cause) =>
+            Effect.provideContext(
+              Effect.flatMap(this.f(Exit.failCause(cause)), () => sink.error(cause)),
+              ctx,
+            ),
+          () =>
+            Effect.provideContext(
+              Effect.flatMap(this.f(Exit.unit()), () => sink.end()),
+              ctx,
+            ),
+        ),
+      ),
+    )
+  }
+}

package/src/internal/operator/onInterrupt.ts

@@ -0,0 +1,63 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import * as HashSet from '@effect/data/HashSet'
+import type * as FiberId from '@effect/io/Fiber/Id'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Sink } from '@typed/fx/internal/Fx'
+import { Cause, Effect } from '@typed/fx/internal/_externals'
+import type { Context, Scope } from '@typed/fx/internal/_externals'
+
+export const onInterrupt: {
+  <R, E, A, R2, B>(
+    self: Fx<R, E, A>,
+    f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, B>,
+  ): Fx<R | R2, E, A>
+
+  <R2, B>(f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, B>): <
+    R,
+    E,
+    A,
+  >(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R2, E, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, B>(
+      self: Fx<R, E, A>,
+      f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, B>,
+    ) =>
+      new OnInterruptCauseFx(self, f).traced(trace),
+)
+
+export class OnInterruptCauseFx<R, E, A, R2, B> extends BaseFx<R | R2, E, A> {
+  readonly name = 'OnInterrupt'
+
+  constructor(
+    readonly self: Fx<R, E, A>,
+    readonly f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, B>,
+  ) {
+    super()
+  }
+
+  run(sink: Sink<E, A>) {
+    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope.Scope>) =>
+      this.self.run(
+        Sink(
+          sink.event,
+          (cause) => {
+            const interruptors = Cause.interruptors(cause)
+
+            if (HashSet.size(interruptors) === 0) {
+              return Effect.flatMap(Effect.provideContext(this.f(interruptors), ctx), sink.end)
+            } else {
+              return sink.error(cause)
+            }
+          },
+          sink.end,
+        ),
+      ),
+    )
+  }
+}

package/src/internal/operator/onNonInterruptCause.ts

@@ -0,0 +1,53 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Context, Scope } from '@typed/fx/internal/_externals'
+
+export const onNonInterruptCause: {
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): Fx<
+    R | R2,
+    E | E2,
+    A
+  >
+  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): <R, A>(
+    fx: Fx<R, E, A>,
+  ) => Fx<R | R2, E | E2, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(
+      fx: Fx<R, E, A>,
+      f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    ): Fx<R | R2, E | E2, A> =>
+      new OnNonInterruptCauseFx(fx, f).traced(trace),
+)
+
+export class OnNonInterruptCauseFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A> {
+  readonly name = 'OnNonInterruptCause' as const
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+  ) {
+    super()
+  }
+
+  run(sink: Sink<E | E2, A>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
+    return Effect.contextWithEffect((ctx: Context.Context<R2>) =>
+      this.fx.run(
+        Sink(
+          sink.event,
+          (cause) =>
+            Cause.isInterruptedOnly(cause)
+              ? sink.end()
+              : Effect.provideContext(Effect.catchAllCause(this.f(cause), sink.error), ctx),
+          sink.end,
+        ),
+      ),
+    )
+  }
+}

package/src/internal/operator/option.ts

@@ -0,0 +1,11 @@
+import { methodWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Option } from '@typed/fx/internal/_externals'
+import { map } from '@typed/fx/internal/operator/map'
+
+export const option: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, Option.Option<A>> = methodWithTrace(
+  (trace) =>
+    <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, Option.Option<A>> =>
+      map(fx, Option.some).traced(trace),
+)