next-leak 0.6.0 → 0.8.0

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

@@ -7,7 +7,7 @@ import {
   minGrowthFor,
   resolveCycles,
   warrantsIssueDraft
-} from "./chunk-22PBLCGO.js";
+} from "./chunk-EJ26OBZI.js";
 import {
   assessPeakPressure,
   describePeakPressure
@@ -91969,30 +91969,543 @@ var require_autocannon = __commonJS({
   }
 });
 
-// src/manifests.ts
+// src/attribution.ts
+var UNATTRIBUTED = { owner: "unattributed", source: null, packageName: null };
+function classifySource(rawSource) {
+  let source = rawSource.replace(/^turbopack:\/+(?=\[)/, "");
+  try {
+    source = decodeURIComponent(source);
+  } catch {
+  }
+  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 };
+  }
+  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 };
+}
+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})` };
+    }
+  }
+  return null;
+}
+function attributeFinding(finding, registry) {
+  let best = UNATTRIBUTED;
+  for (const id of finding.moduleIds) {
+    const source = registry.get(id);
+    if (source === void 0) {
+      continue;
+    }
+    const candidate = classifySource(source);
+    if (OWNER_PRIORITY[candidate.owner] < OWNER_PRIORITY[best.owner]) {
+      best = candidate;
+    }
+  }
+  if (best.owner === "unattributed") {
+    return classifyByChain(finding.retainerChain ?? "") ?? UNATTRIBUTED;
+  }
+  return best;
+}
+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 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 route = winner === null || attributedBytes === 0 ? { ...UNATTRIBUTED, dominance: 0 } : { ...winner.attribution, dominance: winner.bytes / attributedBytes };
+  return { findings, route };
+}
+
+// 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);
+}
+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 };
+}
+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);
+      }
+    }
+  }
+  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 });
+    }
+  }
+  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)
+  };
+}
+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}`);
+  }
+  if (size > constants.MAX_STRING_LENGTH) {
+    throw new SnapshotError(
+      `heap snapshot is ${(size / (1024 * 1024)).toFixed(0)} MB, past the ${(constants.MAX_STRING_LENGTH / (1024 * 1024)).toFixed(0)} MB a single string can hold, so it cannot be parsed: ${file}. The measurement itself is unaffected \u2014 only the snapshot diff, which names the retaining object, is unavailable. Lower --requests or --cycles to keep the heap smaller if you need it`
+    );
+  }
+  const handle = await open(file, "r");
+  try {
+    const head = Buffer.alloc(Math.min(PROBE_BYTES, size));
+    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();
+  }
+}
+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}`);
+    }
+    value += (digit & 31) << shift;
+    if ((digit & 32) !== 0) {
+      shift += 5;
+    } else {
+      values.push((value & 1) === 1 ? -(value >>> 1) : value >>> 1);
+      value = 0;
+      shift = 0;
+    }
+  }
+  return values;
+}
+function decodeVlqLine(line) {
+  const segments = [];
+  for (const raw of line.split(",")) {
+    if (raw !== "") {
+      segments.push(decodeVlqSegment(raw));
+    }
+  }
+  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 });
+  }
+  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;
+    }
+    found = entry.sourceIndex;
+  }
+  return found;
+}
+
+// src/module-registry.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
 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({
+var flatMapSchema = z.looseObject({
   version: z.number(),
-  basePath: z.string(),
-  staticRoutes: z.array(routeEntrySchema),
-  dynamicRoutes: z.array(routeEntrySchema)
+  sources: z.array(z.string()),
+  mappings: z.string()
 });
-var prerenderManifestSchema = z.looseObject({
-  routes: z.record(
-    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 sectioned = sectionedMapSchema.safeParse(raw);
+  if (!sectioned.success) {
+    return null;
+  }
+  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
+        });
+      }
+    }
+  }
+  for (const line of lines) {
+    line?.entries.sort((a, b) => a.column - b.column);
+  }
+  for (let i = 0; i < lines.length; i += 1) {
+    lines[i] ??= { entries: [] };
+  }
+  return { sources, 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);
+  }
+  return last;
+}
+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 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 extractChunkModules(code, rawMap) {
+  const result = /* @__PURE__ */ new Map();
+  if (!code.includes("module.exports=[") && !code.includes("module.exports = [")) {
+    return result;
+  }
+  const map = normalizeSourceMap(rawMap);
+  if (map === null) {
+    return result;
+  }
+  const codeLines = code.split("\n");
+  collectFirstArrayIds(codeLines, map, result);
+  collectTransitionIds(codeLines, map, result);
+  return result;
+}
+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;
+    }
+    for (const [id, source] of extractChunkModules(code, map)) {
+      if (!registry.has(id)) {
+        registry.set(id, source);
+      }
+    }
+  }
+  return registry;
+}
+
+// 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: z.union([z.number(), z.literal(false)]).optional(),
-      srcRoute: z.string().nullable().optional()
+      initialRevalidateSeconds: z2.union([z2.number(), z2.literal(false)]).optional(),
+      srcRoute: z2.string().nullable().optional()
     })
   ).optional(),
-  preview: z.looseObject({ previewModeId: z.string() }).optional()
+  preview: z2.looseObject({ previewModeId: z2.string() }).optional()
 });
 var INTERNAL_PATHS = /* @__PURE__ */ new Set(["/_global-error", "/_not-found"]);
 var INTERCEPTING_SEGMENT = /^(\(\.{1,3}\))+/;
@@ -92055,8 +92568,8 @@ function discoverRoutes(appPaths) {
 }
 
 // src/target.ts
-import { access, readFile } from "fs/promises";
-import path from "path";
+import { access, readFile as readFile2 } from "fs/promises";
+import path2 from "path";
 var TargetError = class extends Error {
   code;
   constructor(code, message) {
@@ -92076,7 +92589,7 @@ async function exists(file) {
 async function readManifest(file, parse2) {
   let raw;
   try {
-    raw = JSON.parse(await readFile(file, "utf8"));
+    raw = JSON.parse(await readFile2(file, "utf8"));
   } catch (cause) {
     throw new TargetError(
       "BAD_MANIFEST",
@@ -92093,14 +92606,14 @@ async function readManifest(file, parse2) {
   }
 }
 async function validateTarget(appDir) {
-  const nextDir = path.resolve(appDir, ".next");
+  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 = path.join(nextDir, "standalone", "server.js");
+  const standaloneServer = path2.join(nextDir, "standalone", "server.js");
   if (!await exists(standaloneServer)) {
     throw new TargetError(
       "NO_STANDALONE",
@@ -92116,8 +92629,8 @@ 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 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) {
@@ -92126,12 +92639,12 @@ This only changes how the build is packaged \u2014 not how your app behaves.`
       `No routes found in ${nextDir}/server: neither app-paths-manifest.json nor pages-manifest.json is present. Rebuild the app with "next build".`
     );
   }
