next-leak 0.1.3 → 0.3.0

package/dist/bootstrap.js

@@ -48,6 +48,10 @@ async function startControlServer(options) {
         respond(200, sampleMemory(gcExposed));
         return;
       }
+      if (url.pathname === "/mem") {
+        respond(200, sampleMemory(typeof g.gc === "function"));
+        return;
+      }
       if (url.pathname === "/snapshot") {
         const name = url.searchParams.get("name");
         if (name === null || name === "") {

package/dist/{chunk-ZFYIR423.js → chunk-2BQ5KXIJ.js}

@@ -1,9 +1,16 @@
 import { createRequire as __nextLeakCreateRequire } from 'node:module';import { fileURLToPath as __nextLeakFileURLToPath } from 'node:url';import { dirname as __nextLeakDirname } from 'node:path';const require = __nextLeakCreateRequire(import.meta.url);const __filename = __nextLeakFileURLToPath(import.meta.url);const __dirname = __nextLeakDirname(__filename);
 import {
   assessConfidence,
+  classifyMemoryTrend,
+  classifyTrend,
   effectiveVerdict,
+  minGrowthFor,
   warrantsIssueDraft
-} from "./chunk-2BQZCZ4Z.js";
+} from "./chunk-E5ZKAANQ.js";
+import {
+  assessPeakPressure,
+  describePeakPressure
+} from "./chunk-XHPUAMJG.js";
 import {
   __commonJS,
   __esm,
@@ -91969,14 +91976,20 @@ var FLAGS = [
     argName: "<list>",
     help: "Only measure these routes \u2014 comma-separated templates or prefixes (e.g. /api,/dashboard)"
   },
-  { flag: "--cycles", value: "int", argName: "<n>", help: "Load cycles per route (default 3, minimum 3)" },
+  { flag: "--cycles", value: "int", argName: "<n>", help: "Load cycles per route (default 4, minimum 3)" },
   { flag: "--requests", value: "int", argName: "<n>", help: "Requests per cycle (default 5000)" },
   { flag: "--connections", value: "int", argName: "<n>", help: "Concurrent connections (default 100)" },
   { flag: "--idle", value: "int", argName: "<seconds>", help: "Idle seconds before each sample (default 30)" },
+  {
+    flag: "--max-old-space",
+    value: "int",
+    argName: "<mb>",
+    help: "Heap cap of each measured process (default 512) \u2014 raise it for apps whose working set is larger"
+  },
   {
     flag: "--quick",
     value: "none",
-    help: "Fast preset: 2000 requests x 4 cycles, 8s idle \u2014 the profile used for real-app validation"
+    help: "Fast preset: 2000 requests x 4 cycles, 8s idle \u2014 same cycle count as the default, less traffic per cycle"
   },
   { flag: "--diff-all", value: "none", help: "Diff snapshots for stable routes too (slow)" },
   { flag: "--output", value: "string", argName: "<dir>", help: "Where to write runs (default <app-dir>/.next-leak)" },
@@ -92015,8 +92028,10 @@ var LIMITS = {
   "--cycles": 100,
   "--requests": 1e6,
   "--connections": 1e4,
-  "--idle": 3600
+  "--idle": 3600,
+  "--max-old-space": 65536
 };
+var MIN_MAX_OLD_SPACE_MB = 128;
 function findSpec(argument) {
   return FLAGS.find((spec) => spec.flag === argument || spec.alias === argument);
 }
@@ -92044,10 +92059,16 @@ function applyNumericFlag(flag, value, options) {
   if (flag === "--cycles" && parsed < 3) {
     return flagError("the trend verdict needs at least 3 cycles (--cycles 3 or more)");
   }
+  if (flag === "--max-old-space" && parsed < MIN_MAX_OLD_SPACE_MB) {
+    return flagError(
+      `option "--max-old-space" needs at least ${MIN_MAX_OLD_SPACE_MB} MB (got ${parsed}) \u2014 below that the measured app cannot start`
+    );
+  }
   if (flag === "--cycles") options.cycles = parsed;
   if (flag === "--requests") options.requests = parsed;
   if (flag === "--connections") options.connections = parsed;
   if (flag === "--idle") options.idleSeconds = parsed;
+  if (flag === "--max-old-space") options.maxOldSpaceMb = parsed;
   return FLAG_OK;
 }
 function applyFlag(spec, value, options) {
@@ -92058,6 +92079,7 @@ function applyFlag(spec, value, options) {
     case "--requests":
     case "--connections":
     case "--idle":
+    case "--max-old-space":
       return applyNumericFlag(spec.flag, value, options);
     case "--quick":
       options.quick = true;
@@ -92113,6 +92135,7 @@ function parseCliArgs(argv) {
     requests: null,
     connections: null,
     idleSeconds: null,
+    maxOldSpaceMb: null,
     quick: false,
     diffAll: false,
     output: null
@@ -92162,6 +92185,7 @@ import path from "path";
 import { pathToFileURL } from "url";
 import { z } from "zod";
 var controlFileSchema = z.object({ port: z.number(), pid: z.number() });
+var DEFAULT_MAX_OLD_SPACE_MB = 512;
 var LaunchError = class extends Error {
   constructor(message) {
     super(message);
@@ -92185,6 +92209,12 @@ function explainStartupFailure(stderr) {
   return `stderr:
 ${stderr}`;
 }
+function explainRuntimeFailure(stderr, maxOldSpaceMb) {
+  if (/heap out of memory|Reached heap limit|Ineffective mark-compacts/i.test(stderr)) {
+    return `the measured process ran out of heap and was killed by V8 mid-run (limit in force: --max-old-space-size=${maxOldSpaceMb} MB). That is the measurement: this route does not fit in ${maxOldSpaceMb} MB under this load. Raise it with --max-old-space <mb> to match your deployment, or lower --requests/--connections to measure a lighter regime.`;
+  }
+  return `the measured process exited mid-run. ${explainStartupFailure(stderr)}`;
+}
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function pollUntil(deadline, what, probe, failed) {
   for (; ; ) {
@@ -92209,7 +92239,7 @@ async function launchInstrumented(options) {
     process.execPath,
     [
       "--expose-gc",
-      `--max-old-space-size=${options.maxOldSpaceMb ?? 512}`,
+      `--max-old-space-size=${options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB}`,
       "--import",
       pathToFileURL(options.bootstrapPath).href,
       options.serverPath
@@ -92287,6 +92317,7 @@ async function launchInstrumented(options) {
       pid: child.pid ?? -1,
       appPort: options.appPort,
       controlPort,
+      explainExit: () => exited ? explainRuntimeFailure(stderrTail, options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB) : null,
       close: async () => {
         if (exited) {
           return;
@@ -92304,69 +92335,6 @@ async function launchInstrumented(options) {
   }
 }
 
-// src/trend.ts
-var DEFAULT_MIN_GROWTH = 256 * 1024;
-var STEPWISE_MIN_GROWING_CYCLES = 2;
-var STEPWISE_MAX_DRAWDOWN_RATIO = 0.1;
-function maxDrawdown(samples) {
-  let peak = samples[1] ?? 0;
-  let worst = 0;
-  for (let i = 1; i < samples.length; i += 1) {
-    const value = samples[i] ?? 0;
-    peak = Math.max(peak, value);
-    worst = Math.max(worst, peak - value);
-  }
-  return worst;
-}
-function isStepwiseGrowth(samples, deltas, growingCycles, mean, minGrowth) {
-  if (growingCycles < STEPWISE_MIN_GROWING_CYCLES || mean < minGrowth) {
-    return false;
-  }
-  const netGrowth = deltas.reduce((sum, delta) => sum + delta, 0);
-  if (netGrowth <= 0) {
-    return false;
-  }
-  return maxDrawdown(samples) <= netGrowth * STEPWISE_MAX_DRAWDOWN_RATIO;
-}
-function classifyTrend(samples, options = {}) {
-  const minGrowth = options.minGrowthPerCycle ?? DEFAULT_MIN_GROWTH;
-  if (samples.length < 4) {
-    return { verdict: "inconclusive", growthPerCycle: 0, deltas: [] };
-  }
-  const deltas = [];
-  for (let i = 2; i < samples.length; i += 1) {
-    const current = samples[i];
-    const previous = samples[i - 1];
-    if (current === void 0 || previous === void 0) {
-      return { verdict: "inconclusive", growthPerCycle: 0, deltas: [] };
-    }
-    deltas.push(current - previous);
-  }
-  const mean = deltas.reduce((sum, d) => sum + d, 0) / deltas.length;
-  const allGrow = deltas.every((d) => d >= minGrowth);
-  const anyFlatOrDown = deltas.some((d) => d <= 0);
-  const growingCycles = deltas.filter((d) => d >= minGrowth).length;
-  if (allGrow) {
-    return { verdict: "leak", growthPerCycle: mean, deltas, source: "heap" };
-  }
-  if (isStepwiseGrowth(samples, deltas, growingCycles, mean, minGrowth)) {
-    return { verdict: "leak", growthPerCycle: mean, deltas, source: "heap" };
-  }
-  if (anyFlatOrDown || mean < minGrowth) {
-    return { verdict: "stable", growthPerCycle: mean, deltas, source: "heap" };
-  }
-  return { verdict: "inconclusive", growthPerCycle: mean, deltas, source: "heap" };
-}
-function classifyMemoryTrend(heapSamples, externalSamples, options = {}) {
-  const heap = classifyTrend(heapSamples, options);
-  const external = classifyTrend(externalSamples, options);
-  const severity = { leak: 0, inconclusive: 1, stable: 2 };
-  if (severity[external.verdict] < severity[heap.verdict]) {
-    return { ...external, source: "external" };
-  }
-  return heap;
-}
-
 // src/report.ts
 var MB = 1024 * 1024;
 var formatMb = (bytes) => `${(bytes / MB).toFixed(1)} MB`;
@@ -92452,7 +92420,19 @@ function findingLines(route) {
   }
   return lines;
 }
-function routeLines(route) {
+function peakPressureLines(route, parameters) {
+  const retained = route.memorySamples.at(-1)?.heapUsed;
+  if (retained === void 0) {
+    return [];
+  }
+  const pressure = assessPeakPressure({
+    peaks: route.peaks,
+    retainedHeapBytes: retained,
+    maxOldSpaceMb: parameters.maxOldSpaceMb
+  });
+  return pressure === null ? [] : [`      \u25B2 peak pressure: ${describePeakPressure(pressure)}`];
+}
+function routeLines(route, parameters) {
   if (route.status === "skipped") {
     return [`  \u2013 ${route.route}  skipped: ${route.reason}`];
   }
@@ -92467,16 +92447,19 @@ function routeLines(route) {
     )})  heap ${curve}`,
     ...confidenceLines(route),
     ...memorySourceLines(route, verdict),
+    ...peakPressureLines(route, parameters),
     ...findingLines(route)
   ];
 }
 function formatReport(report) {
   const lines = [`next-leak \u2014 ${report.appDir}`, ""];
   for (const route of report.routes) {
-    lines.push(...routeLines(route));
+    lines.push(...routeLines(route, report.parameters));
   }
+  const { minGrowthPerCycle, loadRequests, cycles, maxOldSpaceMb } = report.parameters;
   lines.push(
     "",
+    `judged over ${cycles} cycles \xD7 ${loadRequests} requests, growth gate ${(minGrowthPerCycle / 1024).toFixed(0)} KiB/cycle (${formatGrowth(minGrowthPerCycle / loadRequests * 1e3)}), heap cap ${maxOldSpaceMb} MB`,
     `snapshots and run.json: ${report.workDir}`,
     `report: ${report.bundle.htmlReport}`,
     ...report.bundle.issues.map((issue) => `issue draft (${issue.route}): ${issue.file}`)
@@ -93260,6 +93243,9 @@ async function requestGc(port) {
   }
   return sample;
 }
+async function requestMemory(port) {
+  return sampleSchema.parse(await request(port, "/mem"));
+}
 async function requestSnapshot(port, name) {
   const parsed = snapshotResponseSchema.parse(
     await request(port, `/snapshot?name=${encodeURIComponent(name)}`)
@@ -93353,6 +93339,44 @@ Host: ${target.host}\r
 var MIN_POLLS_TO_JUDGE = 2;
 var SETTLE_POLL_MS = 2e3;
 var SETTLE_TOLERANCE = 0.01;
+var PEAK_POLL_MS = 250;
+function pollPeak(controlPort, phase, deps) {
+  const peak = {
+    phase,
+    heapUsed: 0,
+    external: 0,
+    arrayBuffers: 0,
+    rss: 0,
+    polls: 0
+  };
+  let running = true;
+  const loop = (async () => {
+    while (running) {
+      await deps.sleep(PEAK_POLL_MS);
+      if (!running) {
+        return;
+      }
+      let sample;
+      try {
+        sample = await deps.readMemory(controlPort);
+      } catch {
+        return;
+      }
+      peak.polls += 1;
+      peak.heapUsed = Math.max(peak.heapUsed, sample.heapUsed);
+      peak.external = Math.max(peak.external, sample.external);
+      peak.arrayBuffers = Math.max(peak.arrayBuffers, sample.arrayBuffers);
+      peak.rss = Math.max(peak.rss, sample.rss);
+    }
+  })();
+  return {
+    stop: async () => {
+      running = false;
+      await loop;
+      return peak;
+    }
+  };
+}
 async function waitUntilSettled(controlPort, maxIdleMs, deps) {
   const deadline = Date.now() + maxIdleMs;
   let previous = null;
@@ -93376,14 +93400,16 @@ async function waitUntilSettled(controlPort, maxIdleMs, deps) {
 var defaultDeps = {
   launch: launchInstrumented,
   load: runLoadPhase,
-  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  readMemory: requestMemory
 };
 var RITUAL_DEFAULTS = {
   warmupRequests: 200,
   loadRequests: 5e3,
   connections: 100,
-  cycles: 3,
-  idleMs: 3e4
+  cycles: 4,
+  idleMs: 3e4,
+  maxOldSpaceMb: 512
 };
 async function runRitual(options, deps = defaultDeps) {
   const warmupRequests = options.warmupRequests ?? RITUAL_DEFAULTS.warmupRequests;
@@ -93395,24 +93421,20 @@ async function runRitual(options, deps = defaultDeps) {
     throw new Error("the trend verdict needs at least 3 cycles");
   }
   await mkdir(options.workDir, { recursive: true });
+  const launchOptions = {
+    serverPath: options.serverPath,
+    workDir: options.workDir,
+    bootstrapPath: options.bootstrapPath,
+    ...options.maxOldSpaceMb !== void 0 && { maxOldSpaceMb: options.maxOldSpaceMb }
+  };
   let app;
   try {
-    app = await deps.launch({
-      serverPath: options.serverPath,
-      workDir: options.workDir,
-      appPort: options.appPort,
-      bootstrapPath: options.bootstrapPath
-    });
+    app = await deps.launch({ ...launchOptions, appPort: options.appPort });
   } catch (cause) {
     if (!String(cause).includes("EADDRINUSE")) {
       throw cause;
     }
-    app = await deps.launch({
-      serverPath: options.serverPath,
-      workDir: options.workDir,
-      appPort: options.appPort + 1,
-      bootstrapPath: options.bootstrapPath
-    });
+    app = await deps.launch({ ...launchOptions, appPort: options.appPort + 1 });
   }
   const timings = [];
   const loadOutcomes = [];
@@ -93476,9 +93498,17 @@ async function runRitual(options, deps = defaultDeps) {
       () => requestSnapshot(app.controlPort, "baseline")
     );
     const memorySamples = [baseline.sample];
+    const peaks = [];
     let afterSnapshot = "";
     for (let cycle = 1; cycle <= cycles; cycle += 1) {
-      await timed(`cycle ${cycle} load`, () => loadCycle(`cycle ${cycle}`, loadRequests));
+      await timed(`cycle ${cycle} load`, async () => {
+        const poller = pollPeak(app.controlPort, `cycle ${cycle}`, deps);
+        try {
+          await loadCycle(`cycle ${cycle}`, loadRequests);
+        } finally {
+          peaks.push(await poller.stop());
+        }
+      });
       const settle = await timed(
         `cycle ${cycle} settle`,
         () => waitUntilSettled(app.controlPort, idleMs, deps)
@@ -93497,6 +93527,7 @@ async function runRitual(options, deps = defaultDeps) {
     }
     const samples = memorySamples.map((sample) => sample.heapUsed);
     const externalSamples = memorySamples.map((sample) => sample.external);
+    const minGrowthPerCycle = minGrowthFor(loadRequests);
     return {
       route: options.route,
       timings,
@@ -93504,11 +93535,19 @@ async function runRitual(options, deps = defaultDeps) {
       settleOutcomes,
       samples,
       memorySamples,
+      peaks,
       baselineSnapshot: baseline.file,
       afterSnapshot,
-      trend: classifyMemoryTrend(samples, externalSamples),
-      requestsPerCycle: loadRequests
+      trend: classifyMemoryTrend(samples, externalSamples, { minGrowthPerCycle }),
+      requestsPerCycle: loadRequests,
+      minGrowthPerCycle
     };
+  } catch (cause) {
+    const death = app.explainExit();
+    if (death !== null) {
+      throw new Error(death);
+    }
+    throw cause;
   } finally {
     await app.close();
   }
@@ -93806,6 +93845,7 @@ async function measureRoute(context, route, requestPath, index) {
     ...options.connections !== void 0 && { connections: options.connections },
     ...options.cycles !== void 0 && { cycles: options.cycles },
     ...options.idleMs !== void 0 && { idleMs: options.idleMs },
+    ...options.maxOldSpaceMb !== void 0 && { maxOldSpaceMb: options.maxOldSpaceMb },
     ...routeConfig.headers !== void 0 && { headers: routeConfig.headers },
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
@@ -93815,6 +93855,11 @@ async function measureRoute(context, route, requestPath, index) {
     trend: result.trend,
     loadOutcomes: result.loadOutcomes,
     settleOutcomes: result.settleOutcomes,
+    // The audit has to grade against the gate the verdict actually used, or
+    // the noise-floor warning describes a threshold nobody applied.
+    minGrowthPerCycle: result.minGrowthPerCycle,
+    memorySamples: result.memorySamples,
+    maxOldSpaceMb: options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB,
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
     }
@@ -93834,6 +93879,7 @@ async function measureRoute(context, route, requestPath, index) {
     requestPath,
     samples: result.samples,
     memorySamples: result.memorySamples,
+    peaks: result.peaks,
     timings: result.timings,
     loadOutcomes: result.loadOutcomes,
     settleOutcomes: result.settleOutcomes,
@@ -93849,8 +93895,8 @@ async function measureRoute(context, route, requestPath, index) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-26DU7JFW.js");
-  const { renderIssueMarkdown } = await import("./issue-report-FUTEOHN5.js");
+  const { renderHtmlReport } = await import("./html-report-KQGUDYK5.js");
+  const { renderIssueMarkdown } = await import("./issue-report-HKA26WNV.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
       const file = path6.join(workDir, `ISSUE-${routeSlug(route.route)}.md`);
@@ -93892,12 +93938,15 @@ async function planRun(options, target, deps, progress) {
   progress(
     `module registry: ${registry.size} modules` + (nextVersion === null ? "" : ` \xB7 next ${nextVersion}`)
   );
+  const loadRequests = options.loadRequests ?? RITUAL_DEFAULTS.loadRequests;
   const parameters = {
     warmupRequests: options.warmupRequests ?? RITUAL_DEFAULTS.warmupRequests,
-    loadRequests: options.loadRequests ?? RITUAL_DEFAULTS.loadRequests,
+    loadRequests,
     connections: options.connections ?? RITUAL_DEFAULTS.connections,
     cycles: options.cycles ?? RITUAL_DEFAULTS.cycles,
-    idleMs: options.idleMs ?? RITUAL_DEFAULTS.idleMs
+    idleMs: options.idleMs ?? RITUAL_DEFAULTS.idleMs,
+    maxOldSpaceMb: options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB,
+    minGrowthPerCycle: minGrowthFor(loadRequests)
   };
   const measurable = routes.filter(
     (route) => skipReason(route, resolveRoutePath(route.path, routeConfig)) === null
@@ -93972,7 +94021,6 @@ export {
   LaunchError,
   killActiveChildren,
   launchInstrumented,
-  classifyTrend,
   formatReport,
   RouteConfigError,
   ROUTE_CONFIG_FILE,

package/dist/{chunk-C3KH5Z2W.js → chunk-BUNQT6VK.js}

@@ -1,7 +1,11 @@
 import { createRequire as __nextLeakCreateRequire } from 'node:module';import { fileURLToPath as __nextLeakFileURLToPath } from 'node:url';import { dirname as __nextLeakDirname } from 'node:path';const require = __nextLeakCreateRequire(import.meta.url);const __filename = __nextLeakFileURLToPath(import.meta.url);const __dirname = __nextLeakDirname(__filename);
 import {
   effectiveVerdict
-} from "./chunk-2BQZCZ4Z.js";
+} from "./chunk-E5ZKAANQ.js";
+import {
+  assessPeakPressure,
+  describePeakPressure
+} from "./chunk-XHPUAMJG.js";
 
 // src/html-report.ts
 var MB = 1024 * 1024;
@@ -36,7 +40,26 @@ function ownerCell(attribution) {
   const packageName = attribution.packageName ? ` (${escapeHtml(attribution.packageName)})` : "";
   return `${attribution.owner}${source}${packageName}`;
 }
-function measuredSection(route) {
+function peakBlock(route, parameters) {
+  const retained = route.memorySamples.at(-1)?.heapUsed;
+  if (retained === void 0 || route.peaks === void 0) {
+    return "";
+  }
+  const pressure = assessPeakPressure({
+    peaks: route.peaks,
+    retainedHeapBytes: retained,
+    maxOldSpaceMb: parameters.maxOldSpaceMb
+  });
+  const peakRows = route.peaks.filter((peak) => peak.polls > 0).map(
+    (peak) => `<tr><td>${escapeHtml(peak.phase)}</td><td>${(peak.heapUsed / MB).toFixed(1)} MB</td><td>${(peak.external / MB).toFixed(1)} MB</td><td>${(peak.arrayBuffers / MB).toFixed(1)} MB</td><td>${(peak.rss / MB).toFixed(1)} MB</td></tr>`
+  ).join("");
+  if (peakRows === "") {
+    return "";
+  }
+  const note = pressure === null ? "" : `<p class="warn">Peak pressure: ${escapeHtml(describePeakPressure(pressure))}</p>`;
+  return note + `<table><tr><th>peak during</th><th>heap</th><th>external</th><th>arrayBuffers</th><th>rss</th></tr>${peakRows}</table>`;
+}
+function measuredSection(route, parameters) {
   if (route.status !== "measured") {
     return "";
   }
@@ -51,7 +74,7 @@ function measuredSection(route) {
     const owner = ownerCell(attribution);
     return `<tr><td>${finding.kind}</td><td>${escapeHtml(finding.nodeType)}</td><td>${escapeHtml(finding.name)}</td><td>${(finding.retainedBytes / MB).toFixed(2)} MB</td><td>${owner}</td></tr>`;
   }).join("");
-  return `<section><h2><span class="badge" style="background:${color}">${verdict}</span> <code>${escapeHtml(route.route)}</code></h2>` + heapCurveSvg(route.samples, color) + `<p class="curve">heap ${curve} MB \xB7 ${(route.growthPer1000Requests / MB).toFixed(2)} MB/1000 req</p>` + withdrawn + warnings + (findingRows === "" ? "" : `<table><tr><th>kind</th><th>type</th><th>node</th><th>retained</th><th>owner</th></tr>${findingRows}</table>`) + `</section>`;
+  return `<section><h2><span class="badge" style="background:${color}">${verdict}</span> <code>${escapeHtml(route.route)}</code></h2>` + heapCurveSvg(route.samples, color) + `<p class="curve">heap ${curve} MB \xB7 ${(route.growthPer1000Requests / MB).toFixed(2)} MB/1000 req</p>` + withdrawn + warnings + peakBlock(route, parameters) + (findingRows === "" ? "" : `<table><tr><th>kind</th><th>type</th><th>node</th><th>retained</th><th>owner</th></tr>${findingRows}</table>`) + `</section>`;
 }
 function renderHtmlReport(run) {
   const measured = run.routes.filter((route) => route.status === "measured");
@@ -77,7 +100,8 @@ code{background:#f4f4f4;padding:0 4px;border-radius:3px}
   )} \xB7 ${escapeHtml(environment.platform)}/${escapeHtml(environment.arch)} \xB7 next ${escapeHtml(
     environment.nextVersion ?? "unknown"
   )} \xB7 next-leak ${escapeHtml(environment.nextLeakVersion)}</p>
-${measured.map(measuredSection).join("\n")}
+<p class="meta">${run.parameters.cycles} cycles \xD7 ${run.parameters.loadRequests} requests \xB7 heap cap ${run.parameters.maxOldSpaceMb} MB \xB7 growth gate ${(run.parameters.minGrowthPerCycle / 1024).toFixed(0)} KiB/cycle</p>
+${measured.map((route) => measuredSection(route, run.parameters)).join("\n")}
 ${skipped.length === 0 ? "" : `<h2>Skipped</h2><ul>${skipped.map((route) => `<li><code>${escapeHtml(route.route)}</code> \u2014 ${escapeHtml(route.status === "skipped" ? route.reason : "")}</li>`).join("")}</ul>`}
 ${failed.length === 0 ? "" : `<h2>Failed</h2><ul>${failed.map((route) => `<li><code>${escapeHtml(route.route)}</code> \u2014 ${escapeHtml(route.status === "failed" ? route.reason : "")}</li>`).join("")}</ul>`}
 <p class="meta">Raw snapshots and run.json live next to this file \u2014 verify in Chrome DevTools \u2192 Memory \u2192 Load.</p>

package/dist/{chunk-2BQZCZ4Z.js → chunk-E5ZKAANQ.js}

@@ -1,5 +1,72 @@
 import { createRequire as __nextLeakCreateRequire } from 'node:module';import { fileURLToPath as __nextLeakFileURLToPath } from 'node:url';import { dirname as __nextLeakDirname } from 'node:path';const require = __nextLeakCreateRequire(import.meta.url);const __filename = __nextLeakFileURLToPath(import.meta.url);const __dirname = __nextLeakDirname(__filename);
 
+// src/trend.ts
+var MIN_GROWTH_NOISE_FLOOR = 256 * 1024;
+var MIN_GROWTH_PER_1000_REQUESTS = 51.2 * 1024;
+function minGrowthFor(requestsPerCycle) {
+  return Math.max(MIN_GROWTH_NOISE_FLOOR, MIN_GROWTH_PER_1000_REQUESTS * requestsPerCycle / 1e3);
+}
+var STEPWISE_MIN_GROWING_CYCLES = 2;
+var STEPWISE_MAX_DRAWDOWN_RATIO = 0.1;
+function maxDrawdown(samples) {
+  let peak = samples[1] ?? 0;
+  let worst = 0;
+  for (let i = 1; i < samples.length; i += 1) {
+    const value = samples[i] ?? 0;
+    peak = Math.max(peak, value);
+    worst = Math.max(worst, peak - value);
+  }
+  return worst;
+}
+function isStepwiseGrowth(samples, deltas, growingCycles, mean, minGrowth) {
+  if (growingCycles < STEPWISE_MIN_GROWING_CYCLES || mean < minGrowth) {
+    return false;
+  }
+  const netGrowth = deltas.reduce((sum, delta) => sum + delta, 0);
+  if (netGrowth <= 0) {
+    return false;
+  }
+  return maxDrawdown(samples) <= netGrowth * STEPWISE_MAX_DRAWDOWN_RATIO;
+}
+function classifyTrend(samples, options = {}) {
+  const minGrowth = options.minGrowthPerCycle ?? MIN_GROWTH_NOISE_FLOOR;
+  if (samples.length < 4) {
+    return { verdict: "inconclusive", growthPerCycle: 0, deltas: [] };
+  }
+  const deltas = [];
+  for (let i = 2; i < samples.length; i += 1) {
+    const current = samples[i];
+    const previous = samples[i - 1];
+    if (current === void 0 || previous === void 0) {
+      return { verdict: "inconclusive", growthPerCycle: 0, deltas: [] };
+    }
+    deltas.push(current - previous);
+  }
+  const mean = deltas.reduce((sum, d) => sum + d, 0) / deltas.length;
+  const allGrow = deltas.every((d) => d >= minGrowth);
+  const anyFlatOrDown = deltas.some((d) => d <= 0);
+  const growingCycles = deltas.filter((d) => d >= minGrowth).length;
+  if (allGrow) {
+    return { verdict: "leak", growthPerCycle: mean, deltas, source: "heap" };
+  }
+  if (isStepwiseGrowth(samples, deltas, growingCycles, mean, minGrowth)) {
+    return { verdict: "leak", growthPerCycle: mean, deltas, source: "heap" };
+  }
+  if (anyFlatOrDown || mean < minGrowth) {
+    return { verdict: "stable", growthPerCycle: mean, deltas, source: "heap" };
+  }
+  return { verdict: "inconclusive", growthPerCycle: mean, deltas, source: "heap" };
+}
+function classifyMemoryTrend(heapSamples, externalSamples, options = {}) {
+  const heap = classifyTrend(heapSamples, options);
+  const external = classifyTrend(externalSamples, options);
+  const severity = { leak: 0, inconclusive: 1, stable: 2 };
+  if (severity[external.verdict] < severity[heap.verdict]) {
+    return { ...external, source: "external" };
+  }
+  return heap;
+}
+
 // src/confidence.ts
 function effectiveVerdict(report) {
   return report.confidence.supersededVerdict ?? report.trend.verdict;
@@ -11,7 +78,6 @@ var VERDICT_WEAKENING = /* @__PURE__ */ new Set([
 function warrantsIssueDraft(report) {
   return effectiveVerdict(report) === "leak" && !report.confidence.warnings.some((warning) => VERDICT_WEAKENING.has(warning.code));
 }
-var DEFAULT_MIN_GROWTH = 256 * 1024;
 var LOAD_COMPLETION_FLOOR = 0.99;
 var ABANDON_EFFECTIVE_FLOOR = 0.9;
 var MID_STREAM_FLOOR = 0.1;
@@ -99,6 +165,23 @@ function noiseFloorWarnings(trend, minGrowth) {
     detail: `growth of ${mb(trend.growthPerCycle)}/cycle barely clears the ${mb(minGrowth)} threshold \u2014 raise --load-requests so the signal outgrows the noise`
   }];
 }
+var HEAP_CEILING_RATIO = 0.7;
+function heapCeilingWarnings(input) {
+  const samples = input.memorySamples;
+  const capMb = input.maxOldSpaceMb;
+  if (samples === void 0 || capMb === void 0 || samples.length === 0) {
+    return [];
+  }
+  const peak = Math.max(...samples.map((sample) => sample.heapUsed));
+  const capBytes = capMb * 1024 * 1024;
+  if (peak < capBytes * HEAP_CEILING_RATIO) {
+    return [];
+  }
+  return [{
+    code: "near-heap-ceiling",
+    detail: `the heap peaked at ${mb(peak)} against a ${capMb} MB cap (${pct(peak, capBytes)}) \u2014 the curve may have been clipped by the ceiling rather than by the app; re-run with a larger --max-old-space`
+  }];
+}
 function isVerdictInvalid(input) {
   if (input.trend.verdict !== "leak") {
     return false;
@@ -108,12 +191,13 @@ function isVerdictInvalid(input) {
   return neverSettled || abandonedNothing;
 }
 function assessConfidence(input) {
-  const minGrowth = input.minGrowthPerCycle ?? DEFAULT_MIN_GROWTH;
+  const minGrowth = input.minGrowthPerCycle ?? MIN_GROWTH_NOISE_FLOOR;
   const warnings = [
     ...settleWarnings(input.settleOutcomes),
     ...loadWarnings(input.loadOutcomes, input.abandonAfterMs),
     ...growthShapeWarnings(input.trend),
-    ...noiseFloorWarnings(input.trend, minGrowth)
+    ...noiseFloorWarnings(input.trend, minGrowth),
+    ...heapCeilingWarnings(input)
   ];
   return {
     level: warnings.length === 0 ? "high" : "low",
@@ -123,6 +207,9 @@ function assessConfidence(input) {
 }
 
 export {
+  minGrowthFor,
+  classifyTrend,
+  classifyMemoryTrend,
   effectiveVerdict,
   warrantsIssueDraft,
   assessConfidence