@flakiness/sdk 0.146.0 → 0.147.0

package/lib/{playwright-test.js → index.js}

@@ -1,91 +1,49 @@
-// src/playwright-test.ts
-import { ReportUtils as ReportUtils2 } from "@flakiness/report";
-import { Multimap } from "@flakiness/shared/common/multimap.js";
-import chalk2 from "chalk";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+import chalk from "chalk";
 import fs6 from "fs";
-import path5 from "path";
+import open from "open";
+import path3 from "path";
 
-// src/createTestStepSnippets.ts
-import { codeFrameColumns } from "@babel/code-frame";
+// src/flakinessProjectConfig.ts
 import fs from "fs";
-function createTestStepSnippets(filepathToSteps) {
-  for (const [filepath, steps] of filepathToSteps) {
-    let source;
-    try {
-      source = fs.readFileSync(filepath, "utf-8");
-    } catch (e) {
-      continue;
-    }
-    const lines = source.split("\n").length;
-    const highlighted = codeFrameColumns(source, { start: { line: lines, column: 1 } }, { highlightCode: true, linesAbove: lines, linesBelow: 0 });
-    const highlightedLines = highlighted.split("\n");
-    const lineWithArrow = highlightedLines[highlightedLines.length - 1];
-    for (const step of steps) {
-      if (!step.location)
-        continue;
-      if (step.location.line < 2 || step.location.line >= lines)
-        continue;
-      const snippetLines = highlightedLines.slice(step.location.line - 2, step.location.line + 1);
-      const index = lineWithArrow.indexOf("^");
-      const shiftedArrow = lineWithArrow.slice(0, index) + " ".repeat(step.location.column - 1) + lineWithArrow.slice(index);
-      snippetLines.splice(2, 0, shiftedArrow);
-      step.snippet = snippetLines.join("\n");
-    }
-  }
-}
+import path from "path";
 
-// src/reportUploader.ts
-import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
-import assert2 from "assert";
-import fs3 from "fs";
-import { URL as URL2 } from "url";
+// src/git.ts
+import assert from "assert";
 
-// src/serverapi.ts
-import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+// src/pathutils.ts
+var pathutils_exports = {};
+__export(pathutils_exports, {
+  gitFilePath: () => gitFilePath,
+  normalizePath: () => normalizePath
+});
+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);
+}
 
 // src/utils.ts
-import { ReportUtils } from "@flakiness/report";
-import assert from "assert";
 import { spawnSync } from "child_process";
-import crypto from "crypto";
-import fs2 from "fs";
-import http from "http";
-import https from "https";
-import os from "os";
-import path, { posix as posixPath, win32 as win32Path } from "path";
-async function existsAsync(aPath) {
-  return fs2.promises.stat(aPath).then(() => true).catch((e) => false);
-}
-function extractEnvConfiguration() {
-  const ENV_PREFIX = "FK_ENV_";
-  return Object.fromEntries(
-    Object.entries(process.env).filter(([key]) => key.toUpperCase().startsWith(ENV_PREFIX.toUpperCase())).map(([key, value]) => [key.substring(ENV_PREFIX.length).toLowerCase(), (value ?? "").trim().toLowerCase()])
-  );
-}
-function sha1File(filePath) {
-  return new Promise((resolve, reject) => {
-    const hash = crypto.createHash("sha1");
-    const stream = fs2.createReadStream(filePath);
-    stream.on("data", (chunk) => {
-      hash.update(chunk);
-    });
-    stream.on("end", () => {
-      resolve(hash.digest("hex"));
-    });
-    stream.on("error", (err2) => {
-      reject(err2);
-    });
-  });
-}
 var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
 function errorText(error) {
   return FLAKINESS_DBG ? error.stack : error.message;
 }
