next-leak 0.7.0 → 0.9.0

package/dist/{chunk-BXDUPN6Z.js → chunk-UVA77PMC.js}

@@ -91969,1602 +91969,1650 @@ 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";
+// src/attribution.ts
+var UNATTRIBUTED = { owner: "unattributed", source: null, packageName: null };
+function classifySource(rawSource) {
+  let source = rawSource.replace(/^turbopack:\/+(?=\[)/, "");
+  try {
+    source = decodeURIComponent(source);
+  } catch {
   }
-  if (STATIC_ASSET_PATHS.has(routePath)) {
-    return "static asset served by a generated handler \u2014 no user code to leak";
+  const nodeModulesSplit = source.split("/node_modules/");
+  if (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") {
+      return { owner: "framework", source: null, packageName };
+    }
+    return { owner: "dependency", source: null, packageName };
   }
-  return void 0;
+  if (source.startsWith("[project]/")) {
+    return { owner: "app", source: source.slice("[project]/".length), packageName: null };
+  }
+  const relative = source.replace(/^(\.\.\/)+/, "");
+  if (relative !== source && !relative.startsWith("[")) {
+    return { owner: "app", source: relative, packageName: null };
+  }
+  return { owner: "framework", source: null, packageName: null };
 }
-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;
+var OWNER_PRIORITY = {
+  app: 0,
+  dependency: 1,
+  framework: 2,
+  unattributed: 3
+};
+var FRAMEWORK_CHAIN_MARKERS = [
+  ["fsChecker", "route filesystem checker"],
+  ["getDynamicRoutes", "dynamic route matcher"],
+  ["NextNodeServer", "Next server"],
+  ["AppPageRouteModule", "App Router page module"],
+  ["AppRouteRouteModule", "App Router route handler module"],
+  ["incrementalCache", "incremental cache"],
+  ["IncrementalCache", "incremental cache"],
+  ["ReactServer", "React Server Components renderer"],
+  ["loadManifests", "manifest loader"],
+  ["renderToHTML", "HTML renderer"]
+];
+function classifyByChain(retainerChain2) {
+  for (const [marker, component] of FRAMEWORK_CHAIN_MARKERS) {
+    if (retainerChain2.includes(marker)) {
+      return { owner: "framework", source: null, packageName: `next (${component})` };
+    }
   }
-  const segments = withoutSuffix.split("/").filter((segment) => segment !== "").filter((segment) => !(segment.startsWith("(") && segment.endsWith(")"))).filter((segment) => !segment.startsWith("@"));
-  return { path: `/${segments.join("/")}`, kind };
+  return null;
 }
-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)) {
+function attributeFinding(finding, registry) {
+  let best = UNATTRIBUTED;
+  for (const id of finding.moduleIds) {
+    const source = registry.get(id);
+    if (source === void 0) {
       continue;
     }
-    routes.push({
-      path: key,
-      kind: key === "/api" || key.startsWith("/api/") ? "route-handler" : "page",
-      dynamic: key.includes("[")
-    });
+    const candidate = classifySource(source);
+    if (OWNER_PRIORITY[candidate.owner] < OWNER_PRIORITY[best.owner]) {
+      best = candidate;
+    }
   }
-  return routes.sort((a, b) => a.path.localeCompare(b.path));
+  if (best.owner === "unattributed") {
+    return classifyByChain(finding.retainerChain ?? "") ?? UNATTRIBUTED;
+  }
+  return best;
 }
-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)) {
+function attributeDiff(diff, registry) {
+  const all = [...diff.grownNodes, ...diff.newNodes];
+  const findings = all.map((finding) => attributeFinding(finding, registry));
+  const byGroup = /* @__PURE__ */ new Map();
+  let attributedBytes = 0;
+  for (const [index, attribution] of findings.entries()) {
+    if (attribution.owner === "unattributed") {
       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 }
-    });
+    const bytes = all[index]?.retainedBytes ?? 0;
+    attributedBytes += bytes;
+    const key = `${attribution.owner}|${attribution.source ?? ""}|${attribution.packageName ?? ""}`;
+    const group = byGroup.get(key) ?? { attribution, bytes: 0 };
+    group.bytes += bytes;
+    byGroup.set(key, group);
   }
-  return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
+  let winner = null;
+  for (const group of byGroup.values()) {
+    if (winner === null || group.bytes > winner.bytes) {
+      winner = group;
+    }
+  }
+  const route = winner === null || attributedBytes === 0 ? { ...UNATTRIBUTED, dominance: 0 } : { ...winner.attribution, dominance: winner.bytes / attributedBytes };
+  return { findings, route };
 }
 
-// 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;
-  }
+// src/heap-diff.ts
+var import_core = __toESM(require_dist(), 1);
+var import_heap_analysis = __toESM(require_dist4(), 1);
+var DEFAULTS = {
+  minTypeDeltaBytes: 20 * 1024,
+  grownThresholdBytes: 100 * 1024,
+  newThresholdBytes: 2 * 1024,
+  bigRetainedFloorBytes: 50 * 1024,
+  maxFindings: 10,
+  chainDepth: 7
 };
-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)}`
+function summarizeBaseline(heap, options = {}) {
+  const resolved = { ...DEFAULTS, ...options };
+  const summary = {
+    nodeIds: /* @__PURE__ */ new Set(),
+    bigRetained: /* @__PURE__ */ new Map(),
+    typeSelfSizes: /* @__PURE__ */ new Map()
+  };
+  heap.nodes.forEach((node) => {
+    summary.nodeIds.add(node.id);
+    if (node.retainedSize >= resolved.bigRetainedFloorBytes) {
+      summary.bigRetained.set(node.id, node.retainedSize);
+    }
+    summary.typeSelfSizes.set(
+      node.type,
+      (summary.typeSelfSizes.get(node.type) ?? 0) + node.self_size
     );
-  }
-  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.`
+  });
+  return summary;
+}
+function truncateLabel(value, max2 = 60) {
+  return value.replaceAll("\n", " ").slice(0, max2);
+}
+function walkChain(node, depth) {
+  const parts = [];
+  const nodes = [node];
+  let current = node;
+  const seen = /* @__PURE__ */ new Set([node.id]);
+  for (let i = 0; i < depth; i += 1) {
+    const referrers = current.referrers;
+    if (referrers.length === 0) {
+      break;
+    }
+    const edge = referrers.find(
+      (candidate) => !seen.has(candidate.fromNode.id) && candidate.fromNode.type !== "synthetic" && candidate.type !== "weak"
+    ) ?? referrers[0];
+    if (edge === void 0 || seen.has(edge.fromNode.id)) {
+      break;
+    }
+    current = edge.fromNode;
+    seen.add(current.id);
+    nodes.push(current);
+    parts.push(
+      `${truncateLabel(current.name)}#${current.type}[.${truncateLabel(
+        String(edge.name_or_index),
+        40
+      )}]`
     );
   }
+  return { parts, nodes };
 }
-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.`
+function retainerChain(node, depth) {
+  return walkChain(node, depth).parts.join(" <- ");
+}
+function collectModuleIds(chainNodes) {
+  const ids = [];
+  for (const node of chainNodes) {
+    const isModuleInstance = (node.references ?? []).some(
+      (edge) => edge.name_or_index === "namespaceObject" || edge.name_or_index === "exports"
     );
+    if (!isModuleInstance) {
+      continue;
+    }
+    for (const edge of node.referrers) {
+      if (edge.type !== "element") {
+        continue;
+      }
+      const id = Number(edge.name_or_index);
+      if (Number.isInteger(id) && !ids.includes(id)) {
+        ids.push(id);
+      }
+    }
   }
-  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".`
+  return ids;
+}
+function diffAgainstBaseline(baseline, after, options = {}) {
+  const resolved = { ...DEFAULTS, ...options };
+  const afterTypeSelfSizes = /* @__PURE__ */ new Map();
+  const grown = [];
+  const fresh = [];
+  after.nodes.forEach((node) => {
+    afterTypeSelfSizes.set(
+      node.type,
+      (afterTypeSelfSizes.get(node.type) ?? 0) + node.self_size
     );
+    if (node.type === "synthetic") {
+      return;
+    }
+    if (!baseline.nodeIds.has(node.id)) {
+      if (node.retainedSize >= resolved.newThresholdBytes) {
+        const chain = walkChain(node, resolved.chainDepth);
+        fresh.push({
+          kind: "new",
+          nodeType: node.type,
+          name: truncateLabel(node.name),
+          retainedBytes: node.retainedSize,
+          retainerChain: chain.parts.join(" <- "),
+          moduleIds: collectModuleIds(chain.nodes)
+        });
+      }
+      return;
+    }
+    const before = baseline.bigRetained.get(node.id);
+    if (before !== void 0 && node.retainedSize - before >= resolved.grownThresholdBytes) {
+      const chain = walkChain(node, resolved.chainDepth);
+      grown.push({
+        kind: "grown",
+        nodeType: node.type,
+        name: truncateLabel(node.name),
+        retainedBytes: node.retainedSize - before,
+        retainerChain: chain.parts.join(" <- "),
+        moduleIds: collectModuleIds(chain.nodes)
+      });
+    }
+  });
+  const typeDeltas = [];
+  const allTypes = /* @__PURE__ */ new Set([...baseline.typeSelfSizes.keys(), ...afterTypeSelfSizes.keys()]);
+  for (const type of allTypes) {
+    const delta = (afterTypeSelfSizes.get(type) ?? 0) - (baseline.typeSelfSizes.get(type) ?? 0);
+    if (Math.abs(delta) >= resolved.minTypeDeltaBytes) {
+      typeDeltas.push({ type, deltaBytes: delta });
+    }
   }
-  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;
+  typeDeltas.sort((a, b) => b.deltaBytes - a.deltaBytes);
+  grown.sort((a, b) => b.retainedBytes - a.retainedBytes);
+  fresh.sort((a, b) => b.retainedBytes - a.retainedBytes);
   return {
-    appDir: path.resolve(appDir),
-    standaloneServer,
-    appPaths,
-    pages,
-    routes,
-    prerender
+    typeDeltas,
+    grownNodes: grown.slice(0, resolved.maxFindings),
+    newNodes: fresh.slice(0, resolved.maxFindings)
   };
 }
-
-// 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 {
+var SnapshotError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "LaunchError";
+    this.name = "SnapshotError";
   }
 };
