From 63e8630fcb5cebe55e65b8870ae3c5781d1282ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marc-Andr=C3=A9=20Bombeck?= <mbombeck@gmail.com>
Date: Thu, 22 Oct 2026 06:41:15 +0200
Subject: [PATCH] perf(bench): profile a production boot and the idle heap

scripts/bench/boot-profile.ts starts the production build with every role
under the production heap ceiling against the seeded benchmark database,
and records the time to a healthy probe and to a ready worker, every
event-loop stall the process logs, the heap lines, the full collections
from --trace-gc, the main thread's busy stretches during the boot with
their self time by source module (resolved through the chunk source maps),
and one heap snapshot after an idle wait, summarised by node type,
constructor, largest strings and largest retained subtrees.

The baseline on the current runtime: a 753 ms busy stretch at 0.7 s, most
of it the worker graph, and a live heap of 164 to 172 MB after five idle
minutes, of which the query compiler holds about 50 MB and the eight
locale catalogs about 33 MB (32 parsed copies and two 9.7 MB chunk
sources).
---
 scripts/bench/boot-profile.ts                 |  398 +++++
 scripts/bench/profile-analyze.ts              |  599 ++++++++
 .../bench/results/v1.45.0-before-boot.json    | 1351 +++++++++++++++++
 scripts/bench/results/v1.45.0-before-boot.md  |  221 +++
 4 files changed, 2569 insertions(+)
 create mode 100644 scripts/bench/boot-profile.ts
 create mode 100644 scripts/bench/profile-analyze.ts
 create mode 100644 scripts/bench/results/v1.45.0-before-boot.json
 create mode 100644 scripts/bench/results/v1.45.0-before-boot.md

