@houwert/conductor 0.28.0 → 0.29.0

package/dist/commands/profile.js

@@ -3,25 +3,61 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HELP = void 0;
+exports.REACT_PROFILER_STOP = exports.REACT_PROFILER_READ = exports.REACT_PROFILER_INSTALL = exports.HELP = void 0;
+exports.parseSimpleperfReport = parseSimpleperfReport;
 exports.profileCpu = profileCpu;
+exports.heapGrowth = heapGrowth;
 exports.profileMemory = profileMemory;
 exports.profileReactStart = profileReactStart;
 exports.profileReactStop = profileReactStop;
 exports.HELP = `  profile cpu --duration <s> [--out <path>]
                                        Record a CPU trace (iOS: xctrace, Android: simpleperf)
+    --report [--top N]                 Android: also symbolize the trace into a ranked table
   profile memory --track <s> [--interval <ms>] [<appId>]
                                        Sample memory for N seconds, report deltas
+                                       Android: also reports heap growth and GC pauses
+  profile frames reset [<appId>]       Android: zero the app's gfxinfo frame counters
+  profile frames report [<appId>]      Android: jank / frame timing since the last reset
+    --track <s> [--interval <ms>]      Reset, sample for N seconds, then report
+    --save-baseline <name> / --diff <name> / --baselines
+                                       Save, compare against, and list frame baselines
+  profile js record --duration <s>     Sample Hermes JS CPU and rank functions
+  profile js start / stop [--top N]    Same, bracketing a flow you drive yourself
+    --out <path>                       Where to write the raw .cpuprofile
   profile react start                  Install a React commit-profiler hook in the JS runtime
-  profile react stop [--top N]         Stop and summarise captured React commits`;
+    --max-commits <n>                  Commit ring-buffer size (default 500)
+    --max-components <n>               Component records kept per commit (default 200)
+  profile react stop [--top N]         Stop and summarise captured React commits
+    --timeline                         Include per-commit component detail in --json`;
 const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const output_js_1 = require("../output.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const sdk_js_1 = require("../android/sdk.js");
+const runner_js_1 = require("../runner.js");
 const memory_js_1 = require("./memory.js");
 const metro_cdp_js_1 = require("../drivers/metro-cdp.js");
+const profile_gc_js_1 = require("./profile-gc.js");
+/**
+ * Parse `simpleperf report --sort dso,symbol`. The header row is located by its
+ * `Overhead` column rather than by line number, since simpleperf prefixes the
+ * table with a variable-length preamble.
+ */
+function parseSimpleperfReport(out) {
+    const lines = out.split(/\r?\n/);
+    const headerIndex = lines.findIndex((l) => /^\s*Overhead\b/.test(l));
+    if (headerIndex === -1)
+        return [];
+    const entries = [];
+    for (const line of lines.slice(headerIndex + 1)) {
+        const m = line.match(/^\s*([\d.]+)%\s+(\S+)\s+(.+?)\s*$/);
+        if (!m)
+            continue;
+        entries.push({ percent: Number(m[1]), dso: m[2], symbol: m[3] });
+    }
+    return entries;
+}
 function defaultTracePath(prefix, ext) {
     const ts = new Date().toISOString().replace(/[:.]/g, '-');
     return path_1.default.join(os_1.default.tmpdir(), `${prefix}-${ts}.${ext}`);
@@ -47,7 +83,7 @@ async function recordIosCpu(deviceId, appId, durationSec, out) {
         proc.on('error', reject);
     });
 }
-async function recordAndroidCpu(deviceId, appId, durationSec, out) {
+async function recordAndroidCpu(deviceId, appId, durationSec, out, report) {
     const adb = (0, sdk_js_1.resolveAndroidTool)('adb');
     const env = (0, sdk_js_1.androidSpawnEnv)();
     const remote = `/data/local/tmp/conductor-perf-${Date.now()}.data`;
@@ -73,6 +109,31 @@ async function recordAndroidCpu(deviceId, appId, durationSec, out) {
         proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`simpleperf record exited with ${code}`)));
         proc.on('error', reject);
     });
+    // Symbolize on-device before pulling: /system/bin/simpleperf resolves against
+    // the libraries actually loaded there, which a host-side report cannot do
+    // without a matching symfs.
+    let entries;
+    if (report) {
+        const res = await (0, runner_js_1.spawnCommand)(adb, [
+            '-s',
+            deviceId,
+            'shell',
+            'simpleperf',
+            'report',
+            '-i',
+            remote,
+            '--sort',
+            'dso,symbol',
+            '--percent-limit',
+            '0.1',
+        ], { env });
+        if (!res.success) {
+            throw new Error(`simpleperf report failed on-device (${res.stderr.trim() || 'no output'}). ` +
+                `The raw recording is still at ${out}; symbolize it on the host with the NDK's ` +
+                `simpleperf/report.py.`);
+        }
+        entries = parseSimpleperfReport(res.stdout).slice(0, report.top);
+    }
     await new Promise((resolve, reject) => {
         const proc = (0, child_process_1.spawn)(adb, ['-s', deviceId, 'pull', remote, out], { stdio: 'inherit', env });
         proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`adb pull exited with ${code}`)));
