@typed/fx 1.27.3 → 1.28.0

package/src/internal/core.ts

@@ -1,36 +1,36 @@
 import * as Context from "@typed/context"
-import {
-  type ConfigProvider,
-  type Duration,
-  type Equivalence,
-  type FiberId,
-  type FiberRef,
-  type HashSet,
-  type Queue,
-  type Request,
-  type Runtime,
-  type Schedule,
-  type Scheduler,
-  Unify
-} from "effect"
+import { Data, Record } from "effect"
 import * as Boolean from "effect/Boolean"
 import * as Cause from "effect/Cause"
 import * as Clock from "effect/Clock"
+import type * as ConfigProvider from "effect/ConfigProvider"
 import * as Deferred from "effect/Deferred"
+import type * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as Equal from "effect/Equal"
+import type * as Equivalence from "effect/Equivalence"
 import { boolean } from "effect/Equivalence"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
+import type * as FiberRef from "effect/FiberRef"
 import { constFalse, constTrue } from "effect/Function"
+import type * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
+import type * as Queue from "effect/Queue"
 import * as Ref from "effect/Ref"
+import type * as Request from "effect/Request"
+import type * as Runtime from "effect/Runtime"
+import type * as Schedule from "effect/Schedule"
+import type * as Scheduler from "effect/Scheduler"
 import * as Scope from "effect/Scope"
 import * as Tracer from "effect/Tracer"
+import * as Unify from "effect/Unify"
+import type * as Utils from "effect/Utils"
 import type { FlattenStrategy, Fx, FxFork, MergeStrategy } from "../Fx.js"
 import * as Sink from "../Sink.js"
 import type { Bounds } from "./bounds.js"
@@ -284,7 +284,7 @@ export const observe = <A, E, R, B, E2, R2>(
   f: (a: A) => Effect.Effect<B, E2, R2>
 ): Effect.Effect<void, E | E2, R | R2> => Observe.make(fx, f)
 
-const constUnit = () => Effect.unit
+const constUnit = () => Effect.void
 
 export const drain = <A, E, R>(fx: Fx<A, E, R>): Effect.Effect<void, E, R> => Observe.make(fx, constUnit)
 
@@ -303,7 +303,7 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
 
       return Effect.zipRight(
         fx.run(Sink.make(onFailure, (a) => Effect.catchAllCause(f(a), onFailure))),
-        Effect.sync(() => resume(Effect.unit))
+        Effect.sync(() => resume(Effect.void))
       )
     })
   }
@@ -313,7 +313,7 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
     f: (a: A) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<void, E | E2, R | R2> {
     if (isEmpty(fx)) {
-      return Effect.unit
+      return Effect.void
     } else if (isNever(fx)) {
       return Effect.never
     } else if (isProducer(fx)) {
@@ -326,13 +326,13 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
             Filter: (op) =>
               SyncProducer.effectOnce(() =>
-                SyncProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.unit))
+                SyncProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.void))
               ),
             FilterMap: (op) =>
               SyncProducer.effectOnce(() =>
                 SyncProducer.runEffect(
                   fx.i0,
-                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.unit, onSome: f }))
+                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.void, onSome: f }))
                 )
               )
           }),
@@ -342,12 +342,12 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               SyncProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
             FilterMapEffect: (op) =>
               SyncProducer.runEffect(fx.i0, (a) =>
-                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.unit, onSome: f })))),
+                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.void, onSome: f })))),
             FilterEffect: (op) =>
               SyncProducer.runEffect(
                 fx.i0,
                 Unify.unify((a) =>
-                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.unit))
+                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.void))
                 )
               ),
             TapEffect: (op) => SyncProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), () => f(a)))
@@ -400,13 +400,13 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
             Filter: (op) =>
               SyncProducer.effectOnce(() =>
-                EffectProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.unit))
+                EffectProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.void))
               ),
             FilterMap: (op) =>
               SyncProducer.effectOnce(() =>
                 EffectProducer.runEffect(
                   fx.i0,
-                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.unit, onSome: f }))
+                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.void, onSome: f }))
                 )
               )
           }),
