@typed/fx 1.32.0 → 2.0.0-beta.1

package/src/Fx/run/collect.ts

@@ -0,0 +1,79 @@
+import * as Effect from "effect/Effect";
+import type * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import { take } from "../combinators/take.js";
+import type { Fx } from "../Fx.js";
+import { observe } from "./observe.js";
+
+/**
+ * Collects all values emitted by an `Fx` into an array.
+ *
+ * @param fx - The `Fx` to collect values from.
+ * @returns An `Effect` that produces an array of all values when the `Fx` completes.
+ * @since 1.0.0
+ * @category runners
+ */
+export const collectAll = <A, E = never, R = never>(
+  fx: Fx<A, E, R>,
+): Effect.Effect<ReadonlyArray<A>, E, R> =>
+  Effect.suspend(() => {
+    const values: Array<A> = [];
+
+    return fx.pipe(
+      observe((value) => Effect.sync(() => values.push(value))),
+      (_) => Effect.map(_.asEffect(), () => values),
+    );
+  });
+
+/**
+ * Forks the collection of all values from an `Fx`.
+ *
+ * @param fx - The `Fx` to collect values from.
+ * @returns An `Effect` that produces a `Fiber` which computes the array of values.
+ * @since 1.0.0
+ * @category runners
+ */
+export const collectAllFork = <A, E = never, R = never>(
+  fx: Fx<A, E, R>,
+): Effect.Effect<Fiber.Fiber<ReadonlyArray<A>, E>, never, R> =>
+  Effect.forkChild(collectAll(fx), {
+    startImmediately: true,
+    uninterruptible: false,
+  });
+
+/**
+ * Collects the first `n` values emitted by an `Fx` into an array.
+ *
+ * @param fx - The `Fx` to collect values from.
+ * @param upTo - The maximum number of values to collect.
+ * @returns An `Effect` that produces an array of up to `n` values.
+ * @since 1.0.0
+ * @category runners
+ */
+export const collectUpTo: {
+  (upTo: number): <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
+
+  <A, E, R>(fx: Fx<A, E, R>, upTo: number): Effect.Effect<ReadonlyArray<A>, E, R>;
+} = dual(
+  2,
+  <A, E, R>(fx: Fx<A, E, R>, upTo: number): Effect.Effect<ReadonlyArray<A>, E, R> =>
+    fx.pipe(take(upTo), collectAll),
+);
+
+/**
+ * Forks the collection of up to `n` values from an `Fx`.
+ *
+ * @param fx - The `Fx` to collect values from.
+ * @param upTo - The maximum number of values to collect.
+ * @returns An `Effect` that produces a `Fiber` which computes the array of values.
+ * @since 1.0.0
+ * @category runners
+ */
+export const collectUpToFork = <A, E = never, R = never>(
+  fx: Fx<A, E, R>,
+  upTo: number,
+): Effect.Effect<Fiber.Fiber<ReadonlyArray<A>, E>, never, R> =>
+  Effect.forkChild(collectUpTo(fx, upTo), {
+    startImmediately: true,
+    uninterruptible: false,
+  });

package/src/Fx/run/first.ts

@@ -0,0 +1,20 @@
+import { head } from "effect/Array";
+import type { Effect } from "effect/Effect";
+import { map } from "effect/Effect";
+import { pipe } from "effect/Function";
+import type { Option } from "effect/Option";
+import type { Fx } from "../Fx.js";
+import { collectUpTo } from "./collect.js";
+
+/**
+ * Returns the first value emitted by the `Fx` wrapped in an `Option`.
+ * If the `Fx` is empty, returns `None`.
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Effect` that produces `Some(firstValue)` or `None`.
+ * @since 1.0.0
+ * @category runners
+ */
+export function first<A, E, R>(fx: Fx<A, E, R>): Effect<Option<A>, E, R> {
+  return pipe(fx, collectUpTo(1), map(head));
+}

package/src/Fx/run/fork.ts

