@evan_zhong/browser-attach 0.21.0 → 0.22.1

package/extension/evaluate.js

@@ -1,133 +1,133 @@
-// Deliberately a page expression API, not a raw CDP transport.
-const CAPTURE_CHARS = 1000000, CAPTURE_NODES = 50000;
-async function evaluatePage(cdp, tabId, args) {
-  const timeout = args.timeout_ms ?? 10000, maxChars = args.max_chars ?? 20000;
-  if (typeof args.expression !== 'string' || !args.expression.trim() || args.expression.length > 100000)
-    throw new Error('expression must contain 1..100000 characters of JavaScript');
-  if (!Number.isInteger(timeout) || timeout < 100 || timeout > 30000) throw new Error('timeout_ms must be 100..30000');
-  if (!Number.isInteger(maxChars) || maxChars < 1 || maxChars > 100000) throw new Error('max_chars must be 1..100000');
-  let timer;
-  try {
-    const response = await Promise.race([
-      cdp(tabId, 'Runtime.evaluate', {
-        expression: `(async () => { let result = await (\n${args.expression}\n); if (typeof result === "function") result = await result(); return ${args.result_type === 'element' ? 'result' : `(${serializeEvaluation.toString()})(result, ${CAPTURE_CHARS}, ${CAPTURE_NODES})`}; })()`,
-        ...(args.result_type === 'element' ? { objectGroup: 'browser-attach-evaluation' } : {}), ...(args.context_id != null ? { contextId: args.context_id } : {}), awaitPromise: true, returnByValue: args.result_type !== 'element', userGesture: false, timeout,
-      }),
-      new Promise((resolve, reject) => { timer = setTimeout(() => reject(new Error(
-        'JavaScript evaluation timed out. It may still run or have changed the page; observe before continuing. Do not replay automatically.'
-      )), timeout); }),
-    ]);
-    if (response.exceptionDetails) throw new Error(response.exceptionDetails.exception?.description || response.exceptionDetails.text);
-    if (args.result_type === 'element') {
-      if (response.result?.subtype !== 'node' || !response.result.objectId) throw new Error('Element result must be one connected DOM element, not JSON/array/null');
-      return { element: response.result };
-    }
-    if (!response.result?.value || typeof response.result.value.truncated !== 'boolean') throw new Error('Invalid evaluation result');
-    return { ...response.result.value, scope: args.frame || args.frame_id ? 'frame' : 'main_frame', ...(args.evaluation_frame ? { frame_id: args.evaluation_frame } : {}), observe_again: true };
-  } catch (error) {
-    throw new Error(`Evaluation failed; page effects may already have occurred. ${String(error.message).slice(0, 12000)}`);
-  } finally { clearTimeout(timer); }
-}
-
-// Runs in the page. Bound traversal before transferring the result across CDP.
-// Preserve ordinary JSON; explicitly mark values that JSON cannot represent.
-export function serializeEvaluation(value, maxChars, maxNodes = 1000) {
-  const seen = new WeakSet();
-  let nodes = 0, chars = 0, truncated = false;
-  const mark = type => ({ $type: type });
-  function visit(item, depth) {
-    if (++nodes > maxNodes || depth > 8 || chars > maxChars) { truncated = true; return mark('truncated'); }
-    if (item === null || typeof item === 'boolean') return item;
-    if (typeof item === 'number') return Number.isFinite(item) && !Object.is(item, -0) ? item : { $type: 'number', value: String(Object.is(item, -0) ? '-0' : item) };
-    if (typeof item === 'string') {
-      const text = item.slice(0, Math.max(0, maxChars - chars));
-      chars += text.length;
-      if (text.length !== item.length) truncated = true;
-      return text;
-    }
-    if (typeof item === 'bigint') return { $type: 'bigint', value: visit(String(item), depth + 1) };
-    if (typeof item !== 'object') return mark(typeof item);
-    if (seen.has(item)) return mark('circular_or_repeated');
-    seen.add(item);
-    if (item instanceof Date) return { $type: 'date', value: String(item) };
-    if (item instanceof Error) return { $type: 'error', name: visit(item.name, depth + 1), message: visit(item.message, depth + 1) };
-    if (Array.isArray(item)) {
-      const output = [];
-      // Do not copy a sparse index into an array with an unbounded length.
-      for (let i = 0; i < item.length && nodes < maxNodes && chars < maxChars && depth < 8; i++) {
-        const property = Object.getOwnPropertyDescriptor(item, String(i));
-        output.push(!property ? visit(undefined, depth + 1) : 'value' in property ? visit(property.value, depth + 1) : (nodes++, mark('accessor')));
-      }
-      if (output.length < item.length) truncated = true;
-      return output;
-    }
-    const output = Object.create(null);
-    for (const key in item) {
-      if (!Object.prototype.hasOwnProperty.call(item, key)) continue;
-      if (nodes >= maxNodes || chars + key.length > maxChars || depth >= 8) { truncated = true; break; }
-      chars += key.length;
-      const property = Object.getOwnPropertyDescriptor(item, key);
-      const result = property && 'value' in property ? visit(property.value, depth + 1) : (nodes++, mark('accessor'));
-      Object.defineProperty(output, key, { value: result, enumerable: true, configurable: true, writable: true });
-    }
-    return output;
-  }
-  const result = visit(value, 0);
-  const json = JSON.stringify(result);
-  // Escaped strings and property names also count toward the transfer budget.
-  // Never emit half a serialized JSON document. Keep the payload structured,
-  // and state explicitly when the capture budget lost information.
-  if (json.length > maxChars) return { value: { $type: 'truncated', reason: 'serialized_size', required_chars: json.length }, truncated: true };
-  return { value: result, truncated };
-}
-
-// One bounded immutable result per claimed tab. Continuations never execute JS.
-export function createEvaluations(cdp) {
-  const results = new Map();
-  async function read(tabId, args) {
-    const max = args.max_chars ?? 20000;
-    if (!Number.isInteger(max) || max < 1 || max > 100000) throw new Error('max_chars must be 1..100000');
-    let state;
-    if (args.cursor != null) {
-      state = results.get(tabId);
-      if (!state || state.cursor !== args.cursor) throw new Error('Evaluation cursor is stale or unknown; results expire on navigation, release or a new evaluation.');
-      if (args.expression != null) throw new Error('Provide cursor or expression, never both');
-    } else {
-      // Navigation/detach may arrive while the CDP promise is pending. A late
-      // reply must not resurrect cached page data after cleanup.
-      const pending = { frameId: args.evaluation_frame };
-      results.set(tabId, pending);
-      let result;
-      try { result = await evaluatePage(cdp, args.target || tabId, args); }
-      catch (error) { if (results.get(tabId) === pending) results.delete(tabId); throw error; }
-      if (results.get(tabId) !== pending) throw new Error('Document or claim changed during evaluation; effects may already have occurred. Result was discarded. Observe before continuing; do not replay automatically.');
-      if (result.element) { results.delete(tabId); return result; }
-      const kind = Array.isArray(result.value) ? 'array' : typeof result.value === 'string' ? 'string' :
-        result.value && typeof result.value === 'object' ? 'object' : 'scalar';
-      state = Object.assign(pending, { result, kind, offset: 0, token: crypto.randomUUID(), cursor: null,
-        items: kind === 'object' ? Object.entries(result.value) : result.value });
-    }
-    const { kind, items, offset, result } = state;
-    const length = kind === 'scalar' ? 1 : items.length;
-    const make = (end, start = offset) => kind === 'string' || kind === 'array' ? items.slice(start, end) :
-      kind === 'object' ? Object.fromEntries(items.slice(start, end)) : items;
-    let low = offset, high = length;
-    while (low < high) {
-      const mid = Math.ceil((low + high) / 2);
-      if (JSON.stringify(make(mid)).length <= max) low = mid; else high = mid - 1;
-    }
-    if ((length > offset && low === offset) || JSON.stringify(make(low)).length > max) {
-      state.cursor ??= `${state.token}@${offset}`;
-      return { scope: result.scope, ...(result.frame_id ? { frame_id: result.frame_id } : {}), result_kind: kind, budget_too_small: true, next_cursor: state.cursor,
-        required_chars: JSON.stringify(make(Math.min(length, offset + 1))).length,
-        note: 'Increase max_chars (allowed 1..100000) and continue with this cursor. Select smaller fields if an individual item exceeds 100000 characters.' };
-    }
-    state.offset = low;
-    state.cursor = low < length ? `${state.token}@${low}` : null;
-    const nextRequired = low < length ? JSON.stringify(make(low + 1, low)).length : null;
-    return { ...result, value: make(low), result_kind: kind, has_more: low < length,
-      ...(nextRequired > max ? { next_item: { ...(kind === 'object' ? { key: items[low][0] } : { index: low }), required_chars: nextRequired, exceeds_max_chars: nextRequired > 100000 } } : {}),
-      next_cursor: state.cursor, capture_truncated: result.truncated, truncated: result.truncated || low < length };
-  }
-  return { read, forgetFrame(tabId, frameId) { if (results.get(tabId)?.frameId === frameId) results.delete(tabId); }, forget: tabId => results.delete(tabId) };
-}
+// Deliberately a page expression API, not a raw CDP transport.
+const CAPTURE_CHARS = 1000000, CAPTURE_NODES = 50000;
+async function evaluatePage(cdp, tabId, args) {
+  const timeout = args.timeout_ms ?? 10000, maxChars = args.max_chars ?? 20000;
+  if (typeof args.expression !== 'string' || !args.expression.trim() || args.expression.length > 100000)
+    throw new Error('expression must contain 1..100000 characters of JavaScript');
+  if (!Number.isInteger(timeout) || timeout < 100 || timeout > 30000) throw new Error('timeout_ms must be 100..30000');
+  if (!Number.isInteger(maxChars) || maxChars < 1 || maxChars > 100000) throw new Error('max_chars must be 1..100000');
+  let timer;
+  try {
+    const response = await Promise.race([
+      cdp(tabId, 'Runtime.evaluate', {
+        expression: `(async () => { let result = await (\n${args.expression}\n); if (typeof result === "function") result = await result(); return ${args.result_type === 'element' ? 'result' : `(${serializeEvaluation.toString()})(result, ${CAPTURE_CHARS}, ${CAPTURE_NODES})`}; })()`,
+        ...(args.result_type === 'element' ? { objectGroup: 'browser-attach-evaluation' } : {}), ...(args.context_id != null ? { contextId: args.context_id } : {}), awaitPromise: true, returnByValue: args.result_type !== 'element', userGesture: false, timeout,
+      }),
+      new Promise((resolve, reject) => { timer = setTimeout(() => reject(Object.assign(new Error(
+        'JavaScript evaluation timed out. It may still run or have changed the page; observe before continuing. Do not replay automatically.'
+      ), { outcome_unknown: true })), timeout); }),
+    ]);
+    if (response.exceptionDetails) throw new Error(response.exceptionDetails.exception?.description || response.exceptionDetails.text);
+    if (args.result_type === 'element') {
+      if (response.result?.subtype !== 'node' || !response.result.objectId) throw new Error('Element result must be one connected DOM element, not JSON/array/null');
+      return { element: response.result };
+    }
+    if (!response.result?.value || typeof response.result.value.truncated !== 'boolean') throw new Error('Invalid evaluation result');
+    return { ...response.result.value, scope: args.frame || args.frame_id ? 'frame' : 'main_frame', ...(args.evaluation_frame ? { frame_id: args.evaluation_frame } : {}), observe_again: true };
+  } catch (error) {
+    throw Object.assign(new Error(`Evaluation failed; page effects may already have occurred. ${String(error.message).slice(0, 12000)}`), { outcome_unknown: true });
+  } finally { clearTimeout(timer); }
+}
+
+// Runs in the page. Bound traversal before transferring the result across CDP.
+// Preserve ordinary JSON; explicitly mark values that JSON cannot represent.
+export function serializeEvaluation(value, maxChars, maxNodes = 1000) {
+  const seen = new WeakSet();
+  let nodes = 0, chars = 0, truncated = false;
+  const mark = type => ({ $type: type });
+  function visit(item, depth) {
+    if (++nodes > maxNodes || depth > 8 || chars > maxChars) { truncated = true; return mark('truncated'); }
+    if (item === null || typeof item === 'boolean') return item;
+    if (typeof item === 'number') return Number.isFinite(item) && !Object.is(item, -0) ? item : { $type: 'number', value: String(Object.is(item, -0) ? '-0' : item) };
+    if (typeof item === 'string') {
+      const text = item.slice(0, Math.max(0, maxChars - chars));
+      chars += text.length;
+      if (text.length !== item.length) truncated = true;
+      return text;
+    }
+    if (typeof item === 'bigint') return { $type: 'bigint', value: visit(String(item), depth + 1) };
+    if (typeof item !== 'object') return mark(typeof item);
+    if (seen.has(item)) return mark('circular_or_repeated');
+    seen.add(item);
+    if (item instanceof Date) return { $type: 'date', value: String(item) };
+    if (item instanceof Error) return { $type: 'error', name: visit(item.name, depth + 1), message: visit(item.message, depth + 1) };
+    if (Array.isArray(item)) {
+      const output = [];
+      // Do not copy a sparse index into an array with an unbounded length.
+      for (let i = 0; i < item.length && nodes < maxNodes && chars < maxChars && depth < 8; i++) {
+        const property = Object.getOwnPropertyDescriptor(item, String(i));
+        output.push(!property ? visit(undefined, depth + 1) : 'value' in property ? visit(property.value, depth + 1) : (nodes++, mark('accessor')));
+      }
+      if (output.length < item.length) truncated = true;
+      return output;
+    }
+    const output = Object.create(null);
+    for (const key in item) {
+      if (!Object.prototype.hasOwnProperty.call(item, key)) continue;
+      if (nodes >= maxNodes || chars + key.length > maxChars || depth >= 8) { truncated = true; break; }
+      chars += key.length;
+      const property = Object.getOwnPropertyDescriptor(item, key);
+      const result = property && 'value' in property ? visit(property.value, depth + 1) : (nodes++, mark('accessor'));
+      Object.defineProperty(output, key, { value: result, enumerable: true, configurable: true, writable: true });
+    }
+    return output;
+  }
+  const result = visit(value, 0);
+  const json = JSON.stringify(result);
+  // Escaped strings and property names also count toward the transfer budget.
+  // Never emit half a serialized JSON document. Keep the payload structured,
+  // and state explicitly when the capture budget lost information.
+  if (json.length > maxChars) return { value: { $type: 'truncated', reason: 'serialized_size', required_chars: json.length }, truncated: true };
+  return { value: result, truncated };
+}
+
+// One bounded immutable result per claimed tab. Continuations never execute JS.
+export function createEvaluations(cdp) {
+  const results = new Map();
+  async function read(tabId, args) {
+    const max = args.max_chars ?? 20000;
+    if (!Number.isInteger(max) || max < 1 || max > 100000) throw new Error('max_chars must be 1..100000');
+    let state;
+    if (args.cursor != null) {
+      state = results.get(tabId);
+      if (!state || state.cursor !== args.cursor) throw new Error('Evaluation cursor is stale or unknown; results expire on navigation, release or a new evaluation.');
+      if (args.expression != null) throw new Error('Provide cursor or expression, never both');
+    } else {
+      // Navigation/detach may arrive while the CDP promise is pending. A late
+      // reply must not resurrect cached page data after cleanup.
+      const pending = { frameId: args.evaluation_frame };
+      results.set(tabId, pending);
+      let result;
+      try { result = await evaluatePage(cdp, args.target || tabId, args); }
+      catch (error) { if (results.get(tabId) === pending) results.delete(tabId); throw error; }
+      if (results.get(tabId) !== pending) throw Object.assign(new Error('Document or claim changed during evaluation; effects may already have occurred. Result was discarded. Observe before continuing; do not replay automatically.'), { outcome_unknown: true });
+      if (result.element) { results.delete(tabId); return result; }
+      const kind = Array.isArray(result.value) ? 'array' : typeof result.value === 'string' ? 'string' :
+        result.value && typeof result.value === 'object' ? 'object' : 'scalar';
+      state = Object.assign(pending, { result, kind, offset: 0, token: crypto.randomUUID(), cursor: null,
+        items: kind === 'object' ? Object.entries(result.value) : result.value });
+    }
+    const { kind, items, offset, result } = state;
+    const length = kind === 'scalar' ? 1 : items.length;
+    const make = (end, start = offset) => kind === 'string' || kind === 'array' ? items.slice(start, end) :
+      kind === 'object' ? Object.fromEntries(items.slice(start, end)) : items;
+    let low = offset, high = length;
+    while (low < high) {
+      const mid = Math.ceil((low + high) / 2);
+      if (JSON.stringify(make(mid)).length <= max) low = mid; else high = mid - 1;
+    }
+    if ((length > offset && low === offset) || JSON.stringify(make(low)).length > max) {
+      state.cursor ??= `${state.token}@${offset}`;
+      return { scope: result.scope, ...(result.frame_id ? { frame_id: result.frame_id } : {}), result_kind: kind, budget_too_small: true, next_cursor: state.cursor,
+        required_chars: JSON.stringify(make(Math.min(length, offset + 1))).length,
+        note: 'Increase max_chars (allowed 1..100000) and continue with this cursor. Select smaller fields if an individual item exceeds 100000 characters.' };
+    }
+    state.offset = low;
+    state.cursor = low < length ? `${state.token}@${low}` : null;
+    const nextRequired = low < length ? JSON.stringify(make(low + 1, low)).length : null;
+    return { ...result, value: make(low), result_kind: kind, has_more: low < length,
+      ...(nextRequired > max ? { next_item: { ...(kind === 'object' ? { key: items[low][0] } : { index: low }), required_chars: nextRequired, exceeds_max_chars: nextRequired > 100000 } } : {}),
+      next_cursor: state.cursor, capture_truncated: result.truncated, truncated: result.truncated || low < length };
+  }
+  return { read, forgetFrame(tabId, frameId) { if (results.get(tabId)?.frameId === frameId) results.delete(tabId); }, forget: tabId => results.delete(tabId) };
+}

