@browserbridge/bbx 1.7.8 → 1.8.0

package/PRIVACY.md

@@ -1,6 +1,6 @@
 # Browser Bridge (BBX) Privacy Policy
 
-Last updated: 2026-03-27
+Last updated: 2026-07-22
 
 ## Overview
 
@@ -12,12 +12,21 @@ When you enable Browser Bridge for a Chrome window, Browser Bridge can access pa
 
 - Page metadata such as URL, title, viewport, and scroll position
 - DOM structure, element attributes, visible text, and layout information
-- Computed styles, matched rules, and accessibility-tree data
+- Computed styles, class/inline-style context, and semantic accessibility-tree data
 - Console messages and uncaught page errors
-- Network request metadata captured from page `fetch` and `XMLHttpRequest` activity, such as URL, method, status, timing, and size
+- Network request metadata captured from page `fetch` and `XMLHttpRequest` activity, such as URL, method, status, timing, type, timestamp, and size
+- Optional Chrome DevTools Protocol metadata for broader resource activity, including request ID, redacted URL, method, resource type, status, MIME type, protocol, cache indicators, redirects, failure reason, duration, and timestamp
+- Current JavaScript dialog information when observable and explicitly requested, including dialog type, bounded message text, and bounded default prompt text
 - `localStorage` and `sessionStorage` values when explicitly requested
 - Screenshots or cropped image captures when explicitly requested
-- User-triggered interaction data such as clicks, typing, key presses, selection changes, and navigation actions
+- User-triggered interaction data and results such as clicks, native pointer movement/drag, DOM or native text dispatch, key presses, selection changes, dialog decisions, and navigation actions
+- Bounded semantic descriptors for optional stale-element recovery, represented in memory with normalized hashes and structural context rather than page text values or attributes written into the application DOM
+
+All-resource network inspection excludes request and response bodies, cookies,
+authorization values, and complete headers. It removes URL credentials and
+fragments, replaces query parameter values with a redaction marker, and
+summarizes data/blob URLs before returning them. Browser Bridge does not expose
+these excluded values through that feature.
 
 Browser Bridge is designed for local debugging and automation of the browser state you intentionally expose to it.
 
@@ -25,17 +34,17 @@ Browser Bridge is designed for local debugging and automation of the browser sta
 
 Browser Bridge uses this data only to provide its user-facing purpose: letting you inspect, test, and patch the currently enabled browser window from a connected developer tool or agent.
 
-The extension sends request and response data locally through:
+The normal local path sends request and response data through:
 
 1. The Browser Bridge Chrome extension
 2. The Browser Bridge native messaging host running on your machine
-3. The local agent client or IDE that you intentionally connect
+3. The agent client or IDE that you intentionally connect
 
-Browser Bridge does not operate a Browser Bridge cloud service and does not send extension data to developer-operated remote servers.
+The extension/native-host segment remains on the browser machine. If you explicitly configure an authenticated remote destination, the daemon can send bridge results over your own SSH tunnel or network route to that selected client. Browser Bridge does not operate a Browser Bridge cloud service and does not send extension data to developer-operated remote servers. Raw remote TCP is not presented as encrypted.
 
 ## Sharing and downstream processing
 
-Browser Bridge shares page data only with the local companion components and local client you choose to connect.
+Browser Bridge shares page data only with the companion components and client you choose to connect. The normal path is local. If you explicitly configure Browser Bridge's authenticated remote proxy and your own tunnel or network route, the selected remote client can receive bridge results through that user-configured path; Browser Bridge does not provide or operate that network service.
 
 Important:
 
@@ -52,8 +61,11 @@ Browser Bridge keeps data only as long as needed for the current local session a
 
 - Window enablement state is stored in session storage and cleared when disabled or when the browser session ends.
 - Action log entries are stored for the current browser session only.
