@yetanotheraryan/coldstart 1.0.0

package/dist/index.js

@@ -0,0 +1,816 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  monitor: () => monitor,
+  renderFlamegraphHtml: () => renderFlamegraphHtml,
+  renderJsonReport: () => renderJsonReport,
+  renderTextReport: () => renderTextReport,
+  report: () => report
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/cjs.ts
+var import_module = require("module");
+
+// src/tracer.ts
+var import_perf_hooks = require("perf_hooks");
+var Tracer = class {
+  events = [];
+  startTime = performance.now();
+  histogram = null;
+  constructor() {
+    try {
+      this.histogram = (0, import_perf_hooks.monitorEventLoopDelay)({ resolution: 5 });
+      this.histogram.enable();
+    } catch {
+      this.histogram = null;
+    }
+  }
+  /**
+   * Called by cjs.ts for every require() interception.
+   * Appends to the flat event list — tree is built lazily on report().
+   */
+  record(event) {
+    this.events.push(event);
+  }
+  /**
+   * Mark startup as complete and return the full report.
+   * Call this after your server/app signals it's ready.
+   */
+  report() {
+    const totalStartupMs = performance.now() - this.startTime;
+    if (this.histogram) {
+      this.histogram.disable();
+    }
+    const tree = this.buildTree();
+    const flat = this.flatten(tree).sort((a, b) => b.inclusiveMs - a.inclusiveMs);
+    const slowest = [...flat].filter((n) => !n.cached && !n.isBuiltin).sort((a, b) => b.exclusiveMs - a.exclusiveMs).slice(0, 10);
+    const nodeModuleTime = flat.filter((n) => n.isNodeModule && !n.cached).reduce((sum, n) => sum + n.exclusiveMs, 0);
+    const firstPartyTime = flat.filter((n) => !n.isNodeModule && !n.isBuiltin && !n.cached).reduce((sum, n) => sum + n.exclusiveMs, 0);
+    return {
+      totalStartupMs,
+      eventLoop: {
+        maxBlockMs: this.histogram ? this.histogram.max / 1e6 : 0,
+        meanBlockMs: this.histogram ? this.histogram.mean / 1e6 : 0,
+        p99BlockMs: this.histogram ? this.histogram.percentile(99) / 1e6 : 0
+      },
+      tree,
+      flat,
+      slowest,
+      nodeModuleTime,
+      firstPartyTime,
+      totalModulesLoaded: this.events.length,
+      cachedModulesCount: this.events.filter((e) => e.cached).length
+    };
+  }
+  /**
+   * Build the parent→child tree from the flat event list.
+   *
+   * Strategy:
+   * 1. Create a ModuleNode for each event
+   * 2. Wire children to parents using parentPath
+   * 3. Compute exclusive time = inclusive - sum(children inclusive)
+   * 4. Assign depth via BFS from roots
+   */
+  buildTree() {
+    const nodes = this.events.map((e) => ({
+      id: e.id,
+      request: e.request,
+      resolvedPath: e.resolvedPath,
+      parentPath: e.parentPath,
+      inclusiveMs: e.durationMs,
+      exclusiveMs: e.durationMs,
+      // will be adjusted below
+      cached: e.cached,
+      isNodeModule: e.isNodeModule,
+      isBuiltin: e.isBuiltin,
+      children: [],
+      depth: 0
+    }));
+    const byPath = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const existing = byPath.get(node.resolvedPath) ?? [];
+      existing.push(node);
+      byPath.set(node.resolvedPath, existing);
+    }
+    const roots = [];
+    for (const node of nodes) {
+      if (node.parentPath === "<entry>") {
+        roots.push(node);
+        continue;
+      }
+      const parentNodes = byPath.get(node.parentPath);
+      if (parentNodes && parentNodes.length > 0) {
+        parentNodes[parentNodes.length - 1].children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+    const computeExclusive = (node) => {
+      for (const child of node.children) {
+        computeExclusive(child);
+      }
+      const childrenInclusiveSum = node.children.reduce(
+        (sum, c) => sum + c.inclusiveMs,
+        0
+      );
+      node.exclusiveMs = Math.max(0, node.inclusiveMs - childrenInclusiveSum);
+    };
+    for (const root of roots) {
+      computeExclusive(root);
+    }
+    const assignDepth = (node, depth) => {
+      node.depth = depth;
+      for (const child of node.children) {
+        assignDepth(child, depth + 1);
+      }
+    };
+    for (const root of roots) {
+      assignDepth(root, 0);
+    }
+    return roots;
+  }
+  /**
+   * Flatten the tree into a list (pre-order DFS).
+   */
+  flatten(nodes) {
+    const result = [];
+    const visit = (node) => {
+      result.push(node);
+      for (const child of node.children) {
+        visit(child);
+      }
+    };
+    for (const node of nodes) {
+      visit(node);
+    }
+    return result;
+  }
+  /**
+   * Reset — useful for testing multiple startups in the same process.
+   */
+  reset() {
+    this.events = [];
+    this.startTime = performance.now();
+    if (this.histogram) {
+      this.histogram.reset();
+      this.histogram.enable();
+    }
+  }
+  /** Expose raw events for testing */
+  getRawEvents() {
+    return [...this.events];
+  }
+};
+var tracer = new Tracer();
+
+// src/cjs.ts
+var originalLoad = import_module.Module._load;
+var callStack = [];
+import_module.Module._load = function coldstartLoad(request, parent, isMain) {
+  let resolvedFilename;
+  try {
+    resolvedFilename = import_module.Module._resolveFilename(request, parent, isMain);
+  } catch {
+    return originalLoad.apply(this, arguments);
+  }
+  const isCached = !!import_module.Module._cache[resolvedFilename];
+  const isBuiltin = import_module.Module.isBuiltin?.(request) ?? isBuiltinModule(request);
+  const parentFilename = callStack.length > 0 ? callStack[callStack.length - 1] : parent?.filename ?? "<entry>";
+  callStack.push(resolvedFilename);
+  const startTime = performance.now();
+  let result;
+  try {
+    result = originalLoad.apply(this, arguments);
+  } finally {
+    callStack.pop();
+    if (!isBuiltin) {
+      const duration = performance.now() - startTime;
+      tracer.record({
+        id: resolvedFilename,
+        request,
+        // original string passed to require()
+        resolvedPath: resolvedFilename,
+        parentPath: parentFilename,
+        durationMs: duration,
+        startTime,
+        cached: isCached,
+        isNodeModule: resolvedFilename.includes("node_modules"),
+        isBuiltin: false
+      });
+    }
+  }
+  return result;
+};
+var originalResolveFilename = import_module.Module._resolveFilename;
+import_module.Module._resolveFilename = function coldstartResolve(request, parent, isMain, options) {
+  if (import_module.Module.isBuiltin?.(request) ?? isBuiltinModule(request)) {
+    const parentFilename = callStack.length > 0 ? callStack[callStack.length - 1] : parent?.filename ?? "<entry>";
+    tracer.record({
+      id: `builtin:${request}`,
+      request,
+      resolvedPath: `builtin:${request}`,
+      parentPath: parentFilename,
+      durationMs: 0,
+      startTime: performance.now(),
+      cached: true,
+      isNodeModule: false,
+      isBuiltin: true
+    });
+  }
+  return originalResolveFilename.apply(this, arguments);
+};
+function isBuiltinModule(name) {
+  const builtins = /* @__PURE__ */ new Set([
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "sys",
+    "timers",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib"
+  ]);
+  const stripped = name.startsWith("node:") ? name.slice(5) : name;
+  return builtins.has(stripped);
+}
+
+// src/reporter/text.ts
+var BAR_WIDTH = 18;
+var ANSI_RESET = "\x1B[0m";
+var ANSI_RED = "\x1B[31m";
+var ANSI_YELLOW = "\x1B[33m";
+var ANSI_GREEN = "\x1B[32m";
+var ANSI_DIM = "\x1B[2m";
+function renderTextReport(report2, options = {}) {
+  const color = options.color ?? true;
+  const barWidth = options.barWidth ?? BAR_WIDTH;
+  const showSummary = options.showSummary ?? true;
+  const displayTree = collapseDisplayNoise(report2.tree);
+  const maxInclusiveMs = Math.max(
+    1,
+    ...report2.flat.filter((node) => !node.cached).map((node) => node.inclusiveMs)
+  );
+  const lines = [
+    `coldstart - ${formatDuration(report2.totalStartupMs)} total startup`,
+    ""
+  ];
+  for (let index = 0; index < displayTree.length; index += 1) {
+    const isLastRoot = index === displayTree.length - 1;
+    const root = displayTree[index];
+    lines.push(...renderNode(root, "", isLastRoot, maxInclusiveMs, barWidth, color));
+  }
+  if (showSummary) {
+    if (displayTree.length > 0) {
+      lines.push("");
+    }
+    lines.push(
+      `${dim("event loop")} max ${formatDuration(report2.eventLoop.maxBlockMs)}, p99 ${formatDuration(report2.eventLoop.p99BlockMs)}, mean ${formatDuration(report2.eventLoop.meanBlockMs)}`,
+      `${dim("modules")} ${report2.totalModulesLoaded} total, ${report2.cachedModulesCount} cached`,
+      `${dim("time split")} ${formatDuration(report2.firstPartyTime)} first-party, ${formatDuration(report2.nodeModuleTime)} node_modules`
+    );
+  }
+  return lines.join("\n");
+  function dim(value) {
+    return colorize(value, ANSI_DIM, color);
+  }
+}
+function collapseDisplayNoise(nodes) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const collapsedChildren = collapseDisplayNoise(node.children);
+    const collapsedNode = {
+      ...node,
+      children: collapsedChildren
+    };
+    if (shouldCollapseBuiltinNode(collapsedNode)) {
+      const key = [
+        collapsedNode.request,
+        collapsedNode.depth
+      ].join("|");
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+    }
+    result.push(collapsedNode);
+  }
+  return result;
+}
+function shouldCollapseBuiltinNode(node) {
+  return node.isBuiltin && node.cached && node.inclusiveMs === 0 && node.children.length === 0;
+}
+function renderNode(node, prefix, isLast, maxInclusiveMs, barWidth, color) {
+  const branch = prefix.length === 0 ? isLast ? "\u2514\u2500 " : "\u250C\u2500 " : `${prefix}${isLast ? "\u2514\u2500 " : "\u251C\u2500 "}`;
+  const nextPrefix = prefix.length === 0 ? isLast ? "   " : "\u2502  " : `${prefix}${isLast ? "   " : "\u2502  "}`;
+  const label = formatLabel(node);
+  const duration = formatDuration(node.inclusiveMs).padStart(6);
+  const durationColor = getDurationColor(node.inclusiveMs);
+  const bar = renderBar(node.inclusiveMs, maxInclusiveMs, barWidth);
+  const suffix = node.inclusiveMs >= 100 ? `  ${colorize("! slow", ANSI_RED, color)}` : "";
+  const line = `${branch}${label.padEnd(18)} ${colorize(duration, durationColor, color)}  ${colorize(bar, durationColor, color)}${suffix}`;
+  const lines = [line];
+  for (let index = 0; index < node.children.length; index += 1) {
+    const child = node.children[index];
+    const isLastChild = index === node.children.length - 1;
+    lines.push(...renderNode(child, nextPrefix, isLastChild, maxInclusiveMs, barWidth, color));
+  }
+  return lines;
+}
+function formatLabel(node) {
+  if (node.isBuiltin) {
+    return node.request.replace(/^node:/, "");
+  }
+  if (node.isNodeModule) {
+    return packageNameFromRequest(node.request);
+  }
+  const normalizedPath = normalizeModulePath(node);
+  const segments = normalizedPath.split("/");
+  const base = segments[segments.length - 1] ?? "";
+  return base.length > 0 ? base : node.request;
+}
+function normalizeModulePath(node) {
+  if (looksLikeRelativeRequest(node.request)) {
+    return node.request.replace(/\\/g, "/");
+  }
+  if (node.resolvedPath.startsWith("file://")) {
+    try {
+      return decodeURIComponent(new URL(node.resolvedPath).pathname).replace(/\\/g, "/");
+    } catch {
+      return node.resolvedPath.replace(/\\/g, "/");
+    }
+  }
+  return node.resolvedPath.replace(/\\/g, "/");
+}
+function looksLikeRelativeRequest(request) {
+  return request.startsWith("./") || request.startsWith("../") || request.startsWith("/");
+}
+function packageNameFromRequest(request) {
+  if (request.startsWith("@")) {
+    const [scope, name2] = request.split("/");
+    return name2 ? `${scope}/${name2}` : request;
+  }
+  const [name] = request.split("/");
+  return name || request;
+}
+function renderBar(durationMs, maxInclusiveMs, barWidth) {
+  const filled = Math.max(1, Math.round(durationMs / maxInclusiveMs * barWidth));
+  return `${"\u2588".repeat(Math.min(barWidth, filled))}${"\u2591".repeat(Math.max(0, barWidth - filled))}`;
+}
+function formatDuration(valueMs) {
+  if (!Number.isFinite(valueMs)) {
+    return "0ms";
+  }
+  if (valueMs >= 1e3) {
+    return `${Math.round(valueMs)}ms`;
+  }
+  if (valueMs >= 100) {
+    return `${Math.round(valueMs)}ms`;
+  }
+  if (valueMs >= 10) {
+    return `${valueMs.toFixed(1).replace(/\.0$/, "")}ms`;
+  }
+  return `${valueMs.toFixed(2).replace(/0+$/, "").replace(/\.$/, "")}ms`;
+}
+function getDurationColor(durationMs) {
+  if (durationMs > 100) {
+    return ANSI_RED;
+  }
+  if (durationMs >= 20) {
+    return ANSI_YELLOW;
+  }
+  return ANSI_GREEN;
+}
+function colorize(value, code, enabled) {
+  if (!enabled) {
+    return value;
+  }
+  return `${code}${value}${ANSI_RESET}`;
+}
+
+// src/reporter/json.ts
+function renderJsonReport(report2, options = {}) {
+  return `${JSON.stringify(report2, jsonReplacer, options.pretty === false ? 0 : 2)}
+`;
+}
+function jsonReplacer(_key, value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return 0;
+  }
+  return value;
+}
+
+// src/reporter/flamegraph.ts
+function renderFlamegraphHtml(report2) {
+  const total = Math.max(report2.totalStartupMs, 1);
+  const frames = buildFrames(report2.tree);
+  const maxDepth = frames.reduce((depth, frame) => Math.max(depth, frame.depth), 0);
+  const payload = JSON.stringify({
+    totalStartupMs: report2.totalStartupMs,
+    eventLoop: report2.eventLoop,
+    totalModulesLoaded: report2.totalModulesLoaded,
+    cachedModulesCount: report2.cachedModulesCount,
+    frames,
+    maxDepth
+  });
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>coldstart flamegraph</title>
+  <style>
+    :root {
+      --bg: #f7f2e8;
+      --panel: rgba(255, 252, 246, 0.92);
+      --border: #d8c9ae;
+      --text: #2c2418;
+      --muted: #6b5c48;
+      --grid: rgba(117, 95, 63, 0.15);
+      --builtin: #8fb8a8;
+      --node-module: #e09f5a;
+      --first-party: #c8553d;
+      --cached: #b9b0a3;
+    }
+
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: "IBM Plex Sans", "Avenir Next", sans-serif;
+      color: var(--text);
+      background:
+        radial-gradient(circle at top left, rgba(232, 171, 96, 0.28), transparent 28%),
+        radial-gradient(circle at top right, rgba(114, 155, 121, 0.18), transparent 25%),
+        linear-gradient(180deg, #fbf6ee 0%, var(--bg) 100%);
+    }
+
+    .page {
+      max-width: 1280px;
+      margin: 0 auto;
+      padding: 32px 20px 48px;
+    }
+
+    .hero {
+      display: grid;
+      gap: 10px;
+      margin-bottom: 20px;
+    }
+
+    h1 {
+      margin: 0;
+      font-size: clamp(28px, 4vw, 48px);
+      line-height: 0.95;
+      letter-spacing: -0.04em;
+    }
+
+    .subtle {
+      color: var(--muted);
+      font-size: 14px;
+    }
+
+    .stats {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 12px;
+      margin: 18px 0 24px;
+    }
+
+    .stat {
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 14px;
+      padding: 12px 14px;
+      min-width: 150px;
+      backdrop-filter: blur(6px);
+    }
+
+    .stat strong {
+      display: block;
+      font-size: 20px;
+      margin-bottom: 4px;
+    }
+
+    .legend {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 12px;
+      margin-bottom: 14px;
+      font-size: 13px;
+      color: var(--muted);
+    }
+
+    .legend span {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .swatch {
+      width: 12px;
+      height: 12px;
+      border-radius: 3px;
+      border: 1px solid rgba(0, 0, 0, 0.08);
+    }
+
+    .chart {
+      position: relative;
+      overflow: auto;
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 18px;
+      padding: 14px;
+      box-shadow: 0 20px 50px rgba(102, 75, 44, 0.08);
+    }
+
+    .chart-grid {
+      position: absolute;
+      inset: 14px;
+      pointer-events: none;
+      background-image:
+        linear-gradient(to right, var(--grid) 1px, transparent 1px),
+        linear-gradient(to bottom, rgba(117, 95, 63, 0.08) 1px, transparent 1px);
+      background-size: 10% 100%, 100% 32px;
+    }
+
+    #flamegraph {
+      position: relative;
+      min-width: 960px;
+    }
+
+    .frame {
+      position: absolute;
+      height: 26px;
+      border-radius: 6px;
+      overflow: hidden;
+      border: 1px solid rgba(44, 36, 24, 0.08);
+      cursor: default;
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.22);
+    }
+
+    .frame span {
+      display: block;
+      padding: 5px 8px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      font-size: 12px;
+      font-weight: 600;
+    }
+
+    .tooltip {
+      position: fixed;
+      z-index: 10;
+      max-width: 320px;
+      padding: 10px 12px;
+      border-radius: 12px;
+      background: rgba(44, 36, 24, 0.96);
+      color: #fff9ef;
+      font-size: 12px;
+      line-height: 1.4;
+      pointer-events: none;
+      opacity: 0;
+      transform: translateY(6px);
+      transition: opacity 120ms ease, transform 120ms ease;
+      box-shadow: 0 12px 30px rgba(0, 0, 0, 0.25);
+    }
+
+    .tooltip.visible {
+      opacity: 1;
+      transform: translateY(0);
+    }
+  </style>
+</head>
+<body>
+  <div class="page">
+    <div class="hero">
+      <div class="subtle">Node.js startup profile</div>
+      <h1>coldstart flamegraph</h1>
+      <div class="subtle">Inclusive module load time laid out across startup from left to right.</div>
+    </div>
+
+    <div class="stats">
+      <div class="stat"><strong>${formatMs(report2.totalStartupMs)}</strong><span>Total startup</span></div>
+      <div class="stat"><strong>${report2.totalModulesLoaded}</strong><span>Modules loaded</span></div>
+      <div class="stat"><strong>${report2.cachedModulesCount}</strong><span>Cached requires</span></div>
+      <div class="stat"><strong>${formatMs(report2.eventLoop.maxBlockMs)}</strong><span>Max event loop block</span></div>
+    </div>
+
+    <div class="legend">
+      <span><i class="swatch" style="background: var(--first-party)"></i>First-party</span>
+      <span><i class="swatch" style="background: var(--node-module)"></i>node_modules</span>
+      <span><i class="swatch" style="background: var(--builtin)"></i>Builtins</span>
+      <span><i class="swatch" style="background: var(--cached)"></i>Cached</span>
+    </div>
+
+    <div class="chart">
+      <div class="chart-grid"></div>
+      <div id="flamegraph"></div>
+    </div>
+  </div>
+
+  <div id="tooltip" class="tooltip"></div>
+
+  <script>
+    const data = ${payload};
+    const total = Math.max(data.totalStartupMs || ${total}, 1);
+    const rowHeight = 32;
+    const flamegraph = document.getElementById('flamegraph');
+    const tooltip = document.getElementById('tooltip');
+    flamegraph.style.height = ((data.maxDepth + 1) * rowHeight) + 'px';
+
+    const colorFor = (frame) => {
+      if (frame.cached) return 'var(--cached)';
+      if (frame.isBuiltin) return 'var(--builtin)';
+      if (frame.isNodeModule) return 'var(--node-module)';
+      return 'var(--first-party)';
+    };
+
+    for (const frame of data.frames) {
+      const element = document.createElement('div');
+      const width = Math.max((frame.value / total) * 100, 0.25);
+      element.className = 'frame';
+      element.style.left = (frame.start / total) * 100 + '%';
+      element.style.top = (frame.depth * rowHeight) + 'px';
+      element.style.width = width + '%';
+      element.style.background = colorFor(frame);
+      element.innerHTML = '<span>' + escapeHtml(frame.name) + '</span>';
+      element.addEventListener('mousemove', (event) => {
+        tooltip.innerHTML =
+          '<strong>' + escapeHtml(frame.name) + '</strong><br>' +
+          'Inclusive: ' + formatMs(frame.value) + '<br>' +
+          'Range: ' + formatMs(frame.start) + ' - ' + formatMs(frame.end) + '<br>' +
+          'Path: ' + escapeHtml(frame.path);
+        tooltip.style.left = (event.clientX + 14) + 'px';
+        tooltip.style.top = (event.clientY + 14) + 'px';
+        tooltip.classList.add('visible');
+      });
+      element.addEventListener('mouseleave', () => {
+        tooltip.classList.remove('visible');
+      });
+      flamegraph.appendChild(element);
+    }
+
+    function formatMs(value) {
+      if (!Number.isFinite(value)) return '0ms';
+      if (value >= 100) return Math.round(value) + 'ms';
+      if (value >= 10) return value.toFixed(1).replace(/\\.0$/, '') + 'ms';
+      return value.toFixed(2).replace(/0+$/, '').replace(/\\.$/, '') + 'ms';
+    }
+
+    function escapeHtml(value) {
+      return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+    }
+  </script>
+</body>
+</html>`;
+}
+function buildFrames(nodes) {
+  const frames = [];
+  for (const node of nodes) {
+    walk(node, 0, formatLabel2(node));
+  }
+  return frames;
+  function walk(node, start, trail) {
+    const end = start + node.inclusiveMs;
+    frames.push({
+      name: formatLabel2(node),
+      value: node.inclusiveMs,
+      depth: node.depth,
+      start,
+      end,
+      path: trail,
+      isBuiltin: node.isBuiltin,
+      isNodeModule: node.isNodeModule,
+      cached: node.cached
+    });
+    let childOffset = start;
+    for (const child of node.children) {
+      childOffset = walk(child, childOffset, `${trail} -> ${formatLabel2(child)}`);
+    }
+    return end;
+  }
+}
+function formatLabel2(node) {
+  if (node.isBuiltin) {
+    return node.request.replace(/^node:/, "");
+  }
+  if (node.isNodeModule) {
+    return packageNameFromRequest2(node.request);
+  }
+  const normalizedPath = normalizeModulePath2(node);
+  const segments = normalizedPath.split("/");
+  const base = segments[segments.length - 1] ?? "";
+  return base.length > 0 ? base : node.request || node.resolvedPath;
+}
+function normalizeModulePath2(node) {
+  if (looksLikeRelativeRequest2(node.request)) {
+    return node.request.replace(/\\/g, "/");
+  }
+  if (node.resolvedPath.startsWith("file://")) {
+    try {
+      return decodeURIComponent(new URL(node.resolvedPath).pathname).replace(/\\/g, "/");
+    } catch {
+      return node.resolvedPath.replace(/\\/g, "/");
+    }
+  }
+  return node.resolvedPath.replace(/\\/g, "/");
+}
+function looksLikeRelativeRequest2(request) {
+  return request.startsWith("./") || request.startsWith("../") || request.startsWith("/");
+}
+function packageNameFromRequest2(request) {
+  if (request.startsWith("@")) {
+    const [scope, name2] = request.split("/");
+    return name2 ? `${scope}/${name2}` : request;
+  }
+  const [name] = request.split("/");
+  return name || request;
+}
+function formatMs(value) {
+  if (!Number.isFinite(value)) {
+    return "0ms";
+  }
+  if (value >= 100) {
+    return `${Math.round(value)}ms`;
+  }
+  if (value >= 10) {
+    return `${value.toFixed(1).replace(/\.0$/, "")}ms`;
+  }
+  return `${value.toFixed(2).replace(/0+$/, "").replace(/\.$/, "")}ms`;
+}
+
+// src/index.ts
+function monitor() {
+  tracer.reset();
+  return () => tracer.report();
+}
+function report() {
+  return tracer.report();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  monitor,
+  renderFlamegraphHtml,
+  renderJsonReport,
+  renderTextReport,
+  report
+});