# zipRight

Zips two Fx streams in strict lockstep and emits only the right value.
Completes when the **first** of the two streams completes.

## Signatures

```ts
export declare const zipRight: {
    <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

`zipRight` pairs both sources but deliberately keeps the right payload. It emits once per pair,
in pairing order, and never emits an unmatched right value.

## Ownership and lifetime

Both runs belong to the consumer. The first completion or consumer interruption cancels the
remaining run and releases the lockstep queues. Failure is Sink delivery, not an automatic stop;
pairing can continue when the failing producer remains active and later emits a value.

## Examples

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

const left = Fx.make<number, string>((sink) =>
  sink.onFailure(Cause.fail("warning")).pipe(Effect.andThen(sink.onSuccess(1)))
)
const program = Fx.zipRight(left, Fx.succeed("paired")).run(
  Sink.make(Effect.logError, Effect.log)
) // logs the failure and then "paired"
```