@@ -0,0 +1,40 @@
+import type { Effect, RunOptions } from "effect/Effect";
+import { forkChild as effectFork, runFork as effectRunFork } from "effect/Effect";
+import type { Fiber } from "effect/Fiber";
+import type { Fx } from "../Fx.js";
+import { drain } from "./observe.js";
+
+/**
+ * Forks the execution of an `Fx` into a background fiber.
+ * The stream will run until it completes or the fiber is interrupted.
+ *
+ * @param fx - The `Fx` stream to fork.
+ * @param options - Configuration for the forked fiber.
+ * @returns An `Effect` that produces a `Fiber`.
+ * @since 1.0.0
+ * @category runners
+ */
+export const fork = <A, E, R>(
+  fx: Fx<A, E, R>,
+  options?: {
+    readonly startImmediately?: boolean;
+    readonly uninterruptible?: boolean;
+  },
+): Effect<Fiber<unknown, E>, never, R> =>
+  effectFork(drain(fx), {
+    startImmediately: options?.startImmediately ?? true,
+    uninterruptible: options?.uninterruptible ?? false,
+  });
+
+/**
+ * Runs an `Fx` in a new fiber, using the standard `Effect.runFork`.
+ * This is useful for integrating with the top-level Effect runtime.
+ *
+ * @param fx - The `Fx` stream to run.
+ * @param options - `RunOptions` for the execution.
+ * @returns The created `Fiber`.
+ * @since 1.0.0
+ * @category runners
+ */
+export const runFork = <A, E>(fx: Fx<A, E>, options?: RunOptions): Fiber<void, E> =>
+  effectRunFork(drain(fx), options);

package/src/Fx/run/index.ts

@@ -0,0 +1,5 @@
+export * from "./collect.js";
+export * from "./first.js";
+export * from "./fork.js";
+export * from "./observe.js";
+export * from "./runPromise.js";

package/src/Fx/run/observe.ts

