next-leak 0.1.2 → 0.1.3

package/README.md

@@ -7,7 +7,7 @@
 
 > Find out whether your Next.js app actually leaks memory — how much, on which route, and whose fault it is.
 
-<img src="https://raw.githubusercontent.com/xabierlameiro/next-leak/main/docs/demo.svg" alt="next-leak finding a real Next.js memory leak (3-minute run, sped up)" width="720">
+<img src="https://raw.githubusercontent.com/xabierlameiro/next-leak/main/docs/demo.svg" alt="next-leak finding a real Next.js memory leak (43-second run, idle time compressed)" width="720">
 
 ```
 $ npx next-leak . --quick
@@ -46,7 +46,18 @@ that installing it saves memory, but that what it points at is the real cause.
 Across ~25 healthy routes on production applications (PPR, MDX, Auth.js,
 Sentry, i18n), it reported **zero false positives**.
 
-Your server's memory climbs and the container gets OOM-killed. Almost every report of this ends the same way: *"please provide heap snapshots taken after forced GC"* — which almost nobody produces correctly. `next-leak` runs that controlled measurement for you and answers with evidence a maintainer would accept.
+Your self-hosted Next.js server's memory climbs until Node gives up:
+
+```
+FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory
+```
+
+Under Docker or Kubernetes you may not even get that: the process is `OOMKilled`,
+the container exits with **code 137**, and the restart wipes the evidence before
+you can look at it. Almost every report of this ends the same way — *"please
+provide heap snapshots taken after forced GC"* — which almost nobody produces
+correctly. `next-leak` runs that controlled measurement for you and answers with
+evidence a maintainer would accept.
 
 Three possible answers, all valuable:
 

package/dist/bootstrap.js

@@ -1,5 +1,5 @@
 import { createRequire as __nextLeakCreateRequire } from 'node:module';import { fileURLToPath as __nextLeakFileURLToPath } from 'node:url';import { dirname as __nextLeakDirname } from 'node:path';const require = __nextLeakCreateRequire(import.meta.url);const __filename = __nextLeakFileURLToPath(import.meta.url);const __dirname = __nextLeakDirname(__filename);
-import "./chunk-PF7KYD5N.js";
+import "./chunk-6XYFBOL2.js";
 
 // src/bootstrap.ts
 import { mkdir, writeFile } from "fs/promises";

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

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

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

@@ -11,7 +11,7 @@ import {
   __require,
   __toCommonJS,
   __toESM
-} from "./chunk-PF7KYD5N.js";
+} from "./chunk-6XYFBOL2.js";
 
 // node_modules/.pnpm/fs-extra@4.0.3/node_modules/fs-extra/lib/util/assign.js
 var require_assign = __commonJS({
@@ -92475,11 +92475,12 @@ function formatReport(report) {
   for (const route of report.routes) {
     lines.push(...routeLines(route));
   }
-  lines.push("", `snapshots and run.json: ${report.workDir}`);
-  lines.push(`report: ${report.bundle.htmlReport}`);
-  for (const issue of report.bundle.issues) {
-    lines.push(`issue draft (${issue.route}): ${issue.file}`);
-  }
+  lines.push(
+    "",
+    `snapshots and run.json: ${report.workDir}`,
+    `report: ${report.bundle.htmlReport}`,
+    ...report.bundle.issues.map((issue) => `issue draft (${issue.route}): ${issue.file}`)
+  );
   const inconclusive = report.routes.filter(
     (route) => route.status === "measured" && effectiveVerdict(route) === "inconclusive"
   );
@@ -92582,7 +92583,7 @@ function classifySource(rawSource) {
   }
   const nodeModulesSplit = source.split("/node_modules/");
   if (nodeModulesSplit.length > 1) {
-    const tail = nodeModulesSplit[nodeModulesSplit.length - 1] ?? "";
+    const tail = nodeModulesSplit.at(-1) ?? "";
     const segments = tail.split("/");
     const packageName = (segments[0]?.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0]) ?? null;
     if (packageName === "next" || packageName === "react" || packageName === "react-dom") {
@@ -92890,6 +92891,16 @@ var routesManifestSchema = z3.looseObject({
 });
 var INTERNAL_PATHS = /* @__PURE__ */ new Set(["/_global-error", "/_not-found"]);
 var INTERCEPTING_SEGMENT = /^(\(\.{1,3}\))+/;
+var STATIC_ASSET_PATHS = /* @__PURE__ */ new Set(["/favicon.ico"]);
+function unaddressableReason(routePath) {
+  if (routePath.split("/").some((segment) => INTERCEPTING_SEGMENT.test(segment))) {
+    return "intercepting route \u2014 only reachable via client navigation";
+  }
+  if (STATIC_ASSET_PATHS.has(routePath)) {
+    return "static asset served by a generated handler \u2014 no user code to leak";
+  }
+  return void 0;
+}
 function toRequestPath(manifestKey) {
   let kind;
   let withoutSuffix;
@@ -92927,14 +92938,12 @@ function discoverRoutes(appPaths) {
     if (parsed === null || INTERNAL_PATHS.has(parsed.path) || routes.has(parsed.path)) {
       continue;
     }
-    const intercepting = parsed.path.split("/").some((segment) => INTERCEPTING_SEGMENT.test(segment));
+    const reason = unaddressableReason(parsed.path);
     routes.set(parsed.path, {
       path: parsed.path,
       kind: parsed.kind,
       dynamic: parsed.path.includes("["),
-      ...intercepting && {
-        unaddressableReason: "intercepting route \u2014 only reachable via client navigation"
-      }
+      ...reason !== void 0 && { unaddressableReason: reason }
     });
   }
   return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
@@ -93283,55 +93292,55 @@ Host: ${target.host}\r
     errors: 0
   };
   let remaining = options.amount;
+  const sendOne = () => new Promise((resolve) => {
+    const socket = net.connect({ host: target.hostname, port });
+    let settled = false;
+    let responseStarted = false;
+    let timer;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve();
+    };
+    const giveUp = () => {
+      if (!settled) {
+        result.abandoned += 1;
+        if (responseStarted) {
+          result.abandonedMidStream += 1;
+        }
+      }
+      finish();
+    };
+    socket.once("connect", () => {
+      result.sent += 1;
+      socket.write(request2);
+      timer = setTimeout(giveUp, options.abandonAfterMs);
+      timer.unref();
+    });
+    socket.on("data", () => {
+      responseStarted = true;
+    });
+    socket.once("end", () => {
+      if (!settled) {
+        result.completed += 1;
+      }
+      finish();
+    });
+    socket.once("error", () => {
+      if (!settled) {
+        result.errors += 1;
+      }
+      finish();
+    });
+  });
   const worker = async () => {
     while (remaining > 0) {
       remaining -= 1;
-      await new Promise((resolve) => {
-        const socket = net.connect({ host: target.hostname, port });
-        let settled = false;
-        let responseStarted = false;
-        let timer;
-        const finish = () => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          clearTimeout(timer);
-          socket.destroy();
-          resolve();
-        };
-        socket.once("connect", () => {
-          result.sent += 1;
-          socket.write(request2);
-          timer = setTimeout(() => {
-            if (!settled) {
-              result.abandoned += 1;
-              if (responseStarted) {
-                result.abandonedMidStream += 1;
-              }
-            }
-            finish();
-          }, options.abandonAfterMs);
-          timer.unref();
-        });
-        socket.on("data", () => {
-          responseStarted = true;
-        });
-        socket.once("end", () => {
-          if (!settled) {
-            result.completed += 1;
-          }
-          clearTimeout(timer);
-          finish();
-        });
-        socket.once("error", () => {
-          if (!settled) {
-            result.errors += 1;
-          }
-          clearTimeout(timer);
-          finish();
-        });
-      });
+      await sendOne();
     }
   };
   await Promise.all(
@@ -93682,9 +93691,20 @@ import { createServer } from "net";
 import path6 from "path";
 var ESTIMATED_RPS = 250;
 var PER_ROUTE_OVERHEAD_SECONDS = 10;
-function estimateRunSeconds(routeCount, parameters) {
-  const perRoute = parameters.warmupRequests / ESTIMATED_RPS + parameters.cycles * (parameters.loadRequests / ESTIMATED_RPS + parameters.idleMs / 1e3) + PER_ROUTE_OVERHEAD_SECONDS;
-  return Math.round(routeCount * perRoute);
+var MIN_SETTLE_SECONDS = 4;
+function estimateRun(routeCount, parameters) {
+  const settleSeconds = Math.min(MIN_SETTLE_SECONDS, parameters.idleMs / 1e3);
+  const slowPerRoute = parameters.warmupRequests / ESTIMATED_RPS + parameters.cycles * (parameters.loadRequests / ESTIMATED_RPS + parameters.idleMs / 1e3) + PER_ROUTE_OVERHEAD_SECONDS;
+  const fastPerRoute = PER_ROUTE_OVERHEAD_SECONDS + parameters.cycles * settleSeconds;
+  return {
+    fastSeconds: Math.round(routeCount * fastPerRoute),
+    slowSeconds: Math.round(routeCount * slowPerRoute)
+  };
+}
+function formatEstimate(estimate) {
+  const fast = formatDuration(estimate.fastSeconds);
+  const slow = formatDuration(estimate.slowSeconds);
+  return fast === slow ? `\u2248 ${slow}` : `\u2248 ${fast}\u2013${slow}`;
 }
 function formatDuration(seconds) {
   if (seconds < 90) {
@@ -93732,7 +93752,7 @@ function rssTrend(memorySamples) {
   return deltas.reduce((sum, delta) => sum + delta, 0) / deltas.length;
 }
 function routeSlug(route) {
-  const sanitized = route.replaceAll(/[^a-zA-Z0-9-]+/g, "_").replace(/^_+/, "").replace(/_+$/, "");
+  const sanitized = route.replaceAll(/[^a-zA-Z0-9-]+/g, "_").replace(/^_/, "").replace(/_$/, "");
   if (route === "/") {
     return "root";
   }
@@ -93742,9 +93762,16 @@ function routeSlug(route) {
   const digest = createHash3("sha1").update(route).digest("hex").slice(0, 6);
   return sanitized === "" ? `route-${digest}` : `${sanitized}-${digest}`;
 }
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
 function filterRoutes(routes, selectors, progress) {
   const matches = (routePath, selector) => {
-    const normalized = selector.replace(/[/]+$/, "");
+    const normalized = trimTrailingSlashes(selector);
     if (normalized === "") {
       return routePath === "/";
     }
@@ -93822,8 +93849,8 @@ async function measureRoute(context, route, requestPath, index) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-I4PNSLKY.js");
-  const { renderIssueMarkdown } = await import("./issue-report-VQEUXP2E.js");
+  const { renderHtmlReport } = await import("./html-report-26DU7JFW.js");
+  const { renderIssueMarkdown } = await import("./issue-report-FUTEOHN5.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
       const file = path6.join(workDir, `ISSUE-${routeSlug(route.route)}.md`);
@@ -93872,15 +93899,15 @@ async function planRun(options, target, deps, progress) {
     cycles: options.cycles ?? RITUAL_DEFAULTS.cycles,
     idleMs: options.idleMs ?? RITUAL_DEFAULTS.idleMs
   };
-  const estimatedSeconds = estimateRunSeconds(
-    routes.filter((route) => resolveRoutePath(route.path, routeConfig) !== null).length,
-    parameters
-  );
+  const measurable = routes.filter(
+    (route) => skipReason(route, resolveRoutePath(route.path, routeConfig)) === null
+  ).length;
+  const estimate = estimateRun(measurable, parameters);
   progress(
-    `${routes.length} routes discovered \xB7 estimated \u2248 ${formatDuration(estimatedSeconds)}` + // Long default runs are where first-time users give up; point at the two
+    `${routes.length} routes discovered` + (measurable === routes.length ? "" : ` \xB7 ${measurable} measurable`) + ` \xB7 estimated ${formatEstimate(estimate)}` + // Long default runs are where first-time users give up; point at the two
     // ways out. Suppressed once load parameters were tuned by hand (or by
     // --quick, which arrives here as explicit loadRequests/idleMs).
-    (estimatedSeconds > 15 * 60 && options.loadRequests === void 0 && options.idleMs === void 0 ? " \u2014 use --quick for the fast validated preset, or narrow with --routes" : "")
+    (estimate.slowSeconds > 15 * 60 && options.loadRequests === void 0 && options.idleMs === void 0 ? " \u2014 use --quick for the fast validated preset, or narrow with --routes" : "")
   );
   return { routes, routeConfig, registry, nextVersion, parameters };
 }

package/dist/cli.js

@@ -9,9 +9,9 @@ import {
   killActiveChildren,
   parseCliArgs,
   runMeasurement
-} from "./chunk-WHC6S57X.js";
+} from "./chunk-ZFYIR423.js";
 import "./chunk-2BQZCZ4Z.js";
-import "./chunk-PF7KYD5N.js";
+import "./chunk-6XYFBOL2.js";
 
 // src/cli.ts
 import { spawn } from "child_process";

package/dist/{html-report-I4PNSLKY.js → html-report-26DU7JFW.js}

@@ -3,7 +3,7 @@ import {
   renderHtmlReport
 } from "./chunk-C3KH5Z2W.js";
 import "./chunk-2BQZCZ4Z.js";
-import "./chunk-PF7KYD5N.js";
+import "./chunk-6XYFBOL2.js";
 export {
   renderHtmlReport
 };

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   sourceIndexAt,
   summarizeBaseline,
   validateTarget
-} from "./chunk-WHC6S57X.js";
+} from "./chunk-ZFYIR423.js";
 import {
   renderHtmlReport
 } from "./chunk-C3KH5Z2W.js";
@@ -48,7 +48,7 @@ import "./chunk-2BQZCZ4Z.js";
 import {
   renderIssueMarkdown
 } from "./chunk-5ZYZW2BL.js";
-import "./chunk-PF7KYD5N.js";
+import "./chunk-6XYFBOL2.js";
 export {
   LaunchError,
   LoadError,

package/dist/{issue-report-VQEUXP2E.js → issue-report-FUTEOHN5.js}

@@ -2,7 +2,7 @@ import { createRequire as __nextLeakCreateRequire } from 'node:module';import {
 import {
   renderIssueMarkdown
 } from "./chunk-5ZYZW2BL.js";
-import "./chunk-PF7KYD5N.js";
+import "./chunk-6XYFBOL2.js";
 export {
   renderIssueMarkdown
 };

package/dist/runner.d.ts

@@ -96,7 +96,24 @@ export type RunOptions = {
     signal?: AbortSignal;
     onProgress?: (message: string) => void;
 };
-export declare function estimateRunSeconds(routeCount: number, parameters: RunParameters): number;
+export type RunEstimate = {
+    /**
+     * Costs no run avoids: process launch, GC, snapshots and the minimum
+     * settle. Request-serving time is left out on purpose — throughput is the
+     * one term that swings 10x between a hello-world route and a real one, so a
+     * floor that guessed at it would not be a floor.
+     */
+    fastSeconds: number;
+    /** Full idle window every cycle, at the lowest throughput ever measured. */
+    slowSeconds: number;
+};
+export declare function estimateRun(routeCount: number, parameters: RunParameters): RunEstimate;
+/**
+ * A point estimate cannot be right across app weights: the adaptive idle ends
+ * as soon as the heap holds still, which on a small app is almost at once. A
+ * range says that out loud instead of quoting the worst case as the price.
+ */
+export declare function formatEstimate(estimate: RunEstimate): string;
 export declare function formatDuration(seconds: number): string;
 export type RunnerDeps = {
     ritual: typeof runRitual;

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "next-leak",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Find out whether your Next.js app actually leaks memory — how much, on which route, and whose fault it is.",
   "keywords": [
     "nextjs",
+    "next.js",
     "memory-leak",
+    "memory",
+    "oom",
+    "oomkilled",
+    "heap",
     "heap-snapshot",
+    "profiling",
+    "performance",
+    "nodejs",
     "diagnostics",
+    "debugging",
     "cli"
   ],
   "license": "MIT",
@@ -37,7 +46,9 @@
   },
   "pnpm": {
     "overrides": {
-      "uuid": ">=11.1.1"
+      "uuid": ">=11.1.1",
+      "esbuild": ">=0.28.1",
+      "qs": ">=6.15.2"
     }
   },
   "devDependencies": {