@elliemae/encw-leak-runner 1.0.13 → 1.0.15

package/dist/types/lib/config/runnerConfigSchema.d.ts

@@ -4,13 +4,13 @@ export declare const runnerOptionsSchema: z.ZodObject<{
     outputDir: z.ZodOptional<z.ZodString>;
     topN: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    topN?: number | undefined;
     headless?: boolean | undefined;
     outputDir?: string | undefined;
-    topN?: number | undefined;
 }, {
+    topN?: number | undefined;
     headless?: boolean | undefined;
     outputDir?: string | undefined;
-    topN?: number | undefined;
 }>;
 export declare const aiConfigFileSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
@@ -33,13 +33,13 @@ export declare const runnerConfigFileSchema: z.ZodObject<{
         outputDir: z.ZodOptional<z.ZodString>;
         topN: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
+        topN?: number | undefined;
         headless?: boolean | undefined;
         outputDir?: string | undefined;
-        topN?: number | undefined;
     }, {
+        topN?: number | undefined;
         headless?: boolean | undefined;
         outputDir?: string | undefined;
-        topN?: number | undefined;
     }>>;
     ai: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -58,9 +58,9 @@ export declare const runnerConfigFileSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     $schema?: string | undefined;
     runner?: {
+        topN?: number | undefined;
         headless?: boolean | undefined;
         outputDir?: string | undefined;
-        topN?: number | undefined;
     } | undefined;
     ai?: {
         enabled?: boolean | undefined;
@@ -71,9 +71,9 @@ export declare const runnerConfigFileSchema: z.ZodObject<{
 }, {
     $schema?: string | undefined;
     runner?: {
+        topN?: number | undefined;
         headless?: boolean | undefined;
         outputDir?: string | undefined;
-        topN?: number | undefined;
     } | undefined;
     ai?: {
         enabled?: boolean | undefined;

package/dist/types/lib/index.d.ts

@@ -6,6 +6,8 @@ export type { ThresholdResult, ScenarioResult, RunSummary, } from './types/resul
 export { ScenarioRegistry } from './registry/scenarioRegistry.js';
 export { BatchRunner } from './runner/batchRunner.js';
 export { ScenarioRunner } from './runner/scenarioRunner.js';
+export { HeapMemoryProfiler } from './browser/heapMemoryProfiler.js';
+export type { HeapProfilingOptions } from './browser/heapMemoryProfiler.js';
 export { IframeHeapProfiler } from './browser/iframeHeapProfiler.js';
 export { ThresholdEvaluator } from './analysis/thresholdEvaluator.js';
 export { ConsoleReporter } from './reporting/consoleReporter.js';

package/dist/types/lib/scenarios/one-admin/index.d.ts

@@ -1,2 +1,2 @@
-import type { MicroappLeakScenario } from '../../types/scenario.js';
-export declare const oneAdminScenarios: readonly MicroappLeakScenario[];
+import type { ScenarioGroup } from '../../registry/scenarioRegistry.js';
+export declare const oneAdminScenarioGroup: ScenarioGroup;

package/dist/types/lib/scenarios/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+import type { ScenarioGroup } from 'lib/registry/scenarioRegistry.js';
+export declare const pipelineScenarioGroup: ScenarioGroup;

package/dist/types/lib/scenarios/pipeline/page-models/PipelinePageModel.d.ts

@@ -0,0 +1,14 @@
+import type { Page } from '@playwright/test';
+export declare class PipelinePageModel {
+    #private;
+    private readonly page;
+    static readonly IFRAME_SELECTOR = "[data-testid=\"pui-iframe-container-pipelineui\"]";
+    private static readonly TASKS_IFRAME_SELECTOR;
+    private static readonly SPINNER_TEST_ID;
+    constructor(page: Page);
+    waitForPipelineReady(): Promise<void>;
+    clickTasksTab(): Promise<void>;
+    clickPipelineTab(): Promise<void>;
+    waitForPipelineSpinner(): Promise<void>;
+    waitForTasksReady(): Promise<void>;
+}

package/dist/types/lib/scenarios/pipeline/page-models/index.d.ts

@@ -0,0 +1 @@
+export { PipelinePageModel } from './PipelinePageModel.js';

package/dist/types/lib/scenarios/pipeline/pipeline-task-navigation.scenario.d.ts

@@ -0,0 +1,2 @@
+import type { MicroappLeakScenario } from '../../types/scenario.js';
+export declare const pipelineTaskNavigationScenario: MicroappLeakScenario;

package/leak-runner.config.json

@@ -3,7 +3,7 @@
   "runner": {
     "headless": true,
     "outputDir": "./leak-reports/",
-    "topN": 5
+    "topN": 10
   },
   "ai": {
     "enabled": false,

package/lib/browser/heapMemoryProfiler.ts

@@ -0,0 +1,284 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { Page, Frame } from '@playwright/test';
+import { HeapDoctor } from '@elliemae/encw-heap-doctor';
+import type { ComparisonReport } from '@elliemae/encw-heap-doctor';
+
+export interface HeapProfilingOptions {
+  /**
+   * Number of times to execute the flow between the before and after snapshots.
+   * More iterations amplify the leak signal — a leak of N bytes per run becomes
+   * N × heapIterations in the delta, making small leaks detectable above GC noise.
+   * Default: 1.
+   */
+  heapIterations?: number;
+
+  /**
+   * Label prefix used in snapshot filenames and as the Memento key.
+   * Two files are written: `<label>-before-<epoch>.heapsnapshot` and
+   * `<label>-after-<epoch>.heapsnapshot`.
+   * Default: 'flow'.
+   */
+  label?: string;
+
+  /**
+   * Number of top leak groups to include in the HeapDoctor report.
+   * Default: 5 (HeapDoctor default).
+   */
+  topN?: number;
+
+  /**
+   * When `true`, throws after comparison if `retainedSizeDelta` exceeds
+   * {@link leakThresholdBytes}, causing the Playwright test to fail.
+   * Default: false.
+   */
+  failOnLeak?: boolean;
+
+  /**
+   * Retained-size growth in bytes above which the test is failed when
+   * {@link failOnLeak} is `true`. Set to 0 to fail on any positive delta.
+   * Default: 0.
+   */
+  leakThresholdBytes?: number;
+
+  /**
+   * Optional allow-list of `Window` origins (e.g. `'https://encompass.q3.ice.com'`).
+   *
+   * Forwarded to `HeapDoctor`; suppresses retainer chains rooted in unrelated
+   * same-site iframes (e.g. partner plugins) that share the main V8 isolate.
+   * Chains with no `Window` step are always kept.
+   */
+  originAllowList?: readonly string[];
+}
+
+/** Parameters for {@link HeapMemoryProfiler.compare}. */
+export interface CompareParams {
+  /** Label passed to `captureSnapshot()` for the baseline. */
+  beforeLabel: string;
+  /** Label passed to `captureSnapshot()` for the post-flow snapshot. */
+  afterLabel: string;
+  /** Override for the number of top leak groups in the report. */
+  topN?: number;
+  /** Allow-list of `Window` origins; forwarded to `HeapDoctor`. */
+  originAllowList?: readonly string[];
+}
+
+/**
+ * Encapsulates heap memory profiling for a single Playwright test.
+ *
+ * **Responsibilities:**
+ * - CDP session lifecycle (open, stream chunks, detach)
+ * - `.heapsnapshot` file I/O
+ * - Snapshot label cache (Memento store, cleared per test)
+ * - HeapDoctor comparison and markdown report writing
+ * - Optional test failure on leak threshold breach
+ *
+ * **Usage:**
+ * ```ts
+ * class MySpec extends AdminBaseTest {
+ *   private heapProfiler!: HeapMemoryProfiler;
+ *
+ *   async beforeEach() {
+ *     await super.beforeEach();
+ *     this.heapProfiler = new HeapMemoryProfiler(this.page, 'reports/heap-snapshots/my-spec');
+ *   }
+ *
+ *   async afterEach() {
+ *     this.heapProfiler.clearSnapshots();
+ *     await super.afterEach();
+ *   }
+ *
+ *   async testFlow_Memory() {
+ *     await this.goto('some.route');
+ *     await this.heapProfiler.withProfiling(async () => {
+ *       await this.somePage.doSomething();
+ *     }, { heapIterations: 3, label: 'my-flow', failOnLeak: true, leakThresholdBytes: 500_000 });
+ *   }
+ * }
+ * ```
+ *
+ * **Non-Chromium:** All methods silently no-op and return `null` / empty string.
+ * The flow inside `withProfiling` still executes normally.
+ */
+export class HeapMemoryProfiler {
+  /** Memento store: maps snapshot label → absolute file path on disk. */
+  private readonly snapshots = new Map<string, string>();
+
+  /**
+   * @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(
+    private readonly page: Page,
+    private readonly outputDir: string,
+  ) {}
+
+  protected getCDPTarget(): Page | Frame {
+    return this.page;
+  }
+
+  // ─── Browser guard ──────────────────────────────────────────────────────────
+
+  private isChromium(): boolean {
+    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: string): Promise<string> {
+    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 }: { chunk: string }) => {
+        writeStream.write(chunk);
+      },
+    );
+
+    await client.send('HeapProfiler.takeHeapSnapshot', {
+      reportProgress: false,
+    });
+    await client.send('HeapProfiler.disable');
+    await client.detach();
+
+    await new Promise<void>((resolve, reject) => {
+      writeStream.end((err?: Error | null) => {
+        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: CompareParams): Promise<ComparisonReport | null> {
+    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: () => Promise<void>,
+    options: HeapProfilingOptions = {},
+  ): Promise<ComparisonReport | null> {
+    const {
+      heapIterations = 1,
+      label = 'flow',
+      topN,
+      failOnLeak = false,
+      leakThresholdBytes = 0,
+      originAllowList,
+    } = options;
+
+    if (!this.isChromium()) {
+      // eslint-disable-next-line no-await-in-loop
+      for (let i = 0; i < heapIterations; i += 1) await flow();
+      return null;
+    }
+
+    await this.captureSnapshot(`${label}-before`);
+    // eslint-disable-next-line no-await-in-loop
+    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(): void {
+    this.snapshots.clear();
+  }
+}

package/lib/browser/iframeHeapProfiler.ts

@@ -1,5 +1,5 @@
-import { HeapMemoryProfiler } from '@elliemae/smoked-suite';
 import type { Page, Frame } from '@playwright/test';
+import { HeapMemoryProfiler } from './heapMemoryProfiler.js';
 
 export class IframeHeapProfiler extends HeapMemoryProfiler {
   constructor(

package/lib/browser/tests/heapMemoryProfiler.test.ts

@@ -0,0 +1,64 @@
+import type { Page, Frame } from '@playwright/test';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { HeapMemoryProfiler } from '../heapMemoryProfiler.js';
+
+describe('HeapMemoryProfiler — Template Method', () => {
+  it('allows subclass to override getCDPTarget', () => {
+    const mockPage = {
+      context: () => ({
+        browser: () => ({ browserType: () => ({ name: () => 'chromium' }) }),
+        newCDPSession: jest.fn().mockResolvedValue({
+          send: jest.fn().mockResolvedValue(undefined),
+          on: jest.fn(),
+          detach: jest.fn().mockResolvedValue(undefined),
+        }),
+      }),
+    } as unknown as Page;
+
+    const profiler = new HeapMemoryProfiler(mockPage, '/tmp/test-heap');
+    expect(profiler).toBeInstanceOf(HeapMemoryProfiler);
+  });
+
+  it('passes the overridden target to newCDPSession when subclass overrides getCDPTarget', async () => {
+    const sentinelFrame = {} as Frame;
+    let receivedTarget: Page | Frame | undefined;
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'heap-test-'));
+
+    const mockPage = {
+      context: () => ({
+        browser: () => ({ browserType: () => ({ name: () => 'chromium' }) }),
+        newCDPSession: (target: Page | Frame) => {
+          receivedTarget = target;
+          const chunks: Array<(event: { chunk: string }) => void> = [];
+          return Promise.resolve({
+            send: (method: string) => {
+              if (method === 'HeapProfiler.takeHeapSnapshot') {
+                chunks.forEach((cb) => cb({ chunk: '{}' }));
+              }
+              return Promise.resolve();
+            },
+            on: (_: string, cb: (event: { chunk: string }) => void) => {
+              chunks.push(cb);
+            },
+            detach: () => Promise.resolve(),
+          });
+        },
+      }),
+    } as unknown as Page;
+
+    class TestProfiler extends HeapMemoryProfiler {
+      protected override getCDPTarget(): Page | Frame {
+        return sentinelFrame;
+      }
+    }
+
+    const profiler = new TestProfiler(mockPage, tmpDir);
+    await profiler.captureSnapshot('test');
+
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+
+    expect(receivedTarget).toBe(sentinelFrame);
+  });
+});

package/lib/browser/tests/iframeHeapProfiler.test.ts

@@ -1,5 +1,5 @@
-import { HeapMemoryProfiler } from '@elliemae/smoked-suite';
 import type { Page, Frame } from '@playwright/test';
+import { HeapMemoryProfiler } from '../heapMemoryProfiler.js';
 import { IframeHeapProfiler } from '../iframeHeapProfiler.js';
 
 // `getCDPTarget` is protected on the real classes; tests need structural access.

package/lib/index.ts

@@ -22,6 +22,8 @@ export type {
 export { ScenarioRegistry } from './registry/scenarioRegistry.js';
 export { BatchRunner } from './runner/batchRunner.js';
 export { ScenarioRunner } from './runner/scenarioRunner.js';
+export { HeapMemoryProfiler } from './browser/heapMemoryProfiler.js';
+export type { HeapProfilingOptions } from './browser/heapMemoryProfiler.js';
 export { IframeHeapProfiler } from './browser/iframeHeapProfiler.js';
 export { ThresholdEvaluator } from './analysis/thresholdEvaluator.js';
 export { ConsoleReporter } from './reporting/consoleReporter.js';

package/lib/runner/scenarioRunner.ts

@@ -96,11 +96,12 @@ export class ScenarioRunner {
     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;
   }
@@ -121,7 +122,9 @@ export class ScenarioRunner {
       instanceId: this.config.env.instanceId,
     });
     process.stderr.write(`[scenarioRunner] post-login URL = ${page.url()}\n`);
-    await page.waitForURL(`**${scenario.url()}**`, { timeout: 30_000 });
+    if (!page.url().includes(scenario.url())) {
+      await page.goto(scenario.url(), { waitUntil: 'load', timeout: 30_000 });
+    }
     process.stderr.write(
       `[scenarioRunner] settled URL before iframe = ${page.url()}\n`,
     );

package/lib/scenarios/index.ts

@@ -1,8 +1,10 @@
 import { ScenarioRegistry } from '../registry/scenarioRegistry.js';
-import { oneAdminScenarios } from './one-admin/index.js';
+import { oneAdminScenarioGroup } from './one-admin/index.js';
+import { pipelineScenarioGroup } from './pipeline/index.js';
 
-export const scenarioRegistry: ScenarioRegistry =
-  new ScenarioRegistry().register({
-    microapp: 'one-admin',
-    scenarios: oneAdminScenarios,
-  });
+export const scenarioRegistry = ((): ScenarioRegistry => {
+  const registry = new ScenarioRegistry();
+  registry.register(oneAdminScenarioGroup);
+  registry.register(pipelineScenarioGroup);
+  return registry;
+})();

package/lib/scenarios/one-admin/index.ts

@@ -1,6 +1,12 @@
+import type { ScenarioGroup } from '../../registry/scenarioRegistry.js';
 import type { MicroappLeakScenario } from '../../types/scenario.js';
 import { exportNavigationScenario } from './export-navigation.scenario.js';
 
-export const oneAdminScenarios: readonly MicroappLeakScenario[] = [
+const oneAdminScenarios: readonly MicroappLeakScenario[] = [
   exportNavigationScenario,
 ];
+
+export const oneAdminScenarioGroup: ScenarioGroup = {
+  microapp: 'one-admin',
+  scenarios: oneAdminScenarios,
+};

package/lib/scenarios/pipeline/index.ts

@@ -0,0 +1,12 @@
+import type { ScenarioGroup } from 'lib/registry/scenarioRegistry.js';
+import type { MicroappLeakScenario } from '../../types/scenario.js';
+import { pipelineTaskNavigationScenario } from './pipeline-task-navigation.scenario.js';
+
+const pipelineScenarios: readonly MicroappLeakScenario[] = [
+  pipelineTaskNavigationScenario,
+];
+
+export const pipelineScenarioGroup: ScenarioGroup = {
+  microapp: 'pipeline',
+  scenarios: pipelineScenarios,
+};

package/lib/scenarios/pipeline/page-models/PipelinePageModel.ts

@@ -0,0 +1,46 @@
+import type { Page } from '@playwright/test';
+
+export class PipelinePageModel {
+  static readonly IFRAME_SELECTOR =
+    '[data-testid="pui-iframe-container-pipelineui"]';
+
+  private static readonly TASKS_IFRAME_SELECTOR =
+    '[data-testid="pui-iframe-container-taskspipeline"]';
+
+  private static readonly SPINNER_TEST_ID =
+    'ds-circularindeterminateindicator-svg';
+
+  constructor(private readonly page: Page) {}
+
+  async waitForPipelineReady(): Promise<void> {
+    await this.#waitForSpinner(PipelinePageModel.IFRAME_SELECTOR);
+  }
+
+  async clickTasksTab(): Promise<void> {
+    await this.page.getByRole('tab', { name: 'Tasks' }).click();
+  }
+
+  async clickPipelineTab(): Promise<void> {
+    await this.page.getByRole('tab', { name: 'Loans' }).click();
+  }
+
+  async waitForPipelineSpinner(): Promise<void> {
+    await this.#waitForSpinner(PipelinePageModel.IFRAME_SELECTOR);
+  }
+
+  async waitForTasksReady(): Promise<void> {
+    await this.page
+      .locator(PipelinePageModel.TASKS_IFRAME_SELECTOR)
+      .contentFrame()
+      .getByTestId('circular-indicator')
+      .waitFor({ state: 'hidden' });
+  }
+
+  async #waitForSpinner(iframeSelector: string): Promise<void> {
+    const spinner = this.page
+      .frameLocator(iframeSelector)
+      .getByTestId(PipelinePageModel.SPINNER_TEST_ID);
+    await spinner.waitFor({ state: 'visible' });
+    await spinner.waitFor({ state: 'hidden' });
+  }
+}

package/lib/scenarios/pipeline/page-models/index.ts

@@ -0,0 +1 @@
+export { PipelinePageModel } from './PipelinePageModel.js';

package/lib/scenarios/pipeline/pipeline-task-navigation.scenario.ts

@@ -0,0 +1,42 @@
+import type { MicroappLeakScenario } from '../../types/scenario.js';
+import { AdminLandingPageModel } from '../one-admin/page-models/index.js';
+import { PipelinePageModel } from './page-models/index.js';
+
+export const pipelineTaskNavigationScenario: MicroappLeakScenario = {
+  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 path = new URL(page.url()).pathname.replace(/\/$/, '');
+    if (path === '/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,
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/encw-leak-runner",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Playwright orchestration framework for microapp memory leak detection",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -19,8 +19,8 @@
   "dependencies": {
     "commander": "^12.1.0",
     "zod": "^3.25.76",
-    "@elliemae/smoked-suite": "26.2.37",
-    "@elliemae/encw-heap-doctor": "26.2.26"
+    "@elliemae/smoked-suite": "26.3.1",
+    "@elliemae/encw-heap-doctor": "26.3.1"
   },
   "devDependencies": {
     "@elliemae/pui-cli": "~8.59.3",
@@ -41,6 +41,7 @@
     "test-watch": "jest --watch",
     "lint": "pui-cli lint",
     "lint:fix": "pui-cli lint --fix",
-    "tscheck": "pui-cli tscheck --files"
+    "tscheck": "pui-cli tscheck --files",
+    "codegen": "playwright codegen"
   }
 }