next-leak 0.7.0 → 0.8.0

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

@@ -91969,1602 +91969,1618 @@ 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);
-    }
-    stderrTailBuffer = (stderrTailBuffer + text).slice(-STDERR_WINDOW);
-  });
-  const stderrWindow = () => stderrHead === stderrTailBuffer || stderrTailBuffer === "" ? stderrHead : `${stderrHead}
-[...]
-${stderrTailBuffer}`;
-  let exited = false;
-  activeChildren.add(child);
-  child.once("exit", () => {
-    exited = true;
-    activeChildren.delete(child);
-  });
-  const failed = () => exited ? `server exited before becoming ready. ${explainStartupFailure(stderrWindow())}` : void 0;
-  try {
-    const controlPort = await pollUntil(
-      deadline,
-      `control channel in ${options.workDir}`,
-      // Several processes may announce a channel (clustered servers); accept
-      // the first one that actually answers instead of trusting a filename.
-      async () => {
-        let entries;
-        try {
-          entries = (await readdir(options.workDir)).filter(
-            (entry) => entry.startsWith("control-") && entry.endsWith(".json")
-          );
-        } catch {
-          return void 0;
-        }
-        for (const entry of entries) {
-          try {
-            const parsed = controlFileSchema.parse(
-              JSON.parse(await readFile2(path2.join(options.workDir, entry), "utf8"))
-            );
-            const response = await fetch(`http://127.0.0.1:${parsed.port}/gc`);
-            if (response.ok) {
-              return parsed.port;
-            }
-          } catch {
-            continue;
-          }
-        }
-        return void 0;
-      },
-      failed
-    );
-    await pollUntil(
-      deadline,
-      `app on ${hostname}:${options.appPort}`,
-      async () => {
-        try {
-          await fetch(`http://${hostname}:${options.appPort}/`, { method: "HEAD" });
-          return true;
-        } catch {
-          return void 0;
-        }
-      },
-      failed
-    );
-    return {
-      pid: child.pid ?? -1,
-      appPort: options.appPort,
-      controlPort,
-      explainExit: () => exited ? explainRuntimeFailure(stderrWindow(), options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB) : null,
-      close: async () => {
-        if (exited) {
-          return;
-        }
-        const gone = new Promise((resolve) => child.once("exit", () => resolve()));
-        child.kill("SIGTERM");
-        const killTimer = setTimeout(() => child.kill("SIGKILL"), 3e3);
-        await gone;
-        clearTimeout(killTimer);
-      }
-    };
-  } catch (cause) {
-    child.kill("SIGKILL");
-    throw cause;
-  }
-}
-
-// src/cli-args.ts
-var BUILD_COMMAND = "build";
-var RUN_ONLY_FLAGS = [
-  ["routes", "--routes"],
-  ["cycles", "--cycles"],
-  ["requests", "--requests"],
-  ["connections", "--connections"],
-  ["idleSeconds", "--idle"],
-  ["warmupRequests", "--warmup"],
-  ["maxOldSpaceMb", "--max-old-space"],
-  ["quick", "--quick"],
-  ["noResolve", "--no-resolve"],
-  ["diffAll", "--diff-all"],
-  ["writeConfig", "--write-config"]
-];
-function runOnlyFlagUsed(options) {
-  for (const [field, flag] of RUN_ONLY_FLAGS) {
-    const value = options[field];
-    if (value !== null && value !== false) {
-      return flag;
+    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 null;
+  return found;
 }
-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`);
+// 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) };
   }
-  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 sectioned = sectionedMapSchema.safeParse(raw);
+  if (!sectioned.success) {
+    return null;
   }
-  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`
-    );
+  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
+        });
+      }
+    }
   }
