public function resolveRedirects(UrlList $urlList): UrlRedirectInfoList {
    $urlRedirectInfoList = new UrlRedirectInfoList();
    $responses = [];
    foreach ($urlList as $urlItem) {
      $url = $urlItem->toString();
      if (!isset($responses[$url])) {
        $responses[$url] = $this->client->request('GET', $url);
      }
    }
    // Pass in timeout only now to not get exceptions too early.
    foreach ($this->client->stream($responses, $this->timeoutSeconds) as $response => $chunk) {
      try {
        if ($chunk->isTimeout()) {
          $response->cancel();
        } elseif ($chunk->isFirst()) {
          $url = array_search($response, $responses, TRUE);
          // Headers arrived.
          $redirectUrls = [];
          $isRedirectResponse = $response->getStatusCode() >= 300 && $response->getStatusCode() < 400;
          /** @noinspection PhpUnhandledExceptionInspection */
          $redirectUrl = $isRedirectResponse ? $response->getHeaders(throw: FALSE)['location'][0] ?? NULL : NULL;;
          if (!empty($redirectUrl)) {
            $redirectUrls[] = $redirectUrl;
            $urlRedirectInfo = new UrlRedirectInfo($url, ...$redirectUrls);
            $urlRedirectInfoList->add($urlRedirectInfo);
            // In this version, intentionally do NOT follow redirections further than
            // one level.
          }
          // We don't need more.
          $response->cancel();
        } elseif ($chunk->isLast()) {
          // We will never get here.
        }
      } catch (TransportExceptionInterface $e) {
        // @todo Log.
      }
    }
    return $urlRedirectInfoList;
  }

  public function resolveRedirects(UrlList $urlList): UrlRedirectInfoList {
    $urlRedirectInfoList = new UrlRedirectInfoList();
    // Span a try-catch around the complete lifetime of the async responses,
    // to not miss any exception.
    try {
      // Place all requests.
      $responses = [];
      // The "place-many-requests" foreach loop.
      foreach ($urlList as $urlItem) {
        $url = $urlItem->toString();
        if (!isset($responses[$url])) {
          $responses[$url] = $this->client->request('GET', $url);
        }
      }
      // The "work-down-all-responses" foreach loop.
      foreach ($responses as $url => $response) {
        // Span a try-catch around the response evaluation loop. So if a
        // response throws in that loop, processing continues for the next
        // response like we want it.
        // @fixme Assume an async response throws an exception **before**
        //   entering the foreach loop, or in the microsecond when looping.
        //   Then the exception is caught by the outer try-catch, dumping all
        //   remaining responses, which is not what we want.
        //   The problem is more general: Given multiple responses, to catch
        //   an exception for one response, the try clause is left and another
        //   response can throw an exception. Unresolvable.
        //   The above first approximation fortunately is only true in a world
        //   with true parallelism. Afaik we don't have true parallelism, bot
        //   fibers can only be switched (and the exception thrown) with an
        //   explicit switch or sleep or an i/o operation. Leveraging that
        //   knowledge, this for-loop is safe as long as we avoid any i/o
        //   outside the try-catch.
        //   But there's still the problem with the timespan **before** entering
        //   the work-down-all-responses foreach loop. While quite unprobable
        //   (bot more probable the more requests), it is perfectly possible
        //   that one of the responses throws timeout (or fwiw another exception),
        //   while a second one is placed, when the i/o operation of placing the
        //   second requests triggers the fiber event loop.
        //   How can we handle **that** situation?
        //   Anyway, it looks like event in this simplest use case of placing
        //   multiple events, catching exceptions needs a thorough knowledge
        //   of when and how the event loop can be triggered, and where the
        //   exception can be thrown.
        try {
          $redirectUrls = [];
          $isRedirectResponse = $response->getStatusCode() >= 300 && $response->getStatusCode() < 400;
          $redirectUrl = $isRedirectResponse ? $response->getHeaders(throw: FALSE)['location'][0] ?? NULL : NULL;;
          if (!empty($redirectUrl)) {
            $redirectUrls[] = $redirectUrl;
            $urlRedirectInfo = new UrlRedirectInfo($url, ...$redirectUrls);
            $urlRedirectInfoList->add($urlRedirectInfo);
            // In this version, intentionally do NOT follow redirections further than
            // one level.
          }
        } catch (TimeoutException $e) {
          // @todo Log.
        }
      }
      // Ensure destructor is in try-catch too. Otherwise, a response that is
      // header-complete, but not complete yet, might throw timeout after
      // leaving this scope, even if it's only a microsecond away from
      // destruction by leaving the function.
      unset($responses);
    } catch (TimeoutException $e) {
      // @todo Log.
    }
    return $urlRedirectInfoList;
  }