@typed/fx 2.0.0-beta.4 → 2.0.0-beta.5

package/src/Fx/run/collect.ts

@@ -1,79 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,114 +0,0 @@
-import type { Cause } from "effect/Cause";
-import type { Effect } from "effect/Effect";
-import {
-  callback,
-  catchCause,
-  failCause,
-  forkScoped,
-  isEffect,
-  matchCauseEffect,
-  runForkWith,
-  contextWith,
-  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> =>
-    contextWith((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(forkScoped(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(forkScoped(observe(fx, f))),
-);

package/src/Fx/run/runPromise.ts

@@ -1,32 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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));
-});