-  if (flag === "--cycles" && parsed < 3) {
-    return flagError("the trend verdict needs at least 3 cycles (--cycles 3 or more)");
+  for (const line of lines) {
+    line?.entries.sort((a, b) => a.column - b.column);
   }
-  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`
-    );
+  for (let i = 0; i < lines.length; i += 1) {
+    lines[i] ??= { entries: [] };
   }
-  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;
+  return { sources, lines };
 }
-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;
+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 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 ?? ""}` };
+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);
+    }
   }
-  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` } };
+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;
+    }
   }
-  if (spec.flag === "--help") {
-    return { done: { kind: "help" } };
+}
+function extractChunkModules(code, rawMap) {
+  const result = /* @__PURE__ */ new Map();
+  if (!code.includes("module.exports=[") && !code.includes("module.exports = [")) {
+    return result;
   }
-  if (spec.flag === "--version") {
-    return { done: { kind: "version" } };
+  const map = normalizeSourceMap(rawMap);
+  if (map === null) {
+    return result;
   }
-  const read2 = readFlagValue(spec, argv, index);
-  if ("error" in read2) {
-    return { done: { kind: "error", message: read2.error } };
+  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;
   }
-  const outcome = applyFlag(spec, read2.value, options);
-  if (outcome.kind === "error") {
-    return { done: { kind: "error", message: outcome.message } };
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".js")) {
+      out.push(path.join(entry.parentPath, entry.name));
+    }
   }
-  return { consumed: spec.value === "none" ? 0 : 1 };
+  return out;
 }
-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` };
-      }
-      options.appDir = argument;
+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 step = parseFlagAt(rest, index, options);
-    if ("done" in step) {
-      return step.done;
+    for (const [id, source] of extractChunkModules(code, map)) {
+      if (!registry.has(id)) {
+        registry.set(id, source);
+      }
     }
-    index += step.consumed;
   }
-  if (options.appDir === "") {
-    return { kind: "help" };
+  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: 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";
   }
-  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 } };
+  if (STATIC_ASSET_PATHS.has(routePath)) {
+    return "static asset served by a generated handler \u2014 no user code to leak";
   }
-  return { kind: "run", options };
+  return void 0;
 }
-
-// src/guards.ts
-function currentFacts() {
-  return {
-    nodeMajor: Number(process.versions.node.split(".")[0]),
-    platform: process.platform
-  };
+function toRequestPath(manifestKey) {
+  let kind;
+  let withoutSuffix;
+  if (manifestKey.endsWith("/page")) {
+    kind = "page";
+    withoutSuffix = manifestKey.slice(0, -"/page".length);
+  } else if (manifestKey.endsWith("/route")) {
+    kind = "route-handler";
+    withoutSuffix = manifestKey.slice(0, -"/route".length);
+  } else {
+    return null;
+  }
+  const segments = withoutSuffix.split("/").filter((segment) => segment !== "").filter((segment) => !(segment.startsWith("(") && segment.endsWith(")"))).filter((segment) => !segment.startsWith("@"));
+  return { path: `/${segments.join("/")}`, kind };
 }
-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.";
+var PAGES_INTERNAL = /* @__PURE__ */ new Set(["/_app", "/_document", "/_error", "/404", "/500"]);
+function discoverPagesRoutes(pages) {
+  const routes = [];
+  for (const key of Object.keys(pages)) {
+    if (PAGES_INTERNAL.has(key)) {
+      continue;
+    }
+    routes.push({
+      path: key,
+      kind: key === "/api" || key.startsWith("/api/") ? "route-handler" : "page",
+      dynamic: key.includes("[")
+    });
   }
-  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 routes.sort((a, b) => a.path.localeCompare(b.path));
+}
+function discoverRoutes(appPaths) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(appPaths)) {
+    const parsed = toRequestPath(key);
+    if (parsed === null || INTERNAL_PATHS.has(parsed.path) || routes.has(parsed.path)) {
+      continue;
+    }
+    const reason = unaddressableReason(parsed.path);
+    routes.set(parsed.path, {
+      path: parsed.path,
+      kind: parsed.kind,
+      dynamic: parsed.path.includes("["),
+      ...reason !== void 0 && { unaddressableReason: reason }
+    });
   }