-var activeChildren = /* @__PURE__ */ new Set();
-var STDERR_WINDOW = 4096;
-function killActiveChildren() {
-  for (const child of activeChildren) {
-    child.kill("SIGKILL");
+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;
+  } catch {
+    throw new SnapshotError(`heap snapshot is missing: ${file}`);
   }
-}
-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 (size === 0) {
+    throw new SnapshotError(`heap snapshot is empty: ${file}`);
   }
-  if (/EADDRINUSE/.test(stderr)) {
-    return "the port was taken by another process while starting.";
+  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`
+    );
   }
-  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.`;
+  const handle = await open(file, "r");
+  try {
+    const head = Buffer.alloc(Math.min(PROBE_BYTES, size));
+    await handle.read(head, 0, head.length, 0);
+    if (!head.toString("utf8").trimStart().startsWith(SNAPSHOT_HEAD)) {
+      throw new SnapshotError(
+        `not a V8 heap snapshot (missing "snapshot" header): ${file}`
+      );
+    }
+    const tail = Buffer.alloc(Math.min(PROBE_BYTES, size));
+    await handle.read(tail, 0, tail.length, size - tail.length);
+    if (!tail.toString("utf8").trimEnd().endsWith("}")) {
+      throw new SnapshotError(
+        `heap snapshot looks truncated (JSON does not close): ${file} \u2014 the measured process may have been killed while writing it`
+      );
+    }
+  } finally {
+    await handle.close();
   }
-  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);
+var defaultLoader = async (file) => {
+  await assertReadableSnapshot(file);
+  import_core.config.muteConsole = true;
+  return (0, import_heap_analysis.getFullHeapFromFile)(file);
+};
+async function diffSnapshotFiles(baselineFile, afterFile, options = {}, loadHeap = defaultLoader) {
+  const summary = summarizeBaseline(await loadHeap(baselineFile), options);
+  const after = await loadHeap(afterFile);
+  return diffAgainstBaseline(summary, after, options);
+}
+
+// src/vlq.ts
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var CHAR_TO_VALUE = new Map([...BASE64].map((char, index) => [char, index]));
+function decodeVlqSegment(raw) {
+  const values = [];
+  let value = 0;
+  let shift = 0;
+  for (const char of raw) {
+    const digit = CHAR_TO_VALUE.get(char);
+    if (digit === void 0) {
+      throw new Error(`invalid VLQ character: ${char}`);
     }
-    const result = await probe();
-    if (result !== void 0) {
-      return result;
+    value += (digit & 31) << shift;
+    if ((digit & 32) !== 0) {
+      shift += 5;
+    } else {
+      values.push((value & 1) === 1 ? -(value >>> 1) : value >>> 1);
+      value = 0;
+      shift = 0;
     }
-    if (Date.now() > deadline) {
-      throw new LaunchError(`timed out waiting for ${what}`);
+  }
+  return values;
+}
+function decodeVlqLine(line) {
+  const segments = [];
+  for (const raw of line.split(",")) {
+    if (raw !== "") {
+      segments.push(decodeVlqSegment(raw));
     }
-    await sleep(100);
   }
+  return segments;
 }
-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"]
+function decodeMappings(mappings) {
+  const lines = [];
+  let sourceIndex = 0;
+  for (const line of mappings.split(";")) {
+    const entries = [];
+    let column = 0;
+    for (const segment of decodeVlqLine(line)) {
+      const columnDelta = segment[0];
+      if (columnDelta === void 0) {
+        continue;
+      }
+      column += columnDelta;
+      if (segment.length >= 4) {
+        sourceIndex += segment[1] ?? 0;
+        entries.push({ column, sourceIndex });
+      }
     }
-  );
-  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);
+    lines.push({ entries });
+  }
+  return lines;
+}
+function sourceIndexAt(lines, line, column) {
+  const mapping = lines[line];
+  if (mapping === void 0) {
+    return void 0;
+  }
+  let found;
+  for (const entry of mapping.entries) {
+    if (entry.column > column) {
+      break;
     }
-    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;
+    found = entry.sourceIndex;
   }
+  return found;
 }
 
