next-leak 0.13.0 → 0.13.2

package/README.md

@@ -193,7 +193,10 @@ entry, so the route reads as flat whatever it retains, and that false negative
 lands on exactly the leaks being reported now (`use cache`, `cacheComponents`
 and ISR all key on the params). If your app answers 404 for params it never
 prerendered, the run says so through its non-2xx count; drop the marker then.
-When a run skips a route it prints the same fragment.
+When the build prerendered nothing for a route, the value is `REPLACE-ME-{n}`:
+put the shape of a real value in place of `REPLACE-ME` and keep the `-{n}`, or
+the run measures a single cache entry. When a run skips a route it prints the
+same fragment.
 
 ```json
 ```
@@ -240,7 +243,7 @@ separates them, because each one has a different fix:
 | One-time warm-up growth (JIT, lazy caches) | `stable` | The first cycle is excluded from the verdict; warm-up flattens, leaks keep climbing |
 | A route that is expensive, not leaky | `failed` under load it cannot sustain, flat once concurrency fits | Real leaks survive forced GC at any concurrency; saturation disappears when load drops |
 | Growth that pauses and resumes (stepwise) | `leak` | A healthy route gives back 20-30% of its growth; a stepwise leak gives back nothing |
-| A cache filling up under the load that measures it | `saturating` | A bounded store grows by less each cycle as new keys get rarer; a leak does not decelerate |
+| A cache filling up under the load that measures it | `saturating` | A bounded store grows by less each cycle as new keys get rarer; a leak does not decelerate. A bend that lands on a steady rate above the gate is a leak under the fill, and stays `leak` |
 | Memory a forced GC reclaims that production never reclaims in time | `pressure` | Every verdict sample is post-GC; the peaks are sampled under load, and a ceiling every settled cycle comes back to is a regime, not an episode |
 | Native/buffer memory with a flat JS heap | `leak (external)` or an explicit RSS note | Heap, `external` and RSS are sampled and judged separately |
 | A leak in your code vs a dependency vs Next itself | `culprit: src/app/x/page.tsx (your code)` — or the package, or framework internals | Retainer chains mapped through the build's source maps |
@@ -264,14 +267,22 @@ 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
   alternative was calling it a leak: a `use cache` route measured on Next
   16.3.3 came out at +603 MB per 1000 requests that was entirely the cache
   storing what it had been asked to store — the same route dropped to +88 MB
-  once the payload was removed. Because the shape requires every cycle to clear
+  once the payload was removed. The bend has to head for zero, though: a store
+  filling on top of a leak bends too, and then holds the leak's rate for as
+  long as the load runs. So when the last third of the window (at least three
+  cycles) sits at one steady rate at or above the gate, within 1.5x of itself,
+  the route stays `leak`. Measured on the reproduction for
+  [#99335](https://github.com/vercel/next.js/issues/99335), an ISR route
+  keeping every new path's cache control in an unbounded map: it closed on four
+  cycles of ~2.2 MB, twice the gate, and used to be called `saturating`, with
+  no issue draft. Because the shape requires every cycle to clear
   the growth gate, a decelerating curve always ends the window still growing,
   so where it settles is outside what was measured: these routes are
   **measured again** with twice the cycles, like `inconclusive` ones. No issue
@@ -388,7 +399,11 @@ A route with a revalidation period serves its cache unless the request carries
 the build's own `x-prerender-revalidate` header. Measured on that same app: the
 identical run reports `leak` with the header and `stable` without it. next-leak
 reads `previewModeId` from `.next/prerender-manifest.json` and drives those
-routes itself; a header you set in `next-leak.config.json` wins untouched. When
+routes itself; a header you set in `next-leak.config.json` wins untouched. A
+dynamic template with nothing prerendered (`generateStaticParams()` returning
+`[]`) counts too: the build records no period for it, but its blocking fallback
+caches every new param on first request, so `{n}` fills that cache while it is
+measured and the report says so. When
 the manifest cannot supply one, the route is reported `not exercised` with no
 verdict, because a flat curve measured against a static cache says nothing about
 the app.

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-UKWFONEI.js → chunk-5OI4MUND.js}

@@ -11,7 +11,7 @@ import {
   resolveCycles,
   warrantsIssueDraft,
   withdrawnByDisagreement
-} from "./chunk-QUFL2FXU.js";
+} from "./chunk-GU7IJUNY.js";
 import {
   assessPeakPressure,
   assessPressureVerdict,
@@ -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
@@ -93235,6 +93314,10 @@ var prerenderManifestSchema = z2.looseObject({
       srcRoute: z2.string().nullable().optional()
     })
   ).optional(),
