next-leak 0.11.1 → 0.11.2

package/dist/{chunk-672J2BQO.js → chunk-QNYUT2XF.js}

@@ -92815,14 +92815,36 @@ function explainRuntimeFailure(stderr, maxOldSpaceMb) {
   }
   return `the measured process exited mid-run. ${explainStartupFailure(stderr)}`;
 }
-function appNeverListened(hostname, port, budgetMs, stderr) {
-  const head = `app on ${hostname}:${port} \u2014 the process started and answered on its control channel, but never listened within ${Math.round(budgetMs / 1e3)}s`;
+function appNeverListened(hostname, port, budgetMs, stderr, lastFailure = void 0) {
+  const refused = lastFailure === void 0 ? "" : ` (${lastFailure})`;
+  const head = `app on ${hostname}:${port} \u2014 the process started and answered on its control channel, but never accepted a connection${refused} within ${Math.round(budgetMs / 1e3)}s`;
   if (stderr.trim() !== "") {
     return `${head}. It wrote this while starting:
 ${stderr.trim()}`;
   }
   return `${head}, and wrote nothing to stderr. An app that boots slower than that needs a larger budget: --ready-timeout <seconds>. Otherwise it is hanging during startup \u2014 starting the same server.js by hand, with PORT set, hangs the same way and can be interrupted to see where`;
 }
+var NOT_LISTENING_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENOTFOUND"
+]);
+function probeFailure(cause) {
+  const inner = cause?.cause;
+  const code = inner?.code;
+  if (typeof code === "string") {
+    return code;
+  }
+  const message = inner?.message;
+  if (typeof message === "string" && message !== "") {
+    return message;
+  }
+  return cause instanceof Error ? cause.message : String(cause);
+}
+function meansNotListening(failure) {
+  return NOT_LISTENING_CODES.has(failure);
+}
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function pollUntil(deadline, describe, probe, failed) {
   for (; ; ) {
@@ -92916,15 +92938,20 @@ ${stderrTailBuffer}`;
       },
       failed
     );
+    let lastFailure;
     await pollUntil(
       Date.now() + readyTimeoutMs,
-      () => appNeverListened(hostname, options.appPort, readyTimeoutMs, stderrWindow()),
+      () => appNeverListened(hostname, options.appPort, readyTimeoutMs, stderrWindow(), lastFailure),
       async () => {
+        const url = `http://${hostname}:${options.appPort}${options.readyPath ?? "/"}`;
         try {
-          await fetch(`http://${hostname}:${options.appPort}/`, { method: "HEAD" });
+          const response = await fetch(url, { method: "GET", redirect: "manual" });
+          await response.body?.cancel();
           return true;
-        } catch {
-          return void 0;
+        } catch (cause) {
+          const failure = probeFailure(cause);
+          lastFailure = failure;
+          return meansNotListening(failure) ? void 0 : true;
         }
       },
       failed
@@ -93909,6 +93936,10 @@ async function runRitual(options, deps = defaultDeps) {
     serverPath: options.serverPath,
     workDir: options.workDir,
     bootstrapPath: options.bootstrapPath,
+    // Wait on the route this ritual is about to measure. `/` is a different
+    // page with different failure modes, and readiness judged on it withdrew
+    // routes that were serving fine (#74).
+    readyPath: options.route,
     ...options.maxOldSpaceMb !== void 0 && { maxOldSpaceMb: options.maxOldSpaceMb },
     ...options.readyTimeoutMs !== void 0 && { readyTimeoutMs: options.readyTimeoutMs }
   };

package/dist/cli.js

@@ -22,7 +22,7 @@ import {
   runSelfCheck,
   unregisterChild,
   validateTarget
-} from "./chunk-672J2BQO.js";
+} from "./chunk-QNYUT2XF.js";
 import {
   classifyTrend
 } from "./chunk-4FYSLLSX.js";

package/dist/index.js

@@ -41,7 +41,7 @@ import {
   sourceIndexAt,
   summarizeBaseline,
   validateTarget
-} from "./chunk-672J2BQO.js";
+} from "./chunk-QNYUT2XF.js";
 import {
   renderHtmlReport
 } from "./chunk-YLHE4N5G.js";

package/dist/launcher.d.ts

@@ -30,6 +30,13 @@ export type LaunchOptions = {
     /** Path to the built bootstrap module loaded with `--import`. */
     bootstrapPath: string;
     hostname?: string;
+    /**
+     * Path the readiness probe asks for. Defaults to `/`, but a run should pass
+     * the route it is about to measure: an app can serve that route perfectly
+     * and still fail on `/` — an i18n redirect, an auth wall, a rewrite — and
+     * the wait would then be judging a page nobody asked about (#74).
+     */
+    readyPath?: string;
     maxOldSpaceMb?: number;
     /**
      * Budget for each of the two waits below, not for the pair. Default:
@@ -103,7 +110,15 @@ export declare function explainRuntimeFailure(stderr: string, maxOldSpaceMb: num
  * there, which reads like the tool failed to connect to something that was
  * running. The process is up: what did not happen is the listen.
  */
-export declare function appNeverListened(hostname: string, port: number, budgetMs: number, stderr: string): string;
+export declare function appNeverListened(hostname: string, port: number, budgetMs: number, stderr: string, lastFailure?: string | undefined): string;
+/**
+ * `fetch` rejects with a bare `TypeError: fetch failed`; what happened is one
+ * level down, and not always as a `code` — a redirect loop arrives as a
+ * message with none.
+ */
+export declare function probeFailure(cause: unknown): string;
+/** Whether a probe failure means the port is not open yet. */
+export declare function meansNotListening(failure: string): boolean;
 /**
  * Spawns the measured server in a fresh child process with GC exposed and the
  * control-channel bootstrap preloaded, and waits until both the app port and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-leak",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Find out whether your Next.js app actually leaks memory — how much, on which route, and whose fault it is.",
   "keywords": [
     "nextjs",