@typed/fx 1.32.0 → 2.0.0-beta.0

package/src/Fx/Fx.ts

@@ -0,0 +1,164 @@
+import * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import type { Layer } from "effect/Layer";
+import { effect } from "effect/Layer";
+import { type Pipeable, pipeArguments } from "effect/Pipeable";
+import type * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import type * as Types from "effect/Types";
+import type * as Sink from "../Sink/Sink.js";
+import { provideServices } from "./combinators/provide.js";
+import { FxTypeId, isFx } from "./TypeId.js";
+
+/**
+ * `Fx` is a reactive stream of values that supports concurrency, error handling,
+ * and context management, fully integrated with the Effect ecosystem.
+ *
+ * Conceptually, an `Fx<A, E, R>` is a push-based stream that:
+ * - Emits values of type `A`
+ * - Can fail with an error of type `E`
+ * - Requires a context/environment of type `R`
+ *
+ * Unlike a standard `Effect` which produces a single value, `Fx` can produce
+ * 0, 1, or many values over time. It is similar to RxJS Observables or
+ * AsyncIterables, but built on top of Effect's fiber-based concurrency model.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Fx<A, E = never, R = never> extends Pipeable {
+  readonly [FxTypeId]: Fx.Variance<A, E, R>;
+  /**
+   * Runs the Fx stream by providing a Sink to consume the values.
+   * The result is an Effect that runs the stream process.
+   */
+  readonly run: <RSink>(sink: Sink.Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>;
+}
+
+export declare namespace Fx {
+  /**
+   * Any Fx type with wildcards.
+   * @since 1.0.0
+   * @category models
+   */
+  export type Any = Fx<any, any, any>;
+
+  /**
+   * Variance markers for Fx types.
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Variance<A, E, R> {
+    readonly _A: Types.Covariant<A>;
+    readonly _E: Types.Covariant<E>;
+    readonly _R: Types.Covariant<R>;
+  }
+
+  /**
+   * Extract the success type from an Fx.
+   * @since 1.0.0
+   * @category type-level
+   */
+  export type Success<T> = [T] extends [never]
+    ? never
+    : T extends Fx<infer _A, infer _E, infer _R>
+      ? _A
+      : never;
+
+  /**
+   * Extract the error type from an Fx.
+   * @since 1.0.0
+   * @category type-level
+   */
+  export type Error<T> = [T] extends [never]
+    ? never
+    : T extends Fx<infer _A, infer _E, infer _R>
+      ? _E
+      : never;
+
+  /**
+   * Extract the required services from an Fx.
+   * @since 1.0.0
+   * @category type-level
+   */
+  export type Services<T> = [T] extends [never]
+    ? never
+    : [T] extends [Fx<infer _A, infer _E, infer _R>]
+      ? _R
+      : never;
+
+  export interface Service<Self, Id extends string, A, E> extends Fx<A, E, Self> {
+    readonly id: Id;
+    readonly service: ServiceMap.Service<Self, Fx<A, E>>;
+    readonly make: <R = never>(
+      fx: Fx<A, E, R> | Effect.Effect<Fx<A, E, R>, E, R>,
+    ) => Layer<Self, E, Exclude<R, Scope.Scope>>;
+  }
+
+  export interface Class<Self, Id extends string, A, E> extends Service<Self, Id, A, E> {
+    new (): Service<Self, Id, A, E>;
+  }
+}
+
+/**
+ * Extract the success type from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Success<T> = Fx.Success<T>;
+
+/**
+ * Extract the error type from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Error<T> = Fx.Error<T>;
+
+/**
+ * Extract the required services from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Services<T> = Fx.Services<T>;
+
+const VARIANCE: Fx.Variance<any, any, any> = {
+  _A: identity,
+  _E: identity,
+  _R: identity,
+};
+
+export function Service<Self, A, E = never>() {
+  return <const Id extends string>(id: Id): Fx.Class<Self, Id, A, E> => {
+    const service = ServiceMap.Service<Self, Fx<A, E>>(id);
+
+    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+    return class FxService {
+      static readonly id = id;
+      static readonly service = service;
+
+      static readonly make = <R = never>(
+        fx: Fx<A, E, R> | Effect.Effect<Fx<A, E, R>, E, R>,
+      ): Layer<Self, E, Exclude<R, Scope.Scope>> =>
+        effect(
+          service,
+          Effect.gen(function* () {
+            const services = yield* Effect.services<R>();
+            const result = isFx(fx) ? fx : yield* fx;
+            return provideServices(result, services);
+          }),
+        );
+
+      static readonly [FxTypeId] = VARIANCE;
+      static readonly pipe = function (this: any) {
+        return pipeArguments(this, arguments);
+      };
+
+      static readonly run = <RSink>(sink: Sink.Sink<A, E, RSink>) =>
+        Effect.flatMap(service.asEffect(), (fx) => fx.run(sink));
+
+      constructor() {
+        return FxService;
+      }
+    } as unknown as Fx.Class<Self, Id, A, E>;
+  };
+}

package/src/Fx/TypeId.ts

@@ -0,0 +1,25 @@
+import { hasProperty } from "effect/Predicate";
+import type { Fx } from "./Fx.js";
+
+/**
+ * The unique type identifier for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export const FxTypeId = Symbol.for("@typed/fx/Fx");
+
+/**
+ * The unique type identifier type for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export type FxTypeId = typeof FxTypeId;
+
+/**
+ * Checks if a value is an Fx.
+ * @since 1.0.0
+ * @category guards
+ */
+export function isFx(u: unknown): u is Fx<any, any, any> {
+  return hasProperty(u, FxTypeId);
+}