-// 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",
-    value: "list",
-    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 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: "--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",
-    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 same cycle count as the default, less traffic per cycle"
-  },
-  { flag: "--diff-all", value: "none", help: "Diff snapshots for stable routes too (slow)" },
-  {
-    flag: "--no-resolve",
-    value: "none",
-    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" }
-];
-function helpText(version2) {
-  const rows = FLAGS.map((spec) => {
-    const alias = spec.alias ? `${spec.alias}, ` : "";
-    const argName = spec.argName ? ` ${spec.argName}` : "";
-    const left = `${alias}${spec.flag}${argName}`;
-    return `  ${left.padEnd(26)}${spec.help}`;
-  }).join("\n");
-  return `next-leak ${version2}
-
-Find out whether your Next.js app actually leaks memory \u2014 how much, on which
-route, and whose fault it is.
-
-Usage:
-  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:
-warm-up \u2192 GC \u2192 baseline snapshot \u2192 [load \u2192 idle \u2192 GC \u2192 sample] \xD7 cycles \u2192
-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}
-
-Exit codes: 0 when the run completes (whatever the verdicts), 130 when
-interrupted, 1 on errors.
-`;
-}
-var LIMITS = {
-  "--cycles": 100,
-  "--requests": 1e6,
-  "--connections": 1e4,
-  "--idle": 3600,
-  "--warmup": 1e6,
-  "--max-old-space": 65536
-};
-var MIN_MAX_OLD_SPACE_MB = 128;
-function findSpec(argument) {
-  return FLAGS.find((spec) => spec.flag === argument || spec.alias === argument);
-}
-var flagError = (message) => ({ kind: "error", message });
-var FLAG_OK = { kind: "ok" };
-function applyRoutesFlag(value, options) {
-  const routes = value.split(",").map((route) => route.trim()).filter((route) => route !== "");
-  if (routes.length === 0) {
-    return flagError(`option "--routes" needs at least one route`);
-  }
-  options.routes = routes;
-  return FLAG_OK;
-}
-function applyNumericFlag(flag, value, options) {
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    return flagError(`option "${flag}" needs a positive integer, got "${value}"`);
-  }
-  const maximum = LIMITS[flag];
-  if (maximum !== void 0 && parsed > maximum) {
-    return flagError(
-      `option "${flag}" is capped at ${maximum} (got ${parsed}) \u2014 a run that large would never finish`
-    );
-  }
-  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 === "--warmup") options.warmupRequests = parsed;
-  if (flag === "--max-old-space") options.maxOldSpaceMb = parsed;
-  return FLAG_OK;
-}
-function applyFlag(spec, value, options) {
-  switch (spec.flag) {
-    case "--routes":
-      return applyRoutesFlag(value, options);
-    case "--cycles":
-    case "--requests":
-    case "--connections":
-    case "--idle":
-    case "--warmup":
-    case "--max-old-space":
-      return applyNumericFlag(spec.flag, value, options);
-    case "--quick":
-      options.quick = true;
-      return FLAG_OK;
-    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;
-    case "--output":
-      options.output = value;
-      return FLAG_OK;
-    default:
-      return FLAG_OK;
-  }
-}
-function readFlagValue(spec, argv, index) {
-  if (spec.value === "none") {
-    return { value: "" };
-  }
-  const value = argv[index + 1] ?? "";
-  const looksNegativeNumber = /^-\d+(\.\d+)?$/.test(value);
-  if (value === "" || value.startsWith("-") && !looksNegativeNumber) {
-    return { error: `option "${spec.flag}" needs a value ${spec.argName ?? ""}` };
-  }
-  return { value };
-}
-function parseFlagAt(argv, index, options) {
-  const argument = argv[index] ?? "";
-  const spec = findSpec(argument);
-  if (spec === void 0) {
-    return { done: { kind: "error", message: `unknown option "${argument}" \u2014 see --help` } };
-  }
-  if (spec.flag === "--help") {
-    return { done: { kind: "help" } };
-  }
-  if (spec.flag === "--version") {
-    return { done: { kind: "version" } };
-  }
-  const read2 = readFlagValue(spec, argv, index);
-  if ("error" in read2) {
-    return { done: { kind: "error", message: read2.error } };
+// src/module-registry.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var flatMapSchema = z.looseObject({
+  version: z.number(),
+  sources: z.array(z.string()),
+  mappings: z.string()
+});
+var sectionedMapSchema = z.looseObject({
+  version: z.number(),
+  sections: z.array(
+    z.looseObject({
+      offset: z.looseObject({ line: z.number(), column: z.number() }),
+      map: z.looseObject({ sources: z.array(z.string()), mappings: z.string() })
+    })
+  )
+});
+function normalizeSourceMap(raw) {
+  const flat = flatMapSchema.safeParse(raw);
+  if (flat.success) {
+    return { sources: flat.data.sources, lines: decodeMappings(flat.data.mappings) };
   }
-  const outcome = applyFlag(spec, read2.value, options);
-  if (outcome.kind === "error") {
-    return { done: { kind: "error", message: outcome.message } };
+  const sectioned = sectionedMapSchema.safeParse(raw);
+  if (!sectioned.success) {
+    return null;
   }
-  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,
-    cycles: null,
-    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 < 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` };
+  const sources = [];
+  const lines = [];
+  for (const section of sectioned.data.sections) {
+    const sourceBase = sources.length;
+    sources.push(...section.map.sources);
+    for (const [lineIndex, mapping] of decodeMappings(section.map.mappings).entries()) {
+      const targetLine = section.offset.line + lineIndex;
+      const columnShift = lineIndex === 0 ? section.offset.column : 0;
+      const target = lines[targetLine] ??= { entries: [] };
+      for (const entry of mapping.entries) {
+        target.entries.push({
+          column: entry.column + columnShift,
+          sourceIndex: entry.sourceIndex + sourceBase
+        });
       }
-      options.appDir = argument;
-      continue;
-    }
-    const step = parseFlagAt(rest, index, options);
-    if ("done" in step) {
-      return step.done;
     }
-    index += step.consumed;
   }
-  if (options.appDir === "") {
-    return { kind: "help" };
+  for (const line of lines) {
+    line?.entries.sort((a, b) => a.column - b.column);
   }
-  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 } };
+  for (let i = 0; i < lines.length; i += 1) {
+    lines[i] ??= { entries: [] };
   }
-  return { kind: "run", options };
-}
-
-// src/guards.ts
-function currentFacts() {
-  return {
-    nodeMajor: Number(process.versions.node.split(".")[0]),
-    platform: process.platform
-  };
+  return { sources, lines };
 }
-function checkRuntime(facts = currentFacts()) {
-  if (facts.platform === "win32") {
-    return "next-leak does not support Windows (the measurement ritual relies on POSIX process control). Run it inside WSL2 or a Linux container.";
-  }
-  if (facts.nodeMajor < 22) {
-    return `next-leak needs Node.js >= 22 (you are on ${process.versions.node}). It relies on --expose-gc semantics and heap snapshot behavior verified on modern V8. Upgrade Node and retry.`;
+var ID_IN_GAP = /[,[](\d{1,9}),/g;
+function lastModuleIdIn(gap) {
+  ID_IN_GAP.lastIndex = 0;
+  let last = null;
+  let match = ID_IN_GAP.exec(gap);
+  while (match !== null) {
+    last = Number(match[1]);
+    match = ID_IN_GAP.exec(gap);
   }
-  return null;
+  return last;
 }
-
-// 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(),
-  /**
-   * Where the abandon deadline starts. `first-byte` is the default and the
-   * semantics everything else assumes.
-   *
-   * `request` starts it when the request is written, which is the only way
-   * to reach leaks that need the client already gone before the server
-   * produces anything: against a route whose time-to-first-byte exceeds the
-   * deadline, a first-byte clock never cuts early. Measured on the
-   * vercel/next.js#84648 repro, whose upstream answers in 400 ms while its
-   * own load generator cuts at 60 ms — the first-byte clock reached 7% of
-   * requests there, none of them on the path the issue describes.
-   *
-   * Opt-in per route, never a default: armed on connect, the deadline loses
-   * the race to the first byte on fast routes, which is how the earlier
-   * version of this measured 2 mid-stream cuts out of ~1500 on #94919.
-   */
-  abandonFrom: z3.enum(["first-byte", "request"]).optional()
-}).strict().refine((config) => config.abandonFrom === void 0 || config.abandonAfterMs !== void 0, {
-  message: '"abandonFrom" configures nothing without "abandonAfterMs"',
-  path: ["abandonFrom"]
-});
-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 = 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 collectFirstArrayIds(codeLines, map, result) {
+  for (const [lineIndex, lineText] of codeLines.entries()) {
+    const first = /module\.exports ?= ?\[(\d+),/.exec(lineText);
+    if (first?.[1] === void 0) {
+      continue;
+    }
+    const idEnd = first.index + first[0].length;
+    const nextId = /[,[]\d{1,9},/.exec(lineText.slice(idEnd));
+    const spanEnd = nextId === null ? lineText.length : idEnd + nextId.index;
+    const entry = map.lines[lineIndex]?.entries.find(
+      (candidate) => candidate.column >= idEnd && candidate.column < spanEnd
     );
+    const source = entry === void 0 ? void 0 : map.sources[entry.sourceIndex];
+    if (source !== void 0) {
+      result.set(Number(first[1]), source);
+    }
   }
 }
-var SEGMENT_PATTERN = /^\[(\[)?(\.\.\.)?([^\]]+?)\]?\]$/;
-function dynamicSegmentsOf(routeTemplate) {
-  const segments = [];
-  for (const segment of routeTemplate.split("/")) {
-    const match = SEGMENT_PATTERN.exec(segment);
-    if (match === null) {
+function collectTransitionIds(codeLines, map, result) {
+  for (const [lineIndex, mapping] of map.lines.entries()) {
+    const lineText = codeLines[lineIndex];
+    if (lineText === void 0) {
       continue;
     }
-    segments.push({
-      name: match[3] ?? "",
-      catchAll: match[2] !== void 0,
-      optional: match[1] !== void 0
-    });
+    let previousColumn = 0;
+    let previousSource = null;
+    for (const entry of mapping.entries) {
+      if (entry.sourceIndex !== previousSource) {
+        const id = lastModuleIdIn(lineText.slice(previousColumn, entry.column));
+        const source = map.sources[entry.sourceIndex];
+        if (id !== null && source !== void 0 && !result.has(id)) {
+          result.set(id, source);
+        }
+        previousSource = entry.sourceIndex;
+      }
+      previousColumn = entry.column;
+    }
   }
-  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;
+function extractChunkModules(code, rawMap) {
+  const result = /* @__PURE__ */ new Map();
+  if (!code.includes("module.exports=[") && !code.includes("module.exports = [")) {
+    return result;
   }
-  return { marker: match[0], bound };
+  const map = normalizeSourceMap(rawMap);
+  if (map === null) {
+    return result;
+  }
+  const codeLines = code.split("\n");
+  collectFirstArrayIds(codeLines, map, result);
+  collectTransitionIds(codeLines, map, result);
+  return result;
 }
-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));
+async function jsFilesUnder(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true, recursive: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".js")) {
+      out.push(path.join(entry.parentPath, entry.name));
+    }
+  }
+  return out;
+}
+async function extractModuleRegistry(nextServerDir) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const file of await jsFilesUnder(nextServerDir)) {
+    let code;
+    let map;
+    try {
+      code = await readFile(file, "utf8");
+      map = JSON.parse(await readFile(`${file}.map`, "utf8"));
+    } catch {
       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;
+    for (const [id, source] of extractChunkModules(code, map)) {
+      if (!registry.has(id)) {
+        registry.set(id, source);
+      }
     }
   }
-  const joined = resolved.join("/");
-  const path7 = joined === "" ? "/" : joined;
-  const query = config.query?.[routeTemplate];
-  return query === void 0 || query === "" ? path7 : `${path7}?${query}`;
+  return registry;
 }
 
-// src/route-guidance.ts
-var PLACEHOLDER = "REPLACE-ME";
-function sampleValuesFromManifest(manifest, routeTemplate) {
-  const routes = manifest?.routes;
-  if (routes === void 0) {
-    return null;
+// src/manifests.ts
+import { z as z2 } from "zod";
+var appPathsManifestSchema = z2.record(z2.string(), z2.string());
+var pagesManifestSchema = z2.record(z2.string(), z2.string());
+var routeEntrySchema = z2.looseObject({
+  page: z2.string(),
+  regex: z2.string()
+});
+var routesManifestSchema = z2.looseObject({
+  version: z2.number(),
+  basePath: z2.string(),
+  staticRoutes: z2.array(routeEntrySchema),
+  dynamicRoutes: z2.array(routeEntrySchema)
+});
+var prerenderManifestSchema = z2.looseObject({
+  routes: z2.record(
+    z2.string(),
+    z2.looseObject({
+      // `false` on a route that is prerendered but never revalidates.
+      initialRevalidateSeconds: z2.union([z2.number(), z2.literal(false)]).optional(),
+      srcRoute: z2.string().nullable().optional()
+    })
+  ).optional(),
+  preview: z2.looseObject({ previewModeId: z2.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";
   }
-  const concrete = Object.entries(routes).find(([, entry]) => entry.srcRoute === routeTemplate)?.[0];
-  if (concrete === void 0) {
+  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 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) {
+  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;
     }
-    const value = parameter.catchAll ? concreteSegments.slice(index).join("/") : concreteSegments[index];
-    if (value === void 0 || value === "") {
-      return null;
-    }
-    values[parameter.name] = value;
+    routes.push({
+      path: key,
+      kind: key === "/api" || key.startsWith("/api/") ? "route-handler" : "page",
+      dynamic: key.includes("[")
+    });
   }
-  return Object.keys(values).length === 0 ? null : values;
+  return routes.sort((a, b) => a.path.localeCompare(b.path));
 }
-function renderConfigSkeleton(routeTemplates, manifest = void 0) {
-  const routes = {};
-  for (const template of routeTemplates) {
-    const segments = dynamicSegmentsOf(template);
-    if (segments.length === 0) {
+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 sampled = sampleValuesFromManifest(manifest, template);
-    const values = {};
-    for (const segment of segments) {
-      values[segment.name] = sampled?.[segment.name] ?? PLACEHOLDER;
-    }
-    routes[template] = values;
+    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 Object.keys(routes).length === 0 ? null : JSON.stringify({ routes }, null, 2);
-}
-function hasPlaceholders(skeleton) {
-  return skeleton.includes(PLACEHOLDER);
+  return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
 }
 
-// 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;
-    }
-    gaps.push(read(held, memoryClass) - read(afterGc, memoryClass));
+// src/target.ts
+import { access, readFile as readFile2 } from "fs/promises";
+import path2 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;
   }
-  return gaps;
 }
-function assessUnreclaimedRetention(input) {
-  if (input.verdict === "leak" && input.verdictIsWellSupported || input.unreclaimedSamples.length === 0) {
-    return null;
+async function readManifest(file, parse2) {
+  let raw;
+  try {
+    raw = JSON.parse(await readFile2(file, "utf8"));
+  } catch (cause) {
+    throw new TargetError(
+      "BAD_MANIFEST",
+      `Could not read ${file}: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
   }
-  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))
+  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.`
     );
-    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`;
+async function validateTarget(appDir) {
+  const nextDir = path2.resolve(appDir, ".next");
+  if (!await exists(nextDir)) {
+    throw new TargetError(
+      "NO_BUILD",
+      `No .next directory in ${appDir}. Run "next build" first.`
+    );
+  }
+  const standaloneServer = path2.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 = path2.join(nextDir, "server", "app-paths-manifest.json");
+  const pagesFile = path2.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 = path2.join(nextDir, "routes-manifest.json");
+  const routes = await exists(routesFile) ? await readManifest(routesFile, (raw) => routesManifestSchema.parse(raw)) : void 0;
+  const prerenderFile = path2.join(nextDir, "prerender-manifest.json");
+  const prerender = await exists(prerenderFile) ? await readManifest(prerenderFile, (raw) => prerenderManifestSchema.parse(raw)) : void 0;
+  return {
+    appDir: path2.resolve(appDir),
+    standaloneServer,
+    appPaths,
+    pages,
+    routes,
+    prerender
+  };
 }
 
-// src/report.ts
-var MB2 = 1024 * 1024;
-var formatMb = (bytes) => `${(bytes / MB2).toFixed(1)} MB`;
-var formatGrowth = (bytes) => {
-  const sign = bytes >= 0 ? "+" : "";
-  return `${sign}${(bytes / MB2).toFixed(2)} MB/1000 req`;
+// src/launcher.ts
+import { spawn } from "child_process";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+import { pathToFileURL } from "url";
+import { z as z3 } from "zod";
+var controlFileSchema = z3.object({ port: z3.number(), pid: z3.number() });
+var DEFAULT_MAX_OLD_SPACE_MB = 512;
+var LaunchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LaunchError";
+  }
 };
