@elliemae/encw-leak-runner 1.0.2

package/dist/bin/leak-runner.js

@@ -0,0 +1,792 @@
+#!/usr/bin/env node
+
+// lib/cli/index.ts
+import { Command } from "commander";
+
+// lib/runner/scenarioRunner.ts
+import fs from "node:fs";
+import path from "node:path";
+import {
+  chromium
+} from "@playwright/test";
+import { AuthManager, PageSetup } from "@elliemae/smoked-suite";
+
+// lib/browser/iframeHeapProfiler.ts
+import { HeapMemoryProfiler } from "@elliemae/smoked-suite";
+var IframeHeapProfiler = class extends HeapMemoryProfiler {
+  constructor(profiledPage, frame, outputDir) {
+    super(profiledPage, outputDir);
+    this.profiledPage = profiledPage;
+    this.frame = frame;
+  }
+  getCDPTarget() {
+    return this.isSameOriginAsPage(this.frame) ? this.profiledPage : this.frame;
+  }
+  isSameOriginAsPage(frame) {
+    const frameUrl = frame.url();
+    const pageUrl = this.profiledPage.url();
+    if (!frameUrl || frameUrl === "about:blank") return true;
+    try {
+      return new URL(frameUrl).origin === new URL(pageUrl).origin;
+    } catch {
+      return true;
+    }
+  }
+};
+
+// lib/analysis/thresholdEvaluator.ts
+function toMB(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+var ThresholdEvaluator = class {
+  static evaluate(report, thresholds) {
+    const reasons = [];
+    if (report.delta.retainedSizeDelta > thresholds.maxRetainedSizeDeltaBytes) {
+      reasons.push(
+        `Retained size delta ${toMB(report.delta.retainedSizeDelta)} MB exceeds threshold ${toMB(thresholds.maxRetainedSizeDeltaBytes)} MB`
+      );
+    }
+    const newLeakCount = report.delta.newLeakGroups.length;
+    if (newLeakCount > thresholds.maxNewLeakGroups) {
+      reasons.push(
+        `${newLeakCount} new leak groups detected (threshold: ${thresholds.maxNewLeakGroups})`
+      );
+    }
+    if (reasons.length === 0) {
+      return { passed: true, reason: null };
+    }
+    return { passed: false, reason: reasons.join("; ") };
+  }
+};
+
+// lib/types/config.ts
+var DEFAULT_THRESHOLDS = {
+  maxRetainedSizeDeltaBytes: 10 * 1024 * 1024,
+  maxNewLeakGroups: 0
+};
+
+// lib/runner/aiEnhancementStep.ts
+import {
+  AiEnhancer,
+  renderComparisonMarkdown
+} from "@elliemae/encw-heap-doctor";
+async function enhanceMarkdownIfConfigured(report, config, scenarioName) {
+  if (!config.ai?.apiKey) return report.markdown;
+  try {
+    const enhancer = new AiEnhancer(config.ai);
+    await enhancer.enhance(report.afterAnalysis.leakResults);
+    return renderComparisonMarkdown(report);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `Genice enhancement failed for ${scenarioName}: ${message}; writing report without AI section.
+`
+    );
+    return report.markdown;
+  }
+}
+
+// lib/runner/scenarioRunner.ts
+async function resolveIframe(page, selector) {
+  const handle = await page.locator(selector).elementHandle();
+  if (!handle) throw new Error(`Iframe not found for selector: ${selector}`);
+  const frame = await handle.contentFrame();
+  if (!frame)
+    throw new Error(`Could not get content frame for selector: ${selector}`);
+  return frame;
+}
+async function forceGarbageCollection(page) {
+  const session = await page.context().newCDPSession(page);
+  await session.send("HeapProfiler.enable");
+  await session.send("HeapProfiler.collectGarbage");
+  await session.send("HeapProfiler.disable");
+  await session.detach();
+  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);
+}
+var ScenarioRunner = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async launchBrowser() {
+    return chromium.launch({ headless: this.config.runner.headless });
+  }
+  async run(scenario, browser) {
+    const startTime = Date.now();
+    const context = await browser.newContext({
+      baseURL: this.config.env.baseUrl
+    });
+    const page = await context.newPage();
+    const paths = { before: "", after: "" };
+    let report = null;
+    let error = null;
+    try {
+      report = await this.runScenarioInPage(page, scenario, paths);
+    } catch (err) {
+      error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      await context.close();
+      cleanupSnapshots(paths);
+    }
+    return this.buildResult({ scenario, report, error, startTime });
+  }
+  async runScenarioInPage(page, scenario, paths) {
+    const snapshotsDir = path.join(this.config.runner.outputDir, "snapshots");
+    const { profiler, frame } = await this.setupAndProfile(
+      page,
+      scenario,
+      snapshotsDir
+    );
+    paths.before = await profiler.captureSnapshot("before");
+    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
+    );
+    if (report) await this.writeReport(report, scenario);
+    return report;
+  }
+  async setupAndProfile(page, scenario, snapshotsDir) {
+    const auth = new AuthManager();
+    const pageSetup = new PageSetup();
+    await pageSetup.apply(page);
+    await auth.login(page, {
+      username: this.config.env.userId,
+      password: this.config.env.password,
+      instanceId: this.config.env.instanceId
+    });
+    await page.goto(scenario.url());
+    const frame = await resolveIframe(page, scenario.microappSelector);
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+    const profiler = new IframeHeapProfiler(page, frame, snapshotsDir);
+    return { profiler, frame };
+  }
+  async repeatScenarioActions(scenario, page, frame) {
+    const repeatCount = scenario.repeat?.() ?? 3;
+    for (let i = 0; i < repeatCount; i += 1) {
+      await scenario.action(page, frame);
+      if (scenario.back) {
+        await scenario.back(page);
+      }
+    }
+  }
+  async writeReport(report, scenario) {
+    const reportPath = path.join(
+      this.config.runner.outputDir,
+      `${scenario.id}.md`
+    );
+    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+    const markdown = await enhanceMarkdownIfConfigured(
+      report,
+      this.config,
+      scenario.name
+    );
+    fs.writeFileSync(reportPath, markdown);
+  }
+  buildResult(input) {
+    const { scenario, report, error, startTime } = input;
+    const thresholds = {
+      ...DEFAULT_THRESHOLDS,
+      ...scenario.thresholds
+    };
+    const failureFallback = {
+      passed: false,
+      reason: error?.message ?? "Snapshot capture failed"
+    };
+    const thresholdResult = report && !error ? ThresholdEvaluator.evaluate(report, thresholds) : failureFallback;
+    return {
+      name: scenario.name,
+      passed: thresholdResult.passed,
+      thresholdResult,
+      report,
+      durationMs: Date.now() - startTime,
+      error
+    };
+  }
+};
+
+// lib/runner/batchRunner.ts
+function buildSummary(results) {
+  return {
+    results,
+    totalDurationMs: results.reduce((acc, r) => acc + r.durationMs, 0),
+    passCount: results.filter((r) => r.passed).length,
+    failCount: results.filter((r) => !r.passed).length
+  };
+}
+var BatchRunner = class {
+  constructor(config, registry) {
+    this.config = config;
+    this.registry = registry;
+    this.scenarioRunner = new ScenarioRunner(config);
+  }
+  scenarioRunner;
+  async runAll() {
+    const scenarios = this.registry.list().map((entry) => entry.scenario);
+    return this.executeScenarios(scenarios);
+  }
+  async runByTag(tag) {
+    const scenarios = this.registry.filterByTag(tag).map((entry) => entry.scenario);
+    return this.executeScenarios(scenarios);
+  }
+  async runByName(key) {
+    const scenario = this.registry.get(key);
+    if (!scenario) {
+      throw new Error(`No scenario registered with key "${key}"`);
+    }
+    return this.executeScenarios([scenario]);
+  }
+  async executeScenarios(scenarios) {
+    const results = await scenarios.reduce(
+      async (acc, scenario) => {
+        const prior = await acc;
+        const result = await this.runOne(scenario);
+        return [...prior, result];
+      },
+      Promise.resolve([])
+    );
+    return buildSummary(results);
+  }
+  async runOne(scenario) {
+    const browser = await this.scenarioRunner.launchBrowser();
+    try {
+      return await this.scenarioRunner.run(scenario, browser);
+    } finally {
+      await browser.close();
+    }
+  }
+};
+
+// lib/reporting/consoleReporter.ts
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var BOLD = "\x1B[1m";
+var RESET = "\x1B[0m";
+function formatDuration(ms) {
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function printLine(text) {
+  process.stdout.write(`${text}
+`);
+}
+function printScenario(result) {
+  const status = result.passed ? `${GREEN}PASSED${RESET}` : `${RED}FAILED${RESET}`;
+  const duration = formatDuration(result.durationMs);
+  printLine(`  ${status}  ${BOLD}${result.name}${RESET}  (${duration})`);
+  if (!result.passed && result.thresholdResult.reason) {
+    printLine(`         ${RED}\u2192 ${result.thresholdResult.reason}${RESET}`);
+  }
+  if (!result.passed && result.error) {
+    printLine(`         ${RED}\u2192 Error: ${result.error.message}${RESET}`);
+  }
+}
+var ConsoleReporter = class {
+  write(summary) {
+    printLine("");
+    printLine(`${BOLD}MEMORY LEAK RUN RESULTS${RESET}`);
+    printLine("\u2500".repeat(50));
+    summary.results.forEach(printScenario);
+    printLine("\u2500".repeat(50));
+    const total = summary.results.length;
+    const duration = formatDuration(summary.totalDurationMs);
+    printLine(
+      `${summary.passCount} passed, ${summary.failCount} failed of ${total} scenarios  (${duration})`
+    );
+    printLine("");
+  }
+};
+
+// lib/reporting/junitReporter.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatSeconds(ms) {
+  return (ms / 1e3).toFixed(1);
+}
+function renderTestCase(result) {
+  const timeAttr = `time="${formatSeconds(result.durationMs)}"`;
+  const open = `    <testcase name="${escapeXml(
+    result.name
+  )}" classname="memory-leak" ${timeAttr}>`;
+  if (result.passed) {
+    return `${open}
+    </testcase>`;
+  }
+  const message = result.thresholdResult.reason ?? result.error?.message ?? "Unknown failure";
+  const body = result.thresholdResult.reason ? `See leak-reports/${result.name}.md for full analysis` : result.error?.stack ?? "";
+  return `${open}
+      <failure message="${escapeXml(message)}">
+        ${escapeXml(body)}
+      </failure>
+    </testcase>`;
+}
+var JunitReporter = class {
+  write(summary, outputDir) {
+    const totalTime = formatSeconds(summary.totalDurationMs);
+    const testCases = summary.results.map(renderTestCase).join("\n");
+    const xml = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      `<testsuites name="encw-leak-runner" time="${totalTime}">`,
+      `  <testsuite name="microapp-memory-leaks" tests="${summary.results.length}" failures="${summary.failCount}" time="${totalTime}">`,
+      testCases,
+      "  </testsuite>",
+      "</testsuites>"
+    ].join("\n");
+    fs2.mkdirSync(outputDir, { recursive: true });
+    fs2.writeFileSync(path2.join(outputDir, "test-results.xml"), xml, "utf8");
+    return Promise.resolve();
+  }
+};
+
+// lib/config/sources/cliOverrideConfigSource.ts
+var CliOverrideConfigSource = class {
+  constructor(overrides) {
+    this.overrides = overrides;
+  }
+  priority = 3;
+  name = "cli";
+  load() {
+    const runner = {};
+    if (this.overrides.headless !== void 0) {
+      runner.headless = this.overrides.headless;
+    }
+    if (this.overrides.outputDir !== void 0) {
+      runner.outputDir = this.overrides.outputDir;
+    }
+    if (this.overrides.topN !== void 0) {
+      runner.topN = this.overrides.topN;
+    }
+    return Object.keys(runner).length === 0 ? {} : { runner };
+  }
+};
+
+// lib/config/sources/envVarConfigSource.ts
+var EnvVarConfigSource = class {
+  priority = 2;
+  name = "env";
+  load() {
+    const runner = {};
+    if (process.env.HEADLESS !== void 0) {
+      runner.headless = process.env.HEADLESS !== "false";
+    }
+    if (process.env.LEAK_OUTPUT_DIR) {
+      runner.outputDir = process.env.LEAK_OUTPUT_DIR;
+    }
+    if (process.env.LEAK_TOP_N) {
+      const parsed = parseInt(process.env.LEAK_TOP_N, 10);
+      if (Number.isFinite(parsed) && parsed > 0) runner.topN = parsed;
+    }
+    return Object.keys(runner).length === 0 ? {} : { runner };
+  }
+};
+
+// lib/config/sources/fileConfigSource.ts
+import fs3 from "node:fs";
+
+// lib/config/runnerConfigSchema.ts
+import { z } from "zod";
+var runnerOptionsSchema = z.object({
+  headless: z.boolean(),
+  outputDir: z.string().min(1),
+  topN: z.number().int().min(1)
+}).partial();
+var aiConfigFileSchema = z.object({
+  enabled: z.boolean(),
+  model: z.string().min(1),
+  temperature: z.number().min(0).max(2)
+}).partial();
+var runnerConfigFileSchema = z.object({
+  runner: runnerOptionsSchema,
+  ai: aiConfigFileSchema
+}).partial().strict();
+
+// lib/config/sources/fileConfigSource.ts
+var FileConfigSource = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  priority = 1;
+  name = "file";
+  load() {
+    if (!fs3.existsSync(this.filePath)) return {};
+    const raw = fs3.readFileSync(this.filePath, "utf8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(
+        `Failed to parse config file ${this.filePath}: ${err.message}`
+      );
+    }
+    const result = runnerConfigFileSchema.safeParse(parsed);
+    if (!result.success) {
+      const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new Error(`Invalid config file ${this.filePath}:
+${issues}`);
+    }
+    return result.data;
+  }
+};
+
+// lib/config/sources/configSource.ts
+var BUILT_IN_DEFAULTS = {
+  runner: {
+    headless: true,
+    outputDir: "./leak-reports/",
+    topN: 5
+  },
+  ai: {
+    enabled: false,
+    model: "Claude3.7",
+    temperature: 0.3
+  }
+};
+
+// lib/config/runnerConfigLoader.ts
+function applyRunnerPayload(acc, payload) {
+  return {
+    headless: payload.headless ?? acc.headless,
+    outputDir: payload.outputDir ?? acc.outputDir,
+    topN: payload.topN ?? acc.topN
+  };
+}
+function applyAiPayload(acc, payload) {
+  return {
+    aiEnabled: payload.enabled ?? acc.aiEnabled,
+    aiModel: payload.model ?? acc.aiModel,
+    aiTemperature: payload.temperature ?? acc.aiTemperature
+  };
+}
+function applySource(acc, source) {
+  const payload = source.load();
+  return {
+    runner: payload.runner ? applyRunnerPayload(acc.runner, payload.runner) : acc.runner,
+    ai: payload.ai ? applyAiPayload(acc.ai, payload.ai) : acc.ai
+  };
+}
+var RunnerConfigLoader = class {
+  constructor(sources) {
+    this.sources = sources;
+  }
+  resolveOptions() {
+    const ordered = [...this.sources].sort((a, b) => a.priority - b.priority);
+    const initial = {
+      runner: {
+        headless: BUILT_IN_DEFAULTS.runner.headless ?? true,
+        outputDir: BUILT_IN_DEFAULTS.runner.outputDir ?? "./leak-reports/",
+        topN: BUILT_IN_DEFAULTS.runner.topN ?? 5
+      },
+      ai: {
+        aiEnabled: BUILT_IN_DEFAULTS.ai.enabled ?? false,
+        aiModel: BUILT_IN_DEFAULTS.ai.model ?? "Claude3.7",
+        aiTemperature: BUILT_IN_DEFAULTS.ai.temperature ?? 0.3
+      }
+    };
+    const resolved = ordered.reduce(applySource, initial);
+    return {
+      runner: resolved.runner,
+      aiEnabled: resolved.ai.aiEnabled,
+      aiModel: resolved.ai.aiModel,
+      aiTemperature: resolved.ai.aiTemperature
+    };
+  }
+};
+
+// lib/config/missingRequiredParamError.ts
+var MissingRequiredParamError = class extends Error {
+  constructor(missing) {
+    super(
+      `Missing required parameter(s): ${missing.join(", ")}.
+Provide via CLI flag (--base-url / --instance-id / --user-id) or env var (BASE_URL / ENCW_INSTANCE_ID / ENCW_USER_ID / ENCW_PASSWORD).`
+    );
+    this.missing = missing;
+    this.name = "MissingRequiredParamError";
+  }
+};
+
+// lib/config/requiredEnvParams.ts
+var RequiredEnvParamsResolver = class {
+  resolve(cliOpts) {
+    const baseUrl = this.resolveBaseUrl(cliOpts);
+    const instanceId = this.resolveInstanceId(cliOpts);
+    const userId = this.resolveUserId(cliOpts);
+    const password = this.resolvePassword();
+    const params = { baseUrl, instanceId, userId, password };
+    const missing = this.collectMissing(params);
+    if (missing.length > 0) throw new MissingRequiredParamError(missing);
+    return params;
+  }
+  resolveBaseUrl(cliOpts) {
+    return cliOpts.baseUrl || process.env.BASE_URL || "";
+  }
+  resolveInstanceId(cliOpts) {
+    return cliOpts.instanceId || process.env.ENCW_INSTANCE_ID || "";
+  }
+  resolveUserId(cliOpts) {
+    return cliOpts.userId || process.env.ENCW_USER_ID || "";
+  }
+  resolvePassword() {
+    return process.env.ENCW_PASSWORD || "";
+  }
+  collectMissing(params) {
+    const missing = [];
+    if (!params.baseUrl) missing.push("baseUrl");
+    if (!params.instanceId) missing.push("instanceId");
+    if (!params.userId) missing.push("userId");
+    if (!params.password) missing.push("password (ENCW_PASSWORD)");
+    return missing;
+  }
+};
+
+// lib/cli/commands/runCommand.ts
+var RunCommand = class {
+  register(program, deps) {
+    program.command("run [key]").description(
+      "Run a scenario by `<microapp>/<id>`, or use --all / --tag to run multiple"
+    ).option("--all", "Run all registered scenarios").option("--tag <tag>", "Run all scenarios matching a tag").option("--base-url <url>", "Override base URL").option("--instance-id <id>", "Override instance ID").option("--user-id <id>", "Override user ID").option("--output-dir <dir>", "Override output directory").option(
+      "--top-n <n>",
+      "Override top-N for heap comparison",
+      (v) => parseInt(v, 10)
+    ).option(
+      "--headless <bool>",
+      "Override headless mode",
+      (v) => v !== "false"
+    ).option("--config-file <path>", "Path to leak-runner.config.json").action(async (key, options) => {
+      try {
+        const config = this.buildConfig(options, deps);
+        const runner = new BatchRunner(config, deps.registry);
+        const summary = await this.selectSummary(runner, key, options);
+        new ConsoleReporter().write(summary);
+        await new JunitReporter().write(summary, config.runner.outputDir);
+        process.exit(summary.failCount > 0 ? 1 : 0);
+      } catch (err) {
+        if (err instanceof MissingRequiredParamError) {
+          process.stderr.write(`Configuration error: ${err.message}
+`);
+          process.exit(2);
+        }
+        process.stderr.write(`Fatal: ${err.message}
+`);
+        process.exit(1);
+      }
+    });
+  }
+  buildConfig(options, deps) {
+    const filePath = options.configFile ?? `${process.cwd()}/leak-runner.config.json`;
+    const loader = new RunnerConfigLoader([
+      new FileConfigSource(filePath),
+      new EnvVarConfigSource(),
+      new CliOverrideConfigSource({
+        headless: options.headless,
+        outputDir: options.outputDir,
+        topN: options.topN
+      })
+    ]);
+    const resolved = loader.resolveOptions();
+    const env = deps.envParams.resolve({
+      baseUrl: options.baseUrl,
+      instanceId: options.instanceId,
+      userId: options.userId
+    });
+    let ai;
+    if (resolved.aiEnabled) {
+      ai = {
+        model: resolved.aiModel,
+        temperature: resolved.aiTemperature,
+        apiKey: process.env.GENICE_API_KEY ?? ""
+      };
+    }
+    return { env, runner: resolved.runner, ai };
+  }
+  async selectSummary(runner, key, options) {
+    if (options.all) return runner.runAll();
+    if (options.tag) {
+      const summary = await runner.runByTag(options.tag);
+      if (summary.results.length === 0) {
+        process.stderr.write(
+          `Warning: no scenarios matched tag "${options.tag}"
+`
+        );
+        process.exit(1);
+      }
+      return summary;
+    }
+    if (key) return runner.runByName(key);
+    process.stderr.write(
+      "Error: specify a scenario key (e.g. one-admin/export-navigation), --all, or --tag <tag>\n"
+    );
+    process.exit(1);
+    throw new Error("unreachable");
+  }
+};
+
+// lib/cli/commands/listCommand.ts
+var ListCommand = class {
+  register(program, deps) {
+    program.command("list").description("List all registered scenarios").option("--tag <tag>", "Filter by tag").action((options) => {
+      const entries = options.tag ? deps.registry.filterByTag(options.tag) : deps.registry.list();
+      if (entries.length === 0) {
+        process.stdout.write("No scenarios found.\n");
+        return;
+      }
+      const keyWidth = Math.max(...entries.map((e) => e.key.length), 32);
+      process.stdout.write(`
+REGISTERED SCENARIOS (${entries.length})
+
+`);
+      entries.forEach(({ key, scenario }) => {
+        const tags = scenario.tags?.length ? `[${scenario.tags.join(", ")}]` : "";
+        process.stdout.write(
+          `  ${key.padEnd(keyWidth)}  ${tags.padEnd(20)}  ${scenario.description}
+`
+        );
+      });
+      process.stdout.write("\n");
+    });
+  }
+};
+
+// lib/registry/scenarioRegistry.ts
+var ScenarioRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  register(group) {
+    group.scenarios.forEach((scenario) => {
+      const key = `${group.microapp}/${scenario.id}`;
+      if (this.entries.has(key)) {
+        throw new Error(`Duplicate scenario: ${key}`);
+      }
+      this.entries.set(key, scenario);
+    });
+    return this;
+  }
+  get(key) {
+    return this.entries.get(key);
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  size() {
+    return this.entries.size;
+  }
+  list() {
+    return Array.from(this.entries.entries()).map(([key, scenario]) => ({ key, scenario })).sort((a, b) => a.key.localeCompare(b.key));
+  }
+  filterByTag(tag) {
+    return this.list().filter((entry) => entry.scenario.tags?.includes(tag));
+  }
+};
+
+// lib/scenarios/one-admin/page-models/SelectSettingsPageModel.ts
+var SelectSettingsPageModel = class {
+  constructor(frame) {
+    this.frame = frame;
+  }
+  get container() {
+    return this.frame.locator("#one-admin-console-container");
+  }
+  get exportButton() {
+    return this.frame.getByRole("button", { name: "Export" });
+  }
+  async expandTreeItem(name) {
+    const treeItem = this.frame.locator(
+      `[role="treeitem"]:has-text("${name}")`
+    );
+    await treeItem.locator('button[aria-label*="expand"], button[aria-label*="toggle"]').click();
+  }
+  async selectTreeItem(name) {
+    await this.frame.locator(`[role="treeitem"]:has-text("${name}")`).click();
+  }
+  async clickExport() {
+    await this.exportButton.click();
+  }
+};
+
+// lib/scenarios/one-admin/page-models/ExportPageModel.ts
+var IFRAME_SELECTOR = "iframe#pui-iframe-container-emAdminUI";
+var SETTINGS_URL_PATTERN = /\/admin\/oneadmin\/migrate(?:\/)?$/;
+var ExportPageModel = class {
+  constructor(frame) {
+    this.frame = frame;
+  }
+  get sourceDataTab() {
+    return this.frame.getByRole("tab", { name: /Source Data/i });
+  }
+  get dataTable() {
+    return this.frame.locator('[role="table"]').first();
+  }
+  static async clickBackAndWaitForSettings(page) {
+    await Promise.all([
+      page.waitForURL(SETTINGS_URL_PATTERN),
+      page.frameLocator(IFRAME_SELECTOR).getByRole("button", { name: /back/i }).click()
+    ]);
+  }
+};
+
+// lib/scenarios/one-admin/export-navigation.scenario.ts
+var exportNavigationScenario = {
+  id: "export-navigation",
+  name: "Export Navigation",
+  description: "Navigate to export page and come back - verify iframe GC",
+  tags: ["critical"],
+  microappSelector: "iframe#pui-iframe-container-emAdminUI",
+  url: () => "/admin/oneadmin/migrate",
+  async action(page, frame) {
+    const settings = new SelectSettingsPageModel(frame);
+    await settings.container.waitFor({ state: "visible" });
+    await settings.expandTreeItem("eFolder");
+    await settings.selectTreeItem("Enhanced Conditions");
+    await settings.clickExport();
+    const exportPage = new ExportPageModel(frame);
+    await exportPage.sourceDataTab.waitFor({ state: "visible" });
+    await exportPage.dataTable.waitFor({ state: "visible" });
+  },
+  async back(page) {
+    await ExportPageModel.clickBackAndWaitForSettings(page);
+  },
+  repeat: () => 3,
+  thresholds: {
+    maxRetainedSizeDeltaBytes: 10 * 1024 * 1024,
+    maxNewLeakGroups: 0
+  }
+};
+
+// lib/scenarios/one-admin/index.ts
+var oneAdminScenarios = [
+  exportNavigationScenario
+];
+
+// lib/scenarios/index.ts
+var scenarioRegistry = new ScenarioRegistry().register({
+  microapp: "one-admin",
+  scenarios: oneAdminScenarios
+});
+
+// lib/cli/index.ts
+function buildProgram(deps = defaultDeps()) {
+  const program = new Command();
+  program.name("leak-runner").description("Microapp memory leak runner for Encompass Web").version("1.0.0");
+  const commands = [new RunCommand(), new ListCommand()];
+  commands.forEach((cmd) => cmd.register(program, deps));
+  return program;
+}
+function defaultDeps() {
+  return {
+    registry: scenarioRegistry,
+    envParams: new RequiredEnvParamsResolver()
+  };
+}
+
+// bin/leak-runner.ts
+buildProgram().parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`Fatal: ${err.message ?? String(err)}
+`);
+  process.exit(1);
+});