-  const routesFile = path.join(nextDir, "routes-manifest.json");
+  const routesFile = path2.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 prerenderFile = path2.join(nextDir, "prerender-manifest.json");
   const prerender = await exists(prerenderFile) ? await readManifest(prerenderFile, (raw) => prerenderManifestSchema.parse(raw)) : void 0;
   return {
-    appDir: path.resolve(appDir),
+    appDir: path2.resolve(appDir),
     standaloneServer,
     appPaths,
     pages,
@@ -92142,11 +92655,11 @@ This only changes how the build is packaged \u2014 not how your app behaves.`
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import { readdir, readFile as readFile2 } from "fs/promises";
-import path2 from "path";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
+import path3 from "path";
 import { pathToFileURL } from "url";
-import { z as z2 } from "zod";
-var controlFileSchema = z2.object({ port: z2.number(), pid: z2.number() });
+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) {
@@ -92215,7 +92728,7 @@ async function launchInstrumented(options) {
       options.serverPath
     ],
     {
-      cwd: path2.dirname(options.serverPath),
+      cwd: path3.dirname(options.serverPath),
       env: {
         ...process.env,
         ...options.env,
@@ -92255,7 +92768,7 @@ ${stderrTailBuffer}`;
       async () => {
         let entries;
         try {
-          entries = (await readdir(options.workDir)).filter(
+          entries = (await readdir2(options.workDir)).filter(
             (entry) => entry.startsWith("control-") && entry.endsWith(".json")
           );
         } catch {
@@ -92264,7 +92777,7 @@ ${stderrTailBuffer}`;
         for (const entry of entries) {
           try {
             const parsed = controlFileSchema.parse(
-              JSON.parse(await readFile2(path2.join(options.workDir, entry), "utf8"))
+              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) {
@@ -92366,6 +92879,11 @@ var FLAGS = [
     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",
@@ -92480,6 +92998,9 @@ function applyFlag(spec, value, options) {
     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;
@@ -92541,6 +93062,7 @@ function parseCliArgs(argv) {
     quick: false,
     noResolve: false,
     diffAll: false,
+    attributeBuild: false,
     writeConfig: false,
     output: null
   };
@@ -92570,8 +93092,15 @@ function parseCliArgs(argv) {
         message: `option "${misplaced}" shapes HTTP load and does not apply to "next-leak build" \u2014 see --help`
       };
     }
-    return { kind: "build", options: { appDir: options.appDir, output: options.output } };
-  }
+    return {
+      kind: "build",
+      options: {
+        appDir: options.appDir,
+        output: options.output,
+        attributeBuild: options.attributeBuild
+      }
+    };
+  }
   return { kind: "run", options };
 }
 
@@ -92593,25 +93122,25 @@ function checkRuntime(facts = currentFacts()) {
 }
 
 // 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(
+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 = z3.object({
-  params: z3.record(z3.string(), sampleValueSchema).optional(),
-  routes: z3.record(z3.string(), z3.record(z3.string(), sampleValueSchema)).optional(),
+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: z3.record(z3.string(), z3.string()).optional(),
+  headers: z4.record(z4.string(), z4.string()).optional(),
   /** Query string appended per route template, e.g. `"weightKb=2048"`. */
-  query: z3.record(z3.string(), z3.string()).optional(),
+  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
@@ -92624,8 +93153,28 @@ var routeConfigSchema = z3.object({
    * window, so a request-relative clock cuts before the stream starts and
    * tests the wrong path entirely.
    */
-  abandonAfterMs: z3.number().int().positive().optional()
-}).strict();
+  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);
@@ -92634,10 +93183,10 @@ var RouteConfigError = class extends Error {
 };
 var ROUTE_CONFIG_FILE = "next-leak.config.json";
 async function loadRouteConfig(appDir) {
-  const file = path3.join(appDir, ROUTE_CONFIG_FILE);
+  const file = path4.join(appDir, ROUTE_CONFIG_FILE);
   let raw;
   try {
-    raw = await readFile3(file, "utf8");
+    raw = await readFile4(file, "utf8");
   } catch {
     return {};
   }
@@ -92737,805 +93286,301 @@ function renderConfigSkeleton(routeTemplates, manifest = void 0) {
   for (const template of routeTemplates) {
     const segments = dynamicSegmentsOf(template);
     if (segments.length === 0) {
-      continue;
-    }
-    const sampled = sampleValuesFromManifest(manifest, template);
-    const values = {};
-    for (const segment of segments) {
-      values[segment.name] = sampled?.[segment.name] ?? PLACEHOLDER;
-    }
-    routes[template] = values;
-  }
-  return Object.keys(routes).length === 0 ? null : JSON.stringify({ routes }, null, 2);
-}
-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));
-  }
-  return gaps;
-}
-function assessUnreclaimedRetention(input) {
-  if (input.verdict === "leak" && input.verdictIsWellSupported || input.unreclaimedSamples.length === 0) {
-    return null;
-  }
-  let worst = null;
-  for (const memoryClass of CLASSES) {
-    const gaps = gapsFor(input, memoryClass);
-    if (gaps.length === 0) {
-      continue;
-    }
-    const largestGapBytes = largestGap(gaps);
-    if (largestGapBytes < MIN_GAP_BYTES) {
-      continue;
-    }
-    const retainedBytes = largestGap(
-      input.memorySamples.slice(1).map((sample) => read(sample, memoryClass))
-    );
-    const ratio = largestGapBytes / Math.max(retainedBytes, MIN_RETAINED_BYTES);
-    if (ratio < MIN_GAP_RATIO) {
-      continue;
-    }
-    if (worst === null || ratio >= worst.ratio) {
-      worst = { class: memoryClass, largestGapBytes, retainedBytes, ratio };
-    }
-  }
-  return worst;
-}
-var mb = (bytes) => `${(bytes / MB).toFixed(2)} MB`;
-var CLASS_LABEL = {
-  heap: "heap",
-  external: "external memory",
-  arrayBuffers: "arrayBuffers"
-};
-function describeUnreclaimedRetention(retention) {
-  return `held ${mb(retention.largestGapBytes)} of ${CLASS_LABEL[retention.class]} between collections that a GC took back (${retention.ratio.toFixed(1)}x what it retains) \u2014 a forced GC reclaims this, a long-running process may not run one often enough to; read seconds after load, so it also includes memory not yet collected`;
-}
-
-// src/report.ts
-var 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 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 revalidationLines(route) {
-  return route.revalidatedEverySeconds === void 0 ? [] : [
-    `      driven through ISR revalidation (revalidates every ${route.revalidatedEverySeconds}s; without it the load would serve the cache)`
-  ];
-}
-function confidenceLines(route) {
-  const lines = [];
-  if (route.confidence.supersededVerdict !== void 0) {
-    lines.push(
-      `      measured ${route.trend.verdict}, withdrawn: the run did not observe what that verdict needs`
-    );
-  }
-  for (const warning of route.confidence.warnings) {
-    lines.push(`      \u26A0 low confidence: ${warning.detail}`);
-  }
-  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}`
-    );
-  }
-  return lines;
-}
-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}`}`;
-  });
-}
-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;
-}
-function peakPressureLines(route, parameters) {
-  const retained = route.memorySamples.at(-1)?.heapUsed;
-  if (retained === void 0) {
-    return [];
-  }
-  const pressure = assessPeakPressure({
-    peaks: route.peaks,
-    retainedHeapBytes: retained,
-    maxOldSpaceMb: parameters.maxOldSpaceMb
-  });
-  return pressure === null ? [] : [`      \u25B2 peak pressure: ${describePeakPressure(pressure)}`];
-}
-function unreclaimedLines(route, verdict) {
-  const retention = assessUnreclaimedRetention({
-    unreclaimedSamples: route.unreclaimedSamples,
-    memorySamples: route.memorySamples,
-    verdict,
-    verdictIsWellSupported: warrantsIssueDraft(route)
-  });
-  return retention === null ? [] : [`      \u25B2 unreclaimed: ${describeUnreclaimedRetention(retention)}`];
-}
-function routeLines(route, parameters) {
-  if (route.status === "skipped") {
-    return [`  \u2013 ${route.route}  skipped: ${route.reason}`];
-  }
-  if (route.status === "failed") {
-    return [`  \u2716 ${route.route}  failed: ${route.reason}`];
-  }
-  if (route.status === "not-exercised") {
-    return [`  \u2013 ${route.route}  not exercised: ${route.reason}`];
-  }
-  const verdict = effectiveVerdict(route);
-  const curve = route.samples.map(formatMb).join(" \u2192 ");
-  const resolved = route.resolvedWithCycles === void 0 ? "" : `  (resolved at ${route.resolvedWithCycles} cycles)`;
-  return [
-    `  ${VERDICT_ICON[verdict]} ${route.route}  ${verdict}  (${formatGrowth(
-      route.growthPer1000Requests
-    )})  heap ${curve}${resolved}`,
-    ...revalidationLines(route),
-    ...confidenceLines(route),
-    ...memorySourceLines(route, verdict),
-    ...peakPressureLines(route, parameters),
-    ...unreclaimedLines(route, verdict),
-    ...findingLines(route)
-  ];
-}
-function skippedGuidanceLines(report) {
-  const needConfig = report.routes.filter((route) => route.status === "skipped" && route.reason.includes("sample params")).map((route) => route.route);
-  const skeleton = renderConfigSkeleton(needConfig, report.prerender);
-  if (skeleton === null) {
-    return [];
-  }
-  const editing = hasPlaceholders(skeleton) ? ` Replace each ${"REPLACE-ME"} with a value that exists in your app.` : ` The values come from paths your build already prerendered.`;
-  return [
-    "",
-    `${needConfig.length} route(s) need sample params. Write this to next-leak.config.json in the app directory:${editing}`,
-    ...skeleton.split("\n").map((line) => `  ${line}`)
-  ];
-}
-function coverageLine(report) {
-  const total = report.routes.length;
-  const measured = report.routes.filter((route) => route.status === "measured").length;
-  if (measured === total) {
-    return `measured all ${total} discovered route(s)`;
-  }
-  const breakdown = ["skipped", "not-exercised", "failed"].map((status) => ({
-    status,
-    count: report.routes.filter((route) => route.status === status).length
-  })).filter((entry) => entry.count > 0).map((entry) => `${entry.count} ${entry.status.replace("-", " ")}`).join(", ");
-  return `measured ${measured} of ${total} discovered route(s) \u2014 ${breakdown}; the rest is not a verdict about your app`;
-}
-function formatReport(report) {
-  const lines = [`next-leak \u2014 ${report.appDir}`, ""];
-  for (const route of report.routes) {
-    lines.push(...routeLines(route, report.parameters));
-  }
-  lines.push(...skippedGuidanceLines(report));
-  const { minGrowthPerCycle, loadRequests, cycles, maxOldSpaceMb } = report.parameters;
-  const resolvedCycles = [
-    ...new Set(
-      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/attribution.ts
-var UNATTRIBUTED = { owner: "unattributed", source: null, packageName: null };
-function classifySource(rawSource) {
-  let source = rawSource.replace(/^turbopack:\/+(?=\[)/, "");
-  try {
-    source = decodeURIComponent(source);
-  } catch {
-  }
-  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 };
-  }
-  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 };
-}
-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})` };
-    }
-  }
-  return null;
-}
-function attributeFinding(finding, registry) {
-  let best = UNATTRIBUTED;
-  for (const id of finding.moduleIds) {
-    const source = registry.get(id);
-    if (source === void 0) {
-      continue;
-    }
-    const candidate = classifySource(source);
-    if (OWNER_PRIORITY[candidate.owner] < OWNER_PRIORITY[best.owner]) {
-      best = candidate;
-    }
-  }
-  if (best.owner === "unattributed") {
-    return classifyByChain(finding.retainerChain ?? "") ?? UNATTRIBUTED;
-  }
-  return best;
-}
-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 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 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
-  };
-}
-
-// 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);
-}
-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 };
-}
-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);
-      }
-    }
-  }
-  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 });
+      continue;
+    }
+    const sampled = sampleValuesFromManifest(manifest, template);
+    const values = {};
+    for (const segment of segments) {
+      values[segment.name] = sampled?.[segment.name] ?? PLACEHOLDER;
     }
+    routes[template] = values;
   }
-  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 Object.keys(routes).length === 0 ? null : JSON.stringify({ routes }, null, 2);
 }
-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}`);
+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));
   }