package/extension/fetch-page.js

@@ -0,0 +1,131 @@
+import { deadline } from './actionability.js';
+import { boundedRead } from './outcomes.js';
+import { capturePage } from './fetch.js';
+import { waitFor } from './wait.js';
+import { httpUrl } from './page-url.js';
+
+export function createFetchPages(api, cdp, value, navigation, network, sessions, pointer, observations, { queued, attach, currentClaim, forget }) {
+  const temporaryTabs = new Map();
+  async function closeTemporary(tabId) {
+    try { await api.tabs.remove(tabId); }
+    catch (error) {
+      // A closed tab is already clean; otherwise retain ownership for later cleanup.
+      let tab;
+      try { tab = await api.tabs.get(tabId); }
+      catch (lookup) { if (!/No tab with id|Invalid tab ID/i.test(lookup.message)) throw error; }
+      if (tab) throw error;
+    }
+    temporaryTabs.delete(tabId);
+    if (currentClaim(tabId)) forget(tabId);
+  }
+
+  async function fetchPage(owner, args, cap, checkConnection) {
+    const url = httpUrl(args.url), timeout = args.timeout_ms ?? 15000, waitUntil = args.wait_until ?? 'load';
+    const end = Date.now() + timeout, cleanupReserve = Math.min(250, Math.floor(timeout / 10));
+    const budget = deadline(timeout, 'fetch', end - cleanupReserve);
+    const handle = crypto.randomUUID(), temporary = { owner, handle };
+    const creation = api.tabs.create({ url: 'about:blank', active: false }).then(tab => {
+      temporaryTabs.set(tab.id, temporary);
+      return tab;
+    });
+    let tab;
+    try { tab = await budget.run(() => creation); }
+    catch (error) {
+      // A late tabs.create response must not start navigation or leak its tab.
+      creation.then(created => queued(created.id, () => closeTemporary(created.id))).catch(() => {});
+      throw error;
+    }
+    return await queued(tab.id, async () => {
+      let failure;
+      try {
+        checkConnection();
+        await attach(tab.id, owner, { tab_handle: handle }, tab, budget);
+        const claim = currentClaim(tab.id);
+        const checkControl = () => {
+          checkConnection();
+          if (currentClaim(tab.id) !== claim) throw new Error('Tab control ended during fetch; capture discarded');
+        };
+        const metadata = (satisfied, reason, readyState) => ({ wait_until: waitUntil, wait_satisfied: satisfied,
+          degraded: !satisfied, degraded_reason: reason, ready_state: readyState, document_changed: !!temporary.document_changed });
+        const httpFailure = response => {
+          if ((args.format ?? 'text') === 'json') throw new Error(`HTTP ${response.status}: navigation produced an error page without a readable JSON document`);
+          return { url: httpUrl(response.url), contentType: response.contentType, format: args.format ?? 'text', body: '',
+            body_source: response.empty_body ? 'http_response' : 'unavailable', ...(!response.empty_body ? { body_unavailable: true } : {}),
+            capture_truncated: false, status: response.status, ok: response.status >= 200 && response.status < 300,
+            ...metadata(false, 'http_error_response', null), navigation_error: response.error };
+        };
+        checkControl();
+        if (budget.remaining() < 100) throw new Error('Fetch preparation timed out; no navigation was dispatched');
+        const readReserve = Math.min(2000, Math.floor(budget.remaining() / 3));
+        const waitEnd = Date.now() + budget.remaining() - readReserve;
+        const waitBudget = deadline(timeout, 'wait', waitEnd);
+        let satisfied = false, reason = null, waitedDocument;
+        try {
+          const navigationResult = await navigation.navigate(tab.id, url, { wait_until: waitUntil === 'network_idle' ? 'load' : waitUntil,
+            timeout_ms: Math.max(100, waitBudget.remaining()) });
+          waitedDocument = JSON.stringify([navigationResult.document.frameId, navigationResult.document.loaderId]);
+          checkControl();
+          if (waitUntil === 'network_idle') await waitFor(cdp, value, sessions, network, pointer, tab.id, { condition: 'network_idle', budget: waitBudget });
+          satisfied = true;
+        } catch (error) {
+          checkControl();
+          if (error.navigation_error === 'net::ERR_HTTP_RESPONSE_CODE_FAILURE') {
+            const response = network.failedDocument(tab.id, observations.mainFrame(tab.id));
+            if (response) return httpFailure(response);
+            throw error;
+          }
+          if (error.code === 'NAVIGATION_TIMEOUT' || (waitUntil === 'network_idle' && waitBudget.remaining() === 0)) reason = 'wait_timeout';
+          else if (error.navigation_error === 'net::ERR_ABORTED' && temporary.document) reason = 'navigation_interrupted';
+          else throw error;
+        }
+        for (let attempt = 0; attempt < 3; attempt++) {
+          checkControl();
+          const version = observations.version(tab.id);
+          try {
+            const { frameTree } = await budget.run(() => cdp(tab.id, 'Page.getFrameTree'));
+            const response = frameTree.frame.unreachableUrl && network.failedDocument(tab.id, frameTree.frame.id);
+            if (response && response.url === frameTree.frame.unreachableUrl) return httpFailure(response);
+            httpUrl(frameTree.frame.url);
+            const { executionContextId } = await budget.run(() => cdp(tab.id, 'Page.createIsolatedWorld', { frameId: frameTree.frame.id, worldName: 'browser-attach-fetch' }));
+            const result = value(await budget.run(() => cdp(tab.id, 'Runtime.evaluate', { contextId: executionContextId, returnByValue: true, userGesture: false,
+              expression: `(${capturePage.toString()})(${JSON.stringify(args.format ?? 'text')},${cap})` })));
+            checkControl();
+            if (observations.version(tab.id) !== version) throw Object.assign(new Error('Document changed during fetch capture'), { code: 'FETCH_DOCUMENT_CHANGED' });
+            httpUrl(result.url);
+            const status = network.documentStatus(tab.id, frameTree.frame);
+            if (satisfied && waitedDocument !== JSON.stringify([frameTree.frame.id, frameTree.frame.loaderId])) { satisfied = false; reason = 'document_changed'; }
+            return { ...result, status, ok: status == null ? null : status >= 200 && status < 300,
+              ...metadata(satisfied, reason, result.ready_state) };
+          } catch (error) {
+            checkControl();
+            const changing = observations.version(tab.id) !== version || error.code === 'FETCH_DOCUMENT_CHANGED' || /context.*(destroyed|not found)|cannot find context|no frame with given id|inspected target navigated/i.test(error.message);
+            if (!changing || attempt === 2) throw error;
+            await budget.run(() => new Promise(resolve => setTimeout(resolve, 25)));
+          }
+        }
+      } catch (error) { failure = error; throw error; }
+      finally {
+        try { await boundedRead(() => closeTemporary(tab.id), Math.max(1, end - Date.now())); }
+        catch (error) { throw new Error(`${failure ? failure.message + '; ' : ''}Fetch temporary tab ${tab.id} could not be closed: ${error.message}. Cleanup will be retried on disconnect.`); }
+      }
+    });
+  }
+
+
+  function event(source, method, params) {
+    const mainNavigation = !source.sessionId && method === 'Page.frameNavigated' && params.frame && !params.frame.parentId;
+    const temporary = temporaryTabs.get(source.tabId);
+    if (mainNavigation && temporary && params.frame.loaderId) {
+      const document = JSON.stringify([params.frame.id, params.frame.loaderId]);
+      if (!temporary.firstDocument && /^https?:/.test(params.frame.url || '') && !params.frame.unreachableUrl) temporary.firstDocument = document;
+      if (temporary.firstDocument) {
+        temporary.document = document;
+        temporary.document_changed ||= document !== temporary.firstDocument;
+      }
+    }
+  }
+  return { read: fetchPage, close: closeTemporary, event,
+    has: tabId => temporaryTabs.has(tabId), entries: () => temporaryTabs.entries(),
+    removed: tabId => temporaryTabs.delete(tabId),
+  };
+}