next-leak 0.1.0

package/dist/chunk-K5PZFVJH.js

@@ -0,0 +1,103 @@
+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);
+
+// src/confidence.ts
+function effectiveVerdict(report) {
+  return report.confidence.supersededVerdict ?? report.trend.verdict;
+}
+var VERDICT_WEAKENING = /* @__PURE__ */ new Set([
+  "near-threshold",
+  "spiky-growth"
+]);
+function warrantsIssueDraft(report) {
+  return effectiveVerdict(report) === "leak" && !report.confidence.warnings.some((warning) => VERDICT_WEAKENING.has(warning.code));
+}
+var DEFAULT_MIN_GROWTH = 256 * 1024;
+var LOAD_COMPLETION_FLOOR = 0.99;
+var ABANDON_EFFECTIVE_FLOOR = 0.9;
+var MID_STREAM_FLOOR = 0.1;
+var SPIKE_RATIO = 4;
+var NOISE_FLOOR_MULTIPLE = 2;
+var mb = (bytes) => `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+var pct = (part, whole) => `${(part / whole * 100).toFixed(1)}%`;
+function assessConfidence(input) {
+  const warnings = [];
+  const minGrowth = input.minGrowthPerCycle ?? DEFAULT_MIN_GROWTH;
+  const isLeak = input.trend.verdict === "leak";
+  const moving = input.settleOutcomes.filter((outcome) => outcome.status === "moving");
+  if (moving.length > 0) {
+    const phases = moving.map((outcome) => outcome.phase).join(", ");
+    warnings.push({
+      code: "unsettled",
+      detail: `the heap never held steady before sampling on ${phases} \u2014 raise --idle-ms so post-load transients finish draining`
+    });
+  }
+  const unverified = input.settleOutcomes.filter((outcome) => outcome.status === "unknown");
+  if (unverified.length > 0) {
+    const phases = unverified.map((outcome) => outcome.phase).join(", ");
+    warnings.push({
+      code: "settle-unverified",
+      detail: `the idle budget was too short to check whether the heap had settled on ${phases} \u2014 the samples may include post-load transients`
+    });
+  }
+  for (const outcome of input.loadOutcomes) {
+    if (input.abandonAfterMs !== void 0) {
+      const abandoned = outcome.abandoned ?? 0;
+      if (outcome.sent > 0 && abandoned < outcome.sent * ABANDON_EFFECTIVE_FLOOR) {
+        warnings.push({
+          code: "abandon-ineffective",
+          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`
+        });
+        continue;
+      }
+      const midStream = outcome.abandonedMidStream ?? 0;
+      if (abandoned > 0 && midStream < abandoned * MID_STREAM_FLOOR) {
+        warnings.push({
+          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`
+        });
+      }
+      continue;
+    }
+    const landed = outcome.ok2xx ?? 0;
+    if (outcome.sent > 0 && landed < outcome.sent * LOAD_COMPLETION_FLOOR) {
+      warnings.push({
+        code: "load-incomplete",
+        detail: `${outcome.phase} landed ${landed} of ${outcome.sent} requests (${pct(landed, outcome.sent)}) \u2014 the route saw less traffic than reported`
+      });
+    }
+  }
+  const deltas = input.trend.deltas;
+  if ((isLeak || input.trend.verdict === "inconclusive") && deltas.length >= 2) {
+    const positive = deltas.filter((delta) => delta > 0);
+    if (positive.length === deltas.length) {
+      const smallest = Math.min(...positive);
+      const largest = Math.max(...positive);
+      if (largest > smallest * SPIKE_RATIO) {
+        warnings.push({
+          code: "spiky-growth",
+          detail: `one cycle grew ${mb(largest)} and another ${mb(smallest)} \u2014 the mean of ${mb(input.trend.growthPerCycle)}/cycle summarizes an uneven series; measure more cycles before quoting it`
+        });
+      }
+    }
+  }
+  if (isLeak && input.trend.growthPerCycle < minGrowth * NOISE_FLOOR_MULTIPLE) {
+    warnings.push({
+      code: "near-threshold",
+      detail: `growth of ${mb(input.trend.growthPerCycle)}/cycle barely clears the ${mb(minGrowth)} threshold \u2014 raise --load-requests so the signal outgrows the noise`
+    });
+  }
+  const neverSettled = input.settleOutcomes.length > 0 && moving.length === input.settleOutcomes.length;
+  const abandonedNothing = input.abandonAfterMs !== void 0 && input.loadOutcomes.length > 0 && input.loadOutcomes.every((outcome) => (outcome.abandoned ?? 0) === 0);
+  const invalid = isLeak && (neverSettled || abandonedNothing);
+  return {
+    level: warnings.length === 0 ? "high" : "low",
+    warnings,
+    ...invalid && { supersededVerdict: "inconclusive" }
+  };
+}
+
+export {
+  effectiveVerdict,
+  warrantsIssueDraft,
+  assessConfidence
+};

package/dist/chunk-OSZ6ND6E.js

@@ -0,0 +1,38 @@
+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);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};