barebrowse 0.15.0 → 0.18.0

package/src/consent.js

@@ -4,152 +4,13 @@
  * Scans the page ARIA tree for consent dialogs and clicks the "accept" button.
  * Works across languages by matching common accept/agree patterns.
  * Runs once after page load — no polling, no mutation observers.
+ *
+ * The multilingual pattern sets live in consent-patterns.js (shared with the
+ * Firefox/BiDi walker in consent-firefox.js); this file owns the CDP-specific
+ * tree walk + click.
  */
 
-// Button text patterns that mean "accept all" / "I agree" across common languages.
-// Order matters: more specific patterns first to avoid false positives.
-const ACCEPT_PATTERNS = [
-  // English
-  /\baccept\s*all\b/i,
-  /\ballow\s*all\b/i,
-  /\bagree\s*to\s*all\b/i,
-  /\byes,?\s*i\s*agree\b/i,
-  /\bi\s*agree\b/i,
-  /\baccept\s*cookies?\b/i,
-  /\ballow\s*cookies?\b/i,
-  /\bgot\s*it\b/i,
-  // Dutch
-  /\balles\s*accepteren\b/i,
-  /\balles\s*toestaan\b/i,
-  /\baccepteren\b/i,
-  /\bakkoord\b/i,
-  // German
-  /\balle\s*akzeptieren\b/i,
-  /\ballem\s*zustimmen\b/i,
-  /\balle\s*cookies?\s*akzeptieren\b/i,
-  // French
-  /\btout\s*accepter\b/i,
-  /\baccepter\s*tout\b/i,
-  /\bj['']accepte\b/i,
-  // Spanish
-  /\baceptar\s*todo\b/i,
-  /\baceptar\s*todas?\b/i,
-  // Italian
-  /\baccetta\s*tutto\b/i,
-  /\baccetto\b/i,
-  // Portuguese
-  /\baceitar\s*tudo\b/i,
-  // Russian
-  /принять\s*все/i,
-  /принять/i,
-  /согласен/i,
-  // Ukrainian
-  /прийняти\s*все/i,
-  /прийняти/i,
-  // Polish
-  /zaakceptuj\s*wszystk/i,
-  /akceptuj\s*wszystk/i,
-  /zgadzam\s*się/i,
-  // Czech
-  /přijmout\s*vše/i,
-  /souhlasím/i,
-  // Turkish
-  /tümünü\s*kabul\s*et/i,
-  /kabul\s*et/i,
-  /kabul\s*ediyorum/i,
-  // Romanian
-  /acceptă\s*tot/i,
-  /accept\s*toate/i,
-  // Hungarian
-  /összes\s*elfogadás/i,
-  /elfogad/i,
-  // Greek
-  /αποδοχή\s*όλων/i,
-  /αποδέχομαι/i,
-  // Swedish
-  /acceptera\s*alla/i,
-  /godkänn\s*alla/i,
-  // Danish
-  /accepter\s*alle/i,
-  /acceptér\s*alle/i,
-  // Norwegian
-  /godta\s*alle/i,
-  /aksepter\s*alle/i,
-  // Finnish
-  /hyväksy\s*kaikki/i,
-  /hyväksyn/i,
-  // Arabic
-  /قبول\s*الكل/,
-  /قبول\s*الجميع/,
-  /موافق/,
-  /قبول/,
-  // Persian
-  /پذیرش\s*همه/,
-  /موافقم/,
-  /پذیرش/,
-  // Chinese (Simplified + Traditional)
-  /全部接受/,
-  /接受所有/,
-  /接受全部/,
-  /同意并继续/,
-  /全部接受/,
-  /接受/,
-  /同意/,
-  // Japanese
-  /すべて受け入れ/,
-  /すべて許可/,
-  /同意する/,
-  /同意します/,
-  // Korean
-  /모두\s*수락/,
-  /모두\s*동의/,
-  /동의합니다/,
-  /수락/,
-  // Vietnamese
-  /chấp\s*nhận\s*tất\s*cả/i,
-  /đồng\s*ý\s*tất\s*cả/i,
-  /đồng\s*ý/i,
-  // Thai
-  /ยอมรับทั้งหมด/,
-  /ยอมรับ/,
-  // Hindi
-  /सभी\s*स्वीकार/,
-  /स्वीकार\s*करें/,
-  /सहमत/,
-  // Indonesian / Malay
-  /terima\s*semua/i,
-  /setuju/i,
-  // Generic single-word fallbacks (only matched inside dialogs)
-  /^accept$/i,
-  /^agree$/i,
-  /^ok$/i,
-];
-
-// Roles that indicate a consent dialog container.
-const DIALOG_ROLES = new Set(['dialog', 'alertdialog']);
-
-// Text patterns in dialog names/headings that confirm it's about consent.
-const CONSENT_DIALOG_HINTS = [
-  /cookie/i,
-  /consent/i,
-  /privacy/i,
-  /before\s*you\s*continue/i,
-  /voordat\s*je\s*verdergaat/i,  // Dutch
-  /bevor\s*du\s*fortf/i,         // German
-  /avant\s*de\s*continuer/i,     // French
-  /antes\s*de\s*continuar/i,     // Spanish / Portuguese
-  /prima\s*di\s*continuare/i,    // Italian
-  /zanim\s*przejdziesz/i,        // Polish
-  /прежде\s*чем\s*продолжить/i,  // Russian
-  /devam\s*etmeden\s*önce/i,     // Turkish
-  /続行する前に/,                  // Japanese
-  /继续前/,                        // Chinese Simplified
-  /繼續前/,                        // Chinese Traditional
-  /계속하기\s*전에/,                // Korean
-  /trước\s*khi\s*tiếp\s*tục/i,   // Vietnamese
-  /ملفات\s*تعريف\s*الارتباط/,    // Arabic: cookies
-  /คุกกี้/,                        // Thai: cookies
-];
+import { ACCEPT_PATTERNS, DIALOG_ROLES, CONSENT_DIALOG_HINTS } from './consent-patterns.js';
 
 /**
  * Click a node via JavaScript .click() instead of mouse events.

package/src/daemon.js

@@ -67,6 +67,74 @@ export function buildDaemonArgs(opts, absDir, initialUrl, cliPath) {
   return args;
 }
 
+/**
+ * Wire Firefox/BiDi console + network capture onto the daemon's log arrays.
+ * The BiDi analogue of the CDP `Runtime.consoleAPICalled` / `Network.*`
+ * capture — measured event shapes: `log.entryAdded` carries {method, level,
+ * args:[{type,value}], text}; the network events key in-flight requests by
+ * `request.request` and expose `response.{status,statusText,mimeType}` /
+ * top-level `errorText`. Pure + exported so the shape mapping (warn→warning
+ * normalization, arg extraction, orphan-safe response/error pairing) is
+ * unit-testable against a fake bidi without launching Firefox.
+ *
+ * @param {object} bidi - BiDi client (async .subscribe(), .on(method, cb))
+ * @param {object} sinks
+ * @param {Array} sinks.consoleLogs - push-target for console entries
+ * @param {Array} sinks.networkLogs - push-target for completed/failed requests
+ * @param {Map} sinks.pendingRequests - in-flight request bookkeeping
+ * @returns {Promise<void>}
+ */
+export async function attachBiDiCapture(bidi, { consoleLogs, networkLogs, pendingRequests }) {
+  await bidi.subscribe([
+    'log.entryAdded',
+    'network.beforeRequestSent',
+    'network.responseCompleted',
+    'network.fetchError',
+  ]);
+
+  bidi.on('log.entryAdded', (e) => {
+    consoleLogs.push({
+      // Map BiDi's console method (or level for uncaught JS errors) to CDP's
+      // `type` vocabulary so `console-logs --level warning` matches on both
+      // engines — BiDi says 'warn', CDP says 'warning'.
+      type: e.method === 'warn' ? 'warning' : (e.method || e.level),
+      timestamp: new Date().toISOString(),
+      args: Array.isArray(e.args) && e.args.length
+        ? e.args.map((a) => a.value ?? a.type)
+        : [e.text],
+    });
+  });
+
+  bidi.on('network.beforeRequestSent', (e) => {
+    pendingRequests.set(e.request.request, {
+      url: e.request.url,
+      method: e.request.method,
+      timestamp: new Date().toISOString(),
+    });
+  });
+
+  bidi.on('network.responseCompleted', (e) => {
+    const req = pendingRequests.get(e.request.request);
+    if (req) {
+      networkLogs.push({
+        ...req,
+        status: e.response.status,
+        statusText: e.response.statusText,
+        mimeType: e.response.mimeType,
+      });
+      pendingRequests.delete(e.request.request);
+    }
+  });
+
+  bidi.on('network.fetchError', (e) => {
+    const req = pendingRequests.get(e.request.request);
+    if (req) {
+      networkLogs.push({ ...req, status: 0, error: e.errorText });
+      pendingRequests.delete(e.request.request);
+    }
+  });
+}
+
 /**
  * Spawn a detached child process that runs the daemon.
  * Parent polls for session.json, then exits.
@@ -139,10 +207,10 @@ export async function runDaemon(opts, outputDir, initialUrl) {
     incognito: opts.incognito || opts.cookies === false,
   });
 
-  // Console + network log capture is CDP-specific (page.cdp). The Firefox/BiDi
-  // engine exposes page.bidi instead, so these captures are skipped there —
-  // console-logs / network-log commands return empty for a Firefox session.
-  // (BiDi log.entryAdded / network.* events could back these later.)
+  // Console + network log capture. CDP uses Runtime/Network events off
+  // page.cdp; the Firefox/BiDi engine (page.bidi) captures the same shape over
+  // log.entryAdded / network.* events (Phase 2 — attachBiDiCapture). Either
+  // way console-logs / network-log / wait-idle behave the same for both.
   const consoleLogs = [];
   const networkLogs = [];
   const pendingRequests = new Map();
@@ -190,6 +258,8 @@ export async function runDaemon(opts, outputDir, initialUrl) {
         pendingRequests.delete(params.requestId);
       }
     });
+  } else if (page.bidi) {
+    await attachBiDiCapture(page.bidi, { consoleLogs, networkLogs, pendingRequests });
   }
 
   // Navigate to initial URL if provided

package/src/firefox-page.js

@@ -21,6 +21,8 @@ import { axSnapshotExpression, REF_ATTR } from './ax-snapshot.js';
 import { EXTRACT_EXPRESSION, finalizeReadable } from './readable.js';
 import { scopedCookiesForUrl } from './auth.js';
 import { assertNavigable, assertUploadAllowed } from './url-guard.js';
+import { dismissConsentFirefox } from './consent-firefox.js';
+import { waitForNetworkIdleBiDi } from './network-idle.js';
 
 /** BiDi/WebDriver normalized key values for named keys (U+E000 block). */
 const BIDI_KEYS = {
@@ -38,6 +40,7 @@ const BIDI_KEYS = {
  * @param {{allowLocalUrls?: boolean, blockPrivateNetwork?: boolean}} [opts.urlGuard] - Navigation safety policy, applied on every goto().
  * @param {string} [opts.uploadDir] - When set, upload() rejects files outside this dir.
  * @param {boolean} [opts.incognito=false] - Clean session: injectCookies() is a no-op.
+ * @param {boolean} [opts.consent=true] - Auto-dismiss cookie consent dialogs after goto().
  * @returns {Promise<object>} page object
  */
 export async function createFirefoxPage(bidi, opts = {}) {
@@ -45,6 +48,7 @@ export async function createFirefoxPage(bidi, opts = {}) {
   const urlGuard = opts.urlGuard || {};
   const uploadDir = opts.uploadDir || null;
   const incognito = !!opts.incognito;
+  const consent = opts.consent !== false;
   // The active browsing context. Starts at the initial tab; switchTab() points
   // it at another top-level context, so it's mutable and read via a getter.
   const { contexts } = await bidi.send('browsingContext.getTree', {});
@@ -71,6 +75,53 @@ export async function createFirefoxPage(bidi, opts = {}) {
     return flat;
   }
 
+  /**
+   * Build the spliced AX tree for the active tab (main frame + child frames)
+   * and (re)populate refContexts so a subsequent click routes to the right
+   * frame. Returns the top context's root node, or null if it couldn't be
+   * snapshotted. Shared by snapshot() and the consent auto-dismiss so the
+   * iframe-splice logic lives in one place.
+   */
+  async function buildTree() {
+    const contextIds = await allContexts();
+    refContexts = new Map();
+
+    // Snapshot each context, assigning refs from a shared running counter so
+    // they're globally unique (matching CDP's flat integer refs).
+    let base = 0;
+    const treesByContext = new Map();
+    for (const ctx of contextIds) {
+      let raw;
+      try {
+        raw = await bidi.evaluate(ctx, axSnapshotExpression(base), false);
+      } catch { continue; } // frame navigated mid-snapshot — skip it
+      const { tree, count } = JSON.parse(raw);
+      for (let r = base + 1; r <= base + count; r++) refContexts.set(String(r), ctx);
+      base += count;
+      treesByContext.set(ctx, tree);
+    }
+
+    // Splice each child frame's tree under an <iframe> (role 'Iframe')
+    // placeholder in its parent, matched by document order — BiDi getTree
+    // lists children in frame order, and the AX walk emits Iframe nodes in
+    // the same order.
+    const iframeNodes = (tree) => {
+      const out = [];
+      (function walk(n) { if (n.role === 'Iframe') out.push(n); for (const c of n.children) walk(c); })(tree);
+      return out;
+    };
+    for (let i = 1; i < contextIds.length; i++) {
+      const childTree = treesByContext.get(contextIds[i]);
+      if (!childTree) continue;
+      // Attach to the next unfilled Iframe placeholder in the top tree.
+      const holders = iframeNodes(treesByContext.get(topContext) || { role: '', children: [] });
+      const holder = holders[i - 1];
+      if (holder) holder.children = [childTree];
+    }
+
+    return treesByContext.get(topContext) || null;
+  }
+
   /** Resolve a ref to a BiDi element sharedId in its owning context. */
   async function resolveRef(ref) {
     const context = refContexts.get(String(ref));
@@ -119,6 +170,51 @@ export async function createFirefoxPage(bidi, opts = {}) {
     return Promise.race([p, t]).finally(() => clearTimeout(timer));
   }
 
+  // JS dialog handling (alert/confirm/prompt/beforeunload), parity with the
+  // CDP path in index.js. The BiDi session is created with
+  // unhandledPromptBehavior:'ignore' (see bidi.js) so prompts stay open until
+  // we respond; setupDialogs() must run before the first navigation or an
+  // 'ignore' prompt would hang the page. Default: accept everything except
+  // beforeunload (dismiss = stay), mirroring the CDP default. A caller can
+  // override per-dialog via page.onDialog(handler).
+  const dialogLog = [];
+  let onDialogHandler = null;
+  async function setupDialogs() {
+    await bidi.subscribe(['browsingContext.userPromptOpened']);
+    bidi.on('browsingContext.userPromptOpened', async (e) => {
+      dialogLog.push({
+        type: e.type,
+        message: e.message || '',
+        timestamp: new Date().toISOString(),
+      });
+      let accept = e.type !== 'beforeunload';
+      let userText = e.defaultValue || '';
+      if (onDialogHandler) {
+        try {
+          const decision = await onDialogHandler({
+            type: e.type,
+            message: e.message || '',
+            defaultPrompt: e.defaultValue || '',
+          });
+          if (decision && typeof decision === 'object') {
+            if (typeof decision.accept === 'boolean') accept = decision.accept;
+            if (typeof decision.promptText === 'string') userText = decision.promptText;
+          }
+        } catch {
+          // Handler threw — fall back to defaults so the prompt is still
+          // answered and the page doesn't hang on an 'ignore' dialog.
+        }
+      }
+      try {
+        await bidi.send('browsingContext.handleUserPrompt', {
+          context: e.context, accept, userText,
+        });
+      } catch {
+        // Prompt already gone (closed by page JS / navigation). Nothing to do.
+      }
+    });
+  }
+
   const page = {
     /** The BiDi escape hatch, analogous to connect()'s page.cdp. */
     get bidi() { return bidi; },
@@ -134,46 +230,19 @@ export async function createFirefoxPage(bidi, opts = {}) {
         timeout, `goto(${url})`);
       // Brief settle for dynamic/SPA content, matching the CDP path.
       await new Promise((r) => setTimeout(r, 500));
-    },
-
-    async snapshot(pruneOpts) {
-      const contextIds = await allContexts();
-      refContexts = new Map();
-
-      // Snapshot each context, assigning refs from a shared running counter so
-      // they're globally unique (matching CDP's flat integer refs).
-      let base = 0;
-      const treesByContext = new Map();
-      for (const ctx of contextIds) {
-        let raw;
+      // Auto-dismiss cookie consent, mirroring the CDP path (index.js runs
+      // dismissConsent right after navigate). Best-effort: a failure here must
+      // never fail the navigation.
+      if (consent) {
         try {
-          raw = await bidi.evaluate(ctx, axSnapshotExpression(base), false);
-        } catch { continue; } // frame navigated mid-snapshot — skip it
-        const { tree, count } = JSON.parse(raw);
-        for (let r = base + 1; r <= base + count; r++) refContexts.set(String(r), ctx);
-        base += count;
-        treesByContext.set(ctx, tree);
-      }
-
-      // Splice each child frame's tree under an <iframe> (role 'Iframe')
-      // placeholder in its parent, matched by document order — BiDi getTree
-      // lists children in frame order, and the AX walk emits Iframe nodes in
-      // the same order.
-      const iframeNodes = (tree) => {
-        const out = [];
-        (function walk(n) { if (n.role === 'Iframe') out.push(n); for (const c of n.children) walk(c); })(tree);
-        return out;
-      };
-      for (let i = 1; i < contextIds.length; i++) {
-        const childTree = treesByContext.get(contextIds[i]);
-        if (!childTree) continue;
-        // Attach to the next unfilled Iframe placeholder in the top tree.
-        const holders = iframeNodes(treesByContext.get(topContext) || { role: '', children: [] });
-        const holder = holders[i - 1];
-        if (holder) holder.children = [childTree];
+          const root = await buildTree();
+          if (root) await dismissConsentFirefox(root, (ref) => pointerClick(ref));
+        } catch { /* consent dismissal is best-effort */ }
       }
+    },
 
-      const root = treesByContext.get(topContext);
+    async snapshot(pruneOpts) {
+      const root = await buildTree();
       if (!root) return '';
 
       const pageUrl = await bidi.evaluate(topContext, 'location.href', false).catch(() => '');
@@ -379,23 +448,41 @@ export async function createFirefoxPage(bidi, opts = {}) {
       throw new Error(`waitFor timed out after ${timeout}ms`);
     },
 
+    /**
+     * Wait until the network has been idle for `idle` ms, over BiDi
+     * network.* events. Parity with the CDP page.waitForNetworkIdle (Phase 2).
+     */
+    async waitForNetworkIdle(idleOpts = {}) {
+      return waitForNetworkIdleBiDi(bidi, idleOpts);
+    },
+
     // --- CDP-only surfaces, stubbed for daemon parity ---------------------
     // The daemon (src/daemon.js) dispatches these unconditionally. On the
-    // Firefox/BiDi engine download tracking and dialog capture aren't wired,
-    // so the two logs are genuinely empty; the three actions are CDP-only and
-    // fail with a clear, intentional message instead of an incidental
-    // TypeError. Documented as a known gap in CHANGELOG (Firefox engine).
+    // Firefox/BiDi engine download tracking isn't wired (Phase 4), so downloads
+    // is genuinely empty; saveState/waitForNavigation are CDP-only and fail with
+    // a clear, intentional message instead of an incidental TypeError.
+    // (dialogLog + onDialog ARE wired — Phase 3, see setupDialogs above.)
+    // Documented as a known gap in CHANGELOG.
     get downloads() { return []; },
-    get dialogLog() { return []; },
+
+    dialogLog,
+
+    /**
+     * Install a custom JS dialog handler, mirroring connect()'s page.onDialog.
+     * Called with `{ type, message, defaultPrompt }`; may return (sync or async)
+     * `{ accept: bool, promptText: string }` to override the auto-accept
+     * default. Pass null to restore default behavior.
+     */
+    onDialog(handler) {
+      onDialogHandler = handler;
+    },
+
     async saveState() {
       throw new Error('saveState() is not supported on the Firefox/BiDi engine (CDP-only)');
     },
     async waitForNavigation() {
       throw new Error('waitForNavigation() is not supported on the Firefox/BiDi engine (CDP-only)');
     },
-    async waitForNetworkIdle() {
-      throw new Error('waitForNetworkIdle() is not supported on the Firefox/BiDi engine (CDP-only)');
-    },
 
     async close() {
       try { await bidi.send('browsingContext.close', { context: topContext }); } catch {}
@@ -412,5 +499,9 @@ export async function createFirefoxPage(bidi, opts = {}) {
     await new Promise((r) => setTimeout(r, 500));
   }
 
+  // Wire the dialog handler before returning — must precede any navigation so
+  // an 'ignore' prompt (see bidi.js capability) is never left hanging.
+  await setupDialogs();
+
   return page;
 }

package/src/index.js

@@ -19,7 +19,9 @@ import { prune as pruneTree } from './prune.js';
 import { click as cdpClick, type as cdpType, scroll as cdpScroll, press as cdpPress, hover as cdpHover, select as cdpSelect, drag as cdpDrag, upload as cdpUpload } from './interact.js';
 import { dismissConsent } from './consent.js';
 import { applyStealth } from './stealth.js';
-import { DEFAULT_BLOCKLIST } from './blocklist.js';
+import { applyFirefoxStealth } from './stealth-firefox.js';
+import { applyFirefoxBlocklist } from './blocklist-firefox.js';
+import { resolveBlocklistPatterns } from './blocklist.js';
 import { waitForNetworkIdle } from './network-idle.js';
 import { readable as extractReadable } from './readable.js';
 import { assertNavigable, assertUploadAllowed } from './url-guard.js';
@@ -746,12 +748,20 @@ async function suppressPermissions(cdp) {
  * ref model, and AX-tree source all differ (see firefox-page.js). close() is
  * wrapped to also reap the Firefox process + temp profile.
  *
- * Chromium-only options NOT applied on this path: `consent` (auto-dismiss),
- * `blockAds`/`blockUrls`, stealth patches, and `hybrid` mode. `saveState`,
- * `waitForNavigation`, `waitForNetworkIdle`, and download/dialog capture are
- * CDP-only too (the page object stubs them — see firefox-page.js). The
- * navigation guard (`allowLocalUrls`/`blockPrivateNetwork`), `uploadDir`
- * sandbox, `incognito`, `proxy`, `viewport`, and `pruneMode` DO apply.
+ * Chromium-only options NOT applied on this path: `hybrid` mode. `saveState`,
+ * `waitForNavigation`, and download capture are CDP-only too (the page object
+ * stubs them — see firefox-page.js). `blockAds`/`blockUrls` and JS dialog
+ * handling (`dialogLog`/`onDialog`) DO apply as of Phase 3 (ad-block via a
+ * catch-all `network.addIntercept` + in-process glob match; dialogs via
+ * `browsingContext.userPromptOpened` → `handleUserPrompt`).
+ * `waitForNetworkIdle` and daemon console/network capture DO apply as of Phase
+ * 2 (over BiDi `network.*` and `log.entryAdded` events). `consent`
+ * (auto-dismiss) and
+ * stealth patches DO apply here as of v0.16.0 (stealth headless-only, via BiDi
+ * preload script — see stealth-firefox.js / consent-firefox.js), alongside the
+ * navigation guard
+ * (`allowLocalUrls`/`blockPrivateNetwork`), `uploadDir` sandbox, `incognito`,
+ * `proxy`, `viewport`, and `pruneMode`.
  * @param {object} opts - connect() options ({ mode, proxy, binary, viewport, pruneMode, urlGuard, uploadDir, incognito })
  * @returns {Promise<object>} Firefox page object
  */
@@ -763,11 +773,26 @@ async function connectFirefox(opts) {
     viewport: opts.viewport,
   });
   const bidi = await createBiDi(browser.wsUrl);
+  // Stealth patches (headless only, mirroring the CDP path's `mode !== 'headed'`
+  // gate). Registered before the first navigation via script.addPreloadScript.
+  // Firefox needs a much smaller script than Chromium — see stealth-firefox.js.
+  if (opts.mode !== 'headed') {
+    await applyFirefoxStealth(bidi);
+  }
+  // Ad/tracker blocking (parity with the CDP applyBlocklist). Firefox is always
+  // a launched, throwaway profile (never attach mode), so the default is on —
+  // unlike the CDP path, which defaults off in attach mode. Must run before the
+  // first navigation so the catch-all intercept is live when the page loads.
+  await applyFirefoxBlocklist(bidi, {
+    blockAds: opts.blockAds !== undefined ? opts.blockAds : true,
+    blockUrls: opts.blockUrls,
+  });
   const page = await createFirefoxPage(bidi, {
     pruneMode: opts.pruneMode,
     urlGuard: { allowLocalUrls: opts.allowLocalUrls, blockPrivateNetwork: opts.blockPrivateNetwork },
     uploadDir: opts.uploadDir || null,
     incognito: !!opts.incognito,
+    consent: opts.consent,
   });
   const closePage = page.close.bind(page);
   page.close = async () => {
@@ -898,10 +923,7 @@ let blocklistWarned = false;
  * API surface.
  */
 export async function applyBlocklist(session, pageOpts) {
-  if (pageOpts.blockAds === false && !pageOpts.blockUrls) return;
-  const patterns = pageOpts.blockAds === false
-    ? (pageOpts.blockUrls || [])
-    : [...DEFAULT_BLOCKLIST, ...(pageOpts.blockUrls || [])];
+  const patterns = resolveBlocklistPatterns(pageOpts);
   if (!patterns.length) return;
   try {
     await session.send('Network.setBlockedURLs', { urls: patterns });