+  // Read only for `fallback`, and left untyped: its shape has changed across
+  // Next versions (`null`, `false`, an HTML path, a PPR shell), and a template
+  // the tool cannot classify must not fail the whole manifest.
+  dynamicRoutes: z2.record(z2.string(), z2.looseObject({ fallback: z2.unknown().optional() })).optional(),
   preview: z2.looseObject({ previewModeId: z2.string() }).optional()
 });
 var INTERNAL_PATHS = /* @__PURE__ */ new Set(["/_global-error", "/_not-found"]);
@@ -94892,7 +94975,7 @@ function renderConfigSkeleton(routeTemplates, manifest = void 0) {
     const values = {};
     for (const segment of segments) {
       const prerendered = sampled?.[segment.name];
-      values[segment.name] = prerendered === void 0 ? PLACEHOLDER : varyingValueFrom(prerendered);
+      values[segment.name] = varyingValueFrom(prerendered ?? PLACEHOLDER);
     }
     routes[template] = values;
   }
@@ -94901,6 +94984,12 @@ function renderConfigSkeleton(routeTemplates, manifest = void 0) {
 function hasPlaceholders(skeleton) {
   return skeleton.includes(PLACEHOLDER);
 }
+function writtenConfigNote(skeleton) {
+  if (hasPlaceholders(skeleton)) {
+    return `replace each ${PLACEHOLDER} with the shape of a value that exists in your app, and keep the \`-{n}\` after it: a fixed value measures one cache entry and reads as flat whatever the route retains`;
+  }
+  return "`{n}` gives every request a different value: a prerendered one serves the warm cache and reads as flat whatever the route retains. Use `{n%200}` to revisit a fixed set of keys, and drop the marker only if the app 404s on params it never prerendered.";
+}
 
 // src/unreclaimed-retention.ts
 var MB = 1024 * 1024;
@@ -94998,10 +95087,10 @@ function ownerLabel(attribution) {
   }
 }
 function revalidationLines(route) {
-  if (route.revalidatedEverySeconds === void 0) {
+  if (route.servedFromIsrCache !== true) {
     return [];
   }
-  const every = `revalidates every ${route.revalidatedEverySeconds}s`;
+  const every = route.revalidatedEverySeconds === void 0 ? "caches each new key on its first request" : `revalidates every ${route.revalidatedEverySeconds}s`;
   return route.revalidationDriven === true ? [
     `      driven through ISR revalidation (${every}; without it the load would serve the cache) \u2014 this is Next's revalidation path, so a leak that only happens on the path your users take is not in this number`
   ] : [
@@ -95032,7 +95121,7 @@ function cacheLines(route) {
     lines.push(
       `      the load served keys this route had never cached, so some of this growth is cache residency; bound it with {n%N} in next-leak.config.json`
     );
-    if (route.revalidatedEverySeconds !== void 0) {
+    if (route.servedFromIsrCache === true) {
       lines.push(
         `      on this route {n%N} does not isolate that: a bounded key set is served from the ISR cache, so the run would drive revalidation and measure a different path. Compare the two runs rather than trusting either number alone`
       );
@@ -95173,7 +95262,7 @@ function skippedGuidanceLines(report) {
   if (skeleton === null) {
     return [];
   }
-  const editing = hasPlaceholders(skeleton) ? ` Replace each ${"REPLACE-ME"} with a value that exists in your app.` : ` The shapes come from paths your build already prerendered; \`{n}\` makes every request use a different one, because reusing a prerendered value serves the warm cache and reads as flat whatever the route retains. Use \`{n%200}\` instead to revisit a fixed set of 200 keys, and drop the marker only if the app 404s on params it never prerendered.`;
+  const editing = hasPlaceholders(skeleton) ? ` Replace each ${"REPLACE-ME"} with the shape of a value that exists in your app, and keep the \`-{n}\` after it: a fixed value measures one cache entry and reads as flat whatever the route retains.` : ` The shapes come from paths your build already prerendered; \`{n}\` makes every request use a different one, because reusing a prerendered value serves the warm cache and reads as flat whatever the route retains. Use \`{n%200}\` instead to revisit a fixed set of 200 keys, and drop the marker only if the app 404s on params it never prerendered.`;
   return [
     "",
     `${needConfig.length} route(s) need sample params. Write this to next-leak.config.json in the app directory:${editing}`,
@@ -95401,8 +95490,11 @@ function revalidateSecondsFor(manifest, route) {
   }
   return null;
 }
+function cachesOnDemand(manifest, route) {
+  return manifest?.dynamicRoutes?.[route]?.fallback === null;
+}
 function revalidates(manifest, route) {
-  return revalidateSecondsFor(manifest, route) !== null;
+  return revalidateSecondsFor(manifest, route) !== null || cachesOnDemand(manifest, route);
 }
 function planRevalidation(manifest, route, userHeaders, requestPath) {
   const userSupplied = Object.keys(userHeaders ?? {}).some(
@@ -95419,9 +95511,11 @@ function planRevalidation(manifest, route, userHeaders, requestPath) {
   }
   const previewModeId = manifest?.preview?.previewModeId;
   if (previewModeId === void 0 || previewModeId === "") {
+    const seconds = revalidateSecondsFor(manifest, route);
+    const cached = seconds === null ? "is served from the ISR cache" : `revalidates every ${seconds}s`;
     return {
       kind: "cannot-drive",
-      reason: `revalidates every ${revalidateSecondsFor(manifest, route)}s, but the build's prerender-manifest.json carries no previewModeId \u2014 load would serve the cache and measure nothing. Set "${REVALIDATE_HEADER}" in next-leak.config.json to drive it.`
+      reason: `${cached}, but the build's prerender-manifest.json carries no previewModeId \u2014 load would serve the cache and measure nothing. Set "${REVALIDATE_HEADER}" in next-leak.config.json to drive it.`
     };
   }
   return { kind: "drive", headers: { [REVALIDATE_HEADER]: previewModeId } };
@@ -95539,6 +95633,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   const { deps, options, target, workDir, routeConfig, registry, nextVersion, progress } = context;
   const plan = planRevalidation(target.prerender, route.path, routeConfig.headers, requestPath);
   const revalidateSeconds = revalidateSecondsFor(target.prerender, route.path);
+  const servedFromIsrCache = revalidates(target.prerender, route.path);
   const bounded = boundedMarkerOf(requestPath);
   const driven = plan.kind === "drive" ? plan.headers : {};
   const cacheDriven = plan.kind === "no-cache-to-drive" || plan.kind === "drive" && bounded === null;
@@ -95581,7 +95676,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     warmupRequests: options.warmupRequests ?? RITUAL_DEFAULTS.warmupRequests,
     // Decides whether the cache-residency remedy exists on this route: bounding
     // the keys of an ISR route hands the requests back to the cache.
-    revalidatesFromCache: revalidateSeconds !== null,
+    revalidatesFromCache: servedFromIsrCache,
     ...routeConfig.abandonAfterMs !== void 0 && {
       abandonAfterMs: routeConfig.abandonAfterMs
     },
@@ -95624,6 +95719,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
     memorySamples: result.memorySamples,
     peaks: result.peaks,
     ...revalidateSeconds !== null && { revalidatedEverySeconds: revalidateSeconds },
+    ...servedFromIsrCache && { servedFromIsrCache: true },
     ...plan.kind === "drive" && { revalidationDriven: true },
     ...bounded !== null && { keyCardinality: bounded.bound },
     unreclaimedSamples: result.unreclaimedSamples,
@@ -95651,7 +95747,7 @@ async function measureRoute(context, route, requestPath, index, pass = void 0) {
   };
 }
 async function writeEvidenceBundle(report, workDir) {
-  const { renderHtmlReport } = await import("./html-report-ZXDEJ6X5.js");
+  const { renderHtmlReport } = await import("./html-report-VNTPHLO3.js");
   const { renderIssueMarkdown } = await import("./issue-report-4RW5YOT3.js");
   for (const route of report.routes) {
     if (route.status === "measured" && warrantsIssueDraft(route)) {
@@ -95948,7 +96044,7 @@ export {
   runRitual,
   runSelfCheck,
   renderConfigSkeleton,
-  hasPlaceholders,
+  writtenConfigNote,
   formatReport,
   captureEnvironment,
   loadSignatures,

package/dist/{chunk-QUFL2FXU.js → chunk-GU7IJUNY.js}

@@ -11,6 +11,8 @@ var STEPWISE_MAX_DRAWDOWN_RATIO = 0.1;
 var ACQUITTAL_MAX_GROWTH_MULTIPLE = 8;
 var SATURATION_MIN_CYCLES = 3;
 var SATURATION_MAX_FINAL_RATIO = 0.5;
+var SETTLED_TAIL_MIN_CYCLES = 3;
+var SETTLED_TAIL_MAX_SPREAD = 1.5;
 function maxDrawdown(samples) {
   let peak = samples[1] ?? 0;
   let worst = 0;
@@ -46,8 +48,20 @@ function isSaturating(deltas, minGrowth) {
   if (last > first * SATURATION_MAX_FINAL_RATIO) {
     return false;
   }
+  if (hasSettledAboveGate(deltas, minGrowth)) {
+    return false;
+  }
   return isHeadingDown(deltas);
 }
+function hasSettledAboveGate(deltas, minGrowth) {
+  const size = Math.max(SETTLED_TAIL_MIN_CYCLES, Math.ceil(deltas.length / 3));
+  const tail = deltas.slice(-size);
+  const smallest = Math.min(...tail);
+  if (smallest < minGrowth) {
+    return false;
+  }
+  return Math.max(...tail) <= smallest * SETTLED_TAIL_MAX_SPREAD;
+}
 function hasArrivedWithoutResuming(deltas, minGrowth) {
   const stop = deltas.findIndex((delta) => delta <= 0);
   if (stop === -1) {

package/dist/{chunk-UOAW5UA5.js → chunk-QNNVRQ4L.js}

@@ -2,7 +2,7 @@ import { createRequire as __nextLeakCreateRequire } from 'node:module';import {
 import {
   effectiveVerdict,
   withdrawnByDisagreement
-} from "./chunk-QUFL2FXU.js";
+} from "./chunk-GU7IJUNY.js";
 import {
   assessPeakPressure,
   describePeakPressure,

package/dist/cli.js

@@ -12,7 +12,6 @@ import {
   extractModuleRegistry,
   formatReport,
   freePort,
-  hasPlaceholders,
   helpText,
   killActiveChildren,
   parseCliArgs,
@@ -22,12 +21,13 @@ import {
   runSelfCheck,
   terminalSafe,
   unregisterChild,
-  validateTarget
-} from "./chunk-UKWFONEI.js";
+  validateTarget,
+  writtenConfigNote
+} from "./chunk-5OI4MUND.js";
 import "./chunk-IKWF7SSB.js";
 import {
   classifyTrend
-} from "./chunk-QUFL2FXU.js";
+} from "./chunk-GU7IJUNY.js";
 import "./chunk-VTKOO3YJ.js";
 import "./chunk-6XYFBOL2.js";
 
@@ -907,13 +907,7 @@ ${skeleton}`
     return;
   }
   console.log(`wrote ${file}`);
-  if (hasPlaceholders(skeleton)) {
-    console.log("replace each REPLACE-ME with a value that exists in your app");
-  } else {
-    console.log(
-      "`{n}` gives every request a different value: a prerendered one serves the warm cache and reads as flat whatever the route retains. Use `{n%200}` to revisit a fixed set of keys, and drop the marker only if the app 404s on params it never prerendered."
-    );
-  }
+  console.log(writtenConfigNote(skeleton));
 }
 async function main() {
   const parsed = parseCliArgs(process.argv.slice(2));

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/{html-report-ZXDEJ6X5.js → html-report-VNTPHLO3.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-UOAW5UA5.js";
-import "./chunk-QUFL2FXU.js";
+} from "./chunk-QNNVRQ4L.js";
+import "./chunk-GU7IJUNY.js";
 import "./chunk-VTKOO3YJ.js";
 import "./chunk-6XYFBOL2.js";
 export {

package/dist/index.js

@@ -41,14 +41,14 @@ import {
   sourceIndexAt,
   summarizeBaseline,
   validateTarget
-} from "./chunk-UKWFONEI.js";
+} from "./chunk-5OI4MUND.js";
 import "./chunk-IKWF7SSB.js";
 import {
   renderHtmlReport
-} from "./chunk-UOAW5UA5.js";
+} from "./chunk-QNNVRQ4L.js";
 import {
   classifyTrend
-} from "./chunk-QUFL2FXU.js";
+} from "./chunk-GU7IJUNY.js";
 import {
   renderIssueMarkdown
 } from "./chunk-FJVY5MKV.js";

package/dist/manifests.d.ts

@@ -34,6 +34,9 @@ export declare const prerenderManifestSchema: z.ZodObject<{
         initialRevalidateSeconds: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>>;
         srcRoute: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$loose>>>;
+    dynamicRoutes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fallback: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
     preview: z.ZodOptional<z.ZodObject<{
         previewModeId: z.ZodString;
     }, z.core.$loose>>;

package/dist/route-guidance.d.ts

@@ -38,3 +38,5 @@ export declare function sampleValuesFromManifest(manifest: PrerenderManifest | u
 export declare function renderConfigSkeleton(routeTemplates: readonly string[], manifest?: PrerenderManifest | undefined): string | null;
 /** Whether a rendered skeleton still needs the user to fill anything in. */
 export declare function hasPlaceholders(skeleton: string): boolean;
+/** What `--write-config` prints after writing a skeleton: how to edit it. */
+export declare function writtenConfigNote(skeleton: string): string;

package/dist/runner.d.ts

@@ -113,6 +113,12 @@ export type RouteReport = {
      * cache and one measured against a re-render are different experiments.
      */
     revalidatedEverySeconds?: number;
+    /**
+     * Set on every route served from the ISR cache, including a dynamic
+     * template that caches each new key with no prerendered entry to carry
+     * its period — the period is then absent, but the cache is in play.
+     */
+    servedFromIsrCache?: true;
     /**
      * Whether the load carried the build's own revalidation header. Set apart
      * from the period because the two answer different questions: the period

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-leak",
-  "version": "0.13.0",
+  "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",