next-leak 0.3.0 → 0.4.1

package/README.md

@@ -35,7 +35,7 @@ holds it — without being told what to look for.
 | [#95094](https://github.com/vercel/next.js/issues/95094) | Middleware `setTimeout` ids retained by the sandbox | **Reproduced** · mechanism named · 112 MB retained |
 | [#94890](https://github.com/vercel/next.js/issues/94890) | Router LRU cache doesn't count its keys | **Reproduced** · 26.7 → 71.9 MB |
 | [#84884](https://github.com/vercel/next.js/issues/84884) | axios + `AbortSignal` in middleware | **Reproduced** · 32.8 → 369.9 MB |
-| [#94919](https://github.com/vercel/next.js/issues/94919) | RSC tree retained on client aborts | Not reproduced on standalone — [and it says why](#scope-and-limits-read-before-filing-issues) |
+| [#94919](https://github.com/vercel/next.js/issues/94919) | RSC tree retained on client aborts | **Reproduced** · 39 → 139 MB · [with a caveat](#scope-and-limits-read-before-filing-issues) |
 
 The full causal chain, measured on that same issue: leak found (28.7 -> 138.9 MB
 across 8 cycles), the workaround from the thread applied (`clearTimeout(id)`
@@ -86,8 +86,11 @@ The verdict comes from the **shape of the post-GC curve**: retained heap that
 keeps growing every cycle is a leak; growth that flattens is warm-up. Where the
 heap sits is noise — 40 MB and 400 MB say nothing on their own — so only the
 shape is judged. The one absolute number involved is the gate a cycle's growth
-must clear to count, and it scales with the traffic that cycle served, so
-changing `--requests` changes how long the run takes and not what it decides.
+must clear to count, and above 5000 requests per cycle it scales with the
+traffic that cycle served — so in that range changing `--requests` changes how
+long the run takes and not what it decides. Below 5000 the gate stops shrinking
+and sits on the instrument's noise floor instead, so less traffic really does
+buy a less sensitive run: that is the trade `--quick` makes at 2000 requests.
 Every report prints the gate it used.
 
 ## Options
@@ -101,6 +104,7 @@ Every report prints the gate it used.
 | `--idle <seconds>` | 30 | **Maximum** wait before each sample; the run continues as soon as the heap settles |
 | `--max-old-space <mb>` | 512 | Heap cap of each measured process. Raise it for apps whose legitimate working set is larger, or they die under measurement |
 | `--quick` | off | Fast preset (2000 requests × 4 cycles, 8s idle) — the exact profile the real-app validation ran with. Same cycle count as the default; what it trades away is traffic per cycle, so it sits on the noise floor and is less sensitive to slow leaks. Explicit flags override it |
+| `--no-resolve` | off | Skip the second pass on inconclusive routes |
 | `--diff-all` | off | Diff snapshots for stable routes too |
 | `--output <dir>` | `<app>/.next-leak` | Where runs are written |
 
@@ -123,10 +127,14 @@ Dynamic routes need sample params in `next-leak.config.json` in your app dir:
   without it.
 - **`query`** appends a query string per route template
   (`{ "/api/payload/[slug]": "weightKb=2048" }`).
-- **`abandonAfterMs`** makes clients hang up before the response arrives, the
-  way closed tabs, load-balancer timeouts and bots do. Some leaks only exist
-  on that path (`ServerResponse` retained after an early disconnect). Requests
-  abandoned on purpose are not counted as failures.
+- **`abandonAfterMs`** makes clients hang up mid-response, the way closed tabs,
+  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.
 
 `run.json` records what every load phase actually did — requests sent,
 2xx, abandoned — so a run can be audited instead of trusted.
@@ -155,11 +163,13 @@ separates them, because each one has a different fix:
   is deliberately biased toward missing a leak rather than inventing one (a
   single flat or falling cycle is enough to call a route stable), so a leak
   that oscillates while it climbs can land here. To press harder, raise
-  `--cycles` and `--requests`: both make the run more sensitive. If the heap is
+  `--cycles` — every extra cycle is another delta the verdict gets to see.
+  Raising `--requests` only helps from below 5000: above that the gate scales
+  with the traffic, so the longer run decides the same thing. If the heap is
   flat but RSS keeps climbing, the report says so explicitly: that is an
   allocator, external-buffer or fragmentation problem, not a JS-heap leak.
 - **`leak`** — the report names the culprit when attribution resolves: your file (`culprit: src/app/x/page.tsx (your code)`), a dependency (package name), or framework internals. An `ISSUE-<route>.md` draft is generated; if the leak is app-owned, the draft tells you **not** to file it upstream.
-- **`inconclusive`** — sustained sub-threshold growth: measure longer. The CLI prints the exact re-run command (`--routes <those> --cycles 6`).
+- **`inconclusive`** — the evidence does not decide. The run does not stop there: any inconclusive route is **measured again automatically**, with twice the cycles, and the second pass is what you see (`resolved at 8 cycles` next to the verdict). On the reproduction for [#95094](https://github.com/vercel/next.js/issues/95094), `--quick` alone reports `inconclusive` on three deltas and then comes back with the leak. `--no-resolve` turns the second pass off; when even that is undecided, the re-run command is still printed.
 - **`failed`** — the route errored under load (auth redirects, POST-only endpoints). >1% non-2xx aborts measurement instead of measuring garbage. That's by design.
 
 ## Peak pressure: `stable` is not the same as safe
@@ -260,6 +270,13 @@ through the build's source maps.
   `--max-old-space`, or every route dies as an OOM that is not the app's
   fault. When a run's heap gets close to the cap, the report says so.
 - Borderline routes can flip between `stable`/`leak` across runs — more cycles resolves this.
+- The [#94919](https://github.com/vercel/next.js/issues/94919) reproduction ships
+  a **custom Express server and deliberately no standalone output**, which this
+  tool cannot measure as published. The figure above comes from the same app
+  built with `output: "standalone"` — the leak is there too, but that is Next's
+  server under test, not the reporter's middleware chain. Instrumenting their
+  own server by hand (same `--import` bootstrap, no CLI) showed the same shape:
+  post-GC heap 43 → 56 MB and arrayBuffers 0.2 → 10.7 MB over four cycles.
 - The **peak-pressure** thresholds are calibrated against one reproduction measured in three regimes plus the bundled fixture, not against the ~40-route validation set the verdicts were tuned on. A peak note never changes a verdict, so the cost of a false one is noise, not a false accusation — but treat the exact thresholds as young.
 - The measured app runs with its real environment: routes that call external services will call them under load. Scope with `--routes` and moderate `--requests` accordingly.
 

package/dist/abandon-load.d.ts

@@ -2,7 +2,7 @@ export type AbandonPhaseOptions = {
     url: string;
     amount: number;
     connections: number;
-    /** Destroy the socket this many ms after sending the request. */
+    /** Destroy the socket this many ms after the first byte of the response. */
     abandonAfterMs: number;
     headers?: Record<string, string>;
 };
@@ -15,6 +15,8 @@ export type AbandonPhaseResult = {
      * different path (the server may never have begun rendering).
      */
     abandonedMidStream: number;
+    /** Abandonments where the first-byte budget expired in silence. */
+    abandonedBeforeResponse: number;
     completed: number;
     errors: number;
 };
@@ -27,7 +29,7 @@ export type AbandonPhaseResult = {
  * `ServerResponse` retention to an early disconnect, which only happens when
  * a client goes away mid-flight (closed tabs, load-balancer timeouts, bots).
  *
- * Raw sockets keep this honest: write the request, wait `abandonAfterMs`,
- * destroy the socket. No response is read.
+ * Raw sockets keep this honest: write the request, wait for the response to
+ * start, then wait `abandonAfterMs` and destroy the socket mid-stream.
  */
 export declare function runAbandonPhase(options: AbandonPhaseOptions): Promise<AbandonPhaseResult>;

package/dist/{chunk-BUNQT6VK.js → chunk-BTWQYJOW.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-E5ZKAANQ.js";
+} from "./chunk-FFCY6POI.js";
 import {
   assessPeakPressure,
   describePeakPressure

package/dist/{chunk-E5ZKAANQ.js → chunk-FFCY6POI.js}

@@ -73,7 +73,8 @@ function effectiveVerdict(report) {
 }
 var VERDICT_WEAKENING = /* @__PURE__ */ new Set([
   "near-threshold",
-  "spiky-growth"
+  "spiky-growth",
+  "thin-evidence"
 ]);
 function warrantsIssueDraft(report) {
   return effectiveVerdict(report) === "leak" && !report.confidence.warnings.some((warning) => VERDICT_WEAKENING.has(warning.code));
@@ -115,7 +116,7 @@ function abandonmentWarnings(outcome) {
   if (abandoned > 0 && midStream < abandoned * MID_STREAM_FLOOR) {
     return [{
       code: "abandon-before-response",
-      detail: `${outcome.phase} cut ${abandoned} requests before the server sent anything (${midStream} mid-stream) \u2014 this tested pre-response disconnects, not mid-stream teardown; raise abandonAfterMs above the route's time-to-first-byte`
+      detail: `${outcome.phase} cut ${abandoned} requests that never produced a byte (${midStream} mid-stream) \u2014 the route did not start responding, so mid-stream teardown was not exercised; the route is saturated or hung at this load, not mistuned`
     }];
   }
   return [];
@@ -182,13 +183,36 @@ function heapCeilingWarnings(input) {
     detail: `the heap peaked at ${mb(peak)} against a ${capMb} MB cap (${pct(peak, capBytes)}) \u2014 the curve may have been clipped by the ceiling rather than by the app; re-run with a larger --max-old-space`
   }];
 }
+var THIN_EVIDENCE_MIN_DELTAS = 5;
+var THIN_EVIDENCE_MIN_DELTA_RATIO = 4;
+function isThinEvidence(trend, minGrowth) {
+  if (trend.deltas.length >= THIN_EVIDENCE_MIN_DELTAS || trend.deltas.length === 0) {
+    return false;
+  }
+  const smallest = Math.min(...trend.deltas);
+  return smallest < minGrowth * THIN_EVIDENCE_MIN_DELTA_RATIO;
+}
+function thinEvidenceWarnings(trend, minGrowth) {
+  if (trend.verdict !== "leak" || !isThinEvidence(trend, minGrowth)) {
+    return [];
+  }
+  const smallest = Math.min(...trend.deltas);
+  return [{
+    code: "thin-evidence",
+    detail: `judged on ${trend.deltas.length} cycles, and its weakest grew ${mb(smallest)} against a ${mb(minGrowth)} gate \u2014 on that few cycles ordinary oscillation reaches that, and a repeat run often disagrees; measure more cycles to resolve it`
+  }];
+}
 function isVerdictInvalid(input) {
   if (input.trend.verdict !== "leak") {
     return false;
   }
   const neverSettled = input.settleOutcomes.length > 0 && input.settleOutcomes.every((outcome) => outcome.status === "moving");
   const abandonedNothing = input.abandonAfterMs !== void 0 && input.loadOutcomes.length > 0 && input.loadOutcomes.every((outcome) => (outcome.abandoned ?? 0) === 0);
-  return neverSettled || abandonedNothing;
+  const thinEvidence = isThinEvidence(
+    input.trend,
+    input.minGrowthPerCycle ?? MIN_GROWTH_NOISE_FLOOR
+  );
+  return neverSettled || abandonedNothing || thinEvidence;
 }
 function assessConfidence(input) {
   const minGrowth = input.minGrowthPerCycle ?? MIN_GROWTH_NOISE_FLOOR;
@@ -197,6 +221,7 @@ function assessConfidence(input) {
     ...loadWarnings(input.loadOutcomes, input.abandonAfterMs),
     ...growthShapeWarnings(input.trend),
     ...noiseFloorWarnings(input.trend, minGrowth),
+    ...thinEvidenceWarnings(input.trend, minGrowth),
     ...heapCeilingWarnings(input)
   ];
   return {

package/dist/{chunk-2BQ5KXIJ.js → chunk-OJIXF7RP.js}

@@ -6,7 +6,7 @@ import {
   effectiveVerdict,
   minGrowthFor,
   warrantsIssueDraft
-} from "./chunk-E5ZKAANQ.js";
+} from "./chunk-FFCY6POI.js";
 import {
   assessPeakPressure,
   describePeakPressure
@@ -91992,6 +91992,11 @@ var FLAGS = [
     help: "Fast preset: 2000 requests x 4 cycles, 8s idle \u2014 same cycle count as the default, less traffic per cycle"
   },
   { flag: "--diff-all", value: "none", help: "Diff snapshots for stable routes too (slow)" },
+  {
+    flag: "--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: "--help", alias: "-h", value: "none", help: "Show this help" },
   { flag: "--version", alias: "-v", value: "none", help: "Print the version" }
@@ -92087,6 +92092,9 @@ function applyFlag(spec, value, options) {
     case "--diff-all":
       options.diffAll = true;
       return FLAG_OK;
+    case "--no-resolve":
+      options.noResolve = true;
+      return FLAG_OK;
     case "--output":
       options.output = value;
       return FLAG_OK;
@@ -92137,6 +92145,7 @@ function parseCliArgs(argv) {
     idleSeconds: null,
     maxOldSpaceMb: null,
     quick: false,
+    noResolve: false,
     diffAll: false,
     output: null
   };
@@ -92441,10 +92450,11 @@ function routeLines(route, parameters) {
   }
   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}`,
+    )})  heap ${curve}${resolved}`,
     ...confidenceLines(route),
     ...memorySourceLines(route, verdict),
     ...peakPressureLines(route, parameters),
@@ -92457,9 +92467,17 @@ function formatReport(report) {
     lines.push(...routeLines(route, report.parameters));
   }
   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(
     "",
-    `judged over ${cycles} cycles \xD7 ${loadRequests} requests, growth gate ${(minGrowthPerCycle / 1024).toFixed(0)} KiB/cycle (${formatGrowth(minGrowthPerCycle / loadRequests * 1e3)}), heap cap ${maxOldSpaceMb} MB`,
+    `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}`)
@@ -92501,6 +92519,11 @@ var routeConfigSchema = z2.object({
    * 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: z2.number().int().positive().optional()
 }).strict();
@@ -92764,6 +92787,9 @@ function diffAgainstBaseline(baseline, after, options = {}) {
       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);
@@ -93260,6 +93286,7 @@ async function requestSnapshot(port, name) {
 
 // src/abandon-load.ts
 import net from "net";
+var FIRST_BYTE_BUDGET_MS = 5e3;
 async function runAbandonPhase(options) {
   const target = new URL(options.url);
   const port = Number(target.port || 80);
@@ -93274,6 +93301,7 @@ Host: ${target.host}\r
     sent: 0,
     abandoned: 0,
     abandonedMidStream: 0,
+    abandonedBeforeResponse: 0,
     completed: 0,
     errors: 0
   };
@@ -93297,6 +93325,8 @@ Host: ${target.host}\r
         result.abandoned += 1;
         if (responseStarted) {
           result.abandonedMidStream += 1;
+        } else {
+          result.abandonedBeforeResponse += 1;
         }
       }
       finish();
@@ -93304,11 +93334,17 @@ Host: ${target.host}\r
     socket.once("connect", () => {
       result.sent += 1;
       socket.write(request2);
-      timer = setTimeout(giveUp, options.abandonAfterMs);
+      timer = setTimeout(giveUp, FIRST_BYTE_BUDGET_MS);
       timer.unref();
     });
     socket.on("data", () => {
+      if (responseStarted) {
+        return;
+      }
       responseStarted = true;
+      clearTimeout(timer);
+      timer = setTimeout(giveUp, options.abandonAfterMs);
+      timer.unref();
     });
     socket.once("end", () => {
       if (!settled) {
@@ -93470,6 +93506,7 @@ async function runRitual(options, deps = defaultDeps) {
       sent: outcome.sent,
       abandoned: outcome.abandoned,
       abandonedMidStream: outcome.abandonedMidStream,
+      abandonedBeforeResponse: outcome.abandonedBeforeResponse,
       ok2xx: outcome.completed,
       errors: outcome.errors
     });
@@ -93832,18 +93869,21 @@ function skipReason(route, requestPath) {
   }
   return null;
 }
-async function measureRoute(context, route, requestPath, index) {
+async function measureRoute(context, route, requestPath, index, pass = void 0) {
   const { deps, options, target, workDir, routeConfig, registry, nextVersion, progress } = context;
   const result = await deps.ritual({
     serverPath: target.standaloneServer,
     route: requestPath,
-    workDir: path6.join(workDir, `${String(index + 1).padStart(2, "0")}-${routeSlug(route.path)}`),
+    workDir: path6.join(
+      workDir,
+      `${String(index + 1).padStart(2, "0")}-${routeSlug(route.path)}${pass?.dirSuffix ?? ""}`
+    ),
     bootstrapPath: options.bootstrapPath,
     appPort: await deps.freePort(),
     ...options.warmupRequests !== void 0 && { warmupRequests: options.warmupRequests },
     ...options.loadRequests !== void 0 && { loadRequests: options.loadRequests },
     ...options.connections !== void 0 && { connections: options.connections },
-    ...options.cycles !== void 0 && { cycles: options.cycles },
+    ...pass !== void 0 ? { cycles: pass.cycles } : options.cycles !== void 0 && { cycles: options.cycles },
     ...options.idleMs !== void 0 && { idleMs: options.idleMs },
     ...options.maxOldSpaceMb !== void 0 && { maxOldSpaceMb: options.maxOldSpaceMb },
     ...routeConfig.headers !== void 0 && { headers: routeConfig.headers },
@@ -93877,6 +93917,7 @@ async function measureRoute(context, route, requestPath, index) {
     route: route.path,
     status: "measured",
     requestPath,
+    ...pass !== void 0 && { resolvedWithCycles: pass.cycles },
     samples: result.samples,
     memorySamples: result.memorySamples,
     peaks: result.peaks,
@@ -93895,7 +93936,7 @@ async function measureRoute(context, route, requestPath, index) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-KQGUDYK5.js");
+  const { renderHtmlReport } = await import("./html-report-76DP5ADD.js");
   const { renderIssueMarkdown } = await import("./issue-report-HKA26WNV.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
@@ -93906,6 +93947,7 @@ async function writeEvidenceBundle(report, workDir) {
   }
   await writeFile(report.bundle.htmlReport, renderHtmlReport(report));
 }
+var resolveCycles = (cycles) => Math.max(cycles * 2, 6);
 async function routeReportFor(context, route, index, total) {
   const { routeConfig, progress } = context;
   const label = `${route.path} (${index + 1}/${total})`;
@@ -93918,7 +93960,16 @@ async function routeReportFor(context, route, index, total) {
   try {
     const asPath = requestPath === route.path ? "" : ` as ${requestPath}`;
     progress(`measuring ${label}${asPath}`);
-    return await measureRoute(context, route, requestPath, index);
+    const first = await measureRoute(context, route, requestPath, index);
+    if (first.status !== "measured" || context.options.resolveInconclusive === false || effectiveVerdict(first) !== "inconclusive") {
+      return first;
+    }
+    const cycles = resolveCycles(context.options.cycles ?? RITUAL_DEFAULTS.cycles);
+    progress(`re-measuring ${route.path} with ${cycles} cycles: the first pass could not call it`);
+    return await measureRoute(context, route, requestPath, index, {
+      cycles,
+      dirSuffix: "-resolve"
+    });
   } catch (cause) {
     const failure = cause instanceof Error ? cause.message : String(cause);
     progress(`failed ${label}: ${failure}`);
@@ -93953,7 +94004,7 @@ async function planRun(options, target, deps, progress) {
   ).length;
   const estimate = estimateRun(measurable, parameters);
   progress(
-    `${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
+    `${routes.length} routes discovered` + (measurable === routes.length ? "" : ` \xB7 ${measurable} measurable`) + ` \xB7 estimated ${formatEstimate(estimate)}` + (options.resolveInconclusive === false ? "" : " (inconclusive routes are measured again)") + // 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).
     (estimate.slowSeconds > 15 * 60 && options.loadRequests === void 0 && options.idleMs === void 0 ? " \u2014 use --quick for the fast validated preset, or narrow with --routes" : "")

package/dist/cli-args.d.ts

@@ -7,6 +7,7 @@ export type CliRunOptions = {
     idleSeconds: number | null;
     maxOldSpaceMb: number | null;
     quick: boolean;
+    noResolve: boolean;
     diffAll: boolean;
     output: string | null;
 };

package/dist/cli.js

@@ -9,8 +9,8 @@ import {
   killActiveChildren,
   parseCliArgs,
   runMeasurement
-} from "./chunk-2BQ5KXIJ.js";
-import "./chunk-E5ZKAANQ.js";
+} from "./chunk-OJIXF7RP.js";
+import "./chunk-FFCY6POI.js";
 import "./chunk-XHPUAMJG.js";
 import "./chunk-6XYFBOL2.js";
 
@@ -100,6 +100,7 @@ async function main() {
     ...options.idleSeconds !== null && { idleMs: options.idleSeconds * 1e3 },
     ...options.maxOldSpaceMb !== null && { maxOldSpaceMb: options.maxOldSpaceMb },
     ...options.diffAll && { diffAll: true },
+    ...options.noResolve && { resolveInconclusive: false },
     ...options.output !== null && { outputDir: options.output },
     onProgress: (message) => console.error(`\xB7 ${message}`)
   });

package/dist/confidence.d.ts

@@ -12,10 +12,11 @@ import { type TrendResult, type TrendVerdict } from "./trend.js";
  *   mid-stream teardown path was never reached
  * `spiky-growth`        — one cycle dominates, so the mean describes little
  * `near-threshold`      — growth barely clears the noise floor
+ * `thin-evidence`       — a leak called on too few cycles for its size
  * `near-heap-ceiling`   — the heap approached the cap the process ran under,
  *   so the curve was measured against a ceiling instead of running free
  */
-export type WarningCode = "unsettled" | "settle-unverified" | "load-incomplete" | "abandon-ineffective" | "abandon-before-response" | "spiky-growth" | "near-threshold" | "near-heap-ceiling";
+export type WarningCode = "unsettled" | "settle-unverified" | "load-incomplete" | "abandon-ineffective" | "abandon-before-response" | "spiky-growth" | "near-threshold" | "thin-evidence" | "near-heap-ceiling";
 export type MeasurementWarning = {
     code: WarningCode;
     detail: string;

package/dist/{html-report-KQGUDYK5.js → html-report-76DP5ADD.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-BUNQT6VK.js";
-import "./chunk-E5ZKAANQ.js";
+} from "./chunk-BTWQYJOW.js";
+import "./chunk-FFCY6POI.js";
 import "./chunk-XHPUAMJG.js";
 import "./chunk-6XYFBOL2.js";
 export {

package/dist/index.js

@@ -39,13 +39,13 @@ import {
   sourceIndexAt,
   summarizeBaseline,
   validateTarget
-} from "./chunk-2BQ5KXIJ.js";
+} from "./chunk-OJIXF7RP.js";
 import {
   renderHtmlReport
-} from "./chunk-BUNQT6VK.js";
+} from "./chunk-BTWQYJOW.js";
 import {
   classifyTrend
-} from "./chunk-E5ZKAANQ.js";
+} from "./chunk-FFCY6POI.js";
 import {
   renderIssueMarkdown
 } from "./chunk-WXAFXVWS.js";

package/dist/ritual.d.ts

@@ -39,6 +39,8 @@ export type LoadOutcome = {
     abandoned?: number;
     /** Abandonments where the response had already started — the mid-stream path. */
     abandonedMidStream?: number;
+    /** Abandonments where the first-byte budget expired in silence. */
+    abandonedBeforeResponse?: number;
 };
 /**
  * Whether the heap actually held still before each sample was taken.

package/dist/runner.d.ts

@@ -56,6 +56,11 @@ export type RouteReport = {
     /** Null when there is no diff or no module registry. */
     attribution: AttributedDiff | null;
     signatures: MatchedSignature[];
+    /**
+     * Cycles used by the second pass, when the first came back
+     * `inconclusive` and the run went back for more evidence.
+     */
+    resolvedWithCycles?: number;
 };
 export type MeasuredRoute = Extract<RouteReport, {
     status: "measured";
@@ -111,6 +116,11 @@ export type RunOptions = {
     diffAll?: boolean;
     /** Only measure routes matching these templates or prefixes. */
     routeFilter?: string[];
+    /**
+     * Measure a route again, with more cycles, when the first pass could not
+     * call it. Default true: the run should answer the question it was asked.
+     */
+    resolveInconclusive?: boolean;
     /** Abort between phases; remaining routes are reported as interrupted. */
     signal?: AbortSignal;
     onProgress?: (message: string) => void;
@@ -143,6 +153,11 @@ export type RunnerDeps = {
 };
 export declare function freePort(): Promise<number>;
 export declare function routeSlug(route: string): string;
+/**
+ * Cycles a second pass uses — the same figure the report recommends for a
+ * manual re-run, so the tool follows its own advice.
+ */
+export declare const resolveCycles: (cycles: number) => number;
 /**
  * Full measurement run: validate the target, discover routes, run the ritual
  * per route in a fresh process, diff snapshots for non-stable verdicts, and

package/package.json

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