-- Console and network buffers are bounded in memory and cleared when disabled or when the page state is reset.
-- Patch state and remembered element references are session-scoped and cleared on disable, page replacement, or navigation as needed.
+- Console and fetch/XHR network buffers are bounded in memory and cleared when disabled or when the page state is reset.
+- Optional CDP network capture is bounded in memory, explicitly started/stopped, expires after a safety interval, and is cleared on relevant debugger, tab, or access teardown.
+- Dialog message/default prompt text is returned to the requesting caller when inspected but is excluded from persisted action-log summaries and size diagnostics.
+- Patch rollback records and remembered element references live in the current document. Browser Bridge attempts patch rollback when access is disabled or switched, while page replacement/navigation removes document-local state.
+- Hashed semantic descriptors used for optional stale recovery are bounded in memory with the element registry and do not survive the document/registry lifecycle.
 
 Browser Bridge does not provide Browser Bridge-hosted accounts, sync, or long-term server-side storage.
 
@@ -72,12 +84,19 @@ Browser Bridge does not load remotely hosted extension code.
 
 Browser Bridge can, when you explicitly invoke features such as page evaluation, execute user-requested expressions in the inspected page context through Chrome's documented Debugger API. That execution affects only the currently enabled browser window and is part of Browser Bridge's developer-tool functionality.
 
+The same existing Debugger API permission is used only when requested for
+native pointer/text dispatch, JavaScript dialog observation and explicit
+handling, accessibility reads, screenshots, performance/CDP reads, interception,
+and optional all-resource network capture. Browser Bridge does not silently
+accept/dismiss dialogs and does not claim that accepted browser input proves an
+application-level outcome.
+
 ## Security
 
 - Extension code is packaged with the extension; Browser Bridge does not fetch and execute remote extension scripts.
 - Communication with the companion host uses Chrome Native Messaging.
 - Access is limited to the explicitly enabled browser window.
-- The extension includes bounded buffers and session-scoped rollback for temporary page patches.
+- The extension includes bounded buffers and document-local rollback records for temporary page patches, with rollback attempted when enabled-window access ends or switches.
 
 ## Chrome Web Store Limited Use statement
 

package/README.md

