@typed/fx 0.0.6 → 0.0.8

package/src/Stream/flatMap.ts

@@ -1,21 +1,18 @@
 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 { MapStream } from './bimap.js'
 
 import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
 import { Cause } from '@/Cause/index.js'
 import { Env } from '@/Env/Env.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 * as Sink from '@/Sink/Sink.js'
-import { None, and } from '@/Supervisor/Supervisor.js'
+import * as Supervisor from '@/Supervisor/index.js'
 
 export function flatMap<A, R2, E2, B>(
   f: (a: A) => Stream<R2, E2, B>,
@@ -66,16 +63,6 @@ export class FlatMapStream<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2,
 class FlatMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3> {
   protected _running = AtomicCounter()
   protected _ended = false
-  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>,
@@ -89,7 +76,7 @@ class FlatMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3> {
   event = (a: A) =>
     Fx.lazy(() => {
       const forked = this.context.fork({
-        supervisor: and(this.supervisor)(this.context.supervisor),
+        supervisor: Supervisor.and(Supervisor.inheritFiberRefs)(this.context.supervisor),
       })
 
       increment(this._running)

package/src/Stream/flatMapConcurrently.ts

@@ -28,3 +28,7 @@ export function mergeConcurrently(concurrencyLevel: NonNegativeInteger, __trace?
       flatMapConcurrently((a) => a, concurrencyLevel, __trace),
     )
 }
+
+export function concatMap<A, R2, E2, B>(f: (a: A) => Stream<R2, E2, B>, __trace?: string) {
+  return flow(flatMapConcurrently(f, NonNegativeInteger(1), __trace))
+}

package/src/Stream/foldMap.ts

@@ -0,0 +1,88 @@
+import { Maybe, flow, pipe } from 'hkt-ts'
+import * as Endo from 'hkt-ts/Endomorphism'
+import { Identity } from 'hkt-ts/Typeclass/Identity'
+import * as B from 'hkt-ts/boolean'
+
+import { Stream } from './Stream.js'
+import { FilterMapStream, MapStream } from './bimap.js'
+import { observe } from './drain.js'
+import { FromFxStream } from './fromFx.js'
+
+import * as Fx from '@/Fx/index.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+
+export const filterFoldMap = <A>(I: Identity<A>) => {
+  const foldMap_ =
+    <B>(f: (b: B) => Maybe.Maybe<A>, __trace?: string) =>
+    <R, E>(stream: Stream<R, E, B>): Fx.Fx<R | Scheduler, E, A> => {
+      if (stream instanceof FromFxStream) {
+        return pipe(
+          stream.fx,
+          Fx.map(
+            flow(
+              f,
+              Maybe.match(
+                () => I.id,
+                (a) => I.concat(I.id, a),
+              ),
+            ),
+          ),
+        )
+      }
+
+      if (stream instanceof MapStream) {
+        return foldMap_(flow(stream.f, f), __trace)(stream.stream)
+      }
+
+      if (stream instanceof FilterMapStream) {
+        return foldMap_(flow(stream.f, Maybe.flatMap(f)), __trace)(stream.stream)
+      }
+
+      return filterFoldMapStream(I, f, stream, __trace)
+    }
+
+  return foldMap_
+}
+
+export const foldMap =
+  <A>(I: Identity<A>) =>
+  <B>(f: (b: B) => A) =>
+    filterFoldMap(I)(flow(f, Maybe.Just))
+
+const filterFoldMapStream = <A, B, R, E>(
+  I: Identity<A>,
+  f: (b: B) => Maybe.Maybe<A>,
+  stream: Stream<R, E, B>,
+  __trace?: string,
+) =>
+  Fx.lazy(() => {
+    let acc = I.id
+
+    return pipe(
+      stream,
+      observe((b) =>
+        Fx.fromLazy(() => {
+          const maybe = f(b)
+
+          if (Maybe.isJust(maybe)) {
+            acc = I.concat(acc, maybe.value)
+          }
+        }),
+      ),
+      Fx.flatMap(Fx.join),
+      Fx.map(() => acc, __trace),
+    )
+  })
+
+export const reduce = <A, B>(
+  f: (a: A, b: B) => A,
+  seed: A,
+): (<R, E>(stream: Stream<R, E, B>) => Fx.Fx<Scheduler | R, E, A>) => {
+  return flow(
+    foldMap(Endo.makeIdentity<A>())((a: B) => (b: A) => f(b, a)),
+    Fx.flap(seed),
+  )
+}
+
+export const every = foldMap(B.All)
+export const some = foldMap(B.Any)

package/src/Stream/fromArray.ts

@@ -0,0 +1,8 @@
+import { fromCallback } from './fromCallback.js'
+
+export function fromArray<A>(array: ReadonlyArray<A>) {
+  return fromCallback<never, A>(async ({ event, end }) => {
+    await Promise.all(array.map(event))
+    await end()
+  })
+}

package/src/Stream/fromFx.ts

@@ -6,34 +6,43 @@ import { Stream } from './Stream.js'
 import { Cause } from '@/Cause/Cause.js'
 import { Env } from '@/Env/Env.js'
 import * as Exit from '@/Exit/Exit.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { FiberId } from '@/FiberId/index.js'
 import * as Fx from '@/Fx/Fx.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
 
 /**
  * Constructs a Stream from an Fx that runs within a LogSpan enabling
  */
 export function fromFx<R, E, A>(fx: Fx.Fx<R, E, A>, __trace?: string): Stream<R, E, A> {
-  return Stream((sink, scheduler, context) =>
-    Fx.asksEnv(
+  return new FromFxStream(fx, __trace)
+}
+
+export class FromFxStream<R, E, A> implements Stream<R, E, A> {
+  constructor(readonly fx: Fx.Fx<R, E, A>, readonly __trace?: string) {}
+
+  fork<E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) {
+    return Fx.asksEnv(
       (env: Env<R>) =>
         scheduler.asap(
           pipe(
-            fx,
+            this.fx,
             Fx.matchCause(
               sink.error,
               flow(
                 sink.event,
                 Fx.flatMap(() => sink.end),
               ),
-              __trace,
+              this.__trace,
             ),
           ),
           env,
           context,
         ),
-      __trace,
-    ),
-  )
+      this.__trace,
+    )
+  }
 }
 
 export const now = <A>(value: A, __trace?: string) => fromFx(Fx.now(value), __trace)

package/src/Stream/hkt.ts

@@ -1,18 +1,24 @@
 import { HKT3, Params } from 'hkt-ts'
+import * as AB from 'hkt-ts/Typeclass/AssociativeBoth'
+import * as AF from 'hkt-ts/Typeclass/AssociativeFlatten'
 import * as B from 'hkt-ts/Typeclass/Bicovariant'
+import { Bottom3 } from 'hkt-ts/Typeclass/Bottom'
 import * as C from 'hkt-ts/Typeclass/Covariant'
+import * as FM from 'hkt-ts/Typeclass/FilterMap'
+import * as IB from 'hkt-ts/Typeclass/IdentityBoth'
+import { IdentityFlatten3 } from 'hkt-ts/Typeclass/IdentityFlatten'
+import * as T from 'hkt-ts/Typeclass/Top'
+import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { Stream } from './Stream.js'
-import { bimap } from './bimap.js'
-import { map } from './map.js'
+import { bimap, filterMap, map } from './bimap.js'
+import { join } from './flatMap.js'
+import { mergeConcurrently } from './flatMapConcurrently.js'
+import { fromFx } from './fromFx.js'
+
+import * as Fx from '@/Fx/index.js'
 
-// TODO: AssociativeBoth
 // TOOD: AssociativeEither
-// TODO: Top
-// TODO: Bottom
-// TODO: FilterMap
-// TODO: AssociativeFlatten
-// TODO: IdentityBoth
 // TODO: IdentityEither
 // TODO: IdentityFlatten
 
@@ -24,8 +30,6 @@ export const Bicovariant: B.Bicovariant3<StreamHKT> = {
   bimap,
 }
 
-export const mapLeft = B.mapLeft(Bicovariant)
-
 export const Covariant: C.Covariant3<StreamHKT> = {
   map,
 }
@@ -34,3 +38,48 @@ export const bindTo = C.bindTo(Covariant)
 export const flap = C.flap(Covariant)
 export const mapTo = C.mapTo(Covariant)
 export const tupled = C.tupled(Covariant)
+
+export const Top: T.Top3<StreamHKT> = {
+  top: fromFx(Fx.top),
+}
+
+export const Bottom: Bottom3<StreamHKT> = {
+  bottom: fromFx(Fx.bottom),
+}
+
+export const Flatten: AF.AssociativeFlatten3<StreamHKT> = {
+  flatten: join,
+}
+
+export const IdentityFlatten: IdentityFlatten3<StreamHKT> = {
+  ...Flatten,
+  ...Top,
+}
+
+export const makeFlattenConcurrently = (
+  concurrencyLevel: NonNegativeInteger,
+): AF.AssociativeFlatten3<StreamHKT> => ({
+  flatten: mergeConcurrently(concurrencyLevel),
+})
+
+export const AssociativeBoth = AF.makeAssociativeBoth<StreamHKT>({
+  ...Flatten,
+  ...Covariant,
+})
+
+export const zipLeftSeq = AB.zipLeft<StreamHKT>({ ...AssociativeBoth, ...Covariant })
+export const zipRightSeq = AB.zipRight<StreamHKT>({ ...AssociativeBoth, ...Covariant })
+
+export const IdentityBoth: IB.IdentityBoth3<StreamHKT> = {
+  ...AssociativeBoth,
+  ...Top,
+}
+
+export const structSeq = IB.struct<StreamHKT>({ ...IdentityBoth, ...Covariant })
+
+export const FilterMap: FM.FilterMap3<StreamHKT> = {
+  filterMap,
+}
+
+export const compact = FM.compact(FilterMap)
+export const filter = FM.filter(FilterMap)

package/src/Stream/hold.ts

@@ -5,10 +5,10 @@ import { Stream } from './Stream.js'
 import { MulticastStream } from './multicast.js'
 
 import { Cause } from '@/Cause/index.js'
+import { fromFiberRefs } from '@/Env/Env.js'
 import { Fiber } from '@/Fiber/Fiber.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { FiberId } from '@/FiberId/FiberId.js'
-import { getServiceFromFiberRefs } from '@/FiberRef/builtins.js'
 import * as Fx from '@/Fx/index.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
 import { Sink } from '@/Sink/Sink.js'
@@ -100,7 +100,7 @@ export class HoldStream<R, E, A> extends MulticastStream<R, E, A> implements Str
 
     this.scheduledFiber = scheduler.asap(
       this.flushPending(),
-      { get: getServiceFromFiberRefs(context.fiberRefs.fork()) },
+      fromFiberRefs(context.fiberRefs),
       context.fork(),
     )
 

package/src/Stream/index.ts

@@ -1,21 +1,26 @@
 export * from './acquirePermit.js'
 export * from './bimap.js'
 export * from './continueWith.js'
+export * from './delay.js'
 export * from './drain.js'
 export * from './empty.js'
 export * from './flatMap.js'
 export * from './flatMapConcurrently.js'
 export * from './flatMapFx.js'
+export * from './foldMap.js'
+export * from './fromArray.js'
 export * from './fromCallback.js'
 export * from './fromFx.js'
 export * from './hkt.js'
 export * from './hold.js'
 export * from './lazy.js'
-export * from './map.js'
 export * from './merge.js'
 export * from './multicast.js'
 export * from './periodic.js'
+export * from './provide.js'
+export * from './run.js'
 export * from './setFiberRefLocally.js'
+export * from './skipRepeats.js'
 export * from './scan.js'
 export * from './scheduled.js'
 export * from './Stream.js'

package/src/Stream/orElse.ts

@@ -1,6 +1,4 @@
 import { pipe } from 'hkt-ts'
-import { isRight } from 'hkt-ts/Either'
-import { isJust } from 'hkt-ts/Maybe'
 
 import { Stream } from './Stream.js'
 
@@ -9,12 +7,11 @@ import { Cause } from '@/Cause/index.js'
 import { Env } from '@/Env/Env.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, provideService, unit } from '@/Fx/index.js'
+import { access, lazy, unit } from '@/Fx/index.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
 import * as Sink from '@/Sink/Sink.js'
-import { None, and } from '@/Supervisor/Supervisor.js'
+import * as Supervisor from '@/Supervisor/index.js'
 
 export function orElse<E, R2, E2, B>(
   f: (cause: Cause<E>) => Stream<R2, E2, B>,
@@ -34,13 +31,10 @@ export class OrElseStream<R, E, A, R2, E2, B> implements Stream<R | R2, E2, A |
     const { stream, f } = this
 
     return access((env: Env<R | R2>) =>
-      pipe(
-        stream.fork(
-          new OrElseSink(sink, scheduler, context, f, env, this.__trace),
-          scheduler,
-          context,
-        ),
-        provideService(Scheduler, scheduler),
+      stream.fork(
+        new OrElseSink(sink, scheduler, context, f, env, this.__trace),
+        scheduler,
+        context,
       ),
     )
   }
@@ -57,16 +51,6 @@ export class OrElseStream<R, E, A, R2, E2, B> implements Stream<R | R2, E2, A |
 class OrElseSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E, A, E3> {
   protected _running = AtomicCounter()
   protected _ended = false
-  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<E2, A | B, E3>,
@@ -82,7 +66,7 @@ class OrElseSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E, A, E3> {
   error = (cause: Cause<E>) => {
     return lazy(() => {
       const forked = this.context.fork({
-        supervisor: and(this.supervisor)(this.context.supervisor),
+        supervisor: Supervisor.and(Supervisor.inheritFiberRefs)(this.context.supervisor),
       })
 
       increment(this._running)

package/src/Stream/provide.test.ts

@@ -0,0 +1,78 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collectAll } from './_internal.test.js'
+
+import * as Stream from './index.js'
+
+import { Env } from '@/Env/Env.js'
+import * as Fx from '@/Fx/index.js'
+import { Id } from '@/Service/Id.js'
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  const value = Math.random()
+  class Foo extends Id {
+    constructor(readonly foo: typeof value) {
+      super()
+    }
+  }
+
+  describe('provide', () => {
+    it('should provide the environment', async () => {
+      const stream = pipe(
+        Stream.now(value),
+        Stream.flatMapFx((a) =>
+          pipe(
+            Foo.ask(),
+            Fx.flatMap((foo) => Fx.now(a + foo.foo)),
+          ),
+        ),
+        Stream.provide(Env(Foo.id(), new Foo(value))),
+      )
+
+      const events = await collectAll(stream)
+
+      deepStrictEqual(events, [value * 2])
+    })
+  })
+
+  describe('provideService', () => {
+    it('should provide the service', async () => {
+      const stream = pipe(
+        Stream.now(value),
+        Stream.flatMapFx((a) =>
+          pipe(
+            Foo.ask(),
+            Fx.flatMap((foo) => Fx.now(a + foo.foo)),
+          ),
+        ),
+        Stream.provideService(Foo.id(), new Foo(value)),
+      )
+
+      const events = await collectAll(stream)
+
+      deepStrictEqual(events, [value * 2])
+    })
+  })
+
+  describe('provideLayer', () => {
+    it('should provide the layer', async () => {
+      const stream = pipe(
+        Stream.now(value),
+        Stream.flatMapFx((a) =>
+          pipe(
+            Foo.ask(),
+            Fx.flatMap((foo) => Fx.now(a + foo.foo)),
+          ),
+        ),
+        Stream.provideLayer(Foo.layerOf(value)),
+      )
+
+      const events = await collectAll(stream)
+
+      deepStrictEqual(events, [value * 2])
+    })
+  })
+})

package/src/Stream/provide.ts

@@ -0,0 +1,34 @@
+import { pipe } from 'hkt-ts'
+
+import { Stream } from './Stream.js'
+
+import { Env } from '@/Env/Env.js'
+import * as Fx from '@/Fx/index.js'
+import { Layer } from '@/Layer/Layer.js'
+import { Service } from '@/Service/Service.js'
+
+export function provide<R>(env: Env<R>) {
+  return <E, A>(stream: Stream<R, E, A>): Stream<never, E, A> =>
+    Stream((sink, scheduler, context) => Fx.provide(env)(stream.fork(sink, scheduler, context)))
+}
+
+export function provideService<S, I extends S>(service: Service<S>, impl: I) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<Exclude<R, S>, E, A> =>
+    Stream((sink, scheduler, context) =>
+      pipe(stream.fork(sink, scheduler, context), Fx.provideService(service, impl)),
+    )
+}
+
+export function provideLayer<R2, E2, S>(layer: Layer<R2, E2, S>) {
+  return <R, E, A>(stream: Stream<R | S, E, A>): Stream<Exclude<R | R2, S>, E | E2, A> =>
+    Stream((sink, scheduler, context) =>
+      pipe(
+        Fx.getFiberContext,
+        Fx.flatMap((c) => stream.fork(sink, scheduler, c.fork())),
+        Fx.provideLayer(layer),
+        Fx.orElseCause((cause) => Fx.fork(sink.error(cause))),
+        Fx.flatMap((f) => Fx.join(f)),
+        Fx.forkInContext(context),
+      ),
+    )
+}

package/src/Stream/run.ts

@@ -1,4 +1,4 @@
-import { flow, pipe } from 'hkt-ts/function'
+import { pipe } from 'hkt-ts/function'
 
 import { Stream } from './Stream.js'
 import { drain } from './drain.js'
@@ -7,8 +7,11 @@ import * as Fx from '@/Fx/index.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
 
 export function run(scheduler: Scheduler) {
-  return <E, A>(stream: Stream<never, E, A>): Fx.Fx<never, E, unknown> =>
+  return <E, A>(stream: Stream<Scheduler, E, A>): Fx.Fx<never, E, unknown> =>
     pipe(drain(stream), Fx.flatMap(Fx.join), Fx.provideService(Scheduler, scheduler))
 }
 
-export const runMain = (scheduler: Scheduler) => flow(run(scheduler), Fx.runMain)
+export const runMain =
+  (scheduler: Scheduler) =>
+  <E, A>(stream: Stream<Scheduler, E, A>): Promise<unknown> =>
+    pipe(stream, run(scheduler), Fx.runMain)

package/src/Stream/setFiberRefLocally.ts

@@ -23,22 +23,16 @@ export class SetFiberRefLocallyStream<R, E, A, R2, E2, A2> implements Stream<R2,
 
   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,
-        ),
-      ),
+      fromLazy(() => {
+        // SetFiberRef
+        FiberRefs.setFiberRefLocally(this.fiberRef, this.value())(context.fiberRefs)
+
+        // Ensure it is popped off when the stream ends
+        context.scope.ensuring(() =>
+          fromLazy(() => FiberRefs.popLocalFiberRef(this.fiberRef)(context.fiberRefs)),
+        )
+      }),
+      flatMap(() => this.stream.fork(sink, scheduler, context)),
     )
   }
 }

