next-leak 0.5.0 → 0.6.0

package/dist/{chunk-IDSNTUKC.js → chunk-AMSDGT3Y.js}

@@ -7,7 +7,7 @@ import {
   minGrowthFor,
   resolveCycles,
   warrantsIssueDraft
-} from "./chunk-2FZXZLZW.js";
+} from "./chunk-22PBLCGO.js";
 import {
   assessPeakPressure,
   describePeakPressure
@@ -161,7 +161,7 @@ var require_polyfills = __commonJS({
         })(fs.rename);
       }
       fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
-        function read(fd, buffer, offset, length, position, callback_) {
+        function read2(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
             var eagCounter = 0;
@@ -175,8 +175,8 @@ var require_polyfills = __commonJS({
           }
           return fs$read.call(fs, fd, buffer, offset, length, position, callback);
         }
-        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
-        return read;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read2, fs$read);
+        return read2;
       })(fs.read);
       fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
@@ -88693,7 +88693,7 @@ var require_buffer3 = __commonJS({
           byteOffset /= 2;
         }
       }
-      function read(buf, i2) {
+      function read2(buf, i2) {
         if (indexSize === 1) {
           return buf[i2];
         } else {
@@ -88704,7 +88704,7 @@ var require_buffer3 = __commonJS({
       if (dir) {
         var foundIndex = -1;
         for (i = byteOffset; i < arrLength; i++) {
-          if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+          if (read2(arr, i) === read2(val, foundIndex === -1 ? 0 : i - foundIndex)) {
             if (foundIndex === -1) foundIndex = i;
             if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
           } else {
@@ -88717,7 +88717,7 @@ var require_buffer3 = __commonJS({
         for (i = byteOffset; i >= 0; i--) {
           var found = true;
           for (var j = 0; j < valLength; j++) {
-            if (read(arr, i + j) !== read(val, j)) {
+            if (read2(arr, i + j) !== read2(val, j)) {
               found = false;
               break;
             }
@@ -91969,7 +91969,374 @@ var require_autocannon = __commonJS({
   }
 });
 
+// src/manifests.ts
+import { z } from "zod";
+var appPathsManifestSchema = z.record(z.string(), z.string());
+var pagesManifestSchema = z.record(z.string(), z.string());
+var routeEntrySchema = z.looseObject({
+  page: z.string(),
+  regex: z.string()
+});
+var routesManifestSchema = z.looseObject({
+  version: z.number(),
+  basePath: z.string(),
+  staticRoutes: z.array(routeEntrySchema),
+  dynamicRoutes: z.array(routeEntrySchema)
+});
+var prerenderManifestSchema = z.looseObject({
+  routes: z.record(
+    z.string(),
+    z.looseObject({
+      // `false` on a route that is prerendered but never revalidates.
+      initialRevalidateSeconds: z.union([z.number(), z.literal(false)]).optional(),
+      srcRoute: z.string().nullable().optional()
+    })
+  ).optional(),
+  preview: z.looseObject({ previewModeId: z.string() }).optional()
+});
+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;
+  if (manifestKey.endsWith("/page")) {
+    kind = "page";
+    withoutSuffix = manifestKey.slice(0, -"/page".length);
+  } else if (manifestKey.endsWith("/route")) {
+    kind = "route-handler";
+    withoutSuffix = manifestKey.slice(0, -"/route".length);
+  } else {
+    return null;
+  }
+  const segments = withoutSuffix.split("/").filter((segment) => segment !== "").filter((segment) => !(segment.startsWith("(") && segment.endsWith(")"))).filter((segment) => !segment.startsWith("@"));
+  return { path: `/${segments.join("/")}`, kind };
+}
+var PAGES_INTERNAL = /* @__PURE__ */ new Set(["/_app", "/_document", "/_error", "/404", "/500"]);
+function discoverPagesRoutes(pages) {
+  const routes = [];
+  for (const key of Object.keys(pages)) {
+    if (PAGES_INTERNAL.has(key)) {
+      continue;
+    }
+    routes.push({
+      path: key,
+      kind: key === "/api" || key.startsWith("/api/") ? "route-handler" : "page",
+      dynamic: key.includes("[")
+    });
+  }
+  return routes.sort((a, b) => a.path.localeCompare(b.path));
+}
+function discoverRoutes(appPaths) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(appPaths)) {
+    const parsed = toRequestPath(key);
+    if (parsed === null || INTERNAL_PATHS.has(parsed.path) || routes.has(parsed.path)) {
+      continue;
+    }
+    const reason = unaddressableReason(parsed.path);
+    routes.set(parsed.path, {
+      path: parsed.path,
+      kind: parsed.kind,
+      dynamic: parsed.path.includes("["),
+      ...reason !== void 0 && { unaddressableReason: reason }
+    });
+  }
+  return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+
+// src/target.ts
+import { access, readFile } from "fs/promises";
+import path from "path";
+var TargetError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "TargetError";
+    this.code = code;
+  }
+};
+async function exists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readManifest(file, parse2) {
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(file, "utf8"));
+  } catch (cause) {
+    throw new TargetError(
+      "BAD_MANIFEST",
+      `Could not read ${file}: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+  }
+  try {
+    return parse2(raw);
+  } catch {
+    throw new TargetError(
+      "BAD_MANIFEST",
+      `${file} does not match the expected Next.js manifest shape. This Next.js version may not be supported yet.`
+    );
+  }
+}
+async function validateTarget(appDir) {
+  const nextDir = path.resolve(appDir, ".next");
+  if (!await exists(nextDir)) {
+    throw new TargetError(
+      "NO_BUILD",
+      `No .next directory in ${appDir}. Run "next build" first.`
+    );
+  }
+  const standaloneServer = path.join(nextDir, "standalone", "server.js");
+  if (!await exists(standaloneServer)) {
+    throw new TargetError(
+      "NO_STANDALONE",
+      `No ${standaloneServer}.
+next-leak measures the standalone server bundle. Enable it once in next.config:
+
+    const nextConfig = {
+      output: "standalone",
+      // ...your existing config
+    };
+
+then rebuild:  next build
+This only changes how the build is packaged \u2014 not how your app behaves.`
+    );
+  }
+  const appPathsFile = path.join(nextDir, "server", "app-paths-manifest.json");
+  const pagesFile = path.join(nextDir, "server", "pages-manifest.json");
+  const appPaths = await exists(appPathsFile) ? await readManifest(appPathsFile, (raw) => appPathsManifestSchema.parse(raw)) : {};
+  const pages = await exists(pagesFile) ? await readManifest(pagesFile, (raw) => pagesManifestSchema.parse(raw)) : {};
+  if (Object.keys(appPaths).length === 0 && Object.keys(pages).length === 0) {
+    throw new TargetError(
+      "BAD_MANIFEST",
+      `No routes found in ${nextDir}/server: neither app-paths-manifest.json nor pages-manifest.json is present. Rebuild the app with "next build".`
+    );
+  }
+  const routesFile = path.join(nextDir, "routes-manifest.json");
+  const routes = await exists(routesFile) ? await readManifest(routesFile, (raw) => routesManifestSchema.parse(raw)) : void 0;
+  const prerenderFile = path.join(nextDir, "prerender-manifest.json");
+  const prerender = await exists(prerenderFile) ? await readManifest(prerenderFile, (raw) => prerenderManifestSchema.parse(raw)) : void 0;
+  return {
+    appDir: path.resolve(appDir),
+    standaloneServer,
+    appPaths,
+    pages,
+    routes,
+    prerender
+  };
+}
+
+// src/launcher.ts
+import { spawn } from "child_process";
+import { readdir, readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+import { pathToFileURL } from "url";
+import { z as z2 } from "zod";
+var controlFileSchema = z2.object({ port: z2.number(), pid: z2.number() });
+var DEFAULT_MAX_OLD_SPACE_MB = 512;
+var LaunchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LaunchError";
+  }
+};
+var activeChildren = /* @__PURE__ */ new Set();
+var STDERR_WINDOW = 4096;
+function killActiveChildren() {
+  for (const child of activeChildren) {
+    child.kill("SIGKILL");
+  }
+}
+function registerChild(child) {
+  activeChildren.add(child);
+  child.once("exit", () => activeChildren.delete(child));
+}
+function unregisterChild(child) {
+  activeChildren.delete(child);
+}
+function explainStartupFailure(stderr) {
+  const missingModule = /Cannot find module '([^']+)'/.exec(stderr);
+  if (missingModule !== null) {
+    return `the standalone build is missing a dependency (${missingModule[1]}). This is a build problem, not a measurement one: \`node .next/standalone/server.js\` fails the same way on its own. Rebuild, or copy the missing package into .next/standalone/node_modules.`;
+  }
+  if (/EADDRINUSE/.test(stderr)) {
+    return "the port was taken by another process while starting.";
+  }
+  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 (; ; ) {
+    const failure = failed();
+    if (failure !== void 0) {
+      throw new LaunchError(failure);
+    }
+    const result = await probe();
+    if (result !== void 0) {
+      return result;
+    }
+    if (Date.now() > deadline) {
+      throw new LaunchError(`timed out waiting for ${what}`);
+    }
+    await sleep(100);
+  }
+}
+async function launchInstrumented(options) {
+  const hostname = options.hostname ?? "127.0.0.1";
+  const deadline = Date.now() + (options.readyTimeoutMs ?? 15e3);
+  const child = spawn(
+    process.execPath,
+    [
+      "--expose-gc",
+      `--max-old-space-size=${options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB}`,
+      "--import",
+      pathToFileURL(options.bootstrapPath).href,
+      options.serverPath
+    ],
+    {
+      cwd: path2.dirname(options.serverPath),
+      env: {
+        ...process.env,
+        ...options.env,
+        NODE_ENV: "production",
+        PORT: String(options.appPort),
+        HOSTNAME: hostname,
+        NEXT_LEAK_DIR: options.workDir
+      },
+      stdio: ["ignore", "ignore", "pipe"]
+    }
+  );
+  let stderrHead = "";
+  let stderrTailBuffer = "";
+  child.stderr?.on("data", (chunk) => {
+    const text = chunk.toString();
+    if (stderrHead.length < STDERR_WINDOW) {
+      stderrHead = (stderrHead + text).slice(0, STDERR_WINDOW);
+    }
+    stderrTailBuffer = (stderrTailBuffer + text).slice(-STDERR_WINDOW);
+  });
+  const stderrWindow = () => stderrHead === stderrTailBuffer || stderrTailBuffer === "" ? stderrHead : `${stderrHead}
+[...]
+${stderrTailBuffer}`;
+  let exited = false;
+  activeChildren.add(child);
+  child.once("exit", () => {
+    exited = true;
+    activeChildren.delete(child);
+  });
+  const failed = () => exited ? `server exited before becoming ready. ${explainStartupFailure(stderrWindow())}` : void 0;
+  try {
+    const controlPort = await pollUntil(
+      deadline,
+      `control channel in ${options.workDir}`,
+      // Several processes may announce a channel (clustered servers); accept
+      // the first one that actually answers instead of trusting a filename.
+      async () => {
+        let entries;
+        try {
+          entries = (await readdir(options.workDir)).filter(
+            (entry) => entry.startsWith("control-") && entry.endsWith(".json")
+          );
+        } catch {
+          return void 0;
+        }
+        for (const entry of entries) {
+          try {
+            const parsed = controlFileSchema.parse(
+              JSON.parse(await readFile2(path2.join(options.workDir, entry), "utf8"))
+            );
+            const response = await fetch(`http://127.0.0.1:${parsed.port}/gc`);
+            if (response.ok) {
+              return parsed.port;
+            }
+          } catch {
+            continue;
+          }
+        }
+        return void 0;
+      },
+      failed
+    );
+    await pollUntil(
+      deadline,
+      `app on ${hostname}:${options.appPort}`,
+      async () => {
+        try {
+          await fetch(`http://${hostname}:${options.appPort}/`, { method: "HEAD" });
+          return true;
+        } catch {
+          return void 0;
+        }
+      },
+      failed
+    );
+    return {
+      pid: child.pid ?? -1,
+      appPort: options.appPort,
+      controlPort,
+      explainExit: () => exited ? explainRuntimeFailure(stderrWindow(), options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB) : null,
+      close: async () => {
+        if (exited) {
+          return;
+        }
+        const gone = new Promise((resolve) => child.once("exit", () => resolve()));
+        child.kill("SIGTERM");
+        const killTimer = setTimeout(() => child.kill("SIGKILL"), 3e3);
+        await gone;
+        clearTimeout(killTimer);
+      }
+    };
+  } catch (cause) {
+    child.kill("SIGKILL");
+    throw cause;
+  }
+}
+
 // src/cli-args.ts
+var BUILD_COMMAND = "build";
+var RUN_ONLY_FLAGS = [
+  ["routes", "--routes"],
+  ["cycles", "--cycles"],
+  ["requests", "--requests"],
+  ["connections", "--connections"],
+  ["idleSeconds", "--idle"],
+  ["warmupRequests", "--warmup"],
+  ["maxOldSpaceMb", "--max-old-space"],
+  ["quick", "--quick"],
+  ["noResolve", "--no-resolve"],
+  ["diffAll", "--diff-all"],
+  ["writeConfig", "--write-config"]
+];
+function runOnlyFlagUsed(options) {
+  for (const [field, flag] of RUN_ONLY_FLAGS) {
+    const value = options[field];
+    if (value !== null && value !== false) {
+      return flag;
+    }
+  }
+  return null;
+}
 var FLAGS = [
   {
     flag: "--routes",
@@ -91981,6 +92348,12 @@ var FLAGS = [
   { 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: "--warmup",
+    value: "int",
+    argName: "<n>",
+    help: "Requests before the baseline snapshot (default 200) \u2014 lower it on apps that cache per request"
+  },
   {
     flag: "--max-old-space",
     value: "int",
@@ -91999,6 +92372,11 @@ var FLAGS = [
     help: "Do not re-measure inconclusive routes with more cycles (default: re-measure once)"
   },
   { flag: "--output", value: "string", argName: "<dir>", help: "Where to write runs (default <app-dir>/.next-leak)" },
+  {
+    flag: "--write-config",
+    value: "none",
+    help: "Write next-leak.config.json for the routes that need sample params, then exit (never overwrites)"
+  },
   { flag: "--help", alias: "-h", value: "none", help: "Show this help" },
   { flag: "--version", alias: "-v", value: "none", help: "Print the version" }
 ];
@@ -92015,7 +92393,8 @@ Find out whether your Next.js app actually leaks memory \u2014 how much, on whic
 route, and whose fault it is.
 
 Usage:
-  next-leak <app-dir> [options]
+  next-leak <app-dir> [options]        measure a built server under load
+  next-leak build <app-dir>            measure the memory of "next build"
 
 The app must be built with output: "standalone" (next build). For each
 discovered route, next-leak boots a fresh instrumented process and runs:
@@ -92023,6 +92402,11 @@ warm-up \u2192 GC \u2192 baseline snapshot \u2192 [load \u2192 idle \u2192 GC \u
 snapshot. Evidence (report.html, ISSUE drafts, raw snapshots, run.json) is
 written under the output directory.
 
+The build command needs neither a previous build nor standalone output: it runs
+the build itself and samples the resident memory of each static-generation
+worker, which is where large sites run out of heap while prerendering. It takes
+--output only; the options below shape HTTP load and do not apply to it.
+
 Options:
 ${rows}
 
@@ -92035,6 +92419,7 @@ var LIMITS = {
   "--requests": 1e6,
   "--connections": 1e4,
   "--idle": 3600,
+  "--warmup": 1e6,
   "--max-old-space": 65536
 };
 var MIN_MAX_OLD_SPACE_MB = 128;
@@ -92074,6 +92459,7 @@ function applyNumericFlag(flag, value, options) {
   if (flag === "--requests") options.requests = parsed;
   if (flag === "--connections") options.connections = parsed;
   if (flag === "--idle") options.idleSeconds = parsed;
+  if (flag === "--warmup") options.warmupRequests = parsed;
   if (flag === "--max-old-space") options.maxOldSpaceMb = parsed;
   return FLAG_OK;
 }
@@ -92085,6 +92471,7 @@ function applyFlag(spec, value, options) {
     case "--requests":
     case "--connections":
     case "--idle":
+    case "--warmup":
     case "--max-old-space":
       return applyNumericFlag(spec.flag, value, options);
     case "--quick":
@@ -92093,6 +92480,9 @@ function applyFlag(spec, value, options) {
     case "--diff-all":
       options.diffAll = true;
       return FLAG_OK;
+    case "--write-config":
+      options.writeConfig = true;
+      return FLAG_OK;
     case "--no-resolve":
       options.noResolve = true;
       return FLAG_OK;
@@ -92126,17 +92516,19 @@ function parseFlagAt(argv, index, options) {
   if (spec.flag === "--version") {
     return { done: { kind: "version" } };
   }
-  const read = readFlagValue(spec, argv, index);
-  if ("error" in read) {
-    return { done: { kind: "error", message: read.error } };
+  const read2 = readFlagValue(spec, argv, index);
+  if ("error" in read2) {
+    return { done: { kind: "error", message: read2.error } };
   }
-  const outcome = applyFlag(spec, read.value, options);
+  const outcome = applyFlag(spec, read2.value, options);
   if (outcome.kind === "error") {
     return { done: { kind: "error", message: outcome.message } };
   }
   return { consumed: spec.value === "none" ? 0 : 1 };
 }
 function parseCliArgs(argv) {
+  const isBuild = argv[0] === BUILD_COMMAND;
+  const rest = isBuild ? argv.slice(1) : argv;
   const options = {
     appDir: "",
     routes: null,
@@ -92144,14 +92536,16 @@ function parseCliArgs(argv) {
     requests: null,
     connections: null,
     idleSeconds: null,
+    warmupRequests: null,
     maxOldSpaceMb: null,
     quick: false,
     noResolve: false,
     diffAll: false,
+    writeConfig: false,
     output: null
   };
-  for (let index = 0; index < argv.length; index += 1) {
-    const argument = argv[index] ?? "";
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index] ?? "";
     if (!argument.startsWith("-")) {
       if (options.appDir !== "") {
         return { kind: "error", message: `unexpected extra argument "${argument}" \u2014 one app directory only` };
@@ -92159,7 +92553,7 @@ function parseCliArgs(argv) {
       options.appDir = argument;
       continue;
     }
-    const step = parseFlagAt(argv, index, options);
+    const step = parseFlagAt(rest, index, options);
     if ("done" in step) {
       return step.done;
     }
@@ -92168,6 +92562,16 @@ function parseCliArgs(argv) {
   if (options.appDir === "") {
     return { kind: "help" };
   }
+  if (isBuild) {
+    const misplaced = runOnlyFlagUsed(options);
+    if (misplaced !== null) {
+      return {
+        kind: "error",
+        message: `option "${misplaced}" shapes HTTP load and does not apply to "next-leak build" \u2014 see --help`
+      };
+    }
+    return { kind: "build", options: { appDir: options.appDir, output: options.output } };
+  }
   return { kind: "run", options };
 }
 
@@ -92188,173 +92592,234 @@ function checkRuntime(facts = currentFacts()) {
   return null;
 }
 
-// src/launcher.ts
-import { spawn } from "child_process";
-import { readdir, readFile } from "fs/promises";
-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 {
+// src/route-config.ts
+import { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+import { z as z3 } from "zod";
+var sampleValueSchema = z3.string().refine(
+  (value) => !(value.includes("{n}") && /\{n%\d+\}/.test(value)),
+  { message: 'a sample value cannot carry both "{n}" and "{n%N}" \u2014 pick one' }
+);
+var routeConfigSchema = z3.object({
+  params: z3.record(z3.string(), sampleValueSchema).optional(),
+  routes: z3.record(z3.string(), z3.record(z3.string(), sampleValueSchema)).optional(),
+  /**
+   * Headers sent with every request. Real traffic is not header-less:
+   * compression (`Accept-Encoding`), sessions and auth change which code
+   * paths run, and some leaks only exist on those paths (zlib, per-session
+   * caches). Measuring without them measures a different app.
+   */
+  headers: z3.record(z3.string(), z3.string()).optional(),
+  /** Query string appended per route template, e.g. `"weightKb=2048"`. */
+  query: z3.record(z3.string(), z3.string()).optional(),
+  /**
+   * Simulates clients that give up before the response arrives (closed
+   * tabs, load-balancer timeouts, bots). Several real leaks only exist on
+   * that path — vercel/next.js#89091 traces `ServerResponse` retention to
+   * an early disconnect — and a load generator that always waits politely
+   * never reaches it.
+   *
+   * Counted **from the first byte of the response**, not from the request:
+   * under load a server's first byte arrives long after any sane fixed
+   * window, so a request-relative clock cuts before the stream starts and
+   * tests the wrong path entirely.
+   */
+  abandonAfterMs: z3.number().int().positive().optional()
+}).strict();
+var RouteConfigError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "LaunchError";
+    this.name = "RouteConfigError";
   }
 };
-var activeChildren = /* @__PURE__ */ new Set();
-function killActiveChildren() {
-  for (const child of activeChildren) {
-    child.kill("SIGKILL");
+var ROUTE_CONFIG_FILE = "next-leak.config.json";
+async function loadRouteConfig(appDir) {
+  const file = path3.join(appDir, ROUTE_CONFIG_FILE);
+  let raw;
+  try {
+    raw = await readFile3(file, "utf8");
+  } catch {
+    return {};
+  }
+  try {
+    return routeConfigSchema.parse(JSON.parse(raw));
+  } catch (cause) {
+    throw new RouteConfigError(
+      `${file} is invalid: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
   }
 }
-function explainStartupFailure(stderr) {
-  const missingModule = /Cannot find module '([^']+)'/.exec(stderr);
-  if (missingModule !== null) {
-    return `the standalone build is missing a dependency (${missingModule[1]}). This is a build problem, not a measurement one: \`node .next/standalone/server.js\` fails the same way on its own. Rebuild, or copy the missing package into .next/standalone/node_modules.`;
+var SEGMENT_PATTERN = /^\[(\[)?(\.\.\.)?([^\]]+?)\]?\]$/;
+function dynamicSegmentsOf(routeTemplate) {
+  const segments = [];
+  for (const segment of routeTemplate.split("/")) {
+    const match = SEGMENT_PATTERN.exec(segment);
+    if (match === null) {
+      continue;
+    }
+    segments.push({
+      name: match[3] ?? "",
+      catchAll: match[2] !== void 0,
+      optional: match[1] !== void 0
+    });
   }
-  if (/EADDRINUSE/.test(stderr)) {
-    return "the port was taken by another process while starting.";
+  return segments;
+}
+var UNIQUE_MARKER = "{n}";
+var BOUNDED_MARKER = /\{n%(\d+)\}/;
+function boundedMarkerOf(value) {
+  const match = BOUNDED_MARKER.exec(value);
+  const bound = Number(match?.[1]);
+  if (match === null || !Number.isInteger(bound) || bound <= 0) {
+    return null;
   }
-  return `stderr:
-${stderr}`;
+  return { marker: match[0], bound };
 }
-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.`;
+var ENCODED_MARKER = encodeURIComponent(UNIQUE_MARKER);
+var encodeSegment = (value) => restoreMarkers(encodeURIComponent(value).split(ENCODED_MARKER).join(UNIQUE_MARKER));
+var ENCODED_BOUNDED = /%7Bn%25(\d+)%7D/gi;
+var restoreMarkers = (value) => value.replace(ENCODED_BOUNDED, (_match, bound) => `{n%${bound}}`);
+var encodeCatchAll = (value) => value.split("/").map(encodeSegment).join("/");
+function resolveRoutePath(routeTemplate, config) {
+  const resolved = [];
+  for (const segment of routeTemplate.split("/")) {
+    const match = SEGMENT_PATTERN.exec(segment);
+    if (match === null) {
+      resolved.push(encodeSegment(segment));
+      continue;
+    }
+    const optional = match[1] !== void 0;
+    const catchAll = match[2] !== void 0;
+    const name = match[3] ?? "";
+    const value = config.routes?.[routeTemplate]?.[name] ?? config.params?.[name];
+    if (value !== void 0) {
+      resolved.push(catchAll ? encodeCatchAll(value) : encodeSegment(value));
+    } else if (!optional) {
+      return null;
+    }
   }
-  return `the measured process exited mid-run. ${explainStartupFailure(stderr)}`;
+  const joined = resolved.join("/");
+  const path7 = joined === "" ? "/" : joined;
+  const query = config.query?.[routeTemplate];
+  return query === void 0 || query === "" ? path7 : `${path7}?${query}`;
 }
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function pollUntil(deadline, what, probe, failed) {
-  for (; ; ) {
-    const failure = failed();
-    if (failure !== void 0) {
-      throw new LaunchError(failure);
+
+// src/route-guidance.ts
+var PLACEHOLDER = "REPLACE-ME";
+function sampleValuesFromManifest(manifest, routeTemplate) {
+  const routes = manifest?.routes;
+  if (routes === void 0) {
+    return null;
+  }
+  const concrete = Object.entries(routes).find(([, entry]) => entry.srcRoute === routeTemplate)?.[0];
+  if (concrete === void 0) {
+    return null;
+  }
+  const templateSegments = routeTemplate.split("/");
+  const concreteSegments = concrete.split("/");
+  const values = {};
+  for (const [index, segment] of templateSegments.entries()) {
+    const dynamic = dynamicSegmentsOf(segment);
+    const parameter = dynamic[0];
+    if (parameter === void 0) {
+      continue;
     }
-    const result = await probe();
-    if (result !== void 0) {
-      return result;
+    const value = parameter.catchAll ? concreteSegments.slice(index).join("/") : concreteSegments[index];
+    if (value === void 0 || value === "") {
+      return null;
     }
-    if (Date.now() > deadline) {
-      throw new LaunchError(`timed out waiting for ${what}`);
+    values[parameter.name] = value;
+  }
+  return Object.keys(values).length === 0 ? null : values;
+}
+function renderConfigSkeleton(routeTemplates, manifest = void 0) {
+  const routes = {};
+  for (const template of routeTemplates) {
+    const segments = dynamicSegmentsOf(template);
+    if (segments.length === 0) {
+      continue;
     }
-    await sleep(100);
+    const sampled = sampleValuesFromManifest(manifest, template);
+    const values = {};
+    for (const segment of segments) {
+      values[segment.name] = sampled?.[segment.name] ?? PLACEHOLDER;
+    }
+    routes[template] = values;
   }
+  return Object.keys(routes).length === 0 ? null : JSON.stringify({ routes }, null, 2);
 }
-async function launchInstrumented(options) {
-  const hostname = options.hostname ?? "127.0.0.1";
-  const deadline = Date.now() + (options.readyTimeoutMs ?? 15e3);
-  const child = spawn(
-    process.execPath,
-    [
-      "--expose-gc",
-      `--max-old-space-size=${options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB}`,
-      "--import",
-      pathToFileURL(options.bootstrapPath).href,
-      options.serverPath
-    ],
-    {
-      cwd: path.dirname(options.serverPath),
-      env: {
-        ...process.env,
-        ...options.env,
-        NODE_ENV: "production",
-        PORT: String(options.appPort),
-        HOSTNAME: hostname,
-        NEXT_LEAK_DIR: options.workDir
-      },
-      stdio: ["ignore", "ignore", "pipe"]
+function hasPlaceholders(skeleton) {
+  return skeleton.includes(PLACEHOLDER);
+}
+
+// src/unreclaimed-retention.ts
+var MB = 1024 * 1024;
+var CLASSES = ["heap", "external", "arrayBuffers"];
+var MIN_GAP_BYTES = 2 * MB;
+var MIN_GAP_RATIO = 0.35;
+var MIN_RETAINED_BYTES = MB;
+var read = (sample, memoryClass) => memoryClass === "heap" ? sample.heapUsed : memoryClass === "external" ? sample.external : sample.arrayBuffers;
+function largestGap(values) {
+  return values.reduce((highest, value) => Math.max(highest, value), 0);
+}
+function gapsFor(input, memoryClass) {
+  const gaps = [];
+  for (const [index, held] of input.unreclaimedSamples.entries()) {
+    const afterGc = input.memorySamples[index + 1];
+    if (afterGc === void 0) {
+      break;
     }
-  );
-  let stderrTail = "";
-  child.stderr?.on("data", (chunk) => {
-    stderrTail = (stderrTail + chunk.toString()).slice(-2e3);
-  });
-  let exited = false;
-  activeChildren.add(child);
-  child.once("exit", () => {
-    exited = true;
-    activeChildren.delete(child);
-  });
-  const failed = () => exited ? `server exited before becoming ready. ${explainStartupFailure(stderrTail)}` : void 0;
-  try {
-    const controlPort = await pollUntil(
-      deadline,
-      `control channel in ${options.workDir}`,
-      // Several processes may announce a channel (clustered servers); accept
-      // the first one that actually answers instead of trusting a filename.
-      async () => {
-        let entries;
-        try {
-          entries = (await readdir(options.workDir)).filter(
-            (entry) => entry.startsWith("control-") && entry.endsWith(".json")
-          );
-        } catch {
-          return void 0;
-        }
-        for (const entry of entries) {
-          try {
-            const parsed = controlFileSchema.parse(
-              JSON.parse(await readFile(path.join(options.workDir, entry), "utf8"))
-            );
-            const response = await fetch(`http://127.0.0.1:${parsed.port}/gc`);
-            if (response.ok) {
-              return parsed.port;
-            }
-          } catch {
-            continue;
-          }
-        }
-        return void 0;
-      },
-      failed
-    );
-    await pollUntil(
-      deadline,
-      `app on ${hostname}:${options.appPort}`,
-      async () => {
-        try {
-          await fetch(`http://${hostname}:${options.appPort}/`, { method: "HEAD" });
-          return true;
-        } catch {
-          return void 0;
-        }
-      },
-      failed
+    gaps.push(read(held, memoryClass) - read(afterGc, memoryClass));
+  }
+  return gaps;
+}
+function assessUnreclaimedRetention(input) {
+  if (input.verdict === "leak" && input.verdictIsWellSupported || input.unreclaimedSamples.length === 0) {
+    return null;
+  }
+  let worst = null;
+  for (const memoryClass of CLASSES) {
+    const gaps = gapsFor(input, memoryClass);
+    if (gaps.length === 0) {
+      continue;
+    }
+    const largestGapBytes = largestGap(gaps);
+    if (largestGapBytes < MIN_GAP_BYTES) {
+      continue;
+    }
+    const retainedBytes = largestGap(
+      input.memorySamples.slice(1).map((sample) => read(sample, memoryClass))
     );
-    return {
-      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;
-        }
-        const gone = new Promise((resolve) => child.once("exit", () => resolve()));
-        child.kill("SIGTERM");
-        const killTimer = setTimeout(() => child.kill("SIGKILL"), 3e3);
-        await gone;
-        clearTimeout(killTimer);
-      }
-    };
-  } catch (cause) {
-    child.kill("SIGKILL");
-    throw cause;
+    const ratio = largestGapBytes / Math.max(retainedBytes, MIN_RETAINED_BYTES);
+    if (ratio < MIN_GAP_RATIO) {
+      continue;
+    }
+    if (worst === null || ratio >= worst.ratio) {
+      worst = { class: memoryClass, largestGapBytes, retainedBytes, ratio };
+    }
   }
+  return worst;
+}
+var mb = (bytes) => `${(bytes / MB).toFixed(2)} MB`;
+var CLASS_LABEL = {
+  heap: "heap",
+  external: "external memory",
+  arrayBuffers: "arrayBuffers"
+};
+function describeUnreclaimedRetention(retention) {
+  return `held ${mb(retention.largestGapBytes)} of ${CLASS_LABEL[retention.class]} between collections that a GC took back (${retention.ratio.toFixed(1)}x what it retains) \u2014 a forced GC reclaims this, a long-running process may not run one often enough to; read seconds after load, so it also includes memory not yet collected`;
 }
 
 // src/report.ts
-var MB = 1024 * 1024;
-var formatMb = (bytes) => `${(bytes / MB).toFixed(1)} MB`;
+var MB2 = 1024 * 1024;
+var formatMb = (bytes) => `${(bytes / MB2).toFixed(1)} MB`;
 var formatGrowth = (bytes) => {
   const sign = bytes >= 0 ? "+" : "";
-  return `${sign}${(bytes / MB).toFixed(2)} MB/1000 req`;
+  return `${sign}${(bytes / MB2).toFixed(2)} MB/1000 req`;
 };
 var VERDICT_ICON = { leak: "\u2716", stable: "\u2714", inconclusive: "?" };
-var RSS_MIN_GROWTH_PER_CYCLE = 16 * MB;
-var RSS_MIN_TOTAL_GROWTH = 64 * MB;
+var RSS_MIN_GROWTH_PER_CYCLE = 16 * MB2;
+var RSS_MIN_TOTAL_GROWTH = 64 * MB2;
 function hasSustainedRssGrowth(memorySamples) {
   const rss = memorySamples.map((sample) => sample.rss);
   const first = rss[1];
@@ -92376,6 +92841,11 @@ function ownerLabel(attribution) {
       return null;
   }
 }
+function revalidationLines(route) {
+  return route.revalidatedEverySeconds === void 0 ? [] : [
+    `      driven through ISR revalidation (revalidates every ${route.revalidatedEverySeconds}s; without it the load would serve the cache)`
+  ];
+}
 function confidenceLines(route) {
   const lines = [];
   if (route.confidence.supersededVerdict !== void 0) {
@@ -92442,6 +92912,15 @@ function peakPressureLines(route, parameters) {
   });
   return pressure === null ? [] : [`      \u25B2 peak pressure: ${describePeakPressure(pressure)}`];
 }
+function unreclaimedLines(route, verdict) {
+  const retention = assessUnreclaimedRetention({
+    unreclaimedSamples: route.unreclaimedSamples,
+    memorySamples: route.memorySamples,
+    verdict,
+    verdictIsWellSupported: warrantsIssueDraft(route)
+  });
+  return retention === null ? [] : [`      \u25B2 unreclaimed: ${describeUnreclaimedRetention(retention)}`];
+}
 function routeLines(route, parameters) {
   if (route.status === "skipped") {
     return [`  \u2013 ${route.route}  skipped: ${route.reason}`];
@@ -92449,6 +92928,9 @@ function routeLines(route, parameters) {
   if (route.status === "failed") {
     return [`  \u2716 ${route.route}  failed: ${route.reason}`];
   }
+  if (route.status === "not-exercised") {
+    return [`  \u2013 ${route.route}  not exercised: ${route.reason}`];
+  }
   const verdict = effectiveVerdict(route);
   const curve = route.samples.map(formatMb).join(" \u2192 ");
   const resolved = route.resolvedWithCycles === void 0 ? "" : `  (resolved at ${route.resolvedWithCycles} cycles)`;
@@ -92456,17 +92938,45 @@ function routeLines(route, parameters) {
     `  ${VERDICT_ICON[verdict]} ${route.route}  ${verdict}  (${formatGrowth(
       route.growthPer1000Requests
     )})  heap ${curve}${resolved}`,
+    ...revalidationLines(route),
     ...confidenceLines(route),
     ...memorySourceLines(route, verdict),
     ...peakPressureLines(route, parameters),
+    ...unreclaimedLines(route, verdict),
     ...findingLines(route)
   ];
 }
+function skippedGuidanceLines(report) {
+  const needConfig = report.routes.filter((route) => route.status === "skipped" && route.reason.includes("sample params")).map((route) => route.route);
+  const skeleton = renderConfigSkeleton(needConfig, report.prerender);
+  if (skeleton === null) {
+    return [];
+  }
+  const editing = hasPlaceholders(skeleton) ? ` Replace each ${"REPLACE-ME"} with a value that exists in your app.` : ` The values come from paths your build already prerendered.`;
+  return [
+    "",
+    `${needConfig.length} route(s) need sample params. Write this to next-leak.config.json in the app directory:${editing}`,
+    ...skeleton.split("\n").map((line) => `  ${line}`)
+  ];
+}
+function coverageLine(report) {
+  const total = report.routes.length;
+  const measured = report.routes.filter((route) => route.status === "measured").length;
+  if (measured === total) {
+    return `measured all ${total} discovered route(s)`;
+  }
+  const breakdown = ["skipped", "not-exercised", "failed"].map((status) => ({
+    status,
+    count: report.routes.filter((route) => route.status === status).length
+  })).filter((entry) => entry.count > 0).map((entry) => `${entry.count} ${entry.status.replace("-", " ")}`).join(", ");
+  return `measured ${measured} of ${total} discovered route(s) \u2014 ${breakdown}; the rest is not a verdict about your app`;
+}
 function formatReport(report) {
   const lines = [`next-leak \u2014 ${report.appDir}`, ""];
   for (const route of report.routes) {
     lines.push(...routeLines(route, report.parameters));
   }
+  lines.push(...skippedGuidanceLines(report));
   const { minGrowthPerCycle, loadRequests, cycles, maxOldSpaceMb } = report.parameters;
   const resolvedCycles = [
     ...new Set(
@@ -92476,8 +92986,8 @@ function formatReport(report) {
     )
   ].sort((a, b) => a - b);
   const cyclesLabel = resolvedCycles.length === 0 ? `${cycles} cycles` : `${cycles} cycles (${resolvedCycles.join(", ")} where resolved)`;
+  lines.push("", coverageLine(report));
   lines.push(
-    "",
     `judged over ${cyclesLabel} \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}`,
@@ -92498,88 +93008,6 @@ function formatReport(report) {
   return lines.join("\n");
 }
 
-// src/route-config.ts
-import { readFile as readFile2 } from "fs/promises";
-import path2 from "path";
-import { z as z2 } from "zod";
-var routeConfigSchema = z2.object({
-  params: z2.record(z2.string(), z2.string()).optional(),
-  routes: z2.record(z2.string(), z2.record(z2.string(), z2.string())).optional(),
-  /**
-   * Headers sent with every request. Real traffic is not header-less:
-   * compression (`Accept-Encoding`), sessions and auth change which code
-   * paths run, and some leaks only exist on those paths (zlib, per-session
-   * caches). Measuring without them measures a different app.
-   */
-  headers: z2.record(z2.string(), z2.string()).optional(),
-  /** Query string appended per route template, e.g. `"weightKb=2048"`. */
-  query: z2.record(z2.string(), z2.string()).optional(),
-  /**
-   * Simulates clients that give up before the response arrives (closed
-   * tabs, load-balancer timeouts, bots). Several real leaks only exist on
-   * that path — vercel/next.js#89091 traces `ServerResponse` retention to
-   * an early disconnect — and a load generator that always waits politely
-   * never reaches it.
-   *
-   * Counted **from the first byte of the response**, not from the request:
-   * under load a server's first byte arrives long after any sane fixed
-   * window, so a request-relative clock cuts before the stream starts and
-   * tests the wrong path entirely.
-   */
-  abandonAfterMs: z2.number().int().positive().optional()
-}).strict();
-var RouteConfigError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RouteConfigError";
-  }
-};
-var ROUTE_CONFIG_FILE = "next-leak.config.json";
-async function loadRouteConfig(appDir) {
-  const file = path2.join(appDir, ROUTE_CONFIG_FILE);
-  let raw;
-  try {
-    raw = await readFile2(file, "utf8");
-  } catch {
-    return {};
-  }
-  try {
-    return routeConfigSchema.parse(JSON.parse(raw));
-  } catch (cause) {
-    throw new RouteConfigError(
-      `${file} is invalid: ${cause instanceof Error ? cause.message : String(cause)}`
-    );
-  }
-}
-var SEGMENT_PATTERN = /^\[(\[)?(\.\.\.)?([^\]]+?)\]?\]$/;
-var UNIQUE_MARKER = "{n}";
-var ENCODED_MARKER = encodeURIComponent(UNIQUE_MARKER);
-var encodeSegment = (value) => encodeURIComponent(value).split(ENCODED_MARKER).join(UNIQUE_MARKER);
-var encodeCatchAll = (value) => value.split("/").map(encodeSegment).join("/");
-function resolveRoutePath(routeTemplate, config) {
-  const resolved = [];
-  for (const segment of routeTemplate.split("/")) {
-    const match = SEGMENT_PATTERN.exec(segment);
-    if (match === null) {
-      resolved.push(encodeSegment(segment));
-      continue;
-    }
-    const optional = match[1] !== void 0;
-    const catchAll = match[2] !== void 0;
-    const name = match[3] ?? "";
-    const value = config.routes?.[routeTemplate]?.[name] ?? config.params?.[name];
-    if (value !== void 0) {
-      resolved.push(catchAll ? encodeCatchAll(value) : encodeSegment(value));
-    } else if (!optional) {
-      return null;
-    }
-  }
-  const joined = resolved.join("/");
-  const path7 = joined === "" ? "/" : joined;
-  const query = config.query?.[routeTemplate];
-  return query === void 0 || query === "" ? path7 : `${path7}?${query}`;
-}
-
 // src/attribution.ts
 var UNATTRIBUTED = { owner: "unattributed", source: null, packageName: null };
 function classifySource(rawSource) {
@@ -92845,6 +93273,7 @@ var SNAPSHOT_HEAD = '{"snapshot"';
 var PROBE_BYTES = 512;
 async function assertReadableSnapshot(file) {
   const { open, stat } = await import("fs/promises");
+  const { constants } = await import("buffer");
   let size;
   try {
     size = (await stat(file)).size;
@@ -92854,6 +93283,11 @@ async function assertReadableSnapshot(file) {
   if (size === 0) {
     throw new SnapshotError(`heap snapshot is empty: ${file}`);
   }
+  if (size > constants.MAX_STRING_LENGTH) {
+    throw new SnapshotError(
+      `heap snapshot is ${(size / (1024 * 1024)).toFixed(0)} MB, past the ${(constants.MAX_STRING_LENGTH / (1024 * 1024)).toFixed(0)} MB a single string can hold, so it cannot be parsed: ${file}. The measurement itself is unaffected \u2014 only the snapshot diff, which names the retaining object, is unavailable. Lower --requests or --cycles to keep the heap smaller if you need it`
+    );
+  }
   const handle = await open(file, "r");
   try {
     const head = Buffer.alloc(Math.min(PROBE_BYTES, size));
@@ -92885,80 +93319,6 @@ async function diffSnapshotFiles(baselineFile, afterFile, options = {}, loadHeap
   return diffAgainstBaseline(summary, after, options);
 }
 
-// src/manifests.ts
-import { z as z3 } from "zod";
-var appPathsManifestSchema = z3.record(z3.string(), z3.string());
-var pagesManifestSchema = z3.record(z3.string(), z3.string());
-var routeEntrySchema = z3.looseObject({
-  page: z3.string(),
-  regex: z3.string()
-});
-var routesManifestSchema = z3.looseObject({
-  version: z3.number(),
-  basePath: z3.string(),
-  staticRoutes: z3.array(routeEntrySchema),
-  dynamicRoutes: z3.array(routeEntrySchema)
-});
-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;
-  if (manifestKey.endsWith("/page")) {
-    kind = "page";
-    withoutSuffix = manifestKey.slice(0, -"/page".length);
-  } else if (manifestKey.endsWith("/route")) {
-    kind = "route-handler";
-    withoutSuffix = manifestKey.slice(0, -"/route".length);
-  } else {
-    return null;
-  }
-  const segments = withoutSuffix.split("/").filter((segment) => segment !== "").filter((segment) => !(segment.startsWith("(") && segment.endsWith(")"))).filter((segment) => !segment.startsWith("@"));
-  return { path: `/${segments.join("/")}`, kind };
-}
-var PAGES_INTERNAL = /* @__PURE__ */ new Set(["/_app", "/_document", "/_error", "/404", "/500"]);
-function discoverPagesRoutes(pages) {
-  const routes = [];
-  for (const key of Object.keys(pages)) {
-    if (PAGES_INTERNAL.has(key)) {
-      continue;
-    }
-    routes.push({
-      path: key,
-      kind: key === "/api" || key.startsWith("/api/") ? "route-handler" : "page",
-      dynamic: key.includes("[")
-    });
-  }
-  return routes.sort((a, b) => a.path.localeCompare(b.path));
-}
-function discoverRoutes(appPaths) {
-  const routes = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(appPaths)) {
-    const parsed = toRequestPath(key);
-    if (parsed === null || INTERNAL_PATHS.has(parsed.path) || routes.has(parsed.path)) {
-      continue;
-    }
-    const reason = unaddressableReason(parsed.path);
-    routes.set(parsed.path, {
-      path: parsed.path,
-      kind: parsed.kind,
-      dynamic: parsed.path.includes("["),
-      ...reason !== void 0 && { unaddressableReason: reason }
-    });
-  }
-  return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
-}
-
 // src/vlq.ts
 var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var CHAR_TO_VALUE = new Map([...BASE64].map((char, index) => [char, index]));
@@ -93028,8 +93388,8 @@ function sourceIndexAt(lines, line, column) {
 }
 
 // src/module-registry.ts
-import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import path3 from "path";
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import path4 from "path";
 import { z as z4 } from "zod";
 var flatMapSchema = z4.looseObject({
   version: z4.number(),
@@ -93153,7 +93513,7 @@ async function jsFilesUnder(dir) {
   }
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".js")) {
-      out.push(path3.join(entry.parentPath, entry.name));
+      out.push(path4.join(entry.parentPath, entry.name));
     }
   }
   return out;
@@ -93164,8 +93524,8 @@ async function extractModuleRegistry(nextServerDir) {
     let code;
     let map;
     try {
-      code = await readFile3(file, "utf8");
-      map = JSON.parse(await readFile3(`${file}.map`, "utf8"));
+      code = await readFile4(file, "utf8");
+      map = JSON.parse(await readFile4(`${file}.map`, "utf8"));
     } catch {
       continue;
     }
@@ -93200,15 +93560,44 @@ async function describeRedirect(url) {
     return null;
   }
 }
+function boundedRequestSequence(fullUrl, bounded) {
+  const parsed = new URL(fullUrl);
+  const template = fullUrl.slice(parsed.origin.length);
+  let counter = 0;
+  return {
+    origin: parsed.origin,
+    requests: [
+      {
+        setupRequest: (request2) => {
+          const value = String(counter % bounded.bound);
+          counter += 1;
+          return { ...request2, path: template.split(bounded.marker).join(value) };
+        }
+      }
+    ]
+  };
+}
+function diagnoseFailure(result, connections) {
+  if (result.timeouts > result.non2xx) {
+    return ` \u2014 the failures are timeouts rather than error responses, so the load may simply be more than the app or something it calls can serve; lower --connections (currently ${connections}) and re-run before concluding anything about memory`;
+  }
+  if (result.non2xx > 0) {
+    return ` \u2014 the app answered with errors under load, which is a fault in the route rather than too much traffic; fix that before measuring it`;
+  }
+  return "";
+}
 async function runLoadPhase(options) {
   const unique = options.url.includes(UNIQUE_MARKER);
   const url = unique ? options.url.split(UNIQUE_MARKER).join("[<id>]") : options.url;
+  const bounded = boundedMarkerOf(options.url);
+  const boundedRequests = bounded === null ? void 0 : boundedRequestSequence(options.url, bounded);
   const raw = await (0, import_autocannon.default)({
-    url,
+    url: boundedRequests === void 0 ? url : boundedRequests.origin,
     amount: options.amount,
     connections: options.connections,
     ...options.headers !== void 0 && { headers: options.headers },
-    ...unique && { idReplacement: true }
+    ...unique && { idReplacement: true },
+    ...boundedRequests !== void 0 && { requests: boundedRequests.requests }
   });
   const result = {
     sent: raw.requests.sent,
@@ -93224,7 +93613,7 @@ async function runLoadPhase(options) {
     const unanswered = failures - result.non2xx - result.errors - result.timeouts;
     const redirect = result.non2xx > 0 ? await describeRedirect(options.url) : null;
     throw new LoadError(
-      `${failures} of ${options.amount} requests failed against ${options.url} (${result.non2xx} non-2xx, ${result.errors} errors, ${result.timeouts} timeouts` + (unanswered > 0 ? `, ${unanswered} with no recorded response` : "") + ")" + (redirect === null ? "" : ` \u2014 ${redirect}`),
+      `${failures} of ${options.amount} requests failed against ${options.url} (${result.non2xx} non-2xx, ${result.errors} errors, ${result.timeouts} timeouts` + (unanswered > 0 ? `, ${unanswered} with no recorded response` : "") + ")" + (redirect === null ? diagnoseFailure(result, options.connections) : ` \u2014 ${redirect}`),
       result
     );
   }
@@ -93432,6 +93821,10 @@ var MIN_POLLS_TO_JUDGE = 2;
 var SETTLE_POLL_MS = 2e3;
 var SETTLE_TOLERANCE = 0.01;
 var PEAK_POLL_MS = 250;
+var UNRECLAIMED_SETTLE_MS = SETTLE_POLL_MS;
+function unreclaimedSettleFor(idleMs) {
+  return Math.min(UNRECLAIMED_SETTLE_MS, Math.floor(idleMs / 4));
+}
 function pollPeak(controlPort, phase, deps) {
   const peak = {
     phase,
@@ -93592,6 +93985,8 @@ async function runRitual(options, deps = defaultDeps) {
       () => requestSnapshot(app.controlPort, "baseline")
     );
     const memorySamples = [baseline.sample];
+    const unreclaimedSamples = [];
+    let unreclaimedLost = false;
     const peaks = [];
     let afterSnapshot = "";
     for (let cycle = 1; cycle <= cycles; cycle += 1) {
@@ -93603,9 +93998,18 @@ async function runRitual(options, deps = defaultDeps) {
           peaks.push(await poller.stop());
         }
       });
+      const unreclaimedSettleMs = unreclaimedSettleFor(idleMs);
+      await timed(`cycle ${cycle} unreclaimed read`, async () => {
+        await deps.sleep(unreclaimedSettleMs);
+        try {
+          unreclaimedSamples.push(await deps.readMemory(app.controlPort));
+        } catch {
+          unreclaimedLost = true;
+        }
+      });
       const settle = await timed(
         `cycle ${cycle} settle`,
-        () => waitUntilSettled(app.controlPort, idleMs, deps)
+        () => waitUntilSettled(app.controlPort, idleMs - unreclaimedSettleMs, deps)
       );
       settleOutcomes.push({ phase: `cycle ${cycle}`, ...settle });
       if (cycle === cycles) {
@@ -93630,6 +94034,14 @@ async function runRitual(options, deps = defaultDeps) {
       samples,
       memorySamples,
       peaks,
+      unreclaimedSamples: unreclaimedLost ? [] : unreclaimedSamples,
+      // The first cycle plays the part the baseline plays for the post-GC
+      // series, so both trends drop a warm-up delta and stay comparable.
+      unreclaimedTrend: unreclaimedLost ? { verdict: "inconclusive", growthPerCycle: 0, deltas: [] } : classifyMemoryTrend(
+        unreclaimedSamples.map((sample) => sample.heapUsed),
+        unreclaimedSamples.map((sample) => sample.external),
+        { minGrowthPerCycle }
+      ),
       baselineSnapshot: baseline.file,
       afterSnapshot,
       trend: classifyMemoryTrend(samples, externalSamples, { minGrowthPerCycle }),
@@ -93648,8 +94060,8 @@ async function runRitual(options, deps = defaultDeps) {
 }
 
 // src/signatures.ts
-import { readFile as readFile4 } from "fs/promises";
-import path4 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path5 from "path";
 import semver from "semver";
 import { z as z6 } from "zod";
 var signatureSchema = z6.object({
@@ -93726,12 +94138,12 @@ function matchSignatures(diff, nextVersion, signatures = loadSignatures()) {
 }
 async function readNextVersion(appDir) {
   const candidates = [
-    path4.join(appDir, ".next", "standalone", "node_modules", "next", "package.json"),
-    path4.join(appDir, "node_modules", "next", "package.json")
+    path5.join(appDir, ".next", "standalone", "node_modules", "next", "package.json"),
+    path5.join(appDir, "node_modules", "next", "package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const parsed = z6.object({ version: z6.string() }).parse(JSON.parse(await readFile4(candidate, "utf8")));
+      const parsed = z6.object({ version: z6.string() }).parse(JSON.parse(await readFile5(candidate, "utf8")));
       return parsed.version;
     } catch {
       continue;
@@ -93740,88 +94152,54 @@ async function readNextVersion(appDir) {
   return null;
 }
 
-// src/target.ts
-import { access, readFile as readFile5 } from "fs/promises";
-import path5 from "path";
-var TargetError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "TargetError";
-    this.code = code;
-  }
-};
-async function exists(file) {
-  try {
-    await access(file);
-    return true;
-  } catch {
-    return false;
+// src/runner.ts
+import { createHash as createHash3 } from "crypto";
+import { mkdir as mkdir2, writeFile } from "fs/promises";
+import { createServer } from "net";
+import path6 from "path";
+
+// src/isr.ts
+var REVALIDATE_HEADER = "x-prerender-revalidate";
+function revalidateSecondsFor(manifest, route) {
+  const routes = manifest?.routes;
+  if (routes === void 0) {
+    return null;
   }
-}
-async function readManifest(file, parse2) {
-  let raw;
-  try {
-    raw = JSON.parse(await readFile5(file, "utf8"));
-  } catch (cause) {
-    throw new TargetError(
-      "BAD_MANIFEST",
-      `Could not read ${file}: ${cause instanceof Error ? cause.message : String(cause)}`
-    );
+  const direct = routes[route]?.initialRevalidateSeconds;
+  if (typeof direct === "number") {
+    return direct;
   }
-  try {
-    return parse2(raw);
-  } catch {
-    throw new TargetError(
-      "BAD_MANIFEST",
-      `${file} does not match the expected Next.js manifest shape. This Next.js version may not be supported yet.`
-    );
+  for (const entry of Object.values(routes)) {
+    if (entry.srcRoute === route && typeof entry.initialRevalidateSeconds === "number") {
+      return entry.initialRevalidateSeconds;
+    }
   }
+  return null;
 }
-async function validateTarget(appDir) {
-  const nextDir = path5.resolve(appDir, ".next");
-  if (!await exists(nextDir)) {
-    throw new TargetError(
-      "NO_BUILD",
-      `No .next directory in ${appDir}. Run "next build" first.`
-    );
+function revalidates(manifest, route) {
+  return revalidateSecondsFor(manifest, route) !== null;
+}
+function planRevalidation(manifest, route, userHeaders) {
+  const userSupplied = Object.keys(userHeaders ?? {}).some(
+    (name) => name.toLowerCase() === REVALIDATE_HEADER
+  );
+  if (userSupplied) {
+    return { kind: "drive", headers: {} };
   }
-  const standaloneServer = path5.join(nextDir, "standalone", "server.js");
-  if (!await exists(standaloneServer)) {
-    throw new TargetError(
-      "NO_STANDALONE",
-      `No ${standaloneServer}.
-next-leak measures the standalone server bundle. Enable it once in next.config:
-
-    const nextConfig = {
-      output: "standalone",
-      // ...your existing config
-    };
-
-then rebuild:  next build
-This only changes how the build is packaged \u2014 not how your app behaves.`
-    );
+  if (!revalidates(manifest, route)) {
+    return { kind: "not-isr" };
   }
-  const appPathsFile = path5.join(nextDir, "server", "app-paths-manifest.json");
-  const pagesFile = path5.join(nextDir, "server", "pages-manifest.json");
-  const appPaths = await exists(appPathsFile) ? await readManifest(appPathsFile, (raw) => appPathsManifestSchema.parse(raw)) : {};
-  const pages = await exists(pagesFile) ? await readManifest(pagesFile, (raw) => pagesManifestSchema.parse(raw)) : {};
-  if (Object.keys(appPaths).length === 0 && Object.keys(pages).length === 0) {
-    throw new TargetError(
-      "BAD_MANIFEST",
-      `No routes found in ${nextDir}/server: neither app-paths-manifest.json nor pages-manifest.json is present. Rebuild the app with "next build".`
-    );
+  const previewModeId = manifest?.preview?.previewModeId;
+  if (previewModeId === void 0 || previewModeId === "") {
+    return {
+      kind: "cannot-drive",
+      reason: `revalidates every ${revalidateSecondsFor(manifest, route)}s, but the build's prerender-manifest.json carries no previewModeId \u2014 load would serve the cache and measure nothing. Set "${REVALIDATE_HEADER}" in next-leak.config.json to drive it.`
+    };
   }
-  const routesFile = path5.join(nextDir, "routes-manifest.json");
-  const routes = await exists(routesFile) ? await readManifest(routesFile, (raw) => routesManifestSchema.parse(raw)) : void 0;
-  return { appDir: path5.resolve(appDir), standaloneServer, appPaths, pages, routes };
+  return { kind: "drive", headers: { [REVALIDATE_HEADER]: previewModeId } };
 }
 
 // src/runner.ts
-import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { createServer } from "net";
-import path6 from "path";
 var ESTIMATED_RPS = 250;
 var PER_ROUTE_OVERHEAD_SECONDS = 10;
 var MIN_SETTLE_SECONDS = 4;
@@ -93928,6 +94306,12 @@ function skipReason(route, requestPath) {
 }
 async function measureRoute(context, route, requestPath, index, pass = void 0) {
   const { deps, options, target, workDir, routeConfig, registry, nextVersion, progress } = context;
+  const plan = planRevalidation(target.prerender, route.path, routeConfig.headers);
+  const revalidateSeconds = revalidateSecondsFor(target.prerender, route.path);
+  const bounded = boundedMarkerOf(requestPath);
+  const driven = plan.kind === "drive" ? plan.headers : {};
+  const merged = { ...driven, ...routeConfig.headers ?? {} };
+  const headers = Object.keys(merged).length === 0 ? void 0 : merged;
   const result = await deps.ritual({
     serverPath: target.standaloneServer,
     route: requestPath,
@@ -93943,7 +94327,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     ...pass !== void 0 ? { cycles: pass.cycles } : 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 },
+    ...headers !== void 0 && { headers },
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
     }
@@ -93957,6 +94341,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     minGrowthPerCycle: result.minGrowthPerCycle,
     memorySamples: result.memorySamples,
     maxOldSpaceMb: options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB,
+    warmupRequests: options.warmupRequests ?? RITUAL_DEFAULTS.warmupRequests,
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
     }
@@ -93968,7 +94353,13 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   let diff = null;
   if (verdict !== "stable" || options.diffAll === true) {
     progress(`diffing snapshots for ${route.path}`);
-    diff = await deps.diff(result.baselineSnapshot, result.afterSnapshot);
+    try {
+      diff = await deps.diff(result.baselineSnapshot, result.afterSnapshot);
+    } catch (cause) {
+      progress(
+        `snapshot diff unavailable for ${route.path}: ${cause instanceof Error ? cause.message : String(cause)}`
+      );
+    }
   }
   return {
     route: route.path,
@@ -93978,6 +94369,11 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     samples: result.samples,
     memorySamples: result.memorySamples,
     peaks: result.peaks,
+    ...revalidateSeconds !== null && { revalidatedEverySeconds: revalidateSeconds },
+    ...bounded !== null && { keyCardinality: bounded.bound },
+    unreclaimedSamples: result.unreclaimedSamples,
+    unreclaimedTrend: result.unreclaimedTrend,
+    requestsPerCycle: result.requestsPerCycle,
     timings: result.timings,
     loadOutcomes: result.loadOutcomes,
     settleOutcomes: result.settleOutcomes,
@@ -93993,7 +94389,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-X2LUOZRH.js");
+  const { renderHtmlReport } = await import("./html-report-2UAOOZQO.js");
   const { renderIssueMarkdown } = await import("./issue-report-HKA26WNV.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
@@ -94013,6 +94409,11 @@ async function routeReportFor(context, route, index, total) {
     progress(`skipping ${label}: ${reason ?? "needs sample params"}`);
     return { route: route.path, status: "skipped", reason: reason ?? "needs sample params" };
   }
+  const plan = planRevalidation(context.target.prerender, route.path, routeConfig.headers);
+  if (plan.kind === "cannot-drive") {
+    progress(`not measuring ${label}: ${plan.reason}`);
+    return { route: route.path, status: "not-exercised", reason: plan.reason };
+  }
   try {
     const asPath = requestPath === route.path ? "" : ` as ${requestPath}`;
     progress(`measuring ${label}${asPath}`);
@@ -94108,6 +94509,7 @@ async function runMeasurement(options, deps = defaultDeps2) {
     appDir: target.appDir,
     startedAt: startedAt.toISOString(),
     workDir,
+    ...target.prerender !== void 0 && { prerender: target.prerender },
     environment: captureEnvironment(nextVersion),
     parameters,
     routes: reports,
@@ -94132,17 +94534,27 @@ async function runMeasurement(options, deps = defaultDeps2) {
 }
 
 export {
-  helpText,
-  parseCliArgs,
-  checkRuntime,
+  appPathsManifestSchema,
+  routesManifestSchema,
+  discoverPagesRoutes,
+  discoverRoutes,
+  TargetError,
+  validateTarget,
   LaunchError,
   killActiveChildren,
+  registerChild,
+  unregisterChild,
   launchInstrumented,
-  formatReport,
+  helpText,
+  parseCliArgs,
+  checkRuntime,
   RouteConfigError,
   ROUTE_CONFIG_FILE,
   loadRouteConfig,
   resolveRoutePath,
+  renderConfigSkeleton,
+  hasPlaceholders,
+  formatReport,
   classifySource,
   attributeFinding,
   attributeDiff,
@@ -94153,9 +94565,6 @@ export {
   SnapshotError,
   assertReadableSnapshot,
   diffSnapshotFiles,
-  appPathsManifestSchema,
-  routesManifestSchema,
-  discoverRoutes,
   decodeVlqLine,
   decodeMappings,
   sourceIndexAt,
@@ -94167,8 +94576,6 @@ export {
   loadSignatures,
   matchSignatures,
   readNextVersion,
-  TargetError,
-  validateTarget,
   freePort,
   routeSlug,
   runMeasurement