@plune-ai/cli 0.16.0 → 0.17.1

package/dist/cli.cjs

@@ -512,7 +512,7 @@ var init_retry = __esm({
     "use strict";
     init_cjs_shims();
     init_errors2();
-    defaultSleep = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
+    defaultSleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
   }
 });
 
@@ -874,7 +874,7 @@ var init_embedder = __esm({
           throw new Error(
             "The `semantic-similarity` and RAG assertions need local embeddings, which ship separately: install @huggingface/transformers to enable them. Every other assertion works without it."
           );
-        }).then(({ pipeline }) => pipeline("feature-extraction", MODEL_ID));
+        }).then(({ pipeline: pipeline2 }) => pipeline2("feature-extraction", MODEL_ID));
         return this.extractor;
       }
     };
@@ -2226,7 +2226,7 @@ var init_credentials = __esm({
 
 // src/reporter-core/client.ts
 function nodeTransport(url, init, idleMs = IDLE_MS) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const target = new URL(url);
     const send = target.protocol === "https:" ? import_node_https.request : import_node_http.request;
     const req = send(target, { method: init.method, headers: init.headers }, (res) => {
@@ -2236,7 +2236,7 @@ function nodeTransport(url, init, idleMs = IDLE_MS) {
       res.on("end", () => {
         const status = res.statusCode ?? 0;
         const text2 = Buffer.concat(chunks).toString("utf8");
-        resolve8({
+        resolve9({
           ok: status >= 200 && status <= 299,
           status,
           headers: {
@@ -2254,12 +2254,42 @@ function nodeTransport(url, init, idleMs = IDLE_MS) {
     req.end(init.body);
   });
 }
+function nodePut(url, headers, source, idleMs) {
+  return new Promise((resolve9, reject) => {
+    const target = new URL(url);
+    const send = target.protocol === "https:" ? import_node_https.request : import_node_http.request;
+    const length = "body" in source ? source.body.length : source.size;
+    let answered;
+    const settle = (err) => answered !== void 0 ? resolve9(answered) : reject(err);
+    const req = send(
+      target,
+      { method: "PUT", headers: { ...withoutLength(headers), "content-length": String(length) } },
+      (res) => {
+        const retry = res.headers["retry-after"];
+        answered = { status: res.statusCode ?? 0, retryAfter: Array.isArray(retry) ? retry[0] ?? null : retry ?? null };
+        res.on("error", settle);
+        res.on("close", () => {
+          resolve9(answered);
+          req.destroy();
+        });
+        res.resume();
+      }
+    );
+    req.setTimeout(idleMs, () => req.destroy(Object.assign(new Error("idle"), { code: "ETIMEDOUT" })));
+    req.on("error", settle);
+    if ("body" in source) req.end(source.body);
+    else (0, import_node_stream.pipeline)((0, import_node_fs2.createReadStream)(source.path), req, (err) => err ? settle(err) : void 0);
+  });
+}
 async function detailOf(res) {
   try {
     const body = await res.json();
-    return typeof body.error === "string" ? body.error : "";
+    return {
+      detail: typeof body.error === "string" ? body.error : "",
+      ...typeof body.code === "string" && /^[a-z0-9_]{1,60}$/.test(body.code) ? { code: body.code } : {}
+    };
   } catch {
-    return "";
+    return { detail: "" };
   }
 }
 function retryAfterMs2(res) {
@@ -2280,7 +2310,7 @@ function createClient(opts) {
   const wait = opts.wait ?? sleep;
   const base = opts.apiUrl.replace(/\/+$/, "");
   const scrub = (text2) => opts.token === "" ? text2 : text2.split(opts.token).join("***");
-  async function send(method, path15, payload) {
+  async function send(method, path17, payload) {
     let last = {
       kind: "unavailable",
       status: null,
@@ -2289,7 +2319,7 @@ function createClient(opts) {
     for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt += 1) {
       let res;
       try {
-        res = await doFetch(`${base}${path15}`, {
+        res = await doFetch(`${base}${path17}`, {
           method,
           headers: { "content-type": payload?.type ?? "application/json", authorization: `Bearer ${opts.token}` },
           // A DELETE carries none. Sending `"undefined"` as a body is what a naive
@@ -2310,10 +2340,16 @@ function createClient(opts) {
           return { ok: false, kind: "other", status: res.status, detail: "the answer was not JSON" };
         }
       }
-      const detail = scrub(await detailOf(res));
+      const said = await detailOf(res);
       const kind = classify3(res.status);
-      last = { kind, status: res.status, detail };
+      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) {
+        last.kind = "invalid";
+        last.detail = "quota exceeded (no Retry-After)";
+        if (said.detail) last.detail += ` \u2014 ${said.detail}`;
+        break;
+      }
       if (attempt < RETRY_DELAYS_MS.length) {
         await wait(retryAfterMs2(res) ?? RETRY_DELAYS_MS[attempt]);
       }
@@ -2321,20 +2357,57 @@ function createClient(opts) {
     return { ok: false, ...last };
   }
   return {
-    post: (path15, body) => send("POST", path15, { body: JSON.stringify(body), type: "application/json" }),
-    upload: (path15, bytes, contentType) => send("POST", path15, { body: bytes, type: contentType }),
-    del: (path15) => send("DELETE", path15)
+    post: (path17, body) => send("POST", path17, { body: JSON.stringify(body), type: "application/json" }),
+    upload: (path17, bytes, contentType) => send("POST", path17, { body: bytes, type: contentType }),
+    del: (path17) => send("DELETE", path17),
+    async put(url, headers, source) {
+      let last = { ok: false, status: null, code: "network" };
+      for (let attempt = 0; attempt <= PUT_DELAYS_MS.length; attempt += 1) {
+        try {
+          let status;
+          let retryAfter;
+          if (opts.fetchImpl === void 0) ({ status, retryAfter } = await nodePut(url, headers, source, IDLE_MS));
+          else {
+            const body = "body" in source ? source.body : await (0, import_node_fs2.openAsBlob)(source.path);
+            const res = await opts.fetchImpl(url, { method: "PUT", headers: withoutLength(headers), body });
+            await res.arrayBuffer().catch(() => void 0);
+            status = res.status;
+            retryAfter = res.headers.get("retry-after");
+          }
+          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]);
+          }
+          continue;
+        } catch (err) {
+          last = { ok: false, status: null, code: codeOfError(err) };
+        }
+        if (attempt < PUT_DELAYS_MS.length) await wait(PUT_DELAYS_MS[attempt]);
+      }
+      return last;
+    }
   };
 }
-var import_node_http, import_node_https, RETRY_DELAYS_MS, IDLE_MS, sleep;
+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 init_client = __esm({
   "src/reporter-core/client.ts"() {
     "use strict";
     init_cjs_shims();
+    import_node_fs2 = require("fs");
+    import_node_stream = require("stream");
     import_node_http = require("http");
     import_node_https = require("https");
     RETRY_DELAYS_MS = [300, 900];
     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;
+      return typeof code === "string" && /^[A-Z0-9_]{2,40}$/.test(code) ? code : "network";
+    };
     sleep = (ms) => new Promise((r) => setTimeout(r, ms));
   }
 });
@@ -2456,11 +2529,150 @@ var init_fallback = __esm({
   }
 });
 
+// src/reporter-core/failure-detail.ts
+function failureOf(attempt, home = (0, import_node_os2.homedir)()) {
+  const error = chosen(attempt);
+  const line = error === void 0 ? void 0 : firstLine(machineless(error.text, attempt.repoRoot, home));
+  const headline = line !== void 0 && jsonBytes(line) <= HEADLINE_LIMIT ? line : void 0;
+  const steps = chainOf(attempt.steps);
+  const location = error === void 0 ? void 0 : fromRoot(placeOf(error, attempt.testFile), attempt.repoRoot);
+  const artifacts = attempt.attachments.filter((a) => a.path !== void 0 && !a.name.startsWith("_") && a.contentType !== METADATA_TYPE).map(({ name, contentType }) => ({ name: fileNameOf(name), ...contentType ? { contentType } : {} })).filter((a) => a.name !== "");
+  const ciUrl = webLink(attempt.buildHref);
+  const failure = {
+    ...headline !== void 0 ? { headline } : {},
+    ...steps.length > 0 ? { steps } : {},
+    ...location !== void 0 ? { location } : {},
+    ...artifacts.length > 0 ? { artifacts } : {},
+    ...ciUrl !== void 0 ? { ciUrl } : {}
+  };
+  return Object.keys(failure).length === 0 ? void 0 : failure;
+}
+function repoRootOf(dir, stopAt) {
+  for (let here = (0, import_node_path2.resolve)(dir); ; here = (0, import_node_path2.dirname)(here)) {
+    if ((0, import_node_fs3.existsSync)((0, import_node_path2.join)(here, ".git"))) return here;
+    if (here === stopAt || (0, import_node_path2.dirname)(here) === here) return void 0;
+  }
+}
+function errorContextOf(attempt, home = (0, import_node_os2.homedir)()) {
+  const text2 = attempt.errors.map((e) => e.text).filter((t) => t !== "").join("\n\n");
+  return cut(machineless(text2, attempt.repoRoot, home));
+}
+function filesOf(attempt) {
+  return attempt.attachments.filter((a) => a.path !== void 0 || a.body !== void 0 && isTextType(a.contentType));
+}
+function machineless(raw, repoRoot, home) {
+  let text2 = (0, import_node_util.stripVTControlCharacters)(raw).replaceAll("\x1B", "");
+  const root = repoRoot === void 0 ? void 0 : pathIn(repoRoot);
+  if (root !== void 0) text2 = text2.replace(new RegExp(`${PATH_START}${root.source}[\\\\/]+`, root.flags), "");
+  const own = pathIn(home);
+  if (own !== void 0) text2 = text2.replace(new RegExp(`${PATH_START}${own.source}(?![\\w.-])`, own.flags), "~");
+  if (repoRoot === void 0) text2 = text2.replace(ANY_HOME, "~");
+  return text2;
+}
+function pathIn(path17) {
+  const parts = path17.split(/[\\/]+/);
+  while (parts.length > 1 && parts.at(-1) === "") parts.pop();
+  if (!parts.some((part) => part !== "" && !/^[A-Za-z]:$/.test(part))) return void 0;
+  const joined = parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\\\/]+");
+  const escaped = /^\/(?!\/)/.test(path17) ? joined.replace("[\\\\/]+", "\\\\*\\/") : joined;
+  const url = "(?:(?:file|webpack|webpack-internal):(?:\\\\*\\/){2,3})?";
+  return new RegExp(`${url}${escaped}`, /^[A-Za-z]:$/.test(parts[0]) ? "gi" : "g");
+}
+function cut(text2) {
+  if (jsonBytes(text2) <= TEXT_LIMIT) return text2;
+  const lines = text2.split("\n");
+  const size = lines.map((line) => jsonBytes(line) + 2);
+  const budget = TEXT_LIMIT - jsonBytes(omitted(lines.length));
+  let used = 0;
+  let head = 0;
+  let tail = lines.length;
+  while (head < tail && used + size[head] <= budget / 2) used += size[head++];
+  while (tail > head && used + size[tail - 1] <= budget) used += size[--tail];
+  return [...lines.slice(0, head), omitted(tail - head), ...lines.slice(tail)].join("\n");
+}
+function chosen({ status, errors }) {
+  if (status === "timedOut") {
+    const timeout = errors.findIndex((e) => firstLine(e.text)?.startsWith("Test timeout of ") === true);
+    if (timeout !== -1 && timeout + 1 < errors.length) return errors[timeout + 1];
+  }
+  return errors[0];
+}
+function chainOf(steps) {
+  const chain = [];
+  for (let failed = steps.find((s) => s.failed); failed !== void 0; failed = failed.steps.find((s) => s.failed)) {
+    chain.push(failed.title);
+  }
+  return chain;
+}
+function placeOf(error, testFile) {
+  const own = normal(testFile);
+  let first;
+  for (const line of (0, import_node_util.stripVTControlCharacters)(error.text).split("\n")) {
+    if (line.length > FRAME_MAX) continue;
+    const frame = FRAME.exec(line);
+    if (frame === null) continue;
+    const place = { file: fileOf(frame[1]), line: Number(frame[2]), column: Number(frame[3]) };
+    if (normal(place.file) === own) return place;
+    if (first === void 0 && !normal(place.file).includes("/node_modules/")) first = place;
+  }
+  return error.location ?? first;
+}
+function fileOf(raw) {
+  if (!raw.startsWith("file://")) return raw;
+  let path17 = raw.slice("file://".length);
+  try {
+    path17 = decodeURIComponent(path17);
+  } catch {
+  }
+  return /^\/[A-Za-z]:\//.test(path17) ? path17.slice(1) : path17;
+}
+function fromRoot(place, root) {
+  if (place === void 0 || root === void 0 || !Number.isInteger(place.line) || place.line < 1) return void 0;
+  const base = normal(root).replace(/\/+$/, "");
+  const file = normal(place.file);
+  if (!file.startsWith(`${base}/`)) return void 0;
+  const relative3 = file.slice(base.length + 1);
+  if (!REPO_RELATIVE.test(relative3)) return void 0;
+  const column = place.column !== void 0 && Number.isInteger(place.column) && place.column >= 1 ? place.column : void 0;
+  return column === void 0 ? { file: relative3, line: place.line } : { file: relative3, line: place.line, column };
+}
+function webLink(href) {
+  return href !== void 0 && /^https?:\/\//i.test(href) && URL.canParse(href) ? href : void 0;
+}
+var import_node_fs3, import_node_os2, import_node_path2, import_node_util, printable, mediaTypeOf, TEXT_TYPES, isTextType, PATH_START, TEXT_LIMIT, HEADLINE_LIMIT, jsonBytes, ANY_HOME, fileNameOf, omitted, METADATA_TYPE, REPO_RELATIVE, FRAME, FRAME_MAX, firstLine, normal;
+var init_failure_detail = __esm({
+  "src/reporter-core/failure-detail.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs3 = require("fs");
+    import_node_os2 = require("os");
+    import_node_path2 = require("path");
+    import_node_util = require("util");
+    printable = (text2) => text2.replace(/[\u0000-\u001f\u007f-\u009f]/g, "?");
+    mediaTypeOf = (contentType) => contentType?.split(";")[0]?.trim().toLowerCase() || void 0;
+    TEXT_TYPES = /* @__PURE__ */ new Set(["application/json", "text/plain"]);
+    isTextType = (contentType) => TEXT_TYPES.has(mediaTypeOf(contentType) ?? "");
+    PATH_START = "(?<![\\w.~%/\\\\-])";
+    TEXT_LIMIT = 524288;
+    HEADLINE_LIMIT = 8 * 1024;
+    jsonBytes = (text2) => Buffer.byteLength(JSON.stringify(text2)) - 2;
+    ANY_HOME = /(?<=^|[\s'"`(=,[])(?:(?:file|webpack|webpack-internal):(?:\\*\/){2,3})?(?:\\*\/home\\*\/|\\*\/Users\\*\/|[A-Za-z]:[\\/]+Users[\\/]+)[^\\/\s'"`:*?<>|]+/g;
+    fileNameOf = (name) => /^(?:file:\/\/|[\\/]|~[\\/]|[A-Za-z]:[\\/])/.test(name) ? name.split(/[\\/]/).pop() ?? "" : name;
+    omitted = (lines) => `\u2026[omitted ${lines} lines]\u2026`;
+    METADATA_TYPE = "application/plune.metadata+json";
+    REPO_RELATIVE = /^(?![A-Za-z][A-Za-z0-9+.-]*:)(?![\\/~])(?!(?:.*[\\/])?\.\.(?:[\\/]|$)).+$/;
+    FRAME = /^\s+at (?:.*? \()?(.+?):(\d+):(\d+)\)?$/;
+    FRAME_MAX = 8192;
+    firstLine = (text2) => (0, import_node_util.stripVTControlCharacters)(text2).split("\n").map((line) => line.trim()).find((line) => line !== "");
+    normal = (path17) => import_node_path2.posix.normalize(path17.replace(/\\/g, "/")).replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
+  }
+});
+
 // src/reporter-core/session.ts
 function nameOf(file) {
-  const own = file.name.split(/[\\/]/).pop()?.trim() || (0, import_node_path2.basename)(file.path);
-  const fileExt = (0, import_node_path2.extname)(file.path);
-  const ownExt = (0, import_node_path2.extname)(own);
+  const own = file.name.split(/[\\/]/).pop()?.trim() || (file.path === void 0 ? "" : (0, import_node_path3.basename)(file.path));
+  const fileExt = file.path === void 0 ? "" : (0, import_node_path3.extname)(file.path);
+  const ownExt = (0, import_node_path3.extname)(own);
   const typed = ownExt !== "" && (ownExt.toLowerCase() === fileExt.toLowerCase() || TYPE_BY_EXTENSION[ownExt.toLowerCase()] !== void 0);
   const ext = typed ? ownExt : fileExt;
   let stem = typed ? own.slice(0, -ownExt.length) : own;
@@ -2470,6 +2682,41 @@ function nameOf(file) {
   }
   return `${stem}${ext}`;
 }
+function kindOf(type) {
+  if (type.startsWith("image/")) return "screenshot";
+  return TEXT_TYPES.has(type) ? "text" : "file";
+}
+function linkOf(item) {
+  const link = item;
+  if (typeof link?.id !== "string" || typeof link.url !== "string") return void 0;
+  const headers = typeof link.headers === "object" && link.headers !== null ? link.headers : {};
+  return { id: link.id, url: link.url, headers };
+}
+function textTypeOf(contentType, type) {
+  const charset = /;\s*charset\s*=\s*"?([^\s";]+)"?/i.exec(contentType)?.[1];
+  return charset?.toLowerCase() === "utf-8" ? `${type}; charset=utf-8` : type;
+}
+function textRefusal(bytes) {
+  if (bytes.length > TEXT_BYTES) return "textSize";
+  if (bytes.length === 0) return "empty";
+  if (bytes.includes(0)) return "binary";
+  try {
+    UTF8.decode(bytes);
+  } catch {
+    return "encoding";
+  }
+  return void 0;
+}
+function onDisk(result) {
+  if (!("files" in result) || result.files === void 0) return result;
+  const { files, ...rest } = result;
+  const kept = files.filter((f) => f.path !== void 0).map(({ body: _body, ...file }) => file);
+  return kept.length === 0 ? rest : { ...rest, files: kept };
+}
+function tally(counts, noun) {
+  if (counts.uploaded + counts.skipped + counts.failed === 0) return void 0;
+  return `${counts.uploaded} ${noun}(s) uploaded` + (counts.skipped > 0 ? `, ${counts.skipped} skipped` : "") + (counts.failed > 0 ? `, ${counts.failed} failed to upload` : "");
+}
 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);
@@ -2516,7 +2763,7 @@ function warnIfDropped(sent, run, log) {
     `plune: this deployment stored none of ${names.join(", ")} \u2014 it is older than the fields. The run is otherwise reported in full.`
   );
 }
-async function startRun(passed, declared) {
+async function startRun(passed, declared2) {
   const env = readEnv();
   const stated = Object.fromEntries(Object.entries(passed).filter(([, v]) => v !== void 0));
   const cfg = { ...env.config, ...stated };
@@ -2543,7 +2790,9 @@ async function startRun(passed, declared) {
     created: 0,
     unoffered: 0,
     deferred: 0,
-    screenshots: { uploaded: 0, skipped: 0, failed: 0 }
+    screenshots: { uploaded: 0, skipped: 0, failed: 0 },
+    textFiles: { uploaded: 0, skipped: 0, failed: 0 },
+    otherFiles: { uploaded: 0, skipped: 0, failed: 0 }
   };
   const resolved = /* @__PURE__ */ new Map();
   let buffer = [];
@@ -2554,6 +2803,13 @@ async function startRun(passed, declared) {
   let done = false;
   const shortened = /* @__PURE__ */ new Set();
   const skipsSaid = /* @__PURE__ */ new Set();
+  const countsOf = (kind) => kind === "text" ? stats.textFiles : kind === "file" ? stats.otherFiles : stats.screenshots;
+  let bucketSeen = false;
+  let noStorage = 0;
+  let uploadsMissing = false;
+  const failedSaid = /* @__PURE__ */ new Set();
+  const codesSaid = /* @__PURE__ */ new Set();
+  const rooms = /* @__PURE__ */ new Map();
   function bound(keys) {
     return keys.map((key) => {
       const fit = boundKey(key);
@@ -2561,14 +2817,14 @@ async function startRun(passed, declared) {
         shortened.add(key.value);
         if (shortened.size === 1) {
           log(
-            `plune: a test name longer than ${KEY_MAX} characters was shortened to fit its key \u2014 "${key.value.slice(0, 80)}\u2026". Give the test a shorter name; until then this is its identity.`
+            `plune: a test name longer than ${KEY_MAX} characters was shortened to fit its key \u2014 ${JSON.stringify(printable(key.value.slice(0, 80)))}\u2026 Give the test a shorter name; until then this is its identity.`
           );
         }
       }
       return fit;
     });
   }
-  const expected = declared?.map(bound);
+  const expected = declared2?.map(bound);
   if (offline) {
     log('plune: no API token \u2014 run "plune login" first. Results will be written to the fallback file.');
   }
@@ -2581,7 +2837,7 @@ async function startRun(passed, declared) {
       externalKey,
       session: sessionMarker,
       ...cfg.meta !== void 0 ? { meta: cfg.meta } : {},
-      results
+      results: results.map(onDisk)
     });
     stats.deferred += results.length;
   }
@@ -2689,57 +2945,173 @@ async function startRun(passed, declared) {
       stats.created += out.body.results.filter((r) => r?.outcome === "created").length;
     }
   }
-  function skip(name, why) {
-    stats.screenshots.skipped += 1;
-    if (skipsSaid.has(why)) return;
-    skipsSaid.add(why);
-    log(`plune: screenshot "${name}" not uploaded \u2014 ${SKIPPED[why]}.`);
+  function skip(kind, name, why) {
+    countsOf(kind).skipped += 1;
+    if (why === "noStorage") noStorage += 1;
+    const said = why === "noStorage" ? why : `${kind}/${why}`;
+    if (skipsSaid.has(said)) return;
+    skipsSaid.add(said);
+    if (why === "noStorage") log(`plune: "${name}" not stored \u2014 ${SKIPPED[why]}.`);
+    else log(`plune: ${KINDS[kind].label} "${name}" not uploaded \u2014 ${SKIPPED[why]}.`);
+  }
+  function ask(job, size) {
+    return client.post(`/v1/results/${encodeURIComponent(job.id)}/files/uploads`, {
+      files: [{ name: job.name, contentType: job.type, size }]
+    });
+  }
+  function failed(job, why) {
+    countsOf(job.kind).failed += 1;
+    if (!failedSaid.has(job.kind)) {
+      failedSaid.add(job.kind);
+      log(`plune: could not upload a ${KINDS[job.kind].label} (${why}) \u2014 its result is reported without it.`);
+    }
+  }
+  function failedToBucket(job, code) {
+    countsOf(job.kind).failed += 1;
+    if (codesSaid.has(code)) return;
+    codesSaid.add(code);
+    log(`plune: "${job.name}" not uploaded to your bucket (${code}) \u2014 its result is reported without it.`);
   }
-  async function uploadOne(shot) {
+  function refusedHere(job, size) {
+    if (job.kind === "screenshot") {
+      if (!SCREENSHOT_TYPES.has(job.type)) return "type";
+      if (size > SCREENSHOT_BYTES) return "size";
+    }
+    if (job.kind === "text" && size > TEXT_BYTES) return "textSize";
+    return void 0;
+  }
+  async function uploadDirect(job, size) {
+    const { kind } = job;
+    if (kind === "file") return skip(kind, job.name, "noStorage");
+    const { bytes: ceiling, size: tooBig } = KINDS[kind];
+    if (size > ceiling) return skip(kind, job.name, tooBig);
     let bytes;
-    try {
-      if ((await import_node_fs2.promises.stat(shot.path)).size > SCREENSHOT_BYTES) return skip(shot.name, "size");
-      bytes = await import_node_fs2.promises.readFile(shot.path);
-    } catch {
-      return skip(shot.name, "missing");
+    if (job.body !== void 0) bytes = job.body;
+    else {
+      try {
+        bytes = await import_node_fs4.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);
     const out = await client.upload(
-      `/v1/results/${encodeURIComponent(shot.id)}/files?name=${encodeURIComponent(shot.name)}`,
+      `/v1/results/${encodeURIComponent(job.id)}/files?name=${encodeURIComponent(job.name)}`,
       bytes,
-      shot.type
+      job.type
     );
-    if (out.ok) {
-      stats.screenshots.uploaded += 1;
-      return;
+    if (out.ok) countsOf(kind).uploaded += 1;
+    else failed(job, out.detail || out.kind);
+  }
+  async function uploadToBucket(job, size, first) {
+    const source = job.body !== void 0 ? { body: job.body } : { path: job.path, 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(job, put.code);
+      renewed = true;
+      const again = await ask(job, size);
+      if (!again.ok) return failedToBucket(job, codeOf2(again));
+      const fresh = linkOf(again.body?.files?.[0]);
+      if (fresh === void 0) return failedToBucket(job, "bad_answer");
+      link = fresh;
+    }
+    const done2 = await client.post(`/v1/files/${encodeURIComponent(link.id)}/complete`, {});
+    if (!done2.ok) return failedToBucket(job, codeOf2(done2));
+    countsOf(job.kind).uploaded += 1;
+  }
+  let free = UPLOADS_AT_ONCE;
+  const waiting = [];
+  async function gated(work) {
+    if (free === 0) await new Promise((resolve9) => waiting.push(resolve9));
+    else free -= 1;
+    try {
+      return await work();
+    } finally {
+      const next = waiting.shift();
+      if (next !== void 0) next();
+      else free += 1;
     }
-    stats.screenshots.failed += 1;
-    if (stats.screenshots.failed === 1) {
-      log(`plune: could not upload a screenshot (${out.detail || out.kind}) \u2014 its result is reported without it.`);
+  }
+  async function plan(job) {
+    const { kind } = job;
+    let size;
+    if (job.body !== void 0) size = job.body.length;
+    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;
+      } catch {
+        return void skip(kind, job.name, "missing");
+      }
+    }
+    if (size === 0) return void skip(kind, job.name, "empty");
+    const direct = () => {
+      if (kind === "file") return void skip(kind, job.name, "noStorage");
+      const roomKey = `${job.id}/${kind}`;
+      const left = rooms.get(roomKey) ?? KINDS[kind].room;
+      if (left === 0) return void skip(kind, job.name, KINDS[kind].limit);
+      rooms.set(roomKey, left - 1);
+      return () => uploadDirect(job, size);
+    };
+    if (uploadsMissing) return direct();
+    const out = await gated(() => ask(job, size));
+    if (!out.ok) {
+      if (out.status === 404 && out.detail === "" && out.code === void 0) {
+        uploadsMissing = true;
+        return direct();
+      }
+      if (out.code !== void 0) failedToBucket(job, out.code);
+      else failed(job, out.detail || out.kind);
+      return void 0;
+    }
+    const item = out.body?.files?.[0];
+    if (item?.skipped === "no_storage") return void skip(kind, job.name, refusedHere(job, size) ?? "noStorage");
+    if (item?.direct === true) return direct();
+    const link = linkOf(item);
+    if (link === void 0) return void failed(job, "bad_answer");
+    if (!bucketSeen) {
+      bucketSeen = true;
+      log(BUCKET_FOUND);
     }
+    return () => uploadToBucket(job, size, link);
   }
   async function upload(items, filesByKey) {
     if (filesByKey.size === 0 || !Array.isArray(items)) return;
-    const shots = [];
+    const jobs = [];
     for (const item of items) {
       if (item?.status !== "accepted" || typeof item.id !== "string" || typeof item.resultKey !== "string") continue;
-      let room = SCREENSHOTS_PER_RESULT;
       for (const file of filesByKey.get(item.resultKey) ?? []) {
-        const type = file.contentType?.split(";")[0]?.trim().toLowerCase() || TYPE_BY_EXTENSION[(0, import_node_path2.extname)(file.path).toLowerCase()];
-        if (!type?.startsWith("image/")) continue;
+        const type = mediaTypeOf(file.contentType) ?? (file.path === void 0 ? void 0 : TYPE_BY_EXTENSION[(0, import_node_path3.extname)(file.path).toLowerCase()]);
+        if (type === void 0 || type === METADATA_TYPE2) continue;
+        const kind = kindOf(type);
+        if (kind !== "text" && file.path === void 0) continue;
         const name = nameOf(file);
-        if (file.name.startsWith("_")) skip(name, "hidden");
-        else if (!SCREENSHOT_TYPES.has(type)) skip(name, "type");
-        else if (room === 0) skip(name, "limit");
+        if (file.name.startsWith("_")) skip(kind, name, "hidden");
         else {
-          room -= 1;
-          shots.push({ id: item.id, name, type, path: file.path });
+          jobs.push({
+            id: item.id,
+            kind,
+            name,
+            type: kind === "text" ? textTypeOf(file.contentType ?? "", type) : type,
+            ...file.body !== void 0 ? { body: file.body } : {},
+            ...file.path !== void 0 ? { path: file.path } : {}
+          });
         }
       }
     }
-    let next = 0;
+    const byResult = /* @__PURE__ */ new Map();
+    for (const job of jobs) byResult.set(job.id, [...byResult.get(job.id) ?? [], job]);
     await Promise.all(
-      Array.from({ length: Math.min(UPLOADS_AT_ONCE, shots.length) }, async () => {
-        while (next < shots.length) await uploadOne(shots[next++]);
+      [...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);
       })
     );
   }
@@ -2817,11 +3189,20 @@ async function startRun(passed, declared) {
     if (stats.unresolved > 0) parts.push(`${stats.unresolved} with no matching test case`);
     if (stats.offered > 0) parts.push(`${stats.offered} offered for review`);
     if (stats.created > 0) parts.push(`${stats.created} added as cases (trusted source)`);
-    const shots = stats.screenshots;
-    if (shots.uploaded + shots.skipped + shots.failed > 0) {
+    const kinds = [stats.screenshots, stats.textFiles, stats.otherFiles];
+    const sum = (what) => kinds.reduce((n, counts) => n + counts[what], 0);
+    if (bucketSeen) {
+      const other = sum("skipped") - noStorage;
       parts.push(
-        `${shots.uploaded} screenshot(s) uploaded` + (shots.skipped > 0 ? `, ${shots.skipped} skipped` : "") + (shots.failed > 0 ? `, ${shots.failed} failed to upload` : "")
+        `${sum("uploaded")} file(s) uploaded to your bucket` + (noStorage > 0 ? `, ${noStorage} skipped (no bucket connected)` : "") + (other > 0 ? `, ${other} skipped` : "") + (sum("failed") > 0 ? `, ${sum("failed")} failed to upload` : "")
       );
+    } else {
+      for (const said of [tally(stats.screenshots, "screenshot"), tally(stats.textFiles, "text file")]) {
+        if (said !== void 0) parts.push(said);
+      }
+      const other = stats.otherFiles;
+      if (other.skipped > 0) parts.push(`${other.skipped} file(s) not stored (no bucket connected)`);
+      if (other.failed > 0) parts.push(`${other.failed} file(s) failed to upload`);
     }
     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`);
@@ -2874,18 +3255,20 @@ async function startRun(passed, declared) {
     }
   };
 }
-var import_node_crypto2, import_node_fs2, import_node_path2, RESOLVE_CHUNK, BATCH_MAX, DISCOVER_MAX, BATCH_DEFAULT, EXPECTED_MAX, KEY_MAX, TITLE_MAX, COUNTED, SCREENSHOT_TYPES, SCREENSHOT_BYTES, SCREENSHOTS_PER_RESULT, TYPE_BY_EXTENSION, UPLOADS_AT_ONCE, NAME_MAX, SKIPPED, BATCH_BYTES, ENVELOPE_BYTES;
+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 init_session = __esm({
   "src/reporter-core/session.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_crypto2 = require("crypto");
-    import_node_fs2 = require("fs");
-    import_node_path2 = require("path");
+    import_node_fs4 = require("fs");
+    import_node_path3 = require("path");
+    import_node_util2 = require("util");
     init_api_url();
     init_credentials();
     init_client();
     init_env2();
+    init_failure_detail();
     init_fallback();
     RESOLVE_CHUNK = 500;
     BATCH_MAX = 500;
@@ -2898,12 +3281,16 @@ var init_session = __esm({
     SCREENSHOT_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp"]);
     SCREENSHOT_BYTES = 2 * 1024 * 1024;
     SCREENSHOTS_PER_RESULT = 20;
+    TEXT_BYTES = 512 * 1024;
+    TEXTS_PER_RESULT = 10;
+    UTF8 = new import_node_util2.TextDecoder("utf-8", { fatal: true });
     TYPE_BY_EXTENSION = {
       ".png": "image/png",
       ".jpg": "image/jpeg",
       ".jpeg": "image/jpeg",
       ".webp": "image/webp"
     };
+    METADATA_TYPE2 = "application/plune.metadata+json";
     UPLOADS_AT_ONCE = 4;
     NAME_MAX = 200;
     SKIPPED = {
@@ -2911,8 +3298,22 @@ var init_session = __esm({
       type: "Plune takes PNG, JPEG and WebP",
       limit: `a result holds at most ${SCREENSHOTS_PER_RESULT}`,
       missing: "the file cannot be read on this machine",
-      size: "Plune takes a file of at most 2 MB"
+      size: "Plune takes a file of at most 2 MB",
+      textLimit: `a result holds at most ${TEXTS_PER_RESULT} text files`,
+      textSize: "Plune takes a text file of at most 512 KiB",
+      empty: "the file is empty",
+      binary: "the file holds a NUL byte, and Plune takes UTF-8 text without one",
+      encoding: "Plune takes UTF-8 text only",
+      noStorage: "no storage bucket is connected to this project"
     };
+    BUCKET_FOUND = "plune: storage bucket found for this project \u2014 screenshots, text, trace and video go straight to it over short-lived links.";
+    KINDS = {
+      screenshot: { label: "screenshot", bytes: SCREENSHOT_BYTES, room: SCREENSHOTS_PER_RESULT, limit: "limit", size: "size" },
+      text: { label: "text file", bytes: TEXT_BYTES, room: TEXTS_PER_RESULT, limit: "textLimit", size: "textSize" },
+      // Only the label is used: a file of this kind has no home in the database, so no ceiling of its own is known here.
+      file: { label: "file", bytes: 0, room: 0, limit: "limit", size: "size" }
+    };
+    codeOf2 = (out) => out.code ?? (out.status === null ? "network" : `http_${out.status}`);
     BATCH_BYTES = 8 * 1024 * 1024;
     ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({ results: [] }));
   }
@@ -3003,21 +3404,21 @@ async function handleRunDelete(id, options = {}) {
     );
   }
   write(`Run ${id} deleted, with its results and the review-queue entries it produced.`);
-  write("Recoverable for six months \u2014 ask Plune to put it back.");
+  write("Recoverable for 30 days \u2014 ask Plune to put it back.");
 }
 async function handleRunExec(options) {
   const [command, ...args] = options.argv;
   if (command === void 0) throw new RunCommandError("Nothing to run \u2014 pass a command after `--`.");
   const run = await handleRunStart(options);
   const spawnImpl = options.spawnImpl ?? import_node_child_process.spawn;
-  const code = await new Promise((resolve8) => {
+  const code = await new Promise((resolve9) => {
     const child = spawnImpl(command, args, {
       stdio: "inherit",
       shell: process.platform === "win32",
       env: { ...process.env, PLUNE_RUN: run.externalKey, PLUNE_PROCEED: "1" }
     });
-    child.on("close", (exitCode) => resolve8(exitCode ?? 1));
-    child.on("error", () => resolve8(1));
+    child.on("close", (exitCode) => resolve9(exitCode ?? 1));
+    child.on("error", () => resolve9(1));
   });
   await handleRunFinish(run.id, options);
   return code;
@@ -3148,6 +3549,346 @@ var init_result_key = __esm({
   }
 });
 
+// src/importers/attachments.ts
+function reportFolder(report) {
+  const folder = path9.dirname(path9.resolve(report));
+  try {
+    return fs8.realpathSync(folder);
+  } catch {
+    return folder;
+  }
+}
+function reportFolders(report) {
+  return { lexical: path9.dirname(path9.resolve(report)), real: reportFolder(report) };
+}
+function within(folder, target) {
+  const rel = path9.relative(folder, target);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${path9.sep}`) && !path9.isAbsolute(rel);
+}
+function resolveAttachment(folder, ref, lexical = folder) {
+  if (/^[\\/]{2}/.test(ref) || ref.includes("\0")) return { why: "outside" };
+  const face = path9.resolve(lexical, ref);
+  if (!within(lexical, face) && !within(folder, face)) return { why: "outside" };
+  let real;
+  try {
+    real = fs8.realpathSync(path9.resolve(folder, ref));
+  } catch {
+    return { why: "absent" };
+  }
+  if (!within(folder, real)) return { why: "outside" };
+  try {
+    return fs8.statSync(real).isFile() ? { file: real } : { why: "not-a-file" };
+  } catch {
+    return { why: "absent" };
+  }
+}
+function markersOf(test) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const stream of test.children) {
+    if (stream.name !== "system-out" && stream.name !== "system-err") continue;
+    for (const match of stream.text.matchAll(MARKER)) {
+      const ref = match[1]?.trim() ?? "";
+      if (ref !== "") refs.add(ref);
+    }
+  }
+  return [...refs];
+}
+function filesOfTest(test, folder, title, missing, options = {}) {
+  const files = [];
+  const all = markersOf(test);
+  if (all.length > MARKERS_PER_TEST) {
+    options.notes?.push(
+      `plune: ${JSON.stringify(printable(title))}: ${all.length - MARKERS_PER_TEST} more markers ignored (at most ${MARKERS_PER_TEST} per test)`
+    );
+  }
+  for (const ref of all.slice(0, MARKERS_PER_TEST)) {
+    const found = resolveAttachment(folder, ref, options.lexical);
+    if (!("file" in found)) {
+      missing.push({ title, path: ref, ...options.resultKey !== void 0 ? { resultKey: options.resultKey } : {} });
+      continue;
+    }
+    const real = found.file;
+    if (!files.some((f) => f.path === real)) {
+      files.push({ name: printable(ref.split(/[\\/]/).pop() || path9.basename(real)), contentType: typeOfFile(real), path: real });
+    }
+  }
+  return files;
+}
+var fs8, path9, MARKER, TYPES, typeOfFile, MARKERS_PER_TEST;
+var init_attachments = __esm({
+  "src/importers/attachments.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs8 = __toESM(require("fs"), 1);
+    path9 = __toESM(require("path"), 1);
+    init_failure_detail();
+    MARKER = /^[ \t]*\[\[ATTACHMENT\|([^\r\n]*?)\]\][ \t]*$/gm;
+    TYPES = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".webp": "image/webp",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".json": "application/json",
+      ".txt": "text/plain",
+      ".log": "text/plain",
+      ".md": "text/plain",
+      ".csv": "text/csv",
+      ".html": "text/html",
+      ".htm": "text/html",
+      ".xml": "application/xml",
+      ".pdf": "application/pdf",
+      ".zip": "application/zip",
+      ".webm": "video/webm",
+      ".mp4": "video/mp4",
+      ".har": "application/json"
+    };
+    typeOfFile = (file) => TYPES[path9.extname(file).toLowerCase()] ?? "application/octet-stream";
+    MARKERS_PER_TEST = 100;
+  }
+});
+
+// src/importers/allure.ts
+function isFolder(path17) {
+  try {
+    return fs9.statSync(path17).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function load(file, maxBytes) {
+  let size;
+  try {
+    size = fs9.statSync(file).size;
+  } catch (err) {
+    throw new AllureReportError(`${printable(file)} \u2014 cannot read \u2014 ${printable(err instanceof Error ? err.message : String(err))}`);
+  }
+  if (size > maxBytes) {
+    throw new AllureReportError(`${printable(file)} \u2014 ${size} bytes, over the ${maxBytes} an Allure result may have; not read.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs9.readFileSync(file, "utf8"));
+  } catch (err) {
+    throw new AllureReportError(`${printable(file)} \u2014 not JSON \u2014 ${printable(err instanceof Error ? err.message : String(err))}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new AllureReportError(`${printable(file)} \u2014 not an Allure result: expected a JSON object.`);
+  }
+  return parsed;
+}
+function listOf(v) {
+  const out = [];
+  if (!Array.isArray(v)) return out;
+  for (const x of v) if (typeof x === "object" && x !== null && !Array.isArray(x)) out.push(x);
+  return out;
+}
+function keyOf(r, name) {
+  const full = textOf(r.fullName);
+  if (name.endsWith("]") && full.includes("#")) return `${full.split("#")[0]}#${name}`;
+  let base;
+  if (full.includes(" \u203A ")) base = full.split(" \u203A ").join("#");
+  else if (full.includes("#")) base = full;
+  else if (labelOf(r, "package") !== "") base = `${labelOf(r, "package")}#${name}`;
+  else base = full !== "" ? full : name;
+  const params = listOf(r.parameters).map((p) => textOf(p.value));
+  return params.length > 0 && !base.endsWith("]") ? `${base}[${params.join("-")}]` : base;
+}
+function labelGroup(r) {
+  const out = [];
+  for (const l of ["parentSuite", "suite", "subSuite"]) {
+    const v = labelOf(r, l);
+    if (v !== "" && out.at(-1) !== v) out.push(v);
+  }
+  return out;
+}
+function attachmentsOf(holder, out) {
+  let deep = false;
+  const todo = [{ h: holder, depth: 0 }];
+  while (todo.length > 0) {
+    const { h, depth } = todo.pop();
+    for (const a of listOf(h.attachments)) out.push(a);
+    const steps = listOf(h.steps);
+    if (depth >= MAX_DEPTH) {
+      deep ||= steps.length > 0;
+      continue;
+    }
+    for (let i = steps.length - 1; i >= 0; i--) todo.push({ h: steps[i], depth: depth + 1 });
+  }
+  return deep;
+}
+function readAllure(dir, missing = [], notes = [], maxBytes = MAX_JSON_BYTES) {
+  if (!isFolder(dir)) throw new AllureReportError(`${printable(dir)} \u2014 not a folder.`);
+  const resultNames = namesIn(dir, RESULT);
+  if (resultNames.length === 0) {
+    throw new AllureReportError(
+      `${printable(dir)} \u2014 no *-result.json files in it, so there is no Allure report to read. Point at the folder an Allure adapter wrote (pytest --alluredir, allure-results), or at a JUnit or Playwright JSON file.`
+    );
+  }
+  const { lexical, real: folder } = reportFolders(path10.join(dir, "_"));
+  const tests = resultNames.map((n) => load(path10.join(dir, n), maxBytes));
+  const containers = namesIn(dir, CONTAINER).map((n) => load(path10.join(dir, n), maxBytes));
+  const direct = /* @__PURE__ */ new Map();
+  for (const c of containers) {
+    for (const child of Array.isArray(c.children) ? c.children : []) {
+      if (typeof child !== "string") continue;
+      const list2 = direct.get(child);
+      if (list2 === void 0) direct.set(child, [c]);
+      else list2.push(c);
+    }
+  }
+  const around = (uuid) => {
+    const seen = /* @__PURE__ */ new Set();
+    const todo = [uuid];
+    while (todo.length > 0) {
+      for (const c of direct.get(todo.pop()) ?? []) {
+        if (seen.has(c)) continue;
+        seen.add(c);
+        if (typeof c.uuid === "string") todo.push(c.uuid);
+      }
+    }
+    return [...seen];
+  };
+  const ctx = { folder, lexical, missing, notes, around, direct };
+  const groups = /* @__PURE__ */ new Map();
+  tests.forEach((r, i) => {
+    const id = textOf(r.historyId);
+    const g = id === "" ? `\0${i}` : id;
+    const list2 = groups.get(g);
+    if (list2 === void 0) groups.set(g, [r]);
+    else list2.push(r);
+  });
+  const out = [];
+  for (const attempts of groups.values()) {
+    const ordered = attempts.map((r, i) => ({ r, i })).sort(
+      (a, b) => stopOf(a.r) - stopOf(b.r) || (timeOf(a.r.start) ?? 0) - (timeOf(b.r.start) ?? 0) || compareText(textOf(a.r.uuid), textOf(b.r.uuid)) || a.i - b.i
+    ).map((x) => x.r);
+    ordered.forEach((r, retry) => out.push(pendingOf(r, retry, ctx)));
+  }
+  return out;
+}
+function pendingOf(r, retry, ctx) {
+  const name = textOf(r.name);
+  const uuid = textOf(r.uuid);
+  const key = keyOf(r, name);
+  const ancestors = uuid === "" ? [] : ctx.around(uuid);
+  const suite = (uuid === "" ? [] : ctx.direct.get(uuid) ?? []).filter((c) => textOf(c.name) !== "" && c.name !== name).sort((a, b) => (Array.isArray(b.children) ? b.children.length : 0) - (Array.isArray(a.children) ? a.children.length : 0))[0];
+  const group = suite !== void 0 ? [textOf(suite.name)] : labelGroup(r);
+  const title = [...group, name].join(" \u203A ");
+  const safeTitle = printable(title);
+  const rkey = resultKey(key, retry);
+  const files = [];
+  const announced = /* @__PURE__ */ new Set();
+  const ignored = /* @__PURE__ */ new Set();
+  const announce = (att) => {
+    const source = textOf(att.source);
+    if (source === "" || announced.has(source) || ignored.has(source)) return;
+    if (announced.size >= MARKERS_PER_TEST) {
+      ignored.add(source);
+      return;
+    }
+    announced.add(source);
+    const found = resolveAttachment(ctx.folder, source, ctx.lexical);
+    if (!("file" in found)) {
+      ctx.missing.push({ title: safeTitle, resultKey: rkey, path: source });
+      return;
+    }
+    if (files.some((f) => f.path === found.file)) return;
+    const type = textOf(att.type).trim();
+    const name2 = printable(textOf(att.name) !== "" ? textOf(att.name) : path10.basename(found.file));
+    files.push({ name: name2, contentType: type !== "" ? type : typeOfFile(found.file), path: found.file });
+  };
+  const holders = [];
+  for (const c of [...ancestors].reverse()) for (const h of listOf(c.befores)) holders.push(h);
+  holders.push(r);
+  for (const c of ancestors) for (const h of listOf(c.afters)) holders.push(h);
+  const atts = [];
+  let deep = false;
+  for (const h of holders) deep = attachmentsOf(h, atts) || deep;
+  atts.forEach(announce);
+  if (ignored.size > 0) {
+    ctx.notes.push(`plune: ${JSON.stringify(safeTitle)}: ${ignored.size} more markers ignored (at most ${MARKERS_PER_TEST} per test)`);
+  }
+  if (deep) ctx.notes.push(`plune: ${JSON.stringify(safeTitle)}: steps nested deeper than ${MAX_DEPTH} are ignored`);
+  const status = textOf(r.status) !== "" ? textOf(r.status) : "unknown";
+  const details = typeof r.statusDetails === "object" && r.statusDetails !== null ? r.statusDetails : {};
+  const message = textOf(details.message);
+  const trace = textOf(details.trace);
+  const attempt = {
+    status,
+    errors: [{ text: [message, trace].filter((s) => s !== "").join("\n\n") }],
+    steps: declared(r.steps),
+    attachments: files.map(({ name: n, contentType, path: p }) => ({
+      name: n,
+      ...contentType !== void 0 ? { contentType } : {},
+      ...p !== void 0 ? { path: p } : {}
+    })),
+    testFile: ""
+  };
+  const errorContext = errorContextOf(attempt);
+  const failure = FAILED.has(status) ? failureOf(attempt) : void 0;
+  const pkg2 = labelOf(r, "package");
+  const where = (key.includes("#") ? key.split("#")[0] : pkg2)?.replace(/^[A-Za-z][A-Za-z0-9_-]+:(?![\\/])/, "");
+  const stated = TOKEN.exec(name)?.[1];
+  const started = timeOf(r.start);
+  const stopped = timeOf(r.stop);
+  const durationMs = started !== void 0 && stopped !== void 0 ? Math.max(0, stopped - started) : 0;
+  return {
+    resultKey: rkey,
+    ...stated !== void 0 ? { testCaseId: stated } : {},
+    keys: [{ kind: "path-title", value: key }],
+    source: SOURCE,
+    rawStatus: status,
+    title,
+    ...where !== void 0 && where !== "" ? { specRef: where } : {},
+    ...started !== void 0 ? {
+      execution: {
+        startedAt: new Date(started).toISOString(),
+        finishedAt: new Date(started + durationMs).toISOString(),
+        durationMs,
+        retry
+      }
+    } : {},
+    ...errorContext !== "" ? { errorContext } : {},
+    ...failure !== void 0 ? { failure } : {},
+    ...files.length > 0 ? { files } : {}
+  };
+}
+var fs9, path10, SOURCE, TOKEN, AllureReportError, RESULT, CONTAINER, MAX_JSON_BYTES, MAX_DEPTH, MAX_TIME, namesIn, timeOf, textOf, labelOf, FAILED, declared, stopOf, compareText;
+var init_allure = __esm({
+  "src/importers/allure.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs9 = __toESM(require("fs"), 1);
+    path10 = __toESM(require("path"), 1);
+    init_failure_detail();
+    init_result_key();
+    init_attachments();
+    SOURCE = "allure";
+    TOKEN = /@P([A-Za-z0-9_-]+)/;
+    AllureReportError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "AllureReportError";
+      }
+    };
+    RESULT = /-result\.json$/;
+    CONTAINER = /-container\.json$/;
+    MAX_JSON_BYTES = 64 * 1024 * 1024;
+    MAX_DEPTH = 256;
+    MAX_TIME = 864e13;
+    namesIn = (dir, pattern) => fs9.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isFile() && pattern.test(d.name)).map((d) => d.name).sort();
+    timeOf = (v) => typeof v === "number" && Math.abs(v) <= MAX_TIME ? v : void 0;
+    textOf = (v) => typeof v === "string" ? v : "";
+    labelOf = (r, name) => textOf(listOf(r.labels).find((l) => l.name === name)?.value);
+    FAILED = /* @__PURE__ */ new Set(["failed", "broken"]);
+    declared = (steps, depth = 0) => depth >= MAX_DEPTH ? [] : listOf(steps).map((s) => ({ title: textOf(s.name), failed: FAILED.has(textOf(s.status)), steps: declared(s.steps, depth + 1) }));
+    stopOf = (r) => timeOf(r.stop) ?? timeOf(r.start) ?? 0;
+    compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  }
+});
+
 // src/importers/xml.ts
 function decode(raw) {
   if (!raw.includes("&")) return raw;
@@ -3212,9 +3953,9 @@ function parseXml(source, file) {
       if (end === -1) throw new XmlParseError(file, line, "a closing tag is never closed");
       const name2 = source.slice(i + 2, end).trim();
       const open = top();
-      if (open === root) throw new XmlParseError(file, line, `</${name2}> closes nothing`);
+      if (open === root) throw new XmlParseError(file, line, `</${printable(name2)}> closes nothing`);
       if (open.name !== name2) {
-        throw new XmlParseError(file, line, `</${name2}> closes <${open.name}>, opened on line ${open.line}`);
+        throw new XmlParseError(file, line, `</${printable(name2)}> closes <${printable(open.name)}>, opened on line ${open.line}`);
       }
       stack.pop();
       advance(end + 1);
@@ -3230,7 +3971,7 @@ function parseXml(source, file) {
     let selfClosing = false;
     for (; ; ) {
       while (j < source.length && SPACE.test(source[j])) j += 1;
-      if (j >= source.length) throw new XmlParseError(file, startLine, `<${name}> is never closed`);
+      if (j >= source.length) throw new XmlParseError(file, startLine, `<${printable(name)}> is never closed`);
       if (source[j] === "/" && source[j + 1] === ">") {
         selfClosing = true;
         j += 2;
@@ -3243,19 +3984,19 @@ function parseXml(source, file) {
       const attrStart = j;
       while (j < source.length && !ATTR_NAME_END.test(source[j])) j += 1;
       const attr = source.slice(attrStart, j);
-      if (attr === "") throw new XmlParseError(file, startLine, `<${name}> has an attribute with no name`);
+      if (attr === "") throw new XmlParseError(file, startLine, `<${printable(name)}> has an attribute with no name`);
       while (j < source.length && SPACE.test(source[j])) j += 1;
       if (source[j] !== "=") {
-        throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" has no value`);
+        throw new XmlParseError(file, startLine, `<${printable(name)}> attribute "${printable(attr)}" has no value`);
       }
       j += 1;
       while (j < source.length && SPACE.test(source[j])) j += 1;
       const quote = source[j];
       if (quote !== '"' && quote !== "'") {
-        throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" is not quoted`);
+        throw new XmlParseError(file, startLine, `<${printable(name)}> attribute "${printable(attr)}" is not quoted`);
       }
       const close = source.indexOf(quote, j + 1);
-      if (close === -1) throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" is never closed`);
+      if (close === -1) throw new XmlParseError(file, startLine, `<${printable(name)}> attribute "${printable(attr)}" is never closed`);
       el.attrs[attr] = decode(source.slice(j + 1, close));
       j = close + 1;
     }
@@ -3265,7 +4006,7 @@ function parseXml(source, file) {
   }
   if (stack.length > 1) {
     const open = top();
-    throw new XmlParseError(file, open.line, `<${open.name}> is never closed`);
+    throw new XmlParseError(file, open.line, `<${printable(open.name)}> is never closed`);
   }
   if (root.children.length === 0) throw new XmlParseError(file, 1, "no elements \u2014 is this an XML report?");
   return root;
@@ -3275,6 +4016,7 @@ var init_xml = __esm({
   "src/importers/xml.ts"() {
     "use strict";
     init_cjs_shims();
+    init_failure_detail();
     XmlParseError = class extends Error {
       constructor(file, line, detail) {
         super(`${file}:${line} \u2014 ${detail}`);
@@ -3321,7 +4063,7 @@ function playwrightOf(classname, name) {
   if (!SPEC_FILE.test(classname)) return void 0;
   return { file: classname.replaceAll("\\", "/"), titles: name.split(" \u203A ") };
 }
-function keyOf(classname, name, playwright) {
+function keyOf2(classname, name, playwright) {
   if (playwright !== void 0) return { kind: "path-title", value: [playwright.file, ...playwright.titles].join("#") };
   return { kind: "path-title", value: classname === "" ? name : `${classname}#${name}` };
 }
@@ -3354,8 +4096,9 @@ function executionOf(test, suite) {
     retry: 0
   };
 }
-function readJUnit(source, file) {
+function readJUnit(source, file, missing = [], notes = []) {
   const doc = parseXml(source, file);
+  const { lexical, real: folder } = reportFolders(file);
   const found = [];
   locate(doc, void 0, found);
   return found.map(({ test, suite }) => {
@@ -3363,180 +4106,50 @@ function readJUnit(source, file) {
     const classname = test.attrs["classname"] ?? test.attrs["class"] ?? "";
     const { status, detail } = outcomeOf(test);
     const playwright = playwrightOf(classname, name);
-    const key = keyOf(classname, name, playwright);
-    const stated = TOKEN.exec(playwright?.titles.at(-1) ?? name)?.[1];
+    const key = keyOf2(classname, name, playwright);
+    const stated = TOKEN2.exec(playwright?.titles.at(-1) ?? name)?.[1];
     const specRef = specRefOf(test, suite, classname);
     const errorContext = errorTextOf(detail);
     const execution = executionOf(test, suite);
+    const title = titleOf(classname, name);
+    const rkey = resultKey(key.value, 0);
+    const files = filesOfTest(test, folder, title, missing, { lexical, resultKey: rkey, notes });
     return {
-      resultKey: resultKey(key.value, 0),
+      resultKey: rkey,
       ...stated !== void 0 ? { testCaseId: stated } : {},
       keys: [key],
-      source: SOURCE,
+      source: SOURCE2,
       rawStatus: status,
-      title: titleOf(classname, name),
+      title,
       ...specRef !== void 0 ? { specRef } : {},
       ...execution !== void 0 ? { execution } : {},
-      ...errorContext !== "" ? { errorContext } : {}
+      ...errorContext !== "" ? { errorContext } : {},
+      ...files.length > 0 ? { files } : {}
     };
   });
 }
 function looksLikeJUnit(source) {
   return /<\s*testsuites?\b/.test(source.slice(0, 4096));
 }
-var SOURCE, TOKEN, SPEC_FILE;
+var SOURCE2, TOKEN2, SPEC_FILE;
 var init_junit = __esm({
   "src/importers/junit.ts"() {
     "use strict";
     init_cjs_shims();
     init_result_key();
+    init_attachments();
     init_xml();
-    SOURCE = "junit";
-    TOKEN = /@P([A-Za-z0-9_-]+)/;
+    SOURCE2 = "junit";
+    TOKEN2 = /@P([A-Za-z0-9_-]+)/;
     SPEC_FILE = /\.(?:spec|test)\.[cm]?[jt]sx?$/;
   }
 });
 
-// src/reporter-core/failure-detail.ts
-function failureOf(attempt, home = (0, import_node_os2.homedir)()) {
-  const error = chosen(attempt);
-  const line = error === void 0 ? void 0 : firstLine(machineless(error.text, attempt.repoRoot, home));
-  const headline = line !== void 0 && jsonBytes(line) <= HEADLINE_LIMIT ? line : void 0;
-  const steps = chainOf(attempt.steps);
-  const location = error === void 0 ? void 0 : fromRoot(placeOf(error, attempt.testFile), attempt.repoRoot);
-  const artifacts = attempt.attachments.filter((a) => a.path !== void 0 && !a.name.startsWith("_") && a.contentType !== METADATA_TYPE).map(({ name, contentType }) => ({ name: fileNameOf(name), ...contentType ? { contentType } : {} })).filter((a) => a.name !== "");
-  const ciUrl = webLink(attempt.buildHref);
-  const failure = {
-    ...headline !== void 0 ? { headline } : {},
-    ...steps.length > 0 ? { steps } : {},
-    ...location !== void 0 ? { location } : {},
-    ...artifacts.length > 0 ? { artifacts } : {},
-    ...ciUrl !== void 0 ? { ciUrl } : {}
-  };
-  return Object.keys(failure).length === 0 ? void 0 : failure;
-}
-function repoRootOf(dir, stopAt) {
-  for (let here = (0, import_node_path3.resolve)(dir); ; here = (0, import_node_path3.dirname)(here)) {
-    if ((0, import_node_fs3.existsSync)((0, import_node_path3.join)(here, ".git"))) return here;
-    if (here === stopAt || (0, import_node_path3.dirname)(here) === here) return void 0;
-  }
-}
-function errorContextOf(attempt, home = (0, import_node_os2.homedir)()) {
-  const text2 = attempt.errors.map((e) => e.text).filter((t) => t !== "").join("\n\n");
-  return cut(machineless(text2, attempt.repoRoot, home));
-}
-function filesOf(attempt) {
-  return attempt.attachments.filter((a) => a.path !== void 0);
-}
-function machineless(raw, repoRoot, home) {
-  let text2 = (0, import_node_util.stripVTControlCharacters)(raw).replaceAll("\x1B", "");
-  const root = repoRoot === void 0 ? void 0 : pathIn(repoRoot);
-  if (root !== void 0) text2 = text2.replace(new RegExp(`${PATH_START}${root.source}[\\\\/]+`, root.flags), "");
-  const own = pathIn(home);
-  if (own !== void 0) text2 = text2.replace(new RegExp(`${PATH_START}${own.source}(?![\\w.-])`, own.flags), "~");
-  if (repoRoot === void 0) text2 = text2.replace(ANY_HOME, "~");
-  return text2;
-}
-function pathIn(path15) {
-  const parts = path15.split(/[\\/]+/);
-  while (parts.length > 1 && parts.at(-1) === "") parts.pop();
-  if (!parts.some((part) => part !== "" && !/^[A-Za-z]:$/.test(part))) return void 0;
-  const joined = parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\\\/]+");
-  const escaped = /^\/(?!\/)/.test(path15) ? joined.replace("[\\\\/]+", "\\\\*\\/") : joined;
-  const url = "(?:(?:file|webpack|webpack-internal):(?:\\\\*\\/){2,3})?";
-  return new RegExp(`${url}${escaped}`, /^[A-Za-z]:$/.test(parts[0]) ? "gi" : "g");
-}
-function cut(text2) {
-  if (jsonBytes(text2) <= TEXT_LIMIT) return text2;
-  const lines = text2.split("\n");
-  const size = lines.map((line) => jsonBytes(line) + 2);
-  const budget = TEXT_LIMIT - jsonBytes(omitted(lines.length));
-  let used = 0;
-  let head = 0;
-  let tail = lines.length;
-  while (head < tail && used + size[head] <= budget / 2) used += size[head++];
-  while (tail > head && used + size[tail - 1] <= budget) used += size[--tail];
-  return [...lines.slice(0, head), omitted(tail - head), ...lines.slice(tail)].join("\n");
-}
-function chosen({ status, errors }) {
-  if (status === "timedOut") {
-    const timeout = errors.findIndex((e) => firstLine(e.text)?.startsWith("Test timeout of ") === true);
-    if (timeout !== -1 && timeout + 1 < errors.length) return errors[timeout + 1];
-  }
-  return errors[0];
-}
-function chainOf(steps) {
-  const chain = [];
-  for (let failed = steps.find((s) => s.failed); failed !== void 0; failed = failed.steps.find((s) => s.failed)) {
-    chain.push(failed.title);
-  }
-  return chain;
-}
-function placeOf(error, testFile) {
-  const own = normal(testFile);
-  let first;
-  for (const line of (0, import_node_util.stripVTControlCharacters)(error.text).split("\n")) {
-    if (line.length > FRAME_MAX) continue;
-    const frame = FRAME.exec(line);
-    if (frame === null) continue;
-    const place = { file: fileOf(frame[1]), line: Number(frame[2]), column: Number(frame[3]) };
-    if (normal(place.file) === own) return place;
-    if (first === void 0 && !normal(place.file).includes("/node_modules/")) first = place;
-  }
-  return error.location ?? first;
-}
-function fileOf(raw) {
-  if (!raw.startsWith("file://")) return raw;
-  let path15 = raw.slice("file://".length);
-  try {
-    path15 = decodeURIComponent(path15);
-  } catch {
-  }
-  return /^\/[A-Za-z]:\//.test(path15) ? path15.slice(1) : path15;
-}
-function fromRoot(place, root) {
-  if (place === void 0 || root === void 0 || !Number.isInteger(place.line) || place.line < 1) return void 0;
-  const base = normal(root).replace(/\/+$/, "");
-  const file = normal(place.file);
-  if (!file.startsWith(`${base}/`)) return void 0;
-  const relative2 = file.slice(base.length + 1);
-  if (!REPO_RELATIVE.test(relative2)) return void 0;
-  const column = place.column !== void 0 && Number.isInteger(place.column) && place.column >= 1 ? place.column : void 0;
-  return column === void 0 ? { file: relative2, line: place.line } : { file: relative2, line: place.line, column };
-}
-function webLink(href) {
-  return href !== void 0 && /^https?:\/\//i.test(href) && URL.canParse(href) ? href : void 0;
-}
-var import_node_fs3, import_node_os2, import_node_path3, import_node_util, PATH_START, TEXT_LIMIT, HEADLINE_LIMIT, jsonBytes, ANY_HOME, fileNameOf, omitted, METADATA_TYPE, REPO_RELATIVE, FRAME, FRAME_MAX, firstLine, normal;
-var init_failure_detail = __esm({
-  "src/reporter-core/failure-detail.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_node_fs3 = require("fs");
-    import_node_os2 = require("os");
-    import_node_path3 = require("path");
-    import_node_util = require("util");
-    PATH_START = "(?<![\\w.~%/\\\\-])";
-    TEXT_LIMIT = 524288;
-    HEADLINE_LIMIT = 8 * 1024;
-    jsonBytes = (text2) => Buffer.byteLength(JSON.stringify(text2)) - 2;
-    ANY_HOME = /(?<=^|[\s'"`(=,[])(?:(?:file|webpack|webpack-internal):(?:\\*\/){2,3})?(?:\\*\/home\\*\/|\\*\/Users\\*\/|[A-Za-z]:[\\/]+Users[\\/]+)[^\\/\s'"`:*?<>|]+/g;
-    fileNameOf = (name) => /^(?:file:\/\/|[\\/]|~[\\/]|[A-Za-z]:[\\/])/.test(name) ? name.split(/[\\/]/).pop() ?? "" : name;
-    omitted = (lines) => `\u2026[omitted ${lines} lines]\u2026`;
-    METADATA_TYPE = "application/plune.metadata+json";
-    REPO_RELATIVE = /^(?![A-Za-z][A-Za-z0-9+.-]*:)(?![\\/~])(?!(?:.*[\\/])?\.\.(?:[\\/]|$)).+$/;
-    FRAME = /^\s+at (?:.*? \()?(.+?):(\d+):(\d+)\)?$/;
-    FRAME_MAX = 8192;
-    firstLine = (text2) => (0, import_node_util.stripVTControlCharacters)(text2).split("\n").map((line) => line.trim()).find((line) => line !== "");
-    normal = (path15) => import_node_path3.posix.normalize(path15.replace(/\\/g, "/")).replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
-  }
-});
-
 // src/importers/playwright-json.ts
 function statedIdOf(test, title) {
   const annotation = test.annotations?.find((a) => a.type === "PluneId")?.description;
   if (annotation !== void 0 && annotation !== "") return annotation;
-  return TOKEN2.exec(title)?.[1];
+  return TOKEN3.exec(title)?.[1];
 }
 function attemptOf(result, file, ctx) {
   const steps = (list2) => (list2 ?? []).map((s) => ({ title: s.title ?? "", failed: s.error !== void 0, steps: steps(s.steps) }));
@@ -3547,10 +4160,13 @@ function attemptOf(result, file, ctx) {
       ...typeof at?.file === "string" && typeof at.line === "number" ? { location: { file: at.file, line: at.line, ...typeof at.column === "number" ? { column: at.column } : {} } } : {}
     })),
     steps: steps(result.steps),
-    attachments: (result.attachments ?? []).map(({ name, contentType, path: path15 }) => ({
+    attachments: (result.attachments ?? []).map(({ name, contentType, path: path17, body }) => ({
       name: name ?? "",
       ...contentType !== void 0 ? { contentType } : {},
-      ...path15 !== void 0 ? { path: path15 } : {}
+      ...path17 !== void 0 ? { path: path17 } : {},
+      // Decoded only where the platform would take it (plune-ai/plune#928): a report of screenshots kept as
+      // bodies is megabytes of base64 that nothing here will read.
+      ...typeof body === "string" && isTextType(contentType) ? { body: Buffer.from(body, "base64") } : {}
     })),
     ...ctx.buildHref !== void 0 ? { buildHref: ctx.buildHref } : {},
     // Spec files are posix and relative to the root dir; the core reads either slash.
@@ -3580,7 +4196,7 @@ function pendingFrom(spec, test, result, file, titles, ctx) {
     keys,
     title: titles.join(" \u203A "),
     specRef: spec.line !== void 0 ? `${file}:${spec.line}` : file,
-    source: SOURCE2,
+    source: SOURCE3,
     // Untouched, as everywhere: `timedOut` means what the project's map says it means, not what
     // this file decided.
     rawStatus: result.status ?? "unknown",
@@ -3615,7 +4231,7 @@ function readPlaywrightJson(source, file) {
   try {
     parsed = JSON.parse(source);
   } catch (err) {
-    throw new JsonReportError(file, `not JSON \u2014 ${err instanceof Error ? err.message : String(err)}`);
+    throw new JsonReportError(file, `not JSON \u2014 ${printable(err instanceof Error ? err.message : String(err))}`);
   }
   if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.suites)) {
     throw new JsonReportError(file, 'no "suites" array \u2014 is this a Playwright JSON report?');
@@ -3623,7 +4239,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_fs4.existsSync)(rootDir) ? repoRootOf(rootDir) : void 0;
+  const repoRoot = rootDir !== void 0 && (0, import_node_fs5.existsSync)(rootDir) ? repoRootOf(rootDir) : void 0;
   const ctx = {
     ...rootDir !== void 0 ? { rootDir } : {},
     ...repoRoot !== void 0 ? { repoRoot } : {},
@@ -3642,20 +4258,20 @@ function readPlaywrightJson(source, file) {
 function looksLikePlaywrightJson(source) {
   return /^\s*\{/.test(source) && source.includes('"suites"');
 }
-var import_node_fs4, SOURCE2, TOKEN2, NOT_FAILED, JsonReportError;
+var import_node_fs5, SOURCE3, TOKEN3, NOT_FAILED, JsonReportError;
 var init_playwright_json = __esm({
   "src/importers/playwright-json.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs4 = require("fs");
+    import_node_fs5 = require("fs");
     init_failure_detail();
     init_result_key();
-    SOURCE2 = "playwright";
-    TOKEN2 = /@P([A-Za-z0-9_-]+)/;
+    SOURCE3 = "playwright";
+    TOKEN3 = /@P([A-Za-z0-9_-]+)/;
     NOT_FAILED = /* @__PURE__ */ new Set(["passed", "skipped"]);
     JsonReportError = class extends Error {
       constructor(file, detail) {
-        super(`${file} \u2014 ${detail}`);
+        super(`${printable(file)} \u2014 ${detail}`);
         this.file = file;
         this.name = "JsonReportError";
       }
@@ -3667,11 +4283,14 @@ var init_playwright_json = __esm({
 // src/importers/index.ts
 var importers_exports = {};
 __export(importers_exports, {
+  AllureReportError: () => AllureReportError,
   IMPORT_FORMATS: () => IMPORT_FORMATS,
   JsonReportError: () => JsonReportError,
   UnknownFormatError: () => UnknownFormatError,
   XmlParseError: () => XmlParseError,
   detectFormat: () => detectFormat,
+  isFolder: () => isFolder,
+  readFolder: () => readFolder,
   readReport: () => readReport
 });
 function detectFormat(source, file) {
@@ -3682,21 +4301,34 @@ function detectFormat(source, file) {
     'no <testsuite> and no Playwright "suites" \u2014 this is not a report we can read.'
   );
 }
+function readFolder(dir, format) {
+  if (format !== void 0 && format !== "allure") {
+    throw new UnknownFormatError(dir, `this is a folder, and only allure-results is read from one, not ${format}.`);
+  }
+  const missing = [];
+  const notes = [];
+  return { format: "allure", results: readAllure(dir, missing, notes), missing, notes };
+}
 function readReport(source, file, format) {
   const chosen2 = format ?? detectFormat(source, file);
-  if (chosen2 === "junit") return { format: chosen2, results: readJUnit(source, file) };
-  return { format: chosen2, ...readPlaywrightJson(source, file) };
+  const missing = [];
+  if (chosen2 === "allure") throw new UnknownFormatError(file, "allure-results is a folder, and this is a file.");
+  const notes = [];
+  if (chosen2 === "junit") return { format: chosen2, results: readJUnit(source, file, missing, notes), missing, notes };
+  return { format: chosen2, ...readPlaywrightJson(source, file), missing, notes };
 }
 var IMPORT_FORMATS, UnknownFormatError;
 var init_importers = __esm({
   "src/importers/index.ts"() {
     "use strict";
     init_cjs_shims();
+    init_allure();
     init_junit();
     init_playwright_json();
     init_xml();
     init_playwright_json();
-    IMPORT_FORMATS = ["junit", "playwright-json"];
+    init_allure();
+    IMPORT_FORMATS = ["junit", "playwright-json", "allure"];
     UnknownFormatError = class extends Error {
       constructor(file, detail) {
         super(`${file} \u2014 ${detail} Say which with --format ${IMPORT_FORMATS.join(" | ")}.`);
@@ -3714,16 +4346,25 @@ __export(run_import_exports, {
 async function handleRunImport(options) {
   const write = options.write ?? ((line) => void process.stdout.write(`${line}
 `));
-  let source;
-  try {
-    source = fs8.readFileSync(options.file, "utf8");
-  } catch {
-    throw new RunCommandError(`Cannot read ${options.file}.`);
+  let read;
+  if (isFolder(options.file)) {
+    read = readFolder(options.file, options.format);
+  } else {
+    let source;
+    try {
+      source = fs10.readFileSync(options.file, "utf8");
+    } catch {
+      throw new RunCommandError(`Cannot read ${options.file}.`);
+    }
+    read = readReport(source, options.file, options.format);
   }
-  const { format, results, ciUrl, ci } = readReport(source, options.file, options.format);
+  const { format, results, missing, notes, ciUrl, ci } = read;
   if (results.length === 0) {
     throw new RunCommandError(`No test cases in ${options.file} \u2014 it parsed, but there is nothing in it.`);
   }
+  for (const m of missing) write(`plune: attachment not found \u2014 ${JSON.stringify(printable(m.title))}: ${printable(m.path)}`);
+  for (const note of notes) write(note);
+  const announced = (format === "junit" || format === "allure") && (missing.length > 0 || results.some((r) => (r.files?.length ?? 0) > 0));
   const env = readEnv();
   const apiUrl = resolveApiUrl(options.apiUrl ?? env.config.apiUrl);
   const token = options.token ?? env.config.token ?? loadToken() ?? "";
@@ -3767,6 +4408,14 @@ async function handleRunImport(options) {
     ...stats.unofferedWhy !== void 0 ? { unofferedWhy: stats.unofferedWhy } : {},
     deferred: stats.deferred,
     screenshots: { ...stats.screenshots },
+    textFiles: { ...stats.textFiles },
+    missingAttachments: missing,
+    filesUploaded: stats.screenshots.uploaded + stats.textFiles.uploaded + stats.otherFiles.uploaded,
+    announced,
+    filesNotSent: Math.max(
+      0,
+      results.reduce((n, r) => n + (r.files?.length ?? 0), 0) - [stats.screenshots, stats.textFiles, stats.otherFiles].reduce((n, c) => n + c.uploaded + c.skipped + c.failed, 0)
+    ),
     unlocatable: results.filter((r) => r.specRef === void 0).length,
     offering: options.create === true
   };
@@ -3785,17 +4434,11 @@ function describe(result, apiUrl) {
     // worked (#622).
     // `not delivered` always, zero included (#790): a number that only appears when it is bad is one
     // nobody learns to look for. The `[0-9]+ unmatched` the workflows read stays whole.
-    `Read ${result.parsed} result(s) from a ${result.format} report: ${result.accepted} accepted, ${result.duplicate} already there, ${result.unresolved} unmatched, ${result.deferred} not delivered.`
+    `Read ${result.parsed} result(s) from ${result.format === "allure" ? "an" : "a"} ${result.format} report: ${result.accepted} accepted, ${result.duplicate} already there, ${result.unresolved} unmatched, ${result.deferred} not delivered.`
   ];
   if (result.conflict > 0 || result.rejected > 0) {
     lines.push(`${result.conflict} conflicted and ${result.rejected} were refused.`);
   }
-  const shots = result.screenshots;
-  if (shots.uploaded + shots.skipped + shots.failed > 0) {
-    lines.push(
-      `${shots.uploaded} screenshot(s) uploaded to their results` + (shots.skipped > 0 ? `, ${shots.skipped} skipped` : "") + (shots.failed > 0 ? `, ${shots.failed} could not be uploaded` : "") + "."
-    );
-  }
   if (result.deferred > 0) {
     lines.push(
       `${result.deferred} could not be sent and are in the fallback file \u2014 "plune run report" retries them.`
@@ -3823,16 +4466,22 @@ function describe(result, apiUrl) {
       `${result.unlocatable} test(s) carry no file or class in the report, so they cannot be offered for review \u2014 a reviewer would have nowhere to look.`
     );
   }
+  if (result.announced) {
+    lines.push(
+      `Imported ${result.accepted} results \xB7 ${result.filesUploaded} files uploaded \xB7 ${result.missingAttachments.length} files not found` + (result.filesNotSent > 0 ? ` \xB7 ${result.filesNotSent} files not sent (their result was not stored)` : "")
+    );
+  }
   if (result.runId !== null) lines.push(runUrl2(apiUrl, result.runId));
   return lines;
 }
-var fs8, NEXT;
+var fs10, NEXT;
 var init_run_import = __esm({
   "src/cli/commands/run-import.ts"() {
     "use strict";
     init_cjs_shims();
-    fs8 = __toESM(require("fs"), 1);
+    fs10 = __toESM(require("fs"), 1);
     init_session();
+    init_failure_detail();
     init_importers();
     init_run_lifecycle();
     init_api_url();
@@ -3859,10 +4508,10 @@ function isRunResult(v) {
 }
 function handleReport(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const file = path9.join(cwd, ".plune", "last-run.json");
+  const file = path11.join(cwd, ".plune", "last-run.json");
   let raw;
   try {
-    raw = fs9.readFileSync(file, "utf8");
+    raw = fs11.readFileSync(file, "utf8");
   } catch {
     throw new ReportNotFoundError('No saved run found. Run "plune run" first.');
   }
@@ -3877,13 +4526,13 @@ function handleReport(opts = {}) {
   }
   return parsed;
 }
-var fs9, path9, ReportNotFoundError;
+var fs11, path11, ReportNotFoundError;
 var init_report = __esm({
   "src/cli/commands/report.ts"() {
     "use strict";
     init_cjs_shims();
-    fs9 = __toESM(require("fs"), 1);
-    path9 = __toESM(require("path"), 1);
+    fs11 = __toESM(require("fs"), 1);
+    path11 = __toESM(require("path"), 1);
     ReportNotFoundError = class extends Error {
       code = "NO_SAVED_RUN";
       constructor(message) {
@@ -3957,7 +4606,7 @@ function isRunResult2(v) {
 function loadRunResult(file, label) {
   let raw;
   try {
-    raw = fs10.readFileSync(file, "utf8");
+    raw = fs12.readFileSync(file, "utf8");
   } catch {
     throw new DiffInputError(`Cannot read ${label} run file: ${file}`);
   }
@@ -3977,12 +4626,12 @@ function handleDiff(opts) {
   const current = loadRunResult(opts.currentPath, "current");
   return diffRuns(baseline, current);
 }
-var fs10, DiffInputError;
+var fs12, DiffInputError;
 var init_diff2 = __esm({
   "src/cli/commands/diff.ts"() {
     "use strict";
     init_cjs_shims();
-    fs10 = __toESM(require("fs"), 1);
+    fs12 = __toESM(require("fs"), 1);
     init_diff();
     DiffInputError = class extends Error {
       code = "DIFF_INPUT";
@@ -4107,8 +4756,8 @@ async function runInitWizard(cwd) {
     process.exit(1);
     return;
   }
-  const outputPath = path10.join(cwd, "plune.yaml");
-  if (fs11.existsSync(outputPath)) {
+  const outputPath = path12.join(cwd, "plune.yaml");
+  if (fs13.existsSync(outputPath)) {
     const overwrite = await clack.confirm({
       message: "plune.yaml already exists. Overwrite?"
     });
@@ -4147,18 +4796,18 @@ async function runInitWizard(cwd) {
 `;
   const spin = clack.spinner();
   spin.start("Writing plune.yaml\u2026");
-  fs11.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
+  fs13.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
   spin.stop("plune.yaml created!");
   clack.outro("plune.yaml is ready.");
 }
-var clack, fs11, path10, import_yaml2;
+var clack, fs13, path12, import_yaml2;
 var init_wizard = __esm({
   "src/config/init/wizard.ts"() {
     "use strict";
     init_cjs_shims();
     clack = __toESM(require("@clack/prompts"), 1);
-    fs11 = __toESM(require("fs"), 1);
-    path10 = __toESM(require("path"), 1);
+    fs13 = __toESM(require("fs"), 1);
+    path12 = __toESM(require("path"), 1);
     import_yaml2 = require("yaml");
     init_errors();
   }
@@ -4166,21 +4815,21 @@ var init_wizard = __esm({
 
 // src/cli/templates/index.ts
 function writeTemplateFile(cwd, rel, content, force) {
-  const target = path11.join(cwd, rel);
-  if (!force && fs12.existsSync(target)) {
+  const target = path13.join(cwd, rel);
+  if (!force && fs14.existsSync(target)) {
     return "skipped";
   }
-  fs12.mkdirSync(path11.dirname(target), { recursive: true });
-  fs12.writeFileSync(target, content, "utf8");
+  fs14.mkdirSync(path13.dirname(target), { recursive: true });
+  fs14.writeFileSync(target, content, "utf8");
   return "written";
 }
-var fs12, path11, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
+var fs14, path13, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
 var init_templates = __esm({
   "src/cli/templates/index.ts"() {
     "use strict";
     init_cjs_shims();
-    fs12 = __toESM(require("fs"), 1);
-    path11 = __toESM(require("path"), 1);
+    fs14 = __toESM(require("fs"), 1);
+    path13 = __toESM(require("path"), 1);
     ENV_EXAMPLE_TPL = `# Copy this file to .env and replace the placeholders with your real keys.
 # .env is gitignored; .env.example is safe to commit.
 # Plune reads whichever key matches your configured provider.
@@ -4358,68 +5007,136 @@ var init_logout = __esm({
   }
 });
 
+// src/types/test-case-schema.ts
+var import_zod2, TEST_CASE_SCHEMA_VERSION, externalKeySchema, manualStepSchema, assertionResultRecordSchema, manualCaseSchema, automatedCaseSchema, evalCaseSchema, testCaseBaseSchema, testCaseSchema;
+var init_test_case_schema = __esm({
+  "src/types/test-case-schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod2 = require("zod");
+    TEST_CASE_SCHEMA_VERSION = 2;
+    externalKeySchema = import_zod2.z.object({
+      kind: import_zod2.z.enum(["playwright-id", "path-title", "allure-history", "cairn-stable", "eval-id", "qase", "testrail"]),
+      value: import_zod2.z.string().min(1)
+    });
+    manualStepSchema = import_zod2.z.object({
+      action: import_zod2.z.string().min(1),
+      expected: import_zod2.z.string().min(1).optional()
+    });
+    assertionResultRecordSchema = import_zod2.z.object({
+      type: import_zod2.z.string().min(1),
+      passed: import_zod2.z.boolean(),
+      score: import_zod2.z.number().optional(),
+      reason: import_zod2.z.string().optional()
+    });
+    manualCaseSchema = import_zod2.z.object({
+      type: import_zod2.z.literal("manual"),
+      steps: import_zod2.z.array(manualStepSchema).min(1),
+      expected: import_zod2.z.string().min(1).optional()
+    });
+    automatedCaseSchema = import_zod2.z.object({
+      type: import_zod2.z.literal("automated"),
+      specRef: import_zod2.z.string().min(1)
+    });
+    evalCaseSchema = import_zod2.z.object({
+      type: import_zod2.z.literal("eval"),
+      prompt: import_zod2.z.string().min(1),
+      goldenSetId: import_zod2.z.string().min(1).optional(),
+      assertions: import_zod2.z.array(assertionResultRecordSchema).min(1)
+    });
+    testCaseBaseSchema = import_zod2.z.object({
+      schemaVersion: import_zod2.z.literal(TEST_CASE_SCHEMA_VERSION),
+      id: import_zod2.z.string().min(1),
+      externalKeys: import_zod2.z.array(externalKeySchema).optional(),
+      /** ADR 0045 / plune#1246 — optional, purely additive; schemaVersion stays 2. */
+      is_flaky: import_zod2.z.boolean().optional(),
+      /** ADR 0045 / plune#1246 — optional, purely additive; schemaVersion stays 2. */
+      is_muted: import_zod2.z.boolean().optional()
+    });
+    testCaseSchema = import_zod2.z.discriminatedUnion("type", [
+      testCaseBaseSchema.merge(manualCaseSchema),
+      testCaseBaseSchema.merge(automatedCaseSchema),
+      testCaseBaseSchema.merge(evalCaseSchema)
+    ]);
+  }
+});
+
+// src/types/results.ts
+var ROW_INCONCLUSIVE;
+var init_results = __esm({
+  "src/types/results.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_test_case_schema();
+    ROW_INCONCLUSIVE = ["blocked", "skipped"];
+  }
+});
+
 // src/types/run-result-schema.ts
 function parseRunResult(value2) {
   return runResultSchema.parse(value2);
 }
-var import_zod2, RUN_RESULT_SCHEMA_VERSION, binaryVerdictSchema, assertionResultRecordSchema, usageSchema, runErrorSchema, rowResultSchema, summarySchema, evalResultSchema, runResultSchema;
+var import_zod3, RUN_RESULT_SCHEMA_VERSION, binaryVerdictSchema, assertionResultRecordSchema2, usageSchema, runErrorSchema, rowResultSchema, summarySchema, evalResultSchema, runResultSchema;
 var init_run_result_schema = __esm({
   "src/types/run-result-schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod2 = require("zod");
+    import_zod3 = require("zod");
+    init_results();
     RUN_RESULT_SCHEMA_VERSION = 1;
-    binaryVerdictSchema = import_zod2.z.object({
-      question: import_zod2.z.string().min(1),
-      passed: import_zod2.z.boolean()
+    binaryVerdictSchema = import_zod3.z.object({
+      question: import_zod3.z.string().min(1),
+      passed: import_zod3.z.boolean()
     });
-    assertionResultRecordSchema = import_zod2.z.object({
-      type: import_zod2.z.string(),
-      passed: import_zod2.z.boolean(),
-      score: import_zod2.z.number().optional(),
-      reason: import_zod2.z.string().optional(),
-      binaryVerdicts: import_zod2.z.array(binaryVerdictSchema).optional()
+    assertionResultRecordSchema2 = import_zod3.z.object({
+      type: import_zod3.z.string(),
+      passed: import_zod3.z.boolean(),
+      score: import_zod3.z.number().optional(),
+      reason: import_zod3.z.string().optional(),
+      binaryVerdicts: import_zod3.z.array(binaryVerdictSchema).optional()
     });
-    usageSchema = import_zod2.z.object({
-      input_tokens: import_zod2.z.number(),
-      output_tokens: import_zod2.z.number(),
-      cost_usd: import_zod2.z.number()
+    usageSchema = import_zod3.z.object({
+      input_tokens: import_zod3.z.number(),
+      output_tokens: import_zod3.z.number(),
+      cost_usd: import_zod3.z.number()
     });
-    runErrorSchema = import_zod2.z.object({
-      code: import_zod2.z.string(),
-      message: import_zod2.z.string()
+    runErrorSchema = import_zod3.z.object({
+      code: import_zod3.z.string(),
+      message: import_zod3.z.string()
     });
-    rowResultSchema = import_zod2.z.object({
-      vars: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
-      output: import_zod2.z.string().nullable(),
-      cached: import_zod2.z.boolean(),
+    rowResultSchema = import_zod3.z.object({
+      vars: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()),
+      output: import_zod3.z.string().nullable(),
+      cached: import_zod3.z.boolean(),
       usage: usageSchema.optional(),
-      latency_ms: import_zod2.z.number().optional(),
+      latency_ms: import_zod3.z.number().optional(),
       error: runErrorSchema.optional(),
-      assertions: import_zod2.z.array(assertionResultRecordSchema)
+      assertions: import_zod3.z.array(assertionResultRecordSchema2),
+      /** ADR 0045. Optional and additive — the same enum the platform validates on `POST /v1/runs`. */
+      inconclusive: import_zod3.z.enum(ROW_INCONCLUSIVE).optional()
     });
-    summarySchema = import_zod2.z.object({
-      total: import_zod2.z.number(),
-      passed: import_zod2.z.number(),
-      failed: import_zod2.z.number(),
-      errored: import_zod2.z.number(),
-      cost_usd: import_zod2.z.number(),
-      duration_ms: import_zod2.z.number()
+    summarySchema = import_zod3.z.object({
+      total: import_zod3.z.number(),
+      passed: import_zod3.z.number(),
+      failed: import_zod3.z.number(),
+      errored: import_zod3.z.number(),
+      cost_usd: import_zod3.z.number(),
+      duration_ms: import_zod3.z.number()
     });
-    evalResultSchema = import_zod2.z.object({
-      id: import_zod2.z.string(),
-      tags: import_zod2.z.array(import_zod2.z.string()),
-      rows: import_zod2.z.array(rowResultSchema),
-      passed: import_zod2.z.boolean()
+    evalResultSchema = import_zod3.z.object({
+      id: import_zod3.z.string(),
+      tags: import_zod3.z.array(import_zod3.z.string()),
+      rows: import_zod3.z.array(rowResultSchema),
+      passed: import_zod3.z.boolean()
     });
-    runResultSchema = import_zod2.z.object({
-      schemaVersion: import_zod2.z.literal(RUN_RESULT_SCHEMA_VERSION),
-      plune_version: import_zod2.z.string(),
-      started_at: import_zod2.z.string(),
-      finished_at: import_zod2.z.string(),
-      config_hash: import_zod2.z.string(),
+    runResultSchema = import_zod3.z.object({
+      schemaVersion: import_zod3.z.literal(RUN_RESULT_SCHEMA_VERSION),
+      plune_version: import_zod3.z.string(),
+      started_at: import_zod3.z.string(),
+      finished_at: import_zod3.z.string(),
+      config_hash: import_zod3.z.string(),
       summary: summarySchema,
-      evals: import_zod2.z.array(evalResultSchema)
+      evals: import_zod3.z.array(evalResultSchema)
     });
   }
 });
@@ -4436,10 +5153,10 @@ __export(sync_exports, {
   reportSyncFailure: () => reportSyncFailure
 });
 function readRun(cwd, file) {
-  const target = file !== void 0 ? path12.resolve(cwd, file) : path12.join(cwd, ".plune", "last-run.json");
+  const target = file !== void 0 ? path14.resolve(cwd, file) : path14.join(cwd, ".plune", "last-run.json");
   let raw;
   try {
-    raw = fs13.readFileSync(target, "utf8");
+    raw = fs15.readFileSync(target, "utf8");
   } catch {
     throw new SyncFileError(
       file !== void 0 ? `Run file not found: ${target}` : 'No run to sync. Run "plune run" first (or pass --file <path>).'
@@ -4503,13 +5220,13 @@ function reportSyncFailure(err, write) {
   }
   return null;
 }
-var fs13, path12, NotLoggedInError, TokenRejectedError2, SyncFileError, SyncNetworkError, SyncHttpError;
+var fs15, path14, NotLoggedInError, TokenRejectedError2, SyncFileError, SyncNetworkError, SyncHttpError;
 var init_sync = __esm({
   "src/cli/commands/sync.ts"() {
     "use strict";
     init_cjs_shims();
-    fs13 = __toESM(require("fs"), 1);
-    path12 = __toESM(require("path"), 1);
+    fs15 = __toESM(require("fs"), 1);
+    path14 = __toESM(require("path"), 1);
     init_run_result_schema();
     init_api_url();
     init_credentials();
@@ -4554,14 +5271,14 @@ var init_sync = __esm({
 
 // src/cli/commands/cairn-artifact.ts
 async function findLatestCairnRun(runsDir = "runs") {
-  const entries = await fs14.readdir(runsDir, { withFileTypes: true }).catch(() => null);
+  const entries = await fs16.readdir(runsDir, { withFileTypes: true }).catch(() => null);
   if (entries === null) throw new NoCairnRunsError(runsDir);
   let newest;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dir = path13.join(runsDir, entry.name);
+    const dir = path15.join(runsDir, entry.name);
     try {
-      const report = await fs14.lstat(path13.join(dir, "report.json"));
+      const report = await fs16.lstat(path15.join(dir, "report.json"));
       if (!report.isFile()) continue;
       if (newest === void 0 || report.mtimeMs > newest.at) {
         newest = { dir, at: report.mtimeMs };
@@ -4574,13 +5291,13 @@ async function findLatestCairnRun(runsDir = "runs") {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await fs14.readFile(file, "utf8"));
+    return JSON.parse(await fs16.readFile(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 async function defaultReadEvidence(dir) {
-  const raw = await readJson(path13.join(dir, "api-evidence.json"));
+  const raw = await readJson(path15.join(dir, "api-evidence.json"));
   if (!Array.isArray(raw)) return void 0;
   return raw.map((r) => {
     const rec = asRecord(r);
@@ -4622,7 +5339,7 @@ function casesFromApi(report, verdicts) {
   });
 }
 async function readCairnRun(dir, deps = {}) {
-  const raw = await readJson(path13.join(dir, "report.json"));
+  const raw = await readJson(path15.join(dir, "report.json"));
   if (raw === void 0) throw new CairnRunNotFoundError(dir);
   const report = asRecord(raw);
   if (report["schemaVersion"] !== SUPPORTED_ARTIFACT_VERSION) {
@@ -4652,20 +5369,20 @@ async function readCairnRun(dir, deps = {}) {
   return {
     schemaVersion: INGEST_SCHEMA_VERSION,
     run: {
-      runId: str(report["runId"], path13.basename(dir)),
+      runId: str(report["runId"], path15.basename(dir)),
       mode,
       target: str(report["url"], "unknown")
     },
     cases
   };
 }
-var fs14, path13, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
+var fs16, path15, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
 var init_cairn_artifact = __esm({
   "src/cli/commands/cairn-artifact.ts"() {
     "use strict";
     init_cjs_shims();
-    fs14 = __toESM(require("fs/promises"), 1);
-    path13 = __toESM(require("path"), 1);
+    fs16 = __toESM(require("fs/promises"), 1);
+    path15 = __toESM(require("path"), 1);
     SUPPORTED_ARTIFACT_VERSION = 1;
     INGEST_SCHEMA_VERSION = 1;
     NoCairnRunsError = class extends Error {
@@ -4832,7 +5549,7 @@ __export(cases_exports, {
 function gitDirty(file) {
   try {
     const out = (0, import_node_child_process2.execFileSync)("git", ["status", "--porcelain", "--", file], {
-      cwd: path14.dirname(file),
+      cwd: path16.dirname(file),
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf8"
     });
@@ -4858,9 +5575,9 @@ async function handlePull(deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const apiUrl = resolveApiUrl(deps.apiUrl);
   const token = tokenOf(deps);
-  const file = path14.resolve(cwd, deps.file ?? DEFAULT_CASES_FILE);
-  if (fs15.existsSync(file) && !deps.force && (deps.isDirty ?? gitDirty)(file))
-    throw new DirtyFileError(path14.relative(cwd, file) || file);
+  const file = path16.resolve(cwd, deps.file ?? DEFAULT_CASES_FILE);
+  if (fs17.existsSync(file) && !deps.force && (deps.isDirty ?? gitDirty)(file))
+    throw new DirtyFileError(path16.relative(cwd, file) || file);
   const doFetch = deps.fetchImpl ?? fetch;
   const endpoint = deps.suiteId !== void 0 ? `${apiUrl}/v1/suites/${encodeURIComponent(deps.suiteId)}/markdown` : `${apiUrl}/v1/test-cases/markdown`;
   let res;
@@ -4875,18 +5592,18 @@ async function handlePull(deps = {}) {
     throw new SyncHttpError(res.status, detail);
   }
   const text2 = await res.text();
-  fs15.mkdirSync(path14.dirname(file), { recursive: true });
-  fs15.writeFileSync(file, text2, "utf8");
+  fs17.mkdirSync(path16.dirname(file), { recursive: true });
+  fs17.writeFileSync(file, text2, "utf8");
   return { file, cases: Number(res.headers.get("x-plune-cases") ?? "0") };
 }
 async function handlePush(deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const apiUrl = resolveApiUrl(deps.apiUrl);
   const token = tokenOf(deps);
-  const file = path14.resolve(cwd, deps.file ?? DEFAULT_CASES_FILE);
+  const file = path16.resolve(cwd, deps.file ?? DEFAULT_CASES_FILE);
   let text2;
   try {
-    text2 = fs15.readFileSync(file, "utf8");
+    text2 = fs17.readFileSync(file, "utf8");
   } catch {
     throw new SyncFileError(
       `No document to push: ${file}. Run "plune pull" first (or pass a file).`
@@ -4937,18 +5654,18 @@ function reportCasesFailure(err, write) {
   }
   return null;
 }
-var import_node_child_process2, fs15, path14, DEFAULT_CASES_FILE, DirtyFileError;
+var import_node_child_process2, fs17, path16, DEFAULT_CASES_FILE, DirtyFileError;
 var init_cases = __esm({
   "src/cli/commands/cases.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_child_process2 = require("child_process");
-    fs15 = __toESM(require("fs"), 1);
-    path14 = __toESM(require("path"), 1);
+    fs17 = __toESM(require("fs"), 1);
+    path16 = __toESM(require("path"), 1);
     init_api_url();
     init_credentials();
     init_sync();
-    DEFAULT_CASES_FILE = path14.join("plune", "cases.md");
+    DEFAULT_CASES_FILE = path16.join("plune", "cases.md");
     DirtyFileError = class extends Error {
       constructor(file) {
         super(`${file} has uncommitted changes; commit them or pass --force to overwrite.`);
@@ -5029,11 +5746,11 @@ module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
 init_api_url();
 var import_commander = require("commander");
-var import_node_fs5 = require("fs");
+var import_node_fs6 = 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_fs5.readFileSync)((0, import_node_path4.join)(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path4.join)(__dirname, "..", "package.json"), "utf-8"));
 function toFormat(s) {
   return s === "json" || s === "markdown" ? s : "console";
 }
@@ -5042,7 +5759,7 @@ function shouldColor(outputPath) {
 }
 function writeReport(text2, outputPath) {
   if (outputPath !== void 0) {
-    (0, import_node_fs5.writeFileSync)(outputPath, text2);
+    (0, import_node_fs6.writeFileSync)(outputPath, text2);
   } else {
     process.stdout.write(text2 + "\n");
   }
@@ -5233,11 +5950,15 @@ function createProgram() {
       await failRunCommand(err, verboseOf(command));
     }
   });
-  runCommand.command("import").argument("<file>", "A JUnit XML or Playwright JSON report").description("Turn a report another runner wrote into a run in Plune \u2014 no provider key needed").option("--format <fmt>", "junit | playwright-json; detected from the file when omitted").option("--key <externalKey>", "The key several jobs share so their reports land in one run").option("--create", "Offer tests nothing matched to the review queue", false).action(
+  runCommand.command("import").argument("<file>", "A JUnit XML or Playwright JSON report, or an Allure allure-results folder").description("Turn a report another runner wrote into a run in Plune \u2014 no provider key needed").option("--format <fmt>", "junit | playwright-json | allure; detected from the file (a folder is allure) when omitted").option("--key <externalKey>", "The key several jobs share so their reports land in one run").option("--create", "Offer tests nothing matched to the review queue", false).option(
+    "--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
+  ).action(
     async (file, options, command) => {
       const [
         { handleRunImport: handleRunImport2 },
-        { IMPORT_FORMATS: IMPORT_FORMATS2, UnknownFormatError: UnknownFormatError2, XmlParseError: XmlParseError2, JsonReportError: JsonReportError2 }
+        { IMPORT_FORMATS: IMPORT_FORMATS2, UnknownFormatError: UnknownFormatError2, XmlParseError: XmlParseError2, JsonReportError: JsonReportError2, AllureReportError: AllureReportError2 }
       ] = await Promise.all([
         Promise.resolve().then(() => (init_run_import(), run_import_exports)),
         Promise.resolve().then(() => (init_importers(), importers_exports))
@@ -5253,14 +5974,15 @@ function createProgram() {
         return;
       }
       try {
-        await handleRunImport2({
+        const imported = await handleRunImport2({
           file,
           ...format !== void 0 ? { format } : {},
           ...options.key !== void 0 ? { key: options.key } : {},
           ...options.create ? { create: true } : {}
         });
+        if (options.failOnMissingAttachments && imported.missingAttachments.length > 0) process.exitCode = 1;
       } catch (err) {
-        if (err instanceof UnknownFormatError2 || err instanceof XmlParseError2 || err instanceof JsonReportError2) {
+        if (err instanceof UnknownFormatError2 || err instanceof XmlParseError2 || err instanceof JsonReportError2 || err instanceof AllureReportError2) {
           process.stderr.write(err.message + "\n");
           process.exit(2);
           return;
@@ -5339,10 +6061,10 @@ function createProgram() {
     const { handleLogin: handleLogin2, reportLoginFailure: reportLoginFailure2 } = await Promise.resolve().then(() => (init_login(), login_exports));
     try {
       const token = options.token ?? await readTokenFromStdin();
-      const { path: path15, verified } = await handleLogin2({ token, skipVerify: options.skipVerify });
+      const { path: path17, verified } = await handleLogin2({ token, skipVerify: options.skipVerify });
       process.stdout.write(
-        verified ? `Logged in. Token checked against the API and saved to ${path15}
-` : `Token saved to ${path15} WITHOUT being checked (--skip-verify).
+        verified ? `Logged in. Token checked against the API and saved to ${path17}
+` : `Token saved to ${path17} WITHOUT being checked (--skip-verify).
 `
       );
     } catch (err) {
@@ -5359,9 +6081,9 @@ function createProgram() {
     const verbose = command.optsWithGlobals().verbose === true;
     const { handleLogout: handleLogout2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
     try {
-      const { removed, path: path15 } = handleLogout2();
+      const { removed, path: path17 } = handleLogout2();
       process.stdout.write(
-        removed ? `Logged out. Removed ${path15}
+        removed ? `Logged out. Removed ${path17}
 ` : "Not logged in \u2014 nothing to remove.\n"
       );
     } catch (err) {
@@ -5490,7 +6212,7 @@ function isMainModule() {
   const entry = process.argv[1];
   if (entry === void 0) return false;
   try {
-    return (0, import_node_fs5.realpathSync)(entry) === (0, import_node_fs5.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
+    return (0, import_node_fs6.realpathSync)(entry) === (0, import_node_fs6.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
   } catch {
     return false;
   }