-  return null;
+  return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
 }
 
-// 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) {
+// 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 = "RouteConfigError";
+    this.name = "TargetError";
+    this.code = code;
   }
 };
-var ROUTE_CONFIG_FILE = "next-leak.config.json";
-async function loadRouteConfig(appDir) {
-  const file = path3.join(appDir, ROUTE_CONFIG_FILE);
-  let raw;
+async function exists(file) {
   try {
-    raw = await readFile3(file, "utf8");
+    await access(file);
+    return true;
   } catch {
-    return {};
+    return false;
   }
+}
+async function readManifest(file, parse2) {
+  let raw;
   try {
-    return routeConfigSchema.parse(JSON.parse(raw));
+    raw = JSON.parse(await readFile2(file, "utf8"));
   } catch (cause) {
-    throw new RouteConfigError(
-      `${file} is invalid: ${cause instanceof Error ? cause.message : String(cause)}`
+    throw new TargetError(
+      "BAD_MANIFEST",
+      `Could not read ${file}: ${cause instanceof Error ? cause.message : String(cause)}`
     );
   }
-}
-var SEGMENT_PATTERN = /^\[(\[)?(\.\.\.)?([^\]]+?)\]?\]$/;
-function dynamicSegmentsOf(routeTemplate) {
-  const segments = [];
-  for (const segment of routeTemplate.split("/")) {
-    const match = SEGMENT_PATTERN.exec(segment);
-    if (match === null) {
-      continue;
-    }
-    segments.push({
-      name: match[3] ?? "",
-      catchAll: match[2] !== void 0,
-      optional: match[1] !== void 0
-    });
-  }
-  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;
+  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 { marker: match[0], bound };
 }
-var ENCODED_MARKER = encodeURIComponent(UNIQUE_MARKER);
-var encodeSegment = (value) => restoreMarkers(encodeURIComponent(value).split(ENCODED_MARKER).join(UNIQUE_MARKER));
-var ENCODED_BOUNDED = /%7Bn%25(\d+)%7D/gi;
-var restoreMarkers = (value) => value.replace(ENCODED_BOUNDED, (_match, bound) => `{n%${bound}}`);
-var encodeCatchAll = (value) => value.split("/").map(encodeSegment).join("/");
-function resolveRoutePath(routeTemplate, config) {
-  const resolved = [];
-  for (const segment of routeTemplate.split("/")) {
-    const match = SEGMENT_PATTERN.exec(segment);
-    if (match === null) {
-      resolved.push(encodeSegment(segment));
-      continue;
-    }
-    const optional = match[1] !== void 0;
-    const catchAll = match[2] !== void 0;
-    const name = match[3] ?? "";
-    const value = config.routes?.[routeTemplate]?.[name] ?? config.params?.[name];
-    if (value !== void 0) {
-      resolved.push(catchAll ? encodeCatchAll(value) : encodeSegment(value));
-    } else if (!optional) {
-      return null;
-    }
+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 joined = resolved.join("/");
-  const path7 = joined === "" ? "/" : joined;
-  const query = config.query?.[routeTemplate];
-  return query === void 0 || query === "" ? path7 : `${path7}?${query}`;
-}
+  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:
 
-// src/route-guidance.ts
-var PLACEHOLDER = "REPLACE-ME";
-function sampleValuesFromManifest(manifest, routeTemplate) {
-  const routes = manifest?.routes;
-  if (routes === void 0) {
-    return null;
-  }
-  const concrete = Object.entries(routes).find(([, entry]) => entry.srcRoute === routeTemplate)?.[0];
-  if (concrete === void 0) {
-    return null;
+    const 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 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 value = parameter.catchAll ? concreteSegments.slice(index).join("/") : concreteSegments[index];
-    if (value === void 0 || value === "") {
-      return null;
-    }
-    values[parameter.name] = value;
+  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".`
+    );
   }
-  return Object.keys(values).length === 0 ? null : values;
+  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
+  };
 }