-var VERDICT_ICON = { leak: "\u2716", stable: "\u2714", inconclusive: "?" };
-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];
-  const last = rss.at(-1);
-  if (first === void 0 || last === void 0 || rss.length < 4) {
-    return false;
+var activeChildren = /* @__PURE__ */ new Set();
+var STDERR_WINDOW = 4096;
+function killActiveChildren() {
+  for (const child of activeChildren) {
+    child.kill("SIGKILL");
   }
-  return classifyTrend(rss, { minGrowthPerCycle: RSS_MIN_GROWTH_PER_CYCLE }).verdict === "leak" && last - first >= RSS_MIN_TOTAL_GROWTH;
 }
-function ownerLabel(attribution) {
-  switch (attribution.owner) {
-    case "app":
-      return `${attribution.source ?? "your code"} (your code)`;
-    case "dependency":
-      return `${attribution.packageName ?? "a dependency"} (dependency)`;
-    case "framework":
-      return attribution.packageName === null ? "Next.js/runtime internals" : `${attribution.packageName} (framework)`;
-    case "unattributed":
-      return null;
+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 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 stderrShowsHeapExhaustion(stderr) {
+  return /heap out of memory|Reached heap limit|Ineffective mark-compacts/i.test(stderr);
 }
-function abandonLines(route) {
-  if (route.abandon === void 0) {
-    return [];
+function explainRuntimeFailure(stderr, maxOldSpaceMb) {
+  if (stderrShowsHeapExhaustion(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 [
-    route.abandon.from === "request" ? `      cut ${route.abandon.afterMs}ms after the request was sent, so the client is gone before the response starts` : `      cut ${route.abandon.afterMs}ms after the first byte, so the cut lands mid-stream`
-  ];
+  return `the measured process exited mid-run. ${explainStartupFailure(stderr)}`;
 }
-function confidenceLines(route) {
-  const lines = [];
-  if (route.confidence.supersededVerdict !== void 0) {
-    lines.push(
-      `      measured ${route.trend.verdict}, withdrawn: the run did not observe what that verdict needs`
-    );
+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);
   }
-  for (const warning of route.confidence.warnings) {
-    lines.push(`      \u26A0 low confidence: ${warning.detail}`);
+}
+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: path3.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 readdir2(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 readFile3(path3.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: () => {
+        if (!exited) {
+          return null;
+        }
+        const stderr = stderrWindow();
+        return {
+          reason: explainRuntimeFailure(
+            stderr,
+            options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB
+          ),
+          heapExhausted: stderrShowsHeapExhaustion(stderr)
+        };
+      },
+      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;
   }
-  return lines;
 }
-function memorySourceLines(route, verdict) {
-  const lines = [];
-  if (route.trend.source === "external" && verdict !== "stable") {
-    const externalCurve = route.memorySamples.map((sample) => formatMb(sample.external)).join(" \u2192 ");
-    lines.push(
-      `      verdict comes from EXTERNAL memory (buffers, streams, fetch bodies), not the JS heap: external ${externalCurve}`
-    );
-  }
-  if (verdict === "stable" && hasSustainedRssGrowth(route.memorySamples)) {
-    const rssCurve = route.memorySamples.map((sample) => formatMb(sample.rss)).join(" \u2192 ");
-    lines.push(
-      `      note: heap is flat but RSS grows ${formatGrowth(route.rssPer1000Requests)} \u2014 not a JS-heap leak (allocator, external buffers or fragmentation): RSS ${rssCurve}`
-    );
+
+// 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 lines;
+  return null;
 }
-function diffFindingLines(route) {
-  if (route.diff === null) {
-    return [];
-  }
-  const findings = [...route.diff.grownNodes, ...route.diff.newNodes];
-  return findings.slice(0, 3).map((finding, index) => {
-    const size = formatMb(finding.retainedBytes);
-    const attribution = route.attribution?.findings[index];
-    const owner = attribution === void 0 ? null : ownerLabel(attribution);
-    const detail = owner ?? (finding.retainerChain === "" ? "" : finding.retainerChain);
-    return `      \u21B3 ${finding.kind} [${finding.nodeType}] ${finding.name} ${size}${detail === "" ? "" : ` \u2014 ${detail}`}`;
-  });
+var FLAGS = [
+  {
+    flag: "--routes",
+    value: "list",
+    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 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: "--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",
+    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 same cycle count as the default, less traffic per cycle"
+  },
+  { flag: "--diff-all", value: "none", help: "Diff snapshots for stable routes too (slow)" },
+  {
+    flag: "--attribute",
+    value: "none",
+    help: "build only: also name what the worker retains \u2014 signals it for heap snapshots, which can stall the build"
+  },
+  {
+    flag: "--no-resolve",
+    value: "none",
+    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" }
+];
+function helpText(version2) {
+  const rows = FLAGS.map((spec) => {
+    const alias = spec.alias ? `${spec.alias}, ` : "";
+    const argName = spec.argName ? ` ${spec.argName}` : "";
+    const left = `${alias}${spec.flag}${argName}`;
+    return `  ${left.padEnd(26)}${spec.help}`;
+  }).join("\n");
+  return `next-leak ${version2}
+
+Find out whether your Next.js app actually leaks memory \u2014 how much, on which
+route, and whose fault it is.
+
+Usage:
+  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:
+warm-up \u2192 GC \u2192 baseline snapshot \u2192 [load \u2192 idle \u2192 GC \u2192 sample] \xD7 cycles \u2192
+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}
+
+Exit codes: 0 when the run completes (whatever the verdicts), 130 when
+interrupted, 1 on errors.
+`;
 }
-function findingLines(route) {
-  const lines = [];
-  const culprit = route.attribution === null ? null : ownerLabel(route.attribution.route);
-  if (culprit !== null) {
-    lines.push(`      culprit: ${culprit}`);
-  }
-  lines.push(...diffFindingLines(route));
-  for (const signature of route.signatures) {
-    const flag = signature.historical ? " (historical)" : "";
-    lines.push(`      \u26A0 known cause${flag}: ${signature.title} \u2014 ${signature.issue}`);
-  }
-  return lines;
+var LIMITS = {
+  "--cycles": 100,
+  "--requests": 1e6,
+  "--connections": 1e4,
+  "--idle": 3600,
+  "--warmup": 1e6,
+  "--max-old-space": 65536
+};
+var MIN_MAX_OLD_SPACE_MB = 128;
+function findSpec(argument) {
+  return FLAGS.find((spec) => spec.flag === argument || spec.alias === argument);
 }
-function peakPressureLines(route, parameters) {
-  const retained = route.memorySamples.at(-1)?.heapUsed;
-  if (retained === void 0) {
-    return [];
+var flagError = (message) => ({ kind: "error", message });
+var FLAG_OK = { kind: "ok" };
+function applyRoutesFlag(value, options) {
+  const routes = value.split(",").map((route) => route.trim()).filter((route) => route !== "");
+  if (routes.length === 0) {
+    return flagError(`option "--routes" needs at least one route`);
   }
-  const pressure = assessPeakPressure({
-    peaks: route.peaks,
-    retainedHeapBytes: retained,
-    maxOldSpaceMb: parameters.maxOldSpaceMb
-  });
-  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)}`];
+  options.routes = routes;
+  return FLAG_OK;
 }
-function routeLines(route, parameters) {
-  if (route.status === "skipped") {
-    return [`  \u2013 ${route.route}  skipped: ${route.reason}`];
+function applyNumericFlag(flag, value, options) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    return flagError(`option "${flag}" needs a positive integer, got "${value}"`);
   }
-  if (route.status === "failed") {
-    return [`  \u2716 ${route.route}  failed: ${route.reason}`];
+  const maximum = LIMITS[flag];
+  if (maximum !== void 0 && parsed > maximum) {
+    return flagError(
+      `option "${flag}" is capped at ${maximum} (got ${parsed}) \u2014 a run that large would never finish`
+    );
   }
-  if (route.status === "not-exercised") {
-    return [`  \u2013 ${route.route}  not exercised: ${route.reason}`];
+  if (flag === "--cycles" && parsed < 3) {
+    return flagError("the trend verdict needs at least 3 cycles (--cycles 3 or more)");
   }
-  const verdict = effectiveVerdict(route);
-  const curve = route.samples.map(formatMb).join(" \u2192 ");
-  const resolved = route.resolvedWithCycles === void 0 ? "" : `  (resolved at ${route.resolvedWithCycles} cycles)`;
-  return [
-    `  ${VERDICT_ICON[verdict]} ${route.route}  ${verdict}  (${formatGrowth(
-      route.growthPer1000Requests
-    )})  heap ${curve}${resolved}`,
-    ...revalidationLines(route),
-    ...abandonLines(route),
-    ...confidenceLines(route),
-    ...memorySourceLines(route, verdict),
-    ...peakPressureLines(route, parameters),
-    ...unreclaimedLines(route, verdict),
-    ...findingLines(route)
-  ];
+  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 === "--warmup") options.warmupRequests = parsed;
+  if (flag === "--max-old-space") options.maxOldSpaceMb = parsed;
+  return FLAG_OK;
 }
-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 [];
+function applyFlag(spec, value, options) {
+  switch (spec.flag) {
+    case "--routes":
+      return applyRoutesFlag(value, options);
+    case "--cycles":
+    case "--requests":
+    case "--connections":
+    case "--idle":
+    case "--warmup":
+    case "--max-old-space":
+      return applyNumericFlag(spec.flag, value, options);
+    case "--quick":
+      options.quick = true;
+      return FLAG_OK;
+    case "--diff-all":
+      options.diffAll = true;
+      return FLAG_OK;
+    case "--attribute":
+      options.attributeBuild = true;
+      return FLAG_OK;
+    case "--write-config":
+      options.writeConfig = true;
+      return FLAG_OK;
+    case "--no-resolve":
+      options.noResolve = true;
+      return FLAG_OK;
+    case "--output":
+      options.output = value;
+      return FLAG_OK;
+    default:
+      return FLAG_OK;
   }
-  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)`;
+function readFlagValue(spec, argv, index) {
+  if (spec.value === "none") {
+    return { value: "" };
   }
-  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`;
+  const value = argv[index + 1] ?? "";
+  const looksNegativeNumber = /^-\d+(\.\d+)?$/.test(value);
+  if (value === "" || value.startsWith("-") && !looksNegativeNumber) {
+    return { error: `option "${spec.flag}" needs a value ${spec.argName ?? ""}` };
+  }
+  return { value };
 }
-function formatReport(report) {
-  const lines = [`next-leak \u2014 ${report.appDir}`, ""];
-  for (const route of report.routes) {
-    lines.push(...routeLines(route, report.parameters));
+function parseFlagAt(argv, index, options) {
+  const argument = argv[index] ?? "";
+  const spec = findSpec(argument);
+  if (spec === void 0) {
+    return { done: { kind: "error", message: `unknown option "${argument}" \u2014 see --help` } };
   }
-  lines.push(...skippedGuidanceLines(report));
-  const { minGrowthPerCycle, loadRequests, cycles, maxOldSpaceMb } = report.parameters;
-  const resolvedCycles = [
-    ...new Set(
-      report.routes.flatMap(
-        (route) => route.status === "measured" && route.resolvedWithCycles !== void 0 ? [route.resolvedWithCycles] : []
-      )
-    )
-  ].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}`,
-    ...report.bundle.issues.map((issue) => `issue draft (${issue.route}): ${issue.file}`)
-  );
-  const inconclusive = report.routes.filter(
-    (route) => route.status === "measured" && effectiveVerdict(route) === "inconclusive"
-  );
-  if (inconclusive.length > 0) {
-    const routeList = inconclusive.map((route) => route.route).join(",");
-    const moreCycles = resolveCycles(report.parameters.cycles);
-    lines.push(
-      "",
-      "hint: inconclusive means sustained sub-threshold growth \u2014 measure longer to resolve it:",
-      `  next-leak ${report.appDir} --routes ${routeList} --cycles ${moreCycles}`
-    );
+  if (spec.flag === "--help") {
+    return { done: { kind: "help" } };
   }
-  return lines.join("\n");
+  if (spec.flag === "--version") {
+    return { done: { kind: "version" } };
+  }
+  const read2 = readFlagValue(spec, argv, index);
+  if ("error" in read2) {
+    return { done: { kind: "error", message: read2.error } };
+  }
+  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 };
 }
-
-// src/attribution.ts
-var UNATTRIBUTED = { owner: "unattributed", source: null, packageName: null };
-function classifySource(rawSource) {
-  let source = rawSource.replace(/^turbopack:\/+(?=\[)/, "");
-  try {
-    source = decodeURIComponent(source);
-  } catch {
+function parseCliArgs(argv) {
+  const isBuild = argv[0] === BUILD_COMMAND;
+  const rest = isBuild ? argv.slice(1) : argv;
+  const options = {
+    appDir: "",
+    routes: null,
+    cycles: null,
+    requests: null,
+    connections: null,
+    idleSeconds: null,
+    warmupRequests: null,
+    maxOldSpaceMb: null,
+    quick: false,
+    noResolve: false,
+    diffAll: false,
+    attributeBuild: false,
+    writeConfig: false,
+    output: null
+  };
+  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` };
+      }
+      options.appDir = argument;
+      continue;
+    }
+    const step = parseFlagAt(rest, index, options);
+    if ("done" in step) {
+      return step.done;
+    }
+    index += step.consumed;
   }
-  const nodeModulesSplit = source.split("/node_modules/");
-  if (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") {
-      return { owner: "framework", source: null, packageName };
+  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 { owner: "dependency", source: null, packageName };
+    return {
+      kind: "build",
+      options: {
+        appDir: options.appDir,
+        output: options.output,
+        attributeBuild: options.attributeBuild
+      }
+    };
   }
-  if (source.startsWith("[project]/")) {
-    return { owner: "app", source: source.slice("[project]/".length), packageName: null };
+  return { kind: "run", options };
+}
+
+// src/guards.ts
+function currentFacts() {
+  return {
+    nodeMajor: Number(process.versions.node.split(".")[0]),
+    platform: process.platform
+  };
+}
+function checkRuntime(facts = currentFacts()) {
+  if (facts.platform === "win32") {
+    return "next-leak does not support Windows (the measurement ritual relies on POSIX process control). Run it inside WSL2 or a Linux container.";
   }
-  const relative = source.replace(/^(\.\.\/)+/, "");
-  if (relative !== source && !relative.startsWith("[")) {
-    return { owner: "app", source: relative, packageName: null };
+  if (facts.nodeMajor < 22) {
+    return `next-leak needs Node.js >= 22 (you are on ${process.versions.node}). It relies on --expose-gc semantics and heap snapshot behavior verified on modern V8. Upgrade Node and retry.`;
   }
-  return { owner: "framework", source: null, packageName: null };
+  return null;
 }
-var OWNER_PRIORITY = {
-  app: 0,
-  dependency: 1,
-  framework: 2,
-  unattributed: 3
+
+// src/route-config.ts
+import { readFile as readFile4 } from "fs/promises";
+import path4 from "path";
+import { z as z4 } from "zod";
+var sampleValueSchema = z4.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 = z4.object({
+  params: z4.record(z4.string(), sampleValueSchema).optional(),
+  routes: z4.record(z4.string(), z4.record(z4.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: z4.record(z4.string(), z4.string()).optional(),
+  /** Query string appended per route template, e.g. `"weightKb=2048"`. */
+  query: z4.record(z4.string(), z4.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: z4.number().int().positive().optional(),
+  /**
+   * Where the abandon deadline starts. `first-byte` is the default and the
+   * semantics everything else assumes.
+   *
+   * `request` starts it when the request is written, which is the only way
+   * to reach leaks that need the client already gone before the server
+   * produces anything: against a route whose time-to-first-byte exceeds the
+   * deadline, a first-byte clock never cuts early. Measured on the
+   * vercel/next.js#84648 repro, whose upstream answers in 400 ms while its
+   * own load generator cuts at 60 ms — the first-byte clock reached 7% of
+   * requests there, none of them on the path the issue describes.
+   *
+   * Opt-in per route, never a default: armed on connect, the deadline loses
+   * the race to the first byte on fast routes, which is how the earlier
+   * version of this measured 2 mid-stream cuts out of ~1500 on #94919.
+   */
+  abandonFrom: z4.enum(["first-byte", "request"]).optional()
+}).strict().refine((config) => config.abandonFrom === void 0 || config.abandonAfterMs !== void 0, {
+  message: '"abandonFrom" configures nothing without "abandonAfterMs"',
+  path: ["abandonFrom"]
+});
+var RouteConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RouteConfigError";
+  }
 };
-var FRAMEWORK_CHAIN_MARKERS = [
-  ["fsChecker", "route filesystem checker"],
-  ["getDynamicRoutes", "dynamic route matcher"],
-  ["NextNodeServer", "Next server"],
-  ["AppPageRouteModule", "App Router page module"],
-  ["AppRouteRouteModule", "App Router route handler module"],
-  ["incrementalCache", "incremental cache"],
-  ["IncrementalCache", "incremental cache"],
-  ["ReactServer", "React Server Components renderer"],
-  ["loadManifests", "manifest loader"],
-  ["renderToHTML", "HTML renderer"]
-];
-function classifyByChain(retainerChain2) {
-  for (const [marker, component] of FRAMEWORK_CHAIN_MARKERS) {
-    if (retainerChain2.includes(marker)) {
-      return { owner: "framework", source: null, packageName: `next (${component})` };
-    }
+var ROUTE_CONFIG_FILE = "next-leak.config.json";
+async function loadRouteConfig(appDir) {
+  const file = path4.join(appDir, ROUTE_CONFIG_FILE);
+  let raw;
+  try {
+    raw = await readFile4(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)}`
+    );
   }
-  return null;
 }
-function attributeFinding(finding, registry) {
-  let best = UNATTRIBUTED;
-  for (const id of finding.moduleIds) {
-    const source = registry.get(id);
-    if (source === void 0) {
+var SEGMENT_PATTERN = /^\[(\[)?(\.\.\.)?([^\]]+?)\]?\]$/;
+function dynamicSegmentsOf(routeTemplate) {
+  const segments = [];
+  for (const segment of routeTemplate.split("/")) {
+    const match = SEGMENT_PATTERN.exec(segment);
+    if (match === null) {
       continue;
     }
-    const candidate = classifySource(source);
-    if (OWNER_PRIORITY[candidate.owner] < OWNER_PRIORITY[best.owner]) {
-      best = candidate;
-    }
+    segments.push({
+      name: match[3] ?? "",
+      catchAll: match[2] !== void 0,
+      optional: match[1] !== void 0
+    });
   }
-  if (best.owner === "unattributed") {
-    return classifyByChain(finding.retainerChain ?? "") ?? UNATTRIBUTED;
+  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 best;
+  return { marker: match[0], bound };
 }
-function attributeDiff(diff, registry) {
-  const all = [...diff.grownNodes, ...diff.newNodes];
-  const findings = all.map((finding) => attributeFinding(finding, registry));
-  const byGroup = /* @__PURE__ */ new Map();
-  let attributedBytes = 0;
-  for (const [index, attribution] of findings.entries()) {
-    if (attribution.owner === "unattributed") {
+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 bytes = all[index]?.retainedBytes ?? 0;
-    attributedBytes += bytes;
-    const key = `${attribution.owner}|${attribution.source ?? ""}|${attribution.packageName ?? ""}`;
-    const group = byGroup.get(key) ?? { attribution, bytes: 0 };
-    group.bytes += bytes;
-    byGroup.set(key, group);
-  }
-  let winner = null;
-  for (const group of byGroup.values()) {
-    if (winner === null || group.bytes > winner.bytes) {
-      winner = group;
+    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 route = winner === null || attributedBytes === 0 ? { ...UNATTRIBUTED, dominance: 0 } : { ...winner.attribution, dominance: winner.bytes / attributedBytes };
-  return { findings, route };
-}
-
-// src/environment.ts
-import { createRequire } from "module";
-import os from "os";
-var require2 = createRequire(import.meta.url);
-var { version: nextLeakVersion } = require2("../package.json");
-function captureEnvironment(nextVersion) {
-  return {
-    nodeVersion: process.version,
-    platform: os.platform(),
-    arch: os.arch(),
-    cpuModel: os.cpus()[0]?.model ?? null,
-    totalMemoryBytes: os.totalmem(),
-    nextVersion,
-    nextLeakVersion
-  };
+  const joined = resolved.join("/");
+  const path7 = joined === "" ? "/" : joined;
+  const query = config.query?.[routeTemplate];
+  return query === void 0 || query === "" ? path7 : `${path7}?${query}`;
 }
 
-// src/heap-diff.ts
-var import_core = __toESM(require_dist(), 1);
-var import_heap_analysis = __toESM(require_dist4(), 1);
-var DEFAULTS = {
-  minTypeDeltaBytes: 20 * 1024,
-  grownThresholdBytes: 100 * 1024,
-  newThresholdBytes: 2 * 1024,
-  bigRetainedFloorBytes: 50 * 1024,
-  maxFindings: 10,
-  chainDepth: 7
-};
-function summarizeBaseline(heap, options = {}) {
-  const resolved = { ...DEFAULTS, ...options };
-  const summary = {
-    nodeIds: /* @__PURE__ */ new Set(),
-    bigRetained: /* @__PURE__ */ new Map(),
-    typeSelfSizes: /* @__PURE__ */ new Map()
-  };
-  heap.nodes.forEach((node) => {
-    summary.nodeIds.add(node.id);
-    if (node.retainedSize >= resolved.bigRetainedFloorBytes) {
-      summary.bigRetained.set(node.id, node.retainedSize);
-    }
-    summary.typeSelfSizes.set(
-      node.type,
-      (summary.typeSelfSizes.get(node.type) ?? 0) + node.self_size
-    );
-  });
-  return summary;
-}
-function truncateLabel(value, max2 = 60) {
-  return value.replaceAll("\n", " ").slice(0, max2);
+// src/route-guidance.ts
+var PLACEHOLDER = "REPLACE-ME";
+function varyingValueFrom(prerendered) {
+  const numbered = /^(.*?)(\d+)$/.exec(prerendered);
+  if (numbered !== null && numbered[1] !== "") {
+    return `${numbered[1]}{n}`;
+  }
+  return `${prerendered}-{n}`;
 }
-function walkChain(node, depth) {
-  const parts = [];
-  const nodes = [node];
-  let current = node;
-  const seen = /* @__PURE__ */ new Set([node.id]);
-  for (let i = 0; i < depth; i += 1) {
-    const referrers = current.referrers;
-    if (referrers.length === 0) {
-      break;
+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 edge = referrers.find(
-      (candidate) => !seen.has(candidate.fromNode.id) && candidate.fromNode.type !== "synthetic" && candidate.type !== "weak"
-    ) ?? referrers[0];
-    if (edge === void 0 || seen.has(edge.fromNode.id)) {
-      break;
+    const value = parameter.catchAll ? concreteSegments.slice(index).join("/") : concreteSegments[index];
+    if (value === void 0 || value === "") {
+      return null;
     }
-    current = edge.fromNode;
-    seen.add(current.id);
-    nodes.push(current);
-    parts.push(
-      `${truncateLabel(current.name)}#${current.type}[.${truncateLabel(
-        String(edge.name_or_index),
-        40
-      )}]`
-    );
+    values[parameter.name] = value;
   }
-  return { parts, nodes };
-}
-function retainerChain(node, depth) {
-  return walkChain(node, depth).parts.join(" <- ");
+  return Object.keys(values).length === 0 ? null : values;
 }
-function collectModuleIds(chainNodes) {
-  const ids = [];
-  for (const node of chainNodes) {
-    const isModuleInstance = (node.references ?? []).some(
-      (edge) => edge.name_or_index === "namespaceObject" || edge.name_or_index === "exports"
-    );
-    if (!isModuleInstance) {
+function renderConfigSkeleton(routeTemplates, manifest = void 0) {
+  const routes = {};
+  for (const template of routeTemplates) {
+    const segments = dynamicSegmentsOf(template);
+    if (segments.length === 0) {
       continue;
     }
-    for (const edge of node.referrers) {
-      if (edge.type !== "element") {
-        continue;
-      }
-      const id = Number(edge.name_or_index);
-      if (Number.isInteger(id) && !ids.includes(id)) {
-        ids.push(id);
-      }
+    const sampled = sampleValuesFromManifest(manifest, template);
+    const values = {};
+    for (const segment of segments) {
+      const prerendered = sampled?.[segment.name];
+      values[segment.name] = prerendered === void 0 ? PLACEHOLDER : varyingValueFrom(prerendered);
     }
+    routes[template] = values;
   }
-  return ids;
+  return Object.keys(routes).length === 0 ? null : JSON.stringify({ routes }, null, 2);
 }
-function diffAgainstBaseline(baseline, after, options = {}) {
-  const resolved = { ...DEFAULTS, ...options };
-  const afterTypeSelfSizes = /* @__PURE__ */ new Map();
-  const grown = [];
-  const fresh = [];
-  after.nodes.forEach((node) => {
-    afterTypeSelfSizes.set(
-      node.type,
-      (afterTypeSelfSizes.get(node.type) ?? 0) + node.self_size
-    );
-    if (node.type === "synthetic") {
-      return;
-    }
-    if (!baseline.nodeIds.has(node.id)) {
-      if (node.retainedSize >= resolved.newThresholdBytes) {
-        const chain = walkChain(node, resolved.chainDepth);
-        fresh.push({
-          kind: "new",
-          nodeType: node.type,
-          name: truncateLabel(node.name),
-          retainedBytes: node.retainedSize,
-          retainerChain: chain.parts.join(" <- "),
-          moduleIds: collectModuleIds(chain.nodes)
-        });
-      }
-      return;
-    }
-    const before = baseline.bigRetained.get(node.id);
-    if (before !== void 0 && node.retainedSize - before >= resolved.grownThresholdBytes) {
-      const chain = walkChain(node, resolved.chainDepth);
-      grown.push({
-        kind: "grown",
-        nodeType: node.type,
-        name: truncateLabel(node.name),
-        retainedBytes: node.retainedSize - before,
-        retainerChain: chain.parts.join(" <- "),
-        moduleIds: collectModuleIds(chain.nodes)
-      });
-    }
-  });
-  const typeDeltas = [];
-  const allTypes = /* @__PURE__ */ new Set([...baseline.typeSelfSizes.keys(), ...afterTypeSelfSizes.keys()]);
-  for (const type of allTypes) {
-    const delta = (afterTypeSelfSizes.get(type) ?? 0) - (baseline.typeSelfSizes.get(type) ?? 0);
-    if (Math.abs(delta) >= resolved.minTypeDeltaBytes) {
-      typeDeltas.push({ type, deltaBytes: delta });
+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;
     }
+    gaps.push(read(held, memoryClass) - read(afterGc, memoryClass));
   }
-  typeDeltas.sort((a, b) => b.deltaBytes - a.deltaBytes);
-  grown.sort((a, b) => b.retainedBytes - a.retainedBytes);
-  fresh.sort((a, b) => b.retainedBytes - a.retainedBytes);
-  return {
-    typeDeltas,
-    grownNodes: grown.slice(0, resolved.maxFindings),
-    newNodes: fresh.slice(0, resolved.maxFindings)
-  };
+  return gaps;
 }
-var SnapshotError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SnapshotError";
-  }
-};
-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;
-  } catch {
-    throw new SnapshotError(`heap snapshot is missing: ${file}`);
-  }
-  if (size === 0) {
-    throw new SnapshotError(`heap snapshot is empty: ${file}`);
+function assessUnreclaimedRetention(input) {
+  if (input.verdict === "leak" && input.verdictIsWellSupported || input.unreclaimedSamples.length === 0) {
+    return null;
   }
-  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`
+  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))
     );
-  }
-  const handle = await open(file, "r");
-  try {
-    const head = Buffer.alloc(Math.min(PROBE_BYTES, size));
-    await handle.read(head, 0, head.length, 0);
-    if (!head.toString("utf8").trimStart().startsWith(SNAPSHOT_HEAD)) {
-      throw new SnapshotError(
-        `not a V8 heap snapshot (missing "snapshot" header): ${file}`
-      );
+    const ratio = largestGapBytes / Math.max(retainedBytes, MIN_RETAINED_BYTES);
+    if (ratio < MIN_GAP_RATIO) {
+      continue;
     }
-    const tail = Buffer.alloc(Math.min(PROBE_BYTES, size));
-    await handle.read(tail, 0, tail.length, size - tail.length);
-    if (!tail.toString("utf8").trimEnd().endsWith("}")) {
-      throw new SnapshotError(
-        `heap snapshot looks truncated (JSON does not close): ${file} \u2014 the measured process may have been killed while writing it`
-      );
+    if (worst === null || ratio >= worst.ratio) {
+      worst = { class: memoryClass, largestGapBytes, retainedBytes, ratio };
     }
-  } finally {
-    await handle.close();
   }
+  return worst;
 }
-var defaultLoader = async (file) => {
-  await assertReadableSnapshot(file);
-  import_core.config.muteConsole = true;
-  return (0, import_heap_analysis.getFullHeapFromFile)(file);
+var mb = (bytes) => `${(bytes / MB).toFixed(2)} MB`;
+var CLASS_LABEL = {
+  heap: "heap",
+  external: "external memory",
+  arrayBuffers: "arrayBuffers"
 };
-async function diffSnapshotFiles(baselineFile, afterFile, options = {}, loadHeap = defaultLoader) {
-  const summary = summarizeBaseline(await loadHeap(baselineFile), options);
-  const after = await loadHeap(afterFile);
-  return diffAgainstBaseline(summary, after, options);
+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/vlq.ts
-var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var CHAR_TO_VALUE = new Map([...BASE64].map((char, index) => [char, index]));
-function decodeVlqSegment(raw) {
-  const values = [];
-  let value = 0;
-  let shift = 0;
-  for (const char of raw) {
-    const digit = CHAR_TO_VALUE.get(char);
-    if (digit === void 0) {
-      throw new Error(`invalid VLQ character: ${char}`);
-    }
-    value += (digit & 31) << shift;
-    if ((digit & 32) !== 0) {
-      shift += 5;
-    } else {
-      values.push((value & 1) === 1 ? -(value >>> 1) : value >>> 1);
-      value = 0;
-      shift = 0;
-    }
+// src/report.ts
+var MB2 = 1024 * 1024;
+var formatMb = (bytes) => `${(bytes / MB2).toFixed(1)} MB`;
+var formatGrowth = (bytes) => {
+  const sign = bytes >= 0 ? "+" : "";
+  return `${sign}${(bytes / MB2).toFixed(2)} MB/1000 req`;
+};
+var VERDICT_ICON = { leak: "\u2716", stable: "\u2714", inconclusive: "?" };
+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];
+  const last = rss.at(-1);
+  if (first === void 0 || last === void 0 || rss.length < 4) {
+    return false;
   }
-  return values;
+  return classifyTrend(rss, { minGrowthPerCycle: RSS_MIN_GROWTH_PER_CYCLE }).verdict === "leak" && last - first >= RSS_MIN_TOTAL_GROWTH;
 }
-function decodeVlqLine(line) {
-  const segments = [];
-  for (const raw of line.split(",")) {
-    if (raw !== "") {
-      segments.push(decodeVlqSegment(raw));
-    }
+function ownerLabel(attribution) {
+  switch (attribution.owner) {
+    case "app":
+      return `${attribution.source ?? "your code"} (your code)`;
+    case "dependency":
+      return `${attribution.packageName ?? "a dependency"} (dependency)`;
+    case "framework":
+      return attribution.packageName === null ? "Next.js/runtime internals" : `${attribution.packageName} (framework)`;
+    case "unattributed":
+      return null;
   }
-  return segments;
 }
-function decodeMappings(mappings) {
-  const lines = [];
-  let sourceIndex = 0;
-  for (const line of mappings.split(";")) {
-    const entries = [];
-    let column = 0;
-    for (const segment of decodeVlqLine(line)) {
-      const columnDelta = segment[0];
-      if (columnDelta === void 0) {
-        continue;
-      }
-      column += columnDelta;
-      if (segment.length >= 4) {
-        sourceIndex += segment[1] ?? 0;
-        entries.push({ column, sourceIndex });
-      }
-    }
-    lines.push({ entries });
+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 abandonLines(route) {
+  if (route.abandon === void 0) {
+    return [];
   }
-  return lines;
+  return [
+    route.abandon.from === "request" ? `      cut ${route.abandon.afterMs}ms after the request was sent, so the client is gone before the response starts` : `      cut ${route.abandon.afterMs}ms after the first byte, so the cut lands mid-stream`
+  ];
 }
-function sourceIndexAt(lines, line, column) {
-  const mapping = lines[line];
-  if (mapping === void 0) {
-    return void 0;
+function confidenceLines(route) {
+  const lines = [];
+  if (route.confidence.supersededVerdict !== void 0) {
+    lines.push(
+      `      measured ${route.trend.verdict}, withdrawn: the run did not observe what that verdict needs`
+    );
   }
-  let found;
-  for (const entry of mapping.entries) {
-    if (entry.column > column) {
-      break;
-    }
-    found = entry.sourceIndex;
+  for (const warning of route.confidence.warnings) {
+    lines.push(`      \u26A0 low confidence: ${warning.detail}`);
   }
-  return found;
+  return lines;
 }
-
-// src/module-registry.ts
-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(),
-  sources: z4.array(z4.string()),
-  mappings: z4.string()
-});
-var sectionedMapSchema = z4.looseObject({
-  version: z4.number(),
-  sections: z4.array(
-    z4.looseObject({
-      offset: z4.looseObject({ line: z4.number(), column: z4.number() }),
-      map: z4.looseObject({ sources: z4.array(z4.string()), mappings: z4.string() })
-    })
-  )
-});
-function normalizeSourceMap(raw) {
-  const flat = flatMapSchema.safeParse(raw);
-  if (flat.success) {
-    return { sources: flat.data.sources, lines: decodeMappings(flat.data.mappings) };
+function memorySourceLines(route, verdict) {
+  const lines = [];
+  if (route.trend.source === "external" && verdict !== "stable") {
+    const externalCurve = route.memorySamples.map((sample) => formatMb(sample.external)).join(" \u2192 ");
+    lines.push(
+      `      verdict comes from EXTERNAL memory (buffers, streams, fetch bodies), not the JS heap: external ${externalCurve}`
+    );
   }
-  const sectioned = sectionedMapSchema.safeParse(raw);
-  if (!sectioned.success) {
-    return null;
+  if (verdict === "stable" && hasSustainedRssGrowth(route.memorySamples)) {
+    const rssCurve = route.memorySamples.map((sample) => formatMb(sample.rss)).join(" \u2192 ");
+    lines.push(
+      `      note: heap is flat but RSS grows ${formatGrowth(route.rssPer1000Requests)} \u2014 not a JS-heap leak (allocator, external buffers or fragmentation): RSS ${rssCurve}`
+    );
   }
-  const sources = [];
-  const lines = [];
-  for (const section of sectioned.data.sections) {
-    const sourceBase = sources.length;
-    sources.push(...section.map.sources);
-    for (const [lineIndex, mapping] of decodeMappings(section.map.mappings).entries()) {
-      const targetLine = section.offset.line + lineIndex;
-      const columnShift = lineIndex === 0 ? section.offset.column : 0;
-      const target = lines[targetLine] ??= { entries: [] };
-      for (const entry of mapping.entries) {
-        target.entries.push({
-          column: entry.column + columnShift,
-          sourceIndex: entry.sourceIndex + sourceBase
-        });
-      }
-    }
+  return lines;
+}
+function diffFindingLines(route) {
+  if (route.diff === null) {
+    return [];
   }
-  for (const line of lines) {
-    line?.entries.sort((a, b) => a.column - b.column);
+  const findings = [...route.diff.grownNodes, ...route.diff.newNodes];
+  return findings.slice(0, 3).map((finding, index) => {
+    const size = formatMb(finding.retainedBytes);
+    const attribution = route.attribution?.findings[index];
+    const owner = attribution === void 0 ? null : ownerLabel(attribution);
+    const detail = owner ?? (finding.retainerChain === "" ? "" : finding.retainerChain);
+    return `      \u21B3 ${finding.kind} [${finding.nodeType}] ${finding.name} ${size}${detail === "" ? "" : ` \u2014 ${detail}`}`;
+  });
+}
+function findingLines(route) {
+  const lines = [];
+  const culprit = route.attribution === null ? null : ownerLabel(route.attribution.route);
+  if (culprit !== null) {
+    lines.push(`      culprit: ${culprit}`);
   }
-  for (let i = 0; i < lines.length; i += 1) {
-    lines[i] ??= { entries: [] };
+  lines.push(...diffFindingLines(route));
+  for (const signature of route.signatures) {
+    const flag = signature.historical ? " (historical)" : "";
+    lines.push(`      \u26A0 known cause${flag}: ${signature.title} \u2014 ${signature.issue}`);
   }
-  return { sources, lines };
+  return lines;
 }
-var ID_IN_GAP = /[,[](\d{1,9}),/g;
-function lastModuleIdIn(gap) {
-  ID_IN_GAP.lastIndex = 0;
-  let last = null;
-  let match = ID_IN_GAP.exec(gap);
-  while (match !== null) {
-    last = Number(match[1]);
-    match = ID_IN_GAP.exec(gap);
+function peakPressureLines(route, parameters) {
+  const retained = route.memorySamples.at(-1)?.heapUsed;
+  if (retained === void 0) {
+    return [];
   }
-  return last;
+  const pressure = assessPeakPressure({
+    peaks: route.peaks,
+    retainedHeapBytes: retained,
+    maxOldSpaceMb: parameters.maxOldSpaceMb
+  });
+  return pressure === null ? [] : [`      \u25B2 peak pressure: ${describePeakPressure(pressure)}`];
 }
-function collectFirstArrayIds(codeLines, map, result) {
-  for (const [lineIndex, lineText] of codeLines.entries()) {
-    const first = /module\.exports ?= ?\[(\d+),/.exec(lineText);
-    if (first?.[1] === void 0) {
-      continue;
-    }
-    const idEnd = first.index + first[0].length;
-    const nextId = /[,[]\d{1,9},/.exec(lineText.slice(idEnd));
-    const spanEnd = nextId === null ? lineText.length : idEnd + nextId.index;
-    const entry = map.lines[lineIndex]?.entries.find(
-      (candidate) => candidate.column >= idEnd && candidate.column < spanEnd
-    );
-    const source = entry === void 0 ? void 0 : map.sources[entry.sourceIndex];
-    if (source !== void 0) {
-      result.set(Number(first[1]), source);
-    }
-  }
+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 collectTransitionIds(codeLines, map, result) {
-  for (const [lineIndex, mapping] of map.lines.entries()) {
-    const lineText = codeLines[lineIndex];
-    if (lineText === void 0) {
-      continue;
-    }
-    let previousColumn = 0;
-    let previousSource = null;
-    for (const entry of mapping.entries) {
-      if (entry.sourceIndex !== previousSource) {
-        const id = lastModuleIdIn(lineText.slice(previousColumn, entry.column));
-        const source = map.sources[entry.sourceIndex];
-        if (id !== null && source !== void 0 && !result.has(id)) {
-          result.set(id, source);
-        }
-        previousSource = entry.sourceIndex;
-      }
-      previousColumn = entry.column;
-    }
+function routeLines(route, parameters) {
+  if (route.status === "skipped") {
+    return [`  \u2013 ${route.route}  skipped: ${route.reason}`];
   }
-}
-function extractChunkModules(code, rawMap) {
-  const result = /* @__PURE__ */ new Map();
-  if (!code.includes("module.exports=[") && !code.includes("module.exports = [")) {
-    return result;
+  if (route.status === "failed") {
+    return [`  \u2716 ${route.route}  failed: ${route.reason}`];
   }
-  const map = normalizeSourceMap(rawMap);
-  if (map === null) {
-    return result;
+  if (route.status === "not-exercised") {
+    return [`  \u2013 ${route.route}  not exercised: ${route.reason}`];
   }
-  const codeLines = code.split("\n");
-  collectFirstArrayIds(codeLines, map, result);
-  collectTransitionIds(codeLines, map, result);
-  return result;
+  if (route.status === "died-of-heap") {
+    const curve2 = route.memorySamples.map((sample) => formatMb(sample.heapUsed)).join(" \u2192 ");
+    return [
+      `  ${VERDICT_ICON.leak} ${route.route}  leak  (ran out of heap after ${route.cyclesCompleted} of ${route.cyclesRequested} cycles)` + (curve2 === "" ? "" : `  heap ${curve2}`),
+      `      ${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)`;
+  return [
+    `  ${VERDICT_ICON[verdict]} ${route.route}  ${verdict}  (${formatGrowth(
+      route.growthPer1000Requests
+    )})  heap ${curve}${resolved}`,
+    ...revalidationLines(route),
+    ...abandonLines(route),
+    ...confidenceLines(route),
+    ...memorySourceLines(route, verdict),
+    ...peakPressureLines(route, parameters),
+    ...unreclaimedLines(route, verdict),
+    ...findingLines(route)
+  ];
 }
-async function jsFilesUnder(dir) {
-  const out = [];
-  let entries;
-  try {
-    entries = await readdir2(dir, { withFileTypes: true, recursive: true });
-  } catch {
-    return out;
+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 [];
   }
-  for (const entry of entries) {
-    if (entry.isFile() && entry.name.endsWith(".js")) {
-      out.push(path4.join(entry.parentPath, entry.name));
-    }
+  const editing = hasPlaceholders(skeleton) ? ` Replace each ${"REPLACE-ME"} with a value that exists in your app.` : ` The shapes come from paths your build already prerendered; \`{n}\` makes every request use a different one, because reusing a prerendered value serves the warm cache and reads as flat whatever the route retains. Use \`{n%200}\` instead to revisit a fixed set of 200 keys, and drop the marker only if the app 404s on params it never 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" || route.status === "died-of-heap"
+  ).length;
+  if (measured === total) {
+    return `measured all ${total} discovered route(s)`;
   }
-  return out;
+  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`;
 }
-async function extractModuleRegistry(nextServerDir) {
-  const registry = /* @__PURE__ */ new Map();
-  for (const file of await jsFilesUnder(nextServerDir)) {
-    let code;
-    let map;
-    try {
-      code = await readFile4(file, "utf8");
-      map = JSON.parse(await readFile4(`${file}.map`, "utf8"));
-    } catch {
-      continue;
-    }
-    for (const [id, source] of extractChunkModules(code, map)) {
-      if (!registry.has(id)) {
-        registry.set(id, source);
-      }
-    }
+function formatReport(report) {
+  const lines = [`next-leak \u2014 ${report.appDir}`, ""];
+  for (const route of report.routes) {
+    lines.push(...routeLines(route, report.parameters));
   }
-  return registry;
+  lines.push(...skippedGuidanceLines(report));
+  const { minGrowthPerCycle, loadRequests, cycles, maxOldSpaceMb } = report.parameters;
+  const resolvedCycles = [
+    ...new Set(
+      report.routes.flatMap(
+        (route) => route.status === "measured" && route.resolvedWithCycles !== void 0 ? [route.resolvedWithCycles] : []
+      )
+    )
+  ].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}`,
+    ...report.bundle.issues.map((issue) => `issue draft (${issue.route}): ${issue.file}`)
+  );
+  const inconclusive = report.routes.filter(
+    (route) => route.status === "measured" && effectiveVerdict(route) === "inconclusive"
+  );
+  if (inconclusive.length > 0) {
+    const routeList = inconclusive.map((route) => route.route).join(",");
+    const moreCycles = resolveCycles(report.parameters.cycles);
+    lines.push(
+      "",
+      "hint: inconclusive means sustained sub-threshold growth \u2014 measure longer to resolve it:",
+      `  next-leak ${report.appDir} --routes ${routeList} --cycles ${moreCycles}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/environment.ts
+import { createRequire } from "module";
+import os from "os";
+var require2 = createRequire(import.meta.url);
+var { version: nextLeakVersion } = require2("../package.json");
+function captureEnvironment(nextVersion) {
+  return {
+    nodeVersion: process.version,
+    platform: os.platform(),
+    arch: os.arch(),
+    cpuModel: os.cpus()[0]?.model ?? null,
+    totalMemoryBytes: os.totalmem(),
+    nextVersion,
+    nextLeakVersion
+  };
 }
 
 // src/load.ts
@@ -93589,6 +93637,29 @@ async function describeRedirect(url) {
     return null;
   }
 }
+async function describeUnprerenderedParams(url) {
+  const bounded = boundedMarkerOf(url);
+  const marker = bounded === null ? UNIQUE_MARKER : bounded.marker;
+  if (!url.includes(marker)) {
+    return null;
+  }
+  const probe = async (value) => {
+    try {
+      const response = await fetch(url.split(marker).join(value), { redirect: "manual" });
+      return response.status;
+    } catch {
+      return null;
+    }
+  };
+  const [novel, familiar] = await Promise.all([probe("999999"), probe("0")]);
+  if (novel === null || familiar === null) {
+    return null;
+  }
+  if (novel === 404 && familiar >= 200 && familiar < 300) {
+    return `the sample value varies per request (\`${marker}\`) and this app answers 404 for params it never prerendered \u2014 the route itself is fine, the value is the problem. Bound it to the params your build did prerender (\`{n%N}\` with N of them), or drop the marker and accept that every request serves the same cached entry`;
+  }
+  return null;
+}
 function boundedRequestSequence(fullUrl, bounded) {
   const parsed = new URL(fullUrl);
   const template = fullUrl.slice(parsed.origin.length);
@@ -93640,9 +93711,9 @@ async function runLoadPhase(options) {
   const ratio = options.amount === 0 ? 0 : failures / options.amount;
   if (ratio > (options.maxErrorRatio ?? 0.01)) {
     const unanswered = failures - result.non2xx - result.errors - result.timeouts;
-    const redirect = result.non2xx > 0 ? await describeRedirect(options.url) : null;
+    const explained = result.non2xx > 0 ? await describeUnprerenderedParams(options.url) ?? 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 ? diagnoseFailure(result, options.connections) : ` \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` : "") + ")" + (explained === null ? diagnoseFailure(result, options.connections) : ` \u2014 ${explained}`),
       result
     );
   }
@@ -93854,6 +93925,14 @@ Host: ${target.host}\r
 
 // src/ritual.ts
 var MIN_POLLS_TO_JUDGE = 2;
+var HeapExhaustedError = class extends Error {
+  evidence;
+  constructor(message, evidence) {
+    super(message);
+    this.name = "HeapExhaustedError";
+    this.evidence = evidence;
+  }
+};
 var SETTLE_POLL_MS = 2e3;
 var SETTLE_TOLERANCE = 0.01;
 var PEAK_POLL_MS = 250;
@@ -94006,6 +94085,13 @@ async function runRitual(options, deps = defaultDeps) {
       timings.push({ phase, seconds: Math.round((Date.now() - started) / 100) / 10 });
     }
   };
+  const memorySamples = [];
+  const unreclaimedSamples = [];
+  let unreclaimedLost = false;
+  const peaks = [];
+  let afterSnapshot = "";
+  let baselineSnapshot = "";
+  let cyclesCompleted = 0;
   try {
     const routeUrl = `http://127.0.0.1:${app.appPort}${options.route}`;
     await timed(
@@ -94021,11 +94107,8 @@ async function runRitual(options, deps = defaultDeps) {
       "baseline snapshot",
       () => requestSnapshot(app.controlPort, "baseline")
     );
-    const memorySamples = [baseline.sample];
-    const unreclaimedSamples = [];
-    let unreclaimedLost = false;
-    const peaks = [];
-    let afterSnapshot = "";
+    memorySamples.push(baseline.sample);
+    baselineSnapshot = baseline.file;
     for (let cycle = 1; cycle <= cycles; cycle += 1) {
       await timed(`cycle ${cycle} load`, async () => {
         const poller = pollPeak(app.controlPort, `cycle ${cycle}`, deps);
@@ -94059,6 +94142,7 @@ async function runRitual(options, deps = defaultDeps) {
       } else {
         memorySamples.push(await requestGc(app.controlPort));
       }
+      cyclesCompleted = cycle;
     }
     const samples = memorySamples.map((sample) => sample.heapUsed);
     const externalSamples = memorySamples.map((sample) => sample.external);
@@ -94079,7 +94163,7 @@ async function runRitual(options, deps = defaultDeps) {
         unreclaimedSamples.map((sample) => sample.external),
         { minGrowthPerCycle }
       ),
-      baselineSnapshot: baseline.file,
+      baselineSnapshot,
       afterSnapshot,
       trend: classifyMemoryTrend(samples, externalSamples, { minGrowthPerCycle }),
       requestsPerCycle: loadRequests,
@@ -94088,7 +94172,18 @@ async function runRitual(options, deps = defaultDeps) {
   } catch (cause) {
     const death = app.explainExit();
     if (death !== null) {
-      throw new Error(death);
+      if (death.heapExhausted) {
+        throw new HeapExhaustedError(death.reason, {
+          memorySamples,
+          peaks,
+          unreclaimedSamples: unreclaimedLost ? [] : unreclaimedSamples,
+          cyclesCompleted,
+          cyclesRequested: cycles,
+          requestsPerCycle: loadRequests,
+          baselineSnapshot
+        });
+      }
+      throw new Error(death.reason);
     }
     throw cause;
   } finally {
@@ -94438,7 +94533,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-TN7PYVU4.js");
+  const { renderHtmlReport } = await import("./html-report-5XMR3EXE.js");
   const { renderIssueMarkdown } = await import("./issue-report-HKA26WNV.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
@@ -94487,6 +94582,21 @@ async function routeReportFor(context, route, index, total) {
       return first;
     }
   } catch (cause) {
+    if (cause instanceof HeapExhaustedError) {
+      progress(`leak ${label}: ${cause.message}`);
+      const { evidence } = cause;
+      return {
+        route: route.path,
+        status: "died-of-heap",
+        requestPath,
+        reason: cause.message,
+        memorySamples: evidence.memorySamples,
+        peaks: evidence.peaks,
+        cyclesCompleted: evidence.cyclesCompleted,
+        cyclesRequested: evidence.cyclesRequested,
+        requestsPerCycle: evidence.requestsPerCycle
+      };
+    }
     const failure = cause instanceof Error ? cause.message : String(cause);
     progress(`failed ${label}: ${failure}`);
     return { route: route.path, status: "failed", reason: failure };
@@ -94583,6 +94693,20 @@ async function runMeasurement(options, deps = defaultDeps2) {
 }
 
 export {
+  classifySource,
+  attributeFinding,
+  attributeDiff,
+  summarizeBaseline,
+  retainerChain,
+  diffAgainstBaseline,
+  SnapshotError,
+  assertReadableSnapshot,
+  diffSnapshotFiles,
+  decodeVlqLine,
+  decodeMappings,
+  sourceIndexAt,
+  extractChunkModules,
+  extractModuleRegistry,
   appPathsManifestSchema,
   routesManifestSchema,
   discoverPagesRoutes,
@@ -94604,21 +94728,7 @@ export {
   renderConfigSkeleton,
   hasPlaceholders,
   formatReport,
-  classifySource,
-  attributeFinding,
-  attributeDiff,
   captureEnvironment,
-  summarizeBaseline,
-  retainerChain,
-  diffAgainstBaseline,
-  SnapshotError,
-  assertReadableSnapshot,
-  diffSnapshotFiles,
-  decodeVlqLine,
-  decodeMappings,
-  sourceIndexAt,
-  extractChunkModules,
-  extractModuleRegistry,
   LoadError,
   runLoadPhase,
   runRitual,