Function readBodyIdle

src/video-proxy-shared.ts:123–168

(
  res: Response,
  record: RecordConfig | undefined,
  cap = 0,
)

 * disk guard.
 */
export async function readBodyIdle(
  res: Response,
  record: RecordConfig | undefined,
  cap = 0,
): Promise<{ overCap: false; buf: Buffer } | { overCap: true; bytesRead: number }> {
  const body = res.body;
  if (!body) return { overCap: false, buf: Buffer.alloc(0) };
  const idleMs = clampTimeout(record?.bodyTimeoutMs, DEFAULT_UPSTREAM_TIMEOUT_MS);
  const reader = body.getReader();
  const chunks: Buffer[] = [];
  let total = 0;
  try {
    for (;;) {
      let idleTimer: NodeJS.Timeout | undefined;
      // A stream error landing AFTER the idle timeout has already won the
      // race must never become an unhandledRejection (process crash) — attach
      // a no-op rejection handler to the read promise BEFORE racing.
      // Promise.race subscribes to its inputs too, so this is deliberate
      // defense-in-depth pinning the invariant against a refactor that races
      // the read differently; the race below still observes the rejection
      // normally when the read loses first.
      const readPromise = reader.read();
      readPromise.catch(() => {});
      const result = await Promise.race([
        readPromise,
        new Promise<never>((_, reject) => {
          idleTimer = setTimeout(
            () => reject(new Error(`Upstream response body idle for ${idleMs}ms`)),
            idleMs,
          );
        }),
      ]).finally(() => clearTimeout(idleTimer));
      if (result.done) break;
      total += result.value.byteLength;
      if (cap > 0 && total > cap) {
        return { overCap: true, bytesRead: total };
      }
      chunks.push(Buffer.from(result.value));
    }
  } finally {
    // Idle expiry and the over-cap early return leave the stream open —
    // release it. After a normal completion this is a no-op.
    void reader.cancel().catch(() => {});
  }
  return { overCap: false, buf: Buffer.concat(chunks) };
}

/**
 * Cap on the small-JSON upstream envelope bodies (submit, status poll, models