-function renderConfigSkeleton(routeTemplates, manifest = void 0) {
-  const routes = {};
-  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;
+
+// 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 activeChildren = /* @__PURE__ */ new Set();
+var STDERR_WINDOW = 4096;
+function killActiveChildren() {
+  for (const child of activeChildren) {
+    child.kill("SIGKILL");
   }
-  return Object.keys(routes).length === 0 ? null : JSON.stringify({ routes }, null, 2);
 }
-function hasPlaceholders(skeleton) {
-  return skeleton.includes(PLACEHOLDER);
+function registerChild(child) {
+  activeChildren.add(child);
+  child.once("exit", () => activeChildren.delete(child));
 }
-
-// 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 unregisterChild(child) {
+  activeChildren.delete(child);
 }
-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));
+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.`;
   }
-  return gaps;
+  if (/EADDRINUSE/.test(stderr)) {
+    return "the port was taken by another process while starting.";
+  }
+  return `stderr:
+${stderr}`;
 }
-function assessUnreclaimedRetention(input) {
-  if (input.verdict === "leak" && input.verdictIsWellSupported || input.unreclaimedSamples.length === 0) {
-    return null;
+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.`;
   }
-  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;
+  return `the measured process exited mid-run. ${explainStartupFailure(stderr)}`;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function pollUntil(deadline, what, probe, failed) {
+  for (; ; ) {
+    const failure = failed();
+    if (failure !== void 0) {
+      throw new LaunchError(failure);
     }
-    const 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;
+    const result = await probe();
+    if (result !== void 0) {
+      return result;
     }
-    if (worst === null || ratio >= worst.ratio) {
-      worst = { class: memoryClass, largestGapBytes, retainedBytes, ratio };
+    if (Date.now() > deadline) {
+      throw new LaunchError(`timed out waiting for ${what}`);
     }
+    await sleep(100);
   }
-  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 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 = [];
-  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
+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);
   });
-  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)
+  const stderrWindow = () => stderrHead === stderrTailBuffer || stderrTailBuffer === "" ? stderrHead : `${stderrHead}
+[...]
+${stderrTailBuffer}`;
+  let exited = false;
+  activeChildren.add(child);
+  child.once("exit", () => {
+    exited = true;
+    activeChildren.delete(child);
   });
-  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 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: () => 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;
   }
-  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)
-  ];
 }
-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 [];
+
+// 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;
+    }
   }
-  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}`)
-  ];
+  return null;
 }
-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`;
+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 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}`
-    );
+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`);
   }
-  return lines.join("\n");
+  options.routes = routes;
+  return FLAG_OK;
 }
-
-// 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 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 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 };
+  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 (source.startsWith("[project]/")) {
-    return { owner: "app", source: source.slice("[project]/".length), packageName: null };
+  if (flag === "--cycles" && parsed < 3) {
+    return flagError("the trend verdict needs at least 3 cycles (--cycles 3 or more)");
   }
-  const relative = source.replace(/^(\.\.\/)+/, "");
-  if (relative !== source && !relative.startsWith("[")) {
-    return { owner: "app", source: relative, packageName: null };
+  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`
+    );
   }
-  return { owner: "framework", source: null, packageName: null };
+  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;
 }
-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})` };
-    }
+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;
   }
-  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;
-    }
+function readFlagValue(spec, argv, index) {
+  if (spec.value === "none") {
+    return { value: "" };
   }
-  if (best.owner === "unattributed") {
-    return classifyByChain(finding.retainerChain ?? "") ?? UNATTRIBUTED;
+  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 best;
+  return { value };
 }
-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);
+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` } };
   }
-  let winner = null;
-  for (const group of byGroup.values()) {
-    if (winner === null || group.bytes > winner.bytes) {
-      winner = group;
-    }
+  if (spec.flag === "--help") {
+    return { done: { kind: "help" } };
   }
-  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
-      )}]`
-    );
+  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 { parts, nodes };
-}
-function retainerChain(node, depth) {
-  return walkChain(node, depth).parts.join(" <- ");
+  return { consumed: spec.value === "none" ? 0 : 1 };
 }
