# Fx.mergeRight

Merges two Fx streams and emits only values from the right stream.
Both streams run concurrently; completion when **both** complete.

## Signatures

```ts
export declare const mergeRight: {
    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A2, E | E2, R | R2>;
    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A2, E | E2, R | R2>;
};
```

## Why

`mergeRight` observes the left producer's completion and failure while exposing only right
values. Each right value is emitted once with no deterministic ordering against hidden left work.

## Ownership and lifetime

The consumer owns both concurrent runs and normal completion waits for both. Interruption cancels
both. A Cause is delivered to the Sink without inherently canceling the sibling; left successes
remain suppressed even while their failures are observable.

## Examples

```ts
import { Effect, Ref } from "effect"
import { Fx, Sink } from "@typed/fx"

const program = Effect.gen(function* () {
  const values = yield* Ref.make<Array<string>>([])
  yield* Fx.mergeRight(Fx.fail("hidden side failed"), Fx.succeed("visible")).run(
    Sink.make(() => Effect.void, (value) => Ref.update(values, (xs) => [...xs, value]))
  )
  return yield* Ref.get(values) // ["visible"]
})
```