1.js

## 1.js
async function mergeResponses(responsePromises, headers) {
  const readers = responsePromises.map(p => Promise.resolve(p).then(r => r.body.getReader()));
  let doneResolve;
  let doneReject;
  const done = new Promise((r, rr) => {
    doneResolve = r;
    doneReject = rr;
  });

  const readable = new ReadableStream({
    async pull(controller) {
      const reader = await readers[0];

      try {
        const {done, value} = await reader.read();
        if (done) {
          readers.shift();

          if (!readers[0]) {
            controller.close();
            doneResolve();
            return;
          }
          return this.pull(controller);
        }

        controller.enqueue(value);
      }
      catch (err) {
        doneReject(err);
        throw err;
      }
    },
    cancel() {
      doneResolve();
    }
  });

  const response = await responsePromises[0];

  return {
    done,
    response: new Response(readable, {
      headers: headers || response.headers
    })
  };
}

## future.js
// This depends on transform streams & async iterators

async function mergeResponses(responsePromises, headers) {
  const {readable, writable} = new TransformStream();

  const done = (async function() {
    for await (const response of responsePromises) {
      await response.body.pipeTo(writable, {preventClose: true});
    }
    writable.getWriter().close();
  })();

  return {
    done,
    response: new Response(readable, {
      headers: headers || (await responsePromises[0]).headers
    })
  };
}