@@ -416,12 +416,12 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               EffectProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
             FilterMapEffect: (op) =>
               EffectProducer.runEffect(fx.i0, (a) =>
-                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.unit, onSome: f })))),
+                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.void, onSome: f })))),
             FilterEffect: (op) =>
               EffectProducer.runEffect(
                 fx.i0,
                 Unify.unify((a) =>
-                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.unit))
+                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.void))
                 )
               ),
             TapEffect: (op) => EffectProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), () => f(a)))
@@ -617,10 +617,41 @@ export function skipRepeatsWith<A, E, R>(
   })
 }
 
+const toDeepEquals = (u: unknown): unknown => {
+  switch (typeof u) {
+    case "object": {
+      if (Predicate.isNullable(u)) {
+        return u
+      } else if (Equal.symbol in u) {
+        return u
+      } else if (Array.isArray(u)) {
+        return Data.tuple(u.map(toDeepEquals))
+      } else if (u instanceof Set) {
+        return Data.tuple(Array.from(u, toDeepEquals))
+      } else if (u instanceof Map) {
+        return Data.tuple(Array.from(u, ([k, v]) => Data.tuple([toDeepEquals(k), toDeepEquals(v)])))
+      } else {
+        return Data.struct(Record.map(u, toDeepEquals))
+      }
+    }
+    default:
+      return u
+  }
+}
+
+/**
+ * @internal
+ */
+export const deepEquals = (a: unknown, b: unknown) => {
+  // Attempt reference equality first for performance
+  if (Object.is(a, b)) return true
+  return Equal.equals(toDeepEquals(a), toDeepEquals(b))
+}
+
 export function skipRepeats<A, E, R>(
   fx: Fx<A, E, R>
 ): Fx<A, E, R> {
-  return skipRepeatsWith(fx, Equal.equals)
+  return skipRepeatsWith(fx, deepEquals)
 }
 
 class ProducerEffectTransformer<A, E, R, B, E2, R2> extends FxBase<B, E | E2, R | R2> {
@@ -644,7 +675,7 @@ export function isProducerEffectTransformer<A, E, R>(
 
 class Empty extends FxBase<never, never, never> {
   run<R2>(): Effect.Effect<unknown, never, R2> {
-    return Effect.unit
+    return Effect.void
   }
 }
 
@@ -983,22 +1014,25 @@ class FromFxEffect<
   }
 }
 
-export function gen<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+export function gen<Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ): Fx<
   Fx.Success<FX>,
-  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Effect.Effect.Context<Y["value"]> | Fx.Context<FX>
+  YieldWrapError<Y> | Fx.Error<FX>,
+  YieldWrapContext<Y> | Fx.Context<FX>
 > {
   return fromFxEffect(Effect.gen(f))
 }
 
-export function genScoped<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+type YieldWrapError<T> = T extends Utils.YieldWrap<Effect.Effect<infer _, infer E, any>> ? E : never
+type YieldWrapContext<T> = T extends Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R : never
+
+export function genScoped<Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ): Fx<
   Fx.Success<FX>,
-  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>
+  YieldWrapError<Y> | Fx.Error<FX>,
+  Exclude<YieldWrapContext<Y> | Fx.Context<FX>, Scope.Scope>
 > {
   return scoped(fromFxEffect(Effect.gen(f)))
 }
