Function fetchResolvedArchive

ui/src/runner/browser/loader/shared.ts:193–252

(
  resolveUrl: string,
  headers: Record<string, string>,
  signal: AbortSignal | undefined,
  onProgress?: (progress: FetchProgress) => void,
)

 * with progress reporting based on the known content length.
 */
export async function fetchResolvedArchive(
  resolveUrl: string,
  headers: Record<string, string>,
  signal: AbortSignal | undefined,
  onProgress?: (progress: FetchProgress) => void,
): Promise<ArchiveResult> {
  // Step 1: resolve → { url, contentLength, sha, branch, commitMessage, ... }
  const resolveRes = await fetch(resolveUrl, { headers, signal });
  if (!resolveRes.ok) {
    const text = await resolveRes.text();
    throw new Error(`Archive resolve error ${resolveRes.status}: ${text}`);
  }
  const resolved = (await resolveRes.json()) as ResolveResult;
  const { url, contentLength } = resolved;
  const gitMeta: ArchiveGitMeta = {
    sha: resolved.sha,
    branch: resolved.branch,
    commitMessage: resolved.commitMessage,
    authorName: resolved.authorName,
    authorDate: resolved.authorDate,
  };

  // Step 2: fetch the actual zip, streaming for progress
  const zipRes = await fetch(url, { headers, signal });
  if (!zipRes.ok) {
    const text = await zipRes.text();
    throw new Error(`Archive download error ${zipRes.status}: ${text}`);
  }

  const total = contentLength || 0;

  // If no ReadableStream body (unlikely in modern browsers), fall back
  if (!zipRes.body) {
    const buf = new Uint8Array(await zipRes.arrayBuffer());
    onProgress?.({ phase: 'download', current: buf.length, total: buf.length });
    return { data: buf, gitMeta };
  }

  // Stream with progress
  const reader = zipRes.body.getReader();
  const chunks: Uint8Array[] = [];
  let received = 0;

  for (;;) {
    const { done, value } = await reader.read();
    if (done) break;
    chunks.push(value);
    received += value.length;
    onProgress?.({ phase: 'download', current: received, total });
  }

  // Concatenate chunks
  const buf = new Uint8Array(received);
  let offset = 0;
  for (const chunk of chunks) {
    buf.set(chunk, offset);
    offset += chunk.length;
  }