next-leak 0.4.2 → 0.5.0

package/dist/{chunk-YDMJVVWG.js → chunk-IDSNTUKC.js}

@@ -3657,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,
@@ -36043,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++) {
@@ -60212,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;
@@ -60443,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) {
@@ -65957,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];
@@ -65970,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) {
@@ -65986,7 +65986,7 @@ var require_dist5 = __commonJS({
           addExistingPath(pathArray, env[pathVar], append);
           env[pathVar] = pathArray.join(separator);
         });
-        return get();
+        return get2();
       }
     }
     function getPathArray(pathToAdd) {
@@ -86350,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");
@@ -86625,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") {
@@ -93208,9 +93208,6 @@ async function runLoadPhase(options) {
     amount: options.amount,
     connections: options.connections,
     ...options.headers !== void 0 && { headers: options.headers },
-    ...options.abandonAfterMs !== void 0 && {
-      timeout: Math.max(Math.ceil(options.abandonAfterMs / 1e3), 1)
-    },
     ...unique && { idReplacement: true }
   });
   const result = {
@@ -93221,8 +93218,7 @@ async function runLoadPhase(options) {
     timeouts: raw.timeouts,
     durationSeconds: raw.duration
   };
-  const expected = options.abandonAfterMs === void 0 ? 0 : result.timeouts;
-  const failures = Math.max(options.amount - result.ok2xx - expected, 0);
+  const failures = Math.max(options.amount - result.ok2xx, 0);
   const ratio = options.amount === 0 ? 0 : failures / options.amount;
   if (ratio > (options.maxErrorRatio ?? 0.01)) {
     const unanswered = failures - result.non2xx - result.errors - result.timeouts;
@@ -93239,6 +93235,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(),
@@ -93254,19 +93251,70 @@ var ControlError = class extends Error {
     this.name = "ControlError";
   }
 };
-async function request(port, pathname) {
-  let response;
-  try {
-    response = await fetch(`http://127.0.0.1:${port}${pathname}`);
-  } catch (cause) {
-    throw new ControlError(
-      `control channel ${pathname} on port ${port} did not answer (${cause instanceof Error ? cause.message : String(cause)}) \u2014 the measured process is gone or its event loop is blocked`
+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`
+        )
+      })
     );
-  }
-  if (!response.ok) {
+  });
+}
+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"));
@@ -93444,6 +93492,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
 };
@@ -93502,7 +93551,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,

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
   killActiveChildren,
   parseCliArgs,
   runMeasurement
-} from "./chunk-YDMJVVWG.js";
+} from "./chunk-IDSNTUKC.js";
 import "./chunk-2FZXZLZW.js";
 import "./chunk-XHPUAMJG.js";
 import "./chunk-6XYFBOL2.js";

package/dist/control-client.d.ts

@@ -1,4 +1,6 @@
 import type { HeapSample } from "./control-server.js";
+declare function deadlineFor(pathname: string): number;
+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 +13,13 @@ 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;
+/**
+ * Test seam for the deadline table itself. A mutation run showed the mapping
+ * could quietly send `/snapshot?name=x` to the 30-second default instead of
+ * its 30-minute bound — reinstating, from the inside, the exact ceiling this
+ * client exists to remove.
+ */
+export declare const deadlineForOperation: typeof deadlineFor;
+export {};

package/dist/index.js

@@ -39,7 +39,7 @@ import {
   sourceIndexAt,
   summarizeBaseline,
   validateTarget
-} from "./chunk-YDMJVVWG.js";
+} from "./chunk-IDSNTUKC.js";
 import {
   renderHtmlReport
 } from "./chunk-NNDGXIGQ.js";

package/dist/load.d.ts

@@ -5,12 +5,6 @@ export type LoadPhaseOptions = {
     connections: number;
     /** Sent with every request (compression, cookies, auth). */
     headers?: Record<string, string>;
-    /**
-     * Give up on each request after this many milliseconds, emulating clients
-     * that disconnect before the response arrives. Abandoned requests are
-     * expected, so they do not count against the error budget.
-     */
-    abandonAfterMs?: number;
     /**
      * Maximum tolerated ratio of non-2xx responses plus socket errors before
      * the phase fails. A route that errors under load must fail the run, not

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/package.json

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