@mtharrison/pkg-profiler 2.0.0 → 2.2.0

package/src/dep-chain.ts

@@ -0,0 +1,111 @@
+/**
+ * Resolve dependency chains for transitive npm packages.
+ *
+ * BFS through node_modules package.json files starting from the project's
+ * direct dependencies to find the shortest path to each profiled package.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+interface PkgJson {
+  dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+}
+
+function readPkgJson(dir: string, cache: Map<string, PkgJson | null>): PkgJson | null {
+  if (cache.has(dir)) return cache.get(dir)!;
+  try {
+    const raw = readFileSync(join(dir, 'package.json'), 'utf-8');
+    const parsed = JSON.parse(raw) as PkgJson;
+    cache.set(dir, parsed);
+    return parsed;
+  } catch {
+    cache.set(dir, null);
+    return null;
+  }
+}
+
+function depsOf(pkg: PkgJson): string[] {
+  return [
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.optionalDependencies ?? {}),
+  ];
+}
+
+/**
+ * Resolve the shortest dependency chain from the project's direct deps
+ * to each of the given package names.
+ *
+ * @param projectRoot - Absolute path to the project root (contains package.json and node_modules/)
+ * @param packageNames - Set of package names that appeared in profiling data
+ * @param maxDepth - Maximum BFS depth to search (default 5)
+ * @returns Map from package name to chain array (e.g. `["express", "qs"]` means project -> express -> qs)
+ */
+export function resolveDependencyChains(
+  projectRoot: string,
+  packageNames: Set<string>,
+  maxDepth: number = 5,
+): Map<string, string[]> {
+  const result = new Map<string, string[]>();
+  const cache = new Map<string, PkgJson | null>();
+
+  const rootPkg = readPkgJson(projectRoot, cache);
+  if (!rootPkg) return result;
+
+  const directDeps = new Set(depsOf(rootPkg));
+
+  // Mark direct deps — they have no chain
+  for (const name of packageNames) {
+    if (directDeps.has(name)) {
+      // Direct dep: no chain needed (empty array signals "direct")
+    }
+  }
+
+  // Only need to resolve transitive deps
+  const targets = new Set<string>();
+  for (const name of packageNames) {
+    if (!directDeps.has(name)) {
+      targets.add(name);
+    }
+  }
+
+  if (targets.size === 0) return result;
+
+  // BFS: queue entries are [packageName, chain-so-far]
+  const visited = new Set<string>();
+  const queue: Array<[string, string[]]> = [];
+
+  for (const dep of directDeps) {
+    queue.push([dep, [dep]]);
+    visited.add(dep);
+  }
+
+  let qi = 0;
+  while (qi < queue.length && targets.size > 0) {
+    const [pkgName, chain] = queue[qi++]!;
+
+    if (chain.length > maxDepth) continue;
+
+    // If this package is one of our targets, record the chain (excluding the target itself)
+    if (targets.has(pkgName)) {
+      result.set(pkgName, chain.slice(0, -1));
+      targets.delete(pkgName);
+      if (targets.size === 0) break;
+    }
+
+    // Read this package's deps and enqueue
+    const pkgDir = join(projectRoot, 'node_modules', pkgName);
+    const pkg = readPkgJson(pkgDir, cache);
+    if (!pkg) continue;
+
+    for (const child of depsOf(pkg)) {
+      if (!visited.has(child)) {
+        visited.add(child);
+        queue.push([child, [...chain, child]]);
+      }
+    }
+  }
+
+  return result;
+}

package/src/pkg-profile.ts

