@elliemae/encw-leak-runner 1.0.2

package/dist/cjs/config/sources/fileConfigSource.js

@@ -0,0 +1,62 @@
+"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 fileConfigSource_exports = {};
+__export(fileConfigSource_exports, {
+  FileConfigSource: () => FileConfigSource
+});
+module.exports = __toCommonJS(fileConfigSource_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_runnerConfigSchema = require("../runnerConfigSchema.js");
+class FileConfigSource {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  priority = 1;
+  name = "file";
+  load() {
+    if (!import_node_fs.default.existsSync(this.filePath)) return {};
+    const raw = import_node_fs.default.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 = import_runnerConfigSchema.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;
+  }
+}

package/dist/cjs/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  BatchRunner: () => import_batchRunner.BatchRunner,
+  CliOverrideConfigSource: () => import_cliOverrideConfigSource.CliOverrideConfigSource,
+  ConsoleReporter: () => import_consoleReporter.ConsoleReporter,
+  DEFAULT_THRESHOLDS: () => import_config.DEFAULT_THRESHOLDS,
+  EnvVarConfigSource: () => import_envVarConfigSource.EnvVarConfigSource,
+  FileConfigSource: () => import_fileConfigSource.FileConfigSource,
+  IframeHeapProfiler: () => import_iframeHeapProfiler.IframeHeapProfiler,
+  JunitReporter: () => import_junitReporter.JunitReporter,
+  MissingRequiredParamError: () => import_requiredEnvParams.MissingRequiredParamError,
+  RequiredEnvParamsResolver: () => import_requiredEnvParams.RequiredEnvParamsResolver,
+  RunnerConfigLoader: () => import_runnerConfigLoader.RunnerConfigLoader,
+  ScenarioRegistry: () => import_scenarioRegistry.ScenarioRegistry,
+  ScenarioRunner: () => import_scenarioRunner.ScenarioRunner,
+  ThresholdEvaluator: () => import_thresholdEvaluator.ThresholdEvaluator,
+  buildProgram: () => import_cli.buildProgram,
+  defaultDeps: () => import_cli.defaultDeps
+});
+module.exports = __toCommonJS(index_exports);
+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_iframeHeapProfiler = require("./browser/iframeHeapProfiler.js");
+var import_thresholdEvaluator = require("./analysis/thresholdEvaluator.js");
+var import_consoleReporter = require("./reporting/consoleReporter.js");
+var import_junitReporter = require("./reporting/junitReporter.js");
+var import_runnerConfigLoader = require("./config/runnerConfigLoader.js");
+var import_fileConfigSource = require("./config/sources/fileConfigSource.js");
+var import_envVarConfigSource = require("./config/sources/envVarConfigSource.js");
+var import_cliOverrideConfigSource = require("./config/sources/cliOverrideConfigSource.js");
+var import_requiredEnvParams = require("./config/requiredEnvParams.js");
+var import_cli = require("./cli/index.js");

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/dist/cjs/registry/scenarioRegistry.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var scenarioRegistry_exports = {};
+__export(scenarioRegistry_exports, {
+  ScenarioRegistry: () => ScenarioRegistry
+});
+module.exports = __toCommonJS(scenarioRegistry_exports);
+class ScenarioRegistry {
+  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));
+  }
+}

package/dist/cjs/reporting/consoleReporter.js

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var consoleReporter_exports = {};
+__export(consoleReporter_exports, {
+  ConsoleReporter: () => ConsoleReporter
+});
+module.exports = __toCommonJS(consoleReporter_exports);
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const BOLD = "\x1B[1m";
+const 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}`);
+  }
+}
+class ConsoleReporter {
+  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("");
+  }
+}

package/dist/cjs/reporting/junitReporter.js

@@ -0,0 +1,75 @@
+"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 junitReporter_exports = {};
+__export(junitReporter_exports, {
+  JunitReporter: () => JunitReporter
+});
+module.exports = __toCommonJS(junitReporter_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+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>`;
+}
+class JunitReporter {
+  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");
+    import_node_fs.default.mkdirSync(outputDir, { recursive: true });
+    import_node_fs.default.writeFileSync(import_node_path.default.join(outputDir, "test-results.xml"), xml, "utf8");
+    return Promise.resolve();
+  }
+}

