@trackunit/iris-app-playwright 0.1.34 → 0.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/iris-app-playwright",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "generators": "./generators.json",

package/src/fixtures/harRecording.fixture.d.ts

@@ -1,14 +1,55 @@
 /**
- * Adds Playwright HAR recording without permanently leaking the per-test HAR.
+ * Budget for the `context.close()` we issue after the test body. Closing is
+ * normally fast, but on a hard test timeout the page is often unresponsive and
+ * an unbounded close would consume this fixture's teardown budget. We bound it
+ * and move on; Playwright's built-in `context` teardown runs afterwards and
+ * awaits the real close within its own budget, so native video/trace
+ * persistence is never gated behind our close.
+ */
+export declare const CONTEXT_CLOSE_TIMEOUT_MS = 10000;
+/**
+ * Dedicated per-fixture teardown budget for the `context` override (see the tuple
+ * passed to `base.extend` below). Without it, this override's teardown draws from
+ * the single teardown budget shared with Playwright's built-in `context` teardown —
+ * so a slow close could starve native video/trace persistence. Giving the override
+ * its own budget decouples the two. It comfortably exceeds the bounded close; the
+ * unit test asserts that invariant.
+ */
+export declare const HAR_CONTEXT_FIXTURE_TIMEOUT_MS = 25000;
+/** Minimal structural view of the browser context teardown needs. */
+interface ClosableContext {
+    close(): Promise<void>;
+}
+/**
+ * Closes the context (bounded, best-effort).
+ *
+ * Extracted from the fixture so the teardown bounding can be unit tested without a
+ * browser. The bounded close guarantees we return control even if the page is hung,
+ * so Playwright's native context teardown (which persists video/trace) is never
+ * starved. The HAR is **not** handled here — `LogsReporter.onTestEnd` reads the raw
+ * HAR from `harRecordingPath` after all teardown, which is the only point that
+ * reliably runs after a late close flushes the HAR on the hard-timeout path.
+ */
+export declare const closeContextWithinBudget: (context: ClosableContext, options?: {
+    closeTimeoutMs?: number;
+}) => Promise<void>;
+/**
+ * Records a per-test HAR without leaking it into stored artifacts.
+ *
+ * `recordHar` (configured via `contextOptions`) only flushes the HAR to disk when
+ * the browser context closes. We record it to a temp path outside `outputDir`
+ * (see `harRecordingPath`) so a close that flushes late — e.g. during native
+ * teardown on a hard timeout — can never leak an unredacted HAR into uploaded
+ * artifacts. `LogsReporter.onTestEnd` is the single owner of that file: it runs
+ * after all teardown, redacts + retains it on failure, and always deletes the raw
+ * source. Persisting the HAR there (rather than via `testInfo.attach` during this
+ * fixture's teardown) is what makes a hard-timeout HAR survive — the attach seam
+ * ran before the late close flushed the file and lost it.
  *
- * `recordHar` (configured via `contextOptions`) only flushes the HAR to disk when the
- * browser context closes. Playwright tears fixtures down in reverse dependency order, so a
- * fixture that merely *depends on* `context` is torn down BEFORE the built-in `context`
- * fixture closes the context — at which point `testInfo.outputPath("test.har")` does not yet
- * exist and any cleanup there is a no-op (this was the original leak: a `test.har` survived
- * for every test). We therefore override `context` itself: after the test body we close the
- * context to flush the HAR, then attach + clean it up via `finalizeHarRecording`. The
- * built-in `context` teardown still runs afterwards — `close()` on an already-closed context
- * is a no-op — so trace/video/screenshot retain-on-failure are unaffected.
+ * The `context` override exists only to bound the close so a hung page can't starve
+ * native video/trace persistence; it carries its own `timeout`
+ * (`HAR_CONTEXT_FIXTURE_TIMEOUT_MS`) so its teardown draws from a dedicated budget
+ * rather than the one shared with the built-in `context` teardown.
  */
 export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export {};

package/src/fixtures/harRecording.fixture.js

