stackvitals 0.1.0__py3-none-any.whl

stackvitals/ci/shards.py

@@ -0,0 +1,120 @@
+"""Test shards that finish together: test files (or classes) split into N groups by their recorded times, from the
+newest test reports on the default branch or from report files on this machine."""
+import glob
+import json
+import re
+import sys
+from pathlib import Path
+
+from stackvitals.ci.api import APIError, OutOfBudget
+from stackvitals.ci.collect import TEST_REPORTS
+from stackvitals.ci.testreports import parse_archive, parse_report
+
+MAX_BYTES = 50_000_000
+
+
+def unit(tid: str, py_paths: bool = False) -> str:
+    """What a test belongs to: the first part of its id (a file, or a class); py_paths turns a dotted pytest module into
+    its file."""
+    head = tid.split("::", 1)[0]
+    if py_paths and "/" not in head and not head.endswith(".py"):
+        parts = head.split(".")
+        while len(parts) > 1 and parts[-1][:1].isupper():
+            parts.pop()
+        head = "/".join(parts) + ".py"
+    return head
+
+
+def split(times: list, n: int, extra=(), py_paths: bool = False) -> list[dict]:
+    """[{"files", "ms"}] for n shards: the longest first, each onto the lightest shard. Files with no recorded time count
+    as a typical file."""
+    totals = {}
+    for tid, ms in times:
+        u = unit(tid, py_paths)
+        if not u or u.startswith("-") or any(c.isspace() for c in u):
+            continue  # it would reach the test command as an option ("--co"), so it is never passed on
+        totals[u] = totals.get(u, 0) + (ms or 0)
+    typical = sorted(totals.values())[len(totals) // 2] if totals else 0
+    for f in extra:
+        totals.setdefault(f, typical)
+    shards = [{"files": [], "ms": 0} for _ in range(max(1, n))]
+    for u, ms in sorted(totals.items(), key=lambda x: (-x[1], x[0])):
+        s = min(shards, key=lambda s: (s["ms"], len(s["files"])))
+        s["files"].append(u)
+        s["ms"] += ms
+    for s in shards:
+        s["files"].sort()
+    return shards
+
+
+def latest_times(api, branch: str, pattern: str = TEST_REPORTS, look: int = 20) -> tuple[list, dict | None]:
+    """Every test's time from the newest successful run on `branch` that kept test reports, and that run."""
+    # Push runs only: a fork's pull request from its own "main" would otherwise pass for this repo's default branch.
+    body = api._get(f"/repos/{api.repo}/actions/runs", {"branch": branch, "event": "push", "status": "success", "per_page": look})
+    for run in body.get("workflow_runs") or []:
+        arts = [a for a in api.artifacts(run["id"]) if not a.get("expired") and (a.get("size_in_bytes") or 0) <= MAX_BYTES
+                and re.search(pattern, a.get("name") or "", re.I)]
+        times = []
+        for a in arts:
+            data = api.download(a["id"])
+            try:
+                times += parse_archive(data)["all"]
+            except Exception:  # an unreadable report is skipped, never the end of the command
+                continue
+        if times:
+            return times, run
+    return [], None
+
+
+def _local(patterns: list[str]) -> list:
+    times = []
+    for pattern in patterns:
+        for name in sorted(glob.glob(pattern, recursive=True)):
+            parsed = parse_report(name, Path(name).read_bytes())
+            if parsed:
+                times += parsed["all"]
+    return times
+
+
+def _dur(ms: int) -> str:
+    s = round(ms / 1000)
+    return f"{s // 60}m {s % 60:02d}s" if s >= 60 else f"{s}s"
+
+
+def run(args, make_api, tok: str | None) -> int:
+    if args.n < 1 or args.index is not None and not 1 <= args.index <= args.n:
+        print("--n must be 1 or more and --index between 1 and --n.", file=sys.stderr)
+        return 2
+    source = "report files on this machine"
+    if args.reports:
+        times = _local(args.reports)
+    elif args.repo and tok:
+        api = make_api(tok, args.repo, max_requests=60)
+        try:
+            branch = api._get(f"/repos/{args.repo}").get("default_branch") or "main"
+            times, found = latest_times(api, branch)
+        except (APIError, OutOfBudget) as exc:
+            print(f"GitHub refused: {exc}", file=sys.stderr)
+            return 1
+        source = f"run {found['html_url']}" if found else source
+    else:
+        print("Give owner/name (with a GitHub token) or --reports 'path/*.xml'.", file=sys.stderr)
+        return 2
+    if not times:
+        print("No test reports with times found (a test report in an artifact whose name says test results).", file=sys.stderr)
+        return 1
+    extra = sorted({f for pattern in args.files for f in glob.glob(pattern, recursive=True)})
+    shards = split(times, args.n, extra, args.py_paths)
+    if args.index is not None:
+        files = shards[args.index - 1]["files"]
+        if not files:
+            # An empty argument list makes most test runners run everything, so say so where a person will see it.
+            print(f"Shard {args.index} is empty (fewer files than shards): skip the test command in it.", file=sys.stderr)
+        print(" ".join(files))
+    elif args.json:
+        print(json.dumps({"source": source, "tests": len(times), "shards": shards}, indent=1))
+    else:
+        print(f"{args.n} shards from {len(times)} tests in {sum(len(s['files']) for s in shards)} files ({source}):")
+        for k, s in enumerate(shards, 1):
+            print(f"Shard {k}, about {_dur(s['ms'])}: {' '.join(s['files'])}")
+    return 0

stackvitals/ci/share.py

@@ -0,0 +1,59 @@
+"""Opt-in shared benchmarks ([benchmarks] share = true): this repo's CI figures, rounded and without its name unless
+allowed, as a prefilled issue on StackVitals' public repo. Nothing is sent by the Action: a person opens the link and
+files the issue. Once 10+ repos of a kind have shared, their peer group is published beside the public one."""
+import json
+import secrets
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import urlencode
+
+from mergescout.bench.ci import tier
+from stackvitals.ci.bench import BENCH_REPO, PUBLIC_HOME
+
+KIND, SCHEMA, MIN_PUSHES = "ci-benchmark", 1, 20
+FIELDS = ("schema", "kind", "id", "month", "language", "tier", "pushes", "median_s", "p90_s", "first_try_share",
+          "fail_share", "rerun_share")
+ID_FILE = "ci/share-id"  # in the data branch
+
+
+def share_id(root: Path) -> str:
+    """A random id kept in the data branch, so a later month replaces this repo's figures; it says nothing about the repo."""
+    path = Path(root) / ID_FILE
+    try:
+        found = path.read_text(encoding="utf-8").strip()
+    except OSError:
+        found = ""
+    if len(found) == 16 and all(c in "0123456789abcdef" for c in found):
+        return found
+    path.parent.mkdir(parents=True, exist_ok=True)
+    found = secrets.token_hex(8)
+    path.write_text(found + "\n", encoding="utf-8")
+    return found
+
+
+def figures(stats: dict | None, language: str | None, stars: int | None, sid: str, now: datetime,
+            name: str | None = None) -> dict | None:
+    """The shared figures, or None with too few pushes to share safely."""
+    if not stats or stats.get("pushes", 0) < MIN_PUSHES:
+        return None
+    doc = {"schema": SCHEMA, "kind": KIND, "id": sid, "month": f"{now:%Y-%m}", "language": language or "other",
+           "tier": tier(stars), "pushes": int(round(stats["pushes"], -1)), "median_s": int(round(stats["median_s"] / 30) * 30),
+           "p90_s": int(round(stats["p90_s"] / 60) * 60), "first_try_share": round(stats["first_try_share"], 2),
+           "fail_share": round(stats["fail_share"], 2), "rerun_share": round(stats["rerun_share"], 2)}
+    return {**doc, "repo": name} if name else doc
+
+
+def link(doc: dict) -> str:
+    # The issue form adds the "benchmark" label for anyone; a plain new-issue link drops labels for people without triage rights.
+    title = f"Benchmark figures: {doc['language']}, {doc['tier']} stars, {doc['month']}"
+    # Figures are filed on the public home once there is one; the daily collector reads both repos.
+    return f"https://github.com/{PUBLIC_HOME or BENCH_REPO}/issues/new?" + urlencode(
+        {"template": "benchmark.yml", "title": title, "figures": json.dumps(doc, indent=1)})
+
+
+def summary_line(doc: dict | None) -> str:
+    if not doc:
+        return f"Shared benchmarks are on, but this repo had fewer than {MIN_PUSHES} pushes in the window; nothing to share yet."
+    who = f"named {doc['repo']}" if doc.get("repo") else "without the repo's name"
+    return (f"Shared benchmarks: [file this month's rounded CI figures]({link(doc)}) ({who}; the issue shows the account "
+            "that files it). Peer groups are published once 10+ repos of a kind have shared.")

stackvitals/ci/store.py

@@ -0,0 +1,93 @@
+import gzip
+import json
+import os
+from datetime import date, timedelta
+from pathlib import Path
+
+SCHEMA = "1"
+KNOWN = "tests-seen.json.gz"
+
+
+class DataStore:
+    # History lives under <root>/ci: one NDJSON file per collection day, compressed once the day is over.
+    def __init__(self, root: Path):
+        self.dir = Path(root) / "ci"
+        self.days = self.dir / "days"
+        self.days.mkdir(parents=True, exist_ok=True)
+        version = self.dir / "VERSION"
+        if not version.exists():
+            version.write_text(SCHEMA + "\n", encoding="utf-8")
+
+    def add(self, records: list[dict], day: str) -> None:
+        if not records:
+            return
+        with (self.days / f"{day}.ndjson").open("a", encoding="utf-8", newline="\n") as f:
+            for r in records:
+                f.write(json.dumps(r, separators=(",", ":"), ensure_ascii=False) + "\n")
+
+    def _lines(self):
+        for path in sorted(self.days.iterdir()):
+            if path.name.endswith(".ndjson.gz"):
+                text = gzip.decompress(path.read_bytes()).decode("utf-8")
+            elif path.name.endswith(".ndjson"):
+                text = path.read_text(encoding="utf-8")
+            else:
+                continue
+            for line in text.splitlines():
+                if line.strip():
+                    yield json.loads(line)
+
+    def load(self) -> dict[str, list[dict]]:
+        # Later records win, so a run seen again keeps its newest state.
+        runs, jobs, tests = {}, {}, {}
+        for r in self._lines():
+            if r.get("t") == "run":
+                runs[(r["id"], r["att"])] = r
+            elif r.get("t") == "job":
+                jobs[r["id"]] = r
+            elif r.get("t") == "tests":
+                tests[r["art"]] = r
+        return {"runs": list(runs.values()), "jobs": list(jobs.values()), "tests": list(tests.values())}
+
+    def state(self) -> dict:
+        path = self.dir / "state.json"
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return {}
+
+    def save_state(self, state: dict) -> None:
+        path = self.dir / "state.json"
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(state, indent=1, sort_keys=True), encoding="utf-8")
+        os.replace(tmp, path)
+
+    def known_tests(self) -> set | None:
+        """Every test id seen so far, or None before the first collect that read test reports."""
+        try:
+            return set(json.loads(gzip.decompress((self.dir / KNOWN).read_bytes())))
+        except (OSError, ValueError, EOFError):
+            return None
+
+    def save_known_tests(self, ids: set) -> None:
+        data = gzip.compress(json.dumps(sorted(ids), separators=(",", ":")).encode("utf-8"), mtime=0)
+        path = self.dir / KNOWN
+        # Written only when a test was added, so most runs leave the data branch alone.
+        if not path.exists() or path.read_bytes() != data:
+            path.write_bytes(data)
+
+    def compress(self, today: str) -> None:
+        for path in sorted(self.days.glob("*.ndjson")):
+            if path.name.split(".")[0] < today:
+                # A past day is kept compressed; late re-runs are merged in and it is compressed again.
+                gz = path.with_name(path.name + ".gz")
+                old = gzip.decompress(gz.read_bytes()) if gz.exists() else b""
+                gz.write_bytes(gzip.compress(old + path.read_bytes(), mtime=0))
+                path.unlink()
+
+    def compact(self, today: str, retention_days: int = 180) -> None:
+        oldest = (date.fromisoformat(today) - timedelta(days=retention_days)).isoformat()
+        for path in sorted(self.days.iterdir()):
+            if path.name.split(".")[0] < oldest:
+                path.unlink()
+        self.compress(today)

