@flakiness/sdk 0.153.0 → 0.155.0

package/README.md

@@ -95,6 +95,7 @@ Use this entry point when you need to process or manipulate reports in browser-b
 - **`RAMUtilization`** - Track RAM utilization over time via periodic sampling
 
 ### Working with Reports
+- **`readReport()`** - Read a Flakiness report and its attachments from disk
 - **`showReport()`** - Start a local server and open the report in your browser
 - **`uploadReport()`** - Upload reports and attachments to Flakiness.io
 - **`writeReport()`** - Write reports to disk in the standard Flakiness report format

package/lib/browser.js

@@ -4,8 +4,139 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/browser.ts
-import { FlakinessReport as FlakinessReport2 } from "@flakiness/flakiness-report";
+// node_modules/@flakiness/flakiness-report/lib/flakinessReport.js
+var FlakinessReport;
+((FlakinessReport22) => {
+  FlakinessReport22.CATEGORY_PLAYWRIGHT = "playwright";
+  FlakinessReport22.CATEGORY_PYTEST = "pytest";
+  FlakinessReport22.CATEGORY_JUNIT = "junit";
+})(FlakinessReport || (FlakinessReport = {}));
+
+// node_modules/@flakiness/flakiness-report/lib/schema.js
+import z from "zod/v4";
+var Schema;
+((Schema2) => {
+  Schema2.CommitId = z.string().min(40).max(40);
+  Schema2.AttachmentId = z.string().min(1).max(1024);
+  Schema2.UnixTimestampMS = z.number().min(0);
+  Schema2.DurationMS = z.number().min(0);
+  Schema2.Number1Based = z.number();
+  Schema2.GitFilePath = z.string().min(0);
+  Schema2.Location = z.object({
+    file: Schema2.GitFilePath,
+    line: Schema2.Number1Based,
+    // Note: Locations for file suites are (0, 0).
+    column: Schema2.Number1Based
+  });
+  Schema2.TestStatus = z.enum(["passed", "failed", "timedOut", "skipped", "interrupted"]);
+  Schema2.Environment = z.object({
+    name: z.string().min(1).max(512),
+    systemData: z.object({
+      osName: z.string().optional(),
+      osVersion: z.string().optional(),
+      osArch: z.string().optional()
+    }).optional(),
+    metadata: z.any().optional(),
+    userSuppliedData: z.any().optional()
+  });
+  Schema2.STDIOEntry = z.union([
+    z.object({ text: z.string() }),
+    z.object({ buffer: z.string() })
+  ]);
+  Schema2.ReportError = z.object({
+    location: Schema2.Location.optional(),
+    message: z.string().optional(),
+    stack: z.string().optional(),
+    snippet: z.string().optional(),
+    value: z.string().optional()
+  });
+  Schema2.SuiteType = z.enum(["file", "anonymous suite", "suite"]);
+  Schema2.TestStep = z.object({
+    title: z.string(),
+    duration: Schema2.DurationMS.optional(),
+    location: Schema2.Location.optional(),
+    snippet: z.string().optional(),
+    error: Schema2.ReportError.optional(),
+    get steps() {
+      return z.array(Schema2.TestStep).optional();
+    }
+  });
+  Schema2.Attachment = z.object({
+    name: z.string(),
+    contentType: z.string(),
+    id: Schema2.AttachmentId
+  });
+  Schema2.Annotation = z.object({
+    type: z.string(),
+    description: z.string().optional(),
+    location: Schema2.Location.optional()
+  });
+  Schema2.RunAttempt = z.object({
+    // Index of the environment in the environments array (must be >= 0).
+    environmentIdx: z.number().min(0).optional(),
+    expectedStatus: Schema2.TestStatus.optional(),
+    status: Schema2.TestStatus.optional(),
+    startTimestamp: Schema2.UnixTimestampMS,
+    duration: Schema2.DurationMS.optional(),
+    timeout: Schema2.DurationMS.optional(),
+    annotations: z.array(Schema2.Annotation).optional(),
+    errors: z.array(Schema2.ReportError).optional(),
+    parallelIndex: z.number().optional(),
+    steps: z.array(Schema2.TestStep).optional(),
+    stdout: z.array(Schema2.STDIOEntry).optional(),
+    stderr: z.array(Schema2.STDIOEntry).optional(),
+    attachments: z.array(Schema2.Attachment).optional()
+  });
+  Schema2.Suite = z.object({
+    type: Schema2.SuiteType,
+    title: z.string(),
+    location: Schema2.Location.optional(),
+    get suites() {
+      return z.array(Schema2.Suite).optional();
+    },
+    get tests() {
+      return z.array(Schema2.Test).optional();
+    }
+  });
+  Schema2.Test = z.object({
+    title: z.string(),
+    location: Schema2.Location.optional(),
+    tags: z.array(z.string()).optional(),
+    attempts: z.array(Schema2.RunAttempt)
+  });
+  Schema2.SystemUtilizationSample = z.object({
+    dts: Schema2.DurationMS,
+    // Must be between 0 and 100 (inclusive). Can be a rational number.
+    cpuUtilization: z.number().min(0).max(100),
+    // Must be between 0 and 100 (inclusive). Can be a rational number.
+    memoryUtilization: z.number().min(0).max(100)
+  });
+  Schema2.SystemUtilization = z.object({
+    totalMemoryBytes: z.number().min(0),
+    startTimestamp: Schema2.UnixTimestampMS,
+    samples: z.array(Schema2.SystemUtilizationSample)
+  });
+  Schema2.UtilizationTelemetry = z.tuple([Schema2.DurationMS, z.number().min(0).max(100)]);
+  Schema2.Report = z.object({
+    category: z.string().min(1).max(100),
+    commitId: Schema2.CommitId,
+    relatedCommitIds: z.array(Schema2.CommitId).optional(),
+    configPath: Schema2.GitFilePath.optional(),
+    url: z.string().optional(),
+    environments: z.array(Schema2.Environment).min(1),
+    suites: z.array(Schema2.Suite).optional(),
+    tests: z.array(Schema2.Test).optional(),
+    unattributedErrors: z.array(Schema2.ReportError).optional(),
+    startTimestamp: Schema2.UnixTimestampMS,
+    duration: Schema2.DurationMS,
+    systemUtilization: z.optional(Schema2.SystemUtilization),
+    cpuCount: z.number().min(0).optional(),
+    cpuAvg: z.array(Schema2.UtilizationTelemetry).optional(),
+    cpuMax: z.array(Schema2.UtilizationTelemetry).optional(),
+    ram: z.array(Schema2.UtilizationTelemetry).optional(),
+    ramBytes: z.number().min(0).optional()
+  });
+})(Schema || (Schema = {}));
 
 // src/reportUtilsBrowser.ts
 var reportUtilsBrowser_exports = {};