@@ -1,32 +1,85 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.test = void 0;
+exports.test = exports.closeContextWithinBudget = exports.HAR_CONTEXT_FIXTURE_TIMEOUT_MS = exports.CONTEXT_CLOSE_TIMEOUT_MS = void 0;
+const tslib_1 = require("tslib");
 const test_1 = require("@playwright/test");
-const finalizeHarRecording_1 = require("./finalizeHarRecording");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const harRecordingPath_1 = require("../plugins/harRecordingPath");
+const withTimeout_1 = require("./withTimeout");
 /**
- * Adds Playwright HAR recording without permanently leaking the per-test HAR.
+ * Budget for the `context.close()` we issue after the test body. Closing is
+ * normally fast, but on a hard test timeout the page is often unresponsive and
+ * an unbounded close would consume this fixture's teardown budget. We bound it
+ * and move on; Playwright's built-in `context` teardown runs afterwards and
+ * awaits the real close within its own budget, so native video/trace
+ * persistence is never gated behind our close.
+ */
+exports.CONTEXT_CLOSE_TIMEOUT_MS = 10000;
+/**
+ * Dedicated per-fixture teardown budget for the `context` override (see the tuple
+ * passed to `base.extend` below). Without it, this override's teardown draws from
+ * the single teardown budget shared with Playwright's built-in `context` teardown —
+ * so a slow close could starve native video/trace persistence. Giving the override
+ * its own budget decouples the two. It comfortably exceeds the bounded close; the
+ * unit test asserts that invariant.
+ */
+exports.HAR_CONTEXT_FIXTURE_TIMEOUT_MS = 25000;
+/**
+ * Closes the context (bounded, best-effort).
  *
- * `recordHar` (configured via `contextOptions`) only flushes the HAR to disk when the
- * browser context closes. Playwright tears fixtures down in reverse dependency order, so a
- * fixture that merely *depends on* `context` is torn down BEFORE the built-in `context`
- * fixture closes the context — at which point `testInfo.outputPath("test.har")` does not yet
- * exist and any cleanup there is a no-op (this was the original leak: a `test.har` survived
- * for every test). We therefore override `context` itself: after the test body we close the
- * context to flush the HAR, then attach + clean it up via `finalizeHarRecording`. The
- * built-in `context` teardown still runs afterwards — `close()` on an already-closed context
- * is a no-op — so trace/video/screenshot retain-on-failure are unaffected.
+ * Extracted from the fixture so the teardown bounding can be unit tested without a
+ * browser. The bounded close guarantees we return control even if the page is hung,
+ * so Playwright's native context teardown (which persists video/trace) is never
+ * starved. The HAR is **not** handled here — `LogsReporter.onTestEnd` reads the raw
+ * HAR from `harRecordingPath` after all teardown, which is the only point that
+ * reliably runs after a late close flushes the HAR on the hard-timeout path.
+ */
+const closeContextWithinBudget = async (context, options = {}) => {
+    try {
+        await (0, withTimeout_1.withTimeout)(context.close(), options.closeTimeoutMs ?? exports.CONTEXT_CLOSE_TIMEOUT_MS);
+    }
+    catch {
+        // Bounded-out or failed close: leave it to Playwright's built-in context
+        // teardown to await the real close within its own budget.
+    }
+};
+exports.closeContextWithinBudget = closeContextWithinBudget;
+/**
+ * Records a per-test HAR without leaking it into stored artifacts.
+ *
+ * `recordHar` (configured via `contextOptions`) only flushes the HAR to disk when
+ * the browser context closes. We record it to a temp path outside `outputDir`
+ * (see `harRecordingPath`) so a close that flushes late — e.g. during native
+ * teardown on a hard timeout — can never leak an unredacted HAR into uploaded
+ * artifacts. `LogsReporter.onTestEnd` is the single owner of that file: it runs
+ * after all teardown, redacts + retains it on failure, and always deletes the raw
+ * source. Persisting the HAR there (rather than via `testInfo.attach` during this
+ * fixture's teardown) is what makes a hard-timeout HAR survive — the attach seam
+ * ran before the late close flushed the file and lost it.
+ *
+ * The `context` override exists only to bound the close so a hung page can't starve
+ * native video/trace persistence; it carries its own `timeout`
+ * (`HAR_CONTEXT_FIXTURE_TIMEOUT_MS`) so its teardown draws from a dedicated budget
+ * rather than the one shared with the built-in `context` teardown.
  */
 exports.test = test_1.test.extend({
     contextOptions: async ({ contextOptions }, provide, testInfo) => {
+        const harPath = (0, harRecordingPath_1.harRecordingPath)(testInfo);
+        // `recordHar` doesn't create the parent directory; ensure it exists since the
+        // path lives in a temp dir outside Playwright's managed output tree.
+        (0, fs_1.mkdirSync)(path.dirname(harPath), { recursive: true });
         await provide({
             ...contextOptions,
-            recordHar: { path: testInfo.outputPath(finalizeHarRecording_1.HAR_FILENAME), mode: "minimal" },
+            recordHar: { path: harPath, mode: "minimal" },
         });
     },
-    context: async ({ context }, provide, testInfo) => {
-        await provide(context);
-        await context.close();
-        await (0, finalizeHarRecording_1.finalizeHarRecording)(testInfo);
-    },
+    context: [
+        async ({ context }, provide) => {
+            await provide(context);
+            await (0, exports.closeContextWithinBudget)(context);
+        },
+        { scope: "test", timeout: exports.HAR_CONTEXT_FIXTURE_TIMEOUT_MS },
+    ],
 });
 //# sourceMappingURL=harRecording.fixture.js.map