-function sha1Buffer(data) {
-  const hash = crypto.createHash("sha1");
-  hash.update(data);
-  return hash.digest("hex");
-}
 async function retryWithBackoff(job, backoff = []) {
   for (const timeout of backoff) {
     try {
@@ -102,95 +60,10 @@ async function retryWithBackoff(job, backoff = []) {
   }
   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}`));
-      });
-      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) + ""
-    };
-    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"));
-  }
-  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");
 function stripAnsi(str) {
   return str.replace(ansiRegex, "");
 }
-async function saveReportAndAttachments(report, attachments, outputFolder) {
-  const reportPath = path.join(outputFolder, "report.json");
-  const attachmentsFolder = path.join(outputFolder, "attachments");
-  await fs2.promises.rm(outputFolder, { recursive: true, force: true });
-  await fs2.promises.mkdir(outputFolder, { recursive: true });
-  await fs2.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
-  if (attachments.length)
-    await fs2.promises.mkdir(attachmentsFolder);
-  const movedAttachments = [];
-  for (const attachment of attachments) {
-    const attachmentPath = path.join(attachmentsFolder, attachment.id);
-    if (attachment.path)
-      await fs2.promises.cp(attachment.path, attachmentPath);
-    else if (attachment.body)
-      await fs2.promises.writeFile(attachmentPath, attachment.body);
-    movedAttachments.push({
-      contentType: attachment.contentType,
-      id: attachment.id,
-      path: attachmentPath
-    });
-  }
-  return movedAttachments;
-}
 function shell(command, args, options) {
   try {
     const result = spawnSync(command, args, { encoding: "utf-8", ...options });
@@ -203,47 +76,8 @@ function shell(command, args, options) {
     return void 0;
   }
 }
-function readLinuxOSRelease() {
-  const osReleaseText = fs2.readFileSync("/etc/os-release", "utf-8");
-  return new Map(osReleaseText.toLowerCase().split("\n").filter((line) => line.includes("=")).map((line) => {
-    line = line.trim();
-    let [key, value] = line.split("=");
-    if (value.startsWith('"') && value.endsWith('"'))
-      value = value.substring(1, value.length - 1);
-    return [key, value];
-  }));
-}
-function osLinuxInfo() {
-  const arch = shell(`uname`, [`-m`]);
-  const osReleaseMap = readLinuxOSRelease();
-  const name = osReleaseMap.get("name") ?? shell(`uname`);
-  const version = osReleaseMap.get("version_id");
-  return { name, arch, version };
-}
-function osDarwinInfo() {
-  const name = "macos";
-  const arch = shell(`uname`, [`-m`]);
-  const version = shell(`sw_vers`, [`-productVersion`]);
-  return { name, arch, version };
-}
-function osWinInfo() {
-  const name = "win";
-  const arch = process.arch;
-  const version = os.release();
-  return { name, arch, version };
-}
-function getOSInfo() {
-  if (process.platform === "darwin")
-    return osDarwinInfo();
-  if (process.platform === "win32")
-    return osWinInfo();
-  return osLinuxInfo();
-}
-function inferRunUrl() {
-  if (process.env.GITHUB_REPOSITORY && process.env.GITHUB_RUN_ID)
-    return `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
-  return void 0;
-}
+
+// src/git.ts
 function gitCommitInfo(gitRepo) {
   const sha = shell(`git`, ["rev-parse", "HEAD"], {
     cwd: gitRepo,
@@ -252,40 +86,6 @@ function gitCommitInfo(gitRepo) {
   assert(sha, `FAILED: git rev-parse HEAD @ ${gitRepo}`);
   return sha.trim();
 }
-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 fs2.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;
-}
 function computeGitRoot(somePathInsideGitRepo) {
   const root = shell(`git`, ["rev-parse", "--show-toplevel"], {
     cwd: somePathInsideGitRepo,
@@ -294,224 +94,22 @@ function computeGitRoot(somePathInsideGitRepo) {
   assert(root, `FAILED: git rev-parse --show-toplevel HEAD @ ${somePathInsideGitRepo}`);
   return normalizePath(root);
 }
-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);
+
+// src/flakinessProjectConfig.ts
+function createConfigPath(dir) {
+  return path.join(dir, ".flakiness", "config.json");
 }
-function parseDurationMS(value) {
-  if (isNaN(value))
-    throw new Error("Duration cannot be NaN");
-  if (value < 0)
-    throw new Error(`Duration cannot be less than 0, found ${value}`);
-  return value | 0;
+var gConfigPath;
+function ensureConfigPath() {
+  if (!gConfigPath)
+    gConfigPath = computeConfigPath();
+  return gConfigPath;
 }
-function createEnvironments(projects) {
-  const envConfiguration = extractEnvConfiguration();
-  const osInfo = getOSInfo();
-  let uniqueNames = /* @__PURE__ */ new Set();
-  const result = /* @__PURE__ */ new Map();
-  for (const project of projects) {
-    let defaultName = project.name;
-    if (!defaultName.trim())
-      defaultName = "anonymous";
-    let name = defaultName;
-    for (let i = 2; uniqueNames.has(name); ++i)
-      name = `${defaultName}-${i}`;
-    uniqueNames.add(defaultName);
-    result.set(project, {
-      name,
-      systemData: {
-        osArch: osInfo.arch,
-        osName: osInfo.name,
-        osVersion: osInfo.version
-      },
-      userSuppliedData: {
-        ...envConfiguration,
-        ...project.metadata
-      },
-      opaqueData: {
-        project
-      }
-    });
-  }
-  return result;
-}
-
-// 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
-var ReportUploader = class _ReportUploader {
-  static optionsFromEnv(overrides) {
-    const flakinessAccessToken = overrides?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
-    if (!flakinessAccessToken)
-      return void 0;
-    const flakinessEndpoint = overrides?.flakinessEndpoint ?? process.env["FLAKINESS_ENDPOINT"] ?? "https://flakiness.io";
-    return { flakinessAccessToken, flakinessEndpoint };
-  }
-  static async upload(options) {
-    const uploaderOptions = _ReportUploader.optionsFromEnv(options);
-    if (!uploaderOptions) {
-      if (process.env.CI)
-        options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
-      return void 0;
-    }
-    const uploader = new _ReportUploader(uploaderOptions);
-    const upload = uploader.createUpload(options.report, options.attachments);
-    const uploadResult = await upload.upload();
-    if (!uploadResult.success) {
-      options.log?.(`[flakiness.io] X Failed to upload to ${uploaderOptions.flakinessEndpoint}: ${uploadResult.message}`);
-      return { errorMessage: uploadResult.message };
-    }
-    options.log?.(`[flakiness.io] \u2713 Report uploaded ${uploadResult.message ?? ""}`);
-    if (uploadResult.reportUrl)
-      options.log?.(`[flakiness.io] ${uploadResult.reportUrl}`);
-  }
-  _options;
-  constructor(options) {
-    this._options = options;
-  }
-  createUpload(report, attachments) {
-    const upload = new ReportUpload(this._options, report, attachments);
-    return upload;
-  }
-};
-var HTTP_BACKOFF = [100, 500, 1e3, 1e3, 1e3, 1e3];
-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 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 }));
-    if (response?.error || !response.result)
-      return { success: false, message: `flakiness.io returned error: ${response.error.message}` };
-    await Promise.all([
-      this._uploadReport(JSON.stringify(this._report), response.result.report_upload_url, options?.syncCompression ?? false),
-      ...this._attachments.map((attachment) => {
-        const uploadURL = response.result.attachment_upload_urls[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 URL2(response2?.result.report_url, this._options.flakinessEndpoint).toString() : void 0;
-    return { success: true, reportUrl: url };
-  }
-  async _uploadReport(data, uploadUrl, syncCompression) {
-    const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
-    const headers = {
-      "Content-Type": "application/json",
-      "Content-Length": Buffer.byteLength(compressed) + "",
-      "Content-Encoding": "br"
-    };
-    await retryWithBackoff(async () => {
-      const { request, responseDataPromise } = httpUtils.createRequest({
-        url: uploadUrl,
-        headers,
-        method: "put"
-      });
-      request.write(compressed);
-      request.end();
-      await responseDataPromise;
-    }, HTTP_BACKOFF);
-  }
-  async _uploadAttachment(attachment, uploadUrl, syncCompression) {
-    const mimeType = attachment.contentType.toLocaleLowerCase().trim();
-    const compressable = mimeType.startsWith("text/") || mimeType.endsWith("+json") || mimeType.endsWith("+text") || mimeType.endsWith("+xml");
-    if (!compressable && attachment.path) {
-      const attachmentPath = attachment.path;
-      await retryWithBackoff(async () => {
-        const { request, responseDataPromise } = httpUtils.createRequest({
-          url: uploadUrl,
-          headers: {
-            "Content-Type": attachment.contentType,
-            "Content-Length": (await fs3.promises.stat(attachmentPath)).size + ""
-          },
-          method: "put"
-        });
-        fs3.createReadStream(attachmentPath).pipe(request);
-        await responseDataPromise;
-      }, HTTP_BACKOFF);
-      return;
-    }
-    let buffer = attachment.body ? attachment.body : attachment.path ? await fs3.promises.readFile(attachment.path) : void 0;
-    assert2(buffer);
-    const encoding = compressable ? "br" : void 0;
-    if (compressable)
-      buffer = syncCompression ? compressTextSync(buffer) : await compressTextAsync(buffer);
-    const headers = {
-      "Content-Type": attachment.contentType,
-      "Content-Length": Buffer.byteLength(buffer) + "",
-      "Content-Encoding": encoding
-    };
-    await retryWithBackoff(async () => {
-      const { request, responseDataPromise } = httpUtils.createRequest({
-        url: uploadUrl,
-        headers,
-        method: "put"
-      });
-      request.write(buffer);
-      request.end();
-      await responseDataPromise;
-    }, HTTP_BACKOFF);
-  }
-};
-
-// src/showReport.ts
-import chalk from "chalk";
-import open from "open";
-import path4 from "path";
-
-// src/flakinessProjectConfig.ts
-import fs4 from "fs";
-import path2 from "path";
-function createConfigPath(dir) {
-  return path2.join(dir, ".flakiness", "config.json");
-}
-var gConfigPath;
-function ensureConfigPath() {
-  if (!gConfigPath)
-    gConfigPath = computeConfigPath();
-  return gConfigPath;
-}
-function computeConfigPath() {
-  for (let p = process.cwd(); p !== path2.resolve(p, ".."); p = path2.resolve(p, "..")) {
-    const configPath = createConfigPath(p);
-    if (fs4.existsSync(configPath))
-      return configPath;
+function computeConfigPath() {
+  for (let p = process.cwd(); p !== path.resolve(p, ".."); p = path.resolve(p, "..")) {
+    const configPath = createConfigPath(p);
+    if (fs.existsSync(configPath))
+      return configPath;
   }
   try {
     const gitRoot = computeGitRoot(process.cwd());
@@ -527,7 +125,7 @@ var FlakinessProjectConfig = class _FlakinessProjectConfig {
   }
   static async load() {
     const configPath = ensureConfigPath();
-    const data = await fs4.promises.readFile(configPath, "utf-8").catch((e) => void 0);
+    const data = await fs.promises.readFile(configPath, "utf-8").catch((e) => void 0);
     const json = data ? JSON.parse(data) : {};
     return new _FlakinessProjectConfig(configPath, json);
   }
@@ -547,31 +145,33 @@ var FlakinessProjectConfig = class _FlakinessProjectConfig {
     this._config.projectPublicId = projectId;
   }
   async save() {
-    await fs4.promises.mkdir(path2.dirname(this._configPath), { recursive: true });
-    await fs4.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
+    await fs.promises.mkdir(path.dirname(this._configPath), { recursive: true });
+    await fs.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
   }
 };
 
 // src/localReportServer.ts
-import { TypedHTTP as TypedHTTP3 } from "@flakiness/shared/common/typedHttp.js";
+import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
 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 as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
-import fs5 from "fs";
-import path3 from "path";
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+import fs2 from "fs";
+import path2 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 = "|~|";
@@ -607,11 +207,131 @@ 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/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((t2) => t2.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 = {}));
+
 // src/localReportApi.ts
 var ReportInfo = class {
   constructor(_options) {
@@ -621,7 +341,7 @@ var ReportInfo = class {
   attachmentIdToPath = /* @__PURE__ */ new Map();
   commits = [];
   async refresh() {
-    const report = await fs5.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
+    const report = await fs2.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
     if (!report) {
       this.report = void 0;
       this.commits = [];
@@ -631,7 +351,7 @@ var ReportInfo = class {
     if (JSON.stringify(report) === JSON.stringify(this.report))
       return;
     this.report = report;
-    this.commits = await listLocalCommits(path3.dirname(this._options.reportPath), report.commitId, 100);
+    this.commits = await listLocalCommits(path2.dirname(this._options.reportPath), report.commitId, 100);
     const attachmentsDir = this._options.attachmentsFolder;
     const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
     if (missingAttachments.length) {
@@ -644,7 +364,7 @@ var ReportInfo = class {
     this.attachmentIdToPath = attachmentIdToPath;
   }
 };
-var t = TypedHTTP2.Router.create();
+var t = TypedHTTP.Router.create();
 var localReportRouter = {
   ping: t.get({
     handler: async () => {
@@ -655,125 +375,513 @@ var localReportRouter = {
     handler: async ({ ctx }) => {
       return ctx.reportInfo.commits;
     }
-  }),
-  report: {
-    attachment: t.rawMethod("GET", {
-      input: z.object({
-        attachmentId: z.string().min(1).max(100).transform((id) => id)
-      }),
-      handler: async ({ ctx, input }) => {
-        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
-        if (!idx)
-          throw TypedHTTP2.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs5.promises.readFile(idx.path);
-        return TypedHTTP2.ok(buffer, idx.contentType);
-      }
-    }),
-    json: t.get({
-      handler: async ({ ctx }) => {
-        await ctx.reportInfo.refresh();
-        return ctx.reportInfo.report;
-      }
-    })
+  }),
+  report: {
+    attachment: t.rawMethod("GET", {
+      input: z.object({
+        attachmentId: z.string().min(1).max(100).transform((id) => id)
+      }),
+      handler: async ({ ctx, input }) => {
+        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
+        if (!idx)
+          throw TypedHTTP.HttpError.withCode("NOT_FOUND");
+        const buffer = await fs2.promises.readFile(idx.path);
+        return TypedHTTP.ok(buffer, idx.contentType);
+      }
+    }),
+    json: t.get({
+      handler: async ({ ctx }) => {
+        await ctx.reportInfo.refresh();
+        return ctx.reportInfo.report;
+      }
+    })
+  }
+};
+async function resolveAttachmentPaths(report, attachmentsDir) {
+  const attachmentFiles = await listFilesRecursively(attachmentsDir);
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path2.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 fs2.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory())
+      await listFilesRecursively(fullPath, result);
+    else
+      result.push(fullPath);
+  }
+  return result;
+}
+
+// src/localReportServer.ts
+var logHTTPServer = debug2("fk:http");
+var LocalReportServer = class _LocalReportServer {
+  constructor(_server, _port, _authToken) {
+    this._server = _server;
+    this._port = _port;
+    this._authToken = _authToken;
+  }
+  static async create(options) {
+    const app = express();
+    app.set("etag", false);
+    const authToken = randomUUIDBase62();
+    app.use(compression());
+    app.use(bodyParser.json({ limit: 256 * 1024 }));
+    app.use((req, res, next) => {
+      if (!req.path.startsWith("/" + authToken))
+        throw TypedHTTP2.HttpError.withCode("UNAUTHORIZED");
+      res.setHeader("Access-Control-Allow-Headers", "*");
+      res.setHeader("Access-Control-Allow-Origin", options.endpoint);
+      res.setHeader("Access-Control-Allow-Methods", "*");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      req.on("aborted", () => logHTTPServer(`REQ ABORTED ${req.method} ${req.originalUrl}`));
+      res.on("close", () => {
+        if (!res.headersSent) logHTTPServer(`RES CLOSED BEFORE SEND ${req.method} ${req.originalUrl}`);
+      });
+      next();
+    });
+    const reportInfo = new ReportInfo(options);
+    app.use("/" + authToken, createTypedHttpExpressMiddleware({
+      router: localReportRouter,
+      createRootContext: async ({ req, res, input }) => ({ reportInfo })
+    }));
+    app.use((err, req, res, next) => {
+      if (err instanceof TypedHTTP2.HttpError)
+        return res.status(err.status).send({ error: err.message });
+      logHTTPServer(err);
+      res.status(500).send({ error: "Internal Server Error" });
+    });
+    const server = http.createServer(app);
+    server.on("error", (err) => {
+      if (err.code === "ECONNRESET") {
+        logHTTPServer("Client connection reset. Ignoring.");
+        return;
+      }
+      throw err;
+    });
+    const port = await new Promise((resolve) => server.listen(options.port, () => {
+      resolve(server.address().port);
+    }));
+    return new _LocalReportServer(server, port, authToken);
+  }
+  authToken() {
+    return this._authToken;
+  }
+  port() {
+    return this._port;
+  }
+  async dispose() {
+    await new Promise((x) => this._server.close(x));
+  }
+};
+
+// src/index.ts
+import { FlakinessReport } from "@flakiness/flakiness-report";
+
+// src/createEnvironment.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import fs3 from "fs";
+import os from "os";
+function shell2(command, args, options) {
+  try {
+    const result = spawnSync2(command, args, { encoding: "utf-8", ...options });
+    if (result.status !== 0) {
+      return void 0;
+    }
+    return result.stdout.trim();
+  } catch (e) {
+    console.error(e);
+    return void 0;
+  }
+}
+function readLinuxOSRelease() {
+  const osReleaseText = fs3.readFileSync("/etc/os-release", "utf-8");
+  return new Map(osReleaseText.toLowerCase().split("\n").filter((line) => line.includes("=")).map((line) => {
+    line = line.trim();
+    let [key, value] = line.split("=");
+    if (value.startsWith('"') && value.endsWith('"'))
+      value = value.substring(1, value.length - 1);
+    return [key, value];
+  }));
+}
+function osLinuxInfo() {
+  const arch = shell2(`uname`, [`-m`]);
+  const osReleaseMap = readLinuxOSRelease();
+  const name = osReleaseMap.get("name") ?? shell2(`uname`);
+  const version = osReleaseMap.get("version_id");
+  return { name, arch, version };
+}
+function osDarwinInfo() {
+  const name = "macos";
+  const arch = shell2(`uname`, [`-m`]);
+  const version = shell2(`sw_vers`, [`-productVersion`]);
+  return { name, arch, version };
+}
+function osWinInfo() {
+  const name = "win";
+  const arch = process.arch;
+  const version = os.release();
+  return { name, arch, version };
+}
+function getOSInfo() {
+  if (process.platform === "darwin")
+    return osDarwinInfo();
+  if (process.platform === "win32")
+    return osWinInfo();
+  return osLinuxInfo();
+}
+function extractEnvConfiguration() {
+  const ENV_PREFIX = "FK_ENV_";
+  return Object.fromEntries(
+    Object.entries(process.env).filter(([key]) => key.toUpperCase().startsWith(ENV_PREFIX.toUpperCase())).map(([key, value]) => [key.substring(ENV_PREFIX.length).toLowerCase(), (value ?? "").trim().toLowerCase()])
+  );
+}
+function createEnvironment(options) {
+  const osInfo = getOSInfo();
+  return {
+    name: options.name,
+    systemData: {
+      osArch: osInfo.arch,
+      osName: osInfo.name,
+      osVersion: osInfo.version
+    },
+    userSuppliedData: {
+      ...extractEnvConfiguration(),
+      ...options.userSuppliedData ?? {}
+    },
+    opaqueData: options.opaqueData
+  };
+}
+
+// src/createTestStepSnippets.ts
+import { codeFrameColumns } from "@babel/code-frame";
+import fs4 from "fs";
+import { posix as posixPath2 } from "path";
+function createTestStepSnippetsInplace(report, gitRoot) {
+  const allSteps = /* @__PURE__ */ new Map();
+  ReportUtils.visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const step of attempt.steps ?? []) {
+        if (!step.location)
+          continue;
+        let fileSteps = allSteps.get(step.location.file);
+        if (!fileSteps) {
+          fileSteps = /* @__PURE__ */ new Set();
+          allSteps.set(step.location.file, fileSteps);
+        }
+        fileSteps.add(step);
+      }
+    }
+  });
+  for (const [gitFilePath2, steps] of allSteps) {
+    let source;
+    try {
+      source = fs4.readFileSync(posixPath2.join(gitRoot, gitFilePath2), "utf-8");
+    } catch (e) {
+      continue;
+    }
+    const lines = source.split("\n").length;
+    const highlighted = codeFrameColumns(source, { start: { line: lines, column: 1 } }, { highlightCode: true, linesAbove: lines, linesBelow: 0 });
+    const highlightedLines = highlighted.split("\n");
+    const lineWithArrow = highlightedLines[highlightedLines.length - 1];
+    for (const step of steps) {
+      if (!step.location)
+        continue;
+      if (step.location.line < 2 || step.location.line >= lines)
+        continue;
+      const snippetLines = highlightedLines.slice(step.location.line - 2, step.location.line + 1);
+      const index = lineWithArrow.indexOf("^");
+      const shiftedArrow = lineWithArrow.slice(0, index) + " ".repeat(step.location.column - 1) + lineWithArrow.slice(index);
+      snippetLines.splice(2, 0, shiftedArrow);
+      step.snippet = snippetLines.join("\n");
+    }
+  }
+}
+
+// src/reportUploader.ts
+import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
+import assert2 from "assert";
+import crypto from "crypto";
+import fs5 from "fs";
+import { URL as URL2 } from "url";
+
+// src/httpUtils.ts
+import http2 from "http";
+import https from "https";
+var FLAKINESS_DBG2 = !!process.env.FLAKINESS_DBG;
+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 : http2;
+    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}`));
+      });
+      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) + ""
+    };
+    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"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+
+// src/reportUploader.ts
+function sha1File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    const stream = fs5.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"];
+    if (!flakinessAccessToken)
+      return void 0;
+    const flakinessEndpoint = overrides?.flakinessEndpoint ?? process.env["FLAKINESS_ENDPOINT"] ?? "https://flakiness.io";
+    return { flakinessAccessToken, flakinessEndpoint };
+  }
+  static async upload(options) {
+    const uploaderOptions = _ReportUploader.optionsFromEnv(options);
+    if (!uploaderOptions) {
+      if (process.env.CI)
+        options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
+      return void 0;
+    }
+    const uploader = new _ReportUploader(uploaderOptions);
+    const upload = uploader.createUpload(options.report, options.attachments);
+    const uploadResult = await upload.upload();
+    if (!uploadResult.success) {
+      options.log?.(`[flakiness.io] X Failed to upload to ${uploaderOptions.flakinessEndpoint}: ${uploadResult.message}`);
+      return { errorMessage: uploadResult.message };
+    }
+    options.log?.(`[flakiness.io] \u2713 Report uploaded ${uploadResult.message ?? ""}`);
+    if (uploadResult.reportUrl)
+      options.log?.(`[flakiness.io] ${uploadResult.reportUrl}`);
+  }
+  _options;
+  constructor(options) {
+    this._options = options;
+  }
+  createUpload(report, attachments) {
+    const upload = new ReportUpload(this._options, report, attachments);
+    return upload;
   }
 };
-
-// src/localReportServer.ts
-var logHTTPServer = debug("fk:http");
-var LocalReportServer = class _LocalReportServer {
-  constructor(_server, _port, _authToken) {
-    this._server = _server;
-    this._port = _port;
-    this._authToken = _authToken;
+var HTTP_BACKOFF = [100, 500, 1e3, 1e3, 1e3, 1e3];
+var ReportUpload = class {
+  _report;
+  _attachments;
+  _options;
+  constructor(options, report, attachments) {
+    this._options = options;
+    this._report = report;
+    this._attachments = attachments;
   }
-  static async create(options) {
-    const app = express();
-    app.set("etag", false);
-    const authToken = randomUUIDBase62();
-    app.use(compression());
-    app.use(bodyParser.json({ limit: 256 * 1024 }));
-    app.use((req, res, next) => {
-      if (!req.path.startsWith("/" + authToken))
-        throw TypedHTTP3.HttpError.withCode("UNAUTHORIZED");
-      res.setHeader("Access-Control-Allow-Headers", "*");
-      res.setHeader("Access-Control-Allow-Origin", options.endpoint);
-      res.setHeader("Access-Control-Allow-Methods", "*");
-      if (req.method === "OPTIONS") {
-        res.writeHead(204);
-        res.end();
-        return;
-      }
-      req.on("aborted", () => logHTTPServer(`REQ ABORTED ${req.method} ${req.originalUrl}`));
-      res.on("close", () => {
-        if (!res.headersSent) logHTTPServer(`RES CLOSED BEFORE SEND ${req.method} ${req.originalUrl}`);
-      });
-      next();
-    });
-    const reportInfo = new ReportInfo(options);
-    app.use("/" + authToken, createTypedHttpExpressMiddleware({
-      router: localReportRouter,
-      createRootContext: async ({ req, res, input }) => ({ reportInfo })
-    }));
-    app.use((err2, req, res, next) => {
-      if (err2 instanceof TypedHTTP3.HttpError)
-        return res.status(err2.status).send({ error: err2.message });
-      logHTTPServer(err2);
-      res.status(500).send({ error: "Internal Server Error" });
-    });
-    const server = http2.createServer(app);
-    server.on("error", (err2) => {
-      if (err2.code === "ECONNRESET") {
-        logHTTPServer("Client connection reset. Ignoring.");
-        return;
-      }
-      throw err2;
-    });
-    const port = await new Promise((resolve) => server.listen(options.port, () => {
-      resolve(server.address().port);
+  async _api(pathname, token, body) {
+    const url = new URL2(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
     }));
-    return new _LocalReportServer(server, port, authToken);
   }
-  authToken() {
-    return this._authToken;
+  async upload(options) {
+    const response = await this._api("/api/upload/start", this._options.flakinessAccessToken);
+    if (response?.error || !response.result)
+      return { success: false, message: response.error };
+    const webUrl = new URL2(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.presignedReportUrl, options?.syncCompression ?? false),
+      ...this._attachments.map((attachment) => {
+        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);
+      })
+    ]);
+    await this._api("/api/upload/finish", response.result.uploadToken);
+    return { success: true, reportUrl: webUrl };
   }
-  port() {
-    return this._port;
+  async _uploadReport(data, uploadUrl, syncCompression) {
+    const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(compressed) + "",
+      "Content-Encoding": "br"
+    };
+    await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = httpUtils.createRequest({
+        url: uploadUrl,
+        headers,
+        method: "put"
+      });
+      request.write(compressed);
+      request.end();
+      await responseDataPromise;
+    }, HTTP_BACKOFF);
   }
-  async dispose() {
-    await new Promise((x) => this._server.close(x));
+  async _uploadAttachment(attachment, uploadUrl, syncCompression) {
+    const mimeType = attachment.contentType.toLocaleLowerCase().trim();
+    const compressable = mimeType.startsWith("text/") || mimeType.endsWith("+json") || mimeType.endsWith("+text") || mimeType.endsWith("+xml");
+    if (!compressable && attachment.path) {
+      const attachmentPath = attachment.path;
+      await retryWithBackoff(async () => {
+        const { request, responseDataPromise } = httpUtils.createRequest({
+          url: uploadUrl,
+          headers: {
+            "Content-Type": attachment.contentType,
+            "Content-Length": (await fs5.promises.stat(attachmentPath)).size + ""
+          },
+          method: "put"
+        });
+        fs5.createReadStream(attachmentPath).pipe(request);
+        await responseDataPromise;
+      }, HTTP_BACKOFF);
+      return;
+    }
+    let buffer = attachment.body ? attachment.body : attachment.path ? await fs5.promises.readFile(attachment.path) : void 0;
+    assert2(buffer);
+    const encoding = compressable ? "br" : void 0;
+    if (compressable)
+      buffer = syncCompression ? compressTextSync(buffer) : await compressTextAsync(buffer);
+    const headers = {
+      "Content-Type": attachment.contentType,
+      "Content-Length": Buffer.byteLength(buffer) + "",
+      "Content-Encoding": encoding
+    };
+    await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = httpUtils.createRequest({
+        url: uploadUrl,
+        headers,
+        method: "put"
+      });
+      request.write(buffer);
+      request.end();
+      await responseDataPromise;
+    }, HTTP_BACKOFF);
   }
 };
 
-// src/showReport.ts
-async function showReport(reportFolder) {
-  const reportPath = path4.join(reportFolder, "report.json");
-  const config = await FlakinessProjectConfig.load();
-  const projectPublicId = config.projectPublicId();
-  const reportViewerEndpoint = config.reportViewerEndpoint();
-  const server = await LocalReportServer.create({
-    endpoint: reportViewerEndpoint,
-    port: 9373,
-    reportPath,
-    attachmentsFolder: reportFolder
-  });
-  const url = new URL(reportViewerEndpoint);
-  url.searchParams.set("port", String(server.port()));
-  url.searchParams.set("token", server.authToken());
-  if (projectPublicId)
-    url.searchParams.set("ppid", projectPublicId);
-  console.log(chalk.cyan(`
-  Serving Flakiness report at ${url.toString()}
-  Press Ctrl+C to quit.`));
-  await open(url.toString());
-  await new Promise(() => {
-  });
-}
-
 // src/systemUtilizationSampler.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import os2 from "os";
 function getAvailableMemMacOS() {
-  const lines = spawnSync2("vm_stat", { encoding: "utf8" }).stdout.trim().split("\n");
+  const lines = spawnSync3("vm_stat", { encoding: "utf8" }).stdout.trim().split("\n");
   const pageSize = parseInt(lines[0].match(/page size of (\d+) bytes/)[1], 10);
   if (isNaN(pageSize)) {
     console.warn("[flakiness.io] Error detecting macos page size");
@@ -837,250 +945,74 @@ var SystemUtilizationSampler = class {
   }
 };
 
-// src/playwright-test.ts
-var warn = (txt) => console.warn(chalk2.yellow(`[flakiness.io] ${txt}`));
-var err = (txt) => console.error(chalk2.red(`[flakiness.io] ${txt}`));
-var FlakinessReporter = class {
-  constructor(_options = {}) {
-    this._options = _options;
-    this._outputFolder = path5.join(process.cwd(), this._options.outputFolder ?? process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report");
-  }
-  _config;
-  _rootSuite;
-  _results = new Multimap();
-  _unattributedErrors = [];
-  _filepathToSteps = new Multimap();
-  _systemUtilizationSampler = new SystemUtilizationSampler();
-  _report;
-  _attachments = [];
-  _outputFolder;
-  _result;
-  printsToStdio() {
-    return false;
-  }
-  onBegin(config, suite) {
-    this._config = config;
-    this._rootSuite = suite;
-  }
-  onError(error) {
-    this._unattributedErrors.push(error);
-  }
-  onTestBegin(test) {
-  }
-  onTestEnd(test, result) {
-    this._results.set(test, result);
-  }
-  async _toFKSuites(context, pwSuite) {
-    const location = pwSuite.location;
-    if (pwSuite.type === "root" || pwSuite.type === "project" || !location)
-      return (await Promise.all(pwSuite.suites.map((suite) => this._toFKSuites(context, suite)))).flat();
-    let type = "suite";
-    if (pwSuite.type === "file")
-      type = "file";
-    else if (pwSuite.type === "describe" && !pwSuite.title)
-      type = "anonymous suite";
-    return [{
-      type,
-      title: pwSuite.title,
-      location: this._createLocation(context, location),
-      suites: (await Promise.all(pwSuite.suites.map((suite) => this._toFKSuites(context, suite)))).flat(),
-      tests: await Promise.all(pwSuite.tests.map((test) => this._toFKTest(context, test)))
-    }];
-  }
-  async _toFKTest(context, pwTest) {
-    return {
-      title: pwTest.title,
-      // Playwright Test tags must start with '@' so we cut it off.
-      tags: pwTest.tags.map((tag) => tag.startsWith("@") ? tag.substring(1) : tag),
-      location: this._createLocation(context, pwTest.location),
-      // de-duplication of tests will happen later, so here we will have all attempts.
-      attempts: await Promise.all(this._results.getAll(pwTest).map((result) => this._toFKRunAttempt(context, pwTest, result)))
-    };
-  }
-  async _toFKRunAttempt(context, pwTest, result) {
-    const attachments = [];
-    const attempt = {
-      timeout: parseDurationMS(pwTest.timeout),
-      annotations: pwTest.annotations.map((annotation) => ({
-        type: annotation.type,
-        description: annotation.description,
-        location: annotation.location ? this._createLocation(context, annotation.location) : void 0
-      })),
-      environmentIdx: context.project2environmentIdx.get(pwTest.parent.project()),
-      expectedStatus: pwTest.expectedStatus,
-      parallelIndex: result.parallelIndex,
-      status: result.status,
-      errors: result.errors && result.errors.length ? result.errors.map((error) => this._toFKTestError(context, error)) : void 0,
-      stdout: result.stdout ? result.stdout.map(toSTDIOEntry) : void 0,
-      stderr: result.stderr ? result.stderr.map(toSTDIOEntry) : void 0,
-      steps: result.steps ? result.steps.map((jsonTestStep) => this._toFKTestStep(context, jsonTestStep)) : void 0,
-      startTimestamp: +result.startTime,
-      duration: +result.duration,
-      attachments
-    };
-    await Promise.all((result.attachments ?? []).map(async (jsonAttachment) => {
-      if (jsonAttachment.path && !await existsAsync(jsonAttachment.path)) {
-        context.unaccessibleAttachmentPaths.push(jsonAttachment.path);
-        return;
-      }
-      const id = jsonAttachment.path ? await sha1File(jsonAttachment.path) : sha1Buffer(jsonAttachment.body ?? "");
-      context.attachments.set(id, {
-        contentType: jsonAttachment.contentType,
-        id,
-        body: jsonAttachment.body,
-        path: jsonAttachment.path
-      });
-      attachments.push({
-        id,
-        name: jsonAttachment.name,
-        contentType: jsonAttachment.contentType
-      });
-    }));
-    return attempt;
-  }
-  _toFKTestStep(context, pwStep) {
-    const step = {
-      // NOTE: jsonStep.duration was -1 in some playwright versions
-      duration: parseDurationMS(Math.max(pwStep.duration, 0)),
-      title: pwStep.title,
-      location: pwStep.location ? this._createLocation(context, pwStep.location) : void 0
-    };
-    if (pwStep.location) {
-      const resolvedPath = path5.resolve(pwStep.location.file);
-      this._filepathToSteps.set(resolvedPath, step);
-    }
-    if (pwStep.error)
-      step.error = this._toFKTestError(context, pwStep.error);
-    if (pwStep.steps)
-      step.steps = pwStep.steps.map((childJSONStep) => this._toFKTestStep(context, childJSONStep));
-    return step;
-  }
-  _createLocation(context, pwLocation) {
-    return {
-      file: gitFilePath(context.gitRoot, normalizePath(pwLocation.file)),
-      line: pwLocation.line,
-      column: pwLocation.column
-    };
-  }
-  _toFKTestError(context, pwError) {
-    return {
-      location: pwError.location ? this._createLocation(context, pwError.location) : void 0,
-      message: stripAnsi(pwError.message ?? "").split("\n")[0],
-      snippet: pwError.snippet,
-      stack: pwError.stack,
-      value: pwError.value
-    };
-  }
-  async onEnd(result) {
-    this._systemUtilizationSampler.dispose();
-    if (!this._config || !this._rootSuite)
-      throw new Error("ERROR: failed to resolve config");
-    let commitId;
-    try {
-      commitId = gitCommitInfo(this._config.rootDir);
-    } catch (e) {
-      warn(`Failed to fetch commit info - is this a git repo?`);
-      err(`Report is NOT generated.`);
-      return;
-    }
-    const gitRoot = normalizePath(computeGitRoot(this._config.rootDir));
-    const configPath = this._config.configFile ? gitFilePath(gitRoot, normalizePath(this._config.configFile)) : void 0;
-    const context = {
-      project2environmentIdx: /* @__PURE__ */ new Map(),
-      testBaseDir: normalizePath(this._config.rootDir),
-      gitRoot,
-      attachments: /* @__PURE__ */ new Map(),
-      unaccessibleAttachmentPaths: []
-    };
-    const environmentsMap = createEnvironments(this._config.projects);
-    if (this._options.collectBrowserVersions) {
-      try {
-        let playwrightPath = fs6.realpathSync(process.argv[1]);
-        while (path5.basename(playwrightPath) !== "test")
-          playwrightPath = path5.dirname(playwrightPath);
-        const module = await import(path5.join(playwrightPath, "index.js"));
-        for (const [project, env] of environmentsMap) {
-          const { browserName = "chromium", channel, headless } = project.use;
-          let browserType;
-          switch (browserName) {
-            case "chromium":
-              browserType = module.default.chromium;
-              break;
-            case "firefox":
-              browserType = module.default.firefox;
-              break;
-            case "webkit":
-              browserType = module.default.webkit;
-              break;
-            default:
-              throw new Error(`Unsupported browser: ${browserName}`);
-          }
-          const browser = await browserType.launch({ channel, headless });
-          const version = browser.version();
-          await browser.close();
-          env.userSuppliedData ??= {};
-          env.userSuppliedData["browser"] = (channel ?? browserName).toLowerCase().trim() + " " + version;
-        }
-      } catch (e) {
-        err(`Failed to resolve browser version: ${e}`);
-      }
-    }
-    const environments = [...environmentsMap.values()];
-    for (let envIdx = 0; envIdx < environments.length; ++envIdx)
-      context.project2environmentIdx.set(this._config.projects[envIdx], envIdx);
-    const relatedCommitIds = this._options.relatedCommitIds;
-    const report = ReportUtils2.dedupeSuitesTestsEnvironments({
-      category: "playwright",
-      commitId,
-      relatedCommitIds,
-      systemUtilization: this._systemUtilizationSampler.result,
-      configPath,
-      url: inferRunUrl(),
-      environments,
-      suites: await this._toFKSuites(context, this._rootSuite),
-      opaqueData: this._config,
-      unattributedErrors: this._unattributedErrors.map((e) => this._toFKTestError(context, e)),
-      duration: parseDurationMS(result.duration),
-      startTimestamp: +result.startTime
-    });
-    createTestStepSnippets(this._filepathToSteps);
-    for (const unaccessibleAttachment of context.unaccessibleAttachmentPaths)
-      warn(`cannot access attachment ${unaccessibleAttachment}`);
-    this._report = report;
-    this._attachments = await saveReportAndAttachments(report, Array.from(context.attachments.values()), this._outputFolder);
-    this._result = result;
-  }
-  async onExit() {
-    if (!this._report)
-      return;
-    await ReportUploader.upload({
-      report: this._report,
-      attachments: this._attachments,
-      flakinessAccessToken: this._options.token,
-      flakinessEndpoint: this._options.endpoint,
-      log: console.log
+// src/index.ts
+function inferRunUrl() {
+  if (process.env.GITHUB_REPOSITORY && process.env.GITHUB_RUN_ID)
+    return `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+  return void 0;
+}
+async function showReport(reportFolder) {
+  const reportPath = path3.join(reportFolder, "report.json");
+  const config = await FlakinessProjectConfig.load();
+  const projectPublicId = config.projectPublicId();
+  const reportViewerEndpoint = config.reportViewerEndpoint();
+  const server = await LocalReportServer.create({
+    endpoint: reportViewerEndpoint,
+    port: 9373,
+    reportPath,
+    attachmentsFolder: reportFolder
+  });
+  const url = new URL(reportViewerEndpoint);
+  url.searchParams.set("port", String(server.port()));
+  url.searchParams.set("token", server.authToken());
+  if (projectPublicId)
+    url.searchParams.set("ppid", projectPublicId);
+  console.log(chalk.cyan(`
+  Serving Flakiness report at ${url.toString()}
+  Press Ctrl+C to quit.`));
+  await open(url.toString());
+  await new Promise(() => {
+  });
+}
+async function saveReport(report, attachments, outputFolder) {
+  const reportPath = path3.join(outputFolder, "report.json");
+  const attachmentsFolder = path3.join(outputFolder, "attachments");
+  await fs6.promises.rm(outputFolder, { recursive: true, force: true });
+  await fs6.promises.mkdir(outputFolder, { recursive: true });
+  await fs6.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+  if (attachments.length)
+    await fs6.promises.mkdir(attachmentsFolder);
+  const movedAttachments = [];
+  for (const attachment of attachments) {
+    const attachmentPath = path3.join(attachmentsFolder, attachment.id);
+    if (attachment.path)
+      await fs6.promises.cp(attachment.path, attachmentPath);
+    else if (attachment.body)
+      await fs6.promises.writeFile(attachmentPath, attachment.body);
+    movedAttachments.push({
+      contentType: attachment.contentType,
+      id: attachment.id,
+      path: attachmentPath
     });
-    const openMode = this._options.open ?? "on-failure";
-    const shouldOpen = process.stdin.isTTY && !process.env.CI && (openMode === "always" || openMode === "on-failure" && this._result?.status === "failed");
-    if (shouldOpen) {
-      await showReport(this._outputFolder);
-    } else {
-      const defaultOutputFolder = path5.join(process.cwd(), "flakiness-report");
-      const folder = defaultOutputFolder === this._outputFolder ? "" : path5.relative(process.cwd(), this._outputFolder);
-      console.log(`
-To open last Flakiness report, install Flakiness CLI tool and run:
-
-  ${chalk2.cyan(`flakiness show ${folder}`)}
-      `);
-    }
   }
-};
-function toSTDIOEntry(data) {
-  if (Buffer.isBuffer(data))
-    return { buffer: data.toString("base64") };
-  return { text: data };
+  return movedAttachments;
 }
 export {
-  FlakinessReporter as default
+  FlakinessProjectConfig,
+  FlakinessReport,
+  ReportUploader,
+  ReportUtils,
+  SystemUtilizationSampler,
+  computeGitRoot,
+  createDataAttachment,
+  createEnvironment,
+  createFileAttachment,
+  createTestStepSnippetsInplace,
+  gitCommitInfo,
+  inferRunUrl,
+  pathutils_exports as pathutils,
+  saveReport,
+  showReport,
+  stripAnsi
 };
-//# sourceMappingURL=playwright-test.js.map
+//# sourceMappingURL=index.js.map