next-leak 0.1.2 → 0.2.0

package/dist/bootstrap.js

@@ -1,5 +1,5 @@
 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 "./chunk-PF7KYD5N.js";
+import "./chunk-6XYFBOL2.js";
 
 // src/bootstrap.ts
 import { mkdir, writeFile } from "fs/promises";

package/dist/{chunk-PF7KYD5N.js → chunk-6XYFBOL2.js}

@@ -11,11 +11,20 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)

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

package/dist/{chunk-WHC6S57X.js → chunk-HAKKAIHN.js}

@@ -1,9 +1,12 @@
 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 {
   __commonJS,
   __esm,
@@ -11,7 +14,7 @@ import {
   __require,
   __toCommonJS,
   __toESM
-} from "./chunk-PF7KYD5N.js";
+} from "./chunk-6XYFBOL2.js";
 
 // node_modules/.pnpm/fs-extra@4.0.3/node_modules/fs-extra/lib/util/assign.js
 var require_assign = __commonJS({
@@ -91969,14 +91972,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 +92024,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 +92055,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 +92075,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 +92131,7 @@ function parseCliArgs(argv) {
     requests: null,
     connections: null,
     idleSeconds: null,
+    maxOldSpaceMb: null,
     quick: false,
     diffAll: false,
     output: null
@@ -92162,6 +92181,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);
@@ -92209,7 +92229,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
@@ -92304,69 +92324,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`;
@@ -92475,11 +92432,14 @@ function formatReport(report) {
   for (const route of report.routes) {
     lines.push(...routeLines(route));
   }
-  lines.push("", `snapshots and run.json: ${report.workDir}`);
-  lines.push(`report: ${report.bundle.htmlReport}`);
-  for (const issue of report.bundle.issues) {
-    lines.push(`issue draft (${issue.route}): ${issue.file}`);
-  }
+  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}`)
+  );
   const inconclusive = report.routes.filter(
     (route) => route.status === "measured" && effectiveVerdict(route) === "inconclusive"
   );