package/src/fixtures/withTimeout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Races `operation` against a timer, rejecting if it doesn't settle within `ms`.
+ *
+ * Note: this does not cancel `operation` — it keeps running in the background.
+ * That is intentional for the HAR teardown path: a bounded `context.close()`
+ * returns control so Playwright's built-in context teardown can await the real
+ * close within its own budget, rather than our override hogging the shared
+ * teardown budget that native video/trace persistence depends on.
+ */
+export declare const withTimeout: <TResult>(operation: Promise<TResult>, ms: number) => Promise<TResult>;

package/src/fixtures/withTimeout.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = void 0;
+/**
+ * Races `operation` against a timer, rejecting if it doesn't settle within `ms`.
+ *
+ * Note: this does not cancel `operation` — it keeps running in the background.
+ * That is intentional for the HAR teardown path: a bounded `context.close()`
+ * returns control so Playwright's built-in context teardown can await the real
+ * close within its own budget, rather than our override hogging the shared
+ * teardown budget that native video/trace persistence depends on.
+ */
+const withTimeout = async (operation, ms) => {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`withTimeout: operation exceeded ${ms}ms`)), ms);
+    });
+    try {
+        return await Promise.race([operation, timeout]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+};
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=withTimeout.js.map

package/src/plugins/harRecordingPath.d.ts

@@ -0,0 +1,26 @@
+/** Name of the per-test HAR file written by `recordHar`. */
+export declare const HAR_FILENAME = "test.har";
+/**
+ * Identifies a single test attempt. `testId` is Playwright's `TestInfo.testId`,
+ * which is documented to equal `TestCase.id` in the reporter API — so the
+ * `harRecording` fixture (which has `TestInfo`) and `LogsReporter` (which has
+ * `TestCase`/`TestResult`) compute the exact same path for the same attempt.
+ */
+export interface HarRecordingPathInfo {
+    testId: string;
+    retry: number;
+}
+/**
+ * Absolute path the per-test HAR is recorded to, deliberately **outside** the
+ * Playwright `outputDir` (which is uploaded wholesale as CI artifacts).
+ *
+ * `recordHar` only flushes when the browser context closes, and on a hard test
+ * timeout that close completes during Playwright's native context teardown —
+ * after the `harRecording` fixture's own teardown has already run. Recording
+ * here (a temp dir, never uploaded) means that late flush writes a raw,
+ * unredacted HAR (it carries Authorization/Cookie) somewhere CI never stores.
+ * `LogsReporter.onTestEnd` runs after all teardown, reads this path, and writes
+ * only the **redacted** copy into the artifacts `hars/` folder. Keyed by
+ * `testId` + `retry` so parallel workers and retries never collide.
+ */
+export declare const harRecordingPath: (info: HarRecordingPathInfo) => string;

package/src/plugins/harRecordingPath.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.harRecordingPath = exports.HAR_FILENAME = void 0;
+const tslib_1 = require("tslib");
+const os_1 = require("os");
+const path = tslib_1.__importStar(require("path"));
+/** Name of the per-test HAR file written by `recordHar`. */
+exports.HAR_FILENAME = "test.har";
+/**
+ * Absolute path the per-test HAR is recorded to, deliberately **outside** the
+ * Playwright `outputDir` (which is uploaded wholesale as CI artifacts).
+ *
+ * `recordHar` only flushes when the browser context closes, and on a hard test
+ * timeout that close completes during Playwright's native context teardown —
+ * after the `harRecording` fixture's own teardown has already run. Recording
+ * here (a temp dir, never uploaded) means that late flush writes a raw,
+ * unredacted HAR (it carries Authorization/Cookie) somewhere CI never stores.
+ * `LogsReporter.onTestEnd` runs after all teardown, reads this path, and writes
+ * only the **redacted** copy into the artifacts `hars/` folder. Keyed by
+ * `testId` + `retry` so parallel workers and retries never collide.
+ */
+const harRecordingPath = (info) => path.join((0, os_1.tmpdir)(), "tu-iris-playwright-har", `${info.testId}-attempt-${info.retry}.${exports.HAR_FILENAME}`);
+exports.harRecordingPath = harRecordingPath;
+//# sourceMappingURL=harRecordingPath.js.map

package/src/plugins/logsReporter.d.ts

@@ -42,14 +42,23 @@ export declare class LogsReporter implements Reporter {
     onEnd(_result: FullResult): Promise<void>;
     /** Returns false so Playwright adds its own terminal reporter alongside this one. */
     printsToStdio(): boolean;
+    private getResultTracePath;
     /**
-     * Returns the HAR attachment path for *this specific result*. Looking at
-     * `test.results.flatMap(r => r.attachments)` would mix attachments across
-     * retries — on a retry, the first attempt's HAR could be retained instead
-     * of (or alongside) the current attempt's HAR. Per-result scoping keeps
-     * each attempt's artifacts paired with its own log file.
+     * Persists (on failure) or cleans up (always) the per-test HAR recorded by the
+     * `harRecording` fixture.
+     *
+     * The raw HAR is recorded to a deterministic temp path outside `outputDir`
+     * (see `harRecordingPath`). `recordHar` only flushes it when the browser
+     * context closes — and on a hard timeout that close completes during
+     * Playwright's *native* context teardown, after the fixture's own teardown has
+     * bounded out. Because `onTestEnd` runs after all teardown, the file is
+     * reliably present here regardless of how late the close flushed: this is what
+     * makes a hard-timeout HAR survive (the earlier `testInfo.attach` seam ran too
+     * early on that path and lost it). On failure we redact (the HAR carries
+     * Authorization/Cookie and request/response bodies) and move it into the shared
+     * `hars/` artifacts folder; in every case we delete the raw temp source via
+     * `finally` so an unredacted HAR never lingers on disk, even if redaction throws.
      */
-    private getResultHarPath;
-    private getResultTracePath;
+    private persistHar;
 }
 export default LogsReporter;

package/src/plugins/logsReporter.js

@@ -6,6 +6,7 @@ const fs_1 = require("fs");
 const path = tslib_1.__importStar(require("path"));
 const fileNameBuilder_1 = require("../utils/fileNameBuilder");
 const createLogFile_1 = require("./createLogFile");
+const harRecordingPath_1 = require("./harRecordingPath");
 const redactHar_1 = require("./redactHar");
 const redactSensitive_1 = require("./redactSensitive");
 const redactTrace_1 = require("./redactTrace");
@@ -41,7 +42,8 @@ class LogsReporter {
         const describeTitle = titlePath.slice(0, -1).join(" > ");
         const testTitle = test.title;
         const fullTitle = describeTitle ? `${describeTitle} - ${testTitle}` : testTitle;
-        if (result.status === "failed" || result.status === "timedOut") {
+        const isFailure = result.status === "failed" || result.status === "timedOut";
+        if (isFailure) {
             const fileName = (0, fileNameBuilder_1.fileNameBuilder)(fullTitle, "failed", result.retry);
             const logs = result.stdout.concat(result.stderr).map(entry => {
                 const message = typeof entry === "string" ? entry : entry.toString();
@@ -52,19 +54,6 @@ class LogsReporter {
                 };
             });
             this.pendingWrites.push((0, createLogFile_1.createLogFile)(this.nxRoot, this.logsFolder, fileName, logs, this.formatter));
-            if (this.harsFolder !== undefined) {
-                const tempHarPath = this.getResultHarPath(result);
-                if (tempHarPath !== undefined && (0, fs_1.existsSync)(tempHarPath)) {
-                    if (!(0, fs_1.existsSync)(this.harsFolder)) {
-                        (0, fs_1.mkdirSync)(this.harsFolder, { recursive: true });
-                    }
-                    const harFileName = `${(0, fileNameBuilder_1.fileNameBuilder)(fullTitle, "failed", result.retry)}.har`;
-                    // HARs include Authorization, Cookie, and request/response bodies for
-                    // authenticated traffic. Redact before moving to the shared artifacts folder.
-                    (0, redactHar_1.redactHarFile)(tempHarPath, path.join(this.harsFolder, harFileName));
-                    (0, fs_1.rmSync)(tempHarPath);
-                }
-            }
             // Defense in depth for trace artifacts: `login()`'s slow path does
             // `page.goto("/auth/manager-classic#session_token=...")`, and Playwright
             // records the full `goto` URL as the action argument. With
@@ -78,12 +67,7 @@ class LogsReporter {
                 this.pendingWrites.push((0, redactTrace_1.redactTraceFile)(tracePath));
             }
         }
-        else if (this.harsFolder !== undefined) {
-            const tempHarPath = this.getResultHarPath(result);
-            if (tempHarPath !== undefined && (0, fs_1.existsSync)(tempHarPath)) {
-                (0, fs_1.rmSync)(tempHarPath);
-            }
-        }
+        this.persistHar(fullTitle, test, result, isFailure);
     }
     /**
      * Awaits in-flight log writes started in `onTestEnd` before the reporter
@@ -98,21 +82,44 @@ class LogsReporter {
     printsToStdio() {
         return false;
     }
-    /**
-     * Returns the HAR attachment path for *this specific result*. Looking at
-     * `test.results.flatMap(r => r.attachments)` would mix attachments across
-     * retries — on a retry, the first attempt's HAR could be retained instead
-     * of (or alongside) the current attempt's HAR. Per-result scoping keeps
-     * each attempt's artifacts paired with its own log file.
-     */
-    getResultHarPath(result) {
-        const attachment = result.attachments.find(a => a.name === "har" && a.path !== undefined);
-        return attachment?.path;
-    }
     getResultTracePath(result) {
         const attachment = result.attachments.find(a => a.name === "trace" && a.path !== undefined);
         return attachment?.path;
     }
+    /**
+     * Persists (on failure) or cleans up (always) the per-test HAR recorded by the
+     * `harRecording` fixture.
+     *
+     * The raw HAR is recorded to a deterministic temp path outside `outputDir`
+     * (see `harRecordingPath`). `recordHar` only flushes it when the browser
+     * context closes — and on a hard timeout that close completes during
+     * Playwright's *native* context teardown, after the fixture's own teardown has
+     * bounded out. Because `onTestEnd` runs after all teardown, the file is
+     * reliably present here regardless of how late the close flushed: this is what
+     * makes a hard-timeout HAR survive (the earlier `testInfo.attach` seam ran too
+     * early on that path and lost it). On failure we redact (the HAR carries
+     * Authorization/Cookie and request/response bodies) and move it into the shared
+     * `hars/` artifacts folder; in every case we delete the raw temp source via
+     * `finally` so an unredacted HAR never lingers on disk, even if redaction throws.
+     */
+    persistHar(fullTitle, test, result, isFailure) {
+        const harPath = (0, harRecordingPath_1.harRecordingPath)({ testId: test.id, retry: result.retry });
+        if (!(0, fs_1.existsSync)(harPath)) {
+            return;
+        }
+        try {
+            if (isFailure && this.harsFolder !== undefined) {
+                if (!(0, fs_1.existsSync)(this.harsFolder)) {
+                    (0, fs_1.mkdirSync)(this.harsFolder, { recursive: true });
+                }
+                const harFileName = `${(0, fileNameBuilder_1.fileNameBuilder)(fullTitle, "failed", result.retry)}.har`;
+                (0, redactHar_1.redactHarFile)(harPath, path.join(this.harsFolder, harFileName));
+            }
+        }
+        finally {
+            (0, fs_1.rmSync)(harPath, { force: true });
+        }
+    }
 }
 exports.LogsReporter = LogsReporter;
 exports.default = LogsReporter;

package/src/fixtures/finalizeHarRecording.d.ts

@@ -1,27 +0,0 @@
-/** Name of the per-test HAR file written by `recordHar` and read by `LogsReporter`. */
-export declare const HAR_FILENAME = "test.har";
-/**
- * Minimal slice of Playwright's `TestInfo` needed to finalize HAR recording.
- * Declared structurally so the behavior can be unit-tested without constructing
- * a full `TestInfo`; the real `TestInfo` satisfies it.
- */
-export interface HarTestInfo {
-    outputPath(...pathSegments: Array<string>): string;
-    attach(name: string, options: {
-        path: string;
-    }): Promise<void>;
-}
-/**
- * Attaches the per-test HAR (so it appears in the HTML report and is discoverable
- * by `LogsReporter`), then deletes the original `recordHar` output file.
- *
- * `recordHar` writes the HAR to `testInfo.outputPath("test.har")`. `testInfo.attach`
- * copies that file into Playwright's managed attachments location and points the
- * attachment at the copy — which is the only path `LogsReporter` ever sees and
- * cleans up (deleted on pass, redacted and retained on failure). The original file
- * is left untouched, so without this deletion every test (passing included) leaks a
- * `test.har` into the persisted workspace and stored CI artifacts, growing with the
- * suite. Removing it here closes the leak while leaving the attachment copy for the
- * reporter to retain on failure.
- */
-export declare const finalizeHarRecording: (testInfo: HarTestInfo) => Promise<void>;

package/src/fixtures/finalizeHarRecording.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.finalizeHarRecording = exports.HAR_FILENAME = void 0;
-const fs_1 = require("fs");
-/** Name of the per-test HAR file written by `recordHar` and read by `LogsReporter`. */
-exports.HAR_FILENAME = "test.har";
-/**
- * Attaches the per-test HAR (so it appears in the HTML report and is discoverable
- * by `LogsReporter`), then deletes the original `recordHar` output file.
- *
- * `recordHar` writes the HAR to `testInfo.outputPath("test.har")`. `testInfo.attach`
- * copies that file into Playwright's managed attachments location and points the
- * attachment at the copy — which is the only path `LogsReporter` ever sees and
- * cleans up (deleted on pass, redacted and retained on failure). The original file
- * is left untouched, so without this deletion every test (passing included) leaks a
- * `test.har` into the persisted workspace and stored CI artifacts, growing with the
- * suite. Removing it here closes the leak while leaving the attachment copy for the
- * reporter to retain on failure.
- */
-const finalizeHarRecording = async (testInfo) => {
-    const harPath = testInfo.outputPath(exports.HAR_FILENAME);
-    if (!(0, fs_1.existsSync)(harPath)) {
-        return;
-    }
-    await testInfo.attach("har", { path: harPath });
-    (0, fs_1.rmSync)(harPath, { force: true });
-};
-exports.finalizeHarRecording = finalizeHarRecording;
-//# sourceMappingURL=finalizeHarRecording.js.map