chrometools-mcp 3.5.5 → 3.6.0

package/pom/apom-tree-converter.js

@@ -37,9 +37,16 @@ function initializeModelRegistry() {
  *
  * @param {boolean} interactiveOnly - Only include interactive elements and their parents
  * @param {boolean} viewportOnly - Only include elements visible in current viewport
+ * @param {Object} portalOpts - Portal scan options: { include: boolean, selectors: string[] }
+ *                              When include=true, force-includes contents of React Portal containers
+ *                              (e.g. #menu-popup-root, #tooltip-root) that live outside main React root.
  * @returns {Object} APOM tree structure
  */
-function buildAPOMTree(interactiveOnly = true, viewportOnly = false) {
+function buildAPOMTree(interactiveOnly = true, viewportOnly = false, portalOpts = undefined) {
+  const portalInclude = portalOpts ? portalOpts.include !== false : true;
+  const portalSelectors = (portalOpts && Array.isArray(portalOpts.selectors) && portalOpts.selectors.length > 0)
+    ? portalOpts.selectors
+    : ['#modal-root', '#menu-popup-root', '#tooltip-root', '#popover-root', '[data-portal]'];
   const pageId = `page_${btoa(window.location.href).replace(/[^a-zA-Z0-9]/g, '').substring(0, 20)}_${Date.now()}`;
 
   // Initialize model registry (Strategy Pattern setup)
@@ -116,6 +123,54 @@ function buildAPOMTree(interactiveOnly = true, viewportOnly = false) {
         forceMarkModalTree(el);
       }
     });
+
+    // Generic portal containers (menus, tooltips, popovers) — opt-in by selector list.
+    // Unlike framework modals, these are app-defined wrappers (e.g. #menu-popup-root from
+    // client/index.html). When non-empty, force-include their subtree.
+    if (portalInclude && portalSelectors.length > 0) {
+      try {
+        document.querySelectorAll(portalSelectors.join(',')).forEach(container => {
+          if (!container.children || container.children.length === 0) return;
+          for (const child of container.children) {
+            if (!modalElements.has(child)) {
+              forceMarkModalTree(child);
+            }
+          }
+        });
+      } catch (e) {
+        // Invalid selector in portalSelectors — skip silently, do not break analyzePage
+      }
+    }
+
+    // In-tree popups (Popper/Tippy/FloatingUI/custom contextMenu pattern). Some libs
+    // render the popup inside a 0-height inline wrapper and then absolute-position it
+    // out of the wrapper's box. Default isVisible() drops the wrapper (height: 0) and
+    // every popup descendant is lost. Detect: a 0×0 wrapper whose subtree contains a
+    // positioned (absolute/fixed) child with real bounds — force-mark that child.
+    if (portalInclude) {
+      function findPositionedPopup(el, maxDepth) {
+        if (maxDepth <= 0) return null;
+        for (const child of el.children) {
+          if (modalElements.has(child)) continue;
+          const cs = window.getComputedStyle(child);
+          if ((cs.position === 'absolute' || cs.position === 'fixed') &&
+              child.offsetWidth > 0 && child.offsetHeight > 0) {
+            return child;
+          }
+          const deeper = findPositionedPopup(child, maxDepth - 1);
+          if (deeper) return deeper;
+        }
+        return null;
+      }
+
+      const allEls = document.body.querySelectorAll('*');
+      for (const el of allEls) {
+        // Only zero-sized wrappers with children are candidates — cheap filter
+        if ((el.offsetHeight !== 0 && el.offsetWidth !== 0) || el.children.length === 0) continue;
+        const popup = findPositionedPopup(el, 3);
+        if (popup) forceMarkModalTree(popup);
+      }
+    }
   }
 
   // Build tree from body

package/server/tool-definitions.js

@@ -37,6 +37,10 @@ export const toolDefinitions = [
             waitAfter: { type: "number", description: "Wait ms (default: 1500)" },
             screenshot: { type: "boolean", description: "Screenshot (default: false)" },
             timeout: { type: "number", description: "Max wait ms (default: 30000)" },
+            waitForSelector: { type: "string", description: "CSS selector to wait for after click (atomic click+wait). Use for dropdowns/popups that render into portals." },
+            waitTimeoutMs: { type: "number", description: "Timeout for waitForSelector in ms (default: 2000)." },
+            waitForRouteChange: { type: "boolean", description: "SPA route wait: after click, wait for location.pathname+search to change vs before; reports 'routeChanged:true/false'. Does not fail click on timeout. For URL-less view changes use waitForSelector." },
+            autoAnalyzeAfter: { type: "boolean", description: "After click, diff APOM and append '+N appeared: id:\"text\"' delta to result. New ids are pre-registered for follow-up clicks. Use for dropdowns/menus opening with new options." },
           },
         },
       },