package/src/Fx/combinators/catch.ts

@@ -0,0 +1,165 @@
+import type * as Arr from "effect/Array";
+import * as Cause from "effect/Cause";
+import { dual } from "effect/Function";
+import * as Result from "effect/Result";
+import type { ExcludeTag, ExtractTag, NoInfer, Tags } from "effect/Types";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+
+const hasTag = (u: unknown): u is { readonly _tag: string } =>
+  typeof u === "object" &&
+  u !== null &&
+  "_tag" in u &&
+  typeof (u as Record<string, unknown>)["_tag"] === "string";
+
+const matchesTag = <E, K extends string>(
+  tag: K | Arr.NonEmptyReadonlyArray<K>,
+  error: E,
+): error is ExtractTag<E, K> => {
+  if (!hasTag(error)) return false;
+  if (typeof tag === "string") return error._tag === tag;
+  return tag.some((t) => t === error._tag);
+};
+
+/**
+ * Recovers from a typed failure of an Fx by switching to a fallback Fx.
+ *
+ * Mirrors `Effect.catch` / `Effect.catchAll` (catches `Cause.Fail` only).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catch_: {
+  <E, A2, E2, R2>(f: (e: E) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
+
+  <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2> =>
+    make<A | A2, E2, R | R2>((sink) =>
+      self.run(
+        makeSink((cause) => {
+          const result = Cause.findFail(cause);
+          if (Result.isFailure(result)) {
+            return sink.onFailure(result.failure);
+          }
+          return f(result.success.error).run(sink);
+        }, sink.onSuccess),
+      ),
+    ),
+);
+
+export { catch_ as catch };
+
+/**
+ * An alias for {@link catch}.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchAll = catch_;
+
+/**
+ * Recovers from *any* failure cause of an Fx (including defects and interrupts)
+ * by switching to a fallback Fx.
+ *
+ * Mirrors `Effect.catchCause`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchCause: {
+  <E, A2, E2, R2>(
+    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
+  ): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
+
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
+  ): Fx<A | A2, E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
+  ): Fx<A | A2, E2, R | R2> =>
+    make<A | A2, E2, R | R2>((sink) =>
+      self.run(makeSink((cause) => f(cause).run(sink), sink.onSuccess)),
+    ),
+);
+
+/**
+ * Recovers from a typed failure by matching on the `_tag` field of the error.
+ *
+ * Mirrors `Effect.catchTag`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchTag: {
+  <const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, E, A2, E2, R2>(
+    k: K,
+    f: (
+      e: ExtractTag<NoInfer<E>, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
+    ) => Fx<A2, E2, R2>,
+  ): <A, R>(
+    self: Fx<A, E, R>,
+  ) => Fx<
+    A | A2,
+    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
+    R | R2
+  >;
+
+  <A, E, R, const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    k: K,
+    f: (
+      e: ExtractTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
+    ) => Fx<A2, E2, R2>,
+  ): Fx<
+    A | A2,
+    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
+    R | R2
+  >;
+} = dual(
+  3,
+  <A, E, R, const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    k: K,
+    f: (
+      e: ExtractTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
+    ) => Fx<A2, E2, R2>,
+  ): Fx<
+    A | A2,
+    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
+    R | R2
+  > =>
+    make<
+      A | A2,
+      E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
+      R | R2
+    >((sink) =>
+      self.run(
+        makeSink((cause) => {
+          const result = Cause.findFail(cause);
+          if (Result.isFailure(result)) {
+            return sink.onFailure(result.failure);
+          } else if (matchesTag(k, result.success.error)) {
+            return f(
+              result.success.error as ExtractTag<
+                E,
+                K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K
+              >,
+            ).run(sink);
+          } else {
+            return sink.onFailure(
+              cause as Cause.Cause<
+                E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>
+              >,
+            );
+          }
+        }, sink.onSuccess),
+      ),
+    ),
+);

package/src/Fx/combinators/causes.ts

@@ -0,0 +1,23 @@
+import type * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import type { Fx } from "../Fx.js";
+import { exit } from "./exit.js";
+import { filterMap } from "./filterMap.js";
+
+/**
+ * Emits only the failure causes from an Fx, discarding successful values.
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` emitting `Cause<E>`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const causes = <A, E, R>(fx: Fx<A, E, R>): Fx<Cause.Cause<E>, never, R> =>
+  filterMap(
+    exit(fx),
+    Exit.match({
+      onFailure: Option.some,
+      onSuccess: Option.none,
+    }),
+  );

package/src/Fx/combinators/compact.ts

@@ -0,0 +1,15 @@
+import type * as Option from "effect/Option";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * Compacts an Fx of Options, discarding `None` values and unwrapping `Some` values.
+ *
+ * @param self - An `Fx` emitting `Option<A>`.
+ * @returns An `Fx` emitting `A`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const compact = <A, E, R>(self: Fx<Option.Option<A>, E, R>): Fx<A, E, R> =>
+  make<A, E, R>((sink) => self.run(sinkCore.compact(sink)));

package/src/Fx/combinators/continueWith.ts

@@ -0,0 +1,78 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import { make } from "../constructors/make.js";
+import { succeed } from "../constructors/succeed.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * continues an Fx with another Fx after the first one completes.
+ *
+ * @param f - A function that returns the next Fx to run.
+ * @returns An `Fx` that emits values from the first Fx, then from the second Fx.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const continueWith: {
+  <B, E2, R2>(f: () => Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
+
+  <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2> =>
+    make<A | B, E | E2, R | R2>((sink) => Effect.flatMap(fx.run(sink), () => f().run(sink))),
+);
+
+/**
+ * Appends a value to the end of an Fx.
+ *
+ * @param value - The value to append.
+ * @returns An `Fx` that emits values from the input Fx, then the appended value.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const append: {
+  <B>(value: B): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E, R>;
+
+  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<A | B, E, R>;
+} = dual(
+  2,
+  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<A | B, E, R> =>
+    continueWith(fx, () => succeed(value)),
+);
+
+/**
+ * Prepends a value to the beginning of an Fx.
+ *
+ * @param value - The value to prepend.
+ * @returns An `Fx` that emits the prepended value, then values from the input Fx.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const prepend: {
+  <B>(value: B): <A, E, R>(fx: Fx<A, E, R>) => Fx<B | A, E, R>;
+
+  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<B | A, E, R>;
+} = dual(
+  2,
+  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<B | A, E, R> =>
+    continueWith(succeed(value), () => fx),
+);
+
+/**
+ * Wraps an Fx with a start and end value.
+ *
+ * @param before - The value to emit before the Fx starts.
+ * @param after - The value to emit after the Fx completes.
+ * @returns An `Fx` that emits `before`, then values from the input Fx, then `after`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const delimit: {
+  <B, C>(before: B, after: C): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B | C, E, R>;
+
+  <A, E, R, B, C>(fx: Fx<A, E, R>, before: B, after: C): Fx<A | B | C, E, R>;
+} = dual(
+  3,
+  <A, E, R, B, C>(fx: Fx<A, E, R>, before: B, after: C): Fx<A | B | C, E, R> =>
+    fx.pipe(prepend(before), append(after)),
+);

package/src/Fx/combinators/ensuring.ts

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * Adds an `Effect.ensuring`-style finalizer to an `Fx`.
+ *
+ * The finalizer is guaranteed to run when the stream terminates (success,
+ * failure, or interruption).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const ensuring: {
+  <R2>(finalizer: Effect.Effect<void, never, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
+
+  <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<void, never, R2>): Fx<A, E, R | R2>;
+} = dual(
+  2,
+  <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<void, never, R2>): Fx<A, E, R | R2> =>
+    make<A, E, R | R2>((sink) => self.run(sink).pipe(Effect.ensuring(finalizer))),
+);

package/src/Fx/combinators/exhaustLatestMap.ts

@@ -0,0 +1,74 @@
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import { make as makeSink, type Sink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+import { extendScope } from "../internal/scope.js";
+import type { FlatMapLike } from "./flatMap.js";
+
+/**
+ * Maps each element of an Fx to a new Fx, but only runs one inner Fx at a time.
+ * If a new element arrives while an inner Fx is running, the new element is buffered (overwriting any previously buffered value).
+ * When the current inner Fx completes, the latest buffered Fx is run.
+ *
+ * This is useful for scenarios where you want to ignore intermediate values but ensure the latest value is eventually processed.
+ *
+ * @param f - A function that maps an element `A` to a new `Fx<B>`.
+ * @returns An `Fx` that emits values from the inner streams.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const exhaustLatestMap: FlatMapLike = dual(
+  2,
+  <A, E, R, B, E2, R2>(
+    self: Fx<A, E, R>,
+    f: (a: A) => Fx<B, E2, R2>,
+  ): Fx<B, E | E2, R | R2 | Scope.Scope> => {
+    return make<B, E | E2, R | R2 | Scope.Scope>(
+      Effect.fn(function* <RSink>(sink: Sink<B, E | E2, RSink>) {
+        let runningFiber: Fiber.Fiber<unknown, never> | undefined = undefined;
+        let nextEffectToFork: Effect.Effect<unknown, never, R2 | RSink> | undefined = undefined;
+
+        const scope = yield* Effect.scope;
+
+        const fork = (
+          effect: Effect.Effect<unknown, never, R2 | RSink>,
+        ): Effect.Effect<Fiber.Fiber<unknown, never>, never, RSink | R2> =>
+          Effect.forkIn(
+            effect.pipe(Effect.ensuring(Effect.zip(resetRunningFiber, runNext))),
+            scope,
+          );
+
+        const resetRunningFiber: Effect.Effect<void, never, never> = Effect.sync(
+          () => (runningFiber = undefined),
+        );
+
+        const runNext: Effect.Effect<void, never, R2 | RSink> = Effect.gen(function* () {
+          if (nextEffectToFork !== undefined) {
+            const eff = nextEffectToFork;
+            nextEffectToFork = undefined;
+            yield* exhaustLatestFork(eff);
+            // Ensure we don't close the scope until the last fiber completes
+            if (runningFiber !== undefined) yield* Fiber.join(runningFiber);
+          }
+        });
+
+        const exhaustLatestFork = Effect.fn(function* (
+          eff: Effect.Effect<void, never, R2 | RSink>,
+        ) {
+          if (runningFiber === undefined) {
+            runningFiber = yield* fork(eff);
+          } else {
+            nextEffectToFork = eff;
+          }
+        });
+
+        yield* self.run(makeSink(sink.onFailure, (a) => exhaustLatestFork(f(a).run(sink))));
+
+        if (runningFiber !== undefined) yield* Fiber.join(runningFiber as Fiber.Fiber<void, never>);
+      }, extendScope),
+    );
+  },
+);

package/src/Fx/combinators/exhaustLatestMapEffect.ts

@@ -0,0 +1,25 @@
+import type * as Effect from "effect/Effect";
+import { dual, flow } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import { fromEffect } from "../constructors/fromEffect.js";
+import type { Fx } from "../Fx.js";
+import { exhaustLatestMap } from "./exhaustLatestMap.js";
+import type { FlatMapEffectLike } from "./flatMapEffect.js";
+
+/**
+ * Maps each element of an Fx to an Effect, but only runs one effect at a time.
+ * If a new element arrives while an effect is running, the new element is buffered (overwriting any previously buffered value).
+ * When the current effect completes, the latest buffered effect is run.
+ *
+ * @param f - A function that maps an element `A` to an `Effect<B>`.
+ * @returns An `Fx` that emits the results of the effects.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const exhaustLatestMapEffect: FlatMapEffectLike = dual(
+  2,
+  <A, E, R, B, E2, R2>(
+    self: Fx<A, E, R>,
+    f: (a: A) => Effect.Effect<B, E2, R2>,
+  ): Fx<B, E | E2, R | R2 | Scope.Scope> => exhaustLatestMap(self, flow(f, fromEffect)),
+);

package/src/Fx/combinators/exhaustMap.ts

@@ -0,0 +1,36 @@
+import * as Effect from "effect/Effect";
+import * as FiberHandle from "effect/FiberHandle";
+import { dual } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+import { extendScope } from "../internal/scope.js";
+import type { FlatMapLike } from "./flatMap.js";
+
+/**
+ * Maps each element of an Fx to a new Fx, ignoring new elements until the current inner Fx completes.
+ *
+ * @param f - A function that maps an element `A` to a new `Fx<B>`.
+ * @returns An `Fx` that emits values from the active inner stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const exhaustMap: FlatMapLike = dual(
+  2,
+  <A, E, R, B, E2, R2>(
+    self: Fx<A, E, R>,
+    f: (a: A) => Fx<B, E2, R2>,
+  ): Fx<B, E | E2, R | R2 | Scope.Scope> =>
+    make<B, E | E2, R | R2 | Scope.Scope>(
+      Effect.fn(function* (sink) {
+        const handle = yield* FiberHandle.make<void, never>();
+        yield* self.run(
+          makeSink(sink.onFailure, (a) =>
+            FiberHandle.run(handle, f(a).run(sink), { onlyIfMissing: true }),
+          ),
+        );
+        yield* FiberHandle.awaitEmpty(handle);
+      }, extendScope),
+    ),
+);

package/src/Fx/combinators/exhaustMapEffect.ts

@@ -0,0 +1,23 @@
+import type * as Effect from "effect/Effect";
+import { dual, flow } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import { fromEffect } from "../constructors/fromEffect.js";
+import type { Fx } from "../Fx.js";
+import { exhaustMap } from "./exhaustMap.js";
+import type { FlatMapEffectLike } from "./flatMapEffect.js";
+
+/**
+ * Maps each element of an Fx to an Effect, ignoring new elements until the current effect completes.
+ *
+ * @param f - A function that maps an element `A` to an `Effect<B>`.
+ * @returns An `Fx` that emits the results of the active effect.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const exhaustMapEffect: FlatMapEffectLike = dual(
+  2,
+  <A, E, R, B, E2, R2>(
+    self: Fx<A, E, R>,
+    f: (a: A) => Effect.Effect<B, E2, R2>,
+  ): Fx<B, E | E2, R | R2 | Scope.Scope> => exhaustMap(self, flow(f, fromEffect)),
+);

package/src/Fx/combinators/exit.ts

@@ -0,0 +1,15 @@
+import type * as Exit from "effect/Exit";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * Materializes the success and failure of an Fx into `Exit` values.
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` emitting `Exit<A, E>`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const exit = <A, E, R>(fx: Fx<A, E, R>): Fx<Exit.Exit<A, E>, never, R> =>
+  make<Exit.Exit<A, E>, never, R>((sink) => fx.run(sinkCore.exit(sink)));