@typed/fx 1.20.4 → 1.20.6

package/src/Emitter.ts

@@ -3,10 +3,12 @@
  * @since 1.20.0
  */
 
+import { ExecutionStrategy, type Scope } from "effect"
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import type * as Exit from "effect/Exit"
 import * as Runtime from "effect/Runtime"
+import { withScope } from "./internal/helpers.js"
 import * as Sink from "./Sink.js"
 
 /**
@@ -26,22 +28,31 @@ export interface Emitter<in E, in A> {
 export function withEmitter<R, E, A, R2, B>(
   sink: Sink.Sink<R, E, A>,
   f: (emitter: Emitter<E, A>) => Effect.Effect<R2, E, B>
-): Effect.Effect<R | R2, never, void> {
-  return Sink.withEarlyExit(
-    sink,
-    (sink): Effect.Effect<R | R2, E, B> => {
-      return Effect.flatMap(Effect.runtime<R>(), (runtime) => {
-        const run = Runtime.runPromiseExit(runtime)
-        const emitter: Emitter<E, A> = {
-          succeed: (value) => run(sink.onSuccess(value)),
-          failCause: (cause) => run(sink.onFailure(cause)),
-          fail: (error) => run(sink.onFailure(Cause.fail(error))),
-          die: (error) => run(sink.onFailure(Cause.die(error))),
-          end: () => run(sink.earlyExit)
-        }
+): Effect.Effect<R | R2 | Scope.Scope, never, void> {
+  return withScope(
+    (scope) =>
+      Sink.withEarlyExit(
+        sink,
+        (sink): Effect.Effect<R | R2, E, B> => {
+          return Effect.flatMap(Effect.runtime<R>(), (runtime) => {
+            const runFork = Runtime.runFork(runtime)
+            const run = <E, A>(effect: Effect.Effect<R, E, A>): Promise<Exit.Exit<E, A>> =>
+              new Promise((resolve) => {
+                const fiber = runFork(effect, { scope })
+                fiber.addObserver(resolve)
+              })
+            const emitter: Emitter<E, A> = {
+              succeed: (value) => run(sink.onSuccess(value)),
+              failCause: (cause) => run(sink.onFailure(cause)),
+              fail: (error) => run(sink.onFailure(Cause.fail(error))),
+              die: (error) => run(sink.onFailure(Cause.die(error))),
+              end: () => run(sink.earlyExit)
+            }
 
-        return f(emitter)
-      })
-    }
+            return f(emitter)
+          })
+        }
+      ),
+    ExecutionStrategy.sequential
   )
 }

package/src/Fx.ts

@@ -2384,7 +2384,7 @@ export const when: {
  */
 export const withEmitter = <E, A, R = never, E2 = never>(
   f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R, E2, unknown>
-): Fx<R, E | E2, A> => core.make<R, E | E2, A>((sink) => Emitter.withEmitter(sink, f))
+): Fx<R | Scope.Scope, E | E2, A> => core.make<R | Scope.Scope, E | E2, A>((sink) => Emitter.withEmitter(sink, f))
 
 /**
  * Create an Fx which will wait a specified duration of time where no