@@ -92,18 +96,18 @@ export const toolDefinitions = [
       },
       {
         name: "screenshot",
-        description: "Capture element image (5-10k tokens). Use analyzePage for form data/validation (8-10k tokens).",
+        description: "Capture element image (5-10k tokens), or full viewport when no id/selector is given. Use analyzePage for form data/validation (8-10k tokens).",
         inputSchema: {
           type: "object",
           properties: {
-            selector: { type: "string", description: "CSS selector" },
-            padding: { type: "number", description: "Padding px (default: 0)" },
+            id: { type: "string", description: "APOM element ID. Mutually exclusive with selector. Omit both for viewport screenshot." },
+            selector: { type: "string", description: "CSS selector. Mutually exclusive with id. Omit both for viewport screenshot." },
+            padding: { type: "number", description: "Padding px (default: 0). Ignored for viewport." },
             maxWidth: { type: "number", description: "Max width px (default: 1024, null=original)" },
             maxHeight: { type: "number", description: "Max height px (default: 8000, null=original)" },
             quality: { type: "number", minimum: 1, maximum: 100, description: "JPEG quality (default: 40)" },
             format: { type: "string", enum: ["png", "jpeg", "auto"], description: "Format (default: jpeg)" },
           },
-          required: ["selector"],
         },
       },
       {
@@ -364,6 +368,25 @@ Examples:
           required: ["url"],
         },
       },
+      {
+        name: "listFrames",
+        description: "List all frames (main + iframes) on the current page with url/name/isMain, plus the currently active frame. Use to discover cross-origin iframes (e.g. app.example.com), then switchFrame into one.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+      {
+        name: "switchFrame",
+        description: "Set the active frame so click/type/hover/analyzePage/find/executeScript/waitForElement run INSIDE it — required to automate cross-origin iframes (resolved via CDP, bypassing Same-Origin Policy). Call with no args to reset to the main frame. Auto-resets on navigateTo.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            frameUrl: { type: "string", description: "Substring matched against each frame's URL (e.g. 'app.example.com'). Mutually exclusive with frameSelector." },
+            frameSelector: { type: "string", description: "CSS selector of the <iframe> element; its content frame becomes active. Mutually exclusive with frameUrl." },
+          },
+        },
+      },
       {
         name: "getFigmaFrame",
         description: "Export Figma frame as PNG. Requires API token and file/node IDs.",
@@ -503,6 +526,7 @@ Examples:
           properties: {
             description: { type: "string", description: "Natural language description" },
             maxResults: { type: "number", minimum: 1, maximum: 20, description: "Max candidates (default: 5)" },
+            minConfidence: { type: "number", minimum: 0, maximum: 1, description: "Confidence threshold (default: 0.6) for auto-executing `action`. Below it (or too close to runner-up), action is skipped and candidates returned with 'actionSkipped'. Prevents auto-clicking the wrong control." },
             action: {
               type: "object",
               properties: {
@@ -532,6 +556,8 @@ Examples:
             groupBy: { type: "string", description: "Group elements: 'type' or 'flat' (default: 'type')", enum: ["type", "flat"] },
             viewportOnly: { type: "boolean", description: "Only analyze elements in current viewport (default: false). Reduces output for long pages." },
             diff: { type: "boolean", description: "Return only changes since last analysis: {added, removed, changed} (default: false)." },
+            includePortals: { type: "boolean", description: "Include React Portal contents — menus, tooltips, popovers outside main root (default: true). Without this, dropdown items are invisible." },
+            portalSelectors: { type: "array", items: { type: "string" }, description: "Custom portal root CSS selectors. Default: ['#modal-root', '#menu-popup-root', '#tooltip-root', '#popover-root', '[data-portal]']." },
           },
         },
       },

package/server/tool-groups.js

@@ -7,7 +7,7 @@
 export const toolGroups = {
   core: ['ping', 'openBrowser', 'executeScript', 'navigateTo'],
 
-  interaction: ['click', 'type', 'scrollTo', 'waitForElement', 'hover', 'selectOption', 'selectFromGroup', 'drag', 'scrollHorizontal'],
+  interaction: ['click', 'type', 'scrollTo', 'waitForElement', 'hover', 'selectOption', 'selectFromGroup', 'drag', 'scrollHorizontal', 'switchFrame', 'listFrames'],
 
   inspection: ['getElement', 'getComputedCss', 'getBoxModel', 'screenshot', 'saveScreenshot'],
 

package/server/tool-schemas.js

@@ -23,6 +23,10 @@ export const ClickSchema = z.object({
   timeout: z.number().optional().describe("Maximum time to wait for operation in ms (default: 30000)"),
   skipNetworkWait: z.boolean().optional().describe("Skip waiting for network requests (default: false). Use for forms with long-polling/WebSockets to avoid timeouts."),
   networkWaitTimeout: z.number().optional().describe("Maximum time to wait for network requests in ms (default: 3000). Only used if skipNetworkWait is false."),
+  waitForSelector: z.string().optional().describe("CSS selector to wait for after click — atomic click+wait. Useful for dropdowns/popups in portals (e.g. '#menu-popup-root > div') that otherwise race against the next MCP call."),
+  waitTimeoutMs: z.number().optional().describe("Timeout for waitForSelector in ms (default: 2000)."),
+  waitForRouteChange: z.boolean().optional().describe("For SPAs (React Router etc.): after click, wait for location.pathname+search to change relative to before. Surfaces 'routeChanged:true/false' so success means the view actually navigated, not just that the click was delivered. Does not fail the click on timeout. For content that renders without a URL change, prefer waitForSelector."),
+  autoAnalyzeAfter: z.boolean().optional().describe("After click, automatically diff APOM state and append a delta to the result: '+N appeared: id1:\"text\", id2:\"text\"'. New ids are re-registered so callers can use them directly in the next click/type call without an extra analyzePage. Use for dropdowns and menus that reveal new options on click."),
 }).refine(data => (data.id && !data.selector) || (!data.id && data.selector), {
   message: "Either 'id' or 'selector' must be provided, but not both"
 });
@@ -110,15 +114,15 @@ export const SetStylesSchema = z.object({
 
 // Screenshot tools
 export const ScreenshotSchema = z.object({
-  id: z.string().optional().describe("APOM element ID from analyzePage (e.g., 'div_20'). Mutually exclusive with selector."),
-  selector: z.string().optional().describe("CSS selector for element to screenshot. Mutually exclusive with id."),
-  padding: z.number().optional().describe("Padding around element in pixels (default: 0)"),
+  id: z.string().optional().describe("APOM element ID from analyzePage (e.g., 'div_20'). Mutually exclusive with selector. If neither id nor selector is provided, captures full viewport."),
+  selector: z.string().optional().describe("CSS selector for element to screenshot. Mutually exclusive with id. If neither id nor selector is provided, captures full viewport."),
+  padding: z.number().optional().describe("Padding around element in pixels (default: 0). Ignored for viewport screenshot."),
   maxWidth: z.number().nullable().optional().describe("Maximum width in pixels, auto-scales if larger (default: 1024, set to null for original size)"),
   maxHeight: z.number().nullable().optional().describe("Maximum height in pixels, auto-scales if larger (default: 8000 for API limit, set to null for original size)"),
   quality: z.number().min(1).max(100).optional().describe("JPEG quality 1-100 (default: 40)"),
   format: z.enum(['png', 'jpeg', 'auto']).optional().describe("Image format (default: 'jpeg')"),
-}).refine(data => (data.id && !data.selector) || (!data.id && data.selector), {
-  message: "Either 'id' or 'selector' must be provided, but not both"
+}).refine(data => !(data.id && data.selector), {
+  message: "Provide only one of 'id' or 'selector' (or neither for a viewport screenshot)"
 });
 
 export const SaveScreenshotSchema = z.object({
@@ -153,6 +157,13 @@ export const NavigateToSchema = z.object({
     .describe("Wait until event (default: networkidle2)"),
 });
 
+export const ListFramesSchema = z.object({});
+
+export const SwitchFrameSchema = z.object({
+  frameUrl: z.string().optional().describe("Substring matched against each frame's URL (e.g. 'app.example.com'). Selects the first matching frame, including cross-origin iframes (resolved via CDP, so Same-Origin Policy does not block access). Mutually exclusive with frameSelector."),
+  frameSelector: z.string().optional().describe("CSS selector of the <iframe> element in the current document; its content frame becomes active. Mutually exclusive with frameUrl."),
+}).describe("Set the active frame for subsequent click/type/hover/analyzePage/find/executeScript/waitForElement. Call with NO arguments to reset back to the main frame. Active frame is also reset automatically on navigateTo. Use listFrames() to discover available frames.");
+
 export const SetViewportSchema = z.object({
   width: z.number().min(320).max(4000).describe("Viewport width in pixels (320-4000)"),
   height: z.number().min(200).max(3000).describe("Viewport height in pixels (200-3000)"),
@@ -269,6 +280,7 @@ export const ConvertFigmaToCodeSchema = z.object({
 export const SmartFindElementSchema = z.object({
   description: z.string().describe("Natural language description of element to find (e.g., 'login button', 'email field')"),
   maxResults: z.number().min(1).max(20).optional().describe("Maximum number of candidates to return (default: 5)"),
+  minConfidence: z.number().min(0).max(1).optional().describe("Confidence threshold (0-1, default: 0.6) for auto-executing `action`. If the best match scores below this, OR is too close to the runner-up, the action is SKIPPED and candidates are returned with an 'actionSkipped' reason — prevents auto-clicking the wrong control (e.g. a primary form submit when you asked for a menu item). Lower it to act on weaker matches."),
   action: z.object({
     type: z.enum(['click', 'type', 'scrollTo', 'screenshot', 'hover', 'setStyles']).describe("Action to perform on the best match"),
     text: z.string().optional().describe("Text to type (required for 'type' action)"),
@@ -289,6 +301,8 @@ export const AnalyzePageSchema = z.object({
   groupBy: z.enum(['type', 'flat']).optional().describe("Group elements by type or return flat structure (default: 'type')"),
   viewportOnly: z.boolean().optional().describe("Only analyze elements visible in current viewport (default: false). Reduces output for long pages."),
   diff: z.boolean().optional().describe("Return only changes since last analysis: {added, removed, changed} (default: false). Useful after clicks to see what changed."),
+  includePortals: z.boolean().optional().describe("Include contents of React Portal containers that live outside main React root (default: true). Covers menus, tooltips, popovers rendered via portals — without this, dropdown contents are invisible to analyzePage."),
+  portalSelectors: z.array(z.string()).optional().describe("CSS selectors of portal root containers to scan (default: ['#modal-root', '#menu-popup-root', '#tooltip-root', '#popover-root', '[data-portal]']). Provide custom list when the app uses different portal element ids."),
 });
 
 export const GetElementDetailsSchema = z.object({

package/utils/actions/click-action.js

@@ -17,6 +17,8 @@ import { processScreenshot } from '../screenshot-processor.js';
  * @param {boolean} options.screenshot - Whether to capture screenshot after click
  * @param {boolean} options.skipNetworkWait - Skip waiting for network requests
  * @param {number} options.networkWaitTimeout - Network wait timeout in ms
+ * @param {string} options.waitForSelector - CSS selector to wait for after click (e.g., dropdown menu opening)
+ * @param {number} options.waitTimeoutMs - Timeout for waitForSelector in ms (default: 2000)
  * @returns {Promise<Object>} Result with content array
  */
 export async function executeClickAction(page, element, options = {}) {
@@ -24,7 +26,10 @@ export async function executeClickAction(page, element, options = {}) {
     identifier = 'element',
     screenshot = false,
     skipNetworkWait = false,
-    networkWaitTimeout = 3000
+    networkWaitTimeout = 3000,
+    waitForSelector = null,
+    waitTimeoutMs = 2000,
+    waitForRouteChange = false
   } = options;
 
   // Capture timestamp and URL BEFORE click for diagnostics
@@ -127,6 +132,52 @@ export async function executeClickAction(page, element, options = {}) {
 
   await clickWithTimeout();
 
+  // Atomic click + wait: if caller asked to wait for a selector to appear after click,
+  // do it BEFORE diagnostics. Useful for dropdowns/popups that render into a portal —
+  // without atomic wait, the next MCP call may race against the popup closing.
+  let waitResult = null;
+  if (waitForSelector) {
+    const waitStart = Date.now();
+    try {
+      await page.waitForSelector(waitForSelector, { timeout: waitTimeoutMs, visible: true });
+      waitResult = { appeared: true, selector: waitForSelector, appearedInMs: Date.now() - waitStart };
+    } catch (e) {
+      waitResult = {
+        appeared: false,
+        selector: waitForSelector,
+        timedOutAfterMs: Date.now() - waitStart,
+        timeoutMs: waitTimeoutMs
+      };
+    }
+  }
+
+  // SPA route-change wait (P1-5): SPAs navigate via history.pushState, so page.url()
+  // diagnostics below may not register a "navigation". Wait for location.pathname+search
+  // to actually change relative to before. Best-effort — a timeout never fails the click.
+  let routeChangeResult = null;
+  if (waitForRouteChange) {
+    let pathBefore;
+    try {
+      pathBefore = await page.evaluate(() => location.pathname + location.search);
+    } catch (e) {
+      pathBefore = null;
+    }
+    if (pathBefore !== null) {
+      const routeStart = Date.now();
+      try {
+        await page.waitForFunction(
+          (before) => (location.pathname + location.search) !== before,
+          { timeout: waitTimeoutMs },
+          pathBefore
+        );
+        const pathAfter = await page.evaluate(() => location.pathname + location.search);
+        routeChangeResult = { routeChanged: true, from: pathBefore, to: pathAfter, changedInMs: Date.now() - routeStart };
+      } catch (e) {
+        routeChangeResult = { routeChanged: false, from: pathBefore, timeoutMs: waitTimeoutMs };
+      }
+    }
+  }
+
   // Check if element was detached from DOM during click (Angular *ngFor + Zone.js pattern)
   let elementDetached = false;
   try {
@@ -207,6 +258,24 @@ export async function executeClickAction(page, element, options = {}) {
     hintsText += `\nSuggested next: ${hints.suggestedNext.join('; ')}`;
   }
 
+  // Surface SPA route-change outcome to the caller
+  if (routeChangeResult) {
+    if (routeChangeResult.routeChanged) {
+      hintsText += `\nRoute changed: "${routeChangeResult.from}" → "${routeChangeResult.to}" (${routeChangeResult.changedInMs}ms)`;
+    } else {
+      hintsText += `\n⚠️ ROUTE_UNCHANGED: location did not change within ${routeChangeResult.timeoutMs}ms after click (still "${routeChangeResult.from}"). View may render without a URL change — use waitForSelector instead.`;
+    }
+  }
+
+  // Surface waitForSelector outcome to the caller (success or timeout)
+  if (waitResult) {
+    if (waitResult.appeared) {
+      hintsText += `\nWait: "${waitResult.selector}" appeared in ${waitResult.appearedInMs}ms`;
+    } else {
+      hintsText += `\n⚠️ WAIT_TIMEOUT: "${waitResult.selector}" did not appear within ${waitResult.timeoutMs}ms after click`;
+    }
+  }
+
   // 4. Add diagnostics to output
   const diagnosticsText = formatDiagnosticsForAI(diagnostics);
 

package/utils/element-actions.js

@@ -20,13 +20,16 @@ async function takeActionScreenshot(page, clip) {
   };
 }
 
-// Helper function to execute actions on elements
-export async function executeElementAction(page, selector, action) {
+// Helper function to execute actions on elements.
+// `frame` (P0-1) is the DOM context used for element resolution/evaluation —
+// pass the active iframe's Frame to act inside it. Defaults to `page` (main frame).
+// Page-level operations (keyboard, screenshot) always use `page`.
+export async function executeElementAction(page, selector, action, frame = page) {
   if (!action || !action.type) {
     return null;
   }
 
-  const element = await page.$(selector);
+  const element = await frame.$(selector);
   if (!element) {
     throw new Error(`Element not found for action: ${selector}`);
   }
@@ -83,7 +86,7 @@ export async function executeElementAction(page, selector, action) {
     case 'scrollTo':
       await element.scrollIntoView({ behavior: 'auto' });
       await new Promise(resolve => setTimeout(resolve, action.waitAfter || 300));
-      const position = await page.evaluate(() => ({
+      const position = await frame.evaluate(() => ({
         x: window.scrollX,
         y: window.scrollY
       }));
@@ -128,7 +131,7 @@ export async function executeElementAction(page, selector, action) {
       for (const style of action.styles) {
         stylesObject[style.name] = style.value;
       }
-      await page.evaluate((sel, styles) => {
+      await frame.evaluate((sel, styles) => {
         const el = document.querySelector(sel);
         if (el) {
           Object.entries(styles).forEach(([key, value]) => {

package/utils/platform-utils.js

@@ -30,6 +30,10 @@ export const isWindows = process.platform === 'win32' || isWSL;
  * @returns {string} - Path to Chrome executable
  */
 export function getChromePath() {
+  // Explicit override wins on every platform
+  if (process.env.CHROMETOOLS_CHROME_PATH) {
+    return process.env.CHROMETOOLS_CHROME_PATH;
+  }
   if (process.platform === 'win32') {
     // Native Windows
     return 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe';
@@ -57,6 +61,17 @@ export function getTempDir() {
 }
 
 /**
- * Chrome remote debugging port
+ * Get the Chrome user-data-dir used when launching a new instance.
+ * Override with CHROMETOOLS_USER_DATA_DIR to point at a real/cloned profile
+ * that already holds the user's login session/cookies.
+ * @returns {string} - Path to Chrome user data directory
+ */
+export function getUserDataDir() {
+  return process.env.CHROMETOOLS_USER_DATA_DIR || `${getTempDir()}/chrome-mcp-profile`;
+}
+
+/**
+ * Chrome remote debugging port.
+ * Override with CHROMETOOLS_DEBUG_PORT (defaults to 9222).
  */
-export const CHROME_DEBUG_PORT = 9222;
+export const CHROME_DEBUG_PORT = parseInt(process.env.CHROMETOOLS_DEBUG_PORT, 10) || 9222;

package/utils/post-click-diagnostics.js

@@ -298,21 +298,38 @@ export function formatDiagnosticsForAI(diagnostics) {
   const netActivity = diagnostics.networkActivity;
   const trackedRequests = netActivity.trackedRequests || [];
 
-  // Show requests detected within 200ms after action
-  if (trackedRequests.length > 0) {
-    output += `\n\n📡 Network requests (${trackedRequests.length}):`;
-    trackedRequests.forEach((req, idx) => {
+  // Show requests detected within 200ms after action.
+  // P1-6: filter to data requests (XHR/Fetch) and drop static assets — a single
+  // SPA navigation pulls dozens of JS chunks/CSS/fonts that drown the signal.
+  // Cap the printed list and summarize the rest.
+  const STATIC_TYPES = new Set(['Script', 'Stylesheet', 'Font', 'Image', 'Media', 'Manifest', 'Other']);
+  const MAX_SHOWN = 12;
+  const dataRequests = trackedRequests.filter(req => {
+    if (!req.type) return true; // no type info → keep (bridge/legacy)
+    return !STATIC_TYPES.has(req.type);
+  });
+  const staticDropped = trackedRequests.length - dataRequests.length;
+
+  if (dataRequests.length > 0) {
+    const shown = dataRequests.slice(0, MAX_SHOWN);
+    output += `\n\n📡 Network requests (XHR/Fetch: ${dataRequests.length}${staticDropped > 0 ? `, ${staticDropped} static asset(s) hidden` : ''}):`;
+    shown.forEach((req, idx) => {
       const statusIcon = req.status === 'pending' ? '⏳' :
                         (req.status === 'completed' || (typeof req.status === 'number' && req.status < 400) ? '✓' : '✗');
       const statusText = req.statusText || req.status || 'pending';
       output += `\n  ${idx + 1}. ${statusIcon} ${req.method} ${req.url}`;
       output += `\n     → Status: ${statusText}`;
     });
+    if (dataRequests.length > MAX_SHOWN) {
+      output += `\n  … ${dataRequests.length - MAX_SHOWN} more`;
+    }
 
     // Show if some requests are still pending after timeout
     if (netActivity.stillPending > 0) {
       output += `\n\n⏳ ${netActivity.stillPending} request(s) still pending after ${Math.round(netActivity.waitedMs)}ms timeout`;
     }
+  } else if (staticDropped > 0) {
+    output += `\n\n📡 No XHR/Fetch requests detected within 200ms (${staticDropped} static asset(s) hidden)`;
   } else {
     output += '\n\n📡 No network requests detected within 200ms';
   }