@@ -92582,7 +92542,7 @@ function classifySource(rawSource) {
   }
   const nodeModulesSplit = source.split("/node_modules/");
   if (nodeModulesSplit.length > 1) {
-    const tail = nodeModulesSplit[nodeModulesSplit.length - 1] ?? "";
+    const tail = nodeModulesSplit.at(-1) ?? "";
     const segments = tail.split("/");
     const packageName = (segments[0]?.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0]) ?? null;
     if (packageName === "next" || packageName === "react" || packageName === "react-dom") {
@@ -92890,6 +92850,16 @@ var routesManifestSchema = z3.looseObject({
 });
 var INTERNAL_PATHS = /* @__PURE__ */ new Set(["/_global-error", "/_not-found"]);
 var INTERCEPTING_SEGMENT = /^(\(\.{1,3}\))+/;
+var STATIC_ASSET_PATHS = /* @__PURE__ */ new Set(["/favicon.ico"]);
+function unaddressableReason(routePath) {
+  if (routePath.split("/").some((segment) => INTERCEPTING_SEGMENT.test(segment))) {
+    return "intercepting route \u2014 only reachable via client navigation";
+  }
+  if (STATIC_ASSET_PATHS.has(routePath)) {
+    return "static asset served by a generated handler \u2014 no user code to leak";
+  }
+  return void 0;
+}
 function toRequestPath(manifestKey) {
   let kind;
   let withoutSuffix;
@@ -92927,14 +92897,12 @@ function discoverRoutes(appPaths) {
     if (parsed === null || INTERNAL_PATHS.has(parsed.path) || routes.has(parsed.path)) {
       continue;
     }
-    const intercepting = parsed.path.split("/").some((segment) => INTERCEPTING_SEGMENT.test(segment));
+    const reason = unaddressableReason(parsed.path);
     routes.set(parsed.path, {
       path: parsed.path,
       kind: parsed.kind,
       dynamic: parsed.path.includes("["),
-      ...intercepting && {
-        unaddressableReason: "intercepting route \u2014 only reachable via client navigation"
-      }
+      ...reason !== void 0 && { unaddressableReason: reason }
     });
   }
   return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
@@ -93283,55 +93251,55 @@ Host: ${target.host}\r
     errors: 0
   };
   let remaining = options.amount;
+  const sendOne = () => new Promise((resolve) => {
+    const socket = net.connect({ host: target.hostname, port });
+    let settled = false;
+    let responseStarted = false;
+    let timer;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve();
+    };
+    const giveUp = () => {
+      if (!settled) {
+        result.abandoned += 1;
+        if (responseStarted) {
+          result.abandonedMidStream += 1;
+        }
+      }
+      finish();
+    };
+    socket.once("connect", () => {
+      result.sent += 1;
+      socket.write(request2);
+      timer = setTimeout(giveUp, options.abandonAfterMs);
+      timer.unref();
+    });
+    socket.on("data", () => {
+      responseStarted = true;
+    });
+    socket.once("end", () => {
+      if (!settled) {
+        result.completed += 1;
+      }
+      finish();
+    });
+    socket.once("error", () => {
+      if (!settled) {
+        result.errors += 1;
+      }
+      finish();
+    });
+  });
   const worker = async () => {
     while (remaining > 0) {
       remaining -= 1;
-      await new Promise((resolve) => {
-        const socket = net.connect({ host: target.hostname, port });
-        let settled = false;
-        let responseStarted = false;
-        let timer;
-        const finish = () => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          clearTimeout(timer);
-          socket.destroy();
-          resolve();
-        };
-        socket.once("connect", () => {
-          result.sent += 1;
-          socket.write(request2);
-          timer = setTimeout(() => {
-            if (!settled) {
-              result.abandoned += 1;
-              if (responseStarted) {
-                result.abandonedMidStream += 1;
-              }
-            }
-            finish();
-          }, options.abandonAfterMs);
-          timer.unref();
-        });
-        socket.on("data", () => {
-          responseStarted = true;
-        });
-        socket.once("end", () => {
-          if (!settled) {
-            result.completed += 1;
-          }
-          clearTimeout(timer);
-          finish();
-        });
-        socket.once("error", () => {
-          if (!settled) {
-            result.errors += 1;
-          }
-          clearTimeout(timer);
-          finish();
-        });
-      });
+      await sendOne();
     }
   };
   await Promise.all(
@@ -93373,7 +93341,7 @@ var RITUAL_DEFAULTS = {
   warmupRequests: 200,
   loadRequests: 5e3,
   connections: 100,
-  cycles: 3,
+  cycles: 4,
   idleMs: 3e4
 };
 async function runRitual(options, deps = defaultDeps) {
@@ -93386,24 +93354,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 = [];
@@ -93488,6 +93452,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,
@@ -93497,8 +93462,9 @@ async function runRitual(options, deps = defaultDeps) {
       memorySamples,
       baselineSnapshot: baseline.file,
       afterSnapshot,
-      trend: classifyMemoryTrend(samples, externalSamples),
-      requestsPerCycle: loadRequests
+      trend: classifyMemoryTrend(samples, externalSamples, { minGrowthPerCycle }),
+      requestsPerCycle: loadRequests,
+      minGrowthPerCycle
     };
   } finally {
     await app.close();
@@ -93682,9 +93648,20 @@ import { createServer } from "net";
 import path6 from "path";
 var ESTIMATED_RPS = 250;
 var PER_ROUTE_OVERHEAD_SECONDS = 10;
-function estimateRunSeconds(routeCount, parameters) {
-  const perRoute = parameters.warmupRequests / ESTIMATED_RPS + parameters.cycles * (parameters.loadRequests / ESTIMATED_RPS + parameters.idleMs / 1e3) + PER_ROUTE_OVERHEAD_SECONDS;
-  return Math.round(routeCount * perRoute);
+var MIN_SETTLE_SECONDS = 4;
+function estimateRun(routeCount, parameters) {
+  const settleSeconds = Math.min(MIN_SETTLE_SECONDS, parameters.idleMs / 1e3);
+  const slowPerRoute = parameters.warmupRequests / ESTIMATED_RPS + parameters.cycles * (parameters.loadRequests / ESTIMATED_RPS + parameters.idleMs / 1e3) + PER_ROUTE_OVERHEAD_SECONDS;
+  const fastPerRoute = PER_ROUTE_OVERHEAD_SECONDS + parameters.cycles * settleSeconds;
+  return {
+    fastSeconds: Math.round(routeCount * fastPerRoute),
+    slowSeconds: Math.round(routeCount * slowPerRoute)
+  };
+}
+function formatEstimate(estimate) {
+  const fast = formatDuration(estimate.fastSeconds);
+  const slow = formatDuration(estimate.slowSeconds);
+  return fast === slow ? `\u2248 ${slow}` : `\u2248 ${fast}\u2013${slow}`;
 }
 function formatDuration(seconds) {
   if (seconds < 90) {
@@ -93732,7 +93709,7 @@ function rssTrend(memorySamples) {
   return deltas.reduce((sum, delta) => sum + delta, 0) / deltas.length;
 }
 function routeSlug(route) {
-  const sanitized = route.replaceAll(/[^a-zA-Z0-9-]+/g, "_").replace(/^_+/, "").replace(/_+$/, "");
+  const sanitized = route.replaceAll(/[^a-zA-Z0-9-]+/g, "_").replace(/^_/, "").replace(/_$/, "");
   if (route === "/") {
     return "root";
   }
@@ -93742,9 +93719,16 @@ function routeSlug(route) {
   const digest = createHash3("sha1").update(route).digest("hex").slice(0, 6);
   return sanitized === "" ? `route-${digest}` : `${sanitized}-${digest}`;
 }
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
 function filterRoutes(routes, selectors, progress) {
   const matches = (routePath, selector) => {
-    const normalized = selector.replace(/[/]+$/, "");
+    const normalized = trimTrailingSlashes(selector);
     if (normalized === "") {
       return routePath === "/";
     }
@@ -93779,6 +93763,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
@@ -93788,6 +93773,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
     }
@@ -93822,8 +93812,8 @@ async function measureRoute(context, route, requestPath, index) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-I4PNSLKY.js");
-  const { renderIssueMarkdown } = await import("./issue-report-VQEUXP2E.js");
+  const { renderHtmlReport } = await import("./html-report-2SOTNXDG.js");
+  const { renderIssueMarkdown } = await import("./issue-report-X5JYAVN5.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
       const file = path6.join(workDir, `ISSUE-${routeSlug(route.route)}.md`);
@@ -93865,22 +93855,25 @@ 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 estimatedSeconds = estimateRunSeconds(
-    routes.filter((route) => resolveRoutePath(route.path, routeConfig) !== null).length,
-    parameters
-  );
+  const measurable = routes.filter(
+    (route) => skipReason(route, resolveRoutePath(route.path, routeConfig)) === null
+  ).length;
+  const estimate = estimateRun(measurable, parameters);
   progress(
-    `${routes.length} routes discovered \xB7 estimated \u2248 ${formatDuration(estimatedSeconds)}` + // Long default runs are where first-time users give up; point at the two
+    `${routes.length} routes discovered` + (measurable === routes.length ? "" : ` \xB7 ${measurable} measurable`) + ` \xB7 estimated ${formatEstimate(estimate)}` + // Long default runs are where first-time users give up; point at the two
     // ways out. Suppressed once load parameters were tuned by hand (or by
     // --quick, which arrives here as explicit loadRequests/idleMs).
-    (estimatedSeconds > 15 * 60 && options.loadRequests === void 0 && options.idleMs === void 0 ? " \u2014 use --quick for the fast validated preset, or narrow with --routes" : "")
+    (estimate.slowSeconds > 15 * 60 && options.loadRequests === void 0 && options.idleMs === void 0 ? " \u2014 use --quick for the fast validated preset, or narrow with --routes" : "")
   );
   return { routes, routeConfig, registry, nextVersion, parameters };
 }
@@ -93945,7 +93938,6 @@ export {
   LaunchError,
   killActiveChildren,
   launchInstrumented,
-  classifyTrend,
   formatReport,
   RouteConfigError,
   ROUTE_CONFIG_FILE,