-  if (size === 0) {
-    throw new SnapshotError(`heap snapshot is empty: ${file}`);
+  return gaps;
+}
+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) {
+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 [
+    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 confidenceLines(route) {
   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 });
+  if (route.confidence.supersededVerdict !== void 0) {
+    lines.push(
+      `      measured ${route.trend.verdict}, withdrawn: the run did not observe what that verdict needs`
+    );
+  }
+  for (const warning of route.confidence.warnings) {
+    lines.push(`      \u26A0 low confidence: ${warning.detail}`);
   }
   return lines;
 }
-function sourceIndexAt(lines, line, column) {
-  const mapping = lines[line];
-  if (mapping === void 0) {
-    return void 0;
+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}`
+    );
   }
-  let found;
-  for (const entry of mapping.entries) {
-    if (entry.column > column) {
-      break;
-    }
-    found = entry.sourceIndex;
+  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}`
+    );
   }
-  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) };
-  }
-  const sectioned = sectionedMapSchema.safeParse(raw);
-  if (!sectioned.success) {
-    return null;
+function diffFindingLines(route) {
+  if (route.diff === null) {
+    return [];
   }
-  const sources = [];
+  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 = [];
-  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
-        });
-      }
-    }
-  }
-  for (const line of lines) {
-    line?.entries.sort((a, b) => a.column - b.column);
+  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;
+  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 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)`;
   }
-  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
@@ -93735,6 +93780,7 @@ var FIRST_BYTE_BUDGET_MS = 5e3;
 async function runAbandonPhase(options) {
   const target = new URL(options.url);
   const port = Number(target.port || 80);
+  const fromRequest = options.abandonFrom === "request";
   const headerLines = Object.entries(options.headers ?? {}).map(([name, value]) => `${name}: ${value}\r
 `).join("");
   const request2 = `GET ${target.pathname}${target.search} HTTP/1.1\r
