@elliemae/encw-leak-runner 1.0.2

package/dist/cjs/analysis/thresholdEvaluator.js

@@ -0,0 +1,46 @@
+"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 thresholdEvaluator_exports = {};
+__export(thresholdEvaluator_exports, {
+  ThresholdEvaluator: () => ThresholdEvaluator
+});
+module.exports = __toCommonJS(thresholdEvaluator_exports);
+function toMB(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+class ThresholdEvaluator {
+  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("; ") };
+  }
+}

package/dist/cjs/browser/iframeHeapProfiler.js

@@ -0,0 +1,46 @@
+"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 iframeHeapProfiler_exports = {};
+__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 {
+  constructor(profiledPage, frame, outputDir) {
+    super(profiledPage, outputDir);
+    this.profiledPage = profiledPage;
+    this.frame = frame;
+  }
+  profiledPage;
+  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;
+    }
+  }
+}

package/dist/cjs/cli/command.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 command_exports = {};
+module.exports = __toCommonJS(command_exports);

package/dist/cjs/cli/commands/listCommand.js

@@ -0,0 +1,47 @@
+"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 listCommand_exports = {};
+__export(listCommand_exports, {
+  ListCommand: () => ListCommand
+});
+module.exports = __toCommonJS(listCommand_exports);
+class ListCommand {
+  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");
+    });
+  }
+}

package/dist/cjs/cli/commands/runCommand.js

@@ -0,0 +1,111 @@
+"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 runCommand_exports = {};
+__export(runCommand_exports, {
+  RunCommand: () => RunCommand
+});
+module.exports = __toCommonJS(runCommand_exports);
+var import_batchRunner = require("../../runner/batchRunner.js");
+var import_consoleReporter = require("../../reporting/consoleReporter.js");
+var import_junitReporter = require("../../reporting/junitReporter.js");
+var import_cliOverrideConfigSource = require("../../config/sources/cliOverrideConfigSource.js");
+var import_envVarConfigSource = require("../../config/sources/envVarConfigSource.js");
+var import_fileConfigSource = require("../../config/sources/fileConfigSource.js");
+var import_runnerConfigLoader = require("../../config/runnerConfigLoader.js");
+var import_requiredEnvParams = require("../../config/requiredEnvParams.js");
+class RunCommand {
+  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 import_batchRunner.BatchRunner(config, deps.registry);
+        const summary = await this.selectSummary(runner, key, options);
+        new import_consoleReporter.ConsoleReporter().write(summary);
+        await new import_junitReporter.JunitReporter().write(summary, config.runner.outputDir);
+        process.exit(summary.failCount > 0 ? 1 : 0);
+      } catch (err) {
+        if (err instanceof import_requiredEnvParams.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 import_runnerConfigLoader.RunnerConfigLoader([
+      new import_fileConfigSource.FileConfigSource(filePath),
+      new import_envVarConfigSource.EnvVarConfigSource(),
+      new import_cliOverrideConfigSource.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");
+  }
+}

package/dist/cjs/cli/index.js

@@ -0,0 +1,42 @@
+"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 cli_exports = {};
+__export(cli_exports, {
+  buildProgram: () => buildProgram,
+  defaultDeps: () => defaultDeps
+});
+module.exports = __toCommonJS(cli_exports);
+var import_commander = require("commander");
+var import_runCommand = require("./commands/runCommand.js");
+var import_listCommand = require("./commands/listCommand.js");
+var import_requiredEnvParams = require("../config/requiredEnvParams.js");
+var import_scenarios = require("../scenarios/index.js");
+function buildProgram(deps = defaultDeps()) {
+  const program = new import_commander.Command();
+  program.name("leak-runner").description("Microapp memory leak runner for Encompass Web").version("1.0.0");
+  const commands = [new import_runCommand.RunCommand(), new import_listCommand.ListCommand()];
+  commands.forEach((cmd) => cmd.register(program, deps));
+  return program;
+}
+function defaultDeps() {
+  return {
+    registry: import_scenarios.scenarioRegistry,
+    envParams: new import_requiredEnvParams.RequiredEnvParamsResolver()
+  };
+}

package/dist/cjs/config/missingRequiredParamError.js

@@ -0,0 +1,34 @@
+"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 missingRequiredParamError_exports = {};
+__export(missingRequiredParamError_exports, {
+  MissingRequiredParamError: () => MissingRequiredParamError
+});
+module.exports = __toCommonJS(missingRequiredParamError_exports);
+class MissingRequiredParamError 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";
+  }
+  missing;
+}