package/src/Stream/skipRepeats.ts

@@ -0,0 +1,41 @@
+import { Maybe } from 'hkt-ts'
+import { DeepEquals, Eq } from 'hkt-ts/Typeclass/Eq'
+
+import { Stream } from './Stream.js'
+
+import { unit } from '@/Fx/index.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
+
+export function skipRepeatsWith<A>(
+  E: Eq<A>,
+  __trace?: string,
+): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A> {
+  return (stream) =>
+    Stream((sink, scheduler, context) =>
+      stream.fork(addTrace(new SkipRepeatsSink(sink, E), __trace), scheduler, context),
+    )
+}
+
+export function skipRepeats<R, E, A>(stream: Stream<R, E, A>, __trace?: string): Stream<R, E, A> {
+  return skipRepeatsWith<A>(DeepEquals, __trace)(stream)
+}
+
+class SkipRepeatsSink<E, A, E2> implements Sink<E, A, E2> {
+  constructor(readonly sink: Sink<E, A, E2>, readonly E: Eq<A>) {}
+
+  protected last: Maybe.Maybe<A> = Maybe.Nothing
+  protected elem = Maybe.contains(this.E)
+
+  event(value: A) {
+    if (this.elem(value)(this.last)) {
+      return unit
+    }
+
+    this.last = Maybe.Just(value)
+
+    return this.sink.event(value)
+  }
+
+  error = this.sink.error
+  end = this.sink.end
+}

package/src/Stream/switchMap.ts

@@ -1,9 +1,7 @@
 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 { MapStream } from './bimap.js'
 
 import { Cause } from '@/Cause/index.js'
 import { Disposable, Settable, settable } from '@/Disposable/Disposable.js'
@@ -11,13 +9,12 @@ 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'
+import * as Supervisor from '@/Supervisor/index.js'
 
 export function switchMap<A, R2, E2, B>(
   f: (a: A) => Stream<R2, E2, B>,
@@ -70,17 +67,6 @@ class SwitchMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3>
   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,
@@ -93,7 +79,7 @@ class SwitchMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3>
   event = (a: A): Fx.IO<E3, unknown> =>
     Fx.lazy(() => {
       const forked = this.context.fork({
-        supervisor: and(this._supervisor)(this.context.supervisor),
+        supervisor: Supervisor.and(Supervisor.inheritFiberRefs)(this.context.supervisor),
       })
 
       const cleanup: Fx.Of<unknown> = Fx.zipAll(this._fibers.map((f) => f.interruptAs(forked.id)))