@@ -93779,7 +93825,10 @@ Host: ${target.host}\r
     socket.once("connect", () => {
       result.sent += 1;
       socket.write(request2);
-      timer = setTimeout(giveUp, FIRST_BYTE_BUDGET_MS);
+      timer = setTimeout(
+        giveUp,
+        fromRequest ? options.abandonAfterMs : FIRST_BYTE_BUDGET_MS
+      );
       timer.unref();
     });
     socket.on("data", () => {
@@ -93787,6 +93836,9 @@ Host: ${target.host}\r
         return;
       }
       responseStarted = true;
+      if (fromRequest) {
+        return;
+      }
       clearTimeout(timer);
       timer = setTimeout(giveUp, options.abandonAfterMs);
       timer.unref();
@@ -93949,6 +94001,7 @@ async function runRitual(options, deps = defaultDeps) {
       amount,
       connections,
       abandonAfterMs,
+      ...options.abandonFrom !== void 0 && { abandonFrom: options.abandonFrom },
       ...options.headers !== void 0 && { headers: options.headers }
     });
     loadOutcomes.push({
@@ -94330,6 +94383,9 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     ...headers !== void 0 && { headers },
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
+    },
+    ...routeConfig.abandonFrom !== void 0 && {
+      abandonFrom: routeConfig.abandonFrom
     }
   });
   const confidence = assessConfidence({
@@ -94344,6 +94400,9 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     warmupRequests: options.warmupRequests ?? RITUAL_DEFAULTS.warmupRequests,
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
+    },
+    ...routeConfig.abandonFrom !== void 0 && {
+      abandonFrom: routeConfig.abandonFrom
     }
   });
   const verdict = confidence.supersededVerdict ?? result.trend.verdict;
