pi-browser-harness 0.15.1 → 0.16.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to pi-browser-harness will be documented in this file.
 
+## 0.16.0 — 2026-11-07
+
+### Added
+
+- **`browser_web_search` falls back across search engines.** With no `engine` given it tries Google, then Bing, DuckDuckGo and Brave, until one returns results, so a Google CAPTCHA or markup change no longer breaks search. `details.engine` says which engine answered and `details.fallbacks` lists the ones that failed first. When every engine fails the error is `all_engines_failed` with each engine's reason; when none found anything it stays `no_results`.
+- **`engine` parameter.** Name one engine (`google`, `bing`, `duckduckgo`, `brave`) to search it alone, with no fallback.
+- **Pluggable engines.** Each engine is a self-contained module mounted into a registry (`createEngineRegistry().mount(engine)`) that is injected into `createWebSearchTool`; mount order is the fallback order. Adding an engine is one module and one `mount`.
+
 ## 0.15.1 — 2026-11-07
 
 - Re-release of 0.15.0, whose npm publish failed (the provenance log returned 502, then rejected the retry as a duplicate). No code changes.

package/README.md

@@ -119,7 +119,7 @@ Three things follow from that:
 
 | Tool | Purpose |
 |---|---|
-| `browser_web_search` | Query → ranked `{title, url, snippet, rank}`, by scraping a real Google SERP in your Chrome. No API key. Links only. |
+| `browser_web_search` | Query → ranked `{title, url, snippet, rank}`, by scraping a real search results page in your Chrome. No API key. Links only. Walks the fallback ladder Google → Bing → DuckDuckGo → Brave until one answers, or searches only the `engine` you name. |
 | `browser_read_page` | Reader mode. A `url` (opened and closed in its own tab) or an owned `targetId` → clean article text, boilerplate stripped. |
 
 Both run in isolated tabs and never disturb your current page.