@@ -0,0 +1,114 @@
+import type { Cause } from "effect/Cause";
+import type { Effect } from "effect/Effect";
+import {
+  callback,
+  catchCause,
+  failCause,
+  forkChild,
+  isEffect,
+  matchCauseEffect,
+  runForkWith,
+  servicesWith,
+  sync,
+  void as void_,
+} from "effect/Effect";
+import { interrupt } from "effect/Fiber";
+import { dual } from "effect/Function";
+import type { Layer } from "effect/Layer";
+import { effectDiscard } from "effect/Layer";
+import type { Scope } from "effect/Scope";
+import { make } from "../../Sink/Sink.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * Observes the values of an `Fx` stream using a callback function.
+ * The callback can return `void` or an `Effect` which will be executed for each value.
+ *
+ * @param fx - The `Fx` stream to observe.
+ * @param f - The function to call for each emitted value.
+ * @returns An `Effect` that completes when the stream ends.
+ * @since 1.0.0
+ * @category runners
+ */
+export const observe: {
+  <A, E2 = never, R2 = never>(
+    f: (value: A) => void | Effect<unknown, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Effect<unknown, E | E2, R | R2>;
+
+  <A, E, R, E2 = never, R2 = never>(
+    fx: Fx<A, E, R>,
+    f: (value: A) => void | Effect<unknown, E2, R2>,
+  ): Effect<unknown, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2 = never, R2 = never>(
+    fx: Fx<A, E, R>,
+    f: (value: A) => void | Effect<unknown, E2, R2>,
+  ): Effect<unknown, E | E2, R | R2> =>
+    servicesWith((services) =>
+      callback<void, E | E2, R | R2>((resume) => {
+        const onFailure = (cause: Cause<E | E2>) => sync(() => resume(failCause(cause)));
+        const onSuccess = (value: A) => {
+          const result = f(value);
+          return isEffect(result) ? catchCause(result, onFailure) : void_;
+        };
+        const onDone = () => sync(() => resume(void_));
+
+        return fx.run(make(onFailure, onSuccess)).pipe(
+          matchCauseEffect(make(onFailure, onDone)),
+          runForkWith(services),
+          interrupt, // Interrupt fiber when callback is interrupted
+        );
+      }),
+    ),
+);
+
+/**
+ * Runs an `Fx` stream to completion, discarding all values.
+ * Useful when the side effects of the stream are all that matter.
+ *
+ * @param fx - The `Fx` stream to drain.
+ * @returns An `Effect` that completes when the stream ends.
+ * @since 1.0.0
+ * @category runners
+ */
+export const drain = <A, E, R>(fx: Fx<A, E, R>): Effect<void, E, R> => observe(fx, () => void_);
+
+/**
+ * Runs an `Fx` stream as a Layer.
+ * The stream is forked in the background when the layer is acquired.
+ *
+ * @param fx - The `Fx` stream to run.
+ * @returns A `Layer` that manages the background execution of the stream.
+ * @since 1.0.0
+ * @category runners
+ */
+export const drainLayer = <A, E, R>(fx: Fx<A, E, R>): Layer<never, E, Exclude<R, Scope>> =>
+  effectDiscard(forkChild(drain(fx)));
+
+/**
+ * Observes the values of an `Fx` stream using a callback function and returns a `Layer`.
+ * The callback can return `void` or an `Effect` which will be executed for each value.
+ *
+ * @param fx - The `Fx` stream to observe.
+ * @param f - The function to call for each emitted value.
+ * @returns A `Layer` that manages the background execution of the stream.
+ * @since 1.0.0
+ * @category runners
+ */
+export const observeLayer: {
+  <A, E2 = never, R2 = never>(
+    f: (value: A) => void | Effect<unknown, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Layer<never, E | E2, Exclude<R | R2, Scope>>;
+
+  <A, E, R, E2 = never, R2 = never>(
+    fx: Fx<A, E, R>,
+    f: (value: A) => void | Effect<unknown, E2, R2>,
+  ): Layer<never, E | E2, Exclude<R | R2, Scope>>;
+} = dual(
+  2,
+  <A, E, R, E2 = never, R2 = never>(
+    fx: Fx<A, E, R>,
+    f: (value: A) => void | Effect<unknown, E2, R2>,
+  ): Layer<never, E | E2, Exclude<R | R2, Scope>> => effectDiscard(observe(fx, f)),
+);

package/src/Fx/run/runPromise.ts

@@ -0,0 +1,32 @@
+import type { RunOptions } from "effect/Effect";
+import * as Effect from "effect/Effect";
+import type * as Exit from "effect/Exit";
+import type { Fx } from "../Fx.js";
+import { drain } from "./observe.js";
+
+/**
+ * Runs an `Fx` stream to completion and returns a Promise of the Exit.
+ *
+ * @param fx - The `Fx` stream to run.
+ * @param options - `RunOptions` for execution.
+ * @returns A Promise resolving to the `Exit` of the execution.
+ * @since 1.0.0
+ * @category runners
+ */
+export const runPromiseExit = <A, E>(
+  fx: Fx<A, E>,
+  options?: RunOptions,
+): Promise<Exit.Exit<void, E>> => Effect.runPromiseExit(drain(fx), options);
+
+/**
+ * Runs an `Fx` stream to completion and returns a Promise.
+ * Rejects if the stream fails.
+ *
+ * @param fx - The `Fx` stream to run.
+ * @param options - `RunOptions` for execution.
+ * @returns A Promise that resolves when the stream completes.
+ * @since 1.0.0
+ * @category runners
+ */
+export const runPromise = <A, E>(fx: Fx<A, E>, options?: RunOptions): Promise<unknown> =>
+  Effect.runPromise(drain(fx), options);

package/src/Fx/stream.ts

@@ -0,0 +1,42 @@
+import type * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+import * as Sink from "../Sink/Sink.js";
+import { make } from "./constructors/make.js";
+import type * as Fx from "./Fx.js";
+
+export type ToStreamOptions = Parameters<typeof Stream.callback<unknown, unknown, unknown>>[1];
+
+export const toStream = <A, E, R>(
+  fx: Fx.Fx<A, E, R>,
+  options?: ToStreamOptions,
+): Stream.Stream<A, E, R> =>
+  Stream.callback<A, E, R>(
+    (queue) =>
+      fx.run(
+        Sink.make(
+          (cause) => Queue.failCause(queue, cause),
+          (value) => Queue.offer(queue, value),
+        ),
+      ),
+    options,
+  );
+
+export type FromStreamOptions = Parameters<
+  typeof Stream.mapEffect<unknown, unknown, unknown, unknown>
+>[1];
+
+export const fromStream = <A, E, R>(
+  stream: Stream.Stream<A, E, R>,
+  options?: FromStreamOptions,
+): Fx.Fx<A, E, R> =>
+  make<A, E, R>(
+    <RSink = never>(sink: Sink.Sink<A, E, RSink>): Effect.Effect<unknown, never, R | RSink> =>
+      pipe(
+        stream,
+        Stream.mapEffect(sink.onSuccess, options),
+        Stream.catchCause((cause) => Stream.fromEffect(sink.onFailure(cause))),
+        Stream.runDrain,
+      ),
+  );

package/src/Fx.additive-combinators.test.ts

@@ -0,0 +1,126 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { concat, merge } from "./Fx/combinators/additive.js";
+import { Fx } from "./index.js";
+
+describe("Fx additive combinators", () => {
+  describe("merge (binary)", () => {
+    it("emits values from both streams and completes when both complete", () =>
+      Effect.gen(function* () {
+        const fx1 = Fx.fromIterable([1, 2]);
+        const fx2 = Fx.fromIterable([3, 4]);
+        const merged = merge(fx1, fx2);
+        const result = yield* Fx.collectAll(merged);
+        assert.strictEqual(result.length, 4);
+        assert.deepStrictEqual(
+          [...result].sort((a, b) => a - b),
+          [1, 2, 3, 4],
+        );
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when both streams are empty", () =>
+      Effect.gen(function* () {
+        const merged = merge(Fx.fromIterable([]), Fx.fromIterable([]));
+        const result = yield* Fx.collectAll(merged);
+        assert.deepStrictEqual(result, []);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when first stream fails", () =>
+      Effect.gen(function* () {
+        const failFx = Fx.fail("err" as const);
+        const goodFx = Fx.fromIterable([1, 2]);
+        const merged = merge(failFx, goodFx);
+        const exit = yield* Effect.exit(Fx.collectAll(merged));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when second stream fails", () =>
+      Effect.gen(function* () {
+        const goodFx = Fx.fromIterable([1, 2]);
+        const failFx = Fx.fail("err" as const);
+        const merged = merge(goodFx, failFx);
+        const exit = yield* Effect.exit(Fx.collectAll(merged));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("concat", () => {
+    it("emits first stream then second stream in order", () =>
+      Effect.gen(function* () {
+        const fx1 = Fx.fromIterable([1, 2]);
+        const fx2 = Fx.fromIterable([3, 4]);
+        const concatenated = concat(fx1, fx2);
+        const result = yield* Fx.collectAll(concatenated);
+        assert.deepStrictEqual(result, [1, 2, 3, 4]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when second stream completes", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fromIterable([1]), Fx.fromIterable([2, 3]));
+        const result = yield* Fx.collectAll(concatenated);
+        assert.deepStrictEqual(result, [1, 2, 3]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when first stream fails (second never runs)", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fail("err" as const), Fx.fromIterable([1, 2]));
+        const exit = yield* Effect.exit(Fx.collectAll(concatenated));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when second stream fails after first completed", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fromIterable([1, 2]), Fx.fail("err" as const));
+        const exit = yield* Effect.exit(Fx.collectAll(concatenated));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes with first stream only when second is empty", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fromIterable([1, 2]), Fx.fromIterable([]));
+        const result = yield* Fx.collectAll(concatenated);
+        assert.deepStrictEqual(result, [1, 2]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+  it("takeEffect uses count from Effect", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(Fx.takeEffect(Effect.succeed(2)));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skipEffect uses count from Effect", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(Fx.skipEffect(Effect.succeed(2)));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [3, 4]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sliceEffect uses bounds from Effect", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(
+        Fx.sliceEffect(Effect.succeed({ skip: 1, take: 2 })),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeUntilEffect stops when predicate effect succeeds with true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(
+        Fx.takeUntilEffect((n) => Effect.succeed(n > 2)),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeUntilEffect fails when predicate effect fails", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        Fx.takeUntilEffect((n) => (n === 2 ? Effect.fail("boom") : Effect.succeed(false))),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Fx.catch-additive.test.ts

@@ -0,0 +1,206 @@
+import { assert, describe, it } from "vitest";
+import * as Cause from "effect/Cause";
+import { Data } from "effect";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Result from "effect/Result";
+import { catchCauseIf, catchIf, catchTags } from "./Fx/combinators/catch.js";
+import { Fx } from "./index.js";
+
+describe("Fx.catchIf", () => {
+  it("recovers when predicate is true (typed failure)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(42).pipe(
+        catchIf(
+          (n: number) => n > 10,
+          (n) => Fx.succeed(`recovered:${n}`),
+        ),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["recovered:42"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover when predicate is false (re-fails)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(3).pipe(
+        catchIf(
+          (n: number) => n > 10,
+          (n) => Fx.succeed(`recovered:${n}`),
+        ),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      const failResult = Cause.findFail(exit.cause);
+      assert(failResult._tag === "Success");
+      assert.strictEqual(failResult.success.error, 3);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover from defects (only Fail is considered)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(
+        catchIf(
+          () => true,
+          () => Fx.succeed("nope"),
+        ),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("success path is unchanged", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        catchIf(
+          (_: string) => true,
+          () => Fx.succeed(-1),
+        ),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style (data-first)", () =>
+    Effect.gen(function* () {
+      const fx = catchIf(
+        Fx.fail("err"),
+        (e: string) => e.length > 0,
+        (e) => Fx.succeed(e.toUpperCase()),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["ERR"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Fx.catchCauseIf", () => {
+  it("recovers when predicate is true (e.g. has fails)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail("boom").pipe(
+        catchCauseIf(Cause.hasFails, (cause) => {
+          const r = Cause.findFail(cause);
+          const msg = Result.isSuccess(r) ? r.success.error : "?";
+          return Fx.succeed(`recovered:${msg}`);
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.strictEqual(result[0], "recovered:boom");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("recovers from defects when predicate matches cause", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(catchCauseIf(Cause.hasDies, () => Fx.succeed("ok")));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["ok"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover when predicate is false", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("oops").pipe(catchCauseIf(Cause.isEmpty, () => Fx.succeed("no")));
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("success path is unchanged", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2]).pipe(
+        catchCauseIf(
+          () => true,
+          () => Fx.succeed(0),
+        ),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style (data-first)", () =>
+    Effect.gen(function* () {
+      const fx = catchCauseIf(Fx.fail("x"), Cause.hasFails, (cause) =>
+        Fx.succeed(Result.isSuccess(Cause.findFail(cause)) ? "handled" : "unhandled"),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.strictEqual(result[0], "handled");
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Fx.catchTags", () => {
+  class ErrorA extends Data.TaggedError("A")<{ readonly n: number }> {}
+  class ErrorB extends Data.TaggedError("B")<{ readonly msg: string }> {}
+
+  it("recovers from multiple tagged failures with one call", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(new ErrorA({ n: 1 })).pipe(
+        catchTags({
+          A: (e) => Fx.succeed(`A:${e.n}`),
+          B: (e) => Fx.succeed(`B:${e.msg}`),
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["A:1"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("matches second tag when first fails with B", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(new ErrorB({ msg: "hello" })).pipe(
+        catchTags({
+          A: (e) => Fx.succeed(`A:${e.n}`),
+          B: (e) => Fx.succeed(`B:${e.msg}`),
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["B:hello"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not catch untagged or other tags (re-fails)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail("plain").pipe(
+        catchTags({
+          A: () => Fx.succeed(1),
+          B: () => Fx.succeed(2),
+        } as {
+          A: (e: ErrorA) => Fx<number, never, never>;
+          B: (e: ErrorB) => Fx<number, never, never>;
+        }),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      const failResult = Cause.findFail(exit.cause);
+      assert(failResult._tag === "Success");
+      assert.strictEqual(failResult.success.error, "plain");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover from defects (only Fail with _tag)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(
+        catchTags({
+          A: () => Fx.succeed(1),
+          B: () => Fx.succeed(2),
+        }),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("success path is unchanged", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        catchTags({
+          A: () => Fx.succeed(-1),
+          B: () => Fx.succeed(-2),
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style (data-first)", () =>
+    Effect.gen(function* () {
+      const fx = catchTags(Fx.fail(new ErrorA({ n: 42 })), {
+        A: (e) => Fx.succeed(e.n * 2),
+        B: () => Fx.succeed(0),
+      });
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [84]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});