diff --git a/scripts/bench/boot-profile.ts b/scripts/bench/boot-profile.ts
new file mode 100644
index 000000000..e2e499bfe
--- /dev/null
+++ b/scripts/bench/boot-profile.ts
@@ -0,0 +1,398 @@
+/**
+ * Boot and idle-memory profile of the production build.
+ *
+ *   DATABASE_URL=postgresql://… API_TOKEN_HMAC_KEY=… ENCRYPTION_KEYS=… \
+ *   ENCRYPTION_ACTIVE_KEY_ID=… pnpm dlx tsx scripts/bench/boot-profile.ts \
+ *     [--idle-seconds 300] [--heap-mb 792] [--port 3101] \
+ *     [--no-snapshot] [--no-cpu-prof] [--out scripts/bench/results/<label>-boot]
+ *
+ * Starts `next start` with every role (web and worker, as production runs it)
+ * under the production heap ceiling, against the seeded benchmark database
+ * (see docs/contributing/benchmarks.md; never a database with real data: a
+ * heap snapshot holds whatever the process decrypted). It records:
+ *
+ *   - the time to the first healthy `/api/health` and to `[boot] background
+ *     role ready`;
+ *   - every `event_loop_stall` the process logs, with the task it names;
+ *   - every `runtime.heap.sampled` line;
+ *   - with `--cpu-prof` (default on), the busy stretches of the main thread
+ *     over 100 ms during the boot, each with its self time by source module;
+ *   - with a snapshot (default on), one heap snapshot after the idle wait
+ *     (taken with `--heapsnapshot-signal`, so after a full GC: the live heap),
+ *     summarised by node type, constructor, largest strings and the largest
+ *     retained subtrees with a retaining path.
+ *
+ * The raw `.cpuprofile` and `.heapsnapshot` are written to a temporary
+ * directory and deleted after the summary unless `--keep` is given.
+ *
+ * Output: `<out>.json` and `<out>.md`.
+ */
+import { execSync, spawn } from "node:child_process";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { cpus, loadavg, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { longTasks, selfTimeByModule, summariseHeap } from "./profile-analyze";
+
+function arg(name: string, fallback: string): string {
+  const i = process.argv.indexOf(`--${name}`);
+  return i >= 0 && process.argv[i + 1] ? process.argv[i + 1]! : fallback;
+}
+const flag = (name: string) => process.argv.includes(`--${name}`);
+
+const IDLE_SECONDS = Number(arg("idle-seconds", "300"));
+const HEAP_MB = Number(arg("heap-mb", "792"));
+const PORT = Number(arg("port", "3101"));
+const OUT = arg("out", join("scripts", "bench", "results", "latest-boot"));
+const SNAPSHOT = !flag("no-snapshot");
+const CPU_PROF = !flag("no-cpu-prof");
+const KEEP = flag("keep");
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+function find(obj: unknown, key: string): unknown {
+  if (!obj || typeof obj !== "object") return undefined;
+  const rec = obj as Record<string, unknown>;
+  if (key in rec) return rec[key];
+  for (const v of Object.values(rec)) {
+    const hit = find(v, key);
+    if (hit !== undefined) return hit;
+  }
+  return undefined;
+}
+
+async function main(): Promise<void> {
+  if (!process.env.DATABASE_URL) throw new Error("DATABASE_URL is required");
+  const work = mkdtempSync(join(tmpdir(), "hl-boot-profile-"));
+  const nodeOptions = [
+    `--max-old-space-size=${HEAP_MB}`,
+    ...(CPU_PROF ? ["--cpu-prof", `--cpu-prof-dir=${work}`] : []),
+    ...(SNAPSHOT ? ["--heapsnapshot-signal=SIGUSR2"] : []),
+  ].join(" ");
+  const started = Date.now();
+  const child = spawn(
+    process.execPath,
+    [
+      // One line per collection; the mark-compacts say how much of the used
+      // heap was live and how much was garbage waiting for a full GC. Not
+      // allowed in NODE_OPTIONS, and `next start` serves in this process.
+      "--trace-gc",
+      "node_modules/next/dist/bin/next",
+      "start",
+      "-p",
+      String(PORT),
+      "-H",
+      "127.0.0.1",
+    ],
+    {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        NODE_ENV: "production",
+        PORT: String(PORT),
+        HOSTNAME: "127.0.0.1",
+        HEALTHLOG_PROCESS_TYPE: "all",
+        SESSION_COOKIE_SECURE: "false",
+        NODE_OPTIONS: nodeOptions,
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+  // Node writes the snapshot into the process's cwd.
+  const snapshotDir = process.cwd();
+
+  const stalls: Array<Record<string, unknown>> = [];
+  const heapLines: Array<Record<string, unknown>> = [];
+  const bootLines: string[] = [];
+  const markCompacts: Array<{
+    atMs: number;
+    beforeMb: number;
+    afterMb: number;
+  }> = [];
+  let readyAtMs: number | null = null;
+  let snapshotTaken = false;
+  let buffer = "";
+  const onLine = (line: string) => {
+    const gc =
+      /Mark-Compact(?: \(reduce\))? ([\d.]+) \([\d.]+\) -> ([\d.]+) \(/.exec(
+        line,
+      );
+    if (gc) {
+      markCompacts.push({
+        atMs: Date.now() - started,
+        beforeMb: Number(gc[1]),
+        afterMb: Number(gc[2]),
+      });
+      return;
+    }
+    if (line.includes("[boot]")) {
+      bootLines.push(`${Date.now() - started} ms: ${line.slice(0, 200)}`);
+      if (line.includes("background role ready"))
+        readyAtMs = Date.now() - started;
+    }
+    if (!line.startsWith("{")) return;
+    try {
+      const evt = JSON.parse(line) as Record<string, unknown>;
+      const task = find(evt, "task_name");
+      if (task === "startup" && readyAtMs === null) {
+        readyAtMs = Date.now() - started;
+      }
+      if (task === "event_loop_stall") {
+        // The snapshot itself blocks the process for seconds.
+        if (snapshotTaken) return;
+        stalls.push({
+          atMs: Date.now() - started,
+          ...(find(evt, "result") as object),
+        });
+      } else if (task === "runtime.heap.sampled") {
+        heapLines.push({
+          atMs: Date.now() - started,
+          ...((find(evt, "meta") as object) ?? {}),
+        });
+      } else if (typeof task === "string" && task.startsWith("boot.")) {
+        bootLines.push(
+          `${Date.now() - started} ms: ${task} ${JSON.stringify(find(evt, "meta") ?? {})}`.slice(
+            0,
+            400,
+          ),
+        );
+      }
+    } catch {
+      // not a wide event
+    }
+  };
+  child.stdout!.on("data", (d: Buffer) => {
+    buffer += d.toString();
+    let nl: number;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      onLine(buffer.slice(0, nl));
+      buffer = buffer.slice(nl + 1);
+    }
+  });
+  child.stderr!.on("data", (d: Buffer) => {
+    for (const line of d.toString().split("\n"))
+      if (line.includes("[boot]")) onLine(line);
+  });
+
+  let healthyAtMs: number | null = null;
+  const deadline = Date.now() + 180_000;
+  while (Date.now() < deadline && healthyAtMs === null) {
+    if (child.exitCode !== null)
+      throw new Error(`server exited ${child.exitCode}`);
+    try {
+      const res = await fetch(`http://127.0.0.1:${PORT}/api/health`);
+      if (res.status < 500 || res.status === 503) {
+        const body = await res.text();
+        if (res.ok || body.includes("starting"))
+          healthyAtMs = Date.now() - started;
+      }
+    } catch {
+      // not listening yet
+    }
+    await sleep(100);
+  }
+  while (readyAtMs === null && Date.now() < deadline) await sleep(200);
+  console.log(
+    `health ${healthyAtMs} ms, worker ready ${readyAtMs} ms; idling ${IDLE_SECONDS} s`,
+  );
+  await sleep(IDLE_SECONDS * 1000);
+
+  let heap: ReturnType<typeof summariseHeap> | null = null;
+  if (SNAPSHOT) {
+    const before = new Set(readdirSync(snapshotDir));
+    snapshotTaken = true;
+    child.kill("SIGUSR2");
+    let file = "";
+    let lastSize = -1;
+    for (let i = 0; i < 600; i++) {
+      await sleep(1000);
+      const f = readdirSync(snapshotDir).find(
+        (n) => n.endsWith(".heapsnapshot") && !before.has(n),
+      );
+      if (!f) continue;
+      const size = statSync(join(snapshotDir, f)).size;
+      if (size === lastSize && size > 0) {
+        file = join(snapshotDir, f);
+        break;
+      }
+      lastSize = size;
+    }
+    if (file) {
+      // A snapshot is finished when the process answers again.
+      await fetch(`http://127.0.0.1:${PORT}/api/health`).catch(() => undefined);
+      const moved = join(work, "idle.heapsnapshot");
+      execSync(`mv ${JSON.stringify(file)} ${JSON.stringify(moved)}`);
+      console.log("summarising heap snapshot");
+      heap = summariseHeap(moved, {
+        "parsed locale catalogs": ["common", "apiErrors", "doctorReport"],
+      });
+    }
+  }
+
+  const exited = new Promise((r) => child.once("exit", r));
+  child.kill("SIGTERM");
+  await Promise.race([exited, sleep(60_000)]);
+  if (child.exitCode === null) child.kill("SIGKILL");
+
+  let tasks: ReturnType<typeof longTasks> = [];
+  let bootSelf: Array<[string, number]> = [];
+  if (CPU_PROF) {
+    await sleep(1000);
+    const profiles = readdirSync(work).filter((n) => n.endsWith(".cpuprofile"));
+    // The largest profile is the server process (`next start` may run a
+    // small parent).
+    const main = profiles
+      .map((n) => join(work, n))
+      .sort((a, b) => statSync(b).size - statSync(a).size)[0];
+    if (main) {
+      const profile = JSON.parse(readFileSync(main, "utf8"));
+      tasks = longTasks(profile, 50, 0.5).filter((t) => t.startMs < 120_000);
+      bootSelf = selfTimeByModule(
+        profile,
+        0,
+        (readyAtMs ?? 30_000) + 5_000,
+      ).slice(0, 40);
+    }
+  }
+  if (!KEEP) rmSync(work, { recursive: true, force: true });
+  else console.log(`raw files kept in ${work}`);
+
+  let commit = "unknown";
+  try {
+    commit = execSync("git rev-parse --short HEAD").toString().trim();
+  } catch {
+    // not a checkout
+  }
+  const meta = {
+    label: OUT.split("/").pop(),
+    commit,
+    date: new Date().toISOString(),
+    node: process.version,
+    cpus: cpus().length,
+    loadAverage: loadavg().map((n) => Math.round(n * 10) / 10),
+    heapMb: HEAP_MB,
+    idleSeconds: IDLE_SECONDS,
+    healthyAtMs,
+    readyAtMs,
+    stallMaxMs: Math.max(0, ...stalls.map((s) => Number(s.lag_ms ?? 0))),
+  };
+  mkdirSync(dirname(OUT), { recursive: true });
+  // Paths in frame and retainer names are made relative to the checkout.
+  const relative = (text: string) => text.split(`${process.cwd()}/`).join("");
+  writeFileSync(
+    `${OUT}.json`,
+    relative(
+      `${JSON.stringify({ meta, bootLines, stalls, heapLines, markCompacts, tasks, bootSelf, heap }, null, 2)}\n`,
+    ),
+  );
+  const md: string[] = [
+    `# Boot profile ${String(meta.label)}`,
+    "",
+    `Commit ${commit}, ${meta.date}. Production build, every role, heap ceiling ${HEAP_MB} MB, ${IDLE_SECONDS} s idle. ${meta.cpus} cores, load average ${meta.loadAverage.join(",")} at the end.`,
+    "",
+    `- first answer from /api/health: ${healthyAtMs} ms; background role ready: ${readyAtMs} ms`,
+    `- event-loop stalls logged: ${stalls.length}, max ${meta.stallMaxMs} ms`,
+    "",
+    "## Stalls",
+    "",
+    ...stalls.map((s) => `- ${JSON.stringify(s)}`),
+    "",
+    "## Heap samples",
+    "",
+    "| at s | used MB | old | large obj | code | external | array buffers | rss |",
+    "| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+    ...heapLines.map(
+      (h) =>
+        `| ${Math.round(Number(h.atMs) / 1000)} | ${h.heap_used_mb} | ${h.old_space_mb} | ${h.large_object_space_mb} | ${h.code_space_mb} | ${h.external_mb} | ${h.array_buffers_mb} | ${h.rss_mb} |`,
+    ),
+    "",
+    "## Full collections (mark-compact)",
+    "",
+    `${markCompacts.length} mark-compacts during the run. Used heap before the collection, and what survived it (the live heap):`,
+    "",
+    "| at s | before MB | after MB |",
+    "| ---: | ---: | ---: |",
+    ...markCompacts
+      .filter(
+        (m, i, all) =>
+          i === all.length - 1 || i % Math.ceil(all.length / 15) === 0,
+      )
+      .map(
+        (m) =>
+          `| ${Math.round(m.atMs / 1000)} | ${m.beforeMb} | ${m.afterMb} |`,
+      ),
+    "",
+    "## Main-thread busy stretches over 50 ms without an idle sample, first two minutes",
+    "",
+    ...tasks.flatMap((t) => [
+      `### at ${t.startMs} ms, ${t.durationMs} ms`,
+      "",
+      "| self time by module | ms |",
+      "| --- | ---: |",
+      ...t.byModule.slice(0, 10).map(([m, v]) => `| ${m} | ${v} |`),
+      "",
+      "| inclusive, application modules | ms |",
+      "| --- | ---: |",
+      ...t.byEntry.slice(0, 10).map(([m, v]) => `| ${m} | ${v} |`),
+      "",
+    ]),
+    "## Self time by module until the worker is ready",
+    "",
+    "| module | ms |",
+    "| --- | ---: |",
+    ...bootSelf.slice(0, 25).map(([m, v]) => `| ${m} | ${v} |`),
+    "",
+  ];
+  if (heap) {
+    md.push(
+      `## Heap snapshot after ${IDLE_SECONDS} s idle (live heap after a full GC)`,
+      "",
+      `${heap.totalMb} MB in ${heap.nodeCount} nodes; module source strings over 50 KB: ${heap.sourceStringsMb} MB.`,
+      "",
+      ...Object.entries(heap.probes).map(
+        ([k, v]) => `- ${k}: ${v.count} objects, ${v.retainedMb} MB retained`,
+      ),
+      "",
+      "| node type | MB |",
+      "| --- | ---: |",
+      ...heap.byType.map(([k, v]) => `| ${k} | ${v} |`),
+      "",
+      "| constructor | MB | count |",
+      "| --- | ---: | ---: |",
+      ...heap.byConstructor
+        .slice(0, 20)
+        .map(([k, v, c]) => `| ${k.replace(/\|/g, "/")} | ${v} | ${c} |`),
+      "",
+      "| largest retained subtrees | MB | retaining path |",
+      "| --- | ---: | --- |",
+      ...heap.topRetainers
+        .slice(0, 30)
+        .map(
+          (r) =>
+            `| ${r.name.replace(/\|/g, "/")} | ${r.mb} | ${r.path.replace(/\|/g, "/").slice(0, 160)} |`,
+        ),
+      "",
+      "| largest strings | MB |",
+      "| --- | ---: |",
+      ...heap.largestStrings
+        .slice(0, 15)
+        .map(([s, t]) => `| ${t.replace(/\|/g, "/").slice(0, 90)} | ${s} |`),
+      "",
+    );
+  }
+  writeFileSync(`${OUT}.md`, relative(md.join("\n")));
+  console.log(`wrote ${OUT}.json and ${OUT}.md`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});
diff --git a/scripts/bench/profile-analyze.ts b/scripts/bench/profile-analyze.ts
new file mode 100644
index 000000000..047e67cfc
--- /dev/null
+++ b/scripts/bench/profile-analyze.ts
@@ -0,0 +1,599 @@
+/**
+ * Readers for the two files `boot-profile.ts` collects: a V8 CPU profile
+ * (`.cpuprofile`) and a heap snapshot (`.heapsnapshot`). Both are plain
+ * JSON; these turn them into the few tables a boot investigation needs, so a
+ * before/after comparison does not depend on opening DevTools by hand.
+ *
+ * Frames are attributed to source modules through the module ids Turbopack
+ * writes into every server chunk (`"[project]/src/lib/x.ts [app-route] …"`):
+ * a sample at chunk line N belongs to the last module id that starts at or
+ * before N.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+// ---------------------------------------------------------------- modules
+
+const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const B64_INDEX = new Map([...B64].map((c, i) => [c, i]));
+
+interface ChunkMap {
+  sources: string[];
+  /** Per generated line: [column, source index] pairs, ascending. */
+  lines: Array<Array<[number, number]>>;
+}
+const chunkMapCache = new Map<string, ChunkMap | null>();
+
+/** Decode a chunk's source map down to (line, column) → source. */
+function chunkMap(url: string): ChunkMap | null {
+  if (chunkMapCache.has(url)) return chunkMapCache.get(url)!;
+  let path = url;
+  try {
+    if (url.startsWith("file://")) path = fileURLToPath(url);
+  } catch {
+    // not a file URL
+  }
+  let result: ChunkMap | null = null;
+  if (existsSync(`${path}.map`)) {
+    type RawMap = {
+      sources?: string[];
+      mappings?: string;
+      sections?: Array<{ offset: { line: number }; map: RawMap }>;
+    };
+    const raw = JSON.parse(readFileSync(`${path}.map`, "utf8")) as RawMap;
+    const sources: string[] = [];
+    const lines: Array<Array<[number, number]>> = [];
+    // An index map (`sections`) holds one ordinary map per offset.
+    const flat: Array<{ line: number; map: RawMap }> = raw.sections
+      ? raw.sections.map((s) => ({ line: s.offset.line, map: s.map }))
+      : [{ line: 0, map: raw }];
+    for (const { line: lineOffset, map } of flat) {
+      const base = sources.length;
+      sources.push(...(map.sources ?? []));
+      let src = 0;
+      let lineNo = lineOffset;
+      for (const line of (map.mappings ?? "").split(";")) {
+        const segs: Array<[number, number]> = lines[lineNo] ?? [];
+        let col = 0;
+        for (const seg of line.split(",")) {
+          if (!seg) continue;
+          const vals: number[] = [];
+          let shift = 0;
+          let value = 0;
+          for (const ch of seg) {
+            const d = B64_INDEX.get(ch)!;
+            value += (d & 31) << shift;
+            if (d & 32) shift += 5;
+            else {
+              const neg = value & 1;
+              value >>= 1;
+              vals.push(neg ? -value : value);
+              value = 0;
+              shift = 0;
+            }
+          }
+          col += vals[0] ?? 0;
+          if (vals.length > 1) {
+            src += vals[1]!;
+            segs.push([col, base + src]);
+          }
+        }
+        lines[lineNo] = segs;
+        lineNo++;
+      }
+    }
+    for (const segs of lines) segs?.sort((x, y) => x[0] - y[0]);
+    result = { sources, lines };
+  }
+  chunkMapCache.set(url, result);
+  return result;
+}
+
+function packageOf(path: string): string {
+  const parts = path.split("node_modules/");
+  const rest = parts[parts.length - 1]!.split("/");
+  return `npm:${rest[0]!.startsWith("@") ? `${rest[0]}/${rest[1]}` : rest[0]}`;
+}
+
+/** The source module a frame at (url, 0-based line, column) belongs to. */
+export function moduleForFrame(url: string, line: number, column = 0): string {
+  if (!url) return "(native)";
+  if (url.startsWith("node:")) return url;
+  if (url.includes("/node_modules/") && !url.includes("/.next/")) {
+    return packageOf(url);
+  }
+  const map = chunkMap(url);
+  const segs = map?.lines[line];
+  if (map && segs && segs.length > 0) {
+    let lo = 0;
+    let hi = segs.length - 1;
+    let found = segs[0]![1];
+    while (lo <= hi) {
+      const mid = (lo + hi) >> 1;
+      if (segs[mid]![0] <= column) {
+        found = segs[mid]![1];
+        lo = mid + 1;
+      } else hi = mid - 1;
+    }
+    const source = (map.sources[found] ?? "")
+      .replace(/^turbopack:\/\/\/\[project\]\//, "")
+      .replace(/^(\.\.\/)+/, "");
+    if (source.includes("node_modules/")) return packageOf(source);
+    return source || url;
+  }
+  return url.replace(/^.*\/\.next\//, ".next/");
+}
+
+// ------------------------------------------------------------ CPU profile
+
+interface CpuNode {
+  id: number;
+  callFrame: {
+    functionName: string;
+    url: string;
+    lineNumber: number;
+    columnNumber: number;
+  };
+  children?: number[];
+}
+
+interface CpuProfile {
+  nodes: CpuNode[];
+  startTime: number;
+  endTime: number;
+  samples: number[];
+  timeDeltas: number[];
+}
+
+export interface LongTask {
+  startMs: number;
+  durationMs: number;
+  /** Self time by source module, descending. */
+  byModule: Array<[string, number]>;
+  /** Self time by function, descending. */
+  byFunction: Array<[string, number]>;
+  /** Inclusive time of the outermost application frames. */
+  byEntry: Array<[string, number]>;
+}
+
+const IDLE = new Set(["(idle)", "(root)"]);
+
+/**
+ * Busy stretches of the main thread: consecutive non-idle samples whose gaps
+ * stay under `gapMs`, longer than `minMs`. Each comes with its self time by
+ * module and by function.
+ */
+export function longTasks(
+  profile: CpuProfile,
+  minMs = 100,
+  gapMs = 5,
+): LongTask[] {
+  const byId = new Map<number, CpuNode>();
+  const parent = new Map<number, number>();
+  for (const n of profile.nodes) {
+    byId.set(n.id, n);
+    for (const c of n.children ?? []) parent.set(c, n.id);
+  }
+  const tasks: LongTask[] = [];
+  let current: {
+    start: number;
+    end: number;
+    samples: Array<[number, number]>;
+  } | null = null;
+  const flush = () => {
+    if (!current) return;
+    const dur = (current.end - current.start) / 1000;
+    if (dur >= minMs) {
+      const mods = new Map<string, number>();
+      const fns = new Map<string, number>();
+      const entries = new Map<string, number>();
+      for (const [id, dt] of current.samples) {
+        const n = byId.get(id)!;
+        const cf = n.callFrame;
+        const mod = moduleForFrame(cf.url, cf.lineNumber, cf.columnNumber);
+        mods.set(mod, (mods.get(mod) ?? 0) + dt);
+        const fn = `${cf.functionName || "(anonymous)"} ${mod}`;
+        fns.set(fn, (fns.get(fn) ?? 0) + dt);
+        // Inclusive: every distinct module on the stack gets the sample once.
+        const seen = new Set<string>();
+        let cur: number | undefined = id;
+        while (cur !== undefined) {
+          const c = byId.get(cur)!.callFrame;
+          if (c.url) {
+            const m = moduleForFrame(c.url, c.lineNumber, c.columnNumber);
+            if (m.startsWith("src/") && !seen.has(m)) {
+              seen.add(m);
+              entries.set(m, (entries.get(m) ?? 0) + dt);
+            }
+          }
+          cur = parent.get(cur);
+        }
+      }
+      const top = (m: Map<string, number>) =>
+        [...m.entries()]
+          .map(([k, v]) => [k, Math.round(v / 100) / 10] as [string, number])
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 15);
+      tasks.push({
+        startMs: Math.round((current.start - profile.startTime) / 1000),
+        durationMs: Math.round(dur),
+        byModule: top(mods),
+        byFunction: top(fns),
+        byEntry: top(entries),
+      });
+    }
+    current = null;
+  };
+  let at = profile.startTime;
+  for (let i = 0; i < profile.samples.length; i++) {
+    at += profile.timeDeltas[i] ?? 0;
+    const id = profile.samples[i]!;
+    const name = byId.get(id)?.callFrame.functionName ?? "";
+    const dt = profile.timeDeltas[i + 1] ?? 0;
+    if (IDLE.has(name)) {
+      if (current && at - current.end > gapMs * 1000) flush();
+      continue;
+    }
+    if (!current) current = { start: at, end: at, samples: [] };
+    else if (at - current.end > gapMs * 1000) {
+      flush();
+      current = { start: at, end: at, samples: [] };
+    }
+    current.end = at + dt;
+    current.samples.push([id, dt]);
+  }
+  flush();
+  return tasks;
+}
+
+/** Self time per module over the whole profile, or a window of it. */
+export function selfTimeByModule(
+  profile: CpuProfile,
+  fromMs = 0,
+  toMs = Infinity,
+): Array<[string, number]> {
+  const byId = new Map(profile.nodes.map((n) => [n.id, n]));
+  const mods = new Map<string, number>();
+  let at = profile.startTime;
+  for (let i = 0; i < profile.samples.length; i++) {
+    at += profile.timeDeltas[i] ?? 0;
+    const rel = (at - profile.startTime) / 1000;
+    if (rel < fromMs || rel > toMs) continue;
+    const n = byId.get(profile.samples[i]!)!;
+    if (IDLE.has(n.callFrame.functionName)) continue;
+    const mod = moduleForFrame(
+      n.callFrame.url,
+      n.callFrame.lineNumber,
+      n.callFrame.columnNumber,
+    );
+    const dt = profile.timeDeltas[i + 1] ?? 0;
+    mods.set(mod, (mods.get(mod) ?? 0) + dt);
+  }
+  return [...mods.entries()]
+    .map(([k, v]) => [k, Math.round(v / 100) / 10] as [string, number])
+    .sort((a, b) => b[1] - a[1]);
+}
+
+// ---------------------------------------------------------- heap snapshot
+
+interface HeapSnapshot {
+  snapshot: {
+    meta: {
+      node_fields: string[];
+      node_types: [string[], ...unknown[]];
+      edge_fields: string[];
+      edge_types: [string[], ...unknown[]];
+    };
+    node_count: number;
+  };
+  nodes: number[];
+  edges: number[];
+  strings: string[];
+}
+
+export interface HeapSummary {
+  totalMb: number;
+  nodeCount: number;
+  byType: Array<[string, number]>;
+  byConstructor: Array<[string, number, number]>;
+  largestStrings: Array<[number, string]>;
+  /** Retained size of the largest dominator subtrees below the GC roots. */
+  topRetainers: Array<{ mb: number; name: string; path: string }>;
+  /** Module source strings (whole chunk scripts) over 50 KB. */
+  sourceStringsMb: number;
+  /**
+   * For each probe, the objects that carry every listed property: how many,
+   * and their summed retained size (the outermost ones only).
+   */
+  probes: Record<string, { count: number; retainedMb: number }>;
+}
+
+/**
+ * Self size by node type and constructor, the largest strings, and retained
+ * sizes from the dominator tree (Cooper, Harvey, Kennedy), with a retaining
+ * path for each of the largest subtrees.
+ */
+export function summariseHeap(
+  file: string,
+  probes: Record<string, string[]> = {},
+): HeapSummary {
+  const snap = JSON.parse(readFileSync(file, "utf8")) as HeapSnapshot;
+  const nf = snap.snapshot.meta.node_fields;
+  const ef = snap.snapshot.meta.edge_fields;
+  const nodeTypes = snap.snapshot.meta.node_types[0];
+  const edgeTypes = snap.snapshot.meta.edge_types[0];
+  const NF = nf.length;
+  const EF = ef.length;
+  const iType = nf.indexOf("type");
+  const iName = nf.indexOf("name");
+  const iSelf = nf.indexOf("self_size");
+  const iEdges = nf.indexOf("edge_count");
+  const eType = ef.indexOf("type");
+  const eName = ef.indexOf("name_or_index");
+  const eTo = ef.indexOf("to_node");
+  const weak = edgeTypes.indexOf("weak");
+  const shortcut = edgeTypes.indexOf("shortcut");
+  const elementT = edgeTypes.indexOf("element");
+  const hiddenT = edgeTypes.indexOf("hidden");
+  const N = snap.nodes.length / NF;
+  const nodes = snap.nodes;
+  const edges = snap.edges;
+  const strings = snap.strings;
+
+  const firstEdge = new Uint32Array(N + 1);
+  for (let i = 0, e = 0; i < N; i++) {
+    firstEdge[i] = e;
+    e += nodes[i * NF + iEdges]! * EF;
+  }
+  firstEdge[N] = edges.length;
+
+  const self = (i: number) => nodes[i * NF + iSelf]!;
+  const typeOf = (i: number) => nodeTypes[nodes[i * NF + iType]!]!;
+  const nameOf = (i: number) => strings[nodes[i * NF + iName]!]!;
+
+  let total = 0;
+  const byType = new Map<string, number>();
+  const byCtor = new Map<string, [number, number]>();
+  const big: Array<[number, string]> = [];
+  let sourceStrings = 0;
+  for (let i = 0; i < N; i++) {
+    const s = self(i);
+    total += s;
+    const t = typeOf(i);
+    byType.set(t, (byType.get(t) ?? 0) + s);
+    if (t === "object" || t === "closure" || t === "array" || t === "native") {
+      const k = `${t}:${nameOf(i)}`.slice(0, 80);
+      const cur = byCtor.get(k) ?? [0, 0];
+      cur[0] += s;
+      cur[1] += 1;
+      byCtor.set(k, cur);
+    }
+    if (
+      t === "string" ||
+      t === "concatenated string" ||
+      t === "sliced string"
+    ) {
+      if (s > 200_000)
+        big.push([s, nameOf(i).slice(0, 100).replace(/\s+/g, " ")]);
+      const nm = nameOf(i);
+      if (
+        s > 50_000 &&
+        /__turbopack_context__|"use strict";|module\.exports/.test(
+          nm.slice(0, 2000),
+        )
+      ) {
+        sourceStrings += s;
+      }
+    }
+  }
+
+  // Graph for the dominator tree: strong edges only.
+  const isStrong = (et: number) => et !== weak && et !== shortcut;
+  // Post-order DFS from node 0.
+  const order = new Int32Array(N).fill(-1);
+  const post: number[] = [];
+  const stackN: number[] = [0];
+  const stackE: number[] = [firstEdge[0]!];
+  order[0] = -2;
+  while (stackN.length) {
+    const top = stackN.length - 1;
+    const n = stackN[top]!;
+    const e = stackE[top]!;
+    if (e < firstEdge[n + 1]!) {
+      stackE[top] = e + EF;
+      const et = edges[e + eType]!;
+      if (!isStrong(et)) continue;
+      const to = edges[e + eTo]! / NF;
+      if (order[to] === -1) {
+        order[to] = -2;
+        stackN.push(to);
+        stackE.push(firstEdge[to]!);
+      }
+    } else {
+      order[n] = post.length;
+      post.push(n);
+      stackN.pop();
+      stackE.pop();
+    }
+  }
+  const R = post.length;
+  // Predecessors in post-order numbering (CSR).
+  const predCount = new Uint32Array(R + 1);
+  for (let n = 0; n < N; n++) {
+    if (order[n]! < 0) continue;
+    for (let e = firstEdge[n]!; e < firstEdge[n + 1]!; e += EF) {
+      if (!isStrong(edges[e + eType]!)) continue;
+      const to = edges[e + eTo]! / NF;
+      if (order[to]! >= 0) predCount[order[to]! + 1]! += 1;
+    }
+  }
+  for (let i = 0; i < R; i++) predCount[i + 1]! += predCount[i]!;
+  const preds = new Uint32Array(predCount[R]!);
+  const fill = predCount.slice(0, R);
+  for (let n = 0; n < N; n++) {
+    if (order[n]! < 0) continue;
+    for (let e = firstEdge[n]!; e < firstEdge[n + 1]!; e += EF) {
+      if (!isStrong(edges[e + eType]!)) continue;
+      const to = edges[e + eTo]! / NF;
+      if (order[to]! >= 0) preds[fill[order[to]!]!++] = order[n]!;
+    }
+  }
+  const rootPo = order[0]!;
+  const idom = new Int32Array(R).fill(-1);
+  idom[rootPo] = rootPo;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (let b = R - 1; b >= 0; b--) {
+      if (b === rootPo) continue;
+      let ni = -1;
+      for (let p = predCount[b]!; p < predCount[b + 1]!; p++) {
+        let q = preds[p]!;
+        if (idom[q] === -1) continue;
+        if (ni === -1) {
+          ni = q;
+          continue;
+        }
+        let a = ni;
+        while (a !== q) {
+          while (a < q) a = idom[a]!;
+          while (q < a) q = idom[q]!;
+        }
+        ni = a;
+      }
+      if (ni !== -1 && idom[b] !== ni) {
+        idom[b] = ni;
+        changed = true;
+      }
+    }
+  }
+  const retained = new Float64Array(R);
+  for (let b = 0; b < R; b++) retained[b] += self(post[b]!);
+  for (let b = 0; b < R; b++) {
+    if (b !== rootPo && idom[b]! >= 0) retained[idom[b]!] += retained[b]!;
+  }
+
+  // A retaining path: the first strong, named predecessor edge, walked up.
+  const retainerEdge = new Map<number, [number, string]>();
+  const wanted = new Set<number>();
+  const candidates: number[] = [];
+  for (let b = 0; b < R; b++) {
+    const n = post[b]!;
+    const t = typeOf(n);
+    if (b === rootPo || t === "synthetic" || t === "hidden") continue;
+    // Skip nodes whose immediate dominator is itself a big application
+    // object: report the outermost holders only.
+    if (retained[b]! < 2_000_000) continue;
+    candidates.push(b);
+  }
+  candidates.sort((a, b) => retained[b]! - retained[a]!);
+  const picked: number[] = [];
+  for (const b of candidates) {
+    // keep the outermost: skip if an ancestor in the dominator tree is
+    // already picked and within 1.5× (it would be a duplicate line)
+    let a = idom[b]!;
+    let dup = false;
+    while (a !== rootPo && a >= 0) {
+      if (picked.includes(a) && retained[a]! < retained[b]! * 1.5) {
+        dup = true;
+        break;
+      }
+      a = idom[a]!;
+    }
+    if (!dup) picked.push(b);
+    if (picked.length >= 40) break;
+  }
+  for (const b of picked) wanted.add(post[b]!);
+  // Build one retainer per node in a BFS from the root (shortest path).
+  const dist = new Int32Array(N).fill(-1);
+  const queue = new Int32Array(N);
+  let qh = 0;
+  let qt = 0;
+  queue[qt++] = 0;
+  dist[0] = 0;
+  while (qh < qt) {
+    const n = queue[qh++]!;
+    for (let e = firstEdge[n]!; e < firstEdge[n + 1]!; e += EF) {
+      const et = edges[e + eType]!;
+      if (!isStrong(et)) continue;
+      const to = edges[e + eTo]! / NF;
+      if (dist[to] !== -1) continue;
+      dist[to] = dist[n]! + 1;
+      const label =
+        et === elementT || et === hiddenT
+          ? `[${edges[e + eName]}]`
+          : String(strings[edges[e + eName]!] ?? "");
+      retainerEdge.set(to, [n, label]);
+      queue[qt++] = to;
+    }
+  }
+  const pathOf = (n: number) => {
+    const parts: string[] = [];
+    let cur = n;
+    for (let depth = 0; depth < 12 && cur !== 0; depth++) {
+      const r = retainerEdge.get(cur);
+      if (!r) break;
+      parts.unshift(`${r[1]}`);
+      cur = r[0];
+      const t = typeOf(cur);
+      if (t !== "hidden" && t !== "synthetic" && depth > 0) {
+        parts.unshift(`${nameOf(cur).slice(0, 40)}`);
+        if (depth > 4) break;
+      }
+    }
+    return parts.join(" > ");
+  };
+
+  const mb = (n: number) => Math.round((n / 1048576) * 10) / 10;
+  const probeResults: HeapSummary["probes"] = {};
+  const propertyT = edgeTypes.indexOf("property");
+  for (const [label, props] of Object.entries(probes)) {
+    const hits = new Set<number>();
+    for (let n = 0; n < N; n++) {
+      if (typeOf(n) !== "object" || order[n]! < 0) continue;
+      const seen = new Set<string>();
+      for (let e = firstEdge[n]!; e < firstEdge[n + 1]!; e += EF) {
+        if (edges[e + eType] !== propertyT) continue;
+        seen.add(strings[edges[e + eName]!]!);
+      }
+      if (props.every((p) => seen.has(p))) hits.add(order[n]!);
+    }
+    let retainedSum = 0;
+    for (const b of hits) {
+      // Count a hit only when no dominator above it is a hit too.
+      let a = idom[b]!;
+      let nested = false;
+      while (a !== rootPo && a >= 0) {
+        if (hits.has(a)) {
+          nested = true;
+          break;
+        }
+        a = idom[a]!;
+      }
+      if (!nested) retainedSum += retained[b]!;
+    }
+    probeResults[label] = { count: hits.size, retainedMb: mb(retainedSum) };
+  }
+  return {
+    probes: probeResults,
+    totalMb: mb(total),
+    nodeCount: N,
+    byType: [...byType.entries()]
+      .map(([k, v]) => [k, mb(v)] as [string, number])
+      .sort((a, b) => b[1] - a[1]),
+    byConstructor: [...byCtor.entries()]
+      .map(([k, [s, c]]) => [k, mb(s), c] as [string, number, number])
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 30),
+    largestStrings: big
+      .sort((a, b) => b[0] - a[0])
+      .slice(0, 25)
+      .map(([s, t]) => [mb(s), t]),
+    topRetainers: picked.map((b) => ({
+      mb: mb(retained[b]!),
+      name: `${typeOf(post[b]!)}:${nameOf(post[b]!).slice(0, 60).replace(/\s+/g, " ")}`,
+      path: pathOf(post[b]!),
+    })),
+    sourceStringsMb: mb(sourceStrings),
+  };
+}
diff --git a/scripts/bench/results/v1.45.0-before-boot.json b/scripts/bench/results/v1.45.0-before-boot.json
new file mode 100644
index 000000000..65e2ae420
--- /dev/null
+++ b/scripts/bench/results/v1.45.0-before-boot.json
@@ -0,0 +1,1351 @@
+{
+  "meta": {
+    "label": "v1.45.0-before-boot",
+    "commit": "0f6d668df",
+    "date": "2026-10-22T04:36:55.826Z",
+    "node": "v22.23.2",
+    "cpus": 14,
+    "loadAverage": [
+      9.3,
+      9.4,
+      11.2
+    ],
+    "heapMb": 792,
+    "idleSeconds": 300,
+    "healthyAtMs": 1590,
+    "readyAtMs": 5432,
+    "stallMaxMs": 0
+  },
+  "bootLines": [],
+  "stalls": [],
+  "heapLines": [
+    {
+      "atMs": 5752,
+      "heap_used_mb": 184,
+      "heap_total_mb": 219,
+      "heap_limit_mb": 840,
+      "heap_used_ratio": 0.219,
+      "new_space_mb": 1,
+      "old_space_mb": 105,
+      "code_space_mb": 4,
+      "large_object_space_mb": 68,
+      "new_large_object_space_mb": 0,
+      "code_large_object_space_mb": 0,
+      "trusted_space_mb": 6,
+      "read_only_space_mb": 0,
+      "other_spaces_mb": 0,
+      "rss_mb": 267,
+      "external_mb": 11,
+      "array_buffers_mb": 0,
+      "active_requests": 0,
+      "active_jobs": 0,
+      "in_flight_dropped": 0,
+      "uptime_s": 6
+    },
+    {
+      "atMs": 307706,
+      "heap_used_mb": 164,
+      "heap_total_mb": 170,
+      "heap_limit_mb": 840,
+      "heap_used_ratio": 0.196,
+      "new_space_mb": 0,
+      "old_space_mb": 99,
+      "code_space_mb": 5,
+      "large_object_space_mb": 58,
+      "new_large_object_space_mb": 0,
+      "code_large_object_space_mb": 0,
+      "trusted_space_mb": 3,
+      "read_only_space_mb": 0,
+      "other_spaces_mb": 0,
+      "rss_mb": 623,
+      "external_mb": 11,
+      "array_buffers_mb": 0,
+      "active_requests": 0,
+      "active_jobs": 1,
+      "in_flight_dropped": 0,
+      "uptime_s": 308
+    }
+  ],
+  "markCompacts": [
+    {
+      "atMs": 307,
+      "beforeMb": 21.4,
+      "afterMb": 17.4
+    },
+    {
+      "atMs": 560,
+      "beforeMb": 49.9,
+      "afterMb": 47.8
+    },
+    {
+      "atMs": 685,
+      "beforeMb": 79.8,
+      "afterMb": 79.1
+    },
+    {
+      "atMs": 1324,
+      "beforeMb": 159.8,
+      "afterMb": 154.8
+    },
+    {
+      "atMs": 9449,
+      "beforeMb": 189.6,
+      "afterMb": 172.9
+    },
+    {
+      "atMs": 10070,
+      "beforeMb": 174.4,
+      "afterMb": 170.7
+    },
+    {
+      "atMs": 69903,
+      "beforeMb": 179.9,
+      "afterMb": 171.2
+    },
+    {
+      "atMs": 151031,
+      "beforeMb": 191.1,
+      "afterMb": 174.3
+    },
+    {
+      "atMs": 153639,
+      "beforeMb": 193.8,
+      "afterMb": 171.6
+    },
+    {
+      "atMs": 158553,
+      "beforeMb": 204.6,
+      "afterMb": 161.5
+    },
+    {
+      "atMs": 163529,
+      "beforeMb": 191.2,
+      "afterMb": 161.4
+    },
+    {
+      "atMs": 167487,
+      "beforeMb": 185.6,
+      "afterMb": 161.5
+    },
+    {
+      "atMs": 170381,
+      "beforeMb": 187.3,
+      "afterMb": 161.7
+    },
+    {
+      "atMs": 173875,
+      "beforeMb": 192.7,
+      "afterMb": 162.2
+    },
+    {
+      "atMs": 177580,
+      "beforeMb": 185.9,
+      "afterMb": 162.2
+    },
+    {
+      "atMs": 183462,
+      "beforeMb": 189.4,
+      "afterMb": 162.3
+    },
+    {
+      "atMs": 188340,
+      "beforeMb": 181.6,
+      "afterMb": 163.6
+    },
+    {
+      "atMs": 193243,
+      "beforeMb": 184.7,
+      "afterMb": 163.7
+    },
+    {
+      "atMs": 197708,
+      "beforeMb": 186.5,
+      "afterMb": 164.6
+    },
+    {
+      "atMs": 201596,
+      "beforeMb": 188.1,
+      "afterMb": 164.7
+    },
+    {
+      "atMs": 205007,
+      "beforeMb": 182.3,
+      "afterMb": 163.6
+    },
+    {
+      "atMs": 208279,
+      "beforeMb": 190.3,
+      "afterMb": 164.3
+    },
+    {
+      "atMs": 212210,
+      "beforeMb": 184.4,
+      "afterMb": 164.6
+    },
+    {
+      "atMs": 217239,
+      "beforeMb": 197.7,
+      "afterMb": 163.6
+    },
+    {
+      "atMs": 222139,
+      "beforeMb": 190.6,
+      "afterMb": 165
+    },
+    {
+      "atMs": 226947,
+      "beforeMb": 189.7,
+      "afterMb": 164.5
+    },
+    {
+      "atMs": 232566,
+      "beforeMb": 194.2,
+      "afterMb": 164.4
+    },
+    {
+      "atMs": 235870,
+      "beforeMb": 189.2,
+      "afterMb": 164.9
+    },
+    {
+      "atMs": 239409,
+      "beforeMb": 182.9,
+      "afterMb": 163.4
+    },
+    {
+      "atMs": 243098,
+      "beforeMb": 184.4,
+      "afterMb": 163.7
+    },
+    {
+      "atMs": 248670,
+      "beforeMb": 193.1,
+      "afterMb": 164.9
+    },
+    {
+      "atMs": 252268,
+      "beforeMb": 184.2,
+      "afterMb": 164.2
+    },
+    {
+      "atMs": 257945,
+      "beforeMb": 190.5,
+      "afterMb": 163.7
+    },
+    {
+      "atMs": 261312,
+      "beforeMb": 190.4,
+      "afterMb": 166.8
+    },
+    {
+      "atMs": 265221,
+      "beforeMb": 188.2,
+      "afterMb": 163.7
+    },
+    {
+      "atMs": 269662,
+      "beforeMb": 188.6,
+      "afterMb": 164.2
+    },
+    {
+      "atMs": 273624,
+      "beforeMb": 187.7,
+      "afterMb": 164.2
+    },
+    {
+      "atMs": 277464,
+      "beforeMb": 186.3,
+      "afterMb": 163.8
+    },
+    {
+      "atMs": 281950,
+      "beforeMb": 196.7,
+      "afterMb": 163.5
+    },
+    {
+      "atMs": 285110,
+      "beforeMb": 186.2,
+      "afterMb": 164.6
+    },
+    {
+      "atMs": 290497,
+      "beforeMb": 193.9,
+      "afterMb": 164.2
+    },
+    {
+      "atMs": 295540,
+      "beforeMb": 190.6,
+      "afterMb": 164.4
+    },
+    {
+      "atMs": 299084,
+      "beforeMb": 183.5,
+      "afterMb": 164.4
+    },
+    {
+      "atMs": 305318,
+      "beforeMb": 191.1,
+      "afterMb": 164.4
+    },
+    {
+      "atMs": 305585,
+      "beforeMb": 175.3,
+      "afterMb": 163.9
+    },
+    {
+      "atMs": 305613,
+      "beforeMb": 163.9,
+      "afterMb": 163.9
+    },
+    {
+      "atMs": 308911,
+      "beforeMb": 174,
+      "afterMb": 163.7
+    }
+  ],
+  "tasks": [
+    {
+      "startMs": 5,
+      "durationMs": 279,
+      "byModule": [
+        [
+          "(native)",
+          122.3
+        ],
+        [
+          "npm:next",
+          57.1
+        ],
+        [
+          "node:internal/modules/cjs/loader",
+          41.7
+        ],
+        [
+          "node:internal/bootstrap/realm",
+          24.7
+        ],
+        [
+          "node:fs",
+          5.3
+        ],
+        [
+          "node:internal/deps/undici/undici",
+          5.3
+        ],
+        [
+          "node:internal/modules/package_json_reader",
+          4.5
+        ],
+        [
+          "node:path",
+          4
+        ],
+        [
+          "node:internal/streams/destroy",
+          1.5
+        ],
+        [
+          "node:internal/deps/cjs-module-lexer/lexer",
+          1.5
+        ],
+        [
+          "node:zlib",
+          1.5
+        ],
+        [
+          "node:worker_threads",
+          1.5
+        ],
+        [
+          "node:internal/net",
+          1.5
+        ],
+        [
+          "node:events",
+          1.5
+        ],
+        [
+          "node:internal/dns/callback_resolver",
+          1.3
+        ]
+      ],
+      "byFunction": [
+        [
+          "readFileUtf8 (native)",
+          63.6
+        ],
+        [
+          "wrapSafe node:internal/modules/cjs/loader",
+          29.6
+        ],
+        [
+          "compileForInternalLoader node:internal/bootstrap/realm",
+          24.7
+        ],
+        [
+          "startServer npm:next",
+          22.8
+        ],
+        [
+          "internalModuleStat (native)",
+          19.1
+        ],
+        [
+          "dlopen (native)",
+          16.1
+        ],
+        [
+          "(garbage collector) (native)",
+          10.5
+        ],
+        [
+          "compileFunction (native)",
+          8.5
+        ],
+        [
+          "(anonymous) npm:next",
+          8.2
+        ],
+        [
+          "(anonymous) node:internal/modules/cjs/loader",
+          7.9
+        ],
+        [
+          "stat node:internal/modules/cjs/loader",
+          4.2
+        ],
+        [
+          "realpathSync node:fs",
+          4.1
+        ],
+        [
+          "__require node:internal/deps/undici/undici",
+          4.1
+        ],
+        [
+          "normalizeString node:path",
+          4
+        ],
+        [
+          "__nccwpck_require__ npm:next",
+          3.9
+        ]
+      ],
+      "byEntry": []
+    },
+    {
+      "startMs": 339,
+      "durationMs": 324,
+      "byModule": [
+        [
+          "(native)",
+          87.6
+        ],
+        [
+          "node:internal/modules/cjs/loader",
+          54.2
+        ],
+        [
+          "npm:@prisma/client",
+          38
+        ],
+        [
+          "wasm://wasm/00d1cb12",
+          36
+        ],
+        [
+          "node:internal/modules/esm/utils",
+          26.7
+        ],
+        [
+          "turbopack:///[turbopack]/nodejs/runtime/build-base.ts",
+          24.9
+        ],
+        [
+          "npm:next",
+          22.1
+        ],
+        [
+          "npm:zod",
+          6
+        ],
+        [
+          "turbopack:///[turbopack]/shared/runtime/runtime-utils.ts",
+          3.1
+        ],
+        [
+          "npm:@prisma/client-runtime-utils",
+          3
+        ],
+        [
+          "node:fs",
+          2.9
+        ],
+        [
+          "node:internal/bootstrap/realm",
+          2.8
+        ],
+        [
+          "npm:pg-protocol",
+          1.8
+        ],
+        [
+          "node:path",
+          1.5
+        ],
+        [
+          "node:internal/deps/cjs-module-lexer/lexer",
+          1.5
+        ]
+      ],
+      "byFunction": [
+        [
+          "wrapSafe node:internal/modules/cjs/loader",
+          47.1
+        ],
+        [
+          "(garbage collector) (native)",
+          40.1
+        ],
+        [
+          "readFileUtf8 (native)",
+          27
+        ],
+        [
+          "compileSourceTextModule node:internal/modules/esm/utils",
+          26.7
+        ],
+        [
+          "#u npm:@prisma/client",
+          23.8
+        ],
+        [
+          "instantiateModule turbopack:///[turbopack]/nodejs/runtime/build-base.ts",
+          23.3
+        ],
+        [
+          "(anonymous) npm:next",
+          6
+        ],
+        [
+          "(anonymous) npm:@prisma/client",
+          6
+        ],
+        [
+          "(program) (native)",
+          5.2
+        ],
+        [
+          "internalModuleStat (native)",
+          4.5
+        ],
+        [
+          "wasm-function[1090] wasm://wasm/00d1cb12",
+          4.5
+        ],
+        [
+          "wasm-function[2550] wasm://wasm/00d1cb12",
+          3.8
+        ],
+        [
+          "readPackageJSON (native)",
+          3.1
+        ],
+        [
+          "defineProp turbopack:///[turbopack]/shared/runtime/runtime-utils.ts",
+          3.1
+        ],
+        [
+          "(anonymous) node:internal/modules/cjs/loader",
+          3
+        ]
+      ],
+      "byEntry": [
+        [
+          "src/instrumentation.ts",
+          80.6
+        ],
+        [
+          "src/lib/db-session.ts",
+          60.7
+        ],
+        [
+          "src/lib/notifications/types.ts",
+          13.2
+        ],
+        [
+          "src/lib/boot/readiness-summary.ts",
+          13.2
+        ],
+        [
+          "src/lib/ai/local-host-allowlist.ts",
+          13.2
+        ],
+        [
+          "src/generated/prisma/internal/class.ts",
+          7.3
+        ],
+        [
+          "src/lib/logging/context.ts",
+          6
+        ],
+        [
+          "src/lib/crypto.ts",
+          6
+        ],
+        [
+          "src/lib/boot/key-check.ts",
+          6
+        ],
+        [
+          "src/lib/validations/measurement.ts",
+          3
+        ],
+        [
+          "src/lib/validations/entry-instant.ts",
+          1.5
+        ],
+        [
+          "src/lib/medications/scheduling/hhmm.ts",
+          1.5
+        ]
+      ]
+    },
+    {
+      "startMs": 698,
+      "durationMs": 753,
+      "byModule": [
+        [
+          "node:internal/modules/cjs/loader",
+          178.2
+        ],
+        [
+          "turbopack:///[turbopack]/nodejs/runtime/build-base.ts",
+          177.4
+        ],
+        [
+          "(native)",
+          83.8
+        ],
+        [
+          "npm:zod",
+          39.5
+        ],
+        [
+          "npm:next",
+          34.6
+        ],
+        [
+          "turbopack:///[turbopack]/shared/runtime/async-module.ts",
+          33.9
+        ],
+        [
+          "npm:mmdb-lib",
+          26.1
+        ],
+        [
+          "node:fs",
+          23.5
+        ],
+        [
+          "npm:yaml",
+          22.4
+        ],
+        [
+          "src/lib/activity/goal-bounds.ts",
+          18.5
+        ],
+        [
+          "node:internal/modules/esm/utils",
+          14.7
+        ],
+        [
+          "turbopack:///[turbopack]/shared/runtime/runtime-utils.ts",
+          9.3
+        ],
+        [
+          "src/lib/daily/today-overview.ts",
+          4.6
+        ],
+        [
+          "npm:undici",
+          4.5
+        ],
+        [
+          "npm:semver",
+          4.2
+        ]
+      ],
+      "byFunction": [
+        [
+          "instantiateModule turbopack:///[turbopack]/nodejs/runtime/build-base.ts",
+          177.4
+        ],
+        [
+          "wrapSafe node:internal/modules/cjs/loader",
+          172.5
+        ],
+        [
+          "readFileUtf8 (native)",
+          37.3
+        ],
+        [
+          "asyncModule turbopack:///[turbopack]/shared/runtime/async-module.ts",
+          32.4
+        ],
+        [
+          "(garbage collector) (native)",
+          29.3
+        ],
+        [
+          "readFileSync node:fs",
+          22
+        ],
+        [
+          "(anonymous) npm:mmdb-lib",
+          20.5
+        ],
+        [
+          "(anonymous) src/lib/activity/goal-bounds.ts",
+          18.5
+        ],
+        [
+          "compileSourceTextModule node:internal/modules/esm/utils",
+          14.7
+        ],
+        [
+          "u npm:zod",
+          10.3
+        ],
+        [
+          "a npm:next",
+          6.3
+        ],
+        [
+          "(anonymous) npm:zod",
+          5.8
+        ],
+        [
+          "module.exports.Object.defineProperty.value npm:mmdb-lib",
+          5.7
+        ],
+        [
+          "(anonymous) npm:next",
+          5.4
+        ],
+        [
+          "w src/lib/daily/today-overview.ts",
+          4.6
+        ]
+      ],
+      "byEntry": [
+        [
+          "src/instrumentation.ts",
+          410
+        ],
+        [
+          "src/lib/jobs/reminder/register-maintenance.ts",
+          279.5
+        ],
+        [
+          "src/lib/sharing/acting-session.ts",
+          138.5
+        ],
+        [
+          "src/lib/jobs/offhost-backup.ts",
+          137.1
+        ],
+        [
+          "src/lib/integrations/oauth-refresh.ts",
+          136.3
+        ],
+        [
+          "src/lib/jobs/morning-digest-refresh-shared.ts",
+          136.3
+        ],
+        [
+          "src/lib/export/environment-backup.ts",
+          134.1
+        ],
+        [
+          "src/lib/export/full-backup-payload.ts",
+          134.1
+        ],
+        [
+          "src/app/api/health/route.ts",
+          127.5
+        ],
+        [
+          "src/lib/insights/snapshot-hash.ts",
+          124.9
+        ],
+        [
+          "src/lib/export/streamed-field.ts",
+          106.8
+        ],
+        [
+          "src/lib/jobs/report-worker-error.ts",
+          93
+        ],
+        [
+          "src/lib/labs/biomarker-resolve.ts",
+          93
+        ],
+        [
+          "src/lib/jobs/reminder/google-health-sync.ts",
+          89.6
+        ],
+        [
+          "src/lib/api-errors.ts",
+          77.5
+        ]
+      ]
+    }
+  ],
+  "bootSelf": [
+    [
+      "(native)",
+      524.6
+    ],
+    [
+      "node:internal/modules/cjs/loader",
+      274
+    ],
+    [
+      "turbopack:///[turbopack]/nodejs/runtime/build-base.ts",
+      202.3
+    ],
+    [
+      "npm:next",
+      136.8
+    ],
+    [
+      "wasm://wasm/00d1cb12",
+      108.1
+    ],
+    [
+      "npm:@prisma/client",
+      76.1
+    ],
+    [
+      "npm:pg",
+      56.5
+    ],
+    [
+      "npm:zod",
+      45.5
+    ],
+    [
+      "node:internal/modules/esm/utils",
+      41.4
+    ],
+    [
+      "npm:luxon",
+      38.5
+    ],
+    [
+      "turbopack:///[turbopack]/shared/runtime/async-module.ts",
+      35.3
+    ],
+    [
+      "node:fs",
+      31.7
+    ],
+    [
+      "node:internal/bootstrap/realm",
+      28.9
+    ],
+    [
+      "npm:pg-protocol",
+      27.7
+    ],
+    [
+      "npm:mmdb-lib",
+      26.1
+    ],
+    [
+      "npm:yaml",
+      22.4
+    ],
+    [
+      "npm:pg-boss",
+      19.3
+    ],
+    [
+      "src/lib/activity/goal-bounds.ts",
+      18.5
+    ],
+    [
+      "node:internal/process/task_queues",
+      17.7
+    ],
+    [
+      "node:internal/streams/readable",
+      15.5
+    ],
+    [
+      "node:internal/async_hooks",
+      15.1
+    ],
+    [
+      "npm:cron-parser",
+      14.6
+    ],
+    [
+      "node:internal/timers",
+      12.8
+    ],
+    [
+      "turbopack:///[turbopack]/shared/runtime/runtime-utils.ts",
+      12.4
+    ],
+    [
+      "node:buffer",
+      11.6
+    ],
+    [
+      "node:internal/buffer",
+      10
+    ],
+    [
+      "node:net",
+      9.8
+    ],
+    [
+      "npm:pg-pool",
+      9.5
+    ],
+    [
+      "node:internal/event_target",
+      7.5
+    ],
+    [
+      "node:timers",
+      7.3
+    ],
+    [
+      "node:path",
+      7
+    ],
+    [
+      "node:internal/deps/undici/undici",
+      6.8
+    ],
+    [
+      "npm:%40prisma",
+      5.8
+    ],
+    [
+      "node:internal/streams/writable",
+      5.7
+    ],
+    [
+      "node:internal/stream_base_commons",
+      5.2
+    ],
+    [
+      "src/lib/daily/today-overview.ts",
+      4.6
+    ],
+    [
+      "node:internal/modules/package_json_reader",
+      4.5
+    ],
+    [
+      "npm:undici",
+      4.5
+    ],
+    [
+      "src/lib/tz/zone-offset.ts",
+      4.5
+    ],
+    [
+      "node:events",
+      4.4
+    ]
+  ],
+  "heap": {
+    "probes": {
+      "parsed locale catalogs": {
+        "count": 32,
+        "retainedMb": 14.1
+      }
+    },
+    "totalMb": 172.3,
+    "nodeCount": 1412114,
+    "byType": [
+      [
+        "string",
+        79.1
+      ],
+      [
+        "array",
+        27.6
+      ],
+      [
+        "code",
+        18.6
+      ],
+      [
+        "object",
+        16.7
+      ],
+      [
+        "hidden",
+        9.3
+      ],
+      [
+        "native",
+        8
+      ],
+      [
+        "object shape",
+        5.8
+      ],
+      [
+        "closure",
+        5
+      ],
+      [
+        "concatenated string",
+        1.3
+      ],
+      [
+        "number",
+        0.4
+      ],
+      [
+        "regexp",
+        0.2
+      ],
+      [
+        "sliced string",
+        0.2
+      ],
+      [
+        "synthetic",
+        0
+      ],
+      [
+        "symbol",
+        0
+      ],
+      [
+        "bigint",
+        0
+      ]
+    ],
+    "byConstructor": [
+      [
+        "array:(object elements)",
+        20.6,
+        24726
+      ],
+      [
+        "object:Object",
+        11.9,
+        300844
+      ],
+      [
+        "native:system / JSArrayBufferData",
+        7.5,
+        169
+      ],
+      [
+        "array:(object properties)",
+        4.4,
+        6540
+      ],
+      [
+        "array:",
+        2.7,
+        9578
+      ],
+      [
+        "object:system / Context",
+        1.6,
+        28887
+      ],
+      [
+        "closure:",
+        1.5,
+        27081
+      ],
+      [
+        "object:Date1",
+        1,
+        10632
+      ],
+      [
+        "closure:native_bind",
+        0.9,
+        20134
+      ],
+      [
+        "object:Array",
+        0.6,
+        19550
+      ],
+      [
+        "object:a",
+        0.4,
+        3880
+      ],
+      [
+        "native:Node / histogram",
+        0.4,
+        1
+      ],
+      [
+        "closure:get",
+        0.3,
+        4717
+      ],
+      [
+        "object:Set",
+        0.2,
+        5102
+      ],
+      [
+        "closure:set",
+        0.2,
+        3414
+      ],
+      [
+        "object:d",
+        0.2,
+        3874
+      ],
+      [
+        "object:Module",
+        0.1,
+        1907
+      ],
+      [
+        "object:Promise",
+        0.1,
+        1590
+      ],
+      [
+        "closure:n",
+        0.1,
+        1400
+      ],
+      [
+        "closure:i",
+        0.1,
+        1390
+      ],
+      [
+        "object:n",
+        0.1,
+        1900
+      ],
+      [
+        "object:ZodOptional",
+        0.1,
+        236
+      ],
+      [
+        "object:_TstNode",
+        0.1,
+        939
+      ],
+      [
+        "native:Node / parser_buffer",
+        0.1,
+        1
+      ],
+      [
+        "object:TCP",
+        0,
+        7
+      ],
+      [
+        "closure:callbackTrampoline",
+        0,
+        1
+      ],
+      [
+        "closure:promiseInitHook",
+        0,
+        1
+      ],
+      [
+        "closure:promiseBeforeHook",
+        0,
+        1
+      ],
+      [
+        "closure:promiseAfterHook",
+        0,
+        1
+      ],
+      [
+        "object:global",
+        0,
+        4
+      ]
+    ],
+    "largestStrings": [
+      [
+        9.7,
+        "module.exports=[425781,(e,a,i)=>{a.exports=JSON.parse('{\"common\":{\"listCapped\":\"Hier stehen die letz"
+      ],
+      [
+        9.7,
+        "module.exports=[157893,(e,a,i)=>{a.exports=JSON.parse('{\"common\":{\"listCapped\":\"Hier stehen die letz"
+      ],
+      [
+        5.6,
+        "module.exports=[17856,A=>{\"use strict\";var e,C,g,I,Q=Object.defineProperty,B={},s={$:()=>i,bgBlack:("
+      ],
+      [
+        5.6,
+        "module.exports=[234494,A=>{\"use strict\";var e,C,g,I,Q=Object.defineProperty,B={},s={$:()=>i,bgBlack:"
+      ],
+      [
+        4.4,
+        "const wasm = \"AGFzbQEAAAABtgRLYAN/f38Bf2ACf38Bf2ACf38AYAF/AGADf39/AGAEf39/fwBgBX9/f39/AGABfwF/YAZ/f3"
+      ],
+      [
+        4.4,
+        "AGFzbQEAAAABtgRLYAN/f38Bf2ACf38Bf2ACf38AYAF/AGADf39/AGAEf39/fwBgBX9/f39/AGABfwF/YAZ/f39/f38AYAR/f39/"
+      ],
+      [
+        3.7,
+        "module.exports=[799092,(e,t,n)=>{\"use strict\";Object.defineProperty(n,\"__esModule\",{value:!0}),Objec"
+      ],
+      [
+        1.9,
+        "lliADOAUngIEAACgKwAgBgAAoSsAIAcAAKErACAIAACiKwAgCQAAoysAIAoAAKQrACALAAClKwAgDAAApisAIA0AAKcrACARAACS"
+      ],
+      [
+        1.3,
+        "(()=>{var e,t,r={\"./dist/build/webpack/alias/react-dom-server.js\"(e,t,r){\"use strict\";var n;function"
+      ],
+      [
+        1.2,
+        "module.exports=[842865,(e,t,r)=>{let i=e.r(522734);t.exports=function(e){return e?/-----BEGIN ([A-Z\\"
+      ],
+      [
+        1.1,
+        "module.exports=[834886,(e,t,n)=>{\"use strict\";Object.defineProperty(n,\"__esModule\",{value:!0});var r"
+      ],
+      [
+        1.1,
+        "// v1.4.34 web-freeze. Schema is locked additive-only until iOS launch // + v1.5.0 marker. See .plan"
+      ],
+      [
+        1.1,
+        "module.exports=[971743,(A,e,t)=>{\"use strict\";let r=A.r(57328),{addAbortListener:s}=A.r(687769),{Rea"
+      ],
+      [
+        1,
+        "module.exports=[835717,(A,e,t)=>{\"use strict\";let r=A.r(57328),{addAbortListener:s}=A.r(687769),{Rea"
+      ],
+      [
+        0.7,
+        "module.exports=[594108,806176,674750,98746,t=>{\"use strict\";var i;let r;function n(t){return t}funct"
+      ],
+      [
+        0.7,
+        "module.exports=[144056,t=>{\"use strict\";let i,n;function r(t){return t}function a(t){return t}functi"
+      ],
+      [
+        0.5,
+        "'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); // these aren't reall"
+      ],
+      [
+        0.5,
+        "import assert from 'node:assert'; import { indexKeysRaw, indexIncludeRaw, indexPredicateRaw, display"
+      ],
+      [
+        0.5,
+        "module.exports=[21025,(e,t,r)=>{t.exports=e.x(\"next/dist/build/adapter/setup-node-env.external.js\",("
+      ],
+      [
+        0.4,
+        "(()=>{var e,t,r={\"./dist/compiled/@edge-runtime/cookies/index.js\"(e){\"use strict\";var t=Object.defin"
+      ],
+      [
+        0.3,
+        "(()=>{var e={975:(e,t,i)=>{const r=i(485);const{isObject:s,isArray:n}=i(648);const a=\"before\";const "
+      ],
+      [
+        0.3,
+        "(()=>{var a={32:(a,e,i)=>{\"use strict\"; /*! * accepts * Copyright(c) 2014 Jonathan Ong * Copyrigh"
+      ],
+      [
+        0.2,
+        "/* eslint-disable no-restricted-syntax -- everything above the v42 entry keeps its original SQL verb"
+      ],
+      [
+        0.2,
+        "\"use strict\";var pu=Object.create;var xr=Object.defineProperty;var du=Object.getOwnPropertyDescripto"
+      ],
+      [
+        0.2,
+        "\"use strict\"; Object.defineProperty(exports, \"__esModule\", { value: true }); 0 && (module.export"
+      ]
+    ],
+    "topRetainers": [
+      {
+        "mb": 33.9,
+        "name": "object:yr",
+        "path": "[1] > [10] > 15 > extension > global > prisma > [1] > _engine"
+      },
+      {
+        "mb": 10,
+        "name": "object:Object",
+        "path": "tX > onClose > onClose > context > system / Context > previous > system / Context > e > Context > __proto__ > c"
+      },
+      {
+        "mb": 9.8,
+        "name": "code:.next/server/chu",
+        "path": "system / Context > timerListMap > Object > [120000] > TimersList > _idleNext > Timeout > _onTimeout >  > shared > script"
+      },
+      {
+        "mb": 9.7,
+        "name": "code:.next/server/chu",
+        "path": "Module > _cache > Object > .next/server/chunks/_09yxiz_._.js > Module > exports > Array > [1] >  > shared > script"
+      },
+      {
+        "mb": 7.4,
+        "name": "object:system / Context",
+        "path": "Node / PrincipalRealm > base_object_list > Node / BaseObjectList > [25] > Node / ModuleWrap > native_to_javascript > ModuleWrap > 2 > [4] > context"
+      },
+      {
+        "mb": 5.6,
+        "name": "code:.next/server/chu",
+        "path": "global > prisma > [1] > t > _engineConfig > Object > compilerWasm > Object > getRuntime > getRuntime > shared > script"
+      },
+      {
+        "mb": 5.6,
+        "name": "code:.next/server/chu",
+        "path": "Module > _cache > Object > .next/server/chunks/_0hfea7u._.js > Module > exports > Array > [1] >  > shared > script"
+      },
+      {
+        "mb": 4.4,
+        "name": "object:Generator",
+        "path": "[6] > principal_realm > Node / PrincipalRealm > base_object_list > Node / BaseObjectList > [26] > Node / ModuleWrap > native_to_javascript > ModuleWrap > 2 > [4]"
+      },
+      {
+        "mb": 4.4,
+        "name": "string:AGFzbQEAAAABtgRLYAN/f38Bf2ACf38Bf2ACf38AYAF/AGADf39/AGAEf39/",
+        "path": "[1] > [21] > 59867"
+      },
+      {
+        "mb": 3.7,
+        "name": "code:.next/server/chu",
+        "path": "[1] > [10] > 15 > extension > global > __healthlog_pgboss__ > PgBoss > _events > Object > error >  > shared > script"
+      },
+      {
+        "mb": 3.6,
+        "name": "object:Client",
+        "path": "Object > close >  > context > system / Context > self > Connection > _events > Object > parseComplete > bound_this"
+      }
+    ],
+    "sourceStringsMb": 44.2
+  }
+}
diff --git a/scripts/bench/results/v1.45.0-before-boot.md b/scripts/bench/results/v1.45.0-before-boot.md
new file mode 100644
index 000000000..0e47a9786
--- /dev/null
+++ b/scripts/bench/results/v1.45.0-before-boot.md
@@ -0,0 +1,221 @@
+# Boot profile v1.45.0-before-boot
+
+Commit 0f6d668df, 2026-10-22T04:36:55.826Z. Production build, every role, heap ceiling 792 MB, 300 s idle. 14 cores, load average 9.3,9.4,11.2 at the end.
+
+- first answer from /api/health: 1590 ms; background role ready: 5432 ms
+- event-loop stalls logged: 0, max 0 ms
+
+## Stalls
+
+
+## Heap samples
+
+| at s | used MB | old | large obj | code | external | array buffers | rss |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 6 | 184 | 105 | 68 | 4 | 11 | 0 | 267 |
+| 308 | 164 | 99 | 58 | 5 | 11 | 0 | 623 |
+
+## Full collections (mark-compact)
+
+47 mark-compacts during the run. Used heap before the collection, and what survived it (the live heap):
+
+| at s | before MB | after MB |
+| ---: | ---: | ---: |
+| 0 | 21.4 | 17.4 |
+| 9 | 189.6 | 172.9 |
+| 154 | 193.8 | 171.6 |
+| 170 | 187.3 | 161.7 |
+| 188 | 181.6 | 163.6 |
+| 205 | 182.3 | 163.6 |
+| 222 | 190.6 | 165 |
+| 239 | 182.9 | 163.4 |
+| 258 | 190.5 | 163.7 |
+| 274 | 187.7 | 164.2 |
+| 290 | 193.9 | 164.2 |
+| 306 | 175.3 | 163.9 |
+| 309 | 174 | 163.7 |
+
+## Main-thread busy stretches over 50 ms without an idle sample, first two minutes
+
+### at 5 ms, 279 ms
+
+| self time by module | ms |
+| --- | ---: |
+| (native) | 122.3 |
+| npm:next | 57.1 |
+| node:internal/modules/cjs/loader | 41.7 |
+| node:internal/bootstrap/realm | 24.7 |
+| node:fs | 5.3 |
+| node:internal/deps/undici/undici | 5.3 |
+| node:internal/modules/package_json_reader | 4.5 |
+| node:path | 4 |
+| node:internal/streams/destroy | 1.5 |
+| node:internal/deps/cjs-module-lexer/lexer | 1.5 |
+
+| inclusive, application modules | ms |
+| --- | ---: |
+
+### at 339 ms, 324 ms
+
+| self time by module | ms |
+| --- | ---: |
+| (native) | 87.6 |
+| node:internal/modules/cjs/loader | 54.2 |
+| npm:@prisma/client | 38 |
+| wasm://wasm/00d1cb12 | 36 |
+| node:internal/modules/esm/utils | 26.7 |
+| turbopack:///[turbopack]/nodejs/runtime/build-base.ts | 24.9 |
+| npm:next | 22.1 |
+| npm:zod | 6 |
+| turbopack:///[turbopack]/shared/runtime/runtime-utils.ts | 3.1 |
+| npm:@prisma/client-runtime-utils | 3 |
+
+| inclusive, application modules | ms |
+| --- | ---: |
+| src/instrumentation.ts | 80.6 |
+| src/lib/db-session.ts | 60.7 |
+| src/lib/notifications/types.ts | 13.2 |
+| src/lib/boot/readiness-summary.ts | 13.2 |
+| src/lib/ai/local-host-allowlist.ts | 13.2 |
+| src/generated/prisma/internal/class.ts | 7.3 |
+| src/lib/logging/context.ts | 6 |
+| src/lib/crypto.ts | 6 |
+| src/lib/boot/key-check.ts | 6 |
+| src/lib/validations/measurement.ts | 3 |
+
+### at 698 ms, 753 ms
+
+| self time by module | ms |
+| --- | ---: |
+| node:internal/modules/cjs/loader | 178.2 |
+| turbopack:///[turbopack]/nodejs/runtime/build-base.ts | 177.4 |
+| (native) | 83.8 |
+| npm:zod | 39.5 |
+| npm:next | 34.6 |
+| turbopack:///[turbopack]/shared/runtime/async-module.ts | 33.9 |
+| npm:mmdb-lib | 26.1 |
+| node:fs | 23.5 |
+| npm:yaml | 22.4 |
+| src/lib/activity/goal-bounds.ts | 18.5 |
+
+| inclusive, application modules | ms |
+| --- | ---: |
+| src/instrumentation.ts | 410 |
+| src/lib/jobs/reminder/register-maintenance.ts | 279.5 |
+| src/lib/sharing/acting-session.ts | 138.5 |
+| src/lib/jobs/offhost-backup.ts | 137.1 |
+| src/lib/integrations/oauth-refresh.ts | 136.3 |
+| src/lib/jobs/morning-digest-refresh-shared.ts | 136.3 |
+| src/lib/export/environment-backup.ts | 134.1 |
+| src/lib/export/full-backup-payload.ts | 134.1 |
+| src/app/api/health/route.ts | 127.5 |
+| src/lib/insights/snapshot-hash.ts | 124.9 |
+
+## Self time by module until the worker is ready
+
+| module | ms |
+| --- | ---: |
+| (native) | 524.6 |
+| node:internal/modules/cjs/loader | 274 |
+| turbopack:///[turbopack]/nodejs/runtime/build-base.ts | 202.3 |
+| npm:next | 136.8 |
+| wasm://wasm/00d1cb12 | 108.1 |
+| npm:@prisma/client | 76.1 |
+| npm:pg | 56.5 |
+| npm:zod | 45.5 |
+| node:internal/modules/esm/utils | 41.4 |
+| npm:luxon | 38.5 |
+| turbopack:///[turbopack]/shared/runtime/async-module.ts | 35.3 |
+| node:fs | 31.7 |
+| node:internal/bootstrap/realm | 28.9 |
+| npm:pg-protocol | 27.7 |
+| npm:mmdb-lib | 26.1 |
+| npm:yaml | 22.4 |
+| npm:pg-boss | 19.3 |
+| src/lib/activity/goal-bounds.ts | 18.5 |
+| node:internal/process/task_queues | 17.7 |
+| node:internal/streams/readable | 15.5 |
+| node:internal/async_hooks | 15.1 |
+| npm:cron-parser | 14.6 |
+| node:internal/timers | 12.8 |
+| turbopack:///[turbopack]/shared/runtime/runtime-utils.ts | 12.4 |
+| node:buffer | 11.6 |
+
+## Heap snapshot after 300 s idle (live heap after a full GC)
+
+172.3 MB in 1412114 nodes; module source strings over 50 KB: 44.2 MB.
+
+- parsed locale catalogs: 32 objects, 14.1 MB retained
+
+| node type | MB |
+| --- | ---: |
+| string | 79.1 |
+| array | 27.6 |
+| code | 18.6 |
+| object | 16.7 |
+| hidden | 9.3 |
+| native | 8 |
+| object shape | 5.8 |
+| closure | 5 |
+| concatenated string | 1.3 |
+| number | 0.4 |
+| regexp | 0.2 |
+| sliced string | 0.2 |
+| synthetic | 0 |
+| symbol | 0 |
+| bigint | 0 |
+
+| constructor | MB | count |
+| --- | ---: | ---: |
+| array:(object elements) | 20.6 | 24726 |
+| object:Object | 11.9 | 300844 |
+| native:system / JSArrayBufferData | 7.5 | 169 |
+| array:(object properties) | 4.4 | 6540 |
+| array: | 2.7 | 9578 |
+| object:system / Context | 1.6 | 28887 |
+| closure: | 1.5 | 27081 |
+| object:Date1 | 1 | 10632 |
+| closure:native_bind | 0.9 | 20134 |
+| object:Array | 0.6 | 19550 |
+| object:a | 0.4 | 3880 |
+| native:Node / histogram | 0.4 | 1 |
+| closure:get | 0.3 | 4717 |
+| object:Set | 0.2 | 5102 |
+| closure:set | 0.2 | 3414 |
+| object:d | 0.2 | 3874 |
+| object:Module | 0.1 | 1907 |
+| object:Promise | 0.1 | 1590 |
+| closure:n | 0.1 | 1400 |
+| closure:i | 0.1 | 1390 |
+
+| largest retained subtrees | MB | retaining path |
+| --- | ---: | --- |
+| object:yr | 33.9 | [1] > [10] > 15 > extension > global > prisma > [1] > _engine |
+| object:Object | 10 | tX > onClose > onClose > context > system / Context > previous > system / Context > e > Context > __proto__ > c |
+| code:.next/server/chu | 9.8 | system / Context > timerListMap > Object > [120000] > TimersList > _idleNext > Timeout > _onTimeout >  > shared > script |
+| code:.next/server/chu | 9.7 | Module > _cache > Object > .next/server/chunks/_09yxiz_._.js > Module > exports > Array > [1] >  > shared > script |
+| object:system / Context | 7.4 | Node / PrincipalRealm > base_object_list > Node / BaseObjectList > [25] > Node / ModuleWrap > native_to_javascript > ModuleWrap > 2 > [4] > context |
+| code:.next/server/chu | 5.6 | global > prisma > [1] > t > _engineConfig > Object > compilerWasm > Object > getRuntime > getRuntime > shared > script |
+| code:.next/server/chu | 5.6 | Module > _cache > Object > .next/server/chunks/_0hfea7u._.js > Module > exports > Array > [1] >  > shared > script |
+| object:Generator | 4.4 | [6] > principal_realm > Node / PrincipalRealm > base_object_list > Node / BaseObjectList > [26] > Node / ModuleWrap > native_to_javascript > ModuleWrap > 2 > [4 |
+| string:AGFzbQEAAAABtgRLYAN/f38Bf2ACf38Bf2ACf38AYAF/AGADf39/AGAEf39/ | 4.4 | [1] > [21] > 59867 |
+| code:.next/server/chu | 3.7 | [1] > [10] > 15 > extension > global > __healthlog_pgboss__ > PgBoss > _events > Object > error >  > shared > script |
+| object:Client | 3.6 | Object > close >  > context > system / Context > self > Connection > _events > Object > parseComplete > bound_this |
+
+| largest strings | MB |
+| --- | ---: |
+| module.exports=[425781,(e,a,i)=>{a.exports=JSON.parse('{"common":{"listCapped":"Hier stehe | 9.7 |
+| module.exports=[157893,(e,a,i)=>{a.exports=JSON.parse('{"common":{"listCapped":"Hier stehe | 9.7 |
+| module.exports=[17856,A=>{"use strict";var e,C,g,I,Q=Object.defineProperty,B={},s={$:()=>i | 5.6 |
+| module.exports=[234494,A=>{"use strict";var e,C,g,I,Q=Object.defineProperty,B={},s={$:()=> | 5.6 |
+| const wasm = "AGFzbQEAAAABtgRLYAN/f38Bf2ACf38Bf2ACf38AYAF/AGADf39/AGAEf39/fwBgBX9/f39/AGAB | 4.4 |
+| AGFzbQEAAAABtgRLYAN/f38Bf2ACf38Bf2ACf38AYAF/AGADf39/AGAEf39/fwBgBX9/f39/AGABfwF/YAZ/f39/f3 | 4.4 |
+| module.exports=[799092,(e,t,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value: | 3.7 |
+| lliADOAUngIEAACgKwAgBgAAoSsAIAcAAKErACAIAACiKwAgCQAAoysAIAoAAKQrACALAAClKwAgDAAApisAIA0AAK | 1.9 |
+| (()=>{var e,t,r={"./dist/build/webpack/alias/react-dom-server.js"(e,t,r){"use strict";var  | 1.3 |
+| module.exports=[842865,(e,t,r)=>{let i=e.r(522734);t.exports=function(e){return e?/-----BE | 1.2 |
+| module.exports=[834886,(e,t,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value: | 1.1 |
+| // v1.4.34 web-freeze. Schema is locked additive-only until iOS launch // + v1.5.0 marker. | 1.1 |
+| module.exports=[971743,(A,e,t)=>{"use strict";let r=A.r(57328),{addAbortListener:s}=A.r(68 | 1.1 |
+| module.exports=[835717,(A,e,t)=>{"use strict";let r=A.r(57328),{addAbortListener:s}=A.r(68 | 1 |
+| module.exports=[594108,806176,674750,98746,t=>{"use strict";var i;let r;function n(t){retu | 0.7 |