@flakiness/sdk 0.146.0 → 0.147.0

package/lib/localReportServer.js

@@ -4,20 +4,22 @@ import { randomUUIDBase62 } from "@flakiness/shared/node/nodeutils.js";
 import { createTypedHttpExpressMiddleware } from "@flakiness/shared/node/typedHttpExpress.js";
 import bodyParser from "body-parser";
 import compression from "compression";
-import debug from "debug";
+import debug2 from "debug";
 import express from "express";
 import "express-async-errors";
-import http2 from "http";
+import http from "http";
 
 // src/localReportApi.ts
 import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path from "path";
 import { z } from "zod/v4";
 
 // src/localGit.ts
 import { exec } from "child_process";
+import debug from "debug";
 import { promisify } from "util";
+var log = debug("fk:git");
 var execAsync = promisify(exec);
 async function listLocalCommits(gitRoot, head, count) {
   const FIELD_SEPARATOR = "|~|";
@@ -53,136 +55,130 @@ async function listLocalCommits(gitRoot, head, count) {
       };
     });
   } catch (error) {
-    console.error(`Failed to list commits for repository at ${gitRoot}:`, error);
-    throw error;
+    log(`Failed to list commits for repository at ${gitRoot}:`, error);
+    return [];
   }
 }
 
-// src/utils.ts
-import { ReportUtils } from "@flakiness/report";
-import fs from "fs";
-import http from "http";
-import https from "https";
-import path, { posix as posixPath, win32 as win32Path } from "path";
-var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
-function errorText(error) {
-  return FLAKINESS_DBG ? error.stack : error.message;
-}
-async function retryWithBackoff(job, backoff = []) {
-  for (const timeout of backoff) {
-    try {
-      return await job();
-    } catch (e) {
-      if (e instanceof AggregateError)
-        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
-      else if (e instanceof Error)
-        console.error(`[flakiness.io err]`, errorText(e));
-      else
-        console.error(`[flakiness.io err]`, e);
-      await new Promise((x) => setTimeout(x, timeout));
+// src/reportUtils.ts
+import { Multimap } from "@flakiness/shared/common/multimap.js";
+import { xxHash, xxHashObject } from "@flakiness/shared/common/utils.js";
+var ReportUtils;
+((ReportUtils2) => {
+  function visitTests(report, testVisitor) {
+    function visitSuite(suite, parents) {
+      parents.push(suite);
+      for (const test of suite.tests ?? [])
+        testVisitor(test, parents);
+      for (const childSuite of suite.suites ?? [])
+        visitSuite(childSuite, parents);
+      parents.pop();
     }
+    for (const test of report.tests ?? [])
+      testVisitor(test, []);
+    for (const suite of report.suites)
+      visitSuite(suite, []);
   }
-  return await job();
-}
-var httpUtils;
-((httpUtils2) => {
-  function createRequest({ url, method = "get", headers = {} }) {
-    let resolve;
-    let reject;
-    const responseDataPromise = new Promise((a, b) => {
-      resolve = a;
-      reject = b;
-    });
-    const protocol = url.startsWith("https") ? https : http;
-    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
-    const request = protocol.request(url, { method, headers }, (res) => {
-      const chunks = [];
-      res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => {
-        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
-          resolve(Buffer.concat(chunks));
-        else
-          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+  ReportUtils2.visitTests = visitTests;
+  function normalizeReport(report) {
+    const gEnvs = /* @__PURE__ */ new Map();
+    const gSuites = /* @__PURE__ */ new Map();
+    const gTests = new Multimap();
+    const gSuiteIds = /* @__PURE__ */ new Map();
+    const gTestIds = /* @__PURE__ */ new Map();
+    const gEnvIds = /* @__PURE__ */ new Map();
+    const gSuiteChildren = new Multimap();
+    const gSuiteTests = new Multimap();
+    for (const env of report.environments) {
+      const envId = computeEnvId(env);
+      gEnvs.set(envId, env);
+      gEnvIds.set(env, envId);
+    }
+    const usedEnvIds = /* @__PURE__ */ new Set();
+    function visitTests2(tests, suiteId) {
+      for (const test of tests ?? []) {
+        const testId = computeTestId(test, suiteId);
+        gTests.set(testId, test);
+        gTestIds.set(test, testId);
+        gSuiteTests.set(suiteId, test);
+        for (const attempt of test.attempts) {
+          const env = report.environments[attempt.environmentIdx];
+          const envId = gEnvIds.get(env);
+          usedEnvIds.add(envId);
+        }
+      }
+    }
+    function visitSuite(suite, parentSuiteId) {
+      const suiteId = computeSuiteId(suite, parentSuiteId);
+      gSuites.set(suiteId, suite);
+      gSuiteIds.set(suite, suiteId);
+      for (const childSuite of suite.suites ?? []) {
+        visitSuite(childSuite, suiteId);
+        gSuiteChildren.set(suiteId, childSuite);
+      }
+      visitTests2(suite.tests ?? [], suiteId);
+    }
+    function transformTests(tests) {
+      const testIds = new Set(tests.map((test) => gTestIds.get(test)));
+      return [...testIds].map((testId) => {
+        const tests2 = gTests.getAll(testId);
+        const tags = tests2.map((test) => test.tags ?? []).flat();
+        return {
+          location: tests2[0].location,
+          title: tests2[0].title,
+          tags: tags.length ? tags : void 0,
+          attempts: tests2.map((t2) => t2.attempts).flat().map((attempt) => ({
+            ...attempt,
+            environmentIdx: envIdToIndex.get(gEnvIds.get(report.environments[attempt.environmentIdx]))
+          }))
+        };
       });
-      res.on("error", (error) => reject(error));
-    });
-    request.on("error", reject);
-    return { request, responseDataPromise };
-  }
-  httpUtils2.createRequest = createRequest;
-  async function getBuffer(url, backoff) {
-    return await retryWithBackoff(async () => {
-      const { request, responseDataPromise } = createRequest({ url });
-      request.end();
-      return await responseDataPromise;
-    }, backoff);
-  }
-  httpUtils2.getBuffer = getBuffer;
-  async function getText(url, backoff) {
-    const buffer = await getBuffer(url, backoff);
-    return buffer.toString("utf-8");
-  }
-  httpUtils2.getText = getText;
-  async function getJSON(url) {
-    return JSON.parse(await getText(url));
-  }
-  httpUtils2.getJSON = getJSON;
-  async function postText(url, text, backoff) {
-    const headers = {
-      "Content-Type": "application/json",
-      "Content-Length": Buffer.byteLength(text) + ""
+    }
+    function transformSuites(suites) {
+      const suiteIds = new Set(suites.map((suite) => gSuiteIds.get(suite)));
+      return [...suiteIds].map((suiteId) => {
+        const suite = gSuites.get(suiteId);
+        return {
+          location: suite.location,
+          title: suite.title,
+          type: suite.type,
+          suites: transformSuites(gSuiteChildren.getAll(suiteId)),
+          tests: transformTests(gSuiteTests.getAll(suiteId))
+        };
+      });
+    }
+    visitTests2(report.tests ?? [], "suiteless");
+    for (const suite of report.suites)
+      visitSuite(suite);
+    const newEnvironments = [...usedEnvIds];
+    const envIdToIndex = new Map(newEnvironments.map((envId, index) => [envId, index]));
+    return {
+      ...report,
+      environments: newEnvironments.map((envId) => gEnvs.get(envId)),
+      suites: transformSuites(report.suites),
+      tests: transformTests(report.tests ?? [])
     };
-    return await retryWithBackoff(async () => {
-      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
-      request.write(text);
-      request.end();
-      return await responseDataPromise;
-    }, backoff);
   }
-  httpUtils2.postText = postText;
-  async function postJSON(url, json, backoff) {
-    const buffer = await postText(url, JSON.stringify(json), backoff);
-    return JSON.parse(buffer.toString("utf-8"));
+  ReportUtils2.normalizeReport = normalizeReport;
+  function computeEnvId(env) {
+    return xxHashObject(env);
   }
-  httpUtils2.postJSON = postJSON;
-})(httpUtils || (httpUtils = {}));
-var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
-async function resolveAttachmentPaths(report, attachmentsDir) {
-  const attachmentFiles = await listFilesRecursively(attachmentsDir);
-  const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
-  const attachmentIdToPath = /* @__PURE__ */ new Map();
-  const missingAttachments = /* @__PURE__ */ new Set();
-  ReportUtils.visitTests(report, (test) => {
-    for (const attempt of test.attempts) {
-      for (const attachment of attempt.attachments ?? []) {
-        const attachmentPath = filenameToPath.get(attachment.id);
-        if (!attachmentPath) {
-          missingAttachments.add(attachment.id);
-        } else {
-          attachmentIdToPath.set(attachment.id, {
-            contentType: attachment.contentType,
-            id: attachment.id,
-            path: attachmentPath
-          });
-        }
-      }
-    }
-  });
-  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
-}
-async function listFilesRecursively(dir, result = []) {
-  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory())
-      await listFilesRecursively(fullPath, result);
-    else
-      result.push(fullPath);
+  function computeSuiteId(suite, parentSuiteId) {
+    return xxHash([
+      parentSuiteId ?? "",
+      suite.type,
+      suite.location?.file ?? "",
+      suite.title
+    ]);
   }
-  return result;
-}
-var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
-var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+  function computeTestId(test, suiteId) {
+    return xxHash([
+      suiteId,
+      test.location?.file ?? "",
+      test.title
+    ]);
+  }
+})(ReportUtils || (ReportUtils = {}));
 
 // src/localReportApi.ts
 var ReportInfo = class {
@@ -193,7 +189,7 @@ var ReportInfo = class {
   attachmentIdToPath = /* @__PURE__ */ new Map();
   commits = [];
   async refresh() {
-    const report = await fs2.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
+    const report = await fs.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
     if (!report) {
       this.report = void 0;
       this.commits = [];
@@ -203,7 +199,7 @@ var ReportInfo = class {
     if (JSON.stringify(report) === JSON.stringify(this.report))
       return;
     this.report = report;
-    this.commits = await listLocalCommits(path2.dirname(this._options.reportPath), report.commitId, 100);
+    this.commits = await listLocalCommits(path.dirname(this._options.reportPath), report.commitId, 100);
     const attachmentsDir = this._options.attachmentsFolder;
     const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
     if (missingAttachments.length) {
@@ -237,7 +233,7 @@ var localReportRouter = {
         const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
         if (!idx)
           throw TypedHTTP.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs2.promises.readFile(idx.path);
+        const buffer = await fs.promises.readFile(idx.path);
         return TypedHTTP.ok(buffer, idx.contentType);
       }
     }),
@@ -249,9 +245,43 @@ var localReportRouter = {
     })
   }
 };
+async function resolveAttachmentPaths(report, attachmentsDir) {
+  const attachmentFiles = await listFilesRecursively(attachmentsDir);
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
+  const attachmentIdToPath = /* @__PURE__ */ new Map();
+  const missingAttachments = /* @__PURE__ */ new Set();
+  ReportUtils.visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const attachment of attempt.attachments ?? []) {
+        const attachmentPath = filenameToPath.get(attachment.id);
+        if (!attachmentPath) {
+          missingAttachments.add(attachment.id);
+        } else {
+          attachmentIdToPath.set(attachment.id, {
+            contentType: attachment.contentType,
+            id: attachment.id,
+            path: attachmentPath
+          });
+        }
+      }
+    }
+  });
+  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
+}
+async function listFilesRecursively(dir, result = []) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      await listFilesRecursively(fullPath, result);
+    else
+      result.push(fullPath);
+  }
+  return result;
+}
 
 // src/localReportServer.ts
