@typed/fx 1.6.2 → 1.8.0

package/src/internal/operator/mapCause.ts

@@ -1,32 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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 { Context, Scope } from '@typed/fx/internal/externals'
-import { Effect, Exit } 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

@@ -1,63 +0,0 @@
-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 type { Context, Scope } from '@typed/fx/internal/externals'
-import { Cause, Effect } 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

@@ -1,53 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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),
-)