@@ -245,8 +245,14 @@ browser_network_requests({                          // did a request 4xx/5xx?
 ```
 browser_web_search({ query: "chrome devtools protocol overview", limit: 5 })
 browser_read_page({ url: "<the best result's url>" })
+
+// Search one engine only, with no fallback:
+browser_web_search({ query: "chrome devtools protocol overview", engine: "bing" })
 ```
 
+`details.engine` names the engine that answered, and `details.fallbacks` lists any engines that failed
+first (CAPTCHA, no results, markup change, load failure).
+
 Both tools open their own isolated tab, so neither disturbs the tab you are working in.
 
 ### Keyboard modifiers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-browser-harness",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "Browser control extension for pi — navigate, click, type, screenshot, and extract data from real Chrome via CDP",
   "keywords": [
     "pi-package",

package/src/domains/page/serp.page.ts

@@ -1,4 +1,5 @@
-// Page-side code for browser_web_search: pulls the organic result anchors off a Google results page. See fill.page.ts for the rules.
+// Page-side code for browser_web_search: pulls the organic result anchors off a search engine's results page, driven
+// by the engine's selectors. See fill.page.ts for the rules.
 
 export type SerpAnchor = {
   readonly href: string;
@@ -12,29 +13,41 @@ export type SerpExtraction = {
   readonly pageText: string;
 };
 
+export type SerpSelectors = {
+  readonly root: string;
+  readonly heading: string;
+  readonly containers: ReadonlyArray<string>;
+  readonly snippet?: string;
+  readonly cite: string;
+};
+
 // Returns the extraction as JSON text (not an object) so the isolated-tab evaluator can keep its string guard.
-export function extractSerp(pageTextLimit: number): string {
-  const main = document.querySelector<HTMLElement>("#search, #rso, #main") ?? document.body;
-  const headings = Array.from(main.querySelectorAll<HTMLElement>("a h3"));
+export function extractSerp(selectors: SerpSelectors, pageTextLimit: number): string {
+  const main = document.querySelector<HTMLElement>(selectors.root) ?? document.body;
+  const headings = Array.from(main.querySelectorAll<HTMLElement>(selectors.heading));
   const seen = new Set<string>();
   const anchors: SerpAnchor[] = [];
-  for (const h3 of headings) {
-    const a = h3.closest<HTMLAnchorElement>("a[href]");
+  for (const heading of headings) {
+    // The heading is the link (DuckDuckGo), sits inside it (Google, Brave) or wraps it (Bing).
+    const a = heading.closest<HTMLAnchorElement>("a[href]") ?? heading.querySelector<HTMLAnchorElement>("a[href]");
     if (!a) continue;
     const href = a.href;
     if (!href || seen.has(href)) continue;
     seen.add(href);
-    const container: HTMLElement | null =
-      a.closest<HTMLElement>("div.g") ??
-      a.closest<HTMLElement>("div[data-hveid]") ??
-      a.parentElement?.parentElement ??
-      a.parentElement;
-    const containerText = container ? container.innerText : "";
-    const heading = h3.innerText || h3.textContent;
-    const snippet = containerText.replace(heading, "").replace(/\s+/g, " ").trim().slice(0, 500);
-    const citeEl = container ? container.querySelector<HTMLElement>("cite") : null;
+    let container: HTMLElement | null = null;
+    for (const selector of selectors.containers) {
+      container = a.closest<HTMLElement>(selector);
+      if (container) break;
+    }
+    container = container ?? a.parentElement?.parentElement ?? a.parentElement;
+    const title = heading.innerText || heading.textContent || "";
+    const snippetEl =
+      selectors.snippet !== undefined && container ? container.querySelector<HTMLElement>(selectors.snippet) : null;
+    const snippetSource = snippetEl ? snippetEl.innerText : container ? container.innerText.replace(title, "") : "";
+    const snippet = snippetSource.replace(/\s+/g, " ").trim().slice(0, 500);
+    const citeEl = container ? container.querySelector<HTMLElement>(selectors.cite) : null;
     const cite = citeEl ? (citeEl.innerText || citeEl.textContent || "").trim() : "";
-    anchors.push({ href, heading, snippet, cite });
+    anchors.push({ href, heading: title, snippet, cite });
   }
   const pageText = document.body.innerText.slice(0, pageTextLimit);
   const extraction: SerpExtraction = { anchors, pageText };

package/src/domains/search/engines/bing.ts

@@ -0,0 +1,47 @@
+import { externalResult, isWebUrl, type SearchEngine, type SerpAnchor, urlFromCite } from "../serp";
+
+const BING_PROPERTY = /(?:^|\.)bing\.(?:com|net)$/;
+const isExternalResult = externalResult((host) => BING_PROPERTY.test(host));
+
+// Bing wraps organic links as bing.com/ck/a?...&u=a1<base64url(target)>. The "a1" prefix tags the encoding.
+export const decodeBingClick = (href: string): string | undefined => {
+  try {
+    const u = new URL(href);
+    if (!BING_PROPERTY.test(u.hostname.toLowerCase()) || u.pathname !== "/ck/a") return undefined;
+    const encoded = u.searchParams.get("u");
+    if (!encoded?.startsWith("a1")) return undefined;
+    const decoded = Buffer.from(encoded.slice(2), "base64url").toString("utf8");
+    return isWebUrl(decoded) ? decoded : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const resultUrl = (anchor: SerpAnchor): string | undefined => {
+  const target = decodeBingClick(anchor.href) ?? anchor.href;
+  if (isExternalResult(target)) return target;
+  if (anchor.cite !== undefined && anchor.cite.trim() !== "") return urlFromCite(anchor.cite, isExternalResult);
+  return undefined;
+};
+
+export const bing: SearchEngine = {
+  id: "bing",
+  name: "Bing",
+  buildUrl: (query, limit) =>
+    `https://www.bing.com/search?q=${encodeURIComponent(query)}&count=${limit}&setlang=en`,
+  selectors: {
+    root: "#b_results, #b_content",
+    heading: "li.b_algo h2",
+    containers: ["li.b_algo"],
+    snippet: ".b_caption p, p[class*='b_lineclamp'], .b_snippet",
+    cite: "cite",
+  },
+  captchaMarkers: [
+    "one last step",
+    "solve the challenge",
+    "verify you are a human",
+    "unusual traffic",
+    "are you a robot",
+  ],
+  resultUrl,
+};

package/src/domains/search/engines/brave.ts

@@ -0,0 +1,23 @@
+import { externalResult, type SearchEngine, type SerpAnchor } from "../serp";
+
+const BRAVE_PROPERTY = /(?:^|\.)brave\.com$/;
+const isExternalResult = externalResult((host) => BRAVE_PROPERTY.test(host));
+
+// Brave links straight to the target; there is no redirect wrapper to undo.
+const resultUrl = (anchor: SerpAnchor): string | undefined =>
+  isExternalResult(anchor.href) ? anchor.href : undefined;
+
+export const brave: SearchEngine = {
+  id: "brave",
+  name: "Brave Search",
+  buildUrl: (query) => `https://search.brave.com/search?q=${encodeURIComponent(query)}&source=web`,
+  selectors: {
+    root: "#results, main",
+    heading: "[data-type='web'] a .title",
+    containers: ["[data-type='web']"],
+    snippet: ".generic-snippet .content, .snippet-description",
+    cite: "cite",
+  },
+  captchaMarkers: ["captcha", "verify you are human", "unusual activity", "not a robot"],
+  resultUrl,
+};

package/src/domains/search/engines/duckduckgo.ts

@@ -0,0 +1,42 @@
+import { externalResult, type SearchEngine, type SerpAnchor, urlFromCite } from "../serp";
+
+const DDG_PROPERTY = /(?:^|\.)duckduckgo\.com$/;
+const isExternalResult = externalResult((host) => DDG_PROPERTY.test(host));
+
+// Results normally link straight to the target; a duckduckgo.com/l/?uddg=<encoded target> wrapper is undone, and ads
+// (routed through /y.js) are dropped by the own-property filter.
+export const unwrapDuckDuckGo = (href: string): string => {
+  try {
+    const u = new URL(href);
+    if (!DDG_PROPERTY.test(u.hostname.toLowerCase()) || u.pathname !== "/l/") return href;
+    return u.searchParams.get("uddg") ?? href;
+  } catch {
+    return href;
+  }
+};
+
+const resultUrl = (anchor: SerpAnchor): string | undefined => {
+  const target = unwrapDuckDuckGo(anchor.href);
+  if (isExternalResult(target)) return target;
+  if (anchor.cite !== undefined && anchor.cite.trim() !== "") return urlFromCite(anchor.cite, isExternalResult);
+  return undefined;
+};
+
+// The main results page. It renders results with JavaScript after the load event, hence readySelector. (The no-JS
+// html.duckduckgo.com endpoint serves a bot challenge even to a real Chrome, so it is not used.)
+export const duckduckgo: SearchEngine = {
+  id: "duckduckgo",
+  name: "DuckDuckGo",
+  buildUrl: (query) => `https://duckduckgo.com/?q=${encodeURIComponent(query)}&kl=us-en&ia=web`,
+  selectors: {
+    // The page has two mainline containers and the first is empty, so the root is the results list itself.
+    root: ".react-results--main, #react-layout",
+    heading: "article[data-testid='result'] a[data-testid='result-title-a']",
+    containers: ["article[data-testid='result']"],
+    snippet: "[data-result='snippet']",
+    cite: "a[data-testid='result-extras-url-link']",
+  },
+  captchaMarkers: ["bots use duckduckgo too", "complete the following challenge"],
+  readySelector: "article[data-testid='result']",
+  resultUrl,
+};

package/src/domains/search/engines/google.ts

@@ -0,0 +1,95 @@
+import {
+  classifySerpWith,
+  externalResult,
+  parseSerp,
+  type ResolvedTargets,
+  type SearchEngine,
+  type SearchResult,
+  type SerpAnchor,
+  type SerpVerdict,
+  urlFromCite,
+} from "../serp";
+
+const CAPTCHA_MARKERS: ReadonlyArray<string> = [
+  "unusual traffic",
+  "not a robot",
+  "recaptcha",
+  "detected unusual",
+  "systems have detected",
+  "before you continue to google",
+  "our systems have detected unusual traffic",
+];
+
+// Any Google property, on any TLD (google.com, google.co.uk, consent.google.de, googleusercontent.com), is never a
+// result: a sorry or consent page is where a rate-limited /goto redirect lands.
+const GOOGLE_PROPERTY = /(?:^|\.)google(?:usercontent)?\.(?:com?\.[a-z]{2}|[a-z]{2,3})$/;
+
+const isExternalResult = externalResult((host) => GOOGLE_PROPERTY.test(host));
+
+const unwrapRedirect = (href: string): string => {
+  const wrapper = /^(?:https?:\/\/[^/]*google\.[^/]*)?\/url\?/i.exec(href);
+  if (!wrapper) return href;
+  const query = href.slice(href.indexOf("?") + 1);
+  const target = new URLSearchParams(query).get("q");
+  return target ?? href;
+};
+
+// Rebuilds a url from Google's visible breadcrumb cite, the only place the target survives once Google wraps hrefs
+// in /goto.
+export const googleUrlFromCite = (cite: string): string | undefined => urlFromCite(cite, isExternalResult);
+
+// Only a real Google /goto url counts: the daemon fetches these, so a look-alike host, userinfo, a port or http
+// must never qualify. Hosts are google.com or www.google.<tld>, nothing else.
+const GOOGLE_GOTO_HOST = /^(?:www\.)?google\.[a-z]{2,3}(?:\.[a-z]{2})?$/;
+export const isGotoRedirect = (href: string): boolean => {
+  try {
+    const u = new URL(href);
+    return (
+      u.protocol === "https:" &&
+      u.username === "" &&
+      u.password === "" &&
+      u.port === "" &&
+      GOOGLE_GOTO_HOST.test(u.hostname.toLowerCase()) &&
+      u.pathname === "/goto"
+    );
+  } catch {
+    return false;
+  }
+};
+
+// Direct external hrefs win. A /goto wrapper is opaque: the server-resolved redirect target is exact, and the cite is
+// a display breadcrumb that only approximates the path, so it is the fallback when no target was resolved.
+const resultUrl = (anchor: SerpAnchor, resolved: ResolvedTargets): string | undefined => {
+  if (!isGotoRedirect(anchor.href)) {
+    const unwrapped = unwrapRedirect(anchor.href);
+    return isExternalResult(unwrapped) ? unwrapped : undefined;
+  }
+  const target = resolved.get(anchor.href);
+  if (target !== undefined && isExternalResult(target)) return target;
+  if (anchor.cite !== undefined && anchor.cite.trim() !== "") return googleUrlFromCite(anchor.cite);
+  return undefined;
+};
+
+export const google: SearchEngine = {
+  id: "google",
+  name: "Google",
+  buildUrl: (query, limit) => `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${limit}&hl=en`,
+  selectors: {
+    root: "#search, #rso, #main",
+    heading: "a h3",
+    containers: ["div.g", "div[data-hveid]"],
+    cite: "cite",
+  },
+  captchaMarkers: CAPTCHA_MARKERS,
+  resultUrl,
+  needsRedirectResolve: isGotoRedirect,
+};
+
+export const parseGoogleSerp = (
+  anchors: ReadonlyArray<SerpAnchor>,
+  limit: number,
+  resolved: ResolvedTargets = new Map(),
+): ReadonlyArray<SearchResult> => parseSerp(google, anchors, limit, resolved);
+
+export const classifyGoogleSerp = (pageText: string, resultCount: number, anchorCount: number): SerpVerdict =>
+  classifySerpWith(CAPTCHA_MARKERS, pageText, resultCount, anchorCount);

package/src/domains/search/engines/index.ts

@@ -0,0 +1,13 @@
+// Composition root for the built-in engines. The order of mounts is the default fallback ladder. To add an engine,
+// write engines/<id>.ts exporting a SearchEngine and mount it here — or mount it onto defaultEngines() and inject the
+// result into createWebSearchTool from outside.
+import { bing } from "./bing";
+import { brave } from "./brave";
+import { duckduckgo } from "./duckduckgo";
+import { google } from "./google";
+import { createEngineRegistry, type EngineRegistry } from "./registry";
+
+export const defaultEngines = (): EngineRegistry =>
+  createEngineRegistry().mount(google).mount(bing).mount(duckduckgo).mount(brave);
+
+export { createEngineRegistry, type EngineRegistry } from "./registry";

package/src/domains/search/engines/registry.ts

@@ -0,0 +1,29 @@
+import type { SearchEngine } from "../serp";
+
+// An immutable set of mounted engines. Mount order is the fallback ladder: the first engine mounted is tried first.
+export type EngineRegistry = {
+  // A new registry with `engine` appended to the ladder. Throws on a duplicate id: that is a wiring bug, caught at
+  // composition time rather than surfacing as a confusing search.
+  readonly mount: (engine: SearchEngine) => EngineRegistry;
+  readonly get: (id: string) => SearchEngine | undefined;
+  readonly ids: () => ReadonlyArray<string>;
+  readonly ladder: () => ReadonlyArray<SearchEngine>;
+};
+
+const ENGINE_ID = /^[a-z][a-z0-9-]*$/;
+
+const fromEngines = (engines: ReadonlyArray<SearchEngine>): EngineRegistry => {
+  const byId = new Map(engines.map((e) => [e.id, e] as const));
+  return {
+    mount: (engine) => {
+      if (!ENGINE_ID.test(engine.id)) throw new Error(`search engine id "${engine.id}" must match ${String(ENGINE_ID)}`);
+      if (byId.has(engine.id)) throw new Error(`search engine "${engine.id}" is already mounted`);
+      return fromEngines([...engines, engine]);
+    },
+    get: (id) => byId.get(id),
+    ids: () => engines.map((e) => e.id),
+    ladder: () => engines,
+  };
+};
+
+export const createEngineRegistry = (): EngineRegistry => fromEngines([]);

package/src/domains/search/redirect-resolver.ts

@@ -2,7 +2,7 @@
 // following it. The blob cannot be decoded client-side and the page's <cite> is only a display breadcrumb, so this
 // is the one source of the exact url. Google answers the redirect to a cookie-less GET; HEAD returns 200 instead.
 
-import { isGotoRedirect } from "./google-serp";
+import { isGotoRedirect } from "./engines/google";
 
 const REDIRECT_STATUSES: ReadonlySet<number> = new Set([301, 302, 303, 307, 308]);
 

package/src/domains/search/serp.ts

@@ -0,0 +1,157 @@
+// Engine-neutral SERP vocabulary and parsing. Each engine (engines/*.ts) supplies how to find result anchors on its
+// page and how to turn an anchor into its target url; ranking, dedupe and verdicts are shared here.
+
+export type SerpAnchor = {
+  readonly href: string;
+  readonly heading: string;
+  readonly snippet: string;
+  // Visible breadcrumb url ("https://host › path › seg"); the fallback when the href is an opaque redirect.
+  readonly cite?: string;
+};
+
+export type SerpExtraction = {
+  readonly anchors: ReadonlyArray<SerpAnchor>;
+  readonly pageText: string;
+};
+
+export type SearchResult = {
+  readonly title: string;
+  readonly url: string;
+  readonly snippet: string;
+  readonly rank: number;
+};
+
+export type SerpVerdict = "ok" | "captcha" | "no_results" | "extraction_mismatch";
+
+// Redirect hrefs resolved server-side (Google /goto), keyed by href.
+export type ResolvedTargets = ReadonlyMap<string, string>;
+
+// Selectors handed to the page-side extractor. Every result is found from its heading: the title element is either
+// the result link itself or sits inside / around it.
+export type SerpSelectors = {
+  // Results column; the extractor falls back to <body> when none match.
+  readonly root: string;
+  // The title element of each organic result.
+  readonly heading: string;
+  // Result-block selectors, tried in order with closest(); the first match is the result's container.
+  readonly containers: ReadonlyArray<string>;
+  // Snippet element inside the container; without it the snippet is the container text minus the heading.
+  readonly snippet?: string;
+  // Breadcrumb element inside the container.
+  readonly cite: string;
+};
+
+// A pluggable search engine. Engines are plain values mounted into an EngineRegistry (engines/registry.ts); nothing
+// else in the search code knows which engines exist.
+export type SearchEngine = {
+  // Stable lower-case identifier the agent passes as `engine` ("google", "bing").
+  readonly id: string;
+  // Human name, used in error messages ("Bing served a CAPTCHA").
+  readonly name: string;
+  readonly buildUrl: (query: string, limit: number) => string;
+  readonly selectors: SerpSelectors;
+  // Lower-case phrases that mark a bot wall / challenge page.
+  readonly captchaMarkers: ReadonlyArray<string>;
+  // The anchor's external target, or undefined when it is not an organic web result.
+  readonly resultUrl: (anchor: SerpAnchor, resolved: ResolvedTargets) => string | undefined;
+  // For engines that render results with JavaScript after the load event: the tool waits (briefly) for this selector
+  // to match before extracting. A page that never matches is still extracted and classified (captcha / no_results).
+  readonly readySelector?: string;
+  // Hrefs that can only be decoded by asking the engine's server for the redirect (Google /goto).
+  readonly needsRedirectResolve?: (href: string) => boolean;
+};
+
+const CITE_SEPARATOR = /\s*›\s*/;
+const TRUNCATION = /(?:\.\.\.|…)/;
+
+export const isWebUrl = (url: string): boolean => {
+  if (!/^https?:\/\//i.test(url)) return false;
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const hostOf = (url: string): string | undefined => {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return undefined;
+  }
+};
+
+// Rebuilds a url from a visible breadcrumb cite. Segments after a truncation marker are unknowable, so the path stops
+// at the last complete segment rather than guessing. Returns only urls `isResult` accepts.
+export const urlFromCite = (cite: string, isResult: (url: string) => boolean): string | undefined => {
+  const segments = cite
+    .trim()
+    .split(CITE_SEPARATOR)
+    .map((segment) => segment.trim())
+    .filter((segment) => segment.length > 0);
+  const origin = segments[0];
+  if (origin === undefined || TRUNCATION.test(origin)) return undefined;
+  // A cite naming any other scheme (ftp:, mailto:) is not a web result; prefixing it would forge a bogus https url.
+  if (/^[a-z][a-z0-9+.-]*:/i.test(origin) && !/^https?:\/\//i.test(origin)) return undefined;
+  const withScheme = /^https?:\/\//i.test(origin) ? origin : `https://${origin}`;
+  const path: string[] = [];
+  for (const segment of segments.slice(1)) {
+    if (TRUNCATION.test(segment)) break;
+    path.push(segment);
+  }
+  const url = [withScheme.replace(/\/$/, ""), ...path].join("/");
+  return isResult(url) ? url : undefined;
+};
+
+// A web url whose host is not one of the engine's own properties.
+export const externalResult =
+  (isOwnHost: (host: string) => boolean) =>
+  (url: string): boolean => {
+    if (!isWebUrl(url)) return false;
+    const host = hostOf(url);
+    return host !== undefined && !isOwnHost(host);
+  };
+
+const dedupeKey = (url: string): string => {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname.replace(/\/$/, "")}`.toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+};
+
+export const parseSerp = (
+  engine: SearchEngine,
+  anchors: ReadonlyArray<SerpAnchor>,
+  limit: number,
+  resolved: ResolvedTargets = new Map(),
+): ReadonlyArray<SearchResult> => {
+  const seen = new Set<string>();
+  const results: SearchResult[] = [];
+  for (const anchor of anchors) {
+    if (results.length >= limit) break;
+    const url = engine.resultUrl(anchor, resolved);
+    if (url === undefined) continue;
+    const key = dedupeKey(url);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({ title: anchor.heading.trim(), url, snippet: anchor.snippet.trim(), rank: results.length + 1 });
+  }
+  return results;
+};
+
+export const classifySerpWith = (
+  captchaMarkers: ReadonlyArray<string>,
+  pageText: string,
+  resultCount: number,
+  anchorCount: number,
+): SerpVerdict => {
+  if (resultCount > 0) return "ok";
+  const lower = pageText.toLowerCase();
+  if (captchaMarkers.some((marker) => lower.includes(marker))) return "captcha";
+  // Anchors were found but every one was filtered out: the markup changed, not the result set.
+  if (anchorCount > 0) return "extraction_mismatch";
+  return "no_results";
+};

package/src/domains/search/web-search.ts

@@ -4,46 +4,58 @@ import { parseJson } from "../../schemas/parse";
 import { type Result, err, ok } from "../../util/result";
 import { applyTruncation } from "../../util/truncate";
 import { type DetailsOf, defineBrowserTool, type ToolErr, type ToolOk } from "../../util/tool";
+import type { BrowserClient } from "../../client";
 import {
   closeIsolatedTab,
   evalInIsolatedTab,
+  type IsolatedTab,
   isJsonText,
   navigateIsolatedTab,
   openIsolatedTab,
   waitForIsolatedLoad,
 } from "../isolated-tab";
 import { pageCallExpression } from "../page/inject";
+import { pollUntil } from "../poll";
+import { safeJs } from "../../util/js-template";
 import { extractSerp } from "../page/serp.page";
 import type * as extracted from "../page/serp.page";
 import { ExpandableTextSchema, renderExpandableText } from "../render";
 import { deadlineSignal, runLimited } from "../concurrency";
+import { defaultEngines, type EngineRegistry } from "./engines";
 import {
-  classifySerp,
-  isGotoRedirect,
-  parseGoogleSerp,
+  classifySerpWith,
+  parseSerp,
   type ResolvedTargets,
+  type SearchEngine,
   type SearchResult,
   type SerpExtraction,
-} from "./google-serp";
+  type SerpSelectors,
+} from "./serp";
 import { fetchRedirectTarget, type RedirectResolver } from "./redirect-resolver";
 
 const LOAD_TIMEOUT_MS = 15_000;
 const RESOLVE_BUDGET_MS = 5_000;
 const RESOLVE_CONCURRENCY = 5;
+const RENDER_WAIT_MS = 4_000;
 
 export type WebSearchDeps = {
+  // The mounted engines; mount order is the fallback ladder.
+  readonly engines: EngineRegistry;
   readonly resolveRedirect: RedirectResolver;
   readonly resolveBudgetMs?: number;
 };
 
-// Resolves every /goto anchor in parallel under one time budget; a slot that fails or runs out of time is simply
-// absent from the map, and the parser falls back to that anchor's cite.
-const resolveGotoTargets = async (
+// Resolves every server-side redirect anchor (Google /goto) in parallel under one time budget; a slot that fails or
+// runs out of time is simply absent from the map, and the engine falls back to that anchor's cite.
+const resolveRedirectTargets = async (
+  engine: SearchEngine,
   anchors: ReadonlyArray<SerpExtraction["anchors"][number]>,
   deps: WebSearchDeps,
   signal: AbortSignal | undefined,
 ): Promise<ResolvedTargets> => {
-  const hrefs = anchors.map((a) => a.href).filter(isGotoRedirect);
+  const needsResolve = engine.needsRedirectResolve;
+  if (needsResolve === undefined) return new Map();
+  const hrefs = anchors.map((a) => a.href).filter(needsResolve);
   if (hrefs.length === 0) return new Map();
   const deadline = deadlineSignal(deps.resolveBudgetMs ?? RESOLVE_BUDGET_MS, signal);
   const targets = await runLimited(hrefs, { limit: RESOLVE_CONCURRENCY, signal: deadline.signal }, (href, s) =>
@@ -58,25 +70,17 @@ const resolveGotoTargets = async (
   return resolved;
 };
 
-const WebSearchArgs = Type.Object({
-  query: Type.String({ description: "The search query." }),
-  limit: Type.Optional(
-    Type.Integer({ default: 10, minimum: 1, maximum: 30, description: "Max results to return. Default: 10." }),
-  ),
-});
-
 const PAGE_TEXT_LIMIT = 4000;
 
 // The page function declares the extraction shape it produces; this pins it to the shape the SERP parser consumes,
 // so the two cannot drift apart silently (the runtime validator below still guards the actual wire value).
 type Pinned<T extends SerpExtraction> = T;
 export type ExtractionFromPage = Pinned<extracted.SerpExtraction>;
+type PinnedSelectors<T extends extracted.SerpSelectors> = T;
+export type SelectorsForPage = PinnedSelectors<SerpSelectors>;
 
-// Built once: stringifying the page function per call was the only cost of the thunk.
-const SERP_EXTRACTION_EXPR = pageCallExpression(extractSerp, PAGE_TEXT_LIMIT);
-
-const buildSerpUrl = (query: string, limit: number): string =>
-  `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${limit}&hl=en`;
+const extractionExpression = (engine: SearchEngine): string =>
+  pageCallExpression(extractSerp, engine.selectors, PAGE_TEXT_LIMIT);
 
 const SerpExtractionSchema = Type.Object({
   anchors: Type.Array(
@@ -102,105 +106,231 @@ const SearchResultSchema = Type.Object({
   rank: Type.Number(),
 });
 
+const AttemptSchema = Type.Object({
+  engine: Type.String(),
+  kind: Type.String(),
+  reason: Type.Optional(Type.String()),
+  message: Type.String(),
+});
+
 const WebSearchDetailsSchema = Type.Object({
   results: Type.Array(SearchResultSchema),
-  engine: Type.Literal("google"),
+  engine: Type.String(),
   query: Type.String(),
+  // Engines tried and failed before `engine` answered; absent when the first engine answered.
+  fallbacks: Type.Optional(Type.Array(AttemptSchema)),
   render: ExpandableTextSchema,
   fullOutputPath: Type.Optional(Type.String()),
 });
 
 export type WebSearchDetails = DetailsOf<typeof WebSearchDetailsSchema>;
+type Attempt = DetailsOf<typeof AttemptSchema>;
 
 const formatResults = (query: string, results: ReadonlyArray<SearchResult>): string => {
   const lines = results.map((r) => `${r.rank}. ${r.title}\n   ${r.url}\n   ${r.snippet}`);
   return `${results.length} result(s) for "${query}":\n\n${lines.join("\n\n")}`;
 };
 
-export const createWebSearchTool = (deps: WebSearchDeps) => defineBrowserTool({
-  name: "browser_web_search",
-  label: "Browser Web Search",
-  description:
-    "Search the web and return ranked results (title, url, snippet, rank). Scrapes a Google results page in the real Chrome — no API key. Returns links only; use browser_read_page to read a result's content.",
-  promptSnippet: "Search the web for a query",
-  promptGuidelines: [
-    "On a CAPTCHA / bot wall the call fails with kind:'invalid_state' and details.reason:'captcha' (plus serpUrl) — surface it to the user; do not retry in a tight loop.",
-    "On zero results it fails with details.reason:'no_results' — rephrase the query and try again.",
-    "If results were on the page but none could be parsed it fails with details.reason:'extraction_mismatch' (plus anchorCount) — Google's markup changed; report it rather than retrying.",
-    "Runs in its own isolated tab and never disturbs the user's current tab.",
-  ],
-  parameters: WebSearchArgs,
-  details: WebSearchDetailsSchema,
-  concurrency: "serialized",
-  async handler(args, { client, signal }): Promise<Result<ToolOk<WebSearchDetails>, ToolErr>> {
-    const limit = args.limit ?? 10;
-    const serpUrl = buildSerpUrl(args.query, limit);
-
-    const opened = await openIsolatedTab(client);
-    if (!opened.success) return err(opened.error);
-    const tab = opened.data;
-
-    try {
-      const navigated = await navigateIsolatedTab(client, tab, serpUrl);
-      if (!navigated.success) return err(navigated.error);
-
-      const loaded = await waitForIsolatedLoad(client, tab, LOAD_TIMEOUT_MS, signal);
-      if (!loaded.success) return err(loaded.error);
-
-      const extracted = await evalInIsolatedTab(client, tab, SERP_EXTRACTION_EXPR, isJsonText);
-      if (!extracted.success) return err(extracted.error);
-
-      const parsedJson = parseSerpExtraction(extracted.data);
-      if (!parsedJson.success) {
-        return err({ kind: "internal", message: `SERP extraction returned an unexpected shape: ${parsedJson.error}` });
-      }
-      const extraction: SerpExtraction = parsedJson.data;
-
-      const resolved = await resolveGotoTargets(extraction.anchors, deps, signal);
-      const results = parseGoogleSerp(extraction.anchors, limit, resolved);
-      const anchorCount = extraction.anchors.length;
-      const verdict = classifySerp(extraction.pageText, results.length, anchorCount);
-      if (verdict === "captcha") {
-        return err({
-          kind: "invalid_state",
-          message: "Google served a CAPTCHA / bot wall",
-          details: { reason: verdict, serpUrl },
-        });
-      }
-      if (verdict === "extraction_mismatch") {
-        return err({
-          kind: "invalid_state",
-          message: `found ${anchorCount} result anchor(s) but none parsed to an external url (Google markup may have changed)`,
-          details: { reason: verdict, anchorCount, serpUrl },
-        });
-      }
-      if (verdict === "no_results") {
-        return err({ kind: "invalid_state", message: "no results found", details: { reason: verdict, serpUrl } });
-      }
-
-      const body = formatResults(args.query, results);
-      const truncated = await applyTruncation(body, "search");
-      return ok({
-        text: truncated.text,
-        details: {
-          results,
-          engine: "google",
-          query: args.query,
-          render: {
-            summary: `${results.length} result(s) · google · "${args.query}"`,
-            body,
-            ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
-          },
-          ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
-        },
-      });
-    } finally {
-      await closeIsolatedTab(client, tab);
-    }
-  },
-  renderResult(result, expanded) {
-    return renderExpandableText(result.details.render, expanded);
+// One engine, one SERP, in the already-open isolated tab.
+const searchEngine = async (
+  engine: SearchEngine,
+  query: string,
+  limit: number,
+  ctx: {
+    readonly client: BrowserClient;
+    readonly tab: IsolatedTab;
+    readonly signal: AbortSignal | undefined;
+    readonly expression: string;
   },
+  deps: WebSearchDeps,
+): Promise<Result<ReadonlyArray<SearchResult>, ToolErr>> => {
+  const { client, tab, signal, expression } = ctx;
+  const serpUrl = engine.buildUrl(query, limit);
+
+  const navigated = await navigateIsolatedTab(client, tab, serpUrl);
+  if (!navigated.success) return err(navigated.error);
+
+  const loaded = await waitForIsolatedLoad(client, tab, LOAD_TIMEOUT_MS, signal);
+  if (!loaded.success) return err(loaded.error);
+
+  if (engine.readySelector !== undefined) {
+    // A miss is not a failure: a bot wall or an empty SERP never renders results, and extraction classifies it.
+    await pollUntil(client, safeJs`document.querySelector(${engine.readySelector}) !== null`, {
+      timeoutMs: RENDER_WAIT_MS,
+      signal,
+      sessionId: tab.sessionId,
+      what: `${engine.name} results`,
+    });
+    if (signal?.aborted === true) return err({ kind: "timeout", message: `Aborted while waiting for ${engine.name} results` });
+  }
+
+  const evaluated = await evalInIsolatedTab(client, tab, expression, isJsonText);
+  if (!evaluated.success) return err(evaluated.error);
+
+  const parsedJson = parseSerpExtraction(evaluated.data);
+  if (!parsedJson.success) {
+    return err({ kind: "internal", message: `SERP extraction returned an unexpected shape: ${parsedJson.error}` });
+  }
+  const extraction: SerpExtraction = parsedJson.data;
+
+  const resolved = await resolveRedirectTargets(engine, extraction.anchors, deps, signal);
+  const results = parseSerp(engine, extraction.anchors, limit, resolved);
+  const anchorCount = extraction.anchors.length;
+  const verdict = classifySerpWith(engine.captchaMarkers, extraction.pageText, results.length, anchorCount);
+  if (verdict === "captcha") {
+    return err({
+      kind: "invalid_state",
+      message: `${engine.name} served a CAPTCHA / bot wall`,
+      details: { reason: verdict, serpUrl },
+    });
+  }
+  if (verdict === "extraction_mismatch") {
+    return err({
+      kind: "invalid_state",
+      message: `found ${anchorCount} result anchor(s) but none parsed to an external url (${engine.name} markup may have changed)`,
+      details: { reason: verdict, anchorCount, serpUrl },
+    });
+  }
+  if (verdict === "no_results") {
+    return err({ kind: "invalid_state", message: "no results found", details: { reason: verdict, serpUrl } });
+  }
+  return ok(results);
+};
+
+const withEngine = (engine: string, error: ToolErr): ToolErr => ({
+  ...error,
+  details: { ...error.details, engine },
 });
 
-export const webSearchTool = createWebSearchTool({ resolveRedirect: fetchRedirectTarget });
+const toAttempt = (engine: string, error: ToolErr): Attempt => {
+  const reason = error.details?.["reason"];
+  return {
+    engine,
+    kind: error.kind,
+    ...(typeof reason === "string" ? { reason } : {}),
+    message: error.message,
+  };
+};
+
+// A dead browser or a cancelled call fails every engine the same way, so the ladder stops instead of trying the next.
+const stopsLadder = (error: ToolErr, signal: AbortSignal | undefined): boolean =>
+  signal?.aborted === true || error.kind === "not_connected";
+
+const exhausted = (attempts: ReadonlyArray<Attempt>): ToolErr => {
+  const allEmpty = attempts.every((a) => a.reason === "no_results");
+  const summary = attempts.map((a) => `${a.engine}: ${a.message}`).join("; ");
+  return {
+    kind: "invalid_state",
+    message: allEmpty ? `no results found on any engine (${summary})` : `every search engine failed (${summary})`,
+    details: { reason: allEmpty ? "no_results" : "all_engines_failed", attempts },
+  };
+};
+
+// A named engine is tried alone; no name means the whole mounted ladder.
+const pickLadder = (
+  engines: EngineRegistry,
+  name: string | undefined,
+): Result<ReadonlyArray<SearchEngine>, ToolErr> => {
+  if (name === undefined) return ok(engines.ladder());
+  const named = engines.get(name);
+  if (named !== undefined) return ok([named]);
+  return err({
+    kind: "invalid_args",
+    message: `unknown search engine "${name}"; mounted engines: ${engines.ids().join(", ")}`,
+    details: { engine: name, engines: engines.ids() },
+  });
+};
+
+const webSearchArgs = (engines: EngineRegistry) =>
+  Type.Object({
+    query: Type.String({ description: "The search query." }),
+    limit: Type.Optional(
+      Type.Integer({ default: 10, minimum: 1, maximum: 30, description: "Max results to return. Default: 10." }),
+    ),
+    engine: Type.Optional(
+      Type.String({
+        enum: [...engines.ids()],
+        description: `Search only this engine (${engines.ids().join(", ")}), with no fallback. Omit to walk the fallback ladder ${engines.ids().join(" → ")} until one returns results.`,
+      }),
+    ),
+  });
+
+export const createWebSearchTool = (deps: WebSearchDeps) => {
+  const { engines } = deps;
+  const ids = engines.ids();
+  if (ids.length === 0) throw new Error("browser_web_search needs at least one mounted search engine");
+  const ladderText = ids.join(" → ");
+  // Built once per engine: stringifying the page function per call was the only cost of the thunk.
+  const expressions = new Map(engines.ladder().map((e) => [e.id, extractionExpression(e)] as const));
+
+  return defineBrowserTool({
+    name: "browser_web_search",
+    label: "Browser Web Search",
+    description:
+      `Search the web and return ranked results (title, url, snippet, rank). Scrapes a search engine results page in the real Chrome — no API key. Engines: ${ids.join(", ")}. With no engine given it walks the fallback ladder ${ladderText} until one returns results. Returns links only; use browser_read_page to read a result's content.`,
+    promptSnippet: "Search the web for a query",
+    promptGuidelines: [
+      `Omit engine to get the fallback ladder (${ladderText}); details.engine says which engine answered and details.fallbacks lists the engines that failed first.`,
+      "Pass engine only when one engine is specifically needed; a named engine is tried alone, with no fallback.",
+      "On a CAPTCHA / bot wall the call fails with kind:'invalid_state' and details.reason:'captcha' (plus serpUrl and engine) — surface it to the user; do not retry in a tight loop.",
+      "On zero results it fails with details.reason:'no_results' — rephrase the query and try again.",
+      "If results were on the page but none could be parsed it fails with details.reason:'extraction_mismatch' (plus anchorCount) — the engine's markup changed; report it rather than retrying.",
+      "When every engine on the ladder fails it is details.reason:'all_engines_failed' with details.attempts naming each engine's failure.",
+      "Runs in its own isolated tab and never disturbs the user's current tab.",
+    ],
+    parameters: webSearchArgs(engines),
+    details: WebSearchDetailsSchema,
+    concurrency: "serialized",
+    async handler(args, { client, signal }): Promise<Result<ToolOk<WebSearchDetails>, ToolErr>> {
+      const limit = args.limit ?? 10;
+      const ladder = pickLadder(engines, args.engine);
+      if (!ladder.success) return err(ladder.error);
+
+      const opened = await openIsolatedTab(client);
+      if (!opened.success) return err(opened.error);
+      const tab = opened.data;
+
+      try {
+        const attempts: Attempt[] = [];
+        for (const engine of ladder.data) {
+          const id = engine.id;
+          const expression = expressions.get(id) ?? extractionExpression(engine);
+          const searched = await searchEngine(engine, args.query, limit, { client, tab, signal, expression }, deps);
+          if (!searched.success) {
+            // A single named engine reports its own failure exactly, as if there were no ladder.
+            if (ladder.data.length === 1 || stopsLadder(searched.error, signal)) return err(withEngine(id, searched.error));
+            attempts.push(toAttempt(id, searched.error));
+            continue;
+          }
+          const results = searched.data;
+          const body = formatResults(args.query, results);
+          const truncated = await applyTruncation(body, "search");
+          const via = attempts.length > 0 ? ` (after ${attempts.map((a) => a.engine).join(", ")} failed)` : "";
+          return ok({
+            text: truncated.text,
+            details: {
+              results,
+              engine: id,
+              query: args.query,
+              ...(attempts.length > 0 ? { fallbacks: attempts } : {}),
+              render: {
+                summary: `${results.length} result(s) · ${id}${via} · "${args.query}"`,
+                body,
+                ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+              },
+              ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+            },
+          });
+        }
+        return err(exhausted(attempts));
+      } finally {
+        await closeIsolatedTab(client, tab);
+      }
+    },
+    renderResult(result, expanded) {
+      return renderExpandableText(result.details.render, expanded);
+    },
+  });
+};
+
+export const webSearchTool = createWebSearchTool({ engines: defaultEngines(), resolveRedirect: fetchRedirectTarget });

package/src/domains/search/google-serp.ts

@@ -1,155 +0,0 @@
-export type SerpAnchor = {
-  readonly href: string;
-  readonly heading: string;
-  readonly snippet: string;
-  // Visible breadcrumb url ("https://host › path › seg"); the only place the target survives once Google wraps hrefs in /goto.
-  readonly cite?: string;
-};
-
-export type SerpExtraction = {
-  readonly anchors: ReadonlyArray<SerpAnchor>;
-  readonly pageText: string;
-};
-
-export type SearchResult = {
-  readonly title: string;
-  readonly url: string;
-  readonly snippet: string;
-  readonly rank: number;
-};
-
-export type SerpVerdict = "ok" | "captcha" | "no_results" | "extraction_mismatch";
-
-const CAPTCHA_MARKERS: ReadonlyArray<string> = [
-  "unusual traffic",
-  "not a robot",
-  "recaptcha",
-  "detected unusual",
-  "systems have detected",
-  "before you continue to google",
-  "our systems have detected unusual traffic",
-];
-
-const unwrapRedirect = (href: string): string => {
-  const wrapper = /^(?:https?:\/\/[^/]*google\.[^/]*)?\/url\?/i.exec(href);
-  if (!wrapper) return href;
-  const query = href.slice(href.indexOf("?") + 1);
-  const target = new URLSearchParams(query).get("q");
-  return target ?? href;
-};
-
-const CITE_SEPARATOR = /\s*›\s*/;
-const TRUNCATION = /(?:\.\.\.|…)/;
-
-// Rebuilds a url from Google's visible breadcrumb cite. Segments after a truncation marker are unknowable, so the
-// path stops at the last complete segment rather than guessing.
-export const urlFromCite = (cite: string): string | undefined => {
-  const segments = cite
-    .trim()
-    .split(CITE_SEPARATOR)
-    .map((segment) => segment.trim())
-    .filter((segment) => segment.length > 0);
-  const origin = segments[0];
-  if (origin === undefined || TRUNCATION.test(origin)) return undefined;
-  // A cite naming any other scheme (ftp:, mailto:) is not a web result; prefixing it would forge a bogus https url.
-  if (/^[a-z][a-z0-9+.-]*:/i.test(origin) && !/^https?:\/\//i.test(origin)) return undefined;
-  const withScheme = /^https?:\/\//i.test(origin) ? origin : `https://${origin}`;
-  const path: string[] = [];
-  for (const segment of segments.slice(1)) {
-    if (TRUNCATION.test(segment)) break;
-    path.push(segment);
-  }
-  const url = [withScheme.replace(/\/$/, ""), ...path].join("/");
-  return isExternalResult(url) ? url : undefined;
-};
-
-// Only a real Google /goto url counts: the daemon fetches these, so a look-alike host, userinfo, a port or http
-// must never qualify. Hosts are google.com or www.google.<tld>, nothing else.
-const GOOGLE_GOTO_HOST = /^(?:www\.)?google\.[a-z]{2,3}(?:\.[a-z]{2})?$/;
-export const isGotoRedirect = (href: string): boolean => {
-  try {
-    const u = new URL(href);
-    return (
-      u.protocol === "https:" &&
-      u.username === "" &&
-      u.password === "" &&
-      u.port === "" &&
-      GOOGLE_GOTO_HOST.test(u.hostname.toLowerCase()) &&
-      u.pathname === "/goto"
-    );
-  } catch {
-    return false;
-  }
-};
-
-export type ResolvedTargets = ReadonlyMap<string, string>;
-
-// Direct external hrefs win. A /goto wrapper is opaque: the server-resolved redirect target is exact, and the cite is
-// a display breadcrumb that only approximates the path, so it is the fallback when no target was resolved.
-const resolveResultUrl = (anchor: SerpAnchor, resolved: ResolvedTargets): string | undefined => {
-  if (!isGotoRedirect(anchor.href)) {
-    const unwrapped = unwrapRedirect(anchor.href);
-    return isExternalResult(unwrapped) ? unwrapped : undefined;
-  }
-  const target = resolved.get(anchor.href);
-  if (target !== undefined && isExternalResult(target)) return target;
-  if (anchor.cite !== undefined && anchor.cite.trim() !== "") return urlFromCite(anchor.cite);
-  return undefined;
-};
-
-// Any Google property, on any TLD (google.com, google.co.uk, consent.google.de, googleusercontent.com), is never a
-// result: a sorry or consent page is where a rate-limited /goto redirect lands.
-const GOOGLE_PROPERTY = /(?:^|\.)google(?:usercontent)?\.(?:com?\.[a-z]{2}|[a-z]{2,3})$/;
-
-const isExternalResult = (url: string): boolean => {
-  if (!/^https?:\/\//i.test(url)) return false;
-  try {
-    const host = new URL(url).hostname.toLowerCase();
-    if (GOOGLE_PROPERTY.test(host)) return false;
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const dedupeKey = (url: string): string => {
-  try {
-    const u = new URL(url);
-    return `${u.origin}${u.pathname.replace(/\/$/, "")}`.toLowerCase();
-  } catch {
-    return url.toLowerCase();
-  }
-};
-
-export const parseGoogleSerp = (
-  anchors: ReadonlyArray<SerpAnchor>,
-  limit: number,
-  resolved: ResolvedTargets = new Map(),
-): ReadonlyArray<SearchResult> => {
-  const seen = new Set<string>();
-  const results: SearchResult[] = [];
-  for (const anchor of anchors) {
-    if (results.length >= limit) break;
-    const url = resolveResultUrl(anchor, resolved);
-    if (url === undefined) continue;
-    const key = dedupeKey(url);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    results.push({
-      title: anchor.heading.trim(),
-      url,
-      snippet: anchor.snippet.trim(),
-      rank: results.length + 1,
-    });
-  }
-  return results;
-};
-
-export const classifySerp = (pageText: string, resultCount: number, anchorCount: number): SerpVerdict => {
-  if (resultCount > 0) return "ok";
-  const lower = pageText.toLowerCase();
-  if (CAPTCHA_MARKERS.some((marker) => lower.includes(marker))) return "captcha";
-  // Anchors were found but every one was filtered out: the markup changed, not the result set.
-  if (anchorCount > 0) return "extraction_mismatch";
-  return "no_results";
-};