@elliemae/encw-leak-runner 1.0.13 → 1.0.15

package/dist/bin/leak-runner.js

@@ -4,15 +4,163 @@
 import { Command } from "commander";
 
 // lib/runner/scenarioRunner.ts
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import {
   chromium
 } from "@playwright/test";
 import { AuthManager, PageSetup } from "@elliemae/smoked-suite";
 
+// lib/browser/heapMemoryProfiler.ts
+import fs from "node:fs";
+import path from "node:path";
+import { HeapDoctor } from "@elliemae/encw-heap-doctor";
+var HeapMemoryProfiler = class {
+  /**
+   * @param {Page} page      - The Playwright `Page` instance for the current test.
+   * @param {string} outputDir - Directory where `.heapsnapshot` and `.md` files are written.
+   *                    Created automatically if it does not exist.
+   */
+  constructor(page, outputDir) {
+    this.page = page;
+    this.outputDir = outputDir;
+  }
+  /** Memento store: maps snapshot label → absolute file path on disk. */
+  snapshots = /* @__PURE__ */ new Map();
+  getCDPTarget() {
+    return this.page;
+  }
+  // ─── Browser guard ──────────────────────────────────────────────────────────
+  isChromium() {
+    return this.page.context().browser()?.browserType().name() === "chromium";
+  }
+  // ─── Public API ─────────────────────────────────────────────────────────────
+  /**
+   * Capture a Chrome heap snapshot via CDP and persist it to disk.
+   *
+   * The snapshot is streamed in chunks via `HeapProfiler.addHeapSnapshotChunk`,
+   * joined, and written as a single `.heapsnapshot` file. The file path is cached
+   * internally under `label` so {@link compare} can resolve it by name.
+   * @param {string} label - Logical name for this snapshot (e.g. `'before'`, `'after'`).
+   *                Used as the filename prefix and as the Memento key.
+   * @returns {Promise<string>} Absolute path to the written file, or `''` on non-Chromium browsers.
+   */
+  async captureSnapshot(label) {
+    if (!this.isChromium()) return "";
+    const client = await this.page.context().newCDPSession(this.getCDPTarget());
+    await client.send("HeapProfiler.enable");
+    fs.mkdirSync(this.outputDir, { recursive: true });
+    const filePath = path.join(
+      this.outputDir,
+      `${label}-${Date.now()}.heapsnapshot`
+    );
+    const writeStream = fs.createWriteStream(filePath);
+    client.on(
+      "HeapProfiler.addHeapSnapshotChunk",
+      ({ chunk }) => {
+        writeStream.write(chunk);
+      }
+    );
+    await client.send("HeapProfiler.takeHeapSnapshot", {
+      reportProgress: false
+    });
+    await client.send("HeapProfiler.disable");
+    await client.detach();
+    await new Promise((resolve, reject) => {
+      writeStream.end((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    this.snapshots.set(label, filePath);
+    return filePath;
+  }
+  /**
+   * Compare two previously captured snapshots by their labels.
+   *
+   * Runs `HeapDoctor.compare()` on the resolved file paths and writes a
+   * markdown report to {@link outputDir}.
+   * @param {CompareParams} params - {@link CompareParams}
+   * @returns {Promise<ComparisonReport | null>} `ComparisonReport`, or `null` on non-Chromium browsers.
+   * @throws If either label has no cached snapshot path.
+   * @throws If `HeapDoctor.compare` returns `ok: false`.
+   */
+  async compare(params) {
+    const { beforeLabel, afterLabel, topN, originAllowList } = params;
+    if (!this.isChromium()) return null;
+    const before = this.snapshots.get(beforeLabel);
+    const after = this.snapshots.get(afterLabel);
+    if (!before || !after) {
+      throw new Error(
+        `HeapMemoryProfiler: snapshot not found for labels "${beforeLabel}" / "${afterLabel}". Call captureSnapshot() before compare().`
+      );
+    }
+    const result = await new HeapDoctor({ topN, originAllowList }).compare(
+      before,
+      after
+    );
+    if (!result.ok) throw result.error;
+    fs.writeFileSync(
+      path.join(this.outputDir, `comparison-${Date.now()}.md`),
+      result.value.markdown
+    );
+    return result.value;
+  }
+  /**
+   * Orchestrate the full heap profiling sequence for a user flow.
+   *
+   * Sequence (Template Method):
+   * 1. Capture **before** snapshot
+   * 2. Execute `flow` exactly `heapIterations` times
+   * 3. Capture **after** snapshot
+   * 4. Run `HeapDoctor.compare` and write the markdown report
+   * 5. If `failOnLeak` is `true` and `retainedSizeDelta > leakThresholdBytes`, throw
+   *
+   * On non-Chromium browsers: `flow` still runs `heapIterations` times,
+   * no snapshots are taken, and `null` is returned.
+   * @param {() => Promise<void>} flow    - Async function containing the user actions to profile.
+   * @param {HeapProfilingOptions} [options] - {@link HeapProfilingOptions}
+   * @returns {Promise<ComparisonReport | null>} `ComparisonReport` on Chromium, `null` on all other browsers.
+   */
+  async withProfiling(flow, options = {}) {
+    const {
+      heapIterations = 1,
+      label = "flow",
+      topN,
+      failOnLeak = false,
+      leakThresholdBytes = 0,
+      originAllowList
+    } = options;
+    if (!this.isChromium()) {
+      for (let i = 0; i < heapIterations; i += 1) await flow();
+      return null;
+    }
+    await this.captureSnapshot(`${label}-before`);
+    for (let i = 0; i < heapIterations; i += 1) await flow();
+    await this.captureSnapshot(`${label}-after`);
+    const report = await this.compare({
+      beforeLabel: `${label}-before`,
+      afterLabel: `${label}-after`,
+      topN,
+      originAllowList
+    });
+    if (report && failOnLeak && report.delta.retainedSizeDelta > leakThresholdBytes) {
+      throw new Error(
+        `Memory leak detected: retained size grew by ${report.delta.retainedSizeDelta} bytes (threshold: ${leakThresholdBytes} bytes). New leak groups: ${report.delta.newLeakGroups.length}. See: ${this.outputDir}`
+      );
+    }
+    return report;
+  }
+  /**
+   * Clear the internal snapshot label cache.
+   * Call in `afterEach` to prevent snapshot paths bleeding across tests.
+   */
+  clearSnapshots() {
+    this.snapshots.clear();
+  }
+};
+
 // lib/browser/iframeHeapProfiler.ts
-import { HeapMemoryProfiler } from "@elliemae/smoked-suite";
 var IframeHeapProfiler = class extends HeapMemoryProfiler {
   constructor(profiledPage, frame, outputDir) {
     super(profiledPage, outputDir);
@@ -104,8 +252,8 @@ async function forceGarbageCollection(page) {
   await page.waitForTimeout(2e3);
 }
 function cleanupSnapshots(paths) {
-  if (paths.before && fs.existsSync(paths.before)) fs.unlinkSync(paths.before);
-  if (paths.after && fs.existsSync(paths.after)) fs.unlinkSync(paths.after);
+  if (paths.before && fs2.existsSync(paths.before)) fs2.unlinkSync(paths.before);
+  if (paths.after && fs2.existsSync(paths.after)) fs2.unlinkSync(paths.after);
 }
 var ScenarioRunner = class {
   constructor(config) {
@@ -135,7 +283,7 @@ var ScenarioRunner = class {
     return this.buildResult({ scenario, report, error, startTime });
   }
   async runScenarioInPage(page, scenario, paths) {
-    const snapshotsDir = path.join(this.config.runner.outputDir, "snapshots");
+    const snapshotsDir = path2.join(this.config.runner.outputDir, "snapshots");
     const { profiler, frame } = await this.setupAndProfile(
       page,
       scenario,
@@ -146,11 +294,12 @@ var ScenarioRunner = class {
     await this.repeatScenarioActions(scenario, page, frame);
     await forceGarbageCollection(page);
     paths.after = await profiler.captureSnapshot("after");
-    const report = await profiler.compare(
-      "before",
-      "after",
-      this.config.runner.topN
-    );
+    const report = await profiler.compare({
+      beforeLabel: "before",
+      afterLabel: "after",
+      topN: this.config.runner.topN,
+      originAllowList: [new URL(this.config.env.baseUrl).origin]
+    });
     if (report) await this.writeReport(report, scenario);
     return report;
   }
@@ -166,13 +315,15 @@ var ScenarioRunner = class {
     });
     process.stderr.write(`[scenarioRunner] post-login URL = ${page.url()}
 `);
-    await page.waitForURL(`**${scenario.url()}**`, { timeout: 3e4 });
+    if (!page.url().includes(scenario.url())) {
+      await page.goto(scenario.url(), { waitUntil: "load", timeout: 3e4 });
+    }
     process.stderr.write(
       `[scenarioRunner] settled URL before iframe = ${page.url()}
 `
     );
     const frame = await resolveIframe(page, scenario.microappSelector);
-    fs.mkdirSync(snapshotsDir, { recursive: true });
+    fs2.mkdirSync(snapshotsDir, { recursive: true });
     const profiler = new IframeHeapProfiler(page, frame, snapshotsDir);
     return { profiler, frame };
   }
@@ -186,17 +337,17 @@ var ScenarioRunner = class {
     }
   }
   async writeReport(report, scenario) {
-    const reportPath = path.join(
+    const reportPath = path2.join(
       this.config.runner.outputDir,
       `${scenario.id}.md`
     );
-    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+    fs2.mkdirSync(path2.dirname(reportPath), { recursive: true });
     const markdown = await enhanceMarkdownIfConfigured(
       report,
       this.config,
       scenario.name
     );
-    fs.writeFileSync(reportPath, markdown);
+    fs2.writeFileSync(reportPath, markdown);
   }
   buildResult(input) {
     const { scenario, report, error, startTime } = input;
@@ -312,8 +463,8 @@ var ConsoleReporter = class {
 };
 
 // lib/reporting/junitReporter.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 function escapeXml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -349,8 +500,8 @@ var JunitReporter = class {
       "  </testsuite>",
       "</testsuites>"
     ].join("\n");
-    fs2.mkdirSync(outputDir, { recursive: true });
-    fs2.writeFileSync(path2.join(outputDir, "test-results.xml"), xml, "utf8");
+    fs3.mkdirSync(outputDir, { recursive: true });
+    fs3.writeFileSync(path3.join(outputDir, "test-results.xml"), xml, "utf8");
     return Promise.resolve();
   }
 };
@@ -398,7 +549,7 @@ var EnvVarConfigSource = class {
 };
 
 // lib/config/sources/fileConfigSource.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 
 // lib/config/runnerConfigSchema.ts
 import { z } from "zod";
@@ -428,8 +579,8 @@ var FileConfigSource = class {
   priority = 1;
   name = "file";
   load() {
-    if (!fs3.existsSync(this.filePath)) return {};
-    const raw = fs3.readFileSync(this.filePath, "utf8");
+    if (!fs4.existsSync(this.filePath)) return {};
+    const raw = fs4.readFileSync(this.filePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -805,8 +956,8 @@ var exportNavigationScenario = {
     await page.frameLocator(IFRAME_SELECTOR2).getByText("ONE ADMIN CONSOLE").waitFor({ state: "visible", timeout: 12e4 });
   },
   async action(page, frame) {
-    const path3 = new URL(page.url()).pathname.replace(/\/$/, "");
-    if (path3 === "/admin") {
+    const path4 = new URL(page.url()).pathname.replace(/\/$/, "");
+    if (path4 === "/admin") {
       await page.frameLocator(IFRAME_SELECTOR2).getByText("ONE ADMIN CONSOLE").click();
     }
     const settings = new SelectSettingsPageModel(frame);
@@ -832,12 +983,90 @@ var exportNavigationScenario = {
 var oneAdminScenarios = [
   exportNavigationScenario
 ];
-
-// lib/scenarios/index.ts
-var scenarioRegistry = new ScenarioRegistry().register({
+var oneAdminScenarioGroup = {
   microapp: "one-admin",
   scenarios: oneAdminScenarios
-});
+};
+
+// lib/scenarios/pipeline/page-models/PipelinePageModel.ts
+var PipelinePageModel = class _PipelinePageModel {
+  constructor(page) {
+    this.page = page;
+  }
+  static IFRAME_SELECTOR = '[data-testid="pui-iframe-container-pipelineui"]';
+  static TASKS_IFRAME_SELECTOR = '[data-testid="pui-iframe-container-taskspipeline"]';
+  static SPINNER_TEST_ID = "ds-circularindeterminateindicator-svg";
+  async waitForPipelineReady() {
+    await this.#waitForSpinner(_PipelinePageModel.IFRAME_SELECTOR);
+  }
+  async clickTasksTab() {
+    await this.page.getByRole("tab", { name: "Tasks" }).click();
+  }
+  async clickPipelineTab() {
+    await this.page.getByRole("tab", { name: "Loans" }).click();
+  }
+  async waitForPipelineSpinner() {
+    await this.#waitForSpinner(_PipelinePageModel.IFRAME_SELECTOR);
+  }
+  async waitForTasksReady() {
+    await this.page.locator(_PipelinePageModel.TASKS_IFRAME_SELECTOR).contentFrame().getByTestId("circular-indicator").waitFor({ state: "hidden" });
+  }
+  async #waitForSpinner(iframeSelector) {
+    const spinner = this.page.frameLocator(iframeSelector).getByTestId(_PipelinePageModel.SPINNER_TEST_ID);
+    await spinner.waitFor({ state: "visible" });
+    await spinner.waitFor({ state: "hidden" });
+  }
+};
+
+// lib/scenarios/pipeline/pipeline-task-navigation.scenario.ts
+var pipelineTaskNavigationScenario = {
+  id: "pipeline-task-navigation",
+  name: "Pipeline Task Navigation",
+  description: "Navigate to pipeline task details and come back - verify iframe GC",
+  tags: ["critical"],
+  microappSelector: PipelinePageModel.IFRAME_SELECTOR,
+  url: () => "/pipeline",
+  async setup(page) {
+    await AdminLandingPageModel.acceptCookiesIfShown(page);
+    const pipeline = new PipelinePageModel(page);
+    await pipeline.waitForPipelineReady();
+  },
+  async action(page) {
+    const pipeline = new PipelinePageModel(page);
+    const path4 = new URL(page.url()).pathname.replace(/\/$/, "");
+    if (path4 === "/pipeline") {
+      await pipeline.clickTasksTab();
+    }
+    await pipeline.waitForTasksReady();
+  },
+  async back(page) {
+    const pipeline = new PipelinePageModel(page);
+    await pipeline.clickPipelineTab();
+    await pipeline.waitForPipelineSpinner();
+  },
+  repeat: () => 1,
+  thresholds: {
+    maxRetainedSizeDeltaBytes: 10 * 1024 * 1024,
+    maxNewLeakGroups: 0
+  }
+};
+
+// lib/scenarios/pipeline/index.ts
+var pipelineScenarios = [
+  pipelineTaskNavigationScenario
+];
+var pipelineScenarioGroup = {
+  microapp: "pipeline",
+  scenarios: pipelineScenarios
+};
+
+// lib/scenarios/index.ts
+var scenarioRegistry = (() => {
+  const registry = new ScenarioRegistry();
+  registry.register(oneAdminScenarioGroup);
+  registry.register(pipelineScenarioGroup);
+  return registry;
+})();
 
 // lib/cli/index.ts
 function buildProgram(deps = defaultDeps()) {

package/dist/cjs/browser/heapMemoryProfiler.js

@@ -0,0 +1,182 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var heapMemoryProfiler_exports = {};
+__export(heapMemoryProfiler_exports, {
+  HeapMemoryProfiler: () => HeapMemoryProfiler
+});
+module.exports = __toCommonJS(heapMemoryProfiler_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_encw_heap_doctor = require("@elliemae/encw-heap-doctor");
+class HeapMemoryProfiler {
+  /**
+   * @param {Page} page      - The Playwright `Page` instance for the current test.
+   * @param {string} outputDir - Directory where `.heapsnapshot` and `.md` files are written.
+   *                    Created automatically if it does not exist.
+   */
+  constructor(page, outputDir) {
+    this.page = page;
+    this.outputDir = outputDir;
+  }
+  page;
+  outputDir;
+  /** Memento store: maps snapshot label → absolute file path on disk. */
+  snapshots = /* @__PURE__ */ new Map();
+  getCDPTarget() {
+    return this.page;
+  }
+  // ─── Browser guard ──────────────────────────────────────────────────────────
+  isChromium() {
+    return this.page.context().browser()?.browserType().name() === "chromium";
+  }
+  // ─── Public API ─────────────────────────────────────────────────────────────
+  /**
+   * Capture a Chrome heap snapshot via CDP and persist it to disk.
+   *
+   * The snapshot is streamed in chunks via `HeapProfiler.addHeapSnapshotChunk`,
+   * joined, and written as a single `.heapsnapshot` file. The file path is cached
+   * internally under `label` so {@link compare} can resolve it by name.
+   * @param {string} label - Logical name for this snapshot (e.g. `'before'`, `'after'`).
+   *                Used as the filename prefix and as the Memento key.
+   * @returns {Promise<string>} Absolute path to the written file, or `''` on non-Chromium browsers.
+   */
+  async captureSnapshot(label) {
+    if (!this.isChromium()) return "";
+    const client = await this.page.context().newCDPSession(this.getCDPTarget());
+    await client.send("HeapProfiler.enable");
+    import_node_fs.default.mkdirSync(this.outputDir, { recursive: true });
+    const filePath = import_node_path.default.join(
+      this.outputDir,
+      `${label}-${Date.now()}.heapsnapshot`
+    );
+    const writeStream = import_node_fs.default.createWriteStream(filePath);
+    client.on(
+      "HeapProfiler.addHeapSnapshotChunk",
+      ({ chunk }) => {
+        writeStream.write(chunk);
+      }
+    );
+    await client.send("HeapProfiler.takeHeapSnapshot", {
+      reportProgress: false
+    });
+    await client.send("HeapProfiler.disable");
+    await client.detach();
+    await new Promise((resolve, reject) => {
+      writeStream.end((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    this.snapshots.set(label, filePath);
+    return filePath;
+  }
+  /**
+   * Compare two previously captured snapshots by their labels.
+   *
+   * Runs `HeapDoctor.compare()` on the resolved file paths and writes a
+   * markdown report to {@link outputDir}.
+   * @param {CompareParams} params - {@link CompareParams}
+   * @returns {Promise<ComparisonReport | null>} `ComparisonReport`, or `null` on non-Chromium browsers.
+   * @throws If either label has no cached snapshot path.
+   * @throws If `HeapDoctor.compare` returns `ok: false`.
+   */
+  async compare(params) {
+    const { beforeLabel, afterLabel, topN, originAllowList } = params;
+    if (!this.isChromium()) return null;
+    const before = this.snapshots.get(beforeLabel);
+    const after = this.snapshots.get(afterLabel);
+    if (!before || !after) {
+      throw new Error(
+        `HeapMemoryProfiler: snapshot not found for labels "${beforeLabel}" / "${afterLabel}". Call captureSnapshot() before compare().`
+      );
+    }
+    const result = await new import_encw_heap_doctor.HeapDoctor({ topN, originAllowList }).compare(
+      before,
+      after
+    );
+    if (!result.ok) throw result.error;
+    import_node_fs.default.writeFileSync(
+      import_node_path.default.join(this.outputDir, `comparison-${Date.now()}.md`),
+      result.value.markdown
+    );
+    return result.value;
+  }
+  /**
+   * Orchestrate the full heap profiling sequence for a user flow.
+   *
+   * Sequence (Template Method):
+   * 1. Capture **before** snapshot
+   * 2. Execute `flow` exactly `heapIterations` times
+   * 3. Capture **after** snapshot
+   * 4. Run `HeapDoctor.compare` and write the markdown report
+   * 5. If `failOnLeak` is `true` and `retainedSizeDelta > leakThresholdBytes`, throw
+   *
+   * On non-Chromium browsers: `flow` still runs `heapIterations` times,
+   * no snapshots are taken, and `null` is returned.
+   * @param {() => Promise<void>} flow    - Async function containing the user actions to profile.
+   * @param {HeapProfilingOptions} [options] - {@link HeapProfilingOptions}
+   * @returns {Promise<ComparisonReport | null>} `ComparisonReport` on Chromium, `null` on all other browsers.
+   */
+  async withProfiling(flow, options = {}) {
+    const {
+      heapIterations = 1,
+      label = "flow",
+      topN,
+      failOnLeak = false,
+      leakThresholdBytes = 0,
+      originAllowList
+    } = options;
+    if (!this.isChromium()) {
+      for (let i = 0; i < heapIterations; i += 1) await flow();
+      return null;
+    }
+    await this.captureSnapshot(`${label}-before`);
+    for (let i = 0; i < heapIterations; i += 1) await flow();
+    await this.captureSnapshot(`${label}-after`);
+    const report = await this.compare({
+      beforeLabel: `${label}-before`,
+      afterLabel: `${label}-after`,
+      topN,
+      originAllowList
+    });
+    if (report && failOnLeak && report.delta.retainedSizeDelta > leakThresholdBytes) {
+      throw new Error(
+        `Memory leak detected: retained size grew by ${report.delta.retainedSizeDelta} bytes (threshold: ${leakThresholdBytes} bytes). New leak groups: ${report.delta.newLeakGroups.length}. See: ${this.outputDir}`
+      );
+    }
+    return report;
+  }
+  /**
+   * Clear the internal snapshot label cache.
+   * Call in `afterEach` to prevent snapshot paths bleeding across tests.
+   */
+  clearSnapshots() {
+    this.snapshots.clear();
+  }
+}

package/dist/cjs/browser/iframeHeapProfiler.js

@@ -21,8 +21,8 @@ __export(iframeHeapProfiler_exports, {
   IframeHeapProfiler: () => IframeHeapProfiler
 });
 module.exports = __toCommonJS(iframeHeapProfiler_exports);
-var import_smoked_suite = require("@elliemae/smoked-suite");
-class IframeHeapProfiler extends import_smoked_suite.HeapMemoryProfiler {
+var import_heapMemoryProfiler = require("./heapMemoryProfiler.js");
+class IframeHeapProfiler extends import_heapMemoryProfiler.HeapMemoryProfiler {
   constructor(profiledPage, frame, outputDir) {
     super(profiledPage, outputDir);
     this.profiledPage = profiledPage;

package/dist/cjs/index.js

@@ -24,6 +24,7 @@ __export(index_exports, {
   DEFAULT_THRESHOLDS: () => import_config.DEFAULT_THRESHOLDS,
   EnvVarConfigSource: () => import_envVarConfigSource.EnvVarConfigSource,
   FileConfigSource: () => import_fileConfigSource.FileConfigSource,
+  HeapMemoryProfiler: () => import_heapMemoryProfiler.HeapMemoryProfiler,
   IframeHeapProfiler: () => import_iframeHeapProfiler.IframeHeapProfiler,
   JunitReporter: () => import_junitReporter.JunitReporter,
   MissingRequiredParamError: () => import_requiredEnvParams.MissingRequiredParamError,
@@ -41,6 +42,7 @@ var import_config = require("./types/config.js");
 var import_scenarioRegistry = require("./registry/scenarioRegistry.js");
 var import_batchRunner = require("./runner/batchRunner.js");
 var import_scenarioRunner = require("./runner/scenarioRunner.js");
+var import_heapMemoryProfiler = require("./browser/heapMemoryProfiler.js");
 var import_iframeHeapProfiler = require("./browser/iframeHeapProfiler.js");
 var import_thresholdEvaluator = require("./analysis/thresholdEvaluator.js");
 var import_consoleReporter = require("./reporting/consoleReporter.js");

package/dist/cjs/runner/scenarioRunner.js

@@ -99,11 +99,12 @@ class ScenarioRunner {
     await this.repeatScenarioActions(scenario, page, frame);
     await forceGarbageCollection(page);
     paths.after = await profiler.captureSnapshot("after");
-    const report = await profiler.compare(
-      "before",
-      "after",
-      this.config.runner.topN
-    );
+    const report = await profiler.compare({
+      beforeLabel: "before",
+      afterLabel: "after",
+      topN: this.config.runner.topN,
+      originAllowList: [new URL(this.config.env.baseUrl).origin]
+    });
     if (report) await this.writeReport(report, scenario);
     return report;
   }
@@ -119,7 +120,9 @@ class ScenarioRunner {
     });
     process.stderr.write(`[scenarioRunner] post-login URL = ${page.url()}
 `);
-    await page.waitForURL(`**${scenario.url()}**`, { timeout: 3e4 });
+    if (!page.url().includes(scenario.url())) {
+      await page.goto(scenario.url(), { waitUntil: "load", timeout: 3e4 });
+    }
     process.stderr.write(
       `[scenarioRunner] settled URL before iframe = ${page.url()}
 `

package/dist/cjs/scenarios/index.js

@@ -23,7 +23,10 @@ __export(scenarios_exports, {
 module.exports = __toCommonJS(scenarios_exports);
 var import_scenarioRegistry = require("../registry/scenarioRegistry.js");
 var import_one_admin = require("./one-admin/index.js");
-const scenarioRegistry = new import_scenarioRegistry.ScenarioRegistry().register({
-  microapp: "one-admin",
-  scenarios: import_one_admin.oneAdminScenarios
-});
+var import_pipeline = require("./pipeline/index.js");
+const scenarioRegistry = (() => {
+  const registry = new import_scenarioRegistry.ScenarioRegistry();
+  registry.register(import_one_admin.oneAdminScenarioGroup);
+  registry.register(import_pipeline.pipelineScenarioGroup);
+  return registry;
+})();

package/dist/cjs/scenarios/one-admin/index.js

@@ -18,10 +18,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var one_admin_exports = {};
 __export(one_admin_exports, {
-  oneAdminScenarios: () => oneAdminScenarios
+  oneAdminScenarioGroup: () => oneAdminScenarioGroup
 });
 module.exports = __toCommonJS(one_admin_exports);
 var import_export_navigation_scenario = require("./export-navigation.scenario.js");
 const oneAdminScenarios = [
   import_export_navigation_scenario.exportNavigationScenario
 ];
+const oneAdminScenarioGroup = {
+  microapp: "one-admin",
+  scenarios: oneAdminScenarios
+};