package/dist/cjs/reporting/reporter.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reporter_exports = {};
+module.exports = __toCommonJS(reporter_exports);

package/dist/cjs/runner/aiEnhancementStep.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var aiEnhancementStep_exports = {};
+__export(aiEnhancementStep_exports, {
+  enhanceMarkdownIfConfigured: () => enhanceMarkdownIfConfigured
+});
+module.exports = __toCommonJS(aiEnhancementStep_exports);
+var import_encw_heap_doctor = require("@elliemae/encw-heap-doctor");
+async function enhanceMarkdownIfConfigured(report, config, scenarioName) {
+  if (!config.ai?.apiKey) return report.markdown;
+  try {
+    const enhancer = new import_encw_heap_doctor.AiEnhancer(config.ai);
+    await enhancer.enhance(report.afterAnalysis.leakResults);
+    return (0, import_encw_heap_doctor.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;
+  }
+}

package/dist/cjs/runner/batchRunner.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var batchRunner_exports = {};
+__export(batchRunner_exports, {
+  BatchRunner: () => BatchRunner
+});
+module.exports = __toCommonJS(batchRunner_exports);
+var import_scenarioRunner = require("./scenarioRunner.js");
+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
+  };
+}
+class BatchRunner {
+  constructor(config, registry) {
+    this.config = config;
+    this.registry = registry;
+    this.scenarioRunner = new import_scenarioRunner.ScenarioRunner(config);
+  }
+  config;
+  registry;
+  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();
+    }
+  }
+}

package/dist/cjs/runner/scenarioRunner.js

@@ -0,0 +1,165 @@
+"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 scenarioRunner_exports = {};
+__export(scenarioRunner_exports, {
+  ScenarioRunner: () => ScenarioRunner
+});
+module.exports = __toCommonJS(scenarioRunner_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_test = require("@playwright/test");
+var import_smoked_suite = require("@elliemae/smoked-suite");
+var import_iframeHeapProfiler = require("../browser/iframeHeapProfiler.js");
+var import_thresholdEvaluator = require("../analysis/thresholdEvaluator.js");
+var import_config = require("../types/config.js");
+var import_aiEnhancementStep = require("./aiEnhancementStep.js");
+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 && import_node_fs.default.existsSync(paths.before)) import_node_fs.default.unlinkSync(paths.before);
+  if (paths.after && import_node_fs.default.existsSync(paths.after)) import_node_fs.default.unlinkSync(paths.after);
+}
+class ScenarioRunner {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async launchBrowser() {
+    return import_test.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 = import_node_path.default.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 import_smoked_suite.AuthManager();
+    const pageSetup = new import_smoked_suite.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);
+    import_node_fs.default.mkdirSync(snapshotsDir, { recursive: true });
+    const profiler = new import_iframeHeapProfiler.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 = import_node_path.default.join(
+      this.config.runner.outputDir,
+      `${scenario.id}.md`
+    );
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(reportPath), { recursive: true });
+    const markdown = await (0, import_aiEnhancementStep.enhanceMarkdownIfConfigured)(
+      report,
+      this.config,
+      scenario.name
+    );
+    import_node_fs.default.writeFileSync(reportPath, markdown);
+  }
+  buildResult(input) {
+    const { scenario, report, error, startTime } = input;
+    const thresholds = {
+      ...import_config.DEFAULT_THRESHOLDS,
+      ...scenario.thresholds
+    };
+    const failureFallback = {
+      passed: false,
+      reason: error?.message ?? "Snapshot capture failed"
+    };
+    const thresholdResult = report && !error ? import_thresholdEvaluator.ThresholdEvaluator.evaluate(report, thresholds) : failureFallback;
+    return {
+      name: scenario.name,
+      passed: thresholdResult.passed,
+      thresholdResult,
+      report,
+      durationMs: Date.now() - startTime,
+      error
+    };
+  }
+}

package/dist/cjs/scenarios/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var scenarios_exports = {};
+__export(scenarios_exports, {
+  scenarioRegistry: () => scenarioRegistry
+});
+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
+});