@empiricalrun/playwright-utils 0.46.4 → 0.47.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @empiricalrun/playwright-utils
 
+## 0.47.1
+
+### Patch Changes
+
+- 370c14a: chore: more logs on disk space
+
+## 0.47.0
+
+### Minor Changes
+
+- 9a1c6e3: fix: attachment cleanup should track usage before uploads
+
 ## 0.46.4
 
 ### Patch Changes

package/dist/reporter/attachment-cleanup-test-reporter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Test-only reporter used by attachment-cleanup integration tests.
+ *
+ * Records a timestamped event log of register/markUploaded/eviction events
+ * so tests can make precise assertions about ordering and timing.
+ */
+import type { FullResult, Reporter, TestCase, TestResult } from "@playwright/test/reporter";
+declare class AttachmentCleanupTestReporter implements Reporter {
+    private _timeline;
+    private _cleanup;
+    private _allAttachmentPaths;
+    private _pendingUploads;
+    private _queue;
+    constructor();
+    onTestEnd(_test: TestCase, result: TestResult): void;
+    onEnd(_result: FullResult): Promise<void>;
+}
+export default AttachmentCleanupTestReporter;
+//# sourceMappingURL=attachment-cleanup-test-reporter.d.ts.map

package/dist/reporter/attachment-cleanup-test-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment-cleanup-test-reporter.d.ts","sourceRoot":"","sources":["../../src/reporter/attachment-cleanup-test-reporter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,UAAU,EACX,MAAM,2BAA2B,CAAC;AAwCnC,cAAM,6BAA8B,YAAW,QAAQ;IACrD,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,MAAM,CAAkC;;IAYhD,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU;IA2BvC,KAAK,CAAC,OAAO,EAAE,UAAU;CA0BhC;AAED,eAAe,6BAA6B,CAAC"}

package/dist/reporter/attachment-cleanup-test-reporter.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Test-only reporter used by attachment-cleanup integration tests.
+ *
+ * Records a timestamped event log of register/markUploaded/eviction events
+ * so tests can make precise assertions about ordering and timing.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const attachment_cleanup_1 = require("./attachment-cleanup");
+const SUMMARY_FILE = path_1.default.join(process.cwd(), "attachment-cleanup-summary.json");
+const UPLOAD_DELAY_MS = parseInt(process.env.TEST_UPLOAD_DELAY_MS || "100", 10);
+const MAX_CONCURRENT = parseInt(process.env.UPLOAD_MAX_QUEUE_SIZE || "10", 10);
+class AsyncQueue {
+    _maxConcurrent;
+    _running = 0;
+    _waiting = [];
+    constructor(_maxConcurrent) {
+        this._maxConcurrent = _maxConcurrent;
+    }
+    async run(fn) {
+        while (this._running >= this._maxConcurrent) {
+            await new Promise((resolve) => this._waiting.push(resolve));
+        }
+        this._running++;
+        try {
+            return await fn();
+        }
+        finally {
+            this._running--;
+            const next = this._waiting.shift();
+            if (next)
+                next();
+        }
+    }
+}
+class AttachmentCleanupTestReporter {
+    _timeline = [];
+    _cleanup = new attachment_cleanup_1.AttachmentCleanup();
+    _allAttachmentPaths = [];
+    _pendingUploads = [];
+    _queue = new AsyncQueue(MAX_CONCURRENT);
+    constructor() {
+        this._cleanup.onEvict = (evictedPath) => {
+            this._timeline.push({
+                type: "eviction",
+                path: evictedPath,
+                timestamp: Date.now(),
+            });
+        };
+    }
+    onTestEnd(_test, result) {
+        for (const attachment of result.attachments) {
+            if (attachment.path) {
+                this._allAttachmentPaths.push(attachment.path);
+                this._cleanup.register(attachment);
+                this._timeline.push({
+                    type: "register",
+                    path: attachment.path,
+                    timestamp: Date.now(),
+                });
+                const attachmentPath = attachment.path;
+                const uploadPromise = this._queue.run(async () => {
+                    await new Promise((r) => setTimeout(r, UPLOAD_DELAY_MS));
+                    this._cleanup.markUploaded(attachmentPath);
+                    this._timeline.push({
+                        type: "markUploaded",
+                        path: attachmentPath,
+                        timestamp: Date.now(),
+                    });
+                });
+                this._pendingUploads.push(uploadPromise);
+            }
+        }
+    }
+    async onEnd(_result) {
+        await Promise.allSettled(this._pendingUploads);
+        this._cleanup.logSummary();
+        const stats = this._cleanup.stats;
+        const existingPaths = this._allAttachmentPaths.filter((p) => fs_1.default.existsSync(p));
+        const deletedPaths = this._allAttachmentPaths.filter((p) => !fs_1.default.existsSync(p));
+        fs_1.default.writeFileSync(SUMMARY_FILE, JSON.stringify({
+            ...stats,
+            allAttachmentPaths: this._allAttachmentPaths,
+            existingPaths,
+            deletedPaths,
+            timeline: this._timeline,
+        }, null, 2));
+    }
+}
+exports.default = AttachmentCleanupTestReporter;