@@ -31,6 +31,8 @@ export class PkgProfile {
   readonly projectName: string;
   /** Total async wait time in microseconds (undefined when async tracking not enabled) */
   readonly totalAsyncTimeUs?: number;
+  /** Elapsed wall time in microseconds from start() to stop() */
+  readonly wallTimeUs?: number;
 
   /** @internal */
   constructor(data: ReportData) {
@@ -40,6 +42,7 @@ export class PkgProfile {
     this.otherCount = data.otherCount;
     this.projectName = data.projectName;
     this.totalAsyncTimeUs = data.totalAsyncTimeUs;
+    this.wallTimeUs = data.wallTimeUs;
   }
 
   /**
@@ -56,6 +59,7 @@ export class PkgProfile {
       otherCount: this.otherCount,
       projectName: this.projectName,
       totalAsyncTimeUs: this.totalAsyncTimeUs,
+      wallTimeUs: this.wallTimeUs,
     };
     const html = renderHtml(data);
 

package/src/reporter/aggregate.ts

@@ -13,6 +13,7 @@ import type {
   FileEntry,
   FunctionEntry,
 } from '../types.js';
+import { resolveDependencyChains } from '../dep-chain.js';
 
 /**
  * Sum all microseconds in a SampleStore.
@@ -37,10 +38,13 @@ function sumStore(store: SampleStore): number {
  * @param asyncStore - Optional SampleStore with async wait time data
  * @returns ReportData with all packages sorted desc by time, no threshold applied
  */
-export function aggregate(store: SampleStore, projectName: string, asyncStore?: SampleStore): ReportData {
+export function aggregate(store: SampleStore, projectName: string, asyncStore?: SampleStore, globalAsyncTimeUs?: number, wallTimeUs?: number, projectRoot?: string): ReportData {
   // 1. Calculate total user-attributed time
   const totalTimeUs = sumStore(store);
+  // Per-entry percentages use the raw sum so they add up to 100%
   const totalAsyncTimeUs = asyncStore ? sumStore(asyncStore) : 0;
+  // Header total uses the merged (de-duplicated) global value when available
+  const headerAsyncTimeUs = globalAsyncTimeUs ?? totalAsyncTimeUs;
 
   if (totalTimeUs === 0 && totalAsyncTimeUs === 0) {
     return {
@@ -229,6 +233,22 @@ export function aggregate(store: SampleStore, projectName: string, asyncStore?:
     packages.push(pkgEntry);
   }
 
+  // Resolve dependency chains for non-first-party packages
+  if (projectRoot) {
+    const thirdPartyNames = new Set(
+      packages.filter(p => !p.isFirstParty).map(p => p.name),
+    );
+    if (thirdPartyNames.size > 0) {
+      const chains = resolveDependencyChains(projectRoot, thirdPartyNames);
+      for (const pkg of packages) {
+        const chain = chains.get(pkg.name);
+        if (chain && chain.length > 0) {
+          pkg.depChain = chain;
+        }
+      }
+    }
+  }
+
   // Sort packages by timeUs descending
   packages.sort((a, b) => b.timeUs - a.timeUs);
 
@@ -240,8 +260,12 @@ export function aggregate(store: SampleStore, projectName: string, asyncStore?:
     projectName,
   };
 
-  if (totalAsyncTimeUs > 0) {
-    result.totalAsyncTimeUs = totalAsyncTimeUs;
+  if (headerAsyncTimeUs > 0) {
+    result.totalAsyncTimeUs = headerAsyncTimeUs;
+  }
+
+  if (wallTimeUs !== undefined) {
+    result.wallTimeUs = wallTimeUs;
   }
 
   return result;

package/src/reporter/html.ts

@@ -9,6 +9,11 @@
 import type { ReportData, PackageEntry, FileEntry } from '../types.js';
 import { formatTime, formatPct, escapeHtml } from './format.js';
 
+function formatDepChain(depChain: string[] | undefined): string {
+  if (!depChain || depChain.length === 0) return '';
+  return `<span class="dep-chain">via ${depChain.map(n => escapeHtml(n)).join(' &gt; ')}</span>`;
+}
+
 function generateCss(): string {
   return `
     :root {
@@ -152,6 +157,7 @@ function generateCss(): string {
     }
 
     td.pkg-name { font-family: var(--font-mono); font-size: 0.85rem; }
+    .dep-chain { display: block; font-size: 0.7rem; color: var(--muted); font-family: var(--font-sans); }
     td.numeric { text-align: right; font-family: var(--font-mono); font-size: 0.85rem; }
     td.async-col { color: var(--bar-fill-async); }
 
@@ -295,9 +301,59 @@ function generateCss(): string {
     .other-item.indent-1 { padding-left: 2rem; }
     .other-item.indent-2 { padding-left: 3.25rem; }
 
+    /* Sort control */
+    .sort-control {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      margin-left: 1.5rem;
+      font-size: 0.85rem;
+    }
+
+    .sort-control label {
+      font-weight: 600;
+      color: var(--muted);
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+      font-size: 0.8rem;
+    }
+
+    .sort-toggle {
+      display: inline-flex;
+      border: 1px solid var(--border);
+      border-radius: 4px;
+      overflow: hidden;
+    }
+
+    .sort-toggle button {
+      font-family: var(--font-sans);
+      font-size: 0.8rem;
+      padding: 0.25rem 0.6rem;
+      border: none;
+      background: #fff;
+      color: var(--muted);
+      cursor: pointer;
+      transition: background 0.15s, color 0.15s;
+    }
+
+    .sort-toggle button + button {
+      border-left: 1px solid var(--border);
+    }
+
+    .sort-toggle button.active {
+      background: var(--bar-fill);
+      color: #fff;
+    }
+
+    .sort-toggle button.active-async {
+      background: var(--bar-fill-async);
+      color: #fff;
+    }
+
     @media (max-width: 600px) {
       body { padding: 1rem; }
       .bar-cell { width: 25%; }
+      .sort-control { margin-left: 0; margin-top: 0.5rem; }
     }
   `;
 }
@@ -331,14 +387,32 @@ function generateJs(): string {
       .replace(/'/g, '&#39;');
   }
 
+  function depChainHtml(depChain) {
+    if (!depChain || depChain.length === 0) return '';
+    return '<span class="dep-chain">via ' + depChain.map(function(n) { return escapeHtml(n); }).join(' &gt; ') + '</span>';
+  }
+
+  var sortBy = 'cpu';
+
+  function metricTime(entry) {
+    return sortBy === 'async' ? (entry.asyncTimeUs || 0) : entry.timeUs;
+  }
+
+  function sortDesc(arr) {
+    return arr.slice().sort(function(a, b) { return metricTime(b) - metricTime(a); });
+  }
+
   function applyThreshold(data, pct) {
-    var threshold = data.totalTimeUs * (pct / 100);
+    var totalBase = sortBy === 'async' ? (data.totalAsyncTimeUs || 0) : data.totalTimeUs;
+    var threshold = totalBase * (pct / 100);
     var filtered = [];
     var otherCount = 0;
 
-    for (var i = 0; i < data.packages.length; i++) {
-      var pkg = data.packages[i];
-      if (pkg.timeUs < threshold) {
+    var pkgs = sortDesc(data.packages);
+
+    for (var i = 0; i < pkgs.length; i++) {
+      var pkg = pkgs[i];
+      if (metricTime(pkg) < threshold) {
         otherCount++;
         continue;
       }
@@ -346,9 +420,11 @@ function generateJs(): string {
       var files = [];
       var fileOtherCount = 0;
 
-      for (var j = 0; j < pkg.files.length; j++) {
-        var file = pkg.files[j];
-        if (file.timeUs < threshold) {
+      var sortedFiles = sortDesc(pkg.files);
+
+      for (var j = 0; j < sortedFiles.length; j++) {
+        var file = sortedFiles[j];
+        if (metricTime(file) < threshold) {
           fileOtherCount++;
           continue;
         }
@@ -356,9 +432,11 @@ function generateJs(): string {
         var functions = [];
         var funcOtherCount = 0;
 
-        for (var k = 0; k < file.functions.length; k++) {
-          var fn = file.functions[k];
-          if (fn.timeUs < threshold) {
+        var sortedFns = sortDesc(file.functions);
+
+        for (var k = 0; k < sortedFns.length; k++) {
+          var fn = sortedFns[k];
+          if (metricTime(fn) < threshold) {
             funcOtherCount++;
             continue;
           }
@@ -384,6 +462,7 @@ function generateJs(): string {
         pct: pkg.pct,
         isFirstParty: pkg.isFirstParty,
         sampleCount: pkg.sampleCount,
+        depChain: pkg.depChain,
         asyncTimeUs: pkg.asyncTimeUs,
         asyncPct: pkg.asyncPct,
         asyncOpCount: pkg.asyncOpCount,
@@ -395,18 +474,21 @@ function generateJs(): string {
     return { packages: filtered, otherCount: otherCount };
   }
 
-  function renderTable(packages, otherCount, totalTimeUs) {
+  function renderTable(packages, otherCount, totalTimeUs, totalAsyncTimeUs) {
     var rows = '';
+    var isAsync = sortBy === 'async';
+    var barTotal = isAsync ? (totalAsyncTimeUs || 0) : totalTimeUs;
     for (var i = 0; i < packages.length; i++) {
       var pkg = packages[i];
       var cls = pkg.isFirstParty ? 'first-party' : 'dependency';
-      var pctVal = totalTimeUs > 0 ? (pkg.timeUs / totalTimeUs) * 100 : 0;
+      var barVal = isAsync ? (pkg.asyncTimeUs || 0) : pkg.timeUs;
+      var pctVal = barTotal > 0 ? (barVal / barTotal) * 100 : 0;
       rows += '<tr class="' + cls + '">' +
-        '<td class="pkg-name">' + escapeHtml(pkg.name) + '</td>' +
+        '<td class="pkg-name">' + escapeHtml(pkg.name) + depChainHtml(pkg.depChain) + '</td>' +
         '<td class="numeric">' + escapeHtml(formatTime(pkg.timeUs)) + '</td>' +
         '<td class="bar-cell"><div class="bar-container">' +
           '<div class="bar-track"><div class="bar-fill" style="width:' + pctVal.toFixed(1) + '%"></div></div>' +
-          '<span class="bar-pct">' + escapeHtml(formatPct(pkg.timeUs, totalTimeUs)) + '</span>' +
+          '<span class="bar-pct">' + escapeHtml(formatPct(barVal, barTotal)) + '</span>' +
         '</div></td>' +
         '<td class="numeric">' + pkg.sampleCount + '</td>';
       if (HAS_ASYNC) {
@@ -428,9 +510,9 @@ function generateJs(): string {
       rows += '</tr>';
     }
 
-    var headers = '<th>Package</th><th>Wall Time</th><th>% of Total</th><th>Samples</th>';
+    var headers = '<th>Package</th><th>CPU Time</th><th>% of Total</th><th>Samples</th>';
     if (HAS_ASYNC) {
-      headers += '<th>Async Wait</th><th>Async Ops</th>';
+      headers += '<th>Async I/O Wait</th><th>Async Ops</th>';
     }
 
     return '<table><thead><tr>' + headers + '</tr></thead><tbody>' + rows + '</tbody></table>';
@@ -444,34 +526,40 @@ function generateJs(): string {
     return ' <span class="tree-async">| ' + escapeHtml(formatTime(at)) + ' async &middot; ' + ac + ' ops</span>';
   }
 
-  function renderTree(packages, otherCount, totalTimeUs) {
+  function renderTree(packages, otherCount, totalTimeUs, totalAsyncTimeUs) {
     var html = '<div class="tree">';
+    var isAsync = sortBy === 'async';
+    var pctTotal = isAsync ? (totalAsyncTimeUs || 0) : totalTimeUs;
 
     for (var i = 0; i < packages.length; i++) {
       var pkg = packages[i];
       var fpCls = pkg.isFirstParty ? ' fp-pkg' : '';
+      var pkgTime = isAsync ? (pkg.asyncTimeUs || 0) : pkg.timeUs;
       html += '<details class="level-0' + fpCls + '"><summary>';
       html += '<span class="tree-label pkg">pkg</span>';
       html += '<span class="tree-name">' + escapeHtml(pkg.name) + '</span>';
-      html += '<span class="tree-stats">' + escapeHtml(formatTime(pkg.timeUs)) + ' &middot; ' + escapeHtml(formatPct(pkg.timeUs, totalTimeUs)) + ' &middot; ' + pkg.sampleCount + ' samples</span>';
+      html += depChainHtml(pkg.depChain);
+      html += '<span class="tree-stats">' + escapeHtml(formatTime(pkgTime)) + ' &middot; ' + escapeHtml(formatPct(pkgTime, pctTotal)) + ' &middot; ' + pkg.sampleCount + ' samples</span>';
       html += asyncStats(pkg);
       html += '</summary>';
 
       for (var j = 0; j < pkg.files.length; j++) {
         var file = pkg.files[j];
+        var fileTime = isAsync ? (file.asyncTimeUs || 0) : file.timeUs;
         html += '<details class="level-1"><summary>';
         html += '<span class="tree-label file">file</span>';
         html += '<span class="tree-name">' + escapeHtml(file.name) + '</span>';
-        html += '<span class="tree-stats">' + escapeHtml(formatTime(file.timeUs)) + ' &middot; ' + escapeHtml(formatPct(file.timeUs, totalTimeUs)) + ' &middot; ' + file.sampleCount + ' samples</span>';
+        html += '<span class="tree-stats">' + escapeHtml(formatTime(fileTime)) + ' &middot; ' + escapeHtml(formatPct(fileTime, pctTotal)) + ' &middot; ' + file.sampleCount + ' samples</span>';
         html += asyncStats(file);
         html += '</summary>';
 
         for (var k = 0; k < file.functions.length; k++) {
           var fn = file.functions[k];
+          var fnTime = isAsync ? (fn.asyncTimeUs || 0) : fn.timeUs;
           html += '<div class="level-2">';
           html += '<span class="tree-label fn">fn</span> ';
           html += '<span class="tree-name">' + escapeHtml(fn.name) + '</span>';
-          html += ' <span class="tree-stats">' + escapeHtml(formatTime(fn.timeUs)) + ' &middot; ' + escapeHtml(formatPct(fn.timeUs, totalTimeUs)) + ' &middot; ' + fn.sampleCount + ' samples</span>';
+          html += ' <span class="tree-stats">' + escapeHtml(formatTime(fnTime)) + ' &middot; ' + escapeHtml(formatPct(fnTime, pctTotal)) + ' &middot; ' + fn.sampleCount + ' samples</span>';
           html += asyncStats(fn);
           html += '</div>';
         }
@@ -498,12 +586,26 @@ function generateJs(): string {
     return html;
   }
 
+  var currentThreshold = 5;
+
   function update(pct) {
+    currentThreshold = pct;
     var result = applyThreshold(DATA, pct);
     var summaryEl = document.getElementById('summary-container');
     var treeEl = document.getElementById('tree-container');
-    if (summaryEl) summaryEl.innerHTML = renderTable(result.packages, result.otherCount, DATA.totalTimeUs);
-    if (treeEl) treeEl.innerHTML = renderTree(result.packages, result.otherCount, DATA.totalTimeUs);
+    if (summaryEl) summaryEl.innerHTML = renderTable(result.packages, result.otherCount, DATA.totalTimeUs, DATA.totalAsyncTimeUs);
+    if (treeEl) treeEl.innerHTML = renderTree(result.packages, result.otherCount, DATA.totalTimeUs, DATA.totalAsyncTimeUs);
+  }
+
+  function updateSortButtons() {
+    var btns = document.querySelectorAll('.sort-toggle button');
+    for (var i = 0; i < btns.length; i++) {
+      var btn = btns[i];
+      btn.className = '';
+      if (btn.getAttribute('data-sort') === sortBy) {
+        btn.className = sortBy === 'async' ? 'active-async' : 'active';
+      }
+    }
   }
 
   document.addEventListener('DOMContentLoaded', function() {
@@ -517,6 +619,15 @@ function generateJs(): string {
         update(val);
       });
     }
+
+    var sortBtns = document.querySelectorAll('.sort-toggle button');
+    for (var i = 0; i < sortBtns.length; i++) {
+      sortBtns[i].addEventListener('click', function() {
+        sortBy = this.getAttribute('data-sort') || 'cpu';
+        updateSortButtons();
+        update(currentThreshold);
+      });
+    }
   });
 })();
 `;
@@ -535,7 +646,7 @@ function renderSummaryTable(
     const pctVal = totalTimeUs > 0 ? (pkg.timeUs / totalTimeUs) * 100 : 0;
     rows += `
       <tr class="${cls}">
-        <td class="pkg-name">${escapeHtml(pkg.name)}</td>
+        <td class="pkg-name">${escapeHtml(pkg.name)}${formatDepChain(pkg.depChain)}</td>
         <td class="numeric">${escapeHtml(formatTime(pkg.timeUs))}</td>
         <td class="bar-cell">
           <div class="bar-container">
@@ -566,10 +677,10 @@ function renderSummaryTable(
       <thead>
         <tr>
           <th>Package</th>
-          <th>Wall Time</th>
+          <th>CPU Time</th>
           <th>% of Total</th>
           <th>Samples</th>${hasAsync ? `
-          <th>Async Wait</th>
+          <th>Async I/O Wait</th>
           <th>Async Ops</th>` : ''}
         </tr>
       </thead>
@@ -599,6 +710,7 @@ function renderTree(
     html += `<summary>`;
     html += `<span class="tree-label pkg">pkg</span>`;
     html += `<span class="tree-name">${escapeHtml(pkg.name)}</span>`;
+    html += formatDepChain(pkg.depChain);
     html += `<span class="tree-stats">${escapeHtml(formatTime(pkg.timeUs))} &middot; ${escapeHtml(formatPct(pkg.timeUs, totalTimeUs))} &middot; ${pkg.sampleCount} samples</span>`;
     if (hasAsync) html += formatAsyncStats(pkg);
     html += `</summary>`;
@@ -657,9 +769,14 @@ export function renderHtml(data: ReportData): string {
 
   const titleName = escapeHtml(data.projectName);
 
-  let metaLine = `Generated ${escapeHtml(data.timestamp)} &middot; Total wall time: ${totalFormatted}`;
+  const wallFormatted = data.wallTimeUs ? escapeHtml(formatTime(data.wallTimeUs)) : null;
+  let metaLine = `Generated ${escapeHtml(data.timestamp)}`;
+  if (wallFormatted) {
+    metaLine += ` &middot; Wall time: ${wallFormatted}`;
+  }
+  metaLine += ` &middot; CPU time: ${totalFormatted}`;
   if (hasAsync) {
-    metaLine += ` &middot; Total async wait: ${escapeHtml(formatTime(data.totalAsyncTimeUs!))}`;
+    metaLine += ` &middot; Async I/O wait: ${escapeHtml(formatTime(data.totalAsyncTimeUs!))}`;
   }
 
   // Sanitize JSON for safe embedding in <script> — replace < to prevent </script> injection
@@ -682,7 +799,14 @@ export function renderHtml(data: ReportData): string {
   <div class="threshold-control">
     <label>Threshold</label>
     <input type="range" id="threshold-slider" min="0" max="20" step="0.5" value="5">
-    <span id="threshold-value">5.0%</span>
+    <span id="threshold-value">5.0%</span>${hasAsync ? `
+    <span class="sort-control">
+      <label>Sort by</label>
+      <span class="sort-toggle">
+        <button data-sort="cpu" class="active">CPU Time</button>
+        <button data-sort="async">Async I/O Wait</button>
+      </span>
+    </span>` : ''}
   </div>
   <div id="summary-container">${summaryTable}</div>
 

package/src/sampler.ts

@@ -17,6 +17,7 @@ import type {
 // Module-level state -- lazy initialization
 let session: Session | null = null;
 let profiling = false;
+let startHrtime: [number, number] | null = null;
 const store = new SampleStore();
 const asyncStore = new SampleStore();
 const resolver = new PackageResolver(process.cwd());
@@ -85,22 +86,32 @@ function stopSync(): PkgProfile {
     return buildEmptyProfile();
   }
 
+  const elapsed = startHrtime ? process.hrtime(startHrtime) : null;
+  const wallTimeUs = elapsed ? elapsed[0] * 1_000_000 + Math.round(elapsed[1] / 1000) : undefined;
+  startHrtime = null;
+
   const { profile } = postSync("Profiler.stop") as Profiler.StopReturnType;
   postSync("Profiler.disable");
   profiling = false;
 
+  let globalAsyncTimeUs: number | undefined;
   if (asyncTracker) {
     asyncTracker.disable();
+    globalAsyncTimeUs = asyncTracker.mergedTotalUs;
     asyncTracker = null;
   }
 
   processProfile(profile);
 
-  const projectName = readProjectName(process.cwd());
+  const cwd = process.cwd();
+  const projectName = readProjectName(cwd);
   const data = aggregate(
     store,
     projectName,
     asyncStore.packages.size > 0 ? asyncStore : undefined,
+    globalAsyncTimeUs,
+    wallTimeUs,
+    cwd,
   );
   store.clear();
   asyncStore.clear();
@@ -133,6 +144,7 @@ export async function start(options?: StartOptions): Promise<void> {
 
   await postAsync("Profiler.start");
   profiling = true;
+  startHrtime = process.hrtime();
 
   if (options?.trackAsync) {
     asyncTracker = new AsyncTracker(resolver, asyncStore);
@@ -159,6 +171,7 @@ export async function clear(): Promise<void> {
     postSync("Profiler.disable");
     profiling = false;
   }
+  startHrtime = null;
   store.clear();
   if (asyncTracker) {
     asyncTracker.disable();

package/src/types.ts

@@ -41,6 +41,7 @@ export interface FileEntry extends ReportEntry {
 
 export interface PackageEntry extends ReportEntry {
   isFirstParty: boolean;
+  depChain?: string[];
   files: FileEntry[];
   otherCount: number;
 }
@@ -52,6 +53,7 @@ export interface ReportData {
   otherCount: number;
   projectName: string;
   totalAsyncTimeUs?: number;
+  wallTimeUs?: number;
 }
 
 /**