-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 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;
     }
-    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 step = parseFlagAt(rest, index, options);
+    if ("done" in step) {
+      return step.done;
     }
+    index += step.consumed;
   }
-  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 (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`
+      };
     }
-    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 {
+      kind: "build",
+      options: {
+        appDir: options.appDir,
+        output: options.output,
+        attributeBuild: options.attributeBuild
       }
-      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 { kind: "run", options };
+}
+
+// src/guards.ts
+function currentFacts() {
   return {
-    typeDeltas,
-    grownNodes: grown.slice(0, resolved.maxFindings),
-    newNodes: fresh.slice(0, resolved.maxFindings)
+    nodeMajor: Number(process.versions.node.split(".")[0]),
+    platform: process.platform
   };
 }
-var SnapshotError = class extends Error {
+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.`;
+  }
+  return null;
+}
+
+// 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 = "SnapshotError";
+    this.name = "RouteConfigError";
   }
 };
-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;
+var ROUTE_CONFIG_FILE = "next-leak.config.json";
+async function loadRouteConfig(appDir) {
+  const file = path4.join(appDir, ROUTE_CONFIG_FILE);
+  let raw;
   try {
-    size = (await stat(file)).size;
+    raw = await readFile4(file, "utf8");
   } catch {
-    throw new SnapshotError(`heap snapshot is missing: ${file}`);
-  }
-  if (size === 0) {
-    throw new SnapshotError(`heap snapshot is empty: ${file}`);
+    return {};
   }
-  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`
+  try {
+    return routeConfigSchema.parse(JSON.parse(raw));
+  } catch (cause) {
+    throw new RouteConfigError(
+      `${file} is invalid: ${cause instanceof Error ? cause.message : String(cause)}`
     );
   }
-  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}`
-      );
+}
+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 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`
-      );
+    segments.push({
+      name: match[3] ?? "",
+      catchAll: match[2] !== void 0,
+      optional: match[1] !== void 0
+    });
+  }
+  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 { marker: match[0], bound };
+}
+var ENCODED_MARKER = encodeURIComponent(UNIQUE_MARKER);
+var encodeSegment = (value) => restoreMarkers(encodeURIComponent(value).split(ENCODED_MARKER).join(UNIQUE_MARKER));
+var ENCODED_BOUNDED = /%7Bn%25(\d+)%7D/gi;
+var restoreMarkers = (value) => value.replace(ENCODED_BOUNDED, (_match, bound) => `{n%${bound}}`);
+var encodeCatchAll = (value) => value.split("/").map(encodeSegment).join("/");
+function resolveRoutePath(routeTemplate, config) {
+  const resolved = [];
+  for (const segment of routeTemplate.split("/")) {
+    const match = SEGMENT_PATTERN.exec(segment);
+    if (match === null) {
+      resolved.push(encodeSegment(segment));
+      continue;
+    }
+    const optional = match[1] !== void 0;
+    const catchAll = match[2] !== void 0;
+    const name = match[3] ?? "";
+    const value = config.routes?.[routeTemplate]?.[name] ?? config.params?.[name];
+    if (value !== void 0) {
+      resolved.push(catchAll ? encodeCatchAll(value) : encodeSegment(value));
+    } else if (!optional) {
+      return null;
     }
-  } 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);
+  const joined = resolved.join("/");
+  const path7 = joined === "" ? "/" : joined;
+  const query = config.query?.[routeTemplate];
+  return query === void 0 || query === "" ? path7 : `${path7}?${query}`;
 }
 
-// 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}`);
+// src/route-guidance.ts
+var PLACEHOLDER = "REPLACE-ME";
+function sampleValuesFromManifest(manifest, routeTemplate) {
+  const routes = manifest?.routes;
+  if (routes === void 0) {
+    return null;
+  }
+  const concrete = Object.entries(routes).find(([, entry]) => entry.srcRoute === routeTemplate)?.[0];
+  if (concrete === void 0) {
+    return null;
+  }
+  const templateSegments = routeTemplate.split("/");
+  const concreteSegments = concrete.split("/");
+  const values = {};
+  for (const [index, segment] of templateSegments.entries()) {
+    const dynamic = dynamicSegmentsOf(segment);
+    const parameter = dynamic[0];
+    if (parameter === void 0) {
+      continue;
     }
-    value += (digit & 31) << shift;
-    if ((digit & 32) !== 0) {
-      shift += 5;
-    } else {
-      values.push((value & 1) === 1 ? -(value >>> 1) : value >>> 1);
-      value = 0;
-      shift = 0;
+    const value = parameter.catchAll ? concreteSegments.slice(index).join("/") : concreteSegments[index];
+    if (value === void 0 || value === "") {
+      return null;
     }
+    values[parameter.name] = value;
   }
-  return values;
+  return Object.keys(values).length === 0 ? null : values;
 }
-function decodeVlqLine(line) {
-  const segments = [];
-  for (const raw of line.split(",")) {
-    if (raw !== "") {
-      segments.push(decodeVlqSegment(raw));
+function renderConfigSkeleton(routeTemplates, manifest = void 0) {
+  const routes = {};
+  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 segments;
+  return Object.keys(routes).length === 0 ? null : JSON.stringify({ routes }, null, 2);
 }
-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 });
-      }
+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;
     }
