next-leak 0.13.1 → 0.13.2

package/README.md

@@ -267,7 +267,7 @@ separates them, because each one has a different fix:
   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 **when the evidence plainly supports the verdict** — a `leak` carrying low-confidence warnings (growth barely over the threshold, one cycle dominating the mean, too few cycles for its size) gets the verdict but no draft, because a draft is written to be pasted into someone else's tracker. If the leak is app-owned, the draft tells you **not** to file it upstream.
+- **`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. The culprit is whoever holds the most of the growth, each byte counted once even when a container and what it holds are both reported; when more of it is unattributed than any owner holds, no culprit is named rather than a smaller one. An `ISSUE-<route>.md` draft is generated **when the evidence plainly supports the verdict** — a `leak` carrying low-confidence warnings (growth barely over the threshold, one cycle dominating the mean, too few cycles for its size) gets the verdict but no draft, because a draft is written to be pasted into someone else's tracker. If the leak is app-owned, the draft tells you **not** to file it upstream.
 - **`saturating`** — every cycle grew, but by less than the one before, and the
   last by less than half the first. That is the shape of a bounded store
   running out of new keys, not of memory going missing. It matters because the

package/dist/attribution.d.ts

@@ -32,7 +32,13 @@ export type AttributedDiff = {
 };
 /**
  * Attributes every finding and derives the route-level verdict: the
- * owner+source group holding the most attributed retained bytes wins;
- * with nothing attributed the route stays `unattributed`.
+ * owner+source group holding the most exclusive retained bytes wins.
+ *
+ * What nothing could attribute competes as a group of its own. When it is the
+ * largest, the route stays `unattributed`: naming a smaller store as the
+ * culprit misleads, and an `app` or `dependency` culprit is what tells the
+ * issue draft not to file upstream. On the vercel/next.js#99335 long run the
+ * unnamed 19.84 MB map lost to a 9.31 MB fsChecker LRU reported at a
+ * dominance of 1, because unattributed bytes were left out of the share.
  */
 export declare function attributeDiff(diff: HeapDiff, registry: ModuleRegistry): AttributedDiff;

package/dist/{chunk-GBRBWUZZ.js → chunk-5OI4MUND.js}

@@ -92646,6 +92646,12 @@ var FRAMEWORK_CHAIN_MARKERS = [
   ["NextNodeServer", "Next server"],
   ["AppPageRouteModule", "App Router page module"],
   ["AppRouteRouteModule", "App Router route handler module"],
+  // Ahead of the incremental cache, which holds it: a chain reaching through
+  // both should name the store that grows. On the vercel/next.js#99335
+  // reproduction its unbounded Map was the largest finding (19.84 MB over
+  // 240,000 requests) and, unnamed, lost the route to the bounded fsChecker
+  // LRU at 9.31 MB with a reported dominance of 1.
+  ["SharedCacheControls", "shared cache controls"],
   ["incrementalCache", "incremental cache"],
   ["IncrementalCache", "incremental cache"],
   ["ReactServer", "React Server Components renderer"],
@@ -92677,17 +92683,60 @@ function attributeFinding(finding, registry) {
   }
   return best;
 }
+function enclosingIndexes(all) {
+  const indexById = /* @__PURE__ */ new Map();
+  for (const [index, finding] of all.entries()) {
+    if (finding.nodeId !== void 0) {
+      indexById.set(finding.nodeId, index);
+    }
+  }
+  return all.map(
+    (finding) => finding.containedIn === void 0 ? void 0 : indexById.get(finding.containedIn)
+  );
+}
+function inheritOwners(own, enclosing) {
+  return own.map((attribution, index) => {
+    let current = enclosing[index];
+    for (let hops = 0; attribution.owner === "unattributed" && hops < own.length; hops += 1) {
+      if (current === void 0) {
+        break;
+      }
+      const ancestor = own[current];
+      if (ancestor !== void 0 && ancestor.owner !== "unattributed") {
+        return ancestor;
+      }
+      current = enclosing[current];
+    }
+    return attribution;
+  });
+}
+function exclusiveBytes(all, enclosing) {
+  const bytes = all.map((finding) => finding.retainedBytes);
+  for (const [index, parent] of enclosing.entries()) {
+    if (parent !== void 0) {
+      bytes[parent] = (bytes[parent] ?? 0) - (all[index]?.retainedBytes ?? 0);
+    }
+  }
+  return bytes.map((value) => Math.max(0, value));
+}
 function attributeDiff(diff, registry) {
   const all = [...diff.grownNodes, ...diff.newNodes];
-  const findings = all.map((finding) => attributeFinding(finding, registry));
+  const enclosing = enclosingIndexes(all);
+  const findings = inheritOwners(
+    all.map((finding) => attributeFinding(finding, registry)),
+    enclosing
+  );
+  const exclusive = exclusiveBytes(all, enclosing);
   const byGroup = /* @__PURE__ */ new Map();
-  let attributedBytes = 0;
+  let unattributedBytes = 0;
+  let totalBytes = 0;
   for (const [index, attribution] of findings.entries()) {
+    const bytes = exclusive[index] ?? 0;
+    totalBytes += bytes;
     if (attribution.owner === "unattributed") {
+      unattributedBytes += bytes;
       continue;
     }
-    const bytes = all[index]?.retainedBytes ?? 0;
-    attributedBytes += bytes;
     const key = `${attribution.owner}|${attribution.source ?? ""}|${attribution.packageName ?? ""}`;
     const group = byGroup.get(key) ?? { attribution, bytes: 0 };
     group.bytes += bytes;
@@ -92699,7 +92748,7 @@ function attributeDiff(diff, registry) {
       winner = group;
     }
   }
-  const route = winner === null || attributedBytes === 0 ? { ...UNATTRIBUTED, dominance: 0 } : { ...winner.attribution, dominance: winner.bytes / attributedBytes };
+  const route = winner === null || winner.bytes === 0 || unattributedBytes > winner.bytes ? { ...UNATTRIBUTED, dominance: 0 } : { ...winner.attribution, dominance: winner.bytes / totalBytes };
   return { findings, route };
 }
 
@@ -92805,12 +92854,16 @@ function diffAgainstBaseline(baseline, after, options = {}) {
       if (node.retainedSize >= resolved.newThresholdBytes) {
         const chain = walkChain(node, resolved.chainDepth);
         fresh.push({
-          kind: "new",
-          nodeType: node.type,
-          name: truncateLabel(node.name),
-          retainedBytes: node.retainedSize,
-          retainerChain: chain.parts.join(" <- "),
-          moduleIds: collectModuleIds(chain.nodes)
+          node,
+          finding: {
+            kind: "new",
+            nodeType: node.type,
+            name: truncateLabel(node.name),
+            retainedBytes: node.retainedSize,
+            retainerChain: chain.parts.join(" <- "),
+            moduleIds: collectModuleIds(chain.nodes),
+            nodeId: node.id
+          }
         });
       }
       return;
@@ -92819,12 +92872,16 @@ function diffAgainstBaseline(baseline, after, options = {}) {
     if (before !== void 0 && node.retainedSize - before >= resolved.grownThresholdBytes) {
       const chain = walkChain(node, resolved.chainDepth);
       grown.push({
-        kind: "grown",
-        nodeType: node.type,
-        name: truncateLabel(node.name),
-        retainedBytes: node.retainedSize - before,
-        retainerChain: chain.parts.join(" <- "),
-        moduleIds: collectModuleIds(chain.nodes)
+        node,
+        finding: {
+          kind: "grown",
+          nodeType: node.type,
+          name: truncateLabel(node.name),
+          retainedBytes: node.retainedSize - before,
+          retainerChain: chain.parts.join(" <- "),
+          moduleIds: collectModuleIds(chain.nodes),
+          nodeId: node.id
+        }
       });
     }
   });
@@ -92837,14 +92894,36 @@ function diffAgainstBaseline(baseline, after, options = {}) {
     }
   }
   typeDeltas.sort((a, b) => b.deltaBytes - a.deltaBytes);
-  grown.sort((a, b) => b.retainedBytes - a.retainedBytes);
-  fresh.sort((a, b) => b.retainedBytes - a.retainedBytes);
+  const bySize = (a, b) => b.finding.retainedBytes - a.finding.retainedBytes;
+  const keptGrown = grown.sort(bySize).slice(0, resolved.maxFindings);
+  const keptFresh = fresh.sort(bySize).slice(0, resolved.maxFindings);
+  linkContainment([...keptGrown, ...keptFresh]);
   return {
     typeDeltas,
-    grownNodes: grown.slice(0, resolved.maxFindings),
-    newNodes: fresh.slice(0, resolved.maxFindings)
+    grownNodes: keptGrown.map((candidate) => candidate.finding),
+    newNodes: keptFresh.map((candidate) => candidate.finding)
   };
 }
+var MAX_DOMINATOR_DEPTH = 1e4;
+function linkContainment(kept) {
+  const keptIds = new Set(kept.map((candidate) => candidate.node.id));
+  for (const candidate of kept) {
+    let current = candidate.node.dominatorNode;
+    for (let depth = 0; depth < MAX_DOMINATOR_DEPTH && current; depth += 1) {
+      if (current.id === candidate.node.id) {
+        break;
+      }
+      if (keptIds.has(current.id)) {
+        candidate.finding.containedIn = current.id;
+        break;
+      }
+      if (current.dominatorNode?.id === current.id) {
+        break;
+      }
+      current = current.dominatorNode;
+    }
+  }
+}
 var SnapshotError = class extends Error {
   /**
    * Bytes that had to fit in one string, when that is why the snapshot was

package/dist/cli.js

@@ -23,7 +23,7 @@ import {
   unregisterChild,
   validateTarget,
   writtenConfigNote
-} from "./chunk-GBRBWUZZ.js";
+} from "./chunk-5OI4MUND.js";
 import "./chunk-IKWF7SSB.js";
 import {
   classifyTrend

package/dist/heap-diff.d.ts

@@ -18,6 +18,8 @@ export type HeapNodeLike = {
     references?: Array<{
         name_or_index: string | number;
     }>;
+    /** Immediate dominator, as memlab computes it; absent in most fixtures. */
+    dominatorNode?: HeapNodeLike | null;
 };
 export type HeapLike = {
     nodes: {
@@ -53,6 +55,15 @@ export type NodeFinding = {
     retainerChain: string;
     /** Bundler module ids seen along the chain (needs `resolveNumeric`). */
     moduleIds: number[];
+    /** Snapshot node id. Absent in run.json files written before it existed. */
+    nodeId?: number;
+    /**
+     * `nodeId` of the nearest other finding that dominates this one, when there
+     * is one. A grown container's delta already includes everything it
+     * dominates, so without this the same bytes are counted once per level —
+     * see `attributeDiff`.
+     */
+    containedIn?: number;
 };
 export type HeapDiff = {
     typeDeltas: TypeDelta[];

package/dist/index.js

@@ -41,7 +41,7 @@ import {
   sourceIndexAt,
   summarizeBaseline,
   validateTarget
-} from "./chunk-GBRBWUZZ.js";
+} from "./chunk-5OI4MUND.js";
 import "./chunk-IKWF7SSB.js";
 import {
   renderHtmlReport

package/package.json

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