package/dist/reporter/attachment-cleanup.d.ts

@@ -1,7 +1,17 @@
 /**
- * Tracks uploaded attachments and evicts the oldest ones from disk
+ * Tracks test attachments and evicts the oldest uploaded ones from disk
  * when total size exceeds the configured limit.
  *
+ * Two-phase tracking:
+ * 1. register() — called immediately when an attachment is created.
+ *    Adds the file to the total size accounting so the LRU knows about
+ *    all disk usage, even while uploads are still queued.
+ * 2. markUploaded() — called after the file is uploaded to R2.
+ *    Marks the file as safe to evict (delete from disk).
+ *
+ * Eviction only deletes files that have been uploaded. This ensures we
+ * never delete a file before its upload completes.
+ *
  * Why this exists:
  * Test attachments (videos, traces, screenshots) accumulate on disk during a
  * test run. On Fargate workers with 50 GB ephemeral storage, large test suites
@@ -9,23 +19,47 @@
  * safely delete them from disk — but we can't delete them immediately because
  * Playwright's blob reporter reads them during onEnd to embed as resources/.
  *
- * Instead, we use an LRU approach: only evict the oldest files when total size
- * exceeds the limit. The blob reporter's statSync guard (Playwright 1.57+)
- * gracefully skips missing files, and patchBlobZip replaces resources/ with
+ * The blob reporter's statSync guard (Playwright 1.57+) gracefully skips
+ * missing files, and patchBlobZip replaces resources/ with
  * _empirical_urls.json pointing to R2 URLs anyway.
- *
- * Future: when the incremental blob reporter is mature enough to replace the
- * standard blob reporter for all runs (not just spot instances), this class
- * can be removed — the incremental reporter never embeds attachments as resources.
  */
 export declare class AttachmentCleanup {
-    private _entries;
+    private _pending;
+    private _uploaded;
     private _totalSize;
     private _limitBytes;
+    private _registeredCount;
+    private _uploadedCount;
+    private _evictedCount;
+    private _evictedBytes;
+    private _diskLogTimer;
+    private _onEvict;
     constructor(limitBytes?: number);
-    track(attachment: {
+    /**
+     * Phase 1: Register an attachment immediately when it's created.
+     * Adds to total size accounting and attempts eviction of already-uploaded files.
+     */
+    register(attachment: {
         path?: string | undefined;
     }): void;
+    /**
+     * Phase 2: Mark an attachment as uploaded (safe to evict).
+     * Moves from pending to the uploaded queue and attempts eviction.
+     */
+    markUploaded(attachmentPath: string): void;
     private _evict;
+    private _logDiskStatus;
+    logSummary(): void;
+    set onEvict(callback: (path: string) => void);
+    get stats(): {
+        registeredCount: number;
+        uploadedCount: number;
+        pendingCount: number;
+        evictedCount: number;
+        evictedBytes: number;
+        activeCount: number;
+        totalSize: number;
+        limitBytes: number;
+    };
 }
 //# sourceMappingURL=attachment-cleanup.d.ts.map

package/dist/reporter/attachment-cleanup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attachment-cleanup.d.ts","sourceRoot":"","sources":["../../src/reporter/attachment-cleanup.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAwC;IACxD,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAS;gBAEhB,UAAU,GAAE,MAAiC;IAIzD,KAAK,CAAC,UAAU,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE;IAc/C,OAAO,CAAC,MAAM;CAcf"}
+{"version":3,"file":"attachment-cleanup.d.ts","sourceRoot":"","sources":["../../src/reporter/attachment-cleanup.ts"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,aAAa,CAA+C;IACpE,OAAO,CAAC,QAAQ,CAAyC;gBAE7C,UAAU,GAAE,MAAmC;IAY3D;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE;IAelD;;;OAGG;IACH,YAAY,CAAC,cAAc,EAAE,MAAM;IASnC,OAAO,CAAC,MAAM;IA4Bd,OAAO,CAAC,cAAc;IAMtB,UAAU;IAUV,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EAE3C;IAED,IAAI,KAAK;;;;;;;;;MAWR;CACF"}

package/dist/reporter/attachment-cleanup.js

@@ -4,13 +4,61 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AttachmentCleanup = void 0;
+const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const logger_1 = require("../logger");
-const DEFAULT_DISK_LIMIT_BYTES = 10 * 1024 * 1024 * 1024; // 10 GB
+function getDefaultDiskLimitBytes() {
+    const raw = process.env.ATTACHMENT_CLEANUP_LIMIT_BYTES;
+    if (raw != null) {
+        const parsed = Number(raw);
+        if (Number.isSafeInteger(parsed) && parsed > 0)
+            return parsed;
+        logger_1.logger.warn(`[AttachmentCleanup] Invalid ATTACHMENT_CLEANUP_LIMIT_BYTES=${raw}, using default`);
+    }
+    return 10 * 1024 * 1024 * 1024; // 10 GB
+}
+const DISK_LOG_INTERVAL_MS = 30_000;
+function formatBytes(bytes) {
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function getDiskUsage() {
+    try {
+        return (0, child_process_1.execSync)("df -h / | tail -1", {
+            encoding: "utf8",
+            timeout: 5000,
+        }).trim();
+    }
+    catch {
+        return "unavailable";
+    }
+}
+function getTracingDirCount() {
+    try {
+        const output = (0, child_process_1.execSync)("ls -d /tmp/playwright-tracing-* 2>/dev/null | wc -l", { encoding: "utf8", timeout: 3000 }).trim();
+        return parseInt(output, 10) || 0;
+    }
+    catch {
+        return 0;
+    }
+}
 /**
- * Tracks uploaded attachments and evicts the oldest ones from disk
+ * Tracks test attachments and evicts the oldest uploaded ones from disk
  * when total size exceeds the configured limit.
  *
+ * Two-phase tracking:
+ * 1. register() — called immediately when an attachment is created.
+ *    Adds the file to the total size accounting so the LRU knows about
+ *    all disk usage, even while uploads are still queued.
+ * 2. markUploaded() — called after the file is uploaded to R2.
+ *    Marks the file as safe to evict (delete from disk).
+ *
+ * Eviction only deletes files that have been uploaded. This ensures we
+ * never delete a file before its upload completes.
+ *
  * Why this exists:
  * Test attachments (videos, traces, screenshots) accumulate on disk during a
  * test run. On Fargate workers with 50 GB ephemeral storage, large test suites
@@ -18,48 +66,113 @@ const DEFAULT_DISK_LIMIT_BYTES = 10 * 1024 * 1024 * 1024; // 10 GB
  * safely delete them from disk — but we can't delete them immediately because
  * Playwright's blob reporter reads them during onEnd to embed as resources/.
  *
- * Instead, we use an LRU approach: only evict the oldest files when total size
- * exceeds the limit. The blob reporter's statSync guard (Playwright 1.57+)
- * gracefully skips missing files, and patchBlobZip replaces resources/ with
+ * The blob reporter's statSync guard (Playwright 1.57+) gracefully skips
+ * missing files, and patchBlobZip replaces resources/ with
  * _empirical_urls.json pointing to R2 URLs anyway.
- *
- * Future: when the incremental blob reporter is mature enough to replace the
- * standard blob reporter for all runs (not just spot instances), this class
- * can be removed — the incremental reporter never embeds attachments as resources.
  */
 class AttachmentCleanup {
-    _entries = [];
+    _pending = new Map();
+    _uploaded = [];
     _totalSize = 0;
     _limitBytes;
-    constructor(limitBytes = DEFAULT_DISK_LIMIT_BYTES) {
+    _registeredCount = 0;
+    _uploadedCount = 0;
+    _evictedCount = 0;
+    _evictedBytes = 0;
+    _diskLogTimer = null;
+    _onEvict = null;
+    constructor(limitBytes = getDefaultDiskLimitBytes()) {
         this._limitBytes = limitBytes;
+        logger_1.logger.info(`[AttachmentCleanup] Initialized with limit: ${formatBytes(limitBytes)}`);
+        this._diskLogTimer = setInterval(() => {
+            this._logDiskStatus();
+        }, DISK_LOG_INTERVAL_MS);
+        // Don't keep the process alive just for this timer
+        this._diskLogTimer.unref();
     }
-    track(attachment) {
+    /**
+     * Phase 1: Register an attachment immediately when it's created.
+     * Adds to total size accounting and attempts eviction of already-uploaded files.
+     */
+    register(attachment) {
         try {
-            if (attachment.path) {
-                const stat = fs_1.default.statSync(attachment.path);
-                const sizeBytes = stat.size;
-                this._entries.push({ path: attachment.path, size: sizeBytes });
-                this._totalSize += sizeBytes;
-                this._evict();
-            }
+            if (!attachment.path)
+                return;
+            if (this._pending.has(attachment.path))
+                return;
+            const stat = fs_1.default.statSync(attachment.path);
+            const sizeBytes = stat.size;
+            this._pending.set(attachment.path, sizeBytes);
+            this._totalSize += sizeBytes;
+            this._registeredCount++;
+            this._evict();
         }
         catch {
-            // Ignore errors
+            // Ignore errors (file may not exist)
         }
     }
+    /**
+     * Phase 2: Mark an attachment as uploaded (safe to evict).
+     * Moves from pending to the uploaded queue and attempts eviction.
+     */
+    markUploaded(attachmentPath) {
+        const size = this._pending.get(attachmentPath);
+        if (size === undefined)
+            return;
+        this._pending.delete(attachmentPath);
+        this._uploaded.push({ path: attachmentPath, size });
+        this._uploadedCount++;
+        this._evict();
+    }
     _evict() {
-        while (this._totalSize > this._limitBytes && this._entries.length > 0) {
-            const oldest = this._entries.shift();
+        while (this._totalSize > this._limitBytes && this._uploaded.length > 0) {
+            const oldest = this._uploaded[0];
             try {
                 fs_1.default.unlinkSync(oldest.path);
-                logger_1.logger.debug(`[AttachmentCleanup] Evicted ${oldest.path} (${oldest.size} bytes)`);
+                this._uploaded.shift();
+                this._evictedCount++;
+                this._evictedBytes += oldest.size;
+                this._totalSize -= oldest.size;
+                logger_1.logger.info(`[AttachmentCleanup] Evicted ${oldest.path} (${formatBytes(oldest.size)}), totalSize=${formatBytes(this._totalSize)}, pending=${this._pending.size}, uploaded=${this._uploaded.length}`);
+                this._onEvict?.(oldest.path);
             }
-            catch {
-                // File may already be gone
+            catch (err) {
+                const code = err?.code;
+                if (code === "ENOENT") {
+                    this._uploaded.shift();
+                    this._totalSize -= oldest.size;
+                }
+                else {
+                    logger_1.logger.warn(`[AttachmentCleanup] Failed to evict ${oldest.path}: ${code ?? err}`);
+                    break;
+                }
             }
-            this._totalSize -= oldest.size;
         }
     }
+    _logDiskStatus() {
+        logger_1.logger.info(`[AttachmentCleanup] Periodic: registered=${this._registeredCount}, pending=${this._pending.size}, uploaded=${this._uploadedCount}, evicted=${this._evictedCount} (${formatBytes(this._evictedBytes)}), totalSize=${formatBytes(this._totalSize)}, limit=${formatBytes(this._limitBytes)}, disk=${getDiskUsage()}, tracingDirs=${getTracingDirCount()}`);
+    }
+    logSummary() {
+        if (this._diskLogTimer) {
+            clearInterval(this._diskLogTimer);
+            this._diskLogTimer = null;
+        }
+        logger_1.logger.info(`[AttachmentCleanup] Summary: registered=${this._registeredCount}, pending=${this._pending.size}, uploaded=${this._uploadedCount}, evicted=${this._evictedCount} (${formatBytes(this._evictedBytes)}), totalSize=${formatBytes(this._totalSize)}, disk=${getDiskUsage()}`);
+    }
+    set onEvict(callback) {
+        this._onEvict = callback;
+    }
+    get stats() {
+        return {
+            registeredCount: this._registeredCount,
+            uploadedCount: this._uploadedCount,
+            pendingCount: this._pending.size,
+            evictedCount: this._evictedCount,
+            evictedBytes: this._evictedBytes,
+            activeCount: this._uploaded.length,
+            totalSize: this._totalSize,
+            limitBytes: this._limitBytes,
+        };
+    }
 }
 exports.AttachmentCleanup = AttachmentCleanup;

package/dist/reporter/empirical-reporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"empirical-reporter.d.ts","sourceRoot":"","sources":["../../src/reporter/empirical-reporter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,UAAU,EACX,MAAM,2BAA2B,CAAC;AAuBnC,cAAM,iBAAkB,YAAW,QAAQ;IACzC,OAAO,CAAC,kBAAkB,CAAyB;IACnD,OAAO,CAAC,oBAAoB,CAG1B;IACF,OAAO,CAAC,sBAAsB,CAAuB;IACrD,OAAO,CAAC,YAAY,CAAgD;IACpE,OAAO,CAAC,iBAAiB,CAAyC;IAClE,OAAO,CAAC,gBAAgB,CAAkC;IAC1D,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,kBAAkB,CAA2B;;IAMrD,OAAO,CAAC,6BAA6B,CAmCnC;IAEF,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU;IAwGtC,KAAK,CAAC,MAAM,EAAE,UAAU;IAkG9B,OAAO,CAAC,qBAAqB;YAkBf,gBAAgB;YAOhB,iBAAiB;CAmChC;AAED,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"empirical-reporter.d.ts","sourceRoot":"","sources":["../../src/reporter/empirical-reporter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,UAAU,EACX,MAAM,2BAA2B,CAAC;AAuBnC,cAAM,iBAAkB,YAAW,QAAQ;IACzC,OAAO,CAAC,kBAAkB,CAAyB;IACnD,OAAO,CAAC,oBAAoB,CAG1B;IACF,OAAO,CAAC,sBAAsB,CAAuB;IACrD,OAAO,CAAC,YAAY,CAAgD;IACpE,OAAO,CAAC,iBAAiB,CAAyC;IAClE,OAAO,CAAC,gBAAgB,CAAkC;IAC1D,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,kBAAkB,CAA2B;;IAMrD,OAAO,CAAC,6BAA6B,CAqCnC;IAEF,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU;IAwGtC,KAAK,CAAC,MAAM,EAAE,UAAU;IAmG9B,OAAO,CAAC,qBAAqB;YAkBf,gBAAgB;YAOhB,iBAAiB;CAmChC;AAED,eAAe,iBAAiB,CAAC"}

package/dist/reporter/empirical-reporter.js

@@ -38,11 +38,12 @@ class EmpiricalReporter {
             logger_1.logger.error(`[Empirical Reporter] Attachment does not exist: ${attachment.path}`);
             return;
         }
+        this._attachmentCleanup.register(attachment);
         const relativePath = path_1.default.relative(this._testResultSourceDir, attachment.path);
         const destinationPath = `data/${relativePath}`;
         const publicUrl = await this._uploader.uploadFile(attachment.path, destinationPath);
         if (publicUrl) {
-            this._attachmentCleanup.track(attachment);
+            this._attachmentCleanup.markUploaded(attachment.path);
             return { [attachment.path]: publicUrl };
         }
     };
@@ -134,7 +135,7 @@ class EmpiricalReporter {
             return;
         if (!this._uploader)
             return;
-        logger_1.logger.debug(`[Empirical Reporter] Test run completed with status: ${result.status}`);
+        logger_1.logger.info(`[Empirical Reporter] Test run completed with status: ${result.status}`);
         logger_1.logger.debug(`[Empirical Reporter] State: cwd=${this._currentWorkingDir}, hasSharding=${this._hasSharding}`);
         const startTime = Date.now();
         const reportDir = path_1.default.join(this._currentWorkingDir, "playwright-report");
@@ -186,6 +187,7 @@ class EmpiricalReporter {
         else {
             logger_1.logger.info(`[Empirical Reporter] Sharding not enabled (HAS_SHARDING=${process.env.HAS_SHARDING})`);
         }
+        this._attachmentCleanup.logSummary();
         logger_1.logger.debug("[Empirical Reporter] All uploads finished");
         const timeDiff = Date.now() - startTime;
         logger_1.logger.debug("[Empirical Reporter] Time taken to upload after tests ended: ", timeDiff, "ms");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empiricalrun/playwright-utils",
-  "version": "0.46.4",
+  "version": "0.47.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/email.ts","./src/index.ts","./src/kv.ts","./src/logger.ts","./src/mailosaur-client.ts","./src/playwright-extensions.ts","./src/postgres.ts","./src/telemetry.ts","./src/webhook.ts","./src/auth/google.ts","./src/auth/index.ts","./src/auth/types.ts","./src/captcha/index.ts","./src/config/index.ts","./src/config/proxy.ts","./src/config/devices/types.ts","./src/overlay-tests/cache.spec.ts","./src/overlay-tests/click.spec.ts","./src/overlay-tests/fixtures.ts","./src/overlay-tests/patch.spec.ts","./src/reporter/attachment-cleanup.ts","./src/reporter/blob-utils.ts","./src/reporter/empirical-reporter.ts","./src/reporter/failing-line.ts","./src/reporter/harness.ts","./src/reporter/ibr-utils.ts","./src/reporter/incremental-blob-reporter.ts","./src/reporter/lifecycle-events.ts","./src/reporter/local-test.ts","./src/reporter/reporter-state.ts","./src/reporter/uploader.ts","./src/reporter/util.ts","./src/test/constants.ts","./src/test/coverage.ts","./src/test/index.ts","./src/test/types.ts","./src/test/video-labels.ts","./src/test/expect/index.ts","./src/test/expect/types.ts","./src/test/expect/visual.ts","./src/test/expect/webhook.ts","./src/test/scripts/agent-capabilities.ts","./src/test/scripts/index.ts","./src/test/scripts/locator-highlights.ts","./src/test/scripts/locator-vision.ts","./src/test/scripts/mouse-pointer.ts","./src/test/scripts/types.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/cache.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/index.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/prompt.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/types.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/utils.ts","./src/test/scripts/pw-locator-patch/highlight/click.ts","./src/test/scripts/pw-locator-patch/highlight/expect.ts","./src/test/scripts/pw-locator-patch/highlight/hover.ts","./src/test/scripts/pw-locator-patch/highlight/inner-text.ts","./src/test/scripts/pw-locator-patch/highlight/input-value.ts","./src/test/scripts/pw-locator-patch/highlight/is-checked.ts","./src/test/scripts/pw-locator-patch/highlight/is-disabled.ts","./src/test/scripts/pw-locator-patch/highlight/is-editable.ts","./src/test/scripts/pw-locator-patch/highlight/text-content.ts","./src/test/scripts/pw-locator-patch/utils/index.ts","./src/test/scripts/pw-locator-patch/vision/query.ts"],"version":"5.8.3"}
+{"root":["./src/email.ts","./src/index.ts","./src/kv.ts","./src/logger.ts","./src/mailosaur-client.ts","./src/playwright-extensions.ts","./src/postgres.ts","./src/telemetry.ts","./src/webhook.ts","./src/auth/google.ts","./src/auth/index.ts","./src/auth/types.ts","./src/captcha/index.ts","./src/config/index.ts","./src/config/proxy.ts","./src/config/devices/types.ts","./src/overlay-tests/cache.spec.ts","./src/overlay-tests/click.spec.ts","./src/overlay-tests/fixtures.ts","./src/overlay-tests/patch.spec.ts","./src/reporter/attachment-cleanup-test-reporter.ts","./src/reporter/attachment-cleanup.ts","./src/reporter/blob-utils.ts","./src/reporter/empirical-reporter.ts","./src/reporter/failing-line.ts","./src/reporter/harness.ts","./src/reporter/ibr-utils.ts","./src/reporter/incremental-blob-reporter.ts","./src/reporter/lifecycle-events.ts","./src/reporter/local-test.ts","./src/reporter/reporter-state.ts","./src/reporter/uploader.ts","./src/reporter/util.ts","./src/test/constants.ts","./src/test/coverage.ts","./src/test/index.ts","./src/test/types.ts","./src/test/video-labels.ts","./src/test/expect/index.ts","./src/test/expect/types.ts","./src/test/expect/visual.ts","./src/test/expect/webhook.ts","./src/test/scripts/agent-capabilities.ts","./src/test/scripts/index.ts","./src/test/scripts/locator-highlights.ts","./src/test/scripts/locator-vision.ts","./src/test/scripts/mouse-pointer.ts","./src/test/scripts/types.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/cache.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/index.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/prompt.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/types.ts","./src/test/scripts/pw-locator-patch/dismiss-overlays/utils.ts","./src/test/scripts/pw-locator-patch/highlight/click.ts","./src/test/scripts/pw-locator-patch/highlight/expect.ts","./src/test/scripts/pw-locator-patch/highlight/hover.ts","./src/test/scripts/pw-locator-patch/highlight/inner-text.ts","./src/test/scripts/pw-locator-patch/highlight/input-value.ts","./src/test/scripts/pw-locator-patch/highlight/is-checked.ts","./src/test/scripts/pw-locator-patch/highlight/is-disabled.ts","./src/test/scripts/pw-locator-patch/highlight/is-editable.ts","./src/test/scripts/pw-locator-patch/highlight/text-content.ts","./src/test/scripts/pw-locator-patch/utils/index.ts","./src/test/scripts/pw-locator-patch/vision/query.ts"],"version":"5.8.3"}