@@ -175,8 +306,7 @@ function computeTestId(test, suiteId) {
 }
 
 // src/validateReport.ts
-import { Schema } from "@flakiness/flakiness-report";
-import z from "zod";
+import z2 from "zod/v4";
 function validateReport(report) {
   const validation = Schema.Report.safeParse(report);
   if (!validation.success) {
@@ -184,7 +314,7 @@ function validateReport(report) {
     const allIssues = validation.error.issues;
     const shownIssues = allIssues.slice(0, MAX_ISSUES);
     const remaining = allIssues.length - shownIssues.length;
-    const base = [z.prettifyError(new z.ZodError(shownIssues))];
+    const base = [z2.prettifyError(new z2.ZodError(shownIssues))];
     if (remaining > 0)
       base.push(`... and ${remaining} more issue${remaining === 1 ? "" : "s"} ...`);
     return base.join("\n");
@@ -214,7 +344,7 @@ function visitTests(report, testVisitor) {
     visitSuite(suite, []);
 }
 export {
-  FlakinessReport2 as FlakinessReport,
+  FlakinessReport,
   reportUtilsBrowser_exports as ReportUtils
 };
 //# sourceMappingURL=browser.js.map

package/lib/index.js

@@ -4,9 +4,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/index.ts
-import { FlakinessReport as FlakinessReport2, Schema as Schema2 } from "@flakiness/flakiness-report";
-
 // src/ciUtils.ts
 var CIUtils;
 ((CIUtils2) => {
@@ -778,9 +775,142 @@ function computeTestId(test, suiteId) {
   });
 }
 
+// node_modules/@flakiness/flakiness-report/lib/flakinessReport.js
+var FlakinessReport;
+((FlakinessReport22) => {
+  FlakinessReport22.CATEGORY_PLAYWRIGHT = "playwright";
+  FlakinessReport22.CATEGORY_PYTEST = "pytest";
+  FlakinessReport22.CATEGORY_JUNIT = "junit";
+})(FlakinessReport || (FlakinessReport = {}));
+
+// node_modules/@flakiness/flakiness-report/lib/schema.js
+import z from "zod/v4";
+var Schema;
+((Schema2) => {
+  Schema2.CommitId = z.string().min(40).max(40);
+  Schema2.AttachmentId = z.string().min(1).max(1024);
+  Schema2.UnixTimestampMS = z.number().min(0);
+  Schema2.DurationMS = z.number().min(0);
+  Schema2.Number1Based = z.number();
+  Schema2.GitFilePath = z.string().min(0);
+  Schema2.Location = z.object({
+    file: Schema2.GitFilePath,
+    line: Schema2.Number1Based,
+    // Note: Locations for file suites are (0, 0).
+    column: Schema2.Number1Based
+  });
+  Schema2.TestStatus = z.enum(["passed", "failed", "timedOut", "skipped", "interrupted"]);
+  Schema2.Environment = z.object({
+    name: z.string().min(1).max(512),
+    systemData: z.object({
+      osName: z.string().optional(),
+      osVersion: z.string().optional(),
+      osArch: z.string().optional()
+    }).optional(),
+    metadata: z.any().optional(),
+    userSuppliedData: z.any().optional()
+  });
+  Schema2.STDIOEntry = z.union([
+    z.object({ text: z.string() }),
+    z.object({ buffer: z.string() })
+  ]);
+  Schema2.ReportError = z.object({
+    location: Schema2.Location.optional(),
+    message: z.string().optional(),
+    stack: z.string().optional(),
+    snippet: z.string().optional(),
+    value: z.string().optional()
+  });
+  Schema2.SuiteType = z.enum(["file", "anonymous suite", "suite"]);
+  Schema2.TestStep = z.object({
+    title: z.string(),
+    duration: Schema2.DurationMS.optional(),
+    location: Schema2.Location.optional(),
+    snippet: z.string().optional(),
+    error: Schema2.ReportError.optional(),
+    get steps() {
+      return z.array(Schema2.TestStep).optional();
+    }
+  });
+  Schema2.Attachment = z.object({
+    name: z.string(),
+    contentType: z.string(),
+    id: Schema2.AttachmentId
+  });
+  Schema2.Annotation = z.object({
+    type: z.string(),
+    description: z.string().optional(),
+    location: Schema2.Location.optional()
+  });
+  Schema2.RunAttempt = z.object({
+    // Index of the environment in the environments array (must be >= 0).
+    environmentIdx: z.number().min(0).optional(),
+    expectedStatus: Schema2.TestStatus.optional(),
+    status: Schema2.TestStatus.optional(),
+    startTimestamp: Schema2.UnixTimestampMS,
+    duration: Schema2.DurationMS.optional(),
+    timeout: Schema2.DurationMS.optional(),
+    annotations: z.array(Schema2.Annotation).optional(),
+    errors: z.array(Schema2.ReportError).optional(),
+    parallelIndex: z.number().optional(),
+    steps: z.array(Schema2.TestStep).optional(),
+    stdout: z.array(Schema2.STDIOEntry).optional(),
+    stderr: z.array(Schema2.STDIOEntry).optional(),
+    attachments: z.array(Schema2.Attachment).optional()
+  });
+  Schema2.Suite = z.object({
+    type: Schema2.SuiteType,
+    title: z.string(),
+    location: Schema2.Location.optional(),
+    get suites() {
+      return z.array(Schema2.Suite).optional();
+    },
+    get tests() {
+      return z.array(Schema2.Test).optional();
+    }
+  });
+  Schema2.Test = z.object({
+    title: z.string(),
+    location: Schema2.Location.optional(),
+    tags: z.array(z.string()).optional(),
+    attempts: z.array(Schema2.RunAttempt)
+  });
+  Schema2.SystemUtilizationSample = z.object({
+    dts: Schema2.DurationMS,
+    // Must be between 0 and 100 (inclusive). Can be a rational number.
+    cpuUtilization: z.number().min(0).max(100),
+    // Must be between 0 and 100 (inclusive). Can be a rational number.
+    memoryUtilization: z.number().min(0).max(100)
+  });
+  Schema2.SystemUtilization = z.object({
+    totalMemoryBytes: z.number().min(0),
+    startTimestamp: Schema2.UnixTimestampMS,
+    samples: z.array(Schema2.SystemUtilizationSample)
+  });
+  Schema2.UtilizationTelemetry = z.tuple([Schema2.DurationMS, z.number().min(0).max(100)]);
+  Schema2.Report = z.object({
+    category: z.string().min(1).max(100),
+    commitId: Schema2.CommitId,
+    relatedCommitIds: z.array(Schema2.CommitId).optional(),
+    configPath: Schema2.GitFilePath.optional(),
+    url: z.string().optional(),
+    environments: z.array(Schema2.Environment).min(1),
+    suites: z.array(Schema2.Suite).optional(),
+    tests: z.array(Schema2.Test).optional(),
+    unattributedErrors: z.array(Schema2.ReportError).optional(),
+    startTimestamp: Schema2.UnixTimestampMS,
+    duration: Schema2.DurationMS,
+    systemUtilization: z.optional(Schema2.SystemUtilization),
+    cpuCount: z.number().min(0).optional(),
+    cpuAvg: z.array(Schema2.UtilizationTelemetry).optional(),
+    cpuMax: z.array(Schema2.UtilizationTelemetry).optional(),
+    ram: z.array(Schema2.UtilizationTelemetry).optional(),
+    ramBytes: z.number().min(0).optional()
+  });
+})(Schema || (Schema = {}));
+
 // src/validateReport.ts
-import { Schema } from "@flakiness/flakiness-report";
-import z from "zod";
+import z2 from "zod/v4";
 function validateReport(report) {
   const validation = Schema.Report.safeParse(report);
   if (!validation.success) {
@@ -788,7 +918,7 @@ function validateReport(report) {
     const allIssues = validation.error.issues;
     const shownIssues = allIssues.slice(0, MAX_ISSUES);
     const remaining = allIssues.length - shownIssues.length;
-    const base = [z.prettifyError(new z.ZodError(shownIssues))];
+    const base = [z2.prettifyError(new z2.ZodError(shownIssues))];
     if (remaining > 0)
       base.push(`... and ${remaining} more issue${remaining === 1 ? "" : "s"} ...`);
     return base.join("\n");
@@ -988,15 +1118,69 @@ function visitTests(report, testVisitor) {
     visitSuite(suite, []);
 }
 
+// src/readReport.ts
+import fs5 from "fs/promises";
+import path from "path";
+async function readReport(reportFolder) {
+  reportFolder = path.resolve(reportFolder);
+  const text = await fs5.readFile(path.join(reportFolder, "report.json"), "utf-8");
+  const report = JSON.parse(text);
+  const attachmentsFolder = path.join(reportFolder, "attachments");
+  let attachmentFiles = [];
+  try {
+    attachmentFiles = await listFilesRecursively(attachmentsFolder);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
+  const attachmentIdToPath = /* @__PURE__ */ new Map();
+  const missingAttachments = /* @__PURE__ */ new Map();
+  visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const attachment of attempt.attachments ?? []) {
+        const attachmentPath = filenameToPath.get(attachment.id);
+        if (!attachmentPath) {
+          missingAttachments.set(attachment.id, attachment);
+        } else {
+          attachmentIdToPath.set(attachment.id, {
+            contentType: attachment.contentType,
+            id: attachment.id,
+            path: attachmentPath,
+            type: "file"
+          });
+        }
+      }
+    }
+  });
+  return {
+    report,
+    attachments: Array.from(attachmentIdToPath.values()),
+    missingAttachments: Array.from(missingAttachments.values())
+  };
+}
+async function listFilesRecursively(dir, result = []) {
+  const entries = await fs5.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/showReport.ts
 import chalk from "chalk";
 import open from "open";
 
 // src/flakinessProjectConfig.ts
-import fs5 from "fs";
-import path from "path";
+import fs6 from "fs";
+import path2 from "path";
 function createConfigPath(dir) {
-  return path.join(dir, ".flakiness", "config.json");
+  return path2.join(dir, ".flakiness", "config.json");
 }
 var gConfigPath;
 function ensureConfigPath() {
@@ -1005,9 +1189,9 @@ function ensureConfigPath() {
   return gConfigPath;
 }
 function computeConfigPath() {
-  for (let p = process.cwd(); p !== path.resolve(p, ".."); p = path.resolve(p, "..")) {
+  for (let p = process.cwd(); p !== path2.resolve(p, ".."); p = path2.resolve(p, "..")) {
     const configPath = createConfigPath(p);
-    if (fs5.existsSync(configPath))
+    if (fs6.existsSync(configPath))
       return configPath;
   }
   try {
@@ -1040,7 +1224,7 @@ var FlakinessProjectConfig = class _FlakinessProjectConfig {
    */
   static async load() {
     const configPath = ensureConfigPath();
-    const data = await fs5.promises.readFile(configPath, "utf-8").catch((e) => void 0);
+    const data = await fs6.promises.readFile(configPath, "utf-8").catch((e) => void 0);
     const json = data ? JSON.parse(data) : {};
     return new _FlakinessProjectConfig(configPath, json);
   }
@@ -1127,16 +1311,16 @@ var FlakinessProjectConfig = class _FlakinessProjectConfig {
    * ```
    */
   async save() {
-    await fs5.promises.mkdir(path.dirname(this._configPath), { recursive: true });
-    await fs5.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
+    await fs6.promises.mkdir(path2.dirname(this._configPath), { recursive: true });
+    await fs6.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
   }
 };
 
 // src/staticServer.ts
 import debug2 from "debug";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as http from "http";
-import * as path2 from "path";
+import * as path3 from "path";
 var log2 = debug2("fk:static_server");
 var StaticServer = class {
   _server;
@@ -1157,7 +1341,7 @@ var StaticServer = class {
   };
   constructor(pathPrefix, folderPath, cors) {
     this._pathPrefix = "/" + pathPrefix.replace(/^\//, "").replace(/\/$/, "");
-    this._absoluteFolderPath = path2.resolve(folderPath);
+    this._absoluteFolderPath = path3.resolve(folderPath);
     this._cors = cors;
     this._server = http.createServer((req, res) => this._handleRequest(req, res));
   }
@@ -1253,22 +1437,22 @@ var StaticServer = class {
       return;
     }
     const relativePath = url.slice(this._pathPrefix.length);
-    const safeSuffix = path2.normalize(decodeURIComponent(relativePath)).replace(/^(\.\.[\/\\])+/, "");
-    const filePath = path2.join(this._absoluteFolderPath, safeSuffix);
+    const safeSuffix = path3.normalize(decodeURIComponent(relativePath)).replace(/^(\.\.[\/\\])+/, "");
+    const filePath = path3.join(this._absoluteFolderPath, safeSuffix);
     if (!filePath.startsWith(this._absoluteFolderPath)) {
       this._errorResponse(req, res, 403, "Forbidden");
       return;
     }
-    fs6.stat(filePath, (err, stats) => {
+    fs7.stat(filePath, (err, stats) => {
       if (err || !stats.isFile()) {
         this._errorResponse(req, res, 404, "File Not Found");
         return;
       }
-      const ext = path2.extname(filePath).toLowerCase();
+      const ext = path3.extname(filePath).toLowerCase();
       const contentType = this._mimeTypes[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType });
       log2(`[200] ${req.method} ${req.url} -> ${filePath}`);
-      const readStream = fs6.createReadStream(filePath);
+      const readStream = fs7.createReadStream(filePath);
       readStream.pipe(res);
       readStream.on("error", (err2) => {
         log2("Stream error: %o", err2);
@@ -1300,23 +1484,23 @@ async function showReport(reportFolder) {
 }
 
 // src/writeReport.ts
-import fs7 from "fs";
-import path3 from "path";
+import fs8 from "fs";
+import path4 from "path";
 async function writeReport(report, attachments, outputFolder) {
-  const reportPath = path3.join(outputFolder, "report.json");
-  const attachmentsFolder = path3.join(outputFolder, "attachments");
-  await fs7.promises.rm(outputFolder, { recursive: true, force: true });
-  await fs7.promises.mkdir(outputFolder, { recursive: true });
-  await fs7.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+  const reportPath = path4.join(outputFolder, "report.json");
+  const attachmentsFolder = path4.join(outputFolder, "attachments");
+  await fs8.promises.rm(outputFolder, { recursive: true, force: true });
+  await fs8.promises.mkdir(outputFolder, { recursive: true });
+  await fs8.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
   if (attachments.length)
-    await fs7.promises.mkdir(attachmentsFolder);
+    await fs8.promises.mkdir(attachmentsFolder);
   const movedAttachments = [];
   for (const attachment of attachments) {
-    const attachmentPath = path3.join(attachmentsFolder, attachment.id);
+    const attachmentPath = path4.join(attachmentsFolder, attachment.id);
     if (attachment.type === "file")
-      await fs7.promises.cp(attachment.path, attachmentPath);
+      await fs8.promises.cp(attachment.path, attachmentPath);
     else if (attachment.type === "buffer")
-      await fs7.promises.writeFile(attachmentPath, attachment.body);
+      await fs8.promises.writeFile(attachmentPath, attachment.body);
     movedAttachments.push({
       type: "file",
       contentType: attachment.contentType,
@@ -1330,11 +1514,10 @@ export {
   CIUtils,
   CPUUtilization,
   FlakinessProjectConfig,
-  FlakinessReport2 as FlakinessReport,
   GitWorktree,
   RAMUtilization,
   reportUtils_exports as ReportUtils,
-  Schema2 as Schema,
+  readReport,
   showReport,
   uploadReport,
   writeReport

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flakiness/sdk",
-  "version": "0.153.0",
+  "version": "0.155.0",
   "private": false,
   "repository": {
     "type": "git",
@@ -29,6 +29,7 @@
   "author": "Degu Labs, Inc",
   "license": "MIT",
   "devDependencies": {
+    "@flakiness/flakiness-report": "^0.22.0",
     "@types/debug": "^4.1.12",
     "@types/node": "^25.0.3",
     "esbuild": "^0.27.0",
@@ -36,8 +37,10 @@
     "tsx": "^4.21.0",
     "typescript": "^5.6.2"
   },
+  "peerDependencies": {
+    "@flakiness/flakiness-report": "^0.22.0"
+  },
   "dependencies": {
-    "@flakiness/flakiness-report": "^0.20.0",
     "chalk": "^5.6.2",
     "debug": "^4.4.3",
     "open": "^10.2.0",

package/types/src/index.d.ts

@@ -1,9 +1,9 @@
-export { FlakinessReport, Schema } from '@flakiness/flakiness-report';
 export { CIUtils } from './ciUtils.js';
 export { CPUUtilization } from './cpuUtilization.js';
 export { GitWorktree } from './gitWorktree.js';
 export { RAMUtilization } from './ramUtilization.js';
 export * as ReportUtils from './reportUtils.js';
+export { readReport } from './readReport.js';
 export { showReport } from './showReport.js';
 export { uploadReport } from './uploadReport.js';
 export { writeReport } from './writeReport.js';

package/types/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAGtE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAGhD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAGhD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}

package/types/src/readReport.d.ts

@@ -0,0 +1,49 @@
+import { FlakinessReport } from '@flakiness/flakiness-report';
+import { FileAttachment } from './uploadReport.js';
+/**
+ * Reads a Flakiness report and its attachments from a folder on disk.
+ *
+ * This function reads a Flakiness report that was previously written to disk using `writeReport()`.
+ * It parses the `report.json` file and locates all attachment files referenced in the report.
+ *
+ * The function expects the report folder to follow the standard Flakiness report structure:
+ * - `report.json` - The main report file containing test results and metadata
+ * - `attachments/` - Directory containing all attachment files, named by their ID
+ *
+ * @param {string} reportFolder - Absolute or relative path to the folder containing the Flakiness
+ *   report. The folder must contain a `report.json` file. Attachments are expected to be in the
+ *   `attachments/` subdirectory, but the function will work even if the attachments directory
+ *   doesn't exist (all attachments will be reported as missing).
+ *
+ * @returns {Promise<{report: FlakinessReport.Report, attachments: FileAttachment[], missingAttachments: FlakinessReport.Attachment[]}>}
+ *   Promise that resolves to an object containing:
+ *   - `report` - The parsed Flakiness report object
+ *   - `attachments` - Array of `FileAttachment` objects for attachments that were found on disk.
+ *     Each attachment has:
+ *     - `type: 'file'` - All returned attachments are file-based
+ *     - `contentType` - MIME type from the report
+ *     - `id` - Attachment ID (filename)
+ *     - `path` - Absolute path to the attachment file
+ *   - `missingAttachments` - Array of attachment objects from the report that could not be found
+ *     on disk. This allows callers to detect and handle missing attachments gracefully.
+ *
+ * @throws {Error} Throws if `report.json` cannot be read, the folder doesn't exist, or JSON parsing fails.
+ *
+ * @example
+ * ```typescript
+ * const { report, attachments, missingAttachments } = await readReport('./flakiness-report');
+ *
+ * if (missingAttachments.length > 0) {
+ *   console.warn(`Warning: ${missingAttachments.length} attachments are missing`);
+ * }
+ *
+ * // Use the report and attachments
+ * await uploadReport(report, attachments);
+ * ```
+ */
+export declare function readReport(reportFolder: string): Promise<{
+    report: FlakinessReport.Report;
+    attachments: FileAttachment[];
+    missingAttachments: FlakinessReport.Attachment[];
+}>;
+//# sourceMappingURL=readReport.d.ts.map

package/types/src/readReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readReport.d.ts","sourceRoot":"","sources":["../../src/readReport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAsB,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9D,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC;IAC/B,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,kBAAkB,EAAE,eAAe,CAAC,UAAU,EAAE,CAAC;CAClD,CAAC,CA0CD"}