stackvitals/ci/testreports.py

@@ -0,0 +1,351 @@
+import hashlib
+import io
+import json
+import math
+import re
+import zipfile
+
+from defusedxml import DefusedXmlException
+from defusedxml.ElementTree import ParseError, fromstring
+
+from stackvitals.ci import coverage
+from stackvitals.ci.fingerprint import analyse
+
+SLOW_KEEP = 200
+SKIP_KEEP = 200
+# Caps per report: a hostile or giant report can't bloat the data branch (ids longer than this are cut).
+MAX_ID, MAX_ROWS, MAX_ALL = 300, 500, 50_000
+FAIL_TAGS = {"failure", "error"}
+FLAKY_TAGS = {"flakyFailure", "flakyError"}
+REPORT_FILES = (".xml", ".trx", ".json", ".jsonl", ".ndjson")
+# A random test order's seed, so a flaky failure can be replayed: Surefire's runOrder seed, `go test -shuffle`.
+SEED_PROPERTY = re.compile(r"seed|randomly", re.I)
+GO_SEED = re.compile(r"-test\.shuffle (\d+)")
+GO_LINE = re.compile(r"^\s*([\w.\-]+\.go:\d+: .*)$")
+# Hosted runners' checkout folders (Linux and macOS, Windows, containers), so a test file reads as a repo path.
+RUNNER_ROOT = re.compile(r"^(?:.*?[\\/]runner[\\/]work[\\/][^\\/]+[\\/][^\\/]+|[A-Za-z]:[\\/]a[\\/][^\\/]+[\\/][^\\/]+"
+                         r"|/github/workspace)[\\/]")
+TRX_FAILED = {"failed", "error", "timeout", "aborted"}
+TRX_SKIPPED = {"notexecuted", "inconclusive", "pending", "notrunnable", "disconnected"}
+JEST_SKIPPED = {"pending", "skipped", "todo", "disabled"}
+
+
+def _failure(tid: str, type_attr: str | None, message: str | None, text: str | None, ms: int | None) -> list:
+    """[test id, per-test key, short message, cause, where, type, ms]: older records hold only the first three."""
+    f = analyse(type_attr, message, text)
+    shown = message or (f"{f.type}: {f.message}" if f.type else f.message) or text
+    return [tid, f.key(tid), _short(shown), f.cause, f.where, f.type, ms]
+
+
+def _short(message: str | None) -> str:
+    text = (message or "").strip()
+    return text.splitlines()[0][:200] if text else ""
+
+
+def _cap_id(tid: str) -> str:
+    # A long id is cut, with a short hash of the whole so two long ids never become one test.
+    return tid if len(tid) <= MAX_ID else f"{tid[:MAX_ID - 9]}~{hashlib.sha1(tid.encode()).hexdigest()[:8]}"
+
+
+def _millis(value, scale: float = 1) -> int:
+    # Report numbers are untrusted: anything not finite or beyond a few months of run time counts as 0.
+    try:
+        ms = float(value) * scale
+    except (TypeError, ValueError, OverflowError):
+        return 0
+    return round(ms) if math.isfinite(ms) and 0 <= ms < 1e10 else 0
+
+
+def _text(value) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _repo_path(path) -> str | None:
+    return RUNNER_ROOT.sub("", path).replace("\\", "/") if isinstance(path, str) and path else None
+
+
+def _empty() -> dict:
+    # "all" (every test and its time) is read for new-test detection and shards, and never stored per report.
+    return {"total": 0, "skipped": 0, "failed": [], "flaky": [], "slow": [], "sk": [], "all": []}
+
+
+def _case() -> dict:
+    return {"fail": None, "passed": False, "flaky": False, "skipped": False, "ms": 0, "detail": None}
+
+
+def _outcomes(seen: dict[str, dict]) -> dict:
+    """Each test's outcomes, gathered over every time the report lists it, as one report: a failure that also passed
+    (a retry inside the same job) is a flake."""
+    out = _empty()
+    for tid, info in seen.items():
+        out["total"] += 1
+        if info["fail"] is not None and info["passed"] or info["flaky"]:
+            # Failed, then passed on a retry inside the same job (Gradle test-retry, pytest-rerunfailures, Surefire).
+            out["flaky"].append(tid)
+        elif info["fail"] is not None:
+            out["failed"].append(_failure(tid, *info["detail"], info["ms"]))
+        elif info["skipped"] and not info["passed"]:
+            out["skipped"] += 1
+    out["slow"] = sorted(([tid, i["ms"]] for tid, i in seen.items()), key=lambda x: -x[1])[:SLOW_KEEP]
+    out["sk"] = [tid for tid, i in seen.items() if i["skipped"] and not i["passed"] and i["fail"] is None and not i["flaky"]][:SKIP_KEEP]
+    out["all"] = [[tid, i["ms"]] for tid, i in seen.items()]
+    return out
+
+
+def _junit(root) -> dict:
+    # A test can appear several times when a retry plugin re-ran it, so outcomes are gathered per test first.
+    seen: dict[str, dict] = {}
+    for case in root.iter("testcase"):
+        name, cls, file = case.get("name") or "?", case.get("classname"), case.get("file")
+        info = seen.setdefault(_cap_id("::".join(p for p in (file, cls, name) if p)), _case())
+        tags = {child.tag: child for child in case}
+        failure = next((tags[t] for t in FAIL_TAGS if t in tags), None)
+        if failure is not None:
+            info["fail"] = info["fail"] or (failure.get("message") or failure.text or "")
+            # The body holds the stack the fingerprint needs; only its result is kept.
+            info["detail"] = info["detail"] or (failure.get("type"), failure.get("message"), failure.text)
+        elif FLAKY_TAGS & tags.keys():
+            info["flaky"] = True
+        elif "skipped" in tags:
+            info["skipped"] = True
+        else:
+            info["passed"] = True
+        info["ms"] = max(info["ms"], _millis(case.get("time") or 0, 1000))
+    out = _outcomes(seen)
+    seed = next((p.get("value") for p in root.iter("property") if SEED_PROPERTY.search(p.get("name") or "") and p.get("value")), None)
+    return {**out, "seed": seed[:40]} if seed else out
+
+
+def _span(value) -> int:
+    # TRX durations read "00:00:01.5000000".
+    m = re.match(r"^(\d+):(\d+):(\d+(?:\.\d+)?)$", value or "")
+    return _millis(int(m[1]) * 3600 + int(m[2]) * 60 + float(m[3]), 1000) if m else 0
+
+
+def _trx(root) -> dict:
+    """A .NET TRX file (dotnet test --logger trx): each result named by its class and test name, parameters included."""
+    ns = root.tag[:root.tag.index("}") + 1] if root.tag.startswith("{") else ""
+    classes = {}
+    for unit in root.iter(f"{ns}UnitTest"):
+        method = unit.find(f"{ns}TestMethod")
+        if method is not None:
+            classes[unit.get("id")] = method.get("className")
+    seen: dict[str, dict] = {}
+    for result in root.iter(f"{ns}UnitTestResult"):
+        name = result.get("testName") or "?"
+        info = seen.setdefault(_cap_id("::".join(p for p in (classes.get(result.get("testId")), name) if p)), _case())
+        outcome = (result.get("outcome") or "").lower()
+        if outcome in TRX_FAILED:
+            error = result.find(f"{ns}Output/{ns}ErrorInfo")
+            message = (error.findtext(f"{ns}Message") or "").strip() if error is not None else ""
+            trace = error.findtext(f"{ns}StackTrace") if error is not None else None
+            info["fail"] = info["fail"] or message
+            info["detail"] = info["detail"] or (None, message or None, trace or message)
+        elif outcome == "passed":
+            info["passed"] = True
+        elif outcome in TRX_SKIPPED:
+            info["skipped"] = True
+        info["ms"] = max(info["ms"], _span(result.get("duration")))
+    return _outcomes(seen)
+
+
+def _xml(data: bytes) -> dict | None:
+    try:
+        root = fromstring(data, forbid_dtd=True)
+    except (DefusedXmlException, ParseError, ValueError):
+        return None
+    return _trx(root) if root.tag.rsplit("}", 1)[-1] == "TestRun" else _junit(root)
+
+
+def _ctrf(doc: dict) -> dict | None:
+    try:
+        tests = doc["results"]["tests"]
+    except (KeyError, TypeError):
+        return None
+    out, slow = _empty(), []
+    for t in tests if isinstance(tests, list) else []:
+        if not isinstance(t, dict):
+            continue
+        tid = _cap_id("::".join(str(p) for p in (t.get("filePath") or t.get("suite"), t.get("name") or "?") if p))
+        out["total"] += 1
+        status = t.get("status")
+        retries = t.get("retries")
+        if status == "failed":
+            ms = _millis(t["duration"]) if isinstance(t.get("duration"), (int, float)) else None
+            message = _text(t.get("message"))
+            out["failed"].append(_failure(tid, None, message, _text(t.get("trace")) or message, ms))
+        elif status == "passed" and (t.get("flaky") is True or isinstance(retries, (int, float)) and retries > 0):
+            out["flaky"].append(tid)
+        elif status in ("skipped", "pending"):
+            out["skipped"] += 1
+            if len(out["sk"]) < SKIP_KEEP:
+                out["sk"].append(tid)
+        ms = _millis(t["duration"]) if isinstance(t.get("duration"), (int, float)) else 0
+        out["all"].append([tid, ms])
+        if isinstance(t.get("duration"), (int, float)):
+            slow.append([tid, ms])
+    out["slow"] = sorted(slow, key=lambda x: -x[1])[:SLOW_KEEP]
+    return out
+
+
+def _jest(doc: dict) -> dict:
+    """Jest's --json and Vitest's json reporter: each test named by its file and full name; a test that passed after
+    retries (jest.retryTimes, Vitest retry) is a flake."""
+    out, slow = _empty(), []
+    for suite in doc.get("testResults") or []:
+        if not isinstance(suite, dict):
+            continue
+        file = _repo_path(suite.get("name") or suite.get("testFilePath"))
+        for t in suite.get("assertionResults") or []:
+            if not isinstance(t, dict):
+                continue
+            name = t.get("fullName") or " ".join([*(str(a) for a in t.get("ancestorTitles") or []), str(t.get("title") or "?")])
+            tid = _cap_id("::".join(p for p in (file, str(name)) if p))
+            out["total"] += 1
+            status = t.get("status")
+            ms = _millis(t["duration"]) if isinstance(t.get("duration"), (int, float)) else 0
+            retried = (isinstance(t.get("invocations"), int) and t["invocations"] > 1) or bool(t.get("retryReasons"))
+            if status == "failed":
+                text = next((m for m in t.get("failureMessages") or [] if isinstance(m, str)), None)
+                out["failed"].append(_failure(tid, None, text, text, ms))
+            elif status == "passed" and retried:
+                out["flaky"].append(tid)
+            elif status in JEST_SKIPPED:
+                out["skipped"] += 1
+                if len(out["sk"]) < SKIP_KEEP:
+                    out["sk"].append(tid)
+            out["all"].append([tid, ms])
+            if isinstance(t.get("duration"), (int, float)):
+                slow.append([tid, ms])
+    out["slow"] = sorted(slow, key=lambda x: -x[1])[:SLOW_KEEP]
+    return out
+
+
+def _go(data: bytes) -> dict | None:
+    """`go test -json` (and gotestsum): one test per package and full name, subtests apart from their parents (a parent
+    fails whenever a subtest does); a test that failed and then passed in the same stream (a rerun) is a flake."""
+    seen: dict[str, dict] = {}
+    parents, seed, events = set(), None, 0
+    for line in data.splitlines():
+        try:
+            e = json.loads(line)
+        except ValueError:
+            continue  # build output can sit between the events
+        if not isinstance(e, dict) or not isinstance(e.get("Action"), str):
+            continue
+        events += 1
+        output, name, pkg = _text(e.get("Output")), _text(e.get("Test")), _text(e.get("Package")) or ""
+        if output and seed is None and (m := GO_SEED.search(output)):
+            seed = m[1]
+        if not name:
+            continue
+        parts = name.split("/")
+        parents.update(f"{pkg}::{'/'.join(parts[:n])}" for n in range(1, len(parts)))
+        info = seen.setdefault(_cap_id(f"{pkg}::{name}" if pkg else name), {**_case(), "lines": []})
+        action = e["Action"]
+        if action == "output" and output:
+            info["lines"] = (info["lines"] + [output.rstrip("\n")])[-50:]
+        elif action == "fail":
+            found = next((m[1] for x in info["lines"] if (m := GO_LINE.match(x))), None)
+            info["fail"] = info["fail"] or found or ""
+            info["detail"] = info["detail"] or (None, found, "\n".join(info["lines"]))
+        elif action == "pass":
+            info["passed"] = True
+        elif action == "skip":
+            info["skipped"] = True
+        if action in ("pass", "fail", "skip"):
+            info["ms"] = max(info["ms"], _millis(e.get("Elapsed") or 0, 1000))
+    if not events:
+        return None
+    # A parent fails whenever a subtest does, so it is left out then; failing with every subtest passing, it is its own.
+    failed_below = {p for p in parents if any(t.startswith(p + "/") and i["fail"] is not None for t, i in seen.items())}
+    out = _outcomes({tid: i for tid, i in seen.items()
+                     if tid not in parents or (i["fail"] is not None and tid not in failed_below)})
+    return {**out, "seed": seed} if seed else out
+
+
+def _json(data: bytes) -> dict | None:
+    try:
+        doc = json.loads(data)
+    except ValueError:
+        return _go(data)  # an event stream, one JSON object per line
+    if not isinstance(doc, dict):
+        return None
+    if "results" in doc:
+        return _ctrf(doc)
+    if isinstance(doc.get("testResults"), list):
+        return _jest(doc)
+    return _go(data) if isinstance(doc.get("Action"), str) else None
+
+
+def parse_report(name: str, data: bytes) -> dict | None:
+    """One JUnit XML, TRX, CTRF JSON, Jest or Vitest JSON, or `go test -json` file; None when it is none of them or is
+    unsafe to read."""
+    head = data.lstrip()[:1]
+    low = name.lower()
+    if low.endswith((".xml", ".trx")) or head == b"<":
+        return _xml(data)
+    if low.endswith((".json", ".jsonl", ".ndjson")) or head == b"{":
+        return _json(data)
+    return None
+
+
+def merge(parts: list[dict]) -> dict:
+    out = _empty()
+    for p in parts:
+        out["total"] += p["total"]
+        out["skipped"] += p["skipped"]
+        out["failed"] += p["failed"]
+        out["flaky"] += p["flaky"]
+        out["slow"] += p["slow"]
+        out["sk"] += p.get("sk") or []
+        out["all"] += p.get("all") or []
+    out["slow"] = sorted(out["slow"], key=lambda x: -x[1])[:SLOW_KEEP]
+    out["sk"] = out["sk"][:SKIP_KEEP]
+    out["failed"], out["flaky"], out["all"] = out["failed"][:MAX_ROWS], out["flaky"][:MAX_ROWS], out["all"][:MAX_ALL]
+    seed = next((p["seed"] for p in parts if p.get("seed")), None)
+    return {**out, "seed": seed} if seed else out
+
+
+def parse_archive(data: bytes, max_file_bytes: int = 20_000_000, max_total_bytes: int = 200_000_000,
+                  max_files: int = 500) -> dict:
+    """Every report inside an Actions artifact zip, read in memory with size limits (nothing is extracted)."""
+    parts, skipped, total, cov = [], 0, 0, None
+    with zipfile.ZipFile(io.BytesIO(data)) as z:
+        for info in z.infolist()[:max_files]:
+            if info.is_dir() or not info.filename.lower().endswith(REPORT_FILES + (".info", ".lcov")):
+                continue
+            # Sizes are checked before reading, so a zip bomb is skipped, not unpacked.
+            if info.file_size > max_file_bytes or total + info.file_size > max_total_bytes:
+                skipped += 1
+                continue
+            total += info.file_size
+            body = z.read(info)
+            found = coverage.parse(info.filename, body) if info.filename.lower().endswith((".xml", ".info", ".lcov")) else None
+            if found:
+                cov = _merge_cov(cov, found)
+                continue
+            if info.filename.lower().endswith((".info", ".lcov")):
+                continue
+            parsed = parse_report(info.filename, body)
+            if parsed is None:
+                if info.filename.lower().endswith((".xml", ".trx")):
+                    skipped += 1
+                continue
+            parts.append(parsed)
+    # "cov" (coverage with its line hits) is read for patch coverage and never stored per report.
+    return {**merge(parts), "skipped_files": skipped, **({"cov": cov} if cov else {})}
+
+
+def _merge_cov(a: dict | None, b: dict) -> dict:
+    """Two coverage files of one artifact as one: a line ran if it ran in either."""
+    if a is None:
+        return b
+    files = a["files"]  # merged in place: copying everything again for each further file cost minutes on big reports
+    for path, hits in b["files"].items():
+        mine = files.setdefault(path, {})
+        for n, h in hits.items():
+            mine[n] = max(mine.get(n, 0), h)
+    lines = sum(len(h) for h in files.values())
+    covered = sum(1 for h in files.values() for x in h.values() if x > 0)
+    return {"format": a["format"] if a["format"] == b["format"] else "mixed", "lines": lines, "covered": covered, "files": files}