-    lines.push({ entries });
+    gaps.push(read(held, memoryClass) - read(afterGc, memoryClass));
   }
-  return lines;
+  return gaps;
 }
-function sourceIndexAt(lines, line, column) {
-  const mapping = lines[line];
-  if (mapping === void 0) {
-    return void 0;
+function assessUnreclaimedRetention(input) {
+  if (input.verdict === "leak" && input.verdictIsWellSupported || input.unreclaimedSamples.length === 0) {
+    return null;
   }
-  let found;
-  for (const entry of mapping.entries) {
-    if (entry.column > column) {
-      break;
+  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 };
     }
-    found = entry.sourceIndex;
   }
-  return found;
+  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/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) };
+// 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;
   }
-  const sectioned = sectionedMapSchema.safeParse(raw);
-  if (!sectioned.success) {
-    return null;
+  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;
   }
-  const sources = [];
+}
+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 = [];
-  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
-        });
-      }
-    }
+  if (route.confidence.supersededVerdict !== void 0) {
+    lines.push(
+      `      measured ${route.trend.verdict}, withdrawn: the run did not observe what that verdict needs`
+    );
   }
-  for (const line of lines) {
-    line?.entries.sort((a, b) => a.column - b.column);
+  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}`
+    );
   }
-  for (let i = 0; i < lines.length; i += 1) {
-    lines[i] ??= { entries: [] };
+  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 { 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 diffFindingLines(route) {
+  if (route.diff === null) {
+    return [];
   }
-  return last;
+  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 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 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 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 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 extractChunkModules(code, rawMap) {
-  const result = /* @__PURE__ */ new Map();
-  if (!code.includes("module.exports=[") && !code.includes("module.exports = [")) {
-    return result;
+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}`];
   }
-  const map = normalizeSourceMap(rawMap);
-  if (map === null) {
-    return result;
+  if (route.status === "failed") {
+    return [`  \u2716 ${route.route}  failed: ${route.reason}`];
   }
-  const codeLines = code.split("\n");
-  collectFirstArrayIds(codeLines, map, result);
-  collectTransitionIds(codeLines, map, result);
-  return result;
+  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),
+    ...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
@@ -94583,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,
@@ -94604,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,