patchright-bun 1.58.2 → 1.59.0

package/lib/reporters/html.js

@@ -40,7 +40,6 @@ var import_utils = require("patchright-bun-core/lib/utils");
 var import_utils2 = require("patchright-bun-core/lib/utils");
 var import_utilsBundle = require("patchright-bun-core/lib/utilsBundle");
 var import_utilsBundle2 = require("patchright-bun-core/lib/utilsBundle");
-var import_zipBundle = require("patchright-bun-core/lib/zipBundle");
 var import_base = require("./base");
 var import_babelBundle = require("../transform/babelBundle");
 var import_util = require("../util");
@@ -51,6 +50,7 @@ const isHtmlReportOption = (type) => {
 class HtmlReporter {
   constructor(options) {
     this._topLevelErrors = [];
+    this._reportConfigs = /* @__PURE__ */ new Map();
     this._machines = [];
     this._options = options;
   }
@@ -105,25 +105,22 @@ class HtmlReporter {
   onError(error) {
     this._topLevelErrors.push(error);
   }
-  onMachineEnd(result) {
-    this._machines.push(result);
+  onReportConfigure(params) {
+    this._reportConfigs.set(params.reportPath, params.config);
+  }
+  onReportEnd(params) {
+    const config = this._reportConfigs.get(params.reportPath);
+    if (config)
+      this._machines.push({ config, result: params.result, reportPath: params.reportPath });
   }
   async onEnd(result) {
     const projectSuites = this.suite.suites;
     await (0, import_utils.removeFolders)([this._outputFolder]);
-    let noSnippets;
-    if (process.env.PLAYWRIGHT_HTML_NO_SNIPPETS === "false" || process.env.PLAYWRIGHT_HTML_NO_SNIPPETS === "0")
-      noSnippets = false;
-    else if (process.env.PLAYWRIGHT_HTML_NO_SNIPPETS)
-      noSnippets = true;
-    noSnippets = noSnippets || this._options.noSnippets;
-    let noCopyPrompt;
-    if (process.env.PLAYWRIGHT_HTML_NO_COPY_PROMPT === "false" || process.env.PLAYWRIGHT_HTML_NO_COPY_PROMPT === "0")
-      noCopyPrompt = false;
-    else if (process.env.PLAYWRIGHT_HTML_NO_COPY_PROMPT)
-      noCopyPrompt = true;
-    noCopyPrompt = noCopyPrompt || this._options.noCopyPrompt;
-    const builder = new HtmlBuilder(this.config, this._outputFolder, this._attachmentsBaseURL, {
+    const noSnippets = parseBooleanEnvVar("PLAYWRIGHT_HTML_NO_SNIPPETS") ?? this._options.noSnippets;
+    const noCopyPrompt = parseBooleanEnvVar("PLAYWRIGHT_HTML_NO_COPY_PROMPT") ?? this._options.noCopyPrompt;
+    const doNotInlineAssets = parseBooleanEnvVar("PLAYWRIGHT_HTML_DO_NOT_INLINE_ASSETS") ?? this._options.doNotInlineAssets ?? false;
+    const { yazl } = await import("playwright-core/lib/zipBundle");
+    const builder = new HtmlBuilder(yazl, this.config, this._outputFolder, this._attachmentsBaseURL, doNotInlineAssets, {
       title: process.env.PLAYWRIGHT_HTML_TITLE || this._options.title,
       noSnippets,
       noCopyPrompt
@@ -134,7 +131,8 @@ class HtmlReporter {
     if (process.env.CI || !this._buildResult)
       return;
     const { ok, singleTestId } = this._buildResult;
-    const shouldOpen = !!process.stdin.isTTY && (this._open === "always" || !ok && this._open === "on-failure");
+    const isCodingAgent = !!process.env.CLAUDECODE || !!process.env.COPILOT_CLI;
+    const shouldOpen = !isCodingAgent && !!process.stdin.isTTY && (this._open === "always" || !ok && this._open === "on-failure");
     if (shouldOpen) {
       await showHTMLReport(this._outputFolder, this._host, this._port, singleTestId);
     } else if (this._options._mode === "test" && !!process.stdin.isTTY) {
@@ -164,6 +162,14 @@ function getHtmlReportOptionProcessEnv() {
   }
   return htmlOpenEnv;
 }
+function parseBooleanEnvVar(name) {
+  const value = process.env[name];
+  if (value === "false" || value === "0")
+    return false;
+  if (value)
+    return true;
+  return void 0;
+}
 function standaloneDefaultFolder() {
   return reportFolderFromEnv() ?? (0, import_util.resolveReporterOutputPath)("playwright-report", process.cwd(), void 0);
 }
@@ -209,14 +215,15 @@ function startHtmlReportServer(folder) {
   return server;
 }
 class HtmlBuilder {
-  constructor(config, outputDir, attachmentsBaseURL, options) {
+  constructor(yazl, config, outputDir, attachmentsBaseURL, doNotInlineAssets, options) {
     this._stepsInFile = new import_utils.MultiMap();
     this._hasTraces = false;
+    this._dataZipFile = new yazl.ZipFile();
     this._config = config;
     this._reportFolder = outputDir;
     this._options = options;
+    this._doNotInlineAssets = doNotInlineAssets;
     import_fs.default.mkdirSync(this._reportFolder, { recursive: true });
-    this._dataZipFile = new import_zipBundle.yazl.ZipFile();
     this._attachmentsBaseURL = attachmentsBaseURL;
   }
   async build(metadata, projectSuites, result, topLevelErrors, machines) {
@@ -264,11 +271,11 @@ class HtmlBuilder {
       stats: { ...[...data.values()].reduce((a, e) => addStats(a, e.testFileSummary.stats), emptyStats()) },
       errors: topLevelErrors.map((error) => (0, import_base.formatError)(import_base.internalScreen, error).message),
       options: this._options,
-      machines: machines.map((s) => ({
-        duration: s.duration,
-        startTime: s.startTime.getTime(),
-        tag: s.tag,
-        shardIndex: s.shardIndex
+      machines: machines.map((machine) => ({
+        duration: machine.result.duration,
+        startTime: machine.result.startTime.getTime(),
+        tag: machine.config.tags,
+        shardIndex: machine.config.shard?.current
       }))
     };
     htmlReport.files.sort((f1, f2) => {
@@ -282,8 +289,7 @@ class HtmlBuilder {
       const testFile = data.values().next().value.testFile;
       singleTestId = testFile.tests[0].testId;
     }
-    const appFolder = import_path.default.join(require.resolve("patchright-bun-core"), "..", "lib", "vite", "htmlReport");
-    await (0, import_utils.copyFileAndMakeWritable)(import_path.default.join(appFolder, "index.html"), import_path.default.join(this._reportFolder, "index.html"));
+    const reportIndexFile = await this._writeStaticAssets();
     if (this._hasTraces) {
       const traceViewerFolder = import_path.default.join(require.resolve("patchright-bun-core"), "..", "lib", "vite", "traceViewer");
       const traceViewerTargetFolder = import_path.default.join(this._reportFolder, "trace");
@@ -300,17 +306,39 @@ class HtmlBuilder {
         await (0, import_utils.copyFileAndMakeWritable)(import_path.default.join(traceViewerFolder, "assets", file), import_path.default.join(traceViewerAssetsTargetFolder, file));
       }
     }
-    await this._writeReportData(import_path.default.join(this._reportFolder, "index.html"));
+    await this._writeReportData(reportIndexFile);
     return { ok, singleTestId };
   }
+  async _writeStaticAssets() {
+    const appFolder = import_path.default.join(require.resolve("patchright-bun-core"), "..", "lib", "vite", "htmlReport");
+    const reportIndexFile = import_path.default.join(this._reportFolder, "index.html");
+    if (this._doNotInlineAssets) {
+      const html = await import_fs.default.promises.readFile(import_path.default.join(appFolder, "index.html"), "utf-8");
+      await Promise.all([
+        import_fs.default.promises.writeFile(reportIndexFile, html),
+        import_fs.default.promises.copyFile(import_path.default.join(appFolder, "report.js"), import_path.default.join(this._reportFolder, "report.js")),
+        import_fs.default.promises.copyFile(import_path.default.join(appFolder, "report.css"), import_path.default.join(this._reportFolder, "report.css"))
+      ]);
+    } else {
+      let html = await import_fs.default.promises.readFile(import_path.default.join(appFolder, "index.html"), "utf-8");
+      const [js, css] = await Promise.all([
+        import_fs.default.promises.readFile(import_path.default.join(appFolder, "report.js"), "utf-8"),
+        import_fs.default.promises.readFile(import_path.default.join(appFolder, "report.css"), "utf-8")
+      ]);
+      html = html.replace(/<script type="module"[^>]*><\/script>/, () => `<script type="module">${js}</script>`);
+      html = html.replace(/<link rel="stylesheet"[^>]*>/, () => `<style type='text/css'>${css}</style>`);
+      await import_fs.default.promises.writeFile(reportIndexFile, html);
+    }
+    return reportIndexFile;
+  }
   async _writeReportData(filePath) {
-    import_fs.default.appendFileSync(filePath, '<script id="playwrightReportBase64" type="application/zip">data:application/zip;base64,');
+    import_fs.default.appendFileSync(filePath, '<template id="playwrightReportBase64">data:application/zip;base64,');
     await new Promise((f) => {
       this._dataZipFile.end(void 0, () => {
         this._dataZipFile.outputStream.pipe(new Base64Encoder()).pipe(import_fs.default.createWriteStream(filePath, { flags: "a" })).on("close", f);
       });
     });
-    import_fs.default.appendFileSync(filePath, "</script>");
+    import_fs.default.appendFileSync(filePath, "</template>");
   }
   _addDataFile(fileName, data) {
     this._dataZipFile.addBuffer(Buffer.from(JSON.stringify(data)), fileName);
@@ -373,7 +401,11 @@ class HtmlBuilder {
         path: path2,
         ok: test.outcome() === "expected" || test.outcome() === "flaky",
         results: results.map((result) => {
-          return { attachments: result.attachments.map((a) => ({ name: a.name, contentType: a.contentType, path: a.path })) };
+          return {
+            attachments: result.attachments.map((a) => ({ name: a.name, contentType: a.contentType, path: a.path })),
+            startTime: result.startTime,
+            workerIndex: result.workerIndex
+          };
         })
       }
     };
@@ -468,7 +500,8 @@ class HtmlBuilder {
         ...result.attachments,
         ...result.stdout.map((m) => stdioAttachment(m, "stdout")),
         ...result.stderr.map((m) => stdioAttachment(m, "stderr"))
-      ])
+      ]),
+      workerIndex: result.workerIndex
     };
   }
   _createTestStep(dedupedStep, result) {

package/lib/reporters/junit.js

@@ -40,11 +40,14 @@ class JUnitReporter {
   constructor(options) {
     this.totalTests = 0;
     this.totalFailures = 0;
+    this.totalErrors = 0;
     this.totalSkipped = 0;
     this.stripANSIControlSequences = false;
     this.includeProjectInTestName = false;
+    this.includeRetries = false;
     this.stripANSIControlSequences = (0, import_utils.getAsBooleanFromENV)("PLAYWRIGHT_JUNIT_STRIP_ANSI", !!options.stripANSIControlSequences);
     this.includeProjectInTestName = (0, import_utils.getAsBooleanFromENV)("PLAYWRIGHT_JUNIT_INCLUDE_PROJECT_IN_TEST_NAME", !!options.includeProjectInTestName);
+    this.includeRetries = (0, import_utils.getAsBooleanFromENV)("PLAYWRIGHT_JUNIT_INCLUDE_RETRIES", !!options.includeRetries);
     this.configDir = options.configDir;
     this.resolvedOutputFile = (0, import_base.resolveOutputFile)("JUNIT", options)?.outputFile;
   }
@@ -77,7 +80,7 @@ class JUnitReporter {
         tests: self.totalTests,
         failures: self.totalFailures,
         skipped: self.totalSkipped,
-        errors: 0,
+        errors: self.totalErrors,
         time: result.duration / 1e3
       },
       children
@@ -95,6 +98,7 @@ class JUnitReporter {
     let tests = 0;
     let skipped = 0;
     let failures = 0;
+    let errors = 0;
     let duration = 0;
     const children = [];
     const testCaseNamePrefix = projectName && this.includeProjectInTestName ? `[${projectName}] ` : "";
@@ -102,15 +106,18 @@ class JUnitReporter {
       ++tests;
       if (test.outcome() === "skipped")
         ++skipped;
-      if (!test.ok())
-        ++failures;
       for (const result of test.results)
         duration += result.duration;
-      await this._addTestCase(suite.title, testCaseNamePrefix, test, children);
+      const classification = await this._addTestCase(suite.title, testCaseNamePrefix, test, children);
+      if (classification === "error")
+        ++errors;
+      else if (classification === "failure")
+        ++failures;
     }
     this.totalTests += tests;
     this.totalSkipped += skipped;
     this.totalFailures += failures;
+    this.totalErrors += errors;
     const entry = {
       name: "testsuite",
       attributes: {
@@ -121,7 +128,7 @@ class JUnitReporter {
         failures,
         skipped,
         time: duration / 1e3,
-        errors: 0
+        errors
       },
       children
     };
@@ -134,8 +141,7 @@ class JUnitReporter {
         // Skip root, project, file
         name: namePrefix + test.titlePath().slice(3).join(" \u203A "),
         // filename
-        classname: suiteName,
-        time: test.results.reduce((acc, value) => acc + value.duration, 0) / 1e3
+        classname: suiteName
       },
       children: []
     };
@@ -158,21 +164,60 @@ class JUnitReporter {
       entry.children.push(properties);
     if (test.outcome() === "skipped") {
       entry.children.push({ name: "skipped" });
-      return;
+      return null;
+    }
+    if (this.includeRetries && test.ok()) {
+      const passResult = test.results[test.results.length - 1];
+      entry.attributes.time = passResult.duration / 1e3;
+      await this._appendStdIO(entry, [passResult]);
+      for (let i = 0; i < test.results.length - 1; i++) {
+        const result = test.results[i];
+        if (result.status === "passed" || result.status === "skipped")
+          continue;
+        entry.children.push(await this._buildRetryEntry(result, "flaky"));
+      }
+      return null;
+    }
+    if (this.includeRetries) {
+      entry.attributes.time = test.results[0].duration / 1e3;
+      await this._appendStdIO(entry, [test.results[0]]);
+      for (let i = 1; i < test.results.length; i++) {
+        const result = test.results[i];
+        if (result.status === "passed" || result.status === "skipped")
+          continue;
+        entry.children.push(await this._buildRetryEntry(result, "rerun"));
+      }
+      return this._addFailureEntry(test, classifyResultError(test.results[0]), entry);
     }
-    if (!test.ok()) {
+    entry.attributes.time = test.results.reduce((acc, value) => acc + value.duration, 0) / 1e3;
+    await this._appendStdIO(entry, test.results);
+    if (test.ok())
+      return null;
+    return this._addFailureEntry(test, classifyTestError(test), entry);
+  }
+  _addFailureEntry(test, errorInfo, entry) {
+    if (errorInfo) {
       entry.children.push({
-        name: "failure",
-        attributes: {
-          message: `${import_path.default.basename(test.location.file)}:${test.location.line}:${test.location.column} ${test.title}`,
-          type: "FAILURE"
-        },
+        name: errorInfo.elementName,
+        attributes: { message: errorInfo.message, type: errorInfo.type },
         text: (0, import_util.stripAnsiEscapes)((0, import_base.formatFailure)(import_base.nonTerminalScreen, this.config, test))
       });
+      return errorInfo.elementName;
     }
+    entry.children.push({
+      name: "failure",
+      attributes: {
+        message: `${import_path.default.basename(test.location.file)}:${test.location.line}:${test.location.column} ${test.title}`,
+        type: "FAILURE"
+      },
+      text: (0, import_util.stripAnsiEscapes)((0, import_base.formatFailure)(import_base.nonTerminalScreen, this.config, test))
+    });
+    return "failure";
+  }
+  async _appendStdIO(entry, results) {
     const systemOut = [];
     const systemErr = [];
-    for (const result of test.results) {
+    for (const result of results) {
       for (const item of result.stdout)
         systemOut.push(item.toString());
       for (const item of result.stderr)
@@ -204,6 +249,50 @@ Warning: attachment ${attachmentPath} is missing`);
     if (systemErr.length)
       entry.children.push({ name: "system-err", text: systemErr.join("") });
   }
+  async _buildRetryEntry(result, prefix) {
+    const errorInfo = classifyResultError(result);
+    const entry = {
+      name: `${prefix}${errorInfo?.elementName === "error" ? "Error" : "Failure"}`,
+      attributes: { message: errorInfo?.message || "", type: errorInfo?.type || "FAILURE", time: result.duration / 1e3 },
+      children: []
+    };
+    const stackTrace = result.error?.stack || result.error?.message || result.error?.value || "";
+    entry.children.push({ name: "stackTrace", text: (0, import_util.stripAnsiEscapes)(stackTrace) });
+    await this._appendStdIO(entry, [result]);
+    return entry;
+  }
+}
+function classifyResultError(result) {
+  const error = result.error;
+  if (!error)
+    return null;
+  const rawMessage = (0, import_util.stripAnsiEscapes)(error.message || error.value || "");
+  const nameMatch = rawMessage.match(/^(\w+): /);
+  const errorName = nameMatch ? nameMatch[1] : "";
+  const messageBody = nameMatch ? rawMessage.slice(nameMatch[0].length) : rawMessage;
+  const firstLine = messageBody.split("\n")[0].trim();
+  const matcherMatch = rawMessage.match(/expect\(.*?\)\.(not\.)?(\w+)/);
+  if (matcherMatch) {
+    const matcherName = `expect.${matcherMatch[1] || ""}${matcherMatch[2]}`;
+    return {
+      elementName: "failure",
+      type: matcherName,
+      message: firstLine
+    };
+  }
+  return {
+    elementName: "error",
+    type: errorName || "Error",
+    message: firstLine
+  };
+}
+function classifyTestError(test) {
+  for (const result of test.results) {
+    const info = classifyResultError(result);
+    if (info)
+      return info;
+  }
+  return null;
 }
 function serializeXML(entry, tokens, stripANSIControlSequences) {
   const attrs = [];

package/lib/reporters/line.js

@@ -102,7 +102,7 @@ class LineReporter extends import_base.TerminalReporter {
     }
   }
   _updateLine(test, result, step) {
-    const retriesPrefix = this.totalTestCount < this._current ? ` (retries)` : ``;
+    const retriesPrefix = result.retry ? ` (retries)` : ``;
     const prefix = `[${this._current}/${this.totalTestCount}]${retriesPrefix} `;
     const currentRetrySuffix = result.retry ? this.screen.colors.yellow(` (retry #${result.retry})`) : "";
     const title = this.formatTestTitle(test, step) + currentRetrySuffix;

package/lib/reporters/list.js

@@ -22,7 +22,6 @@ __export(list_exports, {
 });
 module.exports = __toCommonJS(list_exports);
 var import_utils = require("patchright-bun-core/lib/utils");
-var import_utilsBundle = require("patchright-bun-core/lib/utilsBundle");
 var import_base = require("./base");
 var import_util = require("../util");
 const DOES_NOT_SUPPORT_UTF8_IN_TERMINAL = process.platform === "win32" && process.env.TERM_PROGRAM !== "vscode" && !process.env.WT_SESSION;
@@ -110,7 +109,7 @@ class ListReporter extends import_base.TerminalReporter {
       text = this.screen.colors.red(title);
     else
       text = title;
-    text += this.screen.colors.dim(` (${(0, import_utilsBundle.ms)(step.duration)})`);
+    text += this.screen.colors.dim(` (${(0, import_utils.msToString)(step.duration)})`);
     this._updateOrAppendLine(this._stepRows, step, text, prefix);
   }
   _maybeWriteNewLine() {
@@ -188,7 +187,7 @@ class ListReporter extends import_base.TerminalReporter {
         prefix = this._testPrefix(index, this.screen.colors.red(statusMark));
         text = this.screen.colors.red(title);
       }
-      text += this._retrySuffix(result) + this.screen.colors.dim(` (${(0, import_utilsBundle.ms)(result.duration)})`);
+      text += this._retrySuffix(result) + this.screen.colors.dim(` (${(0, import_utils.msToString)(result.duration)})`);
     }
     this._updateOrAppendLine(this._testRows, test, text, prefix);
   }

package/lib/reporters/merge.js

@@ -77,22 +77,28 @@ async function createMergedReport(config, dir, reporterDescriptions, rootDirOver
     }
   };
   await dispatchEvents(eventData.prologue);
-  for (const { reportFile, eventPatchers, metadata, tags, startTime, duration } of eventData.reports) {
+  let usedWorkers = 0;
+  for (const { reportFile, zipFile, eventPatchers, metadata, config: config2, fullResult } of eventData.reports) {
+    multiplexer.onReportConfigure({
+      reportPath: zipFile,
+      config: (0, import_teleReceiver.asFullConfig)(config2)
+    });
     const reportJsonl = await import_fs.default.promises.readFile(reportFile);
     const events = parseTestEvents(reportJsonl);
     new import_stringInternPool.JsonStringInternalizer(stringPool).traverse(events);
     eventPatchers.patchers.push(new AttachmentPathPatcher(dir));
     if (metadata.name)
       eventPatchers.patchers.push(new GlobalErrorPatcher(metadata.name));
-    if (tags.length)
-      eventPatchers.patchers.push(new GlobalErrorPatcher(tags.join(" ")));
+    if (config2?.tags?.length)
+      eventPatchers.patchers.push(new GlobalErrorPatcher(config2.tags.join(" ")));
+    const workerIndexPatcher = new WorkerIndexPatcher(usedWorkers);
+    eventPatchers.patchers.push(workerIndexPatcher);
     eventPatchers.patchEvents(events);
+    usedWorkers += workerIndexPatcher.usedWorkers();
     await dispatchEvents(events);
-    multiplexer.onMachineEnd({
-      startTime: new Date(startTime),
-      duration,
-      tag: tags,
-      shardIndex: metadata.shard?.current
+    multiplexer.onReportEnd({
+      reportPath: zipFile,
+      result: (0, import_teleReceiver.asFullResult)(fullResult)
     });
   }
   await dispatchEvents(eventData.epilogue);
@@ -130,22 +136,22 @@ async function extractAndParseReports(dir, shardFiles, internalizer, printStatus
     const zipFile = new import_utils.ZipFile(absolutePath);
     const entryNames = await zipFile.entries();
     for (const entryName of entryNames.sort()) {
-      let fileName = import_path.default.join(dir, entryName);
+      let reportFile = import_path.default.join(dir, entryName);
       const content = await zipFile.read(entryName);
       if (entryName.endsWith(".jsonl")) {
-        fileName = reportNames.makeUnique(fileName);
+        reportFile = reportNames.makeUnique(reportFile);
         let parsedEvents = parseCommonEvents(content);
         internalizer.traverse(parsedEvents);
         const metadata = findMetadata(parsedEvents, file);
         parsedEvents = modernizer.modernize(metadata.version, parsedEvents);
         shardEvents.push({
-          file,
-          localPath: fileName,
+          zipFile: absolutePath,
+          reportFile,
           metadata,
           parsedEvents
         });
       }
-      await import_fs.default.promises.writeFile(fileName, content);
+      await import_fs.default.promises.writeFile(reportFile, content);
     }
     zipFile.close();
   }
@@ -174,13 +180,13 @@ async function mergeEvents(dir, shardReportFiles, stringPool, printStatus, rootD
     const shardB = b.metadata.shard?.current ?? 0;
     if (shardA !== shardB)
       return shardA - shardB;
-    return a.file.localeCompare(b.file);
+    return a.zipFile.localeCompare(b.zipFile);
   });
   printStatus(`merging events`);
   const reports = [];
   const globalTestIdSet = /* @__PURE__ */ new Set();
   for (let i = 0; i < blobs.length; ++i) {
-    const { parsedEvents, metadata, localPath } = blobs[i];
+    const { parsedEvents, metadata, reportFile, zipFile } = blobs[i];
     const eventPatchers = new JsonEventPatchers();
     eventPatchers.patchers.push(new IdsPatcher(
       stringPool,
@@ -191,28 +197,26 @@ async function mergeEvents(dir, shardReportFiles, stringPool, printStatus, rootD
     if (rootDirOverride)
       eventPatchers.patchers.push(new PathSeparatorPatcher(metadata.pathSeparator));
     eventPatchers.patchEvents(parsedEvents);
-    let tags = [];
-    let startTime = 0;
-    let duration = 0;
+    let config;
+    let fullResult;
     for (const event of parsedEvents) {
       if (event.method === "onConfigure") {
         configureEvents.push(event);
-        tags = event.params.config.tags || [];
+        config = event.params.config;
       } else if (event.method === "onProject") {
         projectEvents.push(event);
       } else if (event.method === "onEnd") {
-        endEvents.push({ event, metadata, tags });
-        startTime = event.params.result.startTime;
-        duration = event.params.result.duration;
+        fullResult = event.params.result;
+        endEvents.push({ event, metadata });
       }
     }
     reports.push({
       eventPatchers,
-      reportFile: localPath,
+      reportFile,
+      zipFile,
       metadata,
-      tags,
-      startTime,
-      duration
+      config,
+      fullResult
     });
   }
   return {
@@ -237,6 +241,7 @@ function mergeConfigureEvents(configureEvents, rootDirOverride) {
     globalTimeout: 0,
     maxFailures: 0,
     metadata: {},
+    shard: null,
     rootDir: "",
     version: "",
     workers: 0,
@@ -281,6 +286,7 @@ function mergeConfigs(to, from) {
       ...from.metadata,
       actualWorkers: (to.metadata.actualWorkers || 0) + (from.metadata.actualWorkers || 0)
     },
+    shard: null,
     workers: to.workers + from.workers
   };
 }
@@ -512,6 +518,21 @@ class GlobalErrorPatcher {
       error.stack = this._prefix + error.stack;
   }
 }
+class WorkerIndexPatcher {
+  constructor(baseWorkerIndex) {
+    this._maxWorkerIndex = 0;
+    this._baseWorkerIndex = baseWorkerIndex;
+  }
+  patchEvent(event) {
+    if (event.method === "onTestBegin") {
+      this._maxWorkerIndex = Math.max(this._maxWorkerIndex, event.params.result.workerIndex);
+      event.params.result.workerIndex += this._baseWorkerIndex;
+    }
+  }
+  usedWorkers() {
+    return this._maxWorkerIndex + 1;
+  }
+}
 class JsonEventPatchers {
   constructor() {
     this.patchers = [];

package/lib/reporters/multiplexer.js

@@ -56,9 +56,13 @@ class Multiplexer {
     for (const reporter of this._reporters)
       wrap(() => reporter.onTestEnd?.(test, result));
   }
-  onMachineEnd(result) {
+  onReportConfigure(params) {
     for (const reporter of this._reporters)
-      wrap(() => reporter.onMachineEnd?.(result));
+      wrap(() => reporter.onReportConfigure?.(params));
+  }
+  onReportEnd(params) {
+    for (const reporter of this._reporters)
+      wrap(() => reporter.onReportEnd?.(params));
   }
   async onEnd(result) {
     for (const reporter of this._reporters) {

package/lib/reporters/teleEmitter.js

@@ -168,6 +168,7 @@ class TeleReporterEmitter {
       maxFailures: config.maxFailures,
       metadata: config.metadata,
       rootDir: config.rootDir,
+      shard: config.shard,
       version: config.version,
       workers: config.workers,
       globalSetup: config.globalSetup,
@@ -196,6 +197,7 @@ class TeleReporterEmitter {
       dependencies: project.dependencies,
       snapshotDir: this._relativePath(project.snapshotDir),
       teardown: project.teardown,
+      ignoreSnapshots: project.ignoreSnapshots ? true : void 0,
       use: this._serializeProjectUseOptions(project.use)
     };
     return report;