-var logHTTPServer = debug("fk:http");
+var logHTTPServer = debug2("fk:http");
 var LocalReportServer = class _LocalReportServer {
   constructor(_server, _port, _authToken) {
     this._server = _server;
@@ -292,7 +322,7 @@ var LocalReportServer = class _LocalReportServer {
       logHTTPServer(err);
       res.status(500).send({ error: "Internal Server Error" });
     });
-    const server = http2.createServer(app);
+    const server = http.createServer(app);
     server.on("error", (err) => {
       if (err.code === "ECONNRESET") {
         logHTTPServer("Client connection reset. Ignoring.");

package/lib/pathutils.js

@@ -0,0 +1,20 @@
+// src/pathutils.ts
+import { posix as posixPath, win32 as win32Path } from "path";
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+function normalizePath(aPath) {
+  if (IS_WIN32_PATH.test(aPath)) {
+    aPath = aPath.split(win32Path.sep).join(posixPath.sep);
+  }
+  if (IS_ALMOST_POSIX_PATH.test(aPath))
+    return "/" + aPath[0] + aPath.substring(2);
+  return aPath;
+}
+function gitFilePath(gitRoot, absolutePath) {
+  return posixPath.relative(gitRoot, absolutePath);
+}
+export {
+  gitFilePath,
+  normalizePath
+};
+//# sourceMappingURL=pathutils.js.map

package/lib/reportUploader.js

@@ -1,16 +1,15 @@
 // src/reportUploader.ts
 import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
 import assert from "assert";
+import crypto from "crypto";
 import fs from "fs";
 import { URL } from "url";
 
-// src/serverapi.ts
-import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
-
-// src/utils.ts
-import { ReportUtils } from "@flakiness/report";
+// src/httpUtils.ts
 import http from "http";
 import https from "https";
+
+// src/utils.ts
 var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
 function errorText(error) {
   return FLAKINESS_DBG ? error.stack : error.message;
@@ -31,6 +30,10 @@ async function retryWithBackoff(job, backoff = []) {
   }
   return await job();
 }
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+
+// src/httpUtils.ts
+var FLAKINESS_DBG2 = !!process.env.FLAKINESS_DBG;
 var httpUtils;
 ((httpUtils2) => {
   function createRequest({ url, method = "get", headers = {} }) {
@@ -93,26 +96,40 @@ var httpUtils;
   }
   httpUtils2.postJSON = postJSON;
 })(httpUtils || (httpUtils = {}));
-var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
-var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
-var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
-
-// src/serverapi.ts
-function createServerAPI(endpoint, options) {
-  endpoint += "/api/";
-  const fetcher = options?.auth ? (url, init) => fetch(url, {
-    ...init,
-    headers: {
-      ...init.headers,
-      "Authorization": `Bearer ${options.auth}`
-    }
-  }) : fetch;
-  if (options?.retries)
-    return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
-  return TypedHTTP.createClient(endpoint, fetcher);
-}
 
 // src/reportUploader.ts
+function sha1File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+    stream.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function createFileAttachment(contentType, filePath) {
+  return {
+    contentType,
+    id: await sha1File(filePath),
+    path: filePath
+  };
+}
+async function createDataAttachment(contentType, data) {
+  const hash = crypto.createHash("sha1");
+  hash.update(data);
+  const id = hash.digest("hex");
+  return {
+    contentType,
+    id,
+    body: data
+  };
+}
 var ReportUploader = class _ReportUploader {
   static optionsFromEnv(overrides) {
     const flakinessAccessToken = overrides?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
@@ -153,33 +170,54 @@ var ReportUpload = class {
   _report;
   _attachments;
   _options;
-  _api;
   constructor(options, report, attachments) {
     this._options = options;
     this._report = report;
     this._attachments = attachments;
-    this._api = createServerAPI(this._options.flakinessEndpoint, { retries: HTTP_BACKOFF, auth: this._options.flakinessAccessToken });
+  }
+  async _api(pathname, token, body) {
+    const url = new URL(this._options.flakinessEndpoint);
+    url.pathname = pathname;
+    return await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    }).then(async (response) => !response.ok ? {
+      result: void 0,
+      error: response.status + " " + url.href + " " + await response.text()
+    } : {
+      result: await response.json(),
+      error: void 0
+    }).catch((error) => ({
+      result: void 0,
+      error
+    }));
   }
   async upload(options) {
-    const response = await this._api.run.startUpload.POST({
-      attachmentIds: this._attachments.map((attachment) => attachment.id)
-    }).then((result) => ({ result, error: void 0 })).catch((e) => ({ result: void 0, error: e }));
+    const response = await this._api("/api/upload/start", this._options.flakinessAccessToken);
     if (response?.error || !response.result)
-      return { success: false, message: `flakiness.io returned error: ${response.error.message}` };
+      return { success: false, message: response.error };
+    const webUrl = new URL(response.result.webUrl, this._options.flakinessEndpoint).toString();
+    const attachmentsPresignedUrls = await this._api("/api/upload/attachments", response.result.uploadToken, {
+      attachmentIds: this._attachments.map((a) => a.id)
+    });
+    if (attachmentsPresignedUrls?.error || !attachmentsPresignedUrls.result)
+      return { success: false, message: attachmentsPresignedUrls.error };
+    const attachments = new Map(attachmentsPresignedUrls.result.map((a) => [a.attachmentId, a.presignedUrl]));
     await Promise.all([
-      this._uploadReport(JSON.stringify(this._report), response.result.report_upload_url, options?.syncCompression ?? false),
+      this._uploadReport(JSON.stringify(this._report), response.result.presignedReportUrl, options?.syncCompression ?? false),
       ...this._attachments.map((attachment) => {
-        const uploadURL = response.result.attachment_upload_urls[attachment.id];
+        const uploadURL = attachments.get(attachment.id);
         if (!uploadURL)
           throw new Error("Internal error: missing upload URL for attachment!");
         return this._uploadAttachment(attachment, uploadURL, options?.syncCompression ?? false);
       })
     ]);
-    const response2 = await this._api.run.completeUpload.POST({
-      upload_token: response.result.upload_token
-    }).then((result) => ({ result, error: void 0 })).catch((e) => ({ error: e, result: void 0 }));
-    const url = response2?.result?.report_url ? new URL(response2?.result.report_url, this._options.flakinessEndpoint).toString() : void 0;
-    return { success: true, reportUrl: url };
+    await this._api("/api/upload/finish", response.result.uploadToken);
+    return { success: true, reportUrl: webUrl };
   }
   async _uploadReport(data, uploadUrl, syncCompression) {
     const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
@@ -241,6 +279,8 @@ var ReportUpload = class {
   }
 };
 export {
-  ReportUploader
+  ReportUploader,
+  createDataAttachment,
+  createFileAttachment
 };
 //# sourceMappingURL=reportUploader.js.map

package/lib/reportUtils.js

@@ -0,0 +1,123 @@
+// src/reportUtils.ts
+import { Multimap } from "@flakiness/shared/common/multimap.js";
+import { xxHash, xxHashObject } from "@flakiness/shared/common/utils.js";
+var ReportUtils;
+((ReportUtils2) => {
+  function visitTests(report, testVisitor) {
+    function visitSuite(suite, parents) {
+      parents.push(suite);
+      for (const test of suite.tests ?? [])
+        testVisitor(test, parents);
+      for (const childSuite of suite.suites ?? [])
+        visitSuite(childSuite, parents);
+      parents.pop();
+    }
+    for (const test of report.tests ?? [])
+      testVisitor(test, []);
+    for (const suite of report.suites)
+      visitSuite(suite, []);
+  }
+  ReportUtils2.visitTests = visitTests;
+  function normalizeReport(report) {
+    const gEnvs = /* @__PURE__ */ new Map();
+    const gSuites = /* @__PURE__ */ new Map();
+    const gTests = new Multimap();
+    const gSuiteIds = /* @__PURE__ */ new Map();
+    const gTestIds = /* @__PURE__ */ new Map();
+    const gEnvIds = /* @__PURE__ */ new Map();
+    const gSuiteChildren = new Multimap();
+    const gSuiteTests = new Multimap();
+    for (const env of report.environments) {
+      const envId = computeEnvId(env);
+      gEnvs.set(envId, env);
+      gEnvIds.set(env, envId);
+    }
+    const usedEnvIds = /* @__PURE__ */ new Set();
+    function visitTests2(tests, suiteId) {
+      for (const test of tests ?? []) {
+        const testId = computeTestId(test, suiteId);
+        gTests.set(testId, test);
+        gTestIds.set(test, testId);
+        gSuiteTests.set(suiteId, test);
+        for (const attempt of test.attempts) {
+          const env = report.environments[attempt.environmentIdx];
+          const envId = gEnvIds.get(env);
+          usedEnvIds.add(envId);
+        }
+      }
+    }
+    function visitSuite(suite, parentSuiteId) {
+      const suiteId = computeSuiteId(suite, parentSuiteId);
+      gSuites.set(suiteId, suite);
+      gSuiteIds.set(suite, suiteId);
+      for (const childSuite of suite.suites ?? []) {
+        visitSuite(childSuite, suiteId);
+        gSuiteChildren.set(suiteId, childSuite);
+      }
+      visitTests2(suite.tests ?? [], suiteId);
+    }
+    function transformTests(tests) {
+      const testIds = new Set(tests.map((test) => gTestIds.get(test)));
+      return [...testIds].map((testId) => {
+        const tests2 = gTests.getAll(testId);
+        const tags = tests2.map((test) => test.tags ?? []).flat();
+        return {
+          location: tests2[0].location,
+          title: tests2[0].title,
+          tags: tags.length ? tags : void 0,
+          attempts: tests2.map((t) => t.attempts).flat().map((attempt) => ({
+            ...attempt,
+            environmentIdx: envIdToIndex.get(gEnvIds.get(report.environments[attempt.environmentIdx]))
+          }))
+        };
+      });
+    }
+    function transformSuites(suites) {
+      const suiteIds = new Set(suites.map((suite) => gSuiteIds.get(suite)));
+      return [...suiteIds].map((suiteId) => {
+        const suite = gSuites.get(suiteId);
+        return {
+          location: suite.location,
+          title: suite.title,
+          type: suite.type,
+          suites: transformSuites(gSuiteChildren.getAll(suiteId)),
+          tests: transformTests(gSuiteTests.getAll(suiteId))
+        };
+      });
+    }
+    visitTests2(report.tests ?? [], "suiteless");
+    for (const suite of report.suites)
+      visitSuite(suite);
+    const newEnvironments = [...usedEnvIds];
+    const envIdToIndex = new Map(newEnvironments.map((envId, index) => [envId, index]));
+    return {
+      ...report,
+      environments: newEnvironments.map((envId) => gEnvs.get(envId)),
+      suites: transformSuites(report.suites),
+      tests: transformTests(report.tests ?? [])
+    };
+  }
+  ReportUtils2.normalizeReport = normalizeReport;
+  function computeEnvId(env) {
+    return xxHashObject(env);
+  }
+  function computeSuiteId(suite, parentSuiteId) {
+    return xxHash([
+      parentSuiteId ?? "",
+      suite.type,
+      suite.location?.file ?? "",
+      suite.title
+    ]);
+  }
+  function computeTestId(test, suiteId) {
+    return xxHash([
+      suiteId,
+      test.location?.file ?? "",
+      test.title
+    ]);
+  }
+})(ReportUtils || (ReportUtils = {}));
+export {
+  ReportUtils
+};
+//# sourceMappingURL=reportUtils.js.map