@houwert/conductor 0.29.1 → 0.29.2

package/dist/commands/profile.js

@@ -7,6 +7,7 @@ exports.REACT_PROFILER_STOP = exports.REACT_PROFILER_READ = exports.REACT_PROFIL
 exports.parseSimpleperfReport = parseSimpleperfReport;
 exports.profileCpu = profileCpu;
 exports.heapGrowth = heapGrowth;
+exports.inferCollections = inferCollections;
 exports.profileMemory = profileMemory;
 exports.profileReactStart = profileReactStart;
 exports.profileReactStop = profileReactStop;
@@ -228,6 +229,37 @@ function heapGrowth(samples) {
 function mb(bytes) {
     return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
+/**
+ * Infer collections from the heap series rather than from logcat.
+ *
+ * A heap that shrinks between two samples was collected between them — there is
+ * no other mechanism. This matters because ART's GC logging is not reliably on:
+ * measured on a Fire TV Stick (Fire OS, API 30), a window in which the Java heap
+ * fell 11.8MB produced no `art:I` lines at all. Absence of logged collections is
+ * therefore not absence of collection, and the deltas are the sounder signal.
+ */
+function inferCollections(samples, series = 'javaHeapBytes') {
+    const values = [];
+    for (const s of samples) {
+        const app = s.data?.app;
+        const v = app?.[series];
+        if (typeof v === 'number')
+            values.push(v);
+    }
+    if (values.length < 2)
+        return undefined;
+    let collections = 0;
+    let reclaimedBytes = 0;
+    for (let i = 1; i < values.length; i++) {
+        const drop = values[i - 1] - values[i];
+        // Ignore sampling jitter; only count drops worth a collection.
+        if (drop > 256 * 1024) {
+            collections++;
+            reclaimedBytes += drop;
+        }
+    }
+    return { collections, reclaimedBytes, series };
+}
 async function profileMemory(opts, sessionName, profileOpts) {
     const samples = [];
     const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
@@ -257,6 +289,7 @@ async function profileMemory(opts, sessionName, profileOpts) {
         }
     });
     const growth = heapGrowth(parsed);
+    const inferredGc = isAndroid ? inferCollections(parsed) : undefined;
     let gc;
     if (isAndroid) {
         const events = await (0, profile_gc_js_1.collectGcSince)(sessionName, gcSince);
@@ -264,7 +297,7 @@ async function profileMemory(opts, sessionName, profileOpts) {
             gc = (0, profile_gc_js_1.summariseGc)(events);
     }
     if (opts.json) {
-        (0, output_js_1.printData)({ samples: parsed, durationMs: Date.now() - start, growth, gc }, opts);
+        (0, output_js_1.printData)({ samples: parsed, durationMs: Date.now() - start, growth, gc, inferredGc }, opts);
     }
     else {
         console.log(`profile memory — ${samples.length} samples over ${profileOpts.trackSec}s`);
@@ -293,8 +326,20 @@ async function profileMemory(opts, sessionName, profileOpts) {
             }
         }
         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.');
+            console.log('\n  GC: no ART collections logged in the window.');
+            if (inferredGc && inferredGc.collections > 0) {
+                console.log(`    But ${inferredGc.series} fell ${inferredGc.collections} time(s), reclaiming ` +
+                    `${mb(inferredGc.reclaimedBytes)} — so collections did run and were not logged. ` +
+                    `ART's logging is off or filtered on this build; trust the heap deltas, not logcat.`);
+            }
+            else {
+                console.log('    Absence of logged collections is not absence of collection — ART logging is ' +
+                    'off or filtered on some builds. The heap deltas above are the sounder signal.');
+            }
+        }
+        if (inferredGc && inferredGc.collections > 0 && gc) {
+            console.log(`    (heap deltas independently imply ${inferredGc.collections} collection(s), ` +
+                `${mb(inferredGc.reclaimedBytes)} reclaimed)`);
         }
     }
     return 0;

package/dist/drivers/log-sources/metro.js

@@ -131,7 +131,9 @@ async function discoverTarget(port, host, targetIndex) {
     const data = await fetchTargets(port, host);
     const withWs = data.filter((t) => t.webSocketDebuggerUrl);
     if (withWs.length === 0) {
-        throw new Error('Metro returned no debugger targets. Is the app running on a device/simulator?');
+        throw new Error('Metro is reachable but has no debugger targets. Most often the app is a release ' +
+            'build — release Hermes ships without the inspector and never connects to Metro. ' +
+            'Otherwise, check the app is running and pointed at this Metro instance.');
     }
     if (targetIndex !== undefined) {
         if (targetIndex < 0 || targetIndex >= withWs.length) {

package/dist/drivers/metro-cdp.js

@@ -33,7 +33,17 @@ function selectDebuggerUrl(targets, opts, displayName) {
     const host = opts.host ?? 'localhost';
     const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
     if (withWs.length === 0) {
-        throw new Error(`Metro on ${host}:${port} returned no debugger targets. Is an app running on a device/simulator?`);
+        // Metro is reachable but nothing registered. The usual cause is not a
+        // missing app — it is a release build: release Hermes ships without the
+        // inspector and never connects to Metro at all, so asking "is the app
+        // running?" sends people to check something that is already true.
+        throw new Error(`Metro on ${host}:${port} is reachable but has no debugger targets.\n` +
+            `Most often the app is a release build — release Hermes ships without the ` +
+            `inspector and never connects to Metro, so no amount of relaunching will help. ` +
+            `Use a debug or profiling build for anything that attaches over Metro ` +
+            `(\`profile js\`, \`profile react\`, \`debug\`, \`network\`).\n` +
+            `Otherwise: check the app is running and foreground, and that it is pointed at ` +
+            `this Metro instance rather than another one.`);
     }
     if (opts.targetIndex !== undefined) {
         if (opts.targetIndex < 0 || opts.targetIndex >= withWs.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {