@plune-ai/cli 0.21.0 → 0.23.0

package/dist/cli.cjs

@@ -2304,6 +2304,13 @@ var init_credentials = __esm({
 });
 
 // src/reporter-core/client.ts
+function parseRetryAfter(raw, now = Date.now()) {
+  const text2 = raw?.trim();
+  if (text2 === void 0 || text2 === "") return null;
+  const seconds = /^\d+(\.\d+)?$/.test(text2) ? Number(text2) : (Date.parse(text2) - now) / 1e3;
+  if (!Number.isFinite(seconds)) return null;
+  return Math.min(Math.max(seconds, 0) * 1e3, RETRY_AFTER_CAP_MS);
+}
 function nodeTransport(url, init, idleMs = IDLE_MS) {
   return new Promise((resolve9, reject) => {
     const target = new URL(url);
@@ -2371,12 +2378,6 @@ async function detailOf(res) {
     return { detail: "" };
   }
 }
-function retryAfterMs2(res) {
-  const raw = res.headers.get("retry-after");
-  if (raw === null) return null;
-  const seconds = Number(raw.trim());
-  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : null;
-}
 function classify(status) {
   if (status === 401 || status === 403) return "auth";
   if (status === 409) return "conflict";
@@ -2387,15 +2388,34 @@ function classify(status) {
 function createClient(opts) {
   const doFetch = opts.fetchImpl ?? nodeTransport;
   const wait = opts.wait ?? sleep;
+  const uploadRetries = opts.uploadRetries === void 0 ? void 0 : Math.max(0, Math.floor(opts.uploadRetries));
+  const random = opts.random ?? Math.random;
+  const now = opts.now ?? Date.now;
+  let pausedUntil = 0;
+  const jittered = (ms) => Math.round(ms * (1 + random() * 0.5));
+  async function backOff(attempt, said) {
+    opts.onRetry?.();
+    const ms = jittered(said ?? Math.min(BACKOFF_BASE_MS * 2 ** attempt, BACKOFF_CAP_MS));
+    const until = now() + ms;
+    pausedUntil = Math.max(pausedUntil, until);
+    await wait(ms);
+    return until;
+  }
+  async function respectPause(mine) {
+    const left = pausedUntil - now();
+    if (pausedUntil > mine && left > 0) await wait(left + Math.round(random() * 250));
+  }
   const base = opts.apiUrl.replace(/\/+$/, "");
   const scrub = (text2) => opts.token === "" ? text2 : text2.split(opts.token).join("***");
-  async function send(method, path17, payload) {
+  async function send(method, path17, payload, retries = DEFAULT_RETRIES) {
     let last = {
       kind: "unavailable",
       status: null,
       detail: "no attempt was made"
     };
-    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt += 1) {
+    let mine = 0;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+      await respectPause(mine);
       let res;
       try {
         res = await doFetch(`${base}${path17}`, {
@@ -2408,7 +2428,8 @@ function createClient(opts) {
         });
       } catch (err) {
         last = { kind: "unavailable", status: null, detail: scrub(String(err)) };
-        if (attempt < RETRY_DELAYS_MS.length) await wait(RETRY_DELAYS_MS[attempt]);
+        if (attempt >= Math.min(retries, DEFAULT_RETRIES)) break;
+        mine = await backOff(attempt, null);
         continue;
       }
       if (res.ok) {
@@ -2423,25 +2444,28 @@ function createClient(opts) {
       const kind = classify(res.status);
       last = { kind, status: res.status, detail: scrub(said.detail), ...said.code !== void 0 ? { code: said.code } : {} };
       if (kind !== "unavailable") break;
-      if (res.status === 429 && retryAfterMs2(res) === null) {
+      const said429 = parseRetryAfter(res.headers.get("retry-after"), now());
+      if (res.status === 429 && said429 === null) {
         last.kind = "invalid";
         last.detail = "quota exceeded (no Retry-After)";
         if (said.detail) last.detail += ` \u2014 ${scrub(said.detail)}`;
         break;
       }
-      if (attempt < RETRY_DELAYS_MS.length) {
-        await wait(retryAfterMs2(res) ?? RETRY_DELAYS_MS[attempt]);
-      }
+      if (attempt >= (said429 === null ? Math.min(retries, DEFAULT_RETRIES) : retries)) break;
+      mine = await backOff(attempt, said429);
     }
     return { ok: false, ...last };
   }
   return {
-    post: (path17, body) => send("POST", path17, { body: JSON.stringify(body), type: "application/json" }),
-    upload: (path17, bytes, contentType) => send("POST", path17, { body: bytes, type: contentType }),
+    post: (path17, body, retries) => send("POST", path17, { body: JSON.stringify(body), type: "application/json" }, retries),
+    upload: (path17, bytes, contentType) => send("POST", path17, { body: bytes, type: contentType }, uploadRetries ?? DEFAULT_RETRIES),
     del: (path17) => send("DELETE", path17),
     async put(url, headers, source) {
+      const putRetries = uploadRetries ?? 3;
       let last = { ok: false, status: null, code: "network" };
-      for (let attempt = 0; attempt <= PUT_DELAYS_MS.length; attempt += 1) {
+      let mine = 0;
+      for (let attempt = 0; attempt <= putRetries; attempt += 1) {
+        await respectPause(mine);
         try {
           let status;
           let retryAfter;
@@ -2456,21 +2480,21 @@ function createClient(opts) {
           if (status >= 200 && status <= 299) return { ok: true };
           last = { ok: false, status, code: `bucket_${status}` };
           if (status < 500 && status !== 429) return last;
-          const seconds = retryAfter === null ? NaN : Number(retryAfter.trim());
-          if (attempt < PUT_DELAYS_MS.length) {
-            await wait(Number.isFinite(seconds) && seconds >= 0 ? Math.min(seconds, 60) * 1e3 : PUT_DELAYS_MS[attempt]);
-          }
+          const said = parseRetryAfter(retryAfter, now());
+          if (attempt >= (said === null ? Math.min(putRetries, 3) : putRetries)) return last;
+          mine = await backOff(attempt, said);
           continue;
         } catch (err) {
           last = { ok: false, status: null, code: codeOfError(err) };
         }
-        if (attempt < PUT_DELAYS_MS.length) await wait(PUT_DELAYS_MS[attempt]);
+        if (attempt >= Math.min(putRetries, 3)) return last;
+        mine = await backOff(attempt, null);
       }
       return last;
     }
   };
 }
-var import_node_fs2, import_node_stream, import_node_http, import_node_https, RETRY_DELAYS_MS, IDLE_MS, PUT_DELAYS_MS, withoutLength, codeOfError, sleep;
+var import_node_fs2, import_node_stream, import_node_http, import_node_https, BACKOFF_BASE_MS, BACKOFF_CAP_MS, DEFAULT_RETRIES, RETRY_AFTER_CAP_MS, IDLE_MS, withoutLength, codeOfError, sleep;
 var init_client = __esm({
   "src/reporter-core/client.ts"() {
     "use strict";
@@ -2479,9 +2503,11 @@ var init_client = __esm({
     import_node_stream = require("stream");
     import_node_http = require("http");
     import_node_https = require("https");
-    RETRY_DELAYS_MS = [300, 900];
+    BACKOFF_BASE_MS = 300;
+    BACKOFF_CAP_MS = 1e4;
+    DEFAULT_RETRIES = 2;
+    RETRY_AFTER_CAP_MS = 6e4;
     IDLE_MS = 3e5;
-    PUT_DELAYS_MS = [500, 1500, 4e3];
     withoutLength = (headers) => Object.fromEntries(Object.entries(headers).filter(([name]) => name.toLowerCase() !== "content-length"));
     codeOfError = (err) => {
       const code = err?.code;
@@ -2506,6 +2532,14 @@ function count(env, name) {
   const n = Number(raw);
   return Number.isInteger(n) && n > 0 ? n : void 0;
 }
+function bounded(env, name, range, warnings) {
+  const raw = value(env, name);
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (/^\d+$/.test(raw) && n >= range.min && n <= range.max) return n;
+  warnings.push(`${name}=${JSON.stringify(raw.slice(0, 40))} is not a whole number from ${range.min} to ${range.max} \u2014 using ${range.default}.`);
+  return void 0;
+}
 function list(env, name) {
   const raw = value(env, name);
   if (raw === void 0) return void 0;
@@ -2518,6 +2552,9 @@ function readEnv(env = process.env) {
   const apiUrl = value(env, "PLUNE_API_URL");
   const fallbackPath = value(env, "PLUNE_FALLBACK");
   const batchSize = count(env, "PLUNE_BATCH_SIZE");
+  const warnings = [];
+  const uploadConcurrency = bounded(env, "PLUNE_UPLOAD_CONCURRENCY", UPLOAD_CONCURRENCY, warnings);
+  const uploadRetries = bounded(env, "PLUNE_UPLOAD_RETRIES", UPLOAD_RETRIES, warnings);
   const title = value(env, "PLUNE_RUN_TITLE");
   const environment = value(env, "PLUNE_ENV");
   const labels = list(env, "PLUNE_LABELS");
@@ -2530,6 +2567,8 @@ function readEnv(env = process.env) {
       ...apiUrl !== void 0 ? { apiUrl } : {},
       ...fallbackPath !== void 0 ? { fallbackPath } : {},
       ...batchSize !== void 0 ? { batchSize } : {},
+      ...uploadConcurrency !== void 0 ? { uploadConcurrency } : {},
+      ...uploadRetries !== void 0 ? { uploadRetries } : {},
       ...title !== void 0 ? { title } : {},
       ...environment !== void 0 ? { environment } : {},
       ...labels !== void 0 ? { labels } : {},
@@ -2542,7 +2581,8 @@ function readEnv(env = process.env) {
     // reporting into this run; `PROCEED` says the job will close it on its own schedule. Either
     // way this process must not be the one to call it finished.
     keepOpen: flag(env, "PLUNE_SHARED_RUN") || flag(env, "PLUNE_PROCEED"),
-    ignored: UNSUPPORTED_VARS.filter((name) => value(env, name) !== void 0)
+    ignored: UNSUPPORTED_VARS.filter((name) => value(env, name) !== void 0),
+    warnings
   };
 }
 function defaultRunTitle(env = process.env, now = /* @__PURE__ */ new Date(), cwd = process.cwd()) {
@@ -2568,13 +2608,15 @@ function ciCommit(reported, env = process.env) {
     ...branch !== void 0 ? { branch } : {}
   };
 }
-var path6, UNSUPPORTED_VARS, PROVIDERS;
+var path6, UNSUPPORTED_VARS, UPLOAD_CONCURRENCY, UPLOAD_RETRIES, PROVIDERS;
 var init_env2 = __esm({
   "src/reporter-core/env.ts"() {
     "use strict";
     init_cjs_shims();
     path6 = __toESM(require("path"), 1);
     UNSUPPORTED_VARS = ["PLUNE_GROUP"];
+    UPLOAD_CONCURRENCY = { min: 1, max: 32, default: 4 };
+    UPLOAD_RETRIES = { min: 0, max: 20, default: 6 };
     PROVIDERS = [
       { is: "GITHUB_ACTIONS", sha: "GITHUB_SHA", branch: ["GITHUB_HEAD_REF", "GITHUB_REF_NAME"] },
       { is: "GITLAB_CI", sha: "CI_COMMIT_SHA", branch: ["CI_COMMIT_REF_NAME"] },
@@ -2747,6 +2789,34 @@ var init_failure_detail = __esm({
   }
 });
 
+// src/reporter-core/files-batch.ts
+async function sha256File(path17) {
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  for await (const part of (0, import_node_fs4.createReadStream)(path17)) hash.update(part);
+  return hash.digest("hex");
+}
+var import_node_crypto2, import_node_fs4, FILES_BATCH_MAX, DIRECT_BATCH_BYTES, BATCH_PIPELINES, sha256Bytes, BUCKET_CODES;
+var init_files_batch = __esm({
+  "src/reporter-core/files-batch.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto2 = require("crypto");
+    import_node_fs4 = require("fs");
+    FILES_BATCH_MAX = 100;
+    DIRECT_BATCH_BYTES = 6 * 1024 * 1024;
+    BATCH_PIPELINES = 2;
+    sha256Bytes = (bytes) => (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex");
+    BUCKET_CODES = /* @__PURE__ */ new Set([
+      "bucket_unreachable",
+      "not_connected",
+      "platform_not_configured",
+      "upload_expired",
+      "file_mismatch",
+      "file_missing"
+    ]);
+  }
+});
+
 // src/reporter-core/session.ts
 function nameOf(file) {
   const own = file.name.split(/[\\/]/).pop()?.trim() || (file.path === void 0 ? "" : (0, import_node_path3.basename)(file.path));
@@ -2798,7 +2868,7 @@ function tally(counts, noun) {
 }
 function boundKey(key) {
   if (key.value.length <= KEY_MAX) return key;
-  const digest = (0, import_node_crypto2.createHash)("sha256").update(key.value).digest("hex").slice(0, 16);
+  const digest = (0, import_node_crypto3.createHash)("sha256").update(key.value).digest("hex").slice(0, 16);
   let head = key.value.slice(0, KEY_MAX - digest.length - 1);
   if (/[\uD800-\uDBFF]$/.test(head)) head = head.slice(0, -1);
   return { ...key, value: `${head}#${digest}` };
@@ -2850,13 +2920,22 @@ async function startRun(passed, declared2) {
 `));
   const fallbackPath = cfg.fallbackPath ?? DEFAULT_FALLBACK_PATH;
   const externalKey = cfg.externalKey ?? null;
-  const sessionMarker = (0, import_node_crypto2.randomUUID)();
+  const sessionMarker = (0, import_node_crypto3.randomUUID)();
   const batchSize = Math.min(cfg.batchSize ?? BATCH_DEFAULT, BATCH_MAX);
   const offerDiscovered = cfg.offerDiscovered ?? false;
   const token = cfg.token ?? loadToken() ?? "";
+  const uploadsAtOnce = Math.min(Math.max(Math.floor(cfg.uploadConcurrency ?? UPLOAD_CONCURRENCY.default), UPLOAD_CONCURRENCY.min), UPLOAD_CONCURRENCY.max);
+  const uploadRetries = Math.min(Math.max(Math.floor(cfg.uploadRetries ?? UPLOAD_RETRIES.default), UPLOAD_RETRIES.min), UPLOAD_RETRIES.max);
+  let retried = 0;
+  let uploadMs = 0;
+  let requests = 0;
+  let existed = 0;
+  let batchMissing = false;
   const client = createClient({
     apiUrl: resolveApiUrl(cfg.apiUrl),
     token,
+    uploadRetries,
+    onRetry: () => void (retried += 1),
     ...cfg.fetchImpl !== void 0 ? { fetchImpl: cfg.fetchImpl } : {}
   });
   const stats = {
@@ -2907,6 +2986,7 @@ async function startRun(passed, declared2) {
   if (offline) {
     log('plune: no API token \u2014 run "plune login" first. Results will be written to the fallback file.');
   }
+  for (const warning of env.warnings) log(`plune: ${warning}`);
   if (env.ignored.length > 0) {
     log(`plune: ignoring ${env.ignored.join(", ")} \u2014 a run has nowhere to store them yet.`);
   }
@@ -3034,9 +3114,10 @@ async function startRun(passed, declared2) {
     else log(`plune: ${KINDS[kind].label} "${name}" not uploaded \u2014 ${SKIPPED[why]}.`);
   }
   function ask(job, size) {
+    requests += 1;
     return client.post(`/v1/results/${encodeURIComponent(job.id)}/files/uploads`, {
       files: [{ name: job.name, contentType: job.type, size }]
-    });
+    }, uploadRetries);
   }
   function failed(job, why) {
     countsOf(job.kind).failed += 1;
@@ -3068,13 +3149,14 @@ async function startRun(passed, declared2) {
     if (job.body !== void 0) bytes = job.body;
     else {
       try {
-        bytes = await import_node_fs4.promises.readFile(job.path);
+        bytes = await import_node_fs5.promises.readFile(job.path);
       } catch {
         return skip(kind, job.name, "missing");
       }
     }
     const refusal = kind === "text" ? textRefusal(bytes) : void 0;
     if (refusal !== void 0) return skip(kind, job.name, refusal);
+    requests += 1;
     const out = await client.upload(
       `/v1/results/${encodeURIComponent(job.id)}/files?name=${encodeURIComponent(job.name)}`,
       bytes,
@@ -3097,11 +3179,12 @@ async function startRun(passed, declared2) {
       if (fresh === void 0) return failedToBucket(job, "bad_answer");
       link = fresh;
     }
-    const done2 = await client.post(`/v1/files/${encodeURIComponent(link.id)}/complete`, {});
+    requests += 1;
+    const done2 = await client.post(`/v1/files/${encodeURIComponent(link.id)}/complete`, {}, uploadRetries);
     if (!done2.ok) return failedToBucket(job, codeOf2(done2));
     countsOf(job.kind).uploaded += 1;
   }
-  let free = UPLOADS_AT_ONCE;
+  let free = uploadsAtOnce;
   const waiting = [];
   async function gated(work) {
     if (free === 0) await new Promise((resolve9) => waiting.push(resolve9));
@@ -3121,7 +3204,7 @@ async function startRun(passed, declared2) {
     else if (job.path === void 0) return void skip(kind, job.name, "missing");
     else {
       try {
-        size = (await import_node_fs4.promises.stat(job.path)).size;
+        size = (await import_node_fs5.promises.stat(job.path)).size;
       } catch {
         return void skip(kind, job.name, "missing");
       }
@@ -3157,6 +3240,245 @@ async function startRun(passed, declared2) {
     }
     return () => uploadToBucket(job, size, link);
   }
+  async function uploadEach(jobs) {
+    const byResult = /* @__PURE__ */ new Map();
+    for (const job of jobs) byResult.set(job.id, [...byResult.get(job.id) ?? [], job]);
+    await Promise.all(
+      [...byResult.values()].map(async (group) => {
+        const work = [];
+        for (const job of group) {
+          const act = await plan(job);
+          if (act !== void 0) work.push(gated(act));
+        }
+        await Promise.all(work);
+      })
+    );
+  }
+  async function measure(job) {
+    let size;
+    if (job.body !== void 0) size = job.body.length;
+    else if (job.path === void 0) return void skip(job.kind, job.name, "missing");
+    else {
+      try {
+        size = (await import_node_fs5.promises.stat(job.path)).size;
+      } catch {
+        return void skip(job.kind, job.name, "missing");
+      }
+    }
+    if (size === 0) return void skip(job.kind, job.name, "empty");
+    return size;
+  }
+  const routeMissing = (out) => !out.ok && out.status === 404 && out.detail === "" && out.code === void 0;
+  function takeRoom(job) {
+    if (job.kind === "file") {
+      skip(job.kind, job.name, "noStorage");
+      return false;
+    }
+    const roomKey = `${job.id}/${job.kind}`;
+    const left = rooms.get(roomKey) ?? KINDS[job.kind].room;
+    if (left === 0) {
+      skip(job.kind, job.name, KINDS[job.kind].limit);
+      return false;
+    }
+    rooms.set(roomKey, left - 1);
+    return true;
+  }
+  function refusedItem(job, size, item) {
+    const code = item.code ?? "refused";
+    if (code === "duplicate") existed += 1;
+    else if (code === "no_storage") skip(job.kind, job.name, refusedHere(job, size) ?? "noStorage");
+    else if (code === "too_many_files") skip(job.kind, job.name, KINDS[job.kind].limit);
+    else if (BUCKET_CODES.has(code)) failedToBucket(job, code);
+    else failed(job, code);
+  }
+  const itemPause = (round) => new Promise((r) => setTimeout(r, Math.min(250 * 2 ** round, 4e3)));
+  async function batchOf(jobs) {
+    if (batchMissing) return uploadEach(jobs);
+    const sized = [];
+    for (const job of jobs) {
+      const size = await measure(job);
+      if (size === void 0) continue;
+      try {
+        sized.push({ job, size, sha256: job.body !== void 0 ? sha256Bytes(job.body) : await sha256File(job.path) });
+      } catch {
+        skip(job.kind, job.name, "missing");
+      }
+    }
+    if (sized.length === 0) return;
+    const announced = await gated(() => {
+      requests += 1;
+      return client.post(
+        "/v1/files/uploads-batch",
+        { items: sized.map((s) => ({ resultId: s.job.id, name: s.job.name, contentType: s.job.type, size: s.size, sha256: s.sha256 })) },
+        uploadRetries
+      );
+    });
+    if (routeMissing(announced)) {
+      batchMissing = true;
+      return uploadEach(sized.map((s) => s.job));
+    }
+    const verdicts = announced.ok ? announced.body?.items : void 0;
+    if (!announced.ok || !Array.isArray(verdicts) || verdicts.length !== sized.length) {
+      for (const s of sized) {
+        if (announced.ok) failed(s.job, "bad_answer");
+        else if (announced.code !== void 0) failedToBucket(s.job, announced.code);
+        else failed(s.job, announced.detail || announced.kind);
+      }
+      return;
+    }
+    const puts = [];
+    const directs = [];
+    sized.forEach((s, i) => {
+      const v = verdicts[i] ?? {};
+      if (v.status === "exists") existed += 1;
+      else if (v.status === "direct") {
+        if (takeRoom(s.job)) directs.push(s);
+      } else if (v.status === "upload") {
+        const link = linkOf(v);
+        if (link === void 0) return failed(s.job, "bad_answer");
+        if (!bucketSeen) {
+          bucketSeen = true;
+          log(BUCKET_FOUND);
+        }
+        puts.push({ s, link });
+      } else if (v.status === "refused") refusedItem(s.job, s.size, v);
+      else failed(s.job, "bad_answer");
+    });
+    const toComplete = [];
+    await Promise.all(
+      puts.map(
+        ({ s, link: first }) => gated(async () => {
+          const source = s.job.body !== void 0 ? { body: s.job.body } : { path: s.job.path, size: s.size };
+          let link = first;
+          for (let renewed = false; ; ) {
+            const put = await client.put(link.url, link.headers, source);
+            if (put.ok) break;
+            if (put.status !== 403 || renewed) return failedToBucket(s.job, put.code);
+            renewed = true;
+            requests += 1;
+            const again = await client.post(
+              "/v1/files/uploads-batch",
+              { items: [{ resultId: s.job.id, name: s.job.name, contentType: s.job.type, size: s.size, sha256: s.sha256 }] },
+              uploadRetries
+            );
+            const fresh = again.ok ? linkOf(again.body?.items?.[0]) : void 0;
+            if (fresh === void 0) return failedToBucket(s.job, again.ok ? "bad_answer" : codeOf2(again));
+            link = fresh;
+          }
+          toComplete.push({ job: s.job, id: link.id });
+        })
+      )
+    );
+    await complete(toComplete);
+    await sendDirect(directs);
+  }
+  async function complete(items) {
+    for (let round = 0; items.length > 0; round += 1) {
+      const out = await gated(() => {
+        requests += 1;
+        return client.post("/v1/files/complete-batch", { ids: items.map((i) => i.id) }, uploadRetries);
+      });
+      if (routeMissing(out)) {
+        await Promise.all(
+          items.map(
+            (i) => gated(async () => {
+              requests += 1;
+              const one = await client.post(`/v1/files/${encodeURIComponent(i.id)}/complete`, {}, uploadRetries);
+              if (one.ok) countsOf(i.job.kind).uploaded += 1;
+              else failedToBucket(i.job, codeOf2(one));
+            })
+          )
+        );
+        return;
+      }
+      const verdicts = out.ok ? out.body?.items : void 0;
+      if (!out.ok || !Array.isArray(verdicts) || verdicts.length !== items.length) {
+        for (const i of items) failedToBucket(i.job, out.ok ? "bad_answer" : codeOf2(out));
+        return;
+      }
+      const again = [];
+      items.forEach((i, at) => {
+        const v = verdicts[at] ?? {};
+        if (v.status === "ready") countsOf(i.job.kind).uploaded += 1;
+        else if (v.retryable === true && round < Math.min(uploadRetries, 3)) again.push(i);
+        else refusedItem(i.job, 0, v.status === "refused" ? v : { code: "bad_answer" });
+      });
+      items = again;
+      if (items.length > 0) {
+        retried += items.length;
+        await itemPause(round);
+      }
+    }
+  }
+  async function sendDirect(items) {
+    const groups = [];
+    let bytes = 0;
+    for (const item of items) {
+      const group = groups[groups.length - 1];
+      if (group === void 0 || group.length >= FILES_BATCH_MAX || bytes + item.size > DIRECT_BATCH_BYTES) {
+        groups.push([item]);
+        bytes = item.size;
+      } else {
+        group.push(item);
+        bytes += item.size;
+      }
+    }
+    for (const group of groups) {
+      const body = [];
+      const sent = [];
+      for (const { job, size } of group) {
+        const { kind } = job;
+        if (size > KINDS[kind].bytes) {
+          skip(kind, job.name, KINDS[kind].size);
+          continue;
+        }
+        let data;
+        try {
+          data = job.body ?? await import_node_fs5.promises.readFile(job.path);
+        } catch {
+          skip(kind, job.name, "missing");
+          continue;
+        }
+        const refusal = kind === "text" ? textRefusal(data) : void 0;
+        if (refusal !== void 0) {
+          skip(kind, job.name, refusal);
+          continue;
+        }
+        body.push({ resultId: job.id, name: job.name, contentType: job.type, data: data.toString("base64") });
+        sent.push({ job, size });
+      }
+      if (body.length === 0) continue;
+      const out = await gated(() => {
+        requests += 1;
+        return client.post("/v1/files/direct-batch", { items: body }, uploadRetries);
+      });
+      if (routeMissing(out)) {
+        batchMissing = true;
+        for (const { job, size } of sent) await gated(() => uploadDirect(job, size));
+        continue;
+      }
+      const verdicts = out.ok ? out.body?.items : void 0;
+      if (!out.ok || !Array.isArray(verdicts) || verdicts.length !== sent.length) {
+        for (const { job } of sent) failed(job, out.ok ? "bad_answer" : out.detail || out.kind);
+        continue;
+      }
+      sent.forEach(({ job }, i) => {
+        const v = verdicts[i] ?? {};
+        if (v.status === "stored") countsOf(job.kind).uploaded += 1;
+        else if (v.status === "exists") existed += 1;
+        else refusedItem(job, 0, v.status === "refused" ? v : { code: "bad_answer" });
+      });
+    }
+  }
+  async function uploadBatched(jobs) {
+    const batches = chunk(jobs, FILES_BATCH_MAX);
+    let next = 0;
+    await Promise.all(
+      Array.from({ length: Math.min(BATCH_PIPELINES, batches.length) }, async () => {
+        for (let at = next++; at < batches.length; at = next++) await batchOf(batches[at]);
+      })
+    );
+  }
   async function upload(items, filesByKey) {
     if (filesByKey.size === 0 || !Array.isArray(items)) return;
     const jobs = [];
@@ -3181,18 +3503,10 @@ async function startRun(passed, declared2) {
         }
       }
     }
-    const byResult = /* @__PURE__ */ new Map();
-    for (const job of jobs) byResult.set(job.id, [...byResult.get(job.id) ?? [], job]);
-    await Promise.all(
-      [...byResult.values()].map(async (group) => {
-        const work = [];
-        for (const job of group) {
-          const act = await plan(job);
-          if (act !== void 0) work.push(gated(act));
-        }
-        await Promise.all(work);
-      })
-    );
+    const started = Date.now();
+    if (batchMissing) await uploadEach(jobs);
+    else await uploadBatched(jobs);
+    uploadMs += Date.now() - started;
   }
   async function flush() {
     if (buffer.length === 0) return;
@@ -3285,6 +3599,13 @@ async function startRun(passed, declared2) {
     }
     if (stats.deferred > 0) parts.push(`${stats.deferred} not delivered \u2014 written to ${fallbackPath}`);
     if (shortened.size > 0) parts.push(`${shortened.size} test name(s) shortened to fit a key`);
+    const files = [stats.screenshots, stats.textFiles, stats.otherFiles];
+    const total = (what) => files.reduce((n, counts) => n + counts[what], 0);
+    if (total("uploaded") + total("skipped") + total("failed") + existed > 0) {
+      log(
+        `plune: files \u2014 ${total("uploaded")} uploaded, ${total("skipped")} skipped, ${existed} already there (skipped), ${retried} retried, ${total("failed")} dropped, in ${(uploadMs / 1e3).toFixed(1)} s (${uploadsAtOnce} at once, ${requests} request(s) to Plune)`
+      );
+    }
     log(`plune: ${parts.join(" \xB7 ")}`);
     if (stats.deferred > 0 && process.env["GITHUB_ACTIONS"] === "true") {
       log(`::warning::${stats.deferred} result(s) were not delivered to Plune \u2014 see the reporting step's log.`);
@@ -3339,13 +3660,13 @@ async function startRun(passed, declared2) {
     }
   };
 }
-var import_node_crypto2, import_node_fs4, import_node_path3, import_node_util2, RESOLVE_CHUNK, BATCH_MAX, DISCOVER_MAX, BATCH_DEFAULT, EXPECTED_MAX, KEY_MAX, TITLE_MAX, COUNTED, SCREENSHOT_TYPES, SCREENSHOT_BYTES, SCREENSHOTS_PER_RESULT, TEXT_BYTES, TEXTS_PER_RESULT, UTF8, TYPE_BY_EXTENSION, METADATA_TYPE2, UPLOADS_AT_ONCE, NAME_MAX, SKIPPED, BUCKET_FOUND, KINDS, codeOf2, BATCH_BYTES, ENVELOPE_BYTES;
+var import_node_crypto3, import_node_fs5, import_node_path3, import_node_util2, RESOLVE_CHUNK, BATCH_MAX, DISCOVER_MAX, BATCH_DEFAULT, EXPECTED_MAX, KEY_MAX, TITLE_MAX, COUNTED, SCREENSHOT_TYPES, SCREENSHOT_BYTES, SCREENSHOTS_PER_RESULT, TEXT_BYTES, TEXTS_PER_RESULT, UTF8, TYPE_BY_EXTENSION, METADATA_TYPE2, NAME_MAX, SKIPPED, BUCKET_FOUND, KINDS, codeOf2, BATCH_BYTES, ENVELOPE_BYTES;
 var init_session = __esm({
   "src/reporter-core/session.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_crypto2 = require("crypto");
-    import_node_fs4 = require("fs");
+    import_node_crypto3 = require("crypto");
+    import_node_fs5 = require("fs");
     import_node_path3 = require("path");
     import_node_util2 = require("util");
     init_api_url();
@@ -3353,11 +3674,12 @@ var init_session = __esm({
     init_client();
     init_env2();
     init_failure_detail();
+    init_files_batch();
     init_fallback();
     RESOLVE_CHUNK = 500;
     BATCH_MAX = 500;
     DISCOVER_MAX = 500;
-    BATCH_DEFAULT = 100;
+    BATCH_DEFAULT = 500;
     EXPECTED_MAX = 1e4;
     KEY_MAX = 1024;
     TITLE_MAX = 300;
@@ -3375,7 +3697,6 @@ var init_session = __esm({
       ".webp": "image/webp"
     };
     METADATA_TYPE2 = "application/plune.metadata+json";
-    UPLOADS_AT_ONCE = 4;
     NAME_MAX = 200;
     SKIPPED = {
       hidden: "its name starts with an underscore, which hides an attachment in Playwright's own reports too",
@@ -4821,7 +5142,7 @@ function readPlaywrightJson(source, file) {
   const { config, suites } = parsed;
   const rootDir = typeof config?.rootDir === "string" ? config.rootDir : void 0;
   const buildHref = config?.metadata?.ci?.buildHref;
-  const repoRoot = rootDir !== void 0 && (0, import_node_fs5.existsSync)(rootDir) ? repoRootOf(rootDir) : void 0;
+  const repoRoot = rootDir !== void 0 && (0, import_node_fs6.existsSync)(rootDir) ? repoRootOf(rootDir) : void 0;
   const ctx = {
     ...rootDir !== void 0 ? { rootDir } : {},
     ...repoRoot !== void 0 ? { repoRoot } : {},
@@ -4840,12 +5161,12 @@ function readPlaywrightJson(source, file) {
 function looksLikePlaywrightJson(source) {
   return /^\s*\{/.test(source) && source.includes('"suites"');
 }
-var import_node_fs5, SOURCE3, TOKEN3, NOT_FAILED, JsonReportError;
+var import_node_fs6, SOURCE3, TOKEN3, NOT_FAILED, JsonReportError;
 var init_playwright_json = __esm({
   "src/importers/playwright-json.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs5 = require("fs");
+    import_node_fs6 = require("fs");
     init_failure_detail();
     init_result_key();
     SOURCE3 = "playwright";
@@ -4958,6 +5279,7 @@ async function handleRunImport(options) {
       ...options.fetchImpl !== void 0 ? { fetchImpl: options.fetchImpl } : {},
       ...options.key !== void 0 ? { externalKey: options.key } : {},
       ...options.create === true ? { offerDiscovered: true } : {},
+      ...options.uploadConcurrency !== void 0 ? { uploadConcurrency: options.uploadConcurrency } : {},
       kind: "automated",
       // The CI run the report names, never this machine's: whoever imports may be another job (#790).
       // The commit and branch likewise, where the report names a commit; a report that names none —
@@ -5872,11 +6194,11 @@ module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
 init_api_url();
 var import_commander = require("commander");
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path4 = require("path");
 var import_node_url = require("url");
 var __dirname = (0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
-var pkg = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path4.join)(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path4.join)(__dirname, "..", "package.json"), "utf-8"));
 function toFormat(s) {
   return s === "json" || s === "markdown" ? s : "console";
 }
@@ -5885,7 +6207,7 @@ function shouldColor(outputPath) {
 }
 function writeReport(text2, outputPath) {
   if (outputPath !== void 0) {
-    (0, import_node_fs6.writeFileSync)(outputPath, text2);
+    (0, import_node_fs7.writeFileSync)(outputPath, text2);
   } else {
     process.stdout.write(text2 + "\n");
   }
@@ -6110,6 +6432,13 @@ function createProgram() {
     "--fail-on-missing-attachments",
     "Exit 1 when a file the report names ([[ATTACHMENT|path]] in JUnit, a source in allure-results) is not there; the results are sent either way",
     false
+  ).option(
+    "--upload-concurrency <n>",
+    "File uploads in flight at once, 1 to 32 (default 4; PLUNE_UPLOAD_CONCURRENCY sets it too). Files are announced and confirmed up to 100 to a request; a 429 is retried PLUNE_UPLOAD_RETRIES times (default 6)",
+    (v) => {
+      if (!/^\d+$/.test(v) || Number(v) < 1 || Number(v) > 32) throw new import_commander.InvalidArgumentError("a whole number from 1 to 32.");
+      return Number(v);
+    }
   ).option("--fail-on-failures", FAIL_ON_FAILURES, false).action(
     async (file, options, command) => {
       const [
@@ -6135,6 +6464,7 @@ function createProgram() {
           ...format !== void 0 ? { format } : {},
           ...options.key !== void 0 ? { key: options.key } : {},
           ...options.create ? { create: true } : {},
+          ...options.uploadConcurrency !== void 0 ? { uploadConcurrency: options.uploadConcurrency } : {},
           ...options.failOnFailures ? { failOnFailures: true } : {}
         });
         if (options.failOnMissingAttachments && imported.missingAttachments.length > 0) process.exitCode = 1;
@@ -6376,7 +6706,7 @@ function isMainModule() {
   const entry = process.argv[1];
   if (entry === void 0) return false;
   try {
-    return (0, import_node_fs6.realpathSync)(entry) === (0, import_node_fs6.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
+    return (0, import_node_fs7.realpathSync)(entry) === (0, import_node_fs7.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
   } catch {
     return false;
   }