@@ -94374,6 +94433,12 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     unreclaimedSamples: result.unreclaimedSamples,
     unreclaimedTrend: result.unreclaimedTrend,
     requestsPerCycle: result.requestsPerCycle,
+    ...routeConfig.abandonAfterMs !== void 0 && {
+      abandon: {
+        afterMs: routeConfig.abandonAfterMs,
+        from: routeConfig.abandonFrom ?? "first-byte"
+      }
+    },
     timings: result.timings,
     loadOutcomes: result.loadOutcomes,
     settleOutcomes: result.settleOutcomes,
@@ -94389,7 +94454,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-2UAOOZQO.js");
+  const { renderHtmlReport } = await import("./html-report-TN7PYVU4.js");
   const { renderIssueMarkdown } = await import("./issue-report-HKA26WNV.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
@@ -94534,6 +94599,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,
@@ -94555,21 +94634,7 @@ export {
   renderConfigSkeleton,
   hasPlaceholders,
   formatReport,
-  classifySource,
-  attributeFinding,
-  attributeDiff,
   captureEnvironment,
-  summarizeBaseline,
-  retainerChain,
-  diffAgainstBaseline,
-  SnapshotError,
-  assertReadableSnapshot,
-  diffSnapshotFiles,
-  decodeVlqLine,
-  decodeMappings,
-  sourceIndexAt,
-  extractChunkModules,
-  extractModuleRegistry,
   LoadError,
   runLoadPhase,
   runRitual,