@@ -83,6 +144,7 @@ async function recordAndroidCpu(deviceId, appId, durationSec, out) {
         proc.on('close', () => resolve());
         proc.on('error', () => resolve());
     });
+    return entries;
 }
 async function profileCpu(opts, sessionName, profileOpts) {
     if (sessionName === 'default') {
@@ -92,26 +154,45 @@ async function profileCpu(opts, sessionName, profileOpts) {
     const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => null);
     const isIos = platform === 'ios' || platform === 'tvos';
     const out = profileOpts.out ?? defaultTracePath('cpu', isIos ? 'trace' : 'perf.data');
+    let entries;
     try {
         if (isIos) {
+            if (profileOpts.report) {
+                (0, output_js_1.printError)('profile cpu --report is Android-only. Export the iOS trace with ' +
+                    '`xcrun xctrace export --input <trace> --toc` to see what it holds.', opts);
+                return 1;
+            }
             await recordIosCpu(sessionName, profileOpts.appId, profileOpts.durationSec, out);
         }
         else if (platform === 'android') {
-            await recordAndroidCpu(sessionName, profileOpts.appId, profileOpts.durationSec, out);
+            entries = await recordAndroidCpu(sessionName, profileOpts.appId, profileOpts.durationSec, out, profileOpts.report ? { top: profileOpts.top ?? 30 } : undefined);
         }
         else if (platform === 'vega') {
-            // No native CPU-trace tooling (xctrace/simpleperf) on Vega yet.
-            (0, output_js_1.printError)('profile cpu is not yet supported on vega (Amazon Fire TV)', opts);
+            // Vega is Amazon's own OS, not Android — no simpleperf, no dumpsys. A
+            // physical Fire TV Stick runs Fire OS (Android) over adb and is a
+            // different target entirely, where all the Android tooling applies.
+            (0, output_js_1.printError)('profile cpu is not supported on vega (Amazon Vega OS — no simpleperf on device).\n' +
+                'A physical Fire TV Stick runs Fire OS, which is Android: connect it with ' +
+                '`adb connect <ip>` and conductor treats it as an android device, where ' +
+                '`profile cpu`, `profile frames` and `profile memory` all work.', opts);
             return 1;
         }
         else {
             (0, output_js_1.printError)(`profile cpu is not supported on platform ${platform ?? '(unknown)'}`, opts);
             return 1;
         }
-        if (opts.json)
-            (0, output_js_1.printData)({ out, durationSec: profileOpts.durationSec, platform }, opts);
-        else
+        if (opts.json) {
+            (0, output_js_1.printData)({ out, durationSec: profileOpts.durationSec, platform, symbols: entries }, opts);
+        }
+        else {
             (0, output_js_1.printSuccess)(`profile cpu — recorded ${profileOpts.durationSec}s → ${out}`, opts);
+            if (entries) {
+                console.log(`  ${'overhead'.padStart(9)}  symbol`);
+                for (const e of entries) {
+                    console.log(`  ${`${e.percent}%`.padStart(9)}  ${e.symbol}  [${e.dso}]`);
+                }
+            }
+        }
         return 0;
     }
     catch (err) {
@@ -119,8 +200,41 @@ async function profileCpu(opts, sessionName, profileOpts) {
         return 1;
     }
 }
+/** Growth of each numeric field of `report.app` across the tracked window. */
+function heapGrowth(samples) {
+    const series = new Map();
+    for (const s of samples) {
+        const app = s.data?.app;
+        if (!app)
+            continue;
+        for (const [k, v] of Object.entries(app)) {
+            if (typeof v !== 'number')
+                continue;
+            const arr = series.get(k) ?? [];
+            arr.push(v);
+            series.set(k, arr);
+        }
+    }
+    return [...series.entries()]
+        .map(([key, values]) => ({
+        key,
+        startBytes: values[0],
+        endBytes: values[values.length - 1],
+        deltaBytes: values[values.length - 1] - values[0],
+        peakBytes: Math.max(...values),
+    }))
+        .sort((a, b) => b.deltaBytes - a.deltaBytes);
+}
+function mb(bytes) {
+    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
 async function profileMemory(opts, sessionName, profileOpts) {
     const samples = [];
+    const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
+    const isAndroid = platform === 'android';
+    // Note the device's own clock before sampling so the logcat window lines up
+    // with it even when the host clock has drifted.
+    const gcSince = isAndroid ? await (0, profile_gc_js_1.deviceLogcatTimestamp)(sessionName) : undefined;
     const start = Date.now();
     const end = start + profileOpts.trackSec * 1000;
     while (Date.now() < end) {
@@ -142,8 +256,15 @@ async function profileMemory(opts, sessionName, profileOpts) {
             return { at: s.at, data: null };
         }
     });
+    const growth = heapGrowth(parsed);
+    let gc;
+    if (isAndroid) {
+        const events = await (0, profile_gc_js_1.collectGcSince)(sessionName, gcSince);
+        if (events.length > 0)
+            gc = (0, profile_gc_js_1.summariseGc)(events);
+    }
     if (opts.json) {
-        (0, output_js_1.printData)({ samples: parsed, durationMs: Date.now() - start }, opts);
+        (0, output_js_1.printData)({ samples: parsed, durationMs: Date.now() - start, growth, gc }, opts);
     }
     else {
         console.log(`profile memory — ${samples.length} samples over ${profileOpts.trackSec}s`);
@@ -156,6 +277,25 @@ async function profileMemory(opts, sessionName, profileOpts) {
                 : '(parse error)';
             console.log(`  t+${(p.at / 1000).toFixed(1)}s  ${summary}`);
         }
+        if (growth.length > 0) {
+            console.log('\n  heap growth over the window');
+            for (const g of growth.slice(0, 8)) {
+                const sign = g.deltaBytes >= 0 ? '+' : '';
+                console.log(`    ${g.key.padEnd(20)} ${mb(g.startBytes)} → ${mb(g.endBytes)}  ` +
+                    `${sign}${mb(g.deltaBytes)}  peak ${mb(g.peakBytes)}`);
+            }
+        }
+        if (gc) {
+            console.log(`\n  GC: ${gc.events} collection(s), ${gc.totalPauseMs}ms of stop-the-world pause total`);
+            console.log(`    pause  p50 ${gc.pause.p50Ms}ms  p95 ${gc.pause.p95Ms}ms  max ${gc.pause.maxMs}ms`);
+            for (const k of gc.byKind) {
+                console.log(`    ${k.kind.padEnd(34)} ${String(k.count).padStart(4)}x  ${k.totalPauseMs}ms`);
+            }
+        }
+        else if (isAndroid) {
+            console.log('\n  GC: no ART collections logged in the window. ART only logs collections it ' +
+                'considers noteworthy, so a quiet window here is a real signal.');
+        }
     }
     return 0;
 }
@@ -175,67 +315,190 @@ async function captureStdout(fn) {
     return chunks.join('');
 }
 // ── React profiler ────────────────────────────────────────────────────────────
-const REACT_PROFILER_INSTALL = `
+/**
+ * Injected commit profiler.
+ *
+ * The subtle part is deciding which fibers actually rendered in a given commit.
+ * React does not clear `actualDuration` on fibers it left alone, so "has a
+ * non-zero actualDuration" is true for anything that rendered at any point in
+ * the past, and counting those every commit inflates both render counts and
+ * durations. What React does clear is `actualStartTime`: `createWorkInProgress`
+ * resets it to -1 and `startProfilerTimer` stamps it as work begins, and a
+ * render pass always begins at the root. So the root's own `actualStartTime` is
+ * the start of this pass, and a fiber rendered in it exactly when its start time
+ * is at or after the root's. Anchoring on the root rather than on a running
+ * maximum keeps this independent of whichever clock React's `now()` is bound to.
+ *
+ * That render passes always walk down from the root also lets us prune: a fiber
+ * that did not render cannot contain one that did, so the walk costs the size of
+ * the rendered set, not the size of the tree.
+ *
+ * `actualDuration` bubbles up, so a fiber's own cost is its duration minus that
+ * of the children that rendered alongside it. Both are reported: `selfMs` is
+ * additive across components, `totalMs` is subtree-inclusive and double-counts
+ * by design.
+ */
+const REACT_PROFILER_INSTALL = (maxCommits, maxComponents) => `
 (() => {
   if (globalThis.__CONDUCTOR_REACT_PROFILER__) {
     return { installed: true, already: true };
   }
   const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (!hook) return { installed: false, error: 'No React DevTools hook (Hermes only?)' };
-  const commits = [];
-  const MAX = 500;
-  const orig = hook.onCommitFiberRoot;
-  hook.onCommitFiberRoot = function(rendererID, root, priorityLevel) {
+  if (!hook) return { installed: false, error: 'No React DevTools hook on this runtime' };
+
+  var state = {
+    commits: [],
+    maxCommits: ${maxCommits},
+    maxComponents: ${maxComponents},
+    droppedCommits: 0,
+    droppedComponents: 0,
+    skippedCommits: 0,
+    profilingSupported: null
+  };
+
+  // Detect up front whether this build carries React's timing instrumentation,
+  // so profile react start can fail loudly rather than leaving it to stop.
+  var rendererCount = 0;
+  try {
+    if (hook.renderers && hook.getFiberRoots) {
+      hook.renderers.forEach(function (_r, id) {
+        rendererCount++;
+        var roots = hook.getFiberRoots(id);
+        if (!roots) return;
+        roots.forEach(function (root) {
+          if (state.profilingSupported === null) {
+            state.profilingSupported = root.current.actualDuration !== undefined;
+          }
+        });
+      });
+    }
+  } catch (e) {}
+
+  var orig = hook.onCommitFiberRoot;
+  hook.onCommitFiberRoot = function (rendererID, root, priorityLevel) {
     try {
-      const entry = { at: Date.now(), rendererID, components: [] };
-      let node = root.current;
-      const stack = [{ fiber: node, depth: 0 }];
-      let count = 0;
-      while (stack.length && count < 200) {
-        const { fiber, depth } = stack.pop();
-        if (!fiber) continue;
-        const dur = fiber.actualDuration ?? 0;
-        if (dur > 0) {
-          const name = (fiber.type && (fiber.type.displayName || fiber.type.name)) || (typeof fiber.type === 'string' ? fiber.type : null);
+      var rootFiber = root.current;
+      if (state.profilingSupported === null) {
+        state.profilingSupported = rootFiber.actualDuration !== undefined;
+      }
+      var passStart = rootFiber.actualStartTime;
+      if (state.profilingSupported && !(typeof passStart === 'number' && passStart >= 0)) {
+        // No start stamp on the root means we cannot tell this commit's work
+        // from earlier work; skipping is better than reporting stale fibers.
+        state.skippedCommits++;
+      } else if (state.profilingSupported) {
+        var components = [];
+        var droppedHere = 0;
+
+        var visit = function (fiber, depth) {
+          var start = fiber.actualStartTime;
+          if (!(typeof start === 'number' && start >= passStart)) return 0;
+
+          var childSum = 0;
+          var child = fiber.child;
+          while (child) {
+            childSum += visit(child, depth + 1);
+            child = child.sibling;
+          }
+
+          var dur = fiber.actualDuration || 0;
+          var name =
+            (fiber.type && (fiber.type.displayName || fiber.type.name)) ||
+            (typeof fiber.type === 'string' ? fiber.type : null);
           if (name) {
-            entry.components.push({ name, depth, actualDuration: dur, selfDuration: fiber.selfBaseDuration ?? 0 });
-            count++;
+            if (components.length < state.maxComponents) {
+              components.push({
+                name: name,
+                depth: depth,
+                actualDuration: dur,
+                selfDuration: Math.max(0, dur - childSum)
+              });
+            } else {
+              droppedHere++;
+            }
           }
+          return dur;
+        };
+
+        visit(rootFiber, 0);
+        state.droppedComponents += droppedHere;
+        state.commits.push({
+          at: Date.now(),
+          rendererID: rendererID,
+          durationMs: rootFiber.actualDuration || 0,
+          truncated: droppedHere > 0,
+          droppedComponents: droppedHere,
+          components: components
+        });
+        while (state.commits.length > state.maxCommits) {
+          state.commits.shift();
+          state.droppedCommits++;
         }
-        if (fiber.child) stack.push({ fiber: fiber.child, depth: depth + 1 });
-        if (fiber.sibling) stack.push({ fiber: fiber.sibling, depth });
       }
-      commits.push(entry);
-      if (commits.length > MAX) commits.shift();
     } catch (e) {}
     if (typeof orig === 'function') return orig.apply(this, arguments);
   };
+
   globalThis.__CONDUCTOR_REACT_PROFILER__ = {
     installed: true,
-    commits,
-    uninstall: () => { hook.onCommitFiberRoot = orig; }
+    state: state,
+    uninstall: function () { hook.onCommitFiberRoot = orig; }
+  };
+  return {
+    installed: true,
+    already: false,
+    renderers: rendererCount,
+    profilingSupported: state.profilingSupported
   };
-  return { installed: true, already: false };
 })()
 `;
-const REACT_PROFILER_READ = (top) => `
+exports.REACT_PROFILER_INSTALL = REACT_PROFILER_INSTALL;
+const REACT_PROFILER_READ = (top, timeline) => `
 (() => {
   const p = globalThis.__CONDUCTOR_REACT_PROFILER__;
-  if (!p) return { installed: false, commits: [] };
-  const commits = p.commits.slice();
+  if (!p) return { installed: false };
+  const s = p.state;
   const byName = {};
-  for (const c of commits) {
+  for (const c of s.commits) {
     for (const comp of c.components) {
-      byName[comp.name] = byName[comp.name] ?? { name: comp.name, totalMs: 0, renders: 0 };
-      byName[comp.name].totalMs += comp.actualDuration;
-      byName[comp.name].renders += 1;
+      const e = byName[comp.name] || (byName[comp.name] = {
+        name: comp.name, selfMs: 0, totalMs: 0, renders: 0
+      });
+      e.selfMs += comp.selfDuration;
+      e.totalMs += comp.actualDuration;
+      e.renders += 1;
     }
   }
-  const top = Object.values(byName).sort((a, b) => b.totalMs - a.totalMs).slice(0, ${top});
-  return { installed: true, commits, totalCommits: commits.length, top };
+  const ranked = Object.keys(byName).map(function (k) { return byName[k]; })
+    .sort(function (a, b) { return b.selfMs - a.selfMs; });
+  const commits = s.commits.map(function (c) {
+    const out = {
+      at: c.at,
+      durationMs: c.durationMs,
+      componentCount: c.components.length,
+      droppedComponents: c.droppedComponents
+    };
+    if (${timeline ? 'true' : 'false'}) out.components = c.components;
+    return out;
+  });
+  return {
+    installed: true,
+    profilingSupported: s.profilingSupported,
+    totalCommits: s.commits.length,
+    droppedCommits: s.droppedCommits,
+    skippedCommits: s.skippedCommits,
+    droppedComponents: s.droppedComponents,
+    truncated: s.droppedCommits > 0 || s.droppedComponents > 0,
+    maxCommits: s.maxCommits,
+    maxComponents: s.maxComponents,
+    componentsRanked: ranked.length,
+    top: ranked.slice(0, ${top}),
+    commits: commits
+  };
 })()
 `;
-const REACT_PROFILER_STOP = `
+exports.REACT_PROFILER_READ = REACT_PROFILER_READ;
+exports.REACT_PROFILER_STOP = `
 (() => {
   const p = globalThis.__CONDUCTOR_REACT_PROFILER__;
   if (!p) return { installed: false };
@@ -244,62 +507,113 @@ const REACT_PROFILER_STOP = `
   return { installed: true, stopped: true };
 })()
 `;
-async function profileReactStart(opts, sessionName, cdpOpts) {
+const NO_PROFILING_BUILD = 'this build has no React profiling data (fibers carry no actualDuration). ' +
+    'The React commit profiler needs a dev or profiling build; a release build ' +
+    'strips the timing instrumentation. Use `profile js` or `profile frames` to ' +
+    'measure a release build.';
+async function connectCdp(sessionName, cdpOpts) {
+    const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
+    const client = new metro_cdp_js_1.MetroCdpClient();
+    await client.connect({
+        port: cdpOpts.port,
+        deviceId: sessionName !== 'default' ? sessionName : undefined,
+        platform,
+        targetIndex: cdpOpts.targetIndex,
+    });
+    return client;
+}
+async function profileReactStart(opts, sessionName, reactOpts) {
+    let client;
     try {
-        const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
-        const client = new metro_cdp_js_1.MetroCdpClient();
-        await client.connect({
-            port: cdpOpts.port ?? 8081,
-            deviceId: sessionName !== 'default' ? sessionName : undefined,
-            platform,
-            targetIndex: cdpOpts.targetIndex,
-        });
-        const result = await client.evaluate(REACT_PROFILER_INSTALL);
-        client.close();
+        client = await connectCdp(sessionName, reactOpts);
+        const result = await client.evaluate((0, exports.REACT_PROFILER_INSTALL)(reactOpts.maxCommits ?? 500, reactOpts.maxComponents ?? 200));
         if (!result.installed) {
             (0, output_js_1.printError)(`profile react start — ${result.error ?? 'install failed'}`, opts);
             return 1;
         }
+        if (result.profilingSupported === false) {
+            await client.evaluate(exports.REACT_PROFILER_STOP);
+            (0, output_js_1.printError)(`profile react start — ${NO_PROFILING_BUILD}`, opts);
+            return 1;
+        }
         if (opts.json)
-            (0, output_js_1.printData)(result, opts);
-        else
+            (0, output_js_1.printData)({ status: 'ok', ...result }, opts);
+        else {
             (0, output_js_1.printSuccess)(`profile react start — ${result.already ? 'already installed' : 'installed'}`, opts);
+            if (result.profilingSupported === null) {
+                console.log('  note: nothing has rendered yet, so the build could not be checked for profiling ' +
+                    'support. `profile react stop` will say so if it turns out to be a release build.');
+            }
+        }
         return 0;
     }
     catch (err) {
         (0, output_js_1.printError)(`profile react start — ${err instanceof Error ? err.message : String(err)}`, opts);
         return 1;
     }
+    finally {
+        client?.close();
+    }
 }
-async function profileReactStop(opts, sessionName, cdpOpts, top) {
+async function profileReactStop(opts, sessionName, reactOpts, top) {
+    let client;
     try {
-        const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
-        const client = new metro_cdp_js_1.MetroCdpClient();
-        await client.connect({
-            port: cdpOpts.port ?? 8081,
-            deviceId: sessionName !== 'default' ? sessionName : undefined,
-            platform,
-            targetIndex: cdpOpts.targetIndex,
-        });
-        const read = await client.evaluate(REACT_PROFILER_READ(top));
-        await client.evaluate(REACT_PROFILER_STOP);
-        client.close();
+        client = await connectCdp(sessionName, reactOpts);
+        const read = await client.evaluate((0, exports.REACT_PROFILER_READ)(top, reactOpts.timeline ?? false));
+        await client.evaluate(exports.REACT_PROFILER_STOP);
         if (!read.installed) {
             (0, output_js_1.printError)('profile react stop — profiler was not installed', opts);
             return 1;
         }
-        if (opts.json)
-            (0, output_js_1.printData)(read, opts);
-        else {
-            console.log(`profile react — ${read.totalCommits ?? 0} commit(s)`);
-            for (const t of read.top ?? []) {
-                console.log(`  ${t.totalMs.toFixed(1)}ms  ${t.renders}x  ${t.name}`);
-            }
+        if (read.profilingSupported === false) {
+            (0, output_js_1.printError)(`profile react stop — ${NO_PROFILING_BUILD}`, opts);
+            return 1;
+        }
+        if (read.profilingSupported === null || (read.totalCommits ?? 0) === 0) {
+            (0, output_js_1.printError)('profile react stop — no commits were captured. Either nothing re-rendered while the ' +
+                'profiler was installed, or the app reloaded (which drops the hook).', opts);
+            return 1;
         }
+        if (opts.json)
+            (0, output_js_1.printData)({ status: 'ok', ...read }, opts);
+        else
+            printReactReport(read);
         return 0;
     }
     catch (err) {
         (0, output_js_1.printError)(`profile react stop — ${err instanceof Error ? err.message : String(err)}`, opts);
         return 1;
     }
+    finally {
+        client?.close();
+    }
+}
+function printReactReport(read) {
+    console.log(`profile react — ${read.totalCommits ?? 0} commit(s)`);
+    console.log(`  ${'self'.padStart(9)} ${'total'.padStart(9)}  renders  component`);
+    for (const t of read.top ?? []) {
+        console.log(`  ${`${t.selfMs.toFixed(1)}ms`.padStart(9)} ${`${t.totalMs.toFixed(1)}ms`.padStart(9)}  ` +
+            `${String(t.renders).padStart(7)}  ${t.name}`);
+    }
+    console.log('  self is additive across components; total is subtree-inclusive and double-counts parents.');
+    const commits = read.commits ?? [];
+    if (commits.length > 0) {
+        const slowest = [...commits].sort((a, b) => b.durationMs - a.durationMs).slice(0, 5);
+        const t0 = commits[0].at;
+        console.log('\n  slowest commits');
+        for (const c of slowest) {
+            console.log(`    t+${((c.at - t0) / 1000).toFixed(2)}s  ${c.durationMs.toFixed(1)}ms  ` +
+                `${c.componentCount} component(s)`);
+        }
+        console.log('  full per-commit timeline is in --json output (add --timeline for components).');
+    }
+    if ((read.skippedCommits ?? 0) > 0) {
+        console.log(`\n  skipped ${read.skippedCommits} commit(s) whose root fiber carried no render start ` +
+            'stamp — their work could not be told apart from earlier renders.');
+    }
+    if (read.truncated) {
+        console.log(`\n  TRUNCATED: dropped ${read.droppedCommits ?? 0} commit(s) beyond --max-commits ` +
+            `${read.maxCommits} and ${read.droppedComponents ?? 0} component record(s) beyond ` +
+            `--max-components ${read.maxComponents}. Raise those limits or profile a shorter window.`);
+    }
 }