@typed/fx 0.0.4 → 0.0.6

package/src/Fx/Fx.test.ts

@@ -107,14 +107,14 @@ describe(new URL(import.meta.url).pathname, () => {
     console.time('Fx: Fib25 Construction')
     const program = fib(25)
     console.timeEnd('Fx: Fib25 Construction')
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 5; i++) {
       console.time('Fib25')
       await runMain(program)
       console.timeEnd('Fib25')
     }
   })
 
-  it('runs Fib w/ generators', async () => {
+  it.skip('runs Fib w/ generators', async () => {
     const fib = (n: number): Fx.Of<number> =>
       Fx.Fx(function* () {
         if (n < 2) {

package/src/Fx/Fx.ts

@@ -206,6 +206,9 @@ export const tap =
       __trace,
     )
 
+export const tapLazy = <A, B>(f: (a: A) => B, __trace?: string) =>
+  tap((a: A) => fromLazy(() => f(a)), __trace)
+
 export const mapTo =
   <B>(b: B, __trace?: string) =>
   <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, B> =>
@@ -227,13 +230,7 @@ export const match =
     __trace?: string,
   ) =>
   <R>(fx: Fx<R, E, A>): Fx<R | R2 | R3, E2 | E3, B | C> =>
-    Match.make(
-      fx,
-      (cause) =>
-        cause.tag === 'Expected' ? onLeft(cause.error) : (fromCause(cause) as Fx<R2, E2, B>),
-      onRight,
-      __trace,
-    )
+    Match.make(fx, flow(findExpectedCause, Either.match(onLeft, fromCause)), onRight, __trace)
 
 export const orElseCause =
   <E, R2, E2, B>(onLeft: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, __trace?: string) =>
@@ -601,8 +598,12 @@ export const CommutativeBoth: CB.CommutativeBoth3<FxHKT> = {
   both,
 }
 
-export const zipLeft = AB.zipLeft<FxHKT>({ ...CommutativeBoth, ...Covariant })
-export const zipRight = AB.zipRight<FxHKT>({ ...CommutativeBoth, ...Covariant })
+export const zipLeft = AB.zipLeft<FxHKT>({ ...CommutativeBoth, ...Covariant }) as <R2, E2, B>(
+  second: Fx<R2, E2, B>,
+) => <R, E, A>(first: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+export const zipRight = AB.zipRight<FxHKT>({ ...CommutativeBoth, ...Covariant }) as <R2, E2, B>(
+  second: Fx<R2, E2, B>,
+) => <R, E, A>(first: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
 
 export const IdentityBothPar: IB.IdentityBoth3<FxHKT> = {
   ...CommutativeBoth,

package/src/Fx/join.ts

@@ -18,10 +18,10 @@ export const join = <E, A>(fiber: Fiber.Fiber<E, A>) =>
     ),
   )
 
-export const forkJoinInContext = <R, E, A>(
-  fx: Fx.Fx<R, E, A>,
-  context: FiberContext<FiberId.Live>,
-): Fx.Fx<R, E, A> => pipe(fx, Fx.forkInContext(context), Fx.flatMap(join))
+export const forkJoinInContext =
+  (context: FiberContext<FiberId.Live>) =>
+  <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R, E, A> =>
+    pipe(fx, Fx.forkInContext(context), Fx.flatMap(join))
 
 export const forkJoinIn = <R, E, A>(fx: Fx.Fx<R, E, A>, scope: Scope): Fx.Fx<R, E, A> =>
   pipe(fx, Fx.forkIn(scope), Fx.flatMap(join))

package/src/Schedule/ScheduleState.ts

@@ -20,6 +20,9 @@ const maxTimeAssociative = Time.makeAssociative({
 })
 const maybeMaxTimeAssociative = makeAssociative(maxTimeAssociative)
 
+/**
+ * TODO: ScheduleState should track Exit values to allow exiting early w/ custom logic
+ */
 export class ScheduleState {
   constructor(
     /**

package/src/Scheduler/RootScheduler.ts

@@ -1,5 +1,3 @@
-import { identity } from 'hkt-ts'
-
 import { Scheduler } from './Scheduler.js'
 import { callbackScheduler } from './callbackScheduler.js'
 import { runSchedule } from './runSchedule.js'
@@ -18,6 +16,7 @@ import { complete } from '@/Future/complete.js'
 import { wait } from '@/Future/wait.js'
 import { Fx } from '@/Fx/Fx.js'
 import { Schedule } from '@/Schedule/Schedule.js'
+import { ScheduleState } from '@/Schedule/ScheduleState.js'
 import { Delay } from '@/Time/index.js'
 import { SetTimeoutTimer } from '@/Timer/SetTimeoutTimer.js'
 import { Timer } from '@/Timer/Timer.js'
@@ -45,15 +44,14 @@ class RootSchedulerImpl implements Scheduler {
     }
   }
 
-  readonly asap: Scheduler['asap'] = <R, E, A, E2 = E, B = A>(
+  readonly asap: Scheduler['asap'] = <R, E, A>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     context: FiberContext<FiberId.Live>,
-    transform: (fx: Fx<R, E, A>) => Fx<R, E2, B> = identity as any,
-  ): Live<E2, B> => {
+  ): Live<E, A> => {
     setFiberRef(CurrentEnv, env)(context.fiberRefs)
 
-    const runtime = new FiberRuntime(this.runAt(transform(fx), Delay(0)), context)
+    const runtime = new FiberRuntime(this.runAt(fx, Delay(0)), context)
 
     // Safe to call sync since it will be run by the Timeline.
     runtime.startSync()
@@ -61,17 +59,17 @@ class RootSchedulerImpl implements Scheduler {
     return runtime
   }
 
-  readonly schedule: Scheduler['schedule'] = <R, E, A, E2 = E, B = A>(
+  readonly schedule: Scheduler['schedule'] = <R, E, A, B>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     schedule: Schedule,
     context: FiberContext<FiberId.Live>,
-    transform: (fx: Fx<R, E, A>) => Fx<R, E2, B> = identity as any,
+    onEnd?: (state: ScheduleState) => Fx<R, E, B>,
   ) => {
     setFiberRef(CurrentEnv, env)(context.fiberRefs)
 
     const runtime = new FiberRuntime(
-      runSchedule(transform(fx), schedule, this.timer, this.runAt),
+      runSchedule(fx, schedule, this.timer, this.runAt, onEnd),
       context,
     )
 

package/src/Scheduler/Scheduler.ts

@@ -9,20 +9,19 @@ import { ScheduleState } from '@/Schedule/ScheduleState.js'
 import { Service } from '@/Service/Service.js'
 
 export interface Scheduler extends Disposable {
-  readonly asap: <R, E, A, E2 = E, B = A>(
+  readonly asap: <R, E, A>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     context: FiberContext<FiberId.Live>,
-    transform?: (fx: Fx<R, E, A>) => Fx<R, E2, B>,
-  ) => Live<E2, B>
+  ) => Live<E, A>
 
-  readonly schedule: <R, E, A, E2 = E, B = A>(
+  readonly schedule: <R, E, A, B>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     schedule: Schedule,
     context: FiberContext<FiberId.Live>,
-    transform?: (fx: Fx<R, E, A>) => Fx<R, E2, B>,
-  ) => Live<E2, ScheduleState>
+    onEnd?: (state: ScheduleState) => Fx<R, E, B>,
+  ) => Live<E, ScheduleState>
 }
 
 export const Scheduler = Service<Scheduler>('Scheduler')

package/src/Scheduler/callbackScheduler.ts

@@ -34,6 +34,7 @@ export function callbackScheduler(
   }
 
   function runReadyTasks() {
+    nextArrival = null
     timeline.getReadyTasks(Clock.timeToUnixTime(timer.getCurrentTime())(timer)).forEach((f) => f())
 
     scheduleNextRun()

package/src/Scheduler/runSchedule.ts

@@ -1,5 +1,5 @@
 import * as Clock from '@/Clock/Clock.js'
-import { Fx } from '@/Fx/Fx.js'
+import { Fx, unit } from '@/Fx/Fx.js'
 import { Schedule } from '@/Schedule/Schedule.js'
 import { ScheduleState } from '@/Schedule/ScheduleState.js'
 import { Delay } from '@/Time/index.js'
@@ -7,11 +7,12 @@ import { Delay } from '@/Time/index.js'
 /**
  * Runs an Fx on a given Schedule
  */
-export function runSchedule<R, E, A>(
+export function runSchedule<R, E, A, B>(
   fx: Fx<R, E, A>,
   schedule: Schedule,
   clock: Clock.Clock,
   runAt: (fx: Fx<R, E, A>, delay: Delay) => Fx<R, E, A>,
+  onEnd?: (state: ScheduleState) => Fx<R, E, B>,
 ): Fx<R, E, ScheduleState> {
   return Fx(function* () {
     let [state, decision] = schedule.step(clock.getCurrentTime(), new ScheduleState())
@@ -26,6 +27,8 @@ export function runSchedule<R, E, A>(
       decision = nextDecision
     }
 
+    yield* onEnd?.(state) ?? unit
+
     // Return the final state
     return state
   })

package/src/Scope/LocalScope.ts

@@ -2,7 +2,6 @@ import { mapTo } from 'hkt-ts/Either'
 import * as Maybe from 'hkt-ts/Maybe'
 import { First } from 'hkt-ts/Typeclass/Associative'
 import { pipe } from 'hkt-ts/function'
-import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { Closeable } from './Closeable.js'
 import { ReleaseMap } from './ReleaseMap.js'
@@ -18,7 +17,7 @@ const { concat: concatExits } = makeSequentialAssociative<any, any>(First)
 export class LocalScope implements Closeable {
   protected _state: ScopeState = Open
   protected _releaseMap = new ReleaseMap(this.strategy)
-  protected _refCount = AtomicCounter(NonNegativeInteger(1))
+  protected _refCount = AtomicCounter()
   protected _exit: Maybe.Maybe<Exit<any, any>> = Maybe.Nothing
 
   constructor(readonly strategy: FinalizationStrategy) {}
@@ -44,9 +43,12 @@ export class LocalScope implements Closeable {
 
     const extended = new LocalScope(strategy)
 
-    // Mutually track resources
-    extended.ensuring(() => this.release)
-    extended.ensuring(this.ensuring(() => extended.release))
+    extended.ensuring(() => {
+      decrement(this._refCount)
+
+      return this.release
+    })
+
     increment(this._refCount)
 
     return extended
@@ -64,7 +66,7 @@ export class LocalScope implements Closeable {
   // Internals
 
   protected release = lazy(() => {
-    if (decrement(this._refCount) > 0 || Maybe.isNothing(this._exit) || this.isClosed) {
+    if (this._refCount.get() > 0 || Maybe.isNothing(this._exit) || this.isClosed) {
       return success(false)
     }
 

package/src/Semaphore/Semaphore.ts

@@ -4,7 +4,7 @@ import { NonNegativeInteger } from 'hkt-ts/number'
 import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
 import { MutableFutureQueue } from '@/Future/MutableFutureQueue.js'
 import { wait } from '@/Future/wait.js'
-import { Fx, Of, flatMap, fromLazy, tap, unit } from '@/Fx/Fx.js'
+import * as Fx from '@/Fx/Fx.js'
 import { fiberScoped, managed, scoped } from '@/Fx/scoped.js'
 
 export class Semaphore {
@@ -22,10 +22,10 @@ export class Semaphore {
     return this.running.get()
   }
 
-  readonly prepare = fromLazy(() => {
+  readonly prepare = Fx.fromLazy(() => {
     if (this.available > 0) {
       return new Acquisition(
-        fromLazy(() => {
+        Fx.fromLazy(() => {
           increment(this.running)
         }),
         this.release,
@@ -39,11 +39,7 @@ export class Semaphore {
     const acquisition = new Acquisition(
       pipe(
         wait(future),
-        tap(() =>
-          fromLazy(() => {
-            increment(that.running)
-          }),
-        ),
+        Fx.tapLazy(() => increment(that.running)),
       ),
       this.release,
     )
@@ -51,17 +47,14 @@ export class Semaphore {
     return acquisition
   })
 
-  protected release = fromLazy(() => {
+  protected release = Fx.fromLazy(() => {
     decrement(this.running)
-
-    if (this.waiting.size() > 0) {
-      this.waiting.next(unit)
-    }
+    this.waiting.next(Fx.unit)
   })
 }
 
 export class Acquisition {
-  constructor(readonly acquire: Of<void>, readonly release: Of<void>) {}
+  constructor(readonly acquire: Fx.Of<void>, readonly release: Fx.Of<void>) {}
 }
 
 /**
@@ -80,7 +73,7 @@ export class Lock extends Semaphore {
 export function acquirePermit(semaphore: Semaphore) {
   return pipe(
     semaphore.prepare,
-    flatMap(({ acquire, release }) => managed(acquire, constant(release))),
+    Fx.flatMap(({ acquire, release }) => managed(acquire, constant(release))),
   )
 }
 
@@ -88,10 +81,10 @@ export function acquirePermit(semaphore: Semaphore) {
  * Acquire a permit from a given semaphore, run an Fx, and then release the permit.
  */
 export function acquire(semaphore: Semaphore) {
-  return <R, E, A>(fx: Fx<R, E, A>) =>
+  return <R, E, A>(fx: Fx.Fx<R, E, A>) =>
     pipe(
       acquirePermit(semaphore),
-      flatMap(() => fx),
+      Fx.flatMap(() => fx),
       scoped,
     )
 }
@@ -100,10 +93,10 @@ export function acquire(semaphore: Semaphore) {
  * Acquire a permit from a given semaphore, run an Fx, and then release the permit.
  */
 export function acquireFiber(semaphore: Semaphore) {
-  return <R, E, A>(fx: Fx<R, E, A>) =>
+  return <R, E, A>(fx: Fx.Fx<R, E, A>) =>
     pipe(
       acquirePermit(semaphore),
-      flatMap(() => fx),
+      Fx.flatMap(() => fx),
       fiberScoped,
     )
 }

package/src/Sink/Sink.ts

@@ -2,7 +2,7 @@ import { flow, pipe } from 'hkt-ts'
 import { Left, Right } from 'hkt-ts/Either'
 
 import { Cause } from '@/Cause/Cause.js'
-import { Fx, IO, access, flatMap, fromLazy, provide, unit } from '@/Fx/Fx.js'
+import { Fx, IO, access, addCustomTrace, flatMap, fromLazy, provide, unit } from '@/Fx/Fx.js'
 import { Closeable } from '@/Scope/Closeable.js'
 
 export interface Sink<in E, in A, out E2 = never> {
@@ -77,3 +77,13 @@ export function makeDrain<
     }),
   )
 }
+
+export function addTrace<E, A, E2>(sink: Sink<E, A, E2>, trace?: string): Sink<E, A, E2> {
+  if (trace === undefined) return sink
+
+  return {
+    event: flow(sink.event, addCustomTrace(trace)),
+    error: flow(sink.error, addCustomTrace(trace)),
+    end: pipe(sink.end, addCustomTrace(trace)),
+  }
+}

package/src/Stream/Stream.ts

@@ -7,14 +7,10 @@ import { Sink } from '@/Sink/Sink.js'
 
 /**
  * TODOS:
- * - Scan
  * - Loop
  * - zipItems
  * - withItems
- * - switchLatest
  * - concatMap
- * - mergeConcurrently
- * - merge/mergeArray
  * - combine/combineArray
  * - zip/zipArray
  * - sample
@@ -30,24 +26,26 @@ import { Sink } from '@/Sink/Sink.js'
  * - delay
  * - throttle
  * - debounce
- * - orElse
- * - multicast
- * - hold
  * - reduce
- * - run
  * - Fusion/Commutation
  * - Unique Identification for streams to add to tracing
  *    - How to build a dynamic stream graph?
  */
 
-export interface Stream<R = never, E = never, A = unknown> {
-  readonly fork: <E2 = never>(
+export interface Stream<out R = never, out E = never, out A = unknown> {
+  fork<E2 = never>(
     sink: Sink<E, A, E2>,
     scheduler: Scheduler,
     context: FiberContext<FiberId.Live>,
-  ) => Fx.RIO<R, Fiber<E2, any>>
+  ): Fx.RIO<R, Fiber<E2, any>>
 }
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export type ResourcesOf<T> = T extends Stream<infer R, infer _, infer __> ? R : never
+export type ErrorsOf<T> = T extends Stream<infer _, infer E, infer __> ? E : never
+export type OutputOf<T> = T extends Stream<infer _, infer __, infer A> ? A : never
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
 export interface RIO<R, A> extends Stream<R, never, A> {}
 export interface IO<E, A> extends Stream<never, E, A> {}
 export interface Of<A> extends Stream<never, never, A> {}

package/src/Stream/acquirePermit.ts

@@ -0,0 +1,32 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { Live } from '@/FiberId/FiberId.js'
+import * as Fx from '@/Fx/Fx.js'
+import { Scheduler } from '@/Scheduler/index.js'
+import * as Semaphore from '@/Semaphore/index.js'
+import { Sink } from '@/Sink/Sink.js'
+
+export function acquirePermit(semaphore: Semaphore.Semaphore) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> =>
+    new AcquirePermitStream(stream, semaphore)
+}
+
+export class AcquirePermitStream<R, E, A> implements Stream<R, E, A> {
+  constructor(readonly stream: Stream<R, E, A>, readonly semaphore: Semaphore.Semaphore) {}
+
+  fork = <E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<Live>) =>
+    pipe(
+      this.semaphore.prepare,
+      Fx.flatMap(({ acquire, release }) =>
+        pipe(
+          acquire,
+          Fx.uninterruptable,
+          Fx.tapLazy(() => context.scope.ensuring(() => release)),
+          Fx.flatMap(() => this.stream.fork(sink, scheduler, context)),
+        ),
+      ),
+    )
+}

package/src/Stream/bimap.ts

@@ -12,15 +12,21 @@ import { Sink } from '@/Sink/Sink.js'
 export function bimap<A, B, C, D>(
   f: (a: A) => B,
   g: (c: C) => D,
+  __trace?: string,
 ): <R>(stream: Stream<R, A, C>) => Stream<R, B, D> {
-  return (stream) => BimapStream.make(stream, f, g)
+  return (stream) => BimapStream.make(stream, f, g, __trace)
 }
 
 export class BimapStream<R, A, B, C, D> implements Stream<R, B, D> {
-  constructor(readonly stream: Stream<R, A, C>, readonly f: (a: A) => B, readonly g: (c: C) => D) {}
+  constructor(
+    readonly stream: Stream<R, A, C>,
+    readonly f: (a: A) => B,
+    readonly g: (c: C) => D,
+    readonly __trace?: string,
+  ) {}
 
-  fork = <E2>(sink: Sink<B, D, E2>, scheduler: Scheduler, context: FiberContext<Live>) => {
-    return this.stream.fork<E2>(
+  fork = <E>(sink: Sink<B, D, E>, scheduler: Scheduler, context: FiberContext<Live>) => {
+    return this.stream.fork<E>(
       new BimapSink(sink, scheduler, context, this.f, this.g),
       scheduler,
       context,
@@ -31,16 +37,17 @@ export class BimapStream<R, A, B, C, D> implements Stream<R, B, D> {
     stream: Stream<R, A, C>,
     f: (a: A) => B,
     g: (c: C) => D,
+    __trace?: string,
   ): Stream<R, B, D> {
     if (stream instanceof MapStream) {
-      return BimapStream.make(stream.stream, f, flow(stream.f, g))
+      return BimapStream.make(stream.stream, f, flow(stream.f, g), __trace)
     }
 
     if (stream instanceof BimapStream) {
-      return BimapStream.make(stream.stream, flow(stream.f, f), flow(stream.g, g))
+      return BimapStream.make(stream.stream, flow(stream.f, f), flow(stream.g, g), __trace)
     }
 
-    return new BimapStream(stream, f, g)
+    return new BimapStream(stream, f, g, __trace)
   }
 }
 
@@ -53,7 +60,7 @@ class BimapSink<A, B, C, D, E> implements Sink<A, C, E> {
     readonly g: (c: C) => D,
   ) {}
 
-  event = (c: C) => this.sink.event(this.g(c))
-  error = (cause: Cause.Cause<A>) => this.sink.error(Cause.map(this.f)(cause))
+  event = flow(this.g, this.sink.event)
+  error = flow(Cause.map(this.f), this.sink.error)
   end = this.sink.end
 }

package/src/Stream/continueWith.ts

@@ -8,23 +8,27 @@ import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { FiberId } from '@/FiberId/FiberId.js'
 import * as Fx from '@/Fx/index.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
 
-export function continueWith<R2, E2, B>(f: () => Stream<R2, E2, B>) {
+export function continueWith<R2, E2, B>(f: () => Stream<R2, E2, B>, __trace?: string) {
   return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A | B> =>
-    new ContinueWith(stream, f)
+    new ContinueWith(stream, f, __trace)
 }
 
 export const startWith =
-  <B>(value: B) =>
+  <B>(value: B, __trace?: string) =>
   <R, E, A>(stream: Stream<R, E, A>) =>
     pipe(
       now(value),
-      continueWith(() => stream),
+      continueWith(() => stream, __trace),
     )
 
 export class ContinueWith<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2, A | B> {
-  constructor(readonly stream: Stream<R, E, A>, readonly f: () => Stream<R2, E2, B>) {}
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: () => Stream<R2, E2, B>,
+    readonly __trace?: string,
+  ) {}
 
   fork = <E3>(
     sink: Sink<E | E2, A | B, E3>,
@@ -33,7 +37,7 @@ export class ContinueWith<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2,
   ) => {
     return Fx.access((env: Env<R | R2>) =>
       this.stream.fork(
-        new ContinueWithSink(sink, scheduler, context, env, this.f),
+        addTrace(new ContinueWithSink(sink, scheduler, context, env, this.f), this.__trace),
         scheduler,
         context,
       ),

package/src/Stream/drain.ts

@@ -7,18 +7,18 @@ import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { FiberId } from '@/FiberId/FiberId.js'
 import * as Fx from '@/Fx/index.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Drain, Sink, makeDrain } from '@/Sink/Sink.js'
+import { Drain, Sink, addTrace, makeDrain } from '@/Sink/Sink.js'
 
 export function drain<R, E, A>(
   stream: Stream<R, E, A>,
   __trace?: string,
-): Fx.Fx<R | Scheduler, never, Fiber<E, any>> {
+): Fx.Fx<R | Scheduler, never, Fiber<never, any>> {
   return pipe(
     Fx.Do,
     Fx.bind('fiberContext', () => Fx.getFiberContext),
     Fx.let('context', ({ fiberContext }) => fiberContext.fork()),
     Fx.let('sink', ({ context }) => new Drain<E, A>(context.scope)),
-    Fx.flatMap(({ sink, context }) => fork(stream, sink, context), __trace),
+    Fx.flatMap(({ sink, context }) => fork(stream, sink, context, __trace), __trace),
   )
 }
 
@@ -26,8 +26,9 @@ export function fork<R, E, A, E2 = never>(
   stream: Stream<R, E, A>,
   sink: Sink<E, A, E2>,
   context: FiberContext<FiberId.Live>,
-): Fx.Fx<R | Scheduler, never, Fiber<E | E2, A>> {
-  return Fx.asks(Scheduler)((scheduler) => stream.fork(sink, scheduler, context))
+  __trace?: string,
+): Fx.Fx<R | Scheduler, never, Fiber<E2, A>> {
+  return Fx.asks(Scheduler)((scheduler) => stream.fork(addTrace(sink, __trace), scheduler, context))
 }
 
 export function observe<A, R2, E2, B>(f: (a: A) => Fx.Fx<R2, E2, B>, __trace?: string) {
@@ -37,7 +38,7 @@ export function observe<A, R2, E2, B>(f: (a: A) => Fx.Fx<R2, E2, B>, __trace?: s
       Fx.bind('fiberContext', () => Fx.getFiberContext),
       Fx.let('context', ({ fiberContext }) => fiberContext.fork()),
       Fx.bind('sink', ({ context }) => makeDrain<E, A, R2, E2>(context.scope, { event: f })),
-      Fx.flatMap(({ sink, context }) => fork(stream, sink, context), __trace),
+      Fx.flatMap(({ sink, context }) => fork(stream, sink, context, __trace), __trace),
     )
 }
 
@@ -50,7 +51,7 @@ export function collect<R, E, A>(
 
     yield* pipe(
       stream,
-      observe((a) => Fx.fromLazy(() => events.push(a))),
+      observe((a) => Fx.fromLazy(() => events.push(a)), __trace),
       Fx.flatMap(Fx.join),
     )
 

package/src/Stream/empty.ts

@@ -1,8 +1,7 @@
 import { Stream } from './Stream.js'
 
 import * as Fx from '@/Fx/Fx.js'
-import { span } from '@/Fx/logging.js'
 
 export const empty = Stream<never, never, never>((sink, scheduler, context) =>
-  Fx.asksEnv((env) => scheduler.asap(sink.end, env, context, span('empty'))),
+  Fx.asksEnv((env) => scheduler.asap(sink.end, env, context)),
 )

package/src/Stream/flatMap.test.ts

@@ -2,13 +2,11 @@ import { deepStrictEqual } from 'assert'
 
 import { pipe } from 'hkt-ts'
 
-import { collect, observe } from './drain.js'
+import { collectAll } from './_internal.test.js'
 import { flatMap } from './flatMap.js'
 import { fromFx } from './fromFx.js'
 
 import * as Fx from '@/Fx/index.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
 import { testSuite } from '@/_internal/suite.js'
 
 testSuite(import.meta.url, () => {
@@ -19,25 +17,14 @@ testSuite(import.meta.url, () => {
       flatMap((a) => fromFx(Fx.success(a + 1))),
     )
 
-    it('should create a Stream', () =>
-      pipe(
-        stream,
-        observe((n) => Fx.fromLazy(() => deepStrictEqual(n, value + 1))),
-        Fx.flatMap(Fx.join),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.runMain,
-      ))
-
-    it('should be collectable', async () => {
-      await pipe(
-        Fx.Fx(function* () {
-          const events: readonly number[] = yield* collect(stream)
+    it('is collectable', async () => {
+      const events = await collectAll(stream)
+      deepStrictEqual(events, [value + 1])
+    })
 
-          deepStrictEqual(events, [value + 1])
-        }),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.runMain,
-      )
+    it('is collectable with multiple subscribers', async () => {
+      const events = await Promise.all([collectAll(stream), collectAll(stream)])
+      deepStrictEqual(events, [[value + 1], [value + 1]])
     })
   })
 })