next-leak 0.4.1 → 0.4.3

package/dist/{chunk-FFCY6POI.js → chunk-2FZXZLZW.js}

@@ -68,6 +68,7 @@ function classifyMemoryTrend(heapSamples, externalSamples, options = {}) {
 }
 
 // src/confidence.ts
+var resolveCycles = (cycles) => Math.max(cycles * 2, 6);
 function effectiveVerdict(report) {
   return report.confidence.supersededVerdict ?? report.trend.verdict;
 }
@@ -235,6 +236,7 @@ export {
   minGrowthFor,
   classifyTrend,
   classifyMemoryTrend,
+  resolveCycles,
   effectiveVerdict,
   warrantsIssueDraft,
   assessConfidence

package/dist/{chunk-OJIXF7RP.js → chunk-EQ2DV2YO.js}

@@ -5,8 +5,9 @@ import {
   classifyTrend,
   effectiveVerdict,
   minGrowthFor,
+  resolveCycles,
   warrantsIssueDraft
-} from "./chunk-FFCY6POI.js";
+} from "./chunk-2FZXZLZW.js";
 import {
   assessPeakPressure,
   describePeakPressure
@@ -3656,10 +3657,10 @@ var require_ansi_styles = __commonJS({
     };
     var ansi2ansi = (n) => n;
     var rgb2rgb = (r, g, b) => [r, g, b];
-    var setLazyProperty = (object, property, get) => {
+    var setLazyProperty = (object, property, get2) => {
       Object.defineProperty(object, property, {
         get: () => {
-          const value = get();
+          const value = get2();
           Object.defineProperty(object, property, {
             value,
             enumerable: true,
@@ -36042,18 +36043,18 @@ var require_gen_mapping_umd = __commonJS({
       function cast(set) {
         return set;
       }
-      function get(setarr, key) {
+      function get2(setarr, key) {
         return cast(setarr)._indexes[key];
       }
       function put(setarr, key) {
-        const index = get(setarr, key);
+        const index = get2(setarr, key);
         if (index !== void 0) return index;
         const { array, _indexes: indexes } = cast(setarr);
         const length = array.push(key);
         return indexes[key] = length - 1;
       }
       function remove(setarr, key) {
-        const index = get(setarr, key);
+        const index = get2(setarr, key);
         if (index === void 0) return;
         const { array, _indexes: indexes } = cast(setarr);
         for (let i = index + 1; i < array.length; i++) {
@@ -60211,7 +60212,7 @@ var require_family = __commonJS({
     });
     exports2._getKey = _getKey;
     exports2._getPattern = _getPattern;
-    exports2.get = get;
+    exports2.get = get2;
     exports2.getAllNextSiblings = getAllNextSiblings;
     exports2.getAllPrevSiblings = getAllPrevSiblings;
     exports2.getAssignmentIdentifiers = getAssignmentIdentifiers;
@@ -60442,7 +60443,7 @@ var require_family = __commonJS({
       }
       return siblings;
     }
-    function get(key, context = true) {
+    function get2(key, context = true) {
       if (context === true) context = this.context;
       const parts = key.split(".");
       if (parts.length === 1) {
@@ -65956,7 +65957,7 @@ var require_dist5 = __commonJS({
       var pathVar = getPathVar(env, platform);
       var separator = getSeparator(platform);
       var originalPath = env[pathVar];
-      return { push, unshift, get, restore };
+      return { push, unshift, get: get2, restore };
       function push() {
         for (var _len = arguments.length, paths = Array(_len), _key = 0; _key < _len; _key++) {
           paths[_key] = arguments[_key];
@@ -65969,12 +65970,12 @@ var require_dist5 = __commonJS({
         }
         return change(false, paths);
       }
-      function get() {
+      function get2() {
         return env[pathVar];
       }
       function restore() {
         env[pathVar] = originalPath;
-        return get();
+        return get2();
       }
       function change(append, paths) {
         if (!append) {
@@ -65985,7 +65986,7 @@ var require_dist5 = __commonJS({
           addExistingPath(pathArray, env[pathVar], append);
           env[pathVar] = pathArray.join(separator);
         });
-        return get();
+        return get2();
       }
     }
     function getPathArray(pathToAdd) {
@@ -86349,7 +86350,7 @@ var require_form_data = __commonJS({
     var CombinedStream = require_combined_stream();
     var util = __require("util");
     var path7 = __require("path");
-    var http = __require("http");
+    var http2 = __require("http");
     var https = __require("https");
     var parseUrl = __require("url").parse;
     var fs = __require("fs");
@@ -86624,7 +86625,7 @@ var require_form_data = __commonJS({
       if (options.protocol === "https:") {
         request2 = https.request(options);
       } else {
-        request2 = http.request(options);
+        request2 = http2.request(options);
       }
       this.getLength(function(err, length) {
         if (err && err !== "Unknown stream") {
@@ -92487,7 +92488,7 @@ function formatReport(report) {
   );
   if (inconclusive.length > 0) {
     const routeList = inconclusive.map((route) => route.route).join(",");
-    const moreCycles = Math.max(report.parameters.cycles * 2, 6);
+    const moreCycles = resolveCycles(report.parameters.cycles);
     lines.push(
       "",
       "hint: inconclusive means sustained sub-threshold growth \u2014 measure longer to resolve it:",
@@ -93238,6 +93239,7 @@ async function runLoadPhase(options) {
 import { mkdir } from "fs/promises";
 
 // src/control-client.ts
+import http from "http";
 import { z as z5 } from "zod";
 var sampleSchema = z5.object({
   gcExposed: z5.boolean(),
@@ -93253,12 +93255,70 @@ var ControlError = class extends Error {
     this.name = "ControlError";
   }
 };
-async function request(port, pathname) {
-  const response = await fetch(`http://127.0.0.1:${port}${pathname}`);
-  if (!response.ok) {
+var DEADLINES_MS = {
+  "/mem": 3e4,
+  "/gc": 18e4,
+  "/snapshot": 18e5
+};
+var DEFAULT_DEADLINE_MS = 3e4;
+function deadlineFor(pathname) {
+  const operation = pathname.split("?")[0] ?? pathname;
+  return DEADLINES_MS[operation] ?? DEFAULT_DEADLINE_MS;
+}
+function get(port, pathname, deadlineMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const settle = (outcome) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      if ("ok" in outcome) {
+        resolve(outcome.ok);
+      } else {
+        reject(outcome.error);
+      }
+    };
+    const request2 = http.get({ host: "127.0.0.1", port, path: pathname }, (response) => {
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.once(
+        "end",
+        () => settle({
+          ok: { status: response.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") }
+        })
+      );
+    });
+    const timer = setTimeout(() => {
+      settle({
+        error: new ControlError(
+          `control channel ${pathname} on port ${port} did not answer within ${Math.round(deadlineMs / 1e3)}s \u2014 the measured process is wedged, or this snapshot is larger than anything this tool has been validated on`
+        )
+      });
+      request2.destroy();
+    }, deadlineMs);
+    timer.unref();
+    request2.once(
+      "error",
+      (cause) => settle({
+        error: new ControlError(
+          `control channel ${pathname} on port ${port} did not answer (${cause.message}) \u2014 the measured process is gone or its event loop is blocked`
+        )
+      })
+    );
+  });
+}
+async function request(port, pathname, deadlineMs = deadlineFor(pathname)) {
+  const response = await get(port, pathname, deadlineMs);
+  if (response.status !== 200) {
     throw new ControlError(`control channel ${pathname} responded ${response.status}`);
   }
-  return response.json();
+  try {
+    return JSON.parse(response.body);
+  } catch {
+    throw new ControlError(`control channel ${pathname} answered with malformed JSON`);
+  }
 }
 async function requestGc(port) {
   const sample = sampleSchema.parse(await request(port, "/gc"));
@@ -93436,6 +93496,7 @@ async function waitUntilSettled(controlPort, maxIdleMs, deps) {
 var defaultDeps = {
   launch: launchInstrumented,
   load: runLoadPhase,
+  abandon: runAbandonPhase,
   sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
   readMemory: requestMemory
 };
@@ -93494,7 +93555,7 @@ async function runRitual(options, deps = defaultDeps) {
       });
       return;
     }
-    const outcome = await runAbandonPhase({
+    const outcome = await deps.abandon({
       url: `http://127.0.0.1:${app.appPort}${options.route}`,
       amount,
       connections,
@@ -93936,7 +93997,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-76DP5ADD.js");
+  const { renderHtmlReport } = await import("./html-report-X2LUOZRH.js");
   const { renderIssueMarkdown } = await import("./issue-report-HKA26WNV.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
@@ -93947,7 +94008,6 @@ 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})`;
@@ -93964,12 +94024,22 @@ async function routeReportFor(context, route, index, total) {
     if (first.status !== "measured" || context.options.resolveInconclusive === false || effectiveVerdict(first) !== "inconclusive") {
       return first;
     }
+    if (context.options.signal?.aborted === true) {
+      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"
-    });
+    try {
+      return await measureRoute(context, route, requestPath, index, {
+        cycles,
+        dirSuffix: "-resolve"
+      });
+    } catch (cause) {
+      progress(
+        `re-measurement of ${route.path} failed (${cause instanceof Error ? cause.message : String(cause)}) \u2014 keeping the first pass`
+      );
+      return first;
+    }
   } catch (cause) {
     const failure = cause instanceof Error ? cause.message : String(cause);
     progress(`failed ${label}: ${failure}`);

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

package/dist/cli.js

@@ -9,8 +9,8 @@ import {
   killActiveChildren,
   parseCliArgs,
   runMeasurement
-} from "./chunk-OJIXF7RP.js";
-import "./chunk-FFCY6POI.js";
+} from "./chunk-EQ2DV2YO.js";
+import "./chunk-2FZXZLZW.js";
 import "./chunk-XHPUAMJG.js";
 import "./chunk-6XYFBOL2.js";
 

package/dist/confidence.d.ts

@@ -45,6 +45,12 @@ export type ConfidenceInput = {
     /** Old-space cap the measured process ran under (MB). */
     maxOldSpaceMb?: number;
 };
+/**
+ * Cycles a re-measurement uses when a verdict came back `inconclusive` — the
+ * same figure the report's manual re-run hint prints. One definition, imported
+ * by both, so the tool can never recommend one number and use another.
+ */
+export declare const resolveCycles: (cycles: number) => number;
 /**
  * The verdict a route's evidence actually supports.
  *

package/dist/control-client.d.ts

@@ -1,4 +1,5 @@
 import type { HeapSample } from "./control-server.js";
+declare function request(port: number, pathname: string, deadlineMs?: number): Promise<unknown>;
 /** Forces GC in the measured process and returns a settled memory sample. */
 export declare function requestGc(port: number): Promise<HeapSample>;
 /**
@@ -11,3 +12,6 @@ export declare function requestSnapshot(port: number, name: string): Promise<{
     file: string;
     sample: HeapSample;
 }>;
+/** Test seam: the production deadlines would make a hung-server test take minutes. */
+export declare const requestWithDeadline: typeof request;
+export {};

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

package/dist/index.js

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

package/dist/ritual.d.ts

@@ -1,5 +1,6 @@
 import type { HeapSample } from "./control-server.js";
 import { launchInstrumented } from "./launcher.js";
+import { runAbandonPhase } from "./abandon-load.js";
 import { runLoadPhase } from "./load.js";
 import { type TrendResult } from "./trend.js";
 export type RitualOptions = {
@@ -103,6 +104,8 @@ export type RitualResult = {
 export type RitualDeps = {
     launch: typeof launchInstrumented;
     load: typeof runLoadPhase;
+    /** Early-disconnect load; a seam like `load`, for the same reasons. */
+    abandon: typeof runAbandonPhase;
     sleep: (ms: number) => Promise<void>;
     /** GC-free read, polled while the app is under load. */
     readMemory: (port: number) => Promise<HeapSample>;

package/dist/runner.d.ts

@@ -153,11 +153,6 @@ 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.4.1",
+  "version": "0.4.3",
   "description": "Find out whether your Next.js app actually leaks memory — how much, on which route, and whose fault it is.",
   "keywords": [
     "nextjs",