@@ -1102,7 +1136,7 @@ class OrElse<
   run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.catchAll(
       Effect.asyncEffect<unknown, E, never, never, never, R | R2 | R3>((resume) =>
-        Effect.asUnit(Effect.zipRight(
+        Effect.asVoid(Effect.zipRight(
           this.i0.run(
             Sink.make(
               (cause) =>
@@ -1113,7 +1147,7 @@ class OrElse<
               sink.onSuccess
             )
           ),
-          Effect.sync(() => resume(Effect.unit))
+          Effect.sync(() => resume(Effect.void))
         ))
       ),
       (error: E) => this.i1(error).run(sink)
@@ -1264,16 +1298,16 @@ function runOrdered<
   sink: Sink.Sink<any, any, R2>,
   concurrency: number | "unbounded"
 ): Effect.Effect<unknown, never, R2 | Fx.Context<FX[number]>> {
-  return Effect.suspend(
-    () => {
-      const buffers = withBuffers(fx.length, sink)
+  return Effect.fiberIdWith(
+    (id) => {
+      const buffers = withBuffers(fx.length, sink, id)
       return Effect.forEach(
         fx,
         (fx, i) =>
           Effect.flatMap(
             fx.run(
               Sink.make(
-                (cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause),
+                (cause) => Cause.isInterruptedOnly(cause) ? buffers.onEnd(i) : sink.onFailure(cause),
                 (a) => buffers.onSuccess(i, a)
               )
             ),
@@ -1529,7 +1563,7 @@ class During<A, E, R, B, E2, R2, E3, R3> extends FxBase<A, E | E2 | E3, R | R2 |
                 this.i0.run(
                   Sink.make(
                     onFailure,
-                    (a) => taking ? s.onSuccess(a) : Effect.unit
+                    (a) => taking ? s.onSuccess(a) : Effect.void
                   )
                 )
               )
@@ -1654,7 +1688,7 @@ export function withMaxOpsBeforeYield<A, E, R>(
 
 export function withParentSpan<A, E, R>(
   fx: Fx<A, E, R>,
-  parentSpan: Tracer.ParentSpan
+  parentSpan: Tracer.AnySpan
 ): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withParentSpan(effect, parentSpan))
 }
@@ -2479,10 +2513,10 @@ class FromAsyncIterable<A> extends FxBase<A, never, never> {
       const iterator = this.i0[Symbol.asyncIterator]()
       const loop = (result: IteratorResult<A>): Effect.Effect<unknown, never, R> =>
         result.done
-          ? Effect.sync(() => cb(Effect.unit))
+          ? Effect.sync(() => cb(Effect.void))
           : Effect.zipRight(sink.onSuccess(result.value), Effect.flatMap(Effect.promise(() => iterator.next()), loop))
 
-      return Effect.asUnit(Effect.flatMap(
+      return Effect.asVoid(Effect.flatMap(
         Effect.promise(() => iterator.next()),
         loop
       ))
@@ -2492,7 +2526,7 @@ class FromAsyncIterable<A> extends FxBase<A, never, never> {
 
 export function findFirst<A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Effect.Effect<A, E, R> {
   return Effect.asyncEffect((cb) =>
-    observe(fx, (a) => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.unit)
+    observe(fx, (a) => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.void)
   )
 }
 
@@ -2544,13 +2578,13 @@ class MergeRace<A, E, R, B, E2, R2> extends FxBase<A | B, E | E2, R | R2> {
 
   run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.gen(this, function*(_) {
-      const fiber1 = yield* _(Effect.fork(this.i0.run(Sink.make(
+      const fiber1 = yield* Effect.fork(this.i0.run(Sink.make(
         sink.onFailure,
         (a) => Effect.flatMap(sink.onSuccess(a), () => Fiber.interrupt(fiber2))
-      ))))
-      const fiber2 = yield* _(Effect.fork(this.i1.run(sink)))
+      )))
+      const fiber2 = yield* Effect.fork(this.i1.run(sink))
 
-      return yield* _(Fiber.joinAll([fiber1, fiber2]))
+      return yield* Fiber.joinAll([fiber1, fiber2])
     })
   }
 }
@@ -2585,22 +2619,22 @@ class RaceAll<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
     sink: Sink.Sink<Fx.Success<FX[number]>, Fx.Error<FX[number]>, R2>
   ): Effect.Effect<unknown, never, Fx.Context<FX[number]> | R2> {
     return Effect.gen(this, function*(_) {
-      const winner = yield* _(Deferred.make<Fiber.RuntimeFiber<unknown>>())
+      const winner = yield* Deferred.make<Fiber.RuntimeFiber<unknown>>()
       const fibers: Array<Fiber.RuntimeFiber<unknown>> = []
 
       for (const fx of this.i0) {
-        const fiber: Fiber.RuntimeFiber<unknown> = yield* _(Effect.fork(fx.run(Sink.make(
+        const fiber: Fiber.RuntimeFiber<unknown> = yield* Effect.fork(fx.run(Sink.make(
           sink.onFailure,
           (a) => Effect.flatMap(Deferred.succeed(winner, fiber), () => sink.onSuccess(a))
-        ))))
+        )))
         fibers.push(fiber)
       }
 
-      const winningFiber = yield* _(Deferred.await(winner))
+      const winningFiber = yield* Deferred.await(winner)
 
-      yield* _(Fiber.interruptAll(fibers.filter((x) => x !== winningFiber)))
+      yield* Fiber.interruptAll(fibers.filter((x) => x !== winningFiber))
 
-      return yield* _(Fiber.join(winningFiber))
+      return yield* Fiber.join(winningFiber)
     })
   }
 }
@@ -2644,7 +2678,7 @@ class Snapshot<A, E, R, B, E2, R2, C> extends FxBase<C, E | E2, R | R2> {
               Effect.flatMap(
                 Ref.get(ref),
                 Option.match({
-                  onNone: () => Effect.unit,
+                  onNone: () => Effect.void,
                   onSome: (b) => sink.onSuccess(this.i2(a, b))
                 })
               )
@@ -2688,7 +2722,7 @@ class SnapshotEffect<A, E, R, B, E2, R2, C, E3, R3> extends FxBase<C, E | E2 | E
                 Effect.flatMap(
                   Ref.get(ref),
                   Option.match({
-                    onNone: () => Effect.unit,
+                    onNone: () => Effect.void,
                     onSome: (b) => Effect.matchCauseEffect(this.i2(a, b), sink)
                   })
                 )))
@@ -2720,11 +2754,8 @@ export function when<B, E, R, C>(
     readonly onTrue: B
     readonly onFalse: C
   }
-): Fx<B | C, E, R | Scope.Scope> {
-  return if_(bool, {
-    onTrue: succeed(options.onTrue),
-    onFalse: succeed(options.onFalse)
-  })
+): Fx<B | C, E, R> {
+  return map(skipRepeatsWith(bool, boolean), (b) => (b ? options.onTrue : options.onFalse))
 }
 
 export function mapBoth<A, E, R, B, C>(

package/src/internal/diff.ts

@@ -1,5 +1,5 @@
-import type { Equivalence } from "effect"
 import * as Equal from "effect/Equal"
+import type * as Equivalence from "effect/Equivalence"
 import { identity } from "effect/Function"
 
 export type DiffResult<A, B> = ReadonlyArray<Diff<A, B>>

package/src/internal/effect-operator.ts

@@ -221,7 +221,7 @@ export function compileCauseEffectOperatorSink<R>(
             op.f(a),
             Sink.make(
               (cause2) => sink.onFailure(Cause.sequential(a, cause2)),
-              (b) => b ? sink.onFailure(a) : Effect.unit
+              (b) => b ? sink.onFailure(a) : Effect.void
             )
           ),
         sink.onSuccess
@@ -234,7 +234,7 @@ export function compileCauseEffectOperatorSink<R>(
             Sink.make(
               (cause2) => sink.onFailure(Cause.sequential(a, cause2)),
               Option.match({
-                onNone: () => Effect.unit,
+                onNone: () => Effect.void,
                 onSome: sink.onFailure
               })
             )

package/src/internal/effect-producer.ts

@@ -1,4 +1,4 @@
-import type { Cause } from "effect"
+import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Schedule from "effect/Schedule"
 import type * as Sink from "../Sink.js"
@@ -94,7 +94,7 @@ export function runEffect<A, E, R, B, E2, R2>(
           Effect.asyncEffect((resume) => {
             const onFailure = (cause: Cause.Cause<E | E2>) => Effect.succeed(resume(Effect.failCause(cause)))
 
-            return Effect.asUnit(Effect.matchCauseEffect(
+            return Effect.asVoid(Effect.matchCauseEffect(
               Effect.scheduleFrom(
                 producer.input,
                 i,
@@ -103,7 +103,7 @@ export function runEffect<A, E, R, B, E2, R2>(
                   (a) => Effect.catchAllCause(f(a), onFailure)
                 )
               ),
-              { onFailure, onSuccess: () => Effect.succeed(resume(Effect.unit)) }
+              { onFailure, onSuccess: () => Effect.succeed(resume(Effect.void)) }
             ))
           })
       )

package/src/internal/helpers.ts

@@ -1,65 +1,112 @@
 import { getOption } from "@typed/context"
-import { Equivalence, Unify } from "effect"
-import type { Duration, Exit } from "effect"
 import * as Cause from "effect/Cause"
+import * as Deferred from "effect/Deferred"
+import type * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import * as Equal from "effect/Equal"
+import * as Equivalence from "effect/Equivalence"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
 import * as FiberSet from "effect/FiberSet"
 import * as Option from "effect/Option"
 import * as Ref from "effect/Ref"
 import * as Scope from "effect/Scope"
 import * as SynchronizedRef from "effect/SynchronizedRef"
 import * as TestClock from "effect/TestClock"
+import * as Unify from "effect/Unify"
 import type { FlattenStrategy, FxFork, ScopedFork } from "../Fx.js"
 import type * as Sink from "../Sink.js"
 
-export function withBuffers<A, E, R>(size: number, sink: Sink.Sink<A, E, R>) {
-  const buffers: Array<Array<A>> = Array.from({ length: size }, () => [])
-  const finished = new Set<number>()
-  let currentIndex = 0
-
-  const drainBuffer = (index: number): Effect.Effect<void, never, R> => {
-    const effect = Effect.forEach(buffers[index], sink.onSuccess)
-    buffers[index] = []
-
-    return Effect.flatMap(effect, () => finished.has(index) ? onEnd(index) : Effect.unit)
-  }
-
-  const onSuccess = (index: number, value: A) => {
-    if (index === currentIndex) {
-      const buffer = buffers[index]
+export function withBuffers<A, E, R>(
+  size: number,
+  sink: Sink.Sink<A, E, R>,
+  id: FiberId.FiberId
+) {
+  const buffers = indexedBuffers(size, sink, id)
+  const onSuccess = (index: number, value: A) => buffers.get(index)!.onSuccess(value)
+  const onEnd = (index: number) => buffers.get(index)!.onEnd
 
-      if (buffer.length === 0) {
-        return sink.onSuccess(value)
-      } else {
-        buffer.push(value)
+  return {
+    onSuccess: (i: number, a: A) => onSuccess(i, a),
+    onEnd: (i: number) => onEnd(i)
+  } as const
+}
 
-        return drainBuffer(index)
-      }
-    } else {
-      buffers[index].push(value)
+function indexedBuffers<A, E, R>(
+  size: number,
+  sink: Sink.Sink<A, E, R>,
+  id: FiberId.FiberId
+) {
+  const buffers = new Map<number, ReturnType<typeof IndexedBuffer<A, E, R>>>()
+
+  const last = size - 1
+  for (let i = 0; i < size; i++) {
+    const deferred = Deferred.unsafeMake<void>(id)
+    const state = {
+      ready: i === 0,
+      deferred
+    }
 
-      return Effect.unit
+    // First should start immediately
+    if (i === 0) {
+      Deferred.unsafeDone(deferred, Exit.void)
     }
+
+    buffers.set(
+      i,
+      IndexedBuffer(
+        state,
+        sink,
+        i === last ? Effect.void : Effect.suspend(() => {
+          const next = buffers.get(i + 1)!
+          next.state.ready = true
+          return Deferred.done(next.state.deferred, Exit.void)
+        })
+      )
+    )
   }
 
-  const onEnd = (index: number) => {
-    finished.add(index)
+  return buffers
+}
 
-    if (index === currentIndex && ++currentIndex < size) {
-      return drainBuffer(currentIndex)
+function IndexedBuffer<A, E, R>(
+  state: {
+    ready: boolean
+    deferred: Deferred.Deferred<void>
+  },
+  sink: Sink.Sink<A, E, R>,
+  onDone: Effect.Effect<void>
+) {
+  let buffer: Array<A> = []
+
+  const onSuccess = (value: A) => {
+    if (state.ready) {
+      if (buffer.length === 0) return sink.onSuccess(value)
+      buffer.push(value)
+      const effect = Effect.forEach(buffer, sink.onSuccess)
+      buffer = []
+      return effect
     } else {
-      return Effect.unit
+      buffer.push(value)
+      return Effect.void
     }
   }
 
+  const onEnd = Effect.flatMap(Deferred.await(state.deferred), () => {
+    if (buffer.length === 0) return onDone
+    const effect = Effect.forEach(buffer, sink.onSuccess)
+    buffer = []
+    return Effect.zipRight(effect, onDone)
+  })
+
   return {
+    state,
     onSuccess,
     onEnd
-  } as const
+  }
 }
 
 export const withScope = <A, E, R>(
@@ -112,7 +159,7 @@ export function withSwitchFork<A, E, R>(
   return withScopedFork(
     (fork, scope) =>
       Effect.flatMap(
-        SynchronizedRef.make<Fiber.Fiber<unknown>>(Fiber.unit),
+        SynchronizedRef.make<Fiber.Fiber<unknown>>(Fiber.void),
         (ref) => runSwitchFork(ref, fork, scope, f)
       ),
     executionStrategy
@@ -164,7 +211,7 @@ export function withExhaustFork<A, E, R>(
                     )
                   )
             ), scope),
-          () => Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.unit)
+          () => Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.void)
         )
     )
   }, executionStrategy)
@@ -184,7 +231,7 @@ export function withExhaustLatestFork<A, E, R>(
         const reset = Ref.set(ref, undefined)
 
         // Wait for the current fiber to finish
-        const awaitNext = Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.unit)
+        const awaitNext = Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.void)
 
         // Run the next value that's be saved for replay if it exists
 
@@ -192,7 +239,7 @@ export function withExhaustLatestFork<A, E, R>(
           Ref.get(nextEffect),
           (next) => {
             if (Option.isNone(next)) {
-              return Effect.unit
+              return Effect.void
             }
 
             return Effect.all([
@@ -263,7 +310,7 @@ export function withBoundedFork(capacity: number) {
                   )
                 )
               ), scope),
-            () => Effect.flatMap(Ref.get(ref), (fibers) => fibers.size > 0 ? Fiber.joinAll(fibers) : Effect.unit)
+            () => Effect.flatMap(Ref.get(ref), (fibers) => fibers.size > 0 ? Fiber.joinAll(fibers) : Effect.void)
           )
       ), executionStrategy)
   }
@@ -355,7 +402,7 @@ export function tupleSink<A extends ReadonlyArray<any>, E, R, B, E2, R2>(
       if (values.size === expected) {
         return sink.onSuccess(getValues())
       } else {
-        return Effect.unit
+        return Effect.void
       }
     })
   })
@@ -385,7 +432,7 @@ export function withDebounceFork<A, E, R>(
             ),
             () =>
               SynchronizedRef.get(ref).pipe(Effect.flatMap(Option.match({
-                onNone: () => Effect.unit,
+                onNone: () => Effect.void,
                 onSome: Fiber.join
               })))
           )
@@ -422,7 +469,7 @@ export class RingBuffer<A> {
   ) {
     switch (this._size) {
       case 0:
-        return Effect.unit
+        return Effect.void
       case 1:
         return f(this._buffer[0], 0)
       case 2:
@@ -451,7 +498,7 @@ export class RingBuffer<A> {
 
 export function awaitScopeClose(scope: Scope.Scope) {
   return Effect.asyncEffect<unknown, never, never, never, never, never>((cb) =>
-    Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.unit)))
+    Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.void)))
   )
 }
 
@@ -484,7 +531,7 @@ export class MulticastEffect<A, E, R> extends Effectable.Class<A, E, R> {
       if (this._fiber) {
         return Fiber.interruptFork(this._fiber)
       } else {
-        return Effect.unit
+        return Effect.void
       }
     })
   }