next-leak 0.6.0 → 0.7.0

package/README.md

@@ -167,10 +167,19 @@ first try. When a run skips a route it prints the same fragment.
   load-balancer timeouts and bots do. Some leaks only exist on that path
   (`ServerResponse` retained after an early disconnect; the RSC tee branch in
   [#94919](https://github.com/vercel/next.js/issues/94919)). The clock starts
-  at the **first byte of the response**, not at the request — under load a
-  request-relative window cuts before the stream begins and tests a different
-  path. Small values are the point: `4` means "read the first chunk, then
-  vanish". Requests abandoned on purpose are not counted as failures.
+  at the **first byte of the response**, so the cut lands mid-stream however
+  long the route takes to answer. Small values are the point: `4` means "read
+  the first chunk, then vanish". Requests abandoned on purpose are not counted
+  as failures.
+- **`abandonFrom`** moves that clock to the request itself
+  (`"abandonFrom": "request"`). Use it for the opposite experiment: a client
+  that is already gone before the server produces anything. On a route slower
+  than the deadline the default never cuts early — against the reproduction
+  for [#84648](https://github.com/vercel/next.js/issues/84648), whose upstream
+  answers in 400 ms while its load generator cuts at 60 ms, first-byte reached
+  7% of requests and `request` reached all of them. It stays opt-in because a
+  deadline armed on connect loses the race to the first byte on fast routes,
+  which measures the wrong path silently.
 
 `run.json` records what every load phase actually did — requests sent,
 2xx, abandoned — so a run can be audited instead of trusted.

package/dist/abandon-load.d.ts

@@ -1,9 +1,17 @@
+/**
+ * Where the abandon deadline starts. `first-byte` puts the cut mid-stream
+ * whatever the route's latency; `request` puts it before the response exists,
+ * which is a different leak path and not reachable from the other origin.
+ */
+export type AbandonOrigin = "first-byte" | "request";
 export type AbandonPhaseOptions = {
     url: string;
     amount: number;
     connections: number;
-    /** Destroy the socket this many ms after the first byte of the response. */
+    /** Destroy the socket this many ms after the origin below. */
     abandonAfterMs: number;
+    /** Defaults to `first-byte`. */
+    abandonFrom?: AbandonOrigin;
     headers?: Record<string, string>;
 };
 export type AbandonPhaseResult = {
@@ -30,6 +38,8 @@ export type AbandonPhaseResult = {
  * a client goes away mid-flight (closed tabs, load-balancer timeouts, bots).
  *
  * Raw sockets keep this honest: write the request, wait for the response to
- * start, then wait `abandonAfterMs` and destroy the socket mid-stream.
+ * start, then wait `abandonAfterMs` and destroy the socket mid-stream. With
+ * `abandonFrom: "request"` the wait starts at the write instead, which is the
+ * only way to cut a route that has not begun answering yet.
  */
 export declare function runAbandonPhase(options: AbandonPhaseOptions): Promise<AbandonPhaseResult>;

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

@@ -7,7 +7,7 @@ import {
   minGrowthFor,
   resolveCycles,
   warrantsIssueDraft
-} from "./chunk-22PBLCGO.js";
+} from "./chunk-EJ26OBZI.js";
 import {
   assessPeakPressure,
   describePeakPressure
@@ -92624,8 +92624,28 @@ var routeConfigSchema = z3.object({
    * window, so a request-relative clock cuts before the stream starts and
    * tests the wrong path entirely.
    */
-  abandonAfterMs: z3.number().int().positive().optional()
-}).strict();
+  abandonAfterMs: z3.number().int().positive().optional(),
+  /**
+   * Where the abandon deadline starts. `first-byte` is the default and the
+   * semantics everything else assumes.
+   *
+   * `request` starts it when the request is written, which is the only way
+   * to reach leaks that need the client already gone before the server
+   * produces anything: against a route whose time-to-first-byte exceeds the
+   * deadline, a first-byte clock never cuts early. Measured on the
+   * vercel/next.js#84648 repro, whose upstream answers in 400 ms while its
+   * own load generator cuts at 60 ms — the first-byte clock reached 7% of
+   * requests there, none of them on the path the issue describes.
+   *
+   * Opt-in per route, never a default: armed on connect, the deadline loses
+   * the race to the first byte on fast routes, which is how the earlier
+   * version of this measured 2 mid-stream cuts out of ~1500 on #94919.
+   */
+  abandonFrom: z3.enum(["first-byte", "request"]).optional()
+}).strict().refine((config) => config.abandonFrom === void 0 || config.abandonAfterMs !== void 0, {
+  message: '"abandonFrom" configures nothing without "abandonAfterMs"',
+  path: ["abandonFrom"]
+});
 var RouteConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -92846,6 +92866,14 @@ function revalidationLines(route) {
     `      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) {
@@ -92939,6 +92967,7 @@ function routeLines(route, parameters) {
       route.growthPer1000Requests
     )})  heap ${curve}${resolved}`,
     ...revalidationLines(route),
+    ...abandonLines(route),
     ...confidenceLines(route),
     ...memorySourceLines(route, verdict),
     ...peakPressureLines(route, parameters),
@@ -93735,6 +93764,7 @@ var FIRST_BYTE_BUDGET_MS = 5e3;
 async function runAbandonPhase(options) {
   const target = new URL(options.url);
   const port = Number(target.port || 80);
+  const fromRequest = options.abandonFrom === "request";
   const headerLines = Object.entries(options.headers ?? {}).map(([name, value]) => `${name}: ${value}\r
 `).join("");
   const request2 = `GET ${target.pathname}${target.search} HTTP/1.1\r
@@ -93779,7 +93809,10 @@ Host: ${target.host}\r
     socket.once("connect", () => {
       result.sent += 1;
       socket.write(request2);
-      timer = setTimeout(giveUp, FIRST_BYTE_BUDGET_MS);
+      timer = setTimeout(
+        giveUp,
+        fromRequest ? options.abandonAfterMs : FIRST_BYTE_BUDGET_MS
+      );
       timer.unref();
     });
     socket.on("data", () => {
@@ -93787,6 +93820,9 @@ Host: ${target.host}\r
         return;
       }
       responseStarted = true;
+      if (fromRequest) {
+        return;
+      }
       clearTimeout(timer);
       timer = setTimeout(giveUp, options.abandonAfterMs);
       timer.unref();
@@ -93949,6 +93985,7 @@ async function runRitual(options, deps = defaultDeps) {
       amount,
       connections,
       abandonAfterMs,
+      ...options.abandonFrom !== void 0 && { abandonFrom: options.abandonFrom },
       ...options.headers !== void 0 && { headers: options.headers }
     });
     loadOutcomes.push({
@@ -94330,6 +94367,9 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     ...headers !== void 0 && { headers },
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
+    },
+    ...routeConfig.abandonFrom !== void 0 && {
+      abandonFrom: routeConfig.abandonFrom
     }
   });
   const confidence = assessConfidence({
@@ -94344,6 +94384,9 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     warmupRequests: options.warmupRequests ?? RITUAL_DEFAULTS.warmupRequests,
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
+    },
+    ...routeConfig.abandonFrom !== void 0 && {
+      abandonFrom: routeConfig.abandonFrom
     }
   });
   const verdict = confidence.supersededVerdict ?? result.trend.verdict;
@@ -94374,6 +94417,12 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     unreclaimedSamples: result.unreclaimedSamples,
     unreclaimedTrend: result.unreclaimedTrend,
     requestsPerCycle: result.requestsPerCycle,
+    ...routeConfig.abandonAfterMs !== void 0 && {
+      abandon: {
+        afterMs: routeConfig.abandonAfterMs,
+        from: routeConfig.abandonFrom ?? "first-byte"
+      }
+    },
     timings: result.timings,
     loadOutcomes: result.loadOutcomes,
     settleOutcomes: result.settleOutcomes,
@@ -94389,7 +94438,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-2UAOOZQO.js");
+  const { renderHtmlReport } = await import("./html-report-TN7PYVU4.js");
   const { renderIssueMarkdown } = await import("./issue-report-HKA26WNV.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {

package/dist/{chunk-22PBLCGO.js → chunk-EJ26OBZI.js}

@@ -113,7 +113,7 @@ function settleWarnings(outcomes) {
   }
   return warnings;
 }
-function abandonmentWarnings(outcome) {
+function abandonmentWarnings(outcome, abandonFrom) {
   const abandoned = outcome.abandoned ?? 0;
   if (outcome.sent > 0 && abandoned < outcome.sent * ABANDON_EFFECTIVE_FLOOR) {
     return [{
@@ -121,6 +121,9 @@ function abandonmentWarnings(outcome) {
       detail: `${outcome.phase} disconnected early on only ${abandoned} of ${outcome.sent} requests (${pct(abandoned, outcome.sent)}) \u2014 the early-disconnect path was largely not exercised`
     }];
   }
+  if (abandonFrom === "request") {
+    return [];
+  }
   const midStream = outcome.abandonedMidStream ?? 0;
   if (abandoned > 0 && midStream < abandoned * MID_STREAM_FLOOR) {
     return [{
@@ -130,11 +133,11 @@ function abandonmentWarnings(outcome) {
   }
   return [];
 }
-function loadWarnings(outcomes, abandonAfterMs) {
+function loadWarnings(outcomes, abandonAfterMs, abandonFrom) {
   const warnings = [];
   for (const outcome of outcomes) {
     if (abandonAfterMs !== void 0) {
-      warnings.push(...abandonmentWarnings(outcome));
+      warnings.push(...abandonmentWarnings(outcome, abandonFrom));
       continue;
     }
     const landed = outcome.ok2xx ?? 0;
@@ -246,7 +249,7 @@ function assessConfidence(input) {
   const minGrowth = input.minGrowthPerCycle ?? MIN_GROWTH_NOISE_FLOOR;
   const warnings = [
     ...settleWarnings(input.settleOutcomes),
-    ...loadWarnings(input.loadOutcomes, input.abandonAfterMs),
+    ...loadWarnings(input.loadOutcomes, input.abandonAfterMs, input.abandonFrom),
     ...growthShapeWarnings(input.trend),
     ...noiseFloorWarnings(input.trend, minGrowth),
     ...thinEvidenceWarnings(input.trend, minGrowth),

package/dist/{chunk-6CJU5TVV.js → chunk-RS3AO7HB.js}

@@ -1,7 +1,7 @@
 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 {
   effectiveVerdict
-} from "./chunk-22PBLCGO.js";
+} from "./chunk-EJ26OBZI.js";
 import {
   assessPeakPressure,
   describePeakPressure

package/dist/cli.js

@@ -16,10 +16,10 @@ import {
   runMeasurement,
   unregisterChild,
   validateTarget
-} from "./chunk-AMSDGT3Y.js";
+} from "./chunk-BXDUPN6Z.js";
 import {
   classifyTrend
-} from "./chunk-22PBLCGO.js";
+} from "./chunk-EJ26OBZI.js";
 import "./chunk-XHPUAMJG.js";
 import "./chunk-6XYFBOL2.js";
 

package/dist/confidence.d.ts

@@ -1,3 +1,4 @@
+import type { AbandonOrigin } from "./abandon-load.js";
 import type { HeapSample } from "./control-server.js";
 import type { LoadOutcome, SettleOutcome } from "./ritual.js";
 import { type TrendResult, type TrendVerdict } from "./trend.js";
@@ -41,6 +42,8 @@ export type ConfidenceInput = {
     settleOutcomes: readonly SettleOutcome[];
     /** Set when the run asked for early disconnects. */
     abandonAfterMs?: number;
+    /** Which deadline origin those disconnects used. Defaults to `first-byte`. */
+    abandonFrom?: AbandonOrigin;
     /** Threshold the verdict used, for the noise-floor check. */
     minGrowthPerCycle?: number;
     /** Post-GC samples, for the heap-ceiling check. */

package/dist/{html-report-2UAOOZQO.js → html-report-TN7PYVU4.js}

@@ -1,8 +1,8 @@
 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 {
   renderHtmlReport
-} from "./chunk-6CJU5TVV.js";
-import "./chunk-22PBLCGO.js";
+} from "./chunk-RS3AO7HB.js";
+import "./chunk-EJ26OBZI.js";
 import "./chunk-XHPUAMJG.js";
 import "./chunk-6XYFBOL2.js";
 export {

package/dist/index.js

@@ -39,13 +39,13 @@ import {
   sourceIndexAt,
   summarizeBaseline,
   validateTarget
-} from "./chunk-AMSDGT3Y.js";
+} from "./chunk-BXDUPN6Z.js";
 import {
   renderHtmlReport
-} from "./chunk-6CJU5TVV.js";
+} from "./chunk-RS3AO7HB.js";
 import {
   classifyTrend
-} from "./chunk-22PBLCGO.js";
+} from "./chunk-EJ26OBZI.js";
 import {
   renderIssueMarkdown
 } from "./chunk-WXAFXVWS.js";

package/dist/ritual.d.ts

@@ -1,6 +1,6 @@
 import type { HeapSample } from "./control-server.js";
 import { launchInstrumented } from "./launcher.js";
-import { runAbandonPhase } from "./abandon-load.js";
+import { runAbandonPhase, type AbandonOrigin } from "./abandon-load.js";
 import { runLoadPhase } from "./load.js";
 import { type TrendResult } from "./trend.js";
 export type RitualOptions = {
@@ -24,6 +24,8 @@ export type RitualOptions = {
     headers?: Record<string, string>;
     /** Emulate clients that disconnect before the response arrives. */
     abandonAfterMs?: number;
+    /** Where that deadline starts. Defaults to `first-byte`. */
+    abandonFrom?: AbandonOrigin;
 };
 export type PhaseTiming = {
     phase: string;

package/dist/route-config.d.ts

@@ -5,6 +5,10 @@ declare const routeConfigSchema: z.ZodObject<{
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     abandonAfterMs: z.ZodOptional<z.ZodNumber>;
+    abandonFrom: z.ZodOptional<z.ZodEnum<{
+        "first-byte": "first-byte";
+        request: "request";
+    }>>;
 }, z.core.$strict>;
 export type RouteConfig = z.infer<typeof routeConfigSchema>;
 export declare class RouteConfigError extends Error {

package/dist/runner.d.ts

@@ -1,3 +1,4 @@
+import type { AbandonOrigin } from "./abandon-load.js";
 import { type AttributedDiff } from "./attribution.js";
 import { type ConfidenceReport } from "./confidence.js";
 import type { HeapSample } from "./control-server.js";
@@ -56,6 +57,16 @@ export type RouteReport = {
     unreclaimedTrend: TrendResult;
     /** Requests each cycle served — what the growth rates normalize by. */
     requestsPerCycle: number;
+    /**
+     * The early-disconnect regime, when the route asked for one. Recorded
+     * because a curve measured with cuts landing mid-stream and one measured
+     * with cuts landing before the response are different experiments, and
+     * the counters alone do not say which was intended.
+     */
+    abandon?: {
+        afterMs: number;
+        from: AbandonOrigin;
+    };
     /**
      * Distinct keys the load cycled through, when the route asked for a
      * bounded set. A verdict about a cache depends on how many keys it saw,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-leak",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Find out whether your Next.js app actually leaks memory — how much, on which route, and whose fault it is.",
   "keywords": [
     "nextjs",
@@ -49,7 +49,11 @@
     "overrides": {
       "uuid": ">=11.1.1",
       "esbuild": ">=0.28.1",
-      "qs": ">=6.15.2"
+      "qs": ">=6.15.2",
+      "js-yaml": ">=4.3.1 <5",
+      "fast-uri": ">=3.1.5 <4",
+      "ip-address": ">=10.3.1 <11",
+      "postcss": ">=8.5.23 <9"
     }
   },
   "devDependencies": {