package/dist/cjs/config/requiredEnvParams.js

@@ -0,0 +1,57 @@
+"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 requiredEnvParams_exports = {};
+__export(requiredEnvParams_exports, {
+  MissingRequiredParamError: () => import_missingRequiredParamError.MissingRequiredParamError,
+  RequiredEnvParamsResolver: () => RequiredEnvParamsResolver
+});
+module.exports = __toCommonJS(requiredEnvParams_exports);
+var import_missingRequiredParamError = require("./missingRequiredParamError.js");
+class RequiredEnvParamsResolver {
+  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 import_missingRequiredParamError.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;
+  }
+}

package/dist/cjs/config/runnerConfigLoader.js

@@ -0,0 +1,73 @@
+"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 runnerConfigLoader_exports = {};
+__export(runnerConfigLoader_exports, {
+  RunnerConfigLoader: () => RunnerConfigLoader
+});
+module.exports = __toCommonJS(runnerConfigLoader_exports);
+var import_configSource = require("./sources/configSource.js");
+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
+  };
+}
+class RunnerConfigLoader {
+  constructor(sources) {
+    this.sources = sources;
+  }
+  sources;
+  resolveOptions() {
+    const ordered = [...this.sources].sort((a, b) => a.priority - b.priority);
+    const initial = {
+      runner: {
+        headless: import_configSource.BUILT_IN_DEFAULTS.runner.headless ?? true,
+        outputDir: import_configSource.BUILT_IN_DEFAULTS.runner.outputDir ?? "./leak-reports/",
+        topN: import_configSource.BUILT_IN_DEFAULTS.runner.topN ?? 5
+      },
+      ai: {
+        aiEnabled: import_configSource.BUILT_IN_DEFAULTS.ai.enabled ?? false,
+        aiModel: import_configSource.BUILT_IN_DEFAULTS.ai.model ?? "Claude3.7",
+        aiTemperature: import_configSource.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
+    };
+  }
+}

package/dist/cjs/config/runnerConfigSchema.js

@@ -0,0 +1,40 @@
+"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 runnerConfigSchema_exports = {};
+__export(runnerConfigSchema_exports, {
+  aiConfigFileSchema: () => aiConfigFileSchema,
+  runnerConfigFileSchema: () => runnerConfigFileSchema,
+  runnerOptionsSchema: () => runnerOptionsSchema
+});
+module.exports = __toCommonJS(runnerConfigSchema_exports);
+var import_zod = require("zod");
+const runnerOptionsSchema = import_zod.z.object({
+  headless: import_zod.z.boolean(),
+  outputDir: import_zod.z.string().min(1),
+  topN: import_zod.z.number().int().min(1)
+}).partial();
+const aiConfigFileSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean(),
+  model: import_zod.z.string().min(1),
+  temperature: import_zod.z.number().min(0).max(2)
+}).partial();
+const runnerConfigFileSchema = import_zod.z.object({
+  runner: runnerOptionsSchema,
+  ai: aiConfigFileSchema
+}).partial().strict();

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

@@ -0,0 +1,44 @@
+"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 cliOverrideConfigSource_exports = {};
+__export(cliOverrideConfigSource_exports, {
+  CliOverrideConfigSource: () => CliOverrideConfigSource
+});
+module.exports = __toCommonJS(cliOverrideConfigSource_exports);
+class CliOverrideConfigSource {
+  constructor(overrides) {
+    this.overrides = 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 };
+  }
+}

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

@@ -0,0 +1,35 @@
+"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 configSource_exports = {};
+__export(configSource_exports, {
+  BUILT_IN_DEFAULTS: () => BUILT_IN_DEFAULTS
+});
+module.exports = __toCommonJS(configSource_exports);
+const BUILT_IN_DEFAULTS = {
+  runner: {
+    headless: true,
+    outputDir: "./leak-reports/",
+    topN: 5
+  },
+  ai: {
+    enabled: false,
+    model: "Claude3.7",
+    temperature: 0.3
+  }
+};

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

@@ -0,0 +1,41 @@
+"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 envVarConfigSource_exports = {};
+__export(envVarConfigSource_exports, {
+  EnvVarConfigSource: () => EnvVarConfigSource
+});
+module.exports = __toCommonJS(envVarConfigSource_exports);
+class EnvVarConfigSource {
+  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 };
+  }
+}