@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/tools/web-fetch.js

@@ -1,6 +1,7 @@
-import defaultFetch from '#no-redirect-fetch';
+import { noRedirectFetch } from '#no-redirect-fetch';
 import { AbortController } from 'bare-abort-controller';
 import { lookupHost } from '../dns-lookup.js';
+import { errorMessage } from '../guards.js';
 import { AbortedError } from '../helpers/race-abort.js';
 import { extractEmbeddedState } from '../web-fetch/embedded-state.js';
 import { extractPageText, looksLikeHtml } from '../web-fetch/extract.js';
@@ -8,7 +9,7 @@ import { imageFileName, pageImageUrls } from '../web-fetch/images.js';
 import { pageVideoRef } from '../web-fetch/video.js';
 import { MAX_HTML_CHARS } from '../web-search/fetch-html.js';
 import { BROWSER_UA } from '../web-search/user-agents.js';
-import { isRedirectStatus } from './http-request/utils.js';
+import { isRedirectStatus } from './http-request/request.js';
 import { resolveOutboundUrl } from './url-guard.js';
 const SMALL_CONTEXT_TOKENS = 12_288;
 const SMALL_CONTEXT_CHARS = 6_000;
@@ -64,9 +65,10 @@ export function createWebFetchTool({ fetch: fetchImpl, resolveHost = lookupHost
             if (url.protocol !== 'http:' && url.protocol !== 'https:') {
                 return { error: `Scheme "${url.protocol}" not allowed. Use http: or https:.` };
             }
-            if (ctx?.signal?.aborted)
+            if (ctx?.signal?.aborted) {
                 return { error: 'web_fetch cancelled' };
-            const fetch = fetchImpl ?? defaultFetch;
+            }
+            const fetch = fetchImpl ?? noRedirectFetch;
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(undefined), PAGE_TIMEOUT_MS);
             const onCallerAbort = () => controller.abort(undefined);
@@ -79,8 +81,9 @@ export function createWebFetchTool({ fetch: fetchImpl, resolveHost = lookupHost
                     maxBytes: MAX_PAGE_BYTES,
                     truncate: true
                 });
-                if (!got.ok)
+                if (!got.ok) {
                     return { error: got.error };
+                }
                 const { response, finalUrl: currentUrl } = got;
                 if (response.status < 200 || response.status >= 300) {
                     return {
@@ -91,18 +94,24 @@ export function createWebFetchTool({ fetch: fetchImpl, resolveHost = lookupHost
                 const rawBody = await response.text();
                 const body = rawBody.length > MAX_HTML_CHARS ? rawBody.slice(0, MAX_HTML_CHARS) : rawBody;
                 let mimeType = response.headers?.get('content-type')?.split(';')[0]?.trim().toLowerCase() ?? '';
-                if (body.startsWith('%PDF-'))
+                if (body.startsWith('%PDF-')) {
                     mimeType = 'application/pdf';
+                }
                 if (isBinaryMime(mimeType) || body.includes('\u0000')) {
                     const attachMime = isBinaryMime(mimeType) ? mimeType : 'application/octet-stream';
-                    return await attachDocument(response, currentUrl, attachMime, ctx?.attach);
+                    return await attachDocument(response, {
+                        url: currentUrl,
+                        mimeType: attachMime,
+                        attach: ctx?.attach
+                    });
                 }
                 const isHtml = looksLikeHtml(body);
                 let page = isHtml ? extractPageText(body) : { title: null, text: body.trim() };
                 if (isHtml && page.text.length < MIN_MARKUP_CHARS) {
                     const embedded = extractEmbeddedState(body);
-                    if (embedded.length > page.text.length)
+                    if (embedded.length > page.text.length) {
                         page = { title: page.title, text: embedded };
+                    }
                 }
                 const budget = charBudget(ctx?.ctxSize);
                 const text = page.text.length > budget ? `${page.text.slice(0, budget)}…[truncated]` : page.text;
@@ -149,7 +158,7 @@ export function createWebFetchTool({ fetch: fetchImpl, resolveHost = lookupHost
                 if (controller.signal.aborted) {
                     return { error: `${url.hostname} timed out after ${PAGE_TIMEOUT_MS}ms`, code: 'timeout' };
                 }
-                return { error: err instanceof Error ? err.message : String(err), code: 'transport' };
+                return { error: errorMessage(err), code: 'transport' };
             }
             finally {
                 clearTimeout(timeout);
@@ -164,7 +173,7 @@ function isBinaryMime(mimeType) {
         return true;
     return BINARY_MIME_PREFIXES.some((prefix) => mimeType.startsWith(prefix));
 }
-async function attachDocument(response, url, mimeType, attach) {
+async function attachDocument(response, { url, mimeType, attach }) {
     const bytes = await response.bytes?.();
     if (!attach || !bytes || bytes.byteLength === 0) {
         return { error: 'This URL serves a file, not a readable page, and it could not be attached.' };
@@ -218,33 +227,39 @@ function attachmentFileName(url, mimeType) {
     }
     catch { }
     const base = decoded.split(/[/\\]/).filter(Boolean).pop() ?? '';
-    if (!base)
+    if (!base) {
         return `${url.hostname}.${extensionFor(mimeType)}`;
+    }
     const extension = /\.([\w-]{1,8})$/.exec(base)?.[1]?.toLowerCase() ?? '';
-    if (extension && acceptableExtensions(mimeType).has(extension))
+    if (extension && acceptableExtensions(mimeType).has(extension)) {
         return base;
-    if (mimeType === 'application/octet-stream' && /^[a-z][\w-]*$/.test(extension))
+    }
+    if (mimeType === 'application/octet-stream' && /^[a-z][\w-]*$/.test(extension)) {
         return base;
+    }
     return `${base}.${extensionFor(mimeType)}`;
 }
 function acceptableExtensions(mimeType) {
     const accepted = new Set([extensionFor(mimeType)]);
     const subtype = mimeType.split('/')[1] ?? '';
-    if (/^[a-z0-9]{1,8}$/.test(subtype))
+    if (/^[a-z0-9]{1,8}$/.test(subtype)) {
         accepted.add(subtype);
+    }
     return accepted;
 }
 function extensionFor(mimeType) {
     const known = MIME_EXTENSIONS[mimeType];
-    if (known)
+    if (known) {
         return known;
+    }
     const subtype = mimeType.split('/')[1] ?? '';
     return /^[a-z0-9]{1,5}$/.test(subtype) ? subtype : 'bin';
 }
 async function guardedGet(fetch, url, { resolveHost, signal, accept, maxBytes, truncate }) {
     const initialCheck = await resolveOutboundUrl(url, resolveHost, signal);
-    if (initialCheck.blocked)
+    if (initialCheck.blocked) {
         return { ok: false, error: initialCheck.blocked };
+    }
     let currentUrl = url;
     let validatedAddresses = initialCheck.addresses;
     for (let redirects = 0;; redirects++) {
@@ -257,11 +272,13 @@ async function guardedGet(fetch, url, { resolveHost, signal, accept, maxBytes, t
             maxBytes,
             truncate
         });
-        if (!isRedirectStatus(response.status))
+        if (!isRedirectStatus(response.status)) {
             return { ok: true, response, finalUrl: currentUrl };
+        }
         const location = response.headers?.get('location');
-        if (!location)
+        if (!location) {
             return { ok: true, response, finalUrl: currentUrl };
+        }
         let nextUrl;
         try {
             nextUrl = new URL(location, currentUrl);
@@ -272,11 +289,13 @@ async function guardedGet(fetch, url, { resolveHost, signal, accept, maxBytes, t
         if (nextUrl.protocol !== 'http:' && nextUrl.protocol !== 'https:') {
             return { ok: true, response, finalUrl: currentUrl };
         }
-        if (redirects >= MAX_REDIRECTS)
+        if (redirects >= MAX_REDIRECTS) {
             return { ok: false, error: 'too many redirects' };
+        }
         const hopCheck = await resolveOutboundUrl(nextUrl, resolveHost, signal);
-        if (hopCheck.blocked)
+        if (hopCheck.blocked) {
             return { ok: false, error: hopCheck.blocked };
+        }
         currentUrl = nextUrl;
         validatedAddresses = hopCheck.addresses;
     }
@@ -293,17 +312,21 @@ async function attachPageImages(html, pageUrl, { fetch, resolveHost, attach, sig
                 accept: 'image/*',
                 maxBytes: MAX_IMAGE_BYTES
             });
-            if (!got.ok)
+            if (!got.ok) {
                 continue;
+            }
             const { response, finalUrl } = got;
-            if (response.status < 200 || response.status >= 300)
+            if (response.status < 200 || response.status >= 300) {
                 continue;
+            }
             const mimeType = response.headers?.get('content-type')?.split(';')[0]?.trim() ?? '';
-            if (!mimeType.startsWith('image/'))
+            if (!mimeType.startsWith('image/')) {
                 continue;
+            }
             const bytes = await response.bytes?.();
-            if (!bytes || bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES)
+            if (!bytes || bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES) {
                 continue;
+            }
             const record = await attach({ fileName: imageFileName(finalUrl, mimeType), mimeType, bytes });
             attached.push(record.fileName);
         }

package/dist-lib/lib/tools/web-search.js

@@ -1,4 +1,5 @@
 import defaultFetch from '#fetch';
+import { errorMessage } from '../guards.js';
 import { formatResultsForPrompt } from '../web-search/format-results.js';
 import { searchWeb } from '../web-search/orchestrator.js';
 const nodeFetch = async (url, init) => {
@@ -35,9 +36,13 @@ export function createWebSearchTool({ fetch } = {}) {
                 return { error: 'query must be a non-empty string' };
             }
             try {
-                const { results, engineSummary } = await searchWeb(fetcher, query, resultBudget(ctx?.ctxSize), ctx?.signal);
-                if (ctx?.signal?.aborted)
+                const { results, engineSummary } = await searchWeb(fetcher, query, {
+                    maxResults: resultBudget(ctx?.ctxSize),
+                    signal: ctx?.signal
+                });
+                if (ctx?.signal?.aborted) {
                     return { error: 'web_search cancelled' };
+                }
                 if (results.length > 0) {
                     return { content: formatResultsForPrompt(results), data: { results } };
                 }
@@ -51,7 +56,7 @@ export function createWebSearchTool({ fetch } = {}) {
                 return { content: `No web results found for "${query}".` };
             }
             catch (err) {
-                return { error: err instanceof Error ? err.message : String(err), code: 'transport' };
+                return { error: errorMessage(err), code: 'transport' };
             }
         }
     };

package/dist-lib/lib/validating-lookup.d.ts

@@ -1,14 +1,14 @@
 export type IPFamily = 4 | 6;
-export type LookupAddress = {
+export interface LookupAddress {
     readonly address: string;
     readonly family: IPFamily;
-};
+}
 export type LookupAllCb = (err: Error | null, addresses: ReadonlyArray<LookupAddress> | null) => void;
-export type BareLookupAllOpts = {
+export interface BareLookupAllOpts {
     readonly all: true;
     readonly family?: IPFamily | 0;
     readonly hints?: number;
-};
+}
 export type BareLookupAll = (hostname: string, opts: BareLookupAllOpts, cb: LookupAllCb) => void;
 export declare class BlockedAddressError extends Error {
     readonly code = "EBLOCKEDADDR";

package/dist-lib/lib/wav-encode.d.ts

@@ -2,4 +2,4 @@ export declare const TARGET_SAMPLE_RATE = 16000;
 export declare const WAV_HEADER_SIZE = 44;
 export declare const BITS_PER_SAMPLE = 16;
 export declare const CHANNELS = 1;
-export declare function buildWavBuffer(pcm: Buffer): Buffer;
+export declare function buildWavBuffer(pcm: Uint8Array): Buffer;

package/dist-lib/lib/wav-encode.js

@@ -1,24 +1,25 @@
+import b4a from 'b4a';
 export const TARGET_SAMPLE_RATE = 16000;
 export const WAV_HEADER_SIZE = 44;
 export const BITS_PER_SAMPLE = 16;
 export const CHANNELS = 1;
 export function buildWavBuffer(pcm) {
     const dataSize = pcm.length;
-    const buf = Buffer.alloc(WAV_HEADER_SIZE + dataSize);
+    const buf = b4a.alloc(WAV_HEADER_SIZE + dataSize);
     const blockAlign = CHANNELS * (BITS_PER_SAMPLE / 8);
-    buf.write('RIFF', 0, 'ascii');
-    buf.writeUInt32LE(WAV_HEADER_SIZE + dataSize - 8, 4);
-    buf.write('WAVE', 8, 'ascii');
-    buf.write('fmt ', 12, 'ascii');
-    buf.writeUInt32LE(16, 16);
+    b4a.write(buf, 'RIFF', 0, 'ascii');
+    b4a.writeUInt32LE(buf, WAV_HEADER_SIZE + dataSize - 8, 4);
+    b4a.write(buf, 'WAVE', 8, 'ascii');
+    b4a.write(buf, 'fmt ', 12, 'ascii');
+    b4a.writeUInt32LE(buf, 16, 16);
     buf.writeUInt16LE(1, 20);
     buf.writeUInt16LE(CHANNELS, 22);
-    buf.writeUInt32LE(TARGET_SAMPLE_RATE, 24);
-    buf.writeUInt32LE(TARGET_SAMPLE_RATE * blockAlign, 28);
+    b4a.writeUInt32LE(buf, TARGET_SAMPLE_RATE, 24);
+    b4a.writeUInt32LE(buf, TARGET_SAMPLE_RATE * blockAlign, 28);
     buf.writeUInt16LE(blockAlign, 32);
     buf.writeUInt16LE(BITS_PER_SAMPLE, 34);
-    buf.write('data', 36, 'ascii');
-    buf.writeUInt32LE(dataSize, 40);
+    b4a.write(buf, 'data', 36, 'ascii');
+    b4a.writeUInt32LE(buf, dataSize, 40);
     buf.set(pcm, WAV_HEADER_SIZE);
     return buf;
 }

package/dist-lib/lib/web-fetch/embedded-state.js

@@ -22,11 +22,13 @@ function structuredData(html) {
     const out = [];
     for (const match of html.matchAll(LDJSON_SCRIPT)) {
         const value = parseJson(match[1] ?? '');
-        if (value === null)
+        if (value === null) {
             continue;
+        }
         walk(value, (key, text) => {
-            if (STRUCTURED_PROSE_KEYS.has(key))
+            if (STRUCTURED_PROSE_KEYS.has(key)) {
                 out.push(text);
+            }
         });
     }
     return out;
@@ -35,11 +37,13 @@ function hydrationProse(html) {
     const out = [];
     for (const match of html.matchAll(JSON_SCRIPT)) {
         const value = parseJson(match[1] ?? '');
-        if (value === null)
+        if (value === null) {
             continue;
+        }
         walk(value, (_key, text) => {
-            if (looksLikeProse(text))
+            if (looksLikeProse(text)) {
                 out.push(text);
+            }
         });
     }
     return out;
@@ -51,13 +55,15 @@ function scriptLiteralProse(html) {
             if (literal.length < MIN_PROSE_CHARS)
                 continue;
             const decoded = parseJson(literal);
-            if (typeof decoded !== 'string')
+            if (typeof decoded !== 'string') {
                 continue;
+            }
             const inner = decoded.trimStart().startsWith('{') ? parseJson(decoded) : null;
             if (inner !== null) {
                 walk(inner, (_key, text) => {
-                    if (looksLikeProse(text))
+                    if (looksLikeProse(text)) {
                         out.push(text);
+                    }
                 });
             }
             else if (looksLikeProse(decoded.trim())) {
@@ -71,11 +77,13 @@ function metaTags(html) {
     const out = [];
     for (const match of html.matchAll(META_TAG)) {
         const tag = match[0];
-        if (!META_ATTR.test(tag))
+        if (!META_ATTR.test(tag)) {
             continue;
+        }
         const content = META_CONTENT.exec(tag)?.[1];
-        if (content)
+        if (content) {
             out.push(decodeHtmlEntities(content).trim());
+        }
     }
     return out;
 }
@@ -92,18 +100,21 @@ function parseJson(raw) {
 function walk(value, visit, key = '') {
     if (typeof value === 'string') {
         const text = value.trim();
-        if (text)
+        if (text) {
             visit(key, text);
+        }
         return;
     }
     if (Array.isArray(value)) {
-        for (const entry of value)
+        for (const entry of value) {
             walk(entry, visit, key);
+        }
         return;
     }
     if (value && typeof value === 'object') {
-        for (const [k, v] of Object.entries(value))
+        for (const [k, v] of Object.entries(value)) {
             walk(v, visit, k);
+        }
     }
 }
 function looksLikeProse(text) {
@@ -112,8 +123,9 @@ function looksLikeProse(text) {
     if (/^(?:https?:|data:|\/|#|\.)/.test(text))
         return false;
     const letters = text.match(/\p{L}/gu)?.length ?? 0;
-    if (letters / text.length <= 0.6)
+    if (letters / text.length <= 0.6) {
         return false;
+    }
     return text.includes(' ') || /[\u3000-\u9fff\u3040-\u30ff\uac00-\ud7af]/.test(text);
 }
 function dedupe(parts) {

package/dist-lib/lib/web-fetch/extract.js

@@ -25,16 +25,18 @@ export function extractPageText(html) {
 }
 function extractTitle(html) {
     const match = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
-    if (!match?.[1])
+    if (!match?.[1]) {
         return null;
+    }
     const title = decodeHtmlEntities(stripHtmlTags(match[1])).replace(/\s+/g, ' ').trim();
     return title.length > 0 ? title : null;
 }
 function pickMainRegion(html) {
     for (const tag of ['main', 'article']) {
         const match = new RegExp(`<${tag}[\\s>][\\s\\S]*?</${tag}>`, 'i').exec(html);
-        if (match)
+        if (match) {
             return match[0];
+        }
     }
     return html;
 }

package/dist-lib/lib/web-fetch/images.js

@@ -9,11 +9,13 @@ export function pageImageUrls(html, pageUrl) {
         if (out.length >= MAX_PAGE_IMAGES)
             break;
         const tag = match[0];
-        if (!IMAGE_ATTR.test(tag))
+        if (!IMAGE_ATTR.test(tag)) {
             continue;
+        }
         const content = META_CONTENT.exec(tag)?.[1];
-        if (!content)
+        if (!content) {
             continue;
+        }
         let resolved;
         try {
             resolved = new URL(decodeHtmlEntities(content).trim(), pageUrl);
@@ -21,8 +23,9 @@ export function pageImageUrls(html, pageUrl) {
         catch {
             continue;
         }
-        if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:')
+        if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:') {
             continue;
+        }
         const href = resolved.toString();
         if (!out.some((seen) => seen.replace(/^https?:/, '') === href.replace(/^https?:/, ''))) {
             out.push(href);
@@ -36,8 +39,9 @@ export function imageFileName(url, mimeType) {
         last = decodeURIComponent(last);
     }
     catch { }
-    if (/\.(png|jpe?g|gif|webp|avif)$/i.test(last))
+    if (/\.(png|jpe?g|gif|webp|avif)$/i.test(last)) {
         return last;
+    }
     const ext = mimeType.split('/')[1]?.split('+')[0] ?? 'img';
     return `${url.hostname}.${ext}`;
 }

package/dist-lib/lib/web-fetch/video.d.ts

@@ -1,5 +1,5 @@
-export type PageVideoRef = {
+export interface PageVideoRef {
     readonly provider: string;
     readonly url: string;
-};
+}
 export declare function pageVideoRef(html: string, pageUrl: URL): PageVideoRef | null;

package/dist-lib/lib/web-fetch/video.js

@@ -6,11 +6,13 @@ const YOUTUBE_HOSTS = new Set(['youtube.com', 'youtube-nocookie.com', 'youtu.be'
 export function pageVideoRef(html, pageUrl) {
     for (const match of html.matchAll(META_TAG)) {
         const tag = match[0];
-        if (!VIDEO_ATTR.test(tag))
+        if (!VIDEO_ATTR.test(tag)) {
             continue;
+        }
         const content = META_CONTENT.exec(tag)?.[1];
-        if (!content)
+        if (!content) {
             continue;
+        }
         let resolved;
         try {
             resolved = new URL(decodeHtmlEntities(content).trim(), pageUrl);
@@ -18,8 +20,9 @@ export function pageVideoRef(html, pageUrl) {
         catch {
             continue;
         }
-        if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:')
+        if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:') {
             continue;
+        }
         return classify(resolved);
     }
     return null;
@@ -36,7 +39,8 @@ function classify(url) {
 }
 function watchUrl(url) {
     const embed = /^\/embed\/([\w-]+)/.exec(url.pathname);
-    if (!embed)
+    if (!embed) {
         return url.toString();
+    }
     return `https://www.youtube.com/watch?v=${embed[1]}`;
 }

package/dist-lib/lib/web-search/engine-registry.d.ts

@@ -1,7 +1,7 @@
 import type { SearchEngine } from './types.ts';
-export type EngineEntry = {
+export interface EngineEntry {
     readonly name: string;
     readonly fn: SearchEngine;
-};
+}
 export declare const DEFAULT_MAX_RESULTS = 8;
 export declare const ENGINES: ReadonlyArray<EngineEntry>;

package/dist-lib/lib/web-search/engines/aol.js

@@ -72,7 +72,7 @@ function parseRuFallback(html) {
 }
 export async function searchAol(query, fetcher, signal) {
     const url = `https://search.aol.com/aol/search?q=${encodeURIComponent(query)}`;
-    const html = await fetchHtml(fetcher, url, undefined, signal);
+    const html = await fetchHtml(fetcher, url, { signal });
     const primary = parseAlgoBlocks(html);
     if (primary.length > 0) {
         return primary;

package/dist-lib/lib/web-search/engines/bing.js

@@ -99,7 +99,7 @@ function parseH2Fallback(html) {
 }
 export async function searchBing(query, fetcher, signal) {
     const url = `https://www.bing.com/search?q=${encodeURIComponent(query)}`;
-    const html = await fetchHtml(fetcher, url, { headers: { 'User-Agent': SAFARI_UA } }, signal);
+    const html = await fetchHtml(fetcher, url, { headers: { 'User-Agent': SAFARI_UA }, signal });
     if (html.includes('captcha') || html.includes('challenge/verify') || html.includes('Turnstile')) {
         throw new Error('Bing CAPTCHA detected');
     }

package/dist-lib/lib/web-search/engines/brave.js

@@ -50,7 +50,10 @@ function parseLinkFallback(html) {
 }
 export async function searchBrave(query, fetcher, signal) {
     const url = `https://search.brave.com/search?q=${encodeURIComponent(query)}&source=web`;
-    const html = await fetchHtml(fetcher, url, { cookies: { safesearch: 'off', useLocation: '0', summarizer: '0', country: 'us' } }, signal);
+    const html = await fetchHtml(fetcher, url, {
+        cookies: { safesearch: 'off', useLocation: '0', summarizer: '0', country: 'us' },
+        signal
+    });
     const primary = parseSnippetBlocks(html);
     if (primary.length > 0) {
         return primary;

package/dist-lib/lib/web-search/engines/duckduckgo.js

@@ -98,8 +98,9 @@ export async function searchDuckDuckGo(query, fetcher, signal) {
             'Content-Type': 'application/x-www-form-urlencoded',
             Referer: 'https://html.duckduckgo.com/'
         },
-        body
-    }, signal);
+        body,
+        signal
+    });
     const primary = parseLinksMain(html);
     if (primary.length > 0) {
         return primary;

package/dist-lib/lib/web-search/engines/google.js

@@ -25,7 +25,7 @@ function extractTitle(anchorBody) {
     const titleMatch = anchorBody.match(/<(?:div|h3)[^>]*>([\s\S]*?)<\/(?:div|h3)>/i);
     return titleMatch ? clean(titleMatch[1] || '') : clean(anchorBody);
 }
-function parseAnchor(am, html, snippetPat, existing) {
+function parseAnchor(am, { html, snippetPat, existing }) {
     const rawUrl = resolveGoogleUrl(am[1] || '');
     if (isSkippableUrl(rawUrl) || !rawUrl.startsWith('http')) {
         return null;
@@ -45,7 +45,7 @@ function parseDataVedAnchors(html) {
     const snippetPat = /<div[^>]*class="[^"]*VwiC3b[^"]*"[^>]*>([\s\S]*?)<\/div>/gi;
     const anchorPat = /<a[^>]*\shref="(\/url\?q=[^"]+|https?:\/\/[^"]+)"[^>]*data-ved="[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
     for (const am of html.matchAll(anchorPat)) {
-        const parsed = parseAnchor(am, html, snippetPat, results);
+        const parsed = parseAnchor(am, { html, snippetPat, existing: results });
         if (parsed) {
             results.push({ ...parsed, position: results.length + 1 });
         }
@@ -80,7 +80,11 @@ function parseH3Fallback(html) {
 }
 export async function searchGoogle(query, fetcher, signal) {
     const url = `https://www.google.com/search?q=${encodeURIComponent(query)}&hl=en&ie=utf8&oe=utf8&filter=0`;
-    const html = await fetchHtml(fetcher, url, { headers: { 'User-Agent': GOOGLE_GSA_UA, Accept: '*/*' }, cookies: { CONSENT: 'YES+' } }, signal);
+    const html = await fetchHtml(fetcher, url, {
+        headers: { 'User-Agent': GOOGLE_GSA_UA, Accept: '*/*' },
+        cookies: { CONSENT: 'YES+' },
+        signal
+    });
     if (html.includes('detected unusual traffic') || html.includes('g-recaptcha')) {
         throw new Error('Google CAPTCHA detected');
     }

package/dist-lib/lib/web-search/engines/wikipedia.js

@@ -4,11 +4,11 @@ function extractSearchItems(data) {
     if (typeof data !== 'object' || data === null) {
         return [];
     }
-    const query = data.query;
+    const query = 'query' in data ? data.query : undefined;
     if (typeof query !== 'object' || query === null) {
         return [];
     }
-    const search = query.search;
+    const search = 'search' in query ? query.search : undefined;
     if (!Array.isArray(search)) {
         return [];
     }
@@ -17,7 +17,8 @@ function extractSearchItems(data) {
         if (typeof entry !== 'object' || entry === null) {
             continue;
         }
-        const { title, snippet } = entry;
+        const title = 'title' in entry ? entry.title : undefined;
+        const snippet = 'snippet' in entry ? entry.snippet : undefined;
         if (typeof title === 'string' && typeof snippet === 'string') {
             items.push({ title, snippet });
         }
@@ -26,7 +27,7 @@ function extractSearchItems(data) {
 }
 export async function searchWikipedia(query, fetcher, signal) {
     const apiUrl = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json&srlimit=5&utf8=1`;
-    const data = await fetchJson(fetcher, apiUrl, undefined, signal);
+    const data = await fetchJson(fetcher, apiUrl, { signal });
     const items = extractSearchItems(data);
     return items.map((item, idx) => ({
         title: item.title,

package/dist-lib/lib/web-search/engines/yahoo.js

@@ -72,7 +72,7 @@ function parseRuFallback(html) {
 }
 export async function searchYahoo(query, fetcher, signal) {
     const url = `https://search.yahoo.com/search?p=${encodeURIComponent(query)}`;
-    const html = await fetchHtml(fetcher, url, undefined, signal);
+    const html = await fetchHtml(fetcher, url, { signal });
     const primary = parseAlgoBlocks(html);
     if (primary.length > 0) {
         return primary;

package/dist-lib/lib/web-search/fetch-html.d.ts

@@ -8,18 +8,19 @@ export declare class TimeoutError extends Error {
 export declare class AbortError extends Error {
     constructor();
 }
-type FetchOptions = {
+interface FetchOptions {
     readonly method?: string;
     readonly headers?: Readonly<Record<string, string>>;
     readonly body?: string;
     readonly cookies?: Readonly<Record<string, string>>;
     readonly accept?: string;
     readonly timeoutMs?: number;
-};
-export declare function fetchHtml(fetcher: Fetcher, url: string, options?: FetchOptions, signal?: BareAbortSignal): Promise<string>;
+    readonly signal?: BareAbortSignal;
+}
+export declare function fetchHtml(fetcher: Fetcher, url: string, options?: FetchOptions): Promise<string>;
 export declare class JsonParseError extends Error {
     readonly cause?: unknown;
     constructor(message: string, cause?: unknown);
 }
-export declare function fetchJson(fetcher: Fetcher, url: string, options?: FetchOptions, signal?: BareAbortSignal): Promise<unknown>;
+export declare function fetchJson(fetcher: Fetcher, url: string, options?: FetchOptions): Promise<unknown>;
 export {};