@@ -4,7 +4,7 @@
 
 > **Chrome Web Store:** Install `Browser Bridge (BBX)` from the [Chrome Web Store](https://chromewebstore.google.com/detail/browser-bridge/jjjkmmcdkpcgamlopogicbnnhdgebhie). For local or custom builds, use the unpacked install flow in [docs/unpacked-extension.md](https://github.com/koltyakov/browser-bridge/blob/main/docs/unpacked-extension.md).
 
-A local bridge between your coding agent and a real Chrome tab. Browser Bridge gives the agent structured access to DOM, styles, layout, console, network, and reversible patches - starting from the actual tab you already have open, with all its real state intact.
+A local bridge between your coding agent and a real Chrome tab. Browser Bridge gives the agent structured access to DOM, styles, layout, console, network, accessibility data, reliable browser input, explicit JavaScript dialog handling, and reversible patches - starting from the actual tab you already have open, with all its real state intact.
 
 See [Quickstart](https://github.com/koltyakov/browser-bridge/blob/main/docs/quickstart.md) to get started in another repo, or browse the rest of the guides in [docs/index.md](https://github.com/koltyakov/browser-bridge/blob/main/docs/index.md).
 
@@ -101,7 +101,7 @@ Managed installs support OpenAI Codex, Claude Code, Cursor, GitHub Copilot, Open
 
 Most adjacent tools optimize for different goals. [Playwright](https://playwright.dev/) and headless automation stacks are excellent for deterministic tests and CI - but they start from a clean browser context by design. [Claude in Chrome](https://support.claude.com/en/articles/12012173-get-started-with-claude-in-chrome) is great for integrated Claude workflows, and the [Codex extension](https://chromewebstore.google.com/detail/codex/hehggadaopoacecdllhhajmbjkdcmajg) is a great option if you use Codex, but both are vendor-specific. Generic MCP browser servers offer broad control without the developer-focused depth.
 
-Browser Bridge is optimized for the opposite starting point: **inspect the state that already exists** in a real tab - logged-in sessions, feature flags, seeded storage, SPA state - use structured reads to understand it, test a patch in place, then fix the source. It's open-source, agent-agnostic, and scoped to explicit tab sessions rather than ambient browser control.
+Browser Bridge is optimized for the opposite starting point: **inspect the state that already exists** in a real tab - logged-in sessions, feature flags, seeded storage, SPA state - use structured reads to understand it, test a patch in place, then fix the source. It's open-source, agent-agnostic, and scoped to one explicitly enabled browser window rather than ambient browser control.
 
 ## Setup
 
@@ -120,9 +120,13 @@ MCP mode is self-contained: the server exposes tools and startup instructions, s
 
 - The extension is scoped to one explicitly enabled Chrome window at a time - no ambient browser access
 - Requests default to the active tab in that window unless a tab is targeted explicitly
-- Sessions are tab and origin scoped, auto-refreshed when possible
-- All patch operations are reversible and session-scoped
+- Targeted input actions reject hidden, disabled, ambiguous, stale, or obscured targets instead of silently guessing; their responses report the resolution and DOM/CDP execution path (`cdp_press_key` and `scroll_into_view` use separate contracts)
+- Native pointer/text input, dialog handling, all-resource network capture, accessibility trees, screenshots, and raw CDP reads use the existing debugger permission only when requested
+- Element references are document-local and strict by default; stale input recovery is opt-in, same-document, requires one strong unique semantic match, and fails safely when its bounded scan cannot prove uniqueness
+- Patches keep per-document rollback history and Browser Bridge attempts best-effort rollback when window access is disabled or switched; committing the patch baseline keeps current changes but discards their rollback history
+- URL waits observe full navigation and same-document SPA changes, and report the final URL and observed navigation kind
 - Structured DOM/style/layout reads are the primary transport; screenshots are a fallback
+- Browser input dispatch does not prove the application accepted the intended change, so agents should verify with a wait or structured read
 - Open-ended investigation should start with structured reads on a smaller, lower-cost subagent when the client supports delegation
 - The native host daemon auto-starts on demand
 
@@ -139,7 +143,7 @@ MCP mode is self-contained: the server exposes tools and startup instructions, s
 
 ## Privacy
 
-Browser Bridge itself routes extension data locally through the Chrome extension, native host, and the local client you choose to connect. Browser Bridge does not operate a Browser Bridge cloud service.
+The extension and native host communicate on the browser machine, and local clients connect to that daemon by default. If you explicitly configure an authenticated remote destination, bridge results can travel over your user-provided SSH tunnel or network route to the selected client. Browser Bridge does not operate a Browser Bridge cloud service, and raw remote TCP is not presented as encrypted.
 
 Your connected agent or IDE may still forward tool calls or tool results to remote services under that product's own settings and privacy policy. See [PRIVACY.md](https://github.com/koltyakov/browser-bridge/blob/main/PRIVACY.md) for the Browser Bridge policy.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbridge/bbx",
-  "version": "1.7.8",
+  "version": "1.8.0",
   "private": false,
   "keywords": [
     "agent-tools",
@@ -55,8 +55,9 @@
     "lint": "oxlint . && oxfmt --check .",
     "format": "oxfmt .",
     "format:check": "oxfmt --check .",
-    "test:runtime": "node --test",
-    "test": "c8 node --test",
+    "fixture:browser": "node tests/fixtures/browser-reliability/server.mjs",
+    "test:runtime": "node --import tsx --test packages/*/test/*.test.ts packages/integration-tests/*.test.ts tests/fixtures/*/*.test.ts",
+    "test": "c8 node --import tsx --test packages/*/test/*.test.ts packages/integration-tests/*.test.ts tests/fixtures/*/*.test.ts",
     "coverage": "c8 report --reporter=text --reporter=text-summary",
     "coverage:review": "c8 report --reporter=json-summary && node scripts/review-coverage.mjs",
     "coverage:check": "c8 check-coverage --lines 92 --branches 83",
@@ -73,15 +74,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@mozilla/readability": "^0.6.0",
+    "linkedom": "^0.18.13",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/chrome": "^0.2.2",
     "@types/node": "^26.1.1",
     "c8": "^12.0.0",
-    "linkedom": "^0.18.13",
-    "oxfmt": "^0.59.0",
-    "oxlint": "^1.74.0",
+    "oxfmt": "^0.60.0",
+    "oxlint": "^1.75.0",
+    "tsx": "^4.23.1",
     "typescript": "^7.0.2"
   },
   "engines": {

package/packages/agent-client/src/cli-args.js

@@ -60,6 +60,30 @@ export function extractTabFlag(args) {
   return { tabId, rest };
 }
 
+/**
+ * @param {string[]} args
+ * @returns {{ format: 'png' | 'jpeg' | 'webp', quality: number | undefined, rest: string[] }}
+ */
+export function extractScreenshotFlags(args) {
+  const rest = [...args];
+  const formatIndex = rest.indexOf('--format');
+  const rawFormat = formatIndex === -1 ? 'png' : rest[formatIndex + 1];
+  if (rawFormat !== 'png' && rawFormat !== 'jpeg' && rawFormat !== 'webp') {
+    throw new Error('--format must be png, jpeg, or webp.');
+  }
+  if (formatIndex !== -1) rest.splice(formatIndex, 2);
+  const qualityIndex = rest.indexOf('--quality');
+  let quality;
+  if (qualityIndex !== -1) {
+    quality = Number(rest[qualityIndex + 1]);
+    if (!Number.isInteger(quality) || quality < 0 || quality > 100) {
+      throw new Error('--quality must be an integer from 0 to 100.');
+    }
+    rest.splice(qualityIndex, 2);
+  }
+  return { format: rawFormat, quality, rest };
+}
+
 /**
  * @param {string[]} args
  * @returns {Promise<{ tabId: number | null, method: BridgeMethod, params: Record<string, unknown> }>}

package/packages/agent-client/src/cli.js

@@ -16,6 +16,7 @@ import {
 import { startBridgeMcpServer } from '../../mcp-server/src/server.js';
 import {
   extractRemoteFlag,
+  extractScreenshotFlags,
   extractTabFlag,
   parseCallCommand,
   parseInterceptAddArgs,
@@ -197,10 +198,10 @@ async function runLocalCommand(run) {
  */
 async function createCliClient() {
   try {
-    return await createBridgeClientForDestination(
-      remoteDestinationId,
-      clientTimeoutMs ? { defaultTimeoutMs: clientTimeoutMs } : {}
-    );
+    return await createBridgeClientForDestination(remoteDestinationId, {
+      checkProtocolOnConnect: false,
+      ...(clientTimeoutMs ? { defaultTimeoutMs: clientTimeoutMs } : {}),
+    });
   } catch (error) {
     printJson({
       ok: false,
@@ -362,62 +363,31 @@ async function main() {
 
     const shortcutCmd = SHORTCUT_COMMANDS[command];
     if (shortcutCmd) {
-      // Allow `bbx <shortcut> --tab <id> ...` to target a specific tab.
-      // Without this, --tab gets eaten as a positional argument and the
-      // request hits whatever tab the bridge route happens to be pointing
-      // at (typically the active tab). For element-resolving shortcuts
-      // the ref must be resolved against the SAME tab the action targets,
-      // so we pass tabId to both resolveRef and the subsequent request.
       const { tabId, rest: shortcutArgs } = extractTabFlag(rest);
-      const selectorInput = shortcutCmd.resolve ? shortcutArgs[0] : null;
-      if (shortcutCmd.resolve && !selectorInput) {
-        throw new Error(`Usage: ${command} <ref|selector>`);
-      }
-
-      // Retry-on-stale: if the action fails with ELEMENT_STALE and the
-      // original input was a selector (not an el_xxx ref), re-resolve the
-      // selector and retry once. This handles the common case where the
-      // agent resolved an element, then the page re-rendered (React
-      // reconciliation, SPA navigation) before the action was dispatched.
-      const canRetry = typeof selectorInput === 'string' && !selectorInput.startsWith('el_');
-      const maxAttempts = canRetry ? 2 : 1;
-      /** @type {import('./runtime.js').BridgeResponse | undefined} */
-      let response;
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        let elementRef;
-        if (shortcutCmd.resolve && selectorInput) {
-          elementRef = await resolveRef(client, selectorInput, tabId, REQUEST_SOURCE);
-        }
-        response = await requestBridge(
-          client,
-          shortcutCmd.method,
-          shortcutCmd.build(shortcutArgs, elementRef),
-          { source: REQUEST_SOURCE, tabId }
-        );
-        const isStale = !response.ok && response.error?.code === 'ELEMENT_STALE';
-        if (isStale && attempt < maxAttempts) {
-          process.stderr.write(
-            `bbx: ELEMENT_STALE on "${selectorInput}", re-resolving and retrying...\n`
-          );
-        }
-        if (!isStale || attempt >= maxAttempts) break;
-      }
-      if (response) await printSummary(response, shortcutCmd.printMethod);
+      const response = await requestBridge(
+        client,
+        shortcutCmd.method,
+        shortcutCmd.build(shortcutArgs),
+        { source: REQUEST_SOURCE, tabId }
+      );
+      await printSummary(response, shortcutCmd.printMethod);
       return;
     }
 
     if (command === 'press-key') {
       const [key, refOrSelector] = rest;
       if (!key) throw new Error('Usage: press-key <key> [ref|selector]');
-      const elementRef = refOrSelector
-        ? await resolveRef(client, refOrSelector, null, REQUEST_SOURCE)
+      const target = refOrSelector
+        ? refOrSelector.startsWith('el_')
+          ? { elementRef: refOrSelector }
+          : { selector: refOrSelector }
         : undefined;
       const response = await requestBridge(
         client,
         'input.press_key',
         {
           key,
-          target: elementRef ? { elementRef } : undefined,
+          target,
         },
         { source: REQUEST_SOURCE }
       );
@@ -447,15 +417,20 @@ async function main() {
 
     if (command === 'screenshot') {
       const parsed = extractTabFlag(rest);
-      const [refOrSelector, outputPath] = parsed.rest;
+      const screenshotOptions = extractScreenshotFlags(parsed.rest);
+      const [refOrSelector, outputPath] = screenshotOptions.rest;
       if (!refOrSelector)
-        throw new Error('Usage: screenshot [--tab <tabId>] <ref|selector> [path]');
+        throw new Error(
+          'Usage: screenshot [--tab <tabId>] [--format png|jpeg|webp] [--quality 0-100] <ref|selector> [path]'
+        );
       const elementRef = await resolveRef(client, refOrSelector, parsed.tabId, REQUEST_SOURCE);
       const response = await requestBridge(
         client,
         'screenshot.capture_element',
         {
           elementRef,
+          format: screenshotOptions.format,
+          quality: screenshotOptions.quality,
         },
         { tabId: parsed.tabId, source: REQUEST_SOURCE }
       );
@@ -464,13 +439,32 @@ async function main() {
         return;
       }
       const screenshotResult = /** @type {ScreenshotResult} */ (response.result);
-      const filePath = outputPath || path.join(os.tmpdir(), `bbx-${Date.now()}.png`);
-      const data = screenshotResult.image.replace(/^data:image\/png;base64,/, '');
+      const extension = screenshotOptions.format === 'jpeg' ? 'jpg' : screenshotOptions.format;
+      const acceptedExtensions =
+        screenshotOptions.format === 'jpeg'
+          ? new Set(['.jpg', '.jpeg'])
+          : new Set([`.${extension}`]);
+      let filePath = outputPath || path.join(os.tmpdir(), `bbx-${Date.now()}.${extension}`);
+      if (outputPath && !path.extname(outputPath)) filePath = `${outputPath}.${extension}`;
+      if (
+        outputPath &&
+        path.extname(outputPath) &&
+        !acceptedExtensions.has(path.extname(outputPath))
+      ) {
+        throw new Error(`Screenshot path extension must match ${screenshotOptions.format} format.`);
+      }
+      const data = screenshotResult.image.replace(/^data:image\/(?:png|jpeg|webp);base64,/, '');
       await fs.promises.writeFile(filePath, Buffer.from(data, 'base64'));
       printJson({
         ok: true,
         summary: `Screenshot saved to ${filePath}.`,
-        evidence: { savedTo: filePath, rect: screenshotResult.rect },
+        evidence: {
+          savedTo: filePath,
+          rect: screenshotResult.rect,
+          format: screenshotResult.format,
+          complete: screenshotResult.complete,
+          clipped: screenshotResult.clipped,
+        },
       });
       return;
     }

package/packages/agent-client/src/client.js

@@ -6,12 +6,16 @@ import net from 'node:net';
 import { randomUUID } from 'node:crypto';
 
 import {
+  createFailure,
   createRequest,
+  createSuccess,
   DEFAULT_CLIENT_REQUEST_TIMEOUT_MS,
+  ERROR_CODES,
   getProtocolVersion,
   parseJsonLines,
   setProtocolPackageVersion,
 } from '../../protocol/src/index.js';
+import { extractContentFromHtml } from './content-extract.js';
 import {
   createSocketBridgeTransport,
   getBridgeTransport,
@@ -112,6 +116,7 @@ export class BridgeClient extends EventEmitter {
     clientId = `agent_${randomUUID()}`,
     defaultTimeoutMs = DEFAULT_CLIENT_REQUEST_TIMEOUT_MS,
     autoReconnect = false,
+    checkProtocolOnConnect = true,
     restartDaemonOnVersionMismatch = shouldAutoRestartDaemonOnVersionMismatch(),
     restartDaemonFn = restartBridgeDaemon,
     authToken = undefined,
@@ -123,6 +128,7 @@ export class BridgeClient extends EventEmitter {
     this.clientId = clientId;
     this.defaultTimeoutMs = defaultTimeoutMs;
     this.autoReconnect = autoReconnect;
+    this.checkProtocolOnConnect = checkProtocolOnConnect;
     this.restartDaemonOnVersionMismatch = restartDaemonOnVersionMismatch;
     this.restartDaemonFn = restartDaemonFn;
     this.authToken = authToken;
@@ -246,6 +252,9 @@ export class BridgeClient extends EventEmitter {
 
     this.protocolCompatibility = null;
     this.protocolWarning = null;
+    if (!this.checkProtocolOnConnect) {
+      return;
+    }
 
     /** @type {ProtocolHealthResult | null} */
     let healthResult = null;
@@ -312,6 +321,113 @@ export class BridgeClient extends EventEmitter {
       meta,
     });
 
+    if (method === 'page.extract_content') {
+      const params =
+        /** @type {import('../../protocol/src/types.js').NormalizedExtractContentParams} */ (
+          request.params
+        );
+      const titleResponse = params.includeMetadata
+        ? await this.request({ method: 'page.get_state', tabId, meta, timeoutMs })
+        : null;
+      if (titleResponse && !titleResponse.ok) {
+        return {
+          ...titleResponse,
+          id: request.id,
+          meta: { ...titleResponse.meta, method },
+        };
+      }
+      const titleResult =
+        titleResponse?.ok && titleResponse.result && typeof titleResponse.result === 'object'
+          ? /** @type {Record<string, unknown>} */ (titleResponse.result)
+          : {};
+      const readSnapshot = () =>
+        this.request({
+          method: 'dom.get_html',
+          tabId,
+          params: {
+            target: { selector: params.selector ?? 'body' },
+            outer: true,
+            maxLength: 50_000,
+          },
+          meta: { ...meta, token_budget: null },
+          timeoutMs,
+        });
+
+      let snapshotResponse = await readSnapshot();
+      if (!snapshotResponse.ok) {
+        return {
+          ...snapshotResponse,
+          id: request.id,
+          meta: { ...snapshotResponse.meta, method },
+        };
+      }
+      let snapshot = normalizeHtmlSnapshot(snapshotResponse.result);
+      if (snapshot.truncated) {
+        return createFailure(
+          request.id,
+          ERROR_CODES.RESULT_TRUNCATED,
+          'The bounded HTML snapshot was too large for semantic extraction.',
+          {
+            selector: params.selector,
+            omitted: snapshot.omitted,
+            maxLength: 50_000,
+          },
+          {
+            method,
+            continuation_hint: 'Retry with a narrower selector.',
+          }
+        );
+      }
+
+      let settlement;
+      if (params.consistency === 'settled') {
+        const deadline = Date.now() + params.settleTimeoutMs;
+        let timedOut = false;
+        while (true) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          const nextResponse = await readSnapshot();
+          if (!nextResponse.ok) {
+            return {
+              ...nextResponse,
+              id: request.id,
+              meta: { ...nextResponse.meta, method },
+            };
+          }
+          const nextSnapshot = normalizeHtmlSnapshot(nextResponse.result);
+          if (nextSnapshot.truncated) {
+            return createFailure(
+              request.id,
+              ERROR_CODES.RESULT_TRUNCATED,
+              'The bounded HTML snapshot was too large for semantic extraction.',
+              { selector: params.selector, omitted: nextSnapshot.omitted, maxLength: 50_000 },
+              { method, continuation_hint: 'Retry with a narrower selector.' }
+            );
+          }
+          if (nextSnapshot.html === snapshot.html) {
+            snapshot = nextSnapshot;
+            break;
+          }
+          snapshot = nextSnapshot;
+          if (Date.now() >= deadline) {
+            timedOut = true;
+            break;
+          }
+        }
+        settlement = { requested: true, quietMs: 100, timedOut };
+      }
+
+      const result = extractContentFromHtml(snapshot.html, params, {
+        title: typeof titleResult.title === 'string' ? titleResult.title : undefined,
+        settlement,
+      });
+      return this.attachProtocolWarning(
+        createSuccess(request.id, result, {
+          method,
+          node_processed: true,
+        })
+      );
+    }
+
     const responsePromise = new Promise((resolve, reject) => {
       const timeoutId = setTimeout(() => {
         this.waiting.delete(request.id);
@@ -419,10 +535,13 @@ export class BridgeClient extends EventEmitter {
           ? healthResult.supported_versions
           : [];
     const latestRemote = remoteVersions[0];
+    const extensionVersions = Array.isArray(healthResult?.extension_supported_versions)
+      ? healthResult.extension_supported_versions
+      : healthResult?.supported_versions;
     if (
       healthResult?.extensionConnected === true &&
-      Array.isArray(healthResult.supported_versions) &&
-      !healthResult.supported_versions.includes(getProtocolVersion())
+      Array.isArray(extensionVersions) &&
+      !extensionVersions.includes(getProtocolVersion())
     ) {
       return false;
     }
@@ -466,9 +585,11 @@ export class BridgeClient extends EventEmitter {
    * @returns {{ compatible: boolean, localVersion: string, remoteVersions: string[], warning?: string }}
    */
   static checkProtocolVersion(healthResult) {
-    const remoteVersions = Array.isArray(healthResult?.supported_versions)
-      ? healthResult.supported_versions
-      : [];
+    const remoteVersions = Array.isArray(healthResult?.extension_supported_versions)
+      ? healthResult.extension_supported_versions
+      : Array.isArray(healthResult?.supported_versions)
+        ? healthResult.supported_versions
+        : [];
     if (remoteVersions.length === 0) {
       return {
         compatible: true,
@@ -520,3 +641,17 @@ export class BridgeClient extends EventEmitter {
     };
   }
 }
+
+/**
+ * @param {unknown} result
+ * @returns {{ html: string, truncated: boolean, omitted: number }}
+ */
+function normalizeHtmlSnapshot(result) {
+  const value =
+    result && typeof result === 'object' ? /** @type {Record<string, unknown>} */ (result) : {};
+  return {
+    html: typeof value.html === 'string' ? value.html : '',
+    truncated: value.truncated === true,
+    omitted: typeof value.omitted === 'number' ? value.omitted : 0,
+  };
+}