@mjasnikovs/pi-task 0.38.15 → 0.38.16

package/dist/task/task-gates.js

@@ -319,12 +319,31 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                 fixInstruction
             });
             active = fixRes.ctx ?? active;
-            if (fixRes.sessionCancelled)
+            // The re-run's ending, mapped to this loop's own terminal kinds. A
+            // CANCEL lands on `interrupted` — the user stopped it, so the task is
+            // left resumable rather than reported as a fault.
+            if (fixRes.end.kind === 'no-session') {
                 return { stop: { kind: 'session-cancelled', ctx: active } };
-            if (fixRes.interrupted)
+            }
+            // A CANCEL and an ESC-interrupt are NOT the same ending. Folding them
+            // together sent a cancelled re-run down the `interrupted` row, which
+            // demotes the task file — writing `failed` over the `cancelled` the
+            // cancel itself wrote.
+            if (fixRes.end.kind === 'cancelled') {
+                return { stop: { kind: 'cancelled', ctx: active } };
+            }
+            if (fixRes.end.kind === 'interrupted') {
                 return { stop: { kind: 'interrupted', ctx: active } };
-            if (!fixRes.ok)
-                return { stop: { kind: 'failed', ctx: active, reason: fixRes.reason } };
+            }
+            if (fixRes.end.kind === 'failed') {
+                return {
+                    stop: {
+                        kind: 'failed',
+                        ctx: active,
+                        ...(fixRes.end.reason === undefined ? {} : { reason: fixRes.end.reason })
+                    }
+                };
+            }
             // Resume reuses the same inner task id, so p.taskId is stable.
             verified = await deps.verify(active, p.cwd, p.title, p.taskId);
             await rec(verdictLine(verified));

package/dist/task/terminal-outcome.d.ts

@@ -25,7 +25,7 @@
  * overrides, which is not a simplification.
  */
 /** The gate outcomes a command has to act on. Mirrors runGatesForTask's union. */
-export type TerminalOutcomeKind = 'done' | 'paused' | 'session-cancelled' | 'interrupted' | 'failed';
+export type TerminalOutcomeKind = 'done' | 'paused' | 'session-cancelled' | 'cancelled' | 'interrupted' | 'failed';
 /** What the message needs to name. */
 export interface TerminalMessageContext {
     /** The task or run id shown to the user (`TASK_0007`, `AUTO_0002`, `Task`). */

package/dist/task/terminal-outcome.js

@@ -59,6 +59,18 @@ export const TERMINAL_OUTCOMES = {
         message: c => `${c.tag} paused — could not start a session for autofix. `
             + `Run ${c.resumeCmd} to retry.`
     },
+    cancelled: {
+        // The USER stopped the re-run. The task file already says `cancelled`, and
+        // `markResumable` writes `failed` — that both lies in the ledger and turns
+        // a deliberate stop into a red error. RUN_END_POLICY states this for the
+        // first implementation run; this row states the same thing for a re-run.
+        markResumable: false,
+        failParent: false,
+        level: 'warning',
+        // `cancelled` is already in RESUMABLE_STATES, so the file needs no demotion
+        // AND the resume works — naming it costs nothing and is true.
+        message: c => `${c.tag} cancelled${c.at} — resume with ${c.resumeCmd}.`
+    },
     interrupted: {
         markResumable: true,
         // NOT a failure: the user stopped it. The parent run stays in_progress so

package/dist/workers/brave-search.d.ts

@@ -1,3 +1,4 @@
+import { type FetchLike } from './http-request.js';
 import type { SearchResult } from './search-types.js';
 export type BraveResult = SearchResult;
 export interface BraveSearchOpts {
@@ -5,6 +6,12 @@ export interface BraveSearchOpts {
     count?: number;
     timeoutMs?: number;
     signal?: AbortSignal;
+    /**
+     * Injectable fetch. Brave was the ONE provider without this: exa and ddg both
+     * took a `fetchImpl`, so brave's status ladder — the widest of the three — was
+     * the only one no test could drive at the request level.
+     */
+    fetchImpl?: FetchLike;
 }
 export declare class BraveSearchError extends Error {
     readonly kind: 'auth' | 'rate-limit' | 'http' | 'network' | 'aborted';

package/dist/workers/brave-search.js

@@ -1,3 +1,4 @@
+import { httpRequest, HttpRequestError } from './http-request.js';
 const BRAVE_ENDPOINT = 'https://api.search.brave.com/res/v1/web/search';
 const DEFAULT_COUNT = 10;
 const MAX_COUNT = 20;
@@ -14,64 +15,44 @@ export class BraveSearchError extends Error {
 }
 export async function braveSearch(query, opts) {
     const count = Math.max(1, Math.min(MAX_COUNT, opts.count ?? DEFAULT_COUNT));
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const url = `${BRAVE_ENDPOINT}?q=${encodeURIComponent(query)}&count=${count}`;
-    const internalController = new AbortController();
-    let userAborted = false;
-    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
-    const onUserAbort = () => {
-        userAborted = true;
-        internalController.abort();
-    };
-    if (opts.signal) {
-        if (opts.signal.aborted)
-            onUserAbort();
-        else
-            opts.signal.addEventListener('abort', onUserAbort, { once: true });
-    }
     try {
-        let response;
-        try {
-            response = await fetch(url, {
-                method: 'GET',
-                headers: {
-                    accept: 'application/json',
-                    'x-subscription-token': opts.apiKey
-                },
-                signal: internalController.signal
-            });
-        }
-        catch (err) {
-            if (userAborted) {
-                throw new BraveSearchError('Search aborted.', 'aborted');
+        return await httpRequest(url, {
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            ...(opts.signal === undefined ? {} : { signal: opts.signal }),
+            ...(opts.fetchImpl === undefined ? {} : { fetchImpl: opts.fetchImpl }),
+            method: 'GET',
+            headers: {
+                accept: 'application/json',
+                'x-subscription-token': opts.apiKey
             }
-            throw new BraveSearchError(`Brave Search request failed: ${describeError(err)}`, 'network');
-        }
-        if (response.status === 401 || response.status === 403) {
-            throw new BraveSearchError(`Brave Search rejected the key (HTTP ${response.status}). Check BRAVE_SEARCH_API_KEY.`, 'auth', response.status);
-        }
-        if (response.status === 429) {
-            throw new BraveSearchError('Brave Search rate limit hit (HTTP 429). Try again in a moment.', 'rate-limit', 429);
-        }
-        if (!response.ok) {
-            throw new BraveSearchError(`Brave Search HTTP ${response.status} ${response.statusText}`, 'http', response.status);
-        }
-        const body = (await response.json());
-        const rawResults = body.web?.results ?? [];
-        return rawResults
-            .filter((r) => typeof r.title === 'string'
-            && typeof r.url === 'string'
-            && typeof r.description === 'string')
-            .map(r => ({ title: r.title, url: r.url, description: r.description }));
+        }, async (response) => {
+            // Brave's own status policy: a rejected key and a rate limit are
+            // different problems for the user, and neither is a plain HTTP fault.
+            if (response.status === 401 || response.status === 403) {
+                throw new BraveSearchError(`Brave Search rejected the key (HTTP ${response.status}). Check BRAVE_SEARCH_API_KEY.`, 'auth', response.status);
+            }
+            if (response.status === 429) {
+                throw new BraveSearchError('Brave Search rate limit hit (HTTP 429). Try again in a moment.', 'rate-limit', 429);
+            }
+            if (!response.ok) {
+                throw new BraveSearchError(`Brave Search HTTP ${response.status} ${response.statusText}`, 'http', response.status);
+            }
+            const body = (await response.json());
+            const rawResults = body.web?.results ?? [];
+            return rawResults
+                .filter((r) => typeof r.title === 'string'
+                && typeof r.url === 'string'
+                && typeof r.description === 'string')
+                .map(r => ({ title: r.title, url: r.url, description: r.description }));
+        });
     }
-    finally {
-        clearTimeout(timeoutHandle);
-        if (opts.signal)
-            opts.signal.removeEventListener('abort', onUserAbort);
+    catch (err) {
+        if (err instanceof HttpRequestError) {
+            throw err.kind === 'aborted' ?
+                new BraveSearchError('Search aborted.', 'aborted')
+                : new BraveSearchError(`Brave Search request failed: ${err.detail}`, 'network');
+        }
+        throw err;
     }
 }
-function describeError(err) {
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}

package/dist/workers/ddg-search.d.ts

@@ -7,7 +7,7 @@
  * get the destination URL. Ad rows redirect through duckduckgo.com itself and
  * are dropped.
  */
-import type { FetchLike } from './exa-search.js';
+import { type FetchLike } from './http-request.js';
 import type { SearchResult } from './search-types.js';
 export interface DdgSearchOpts {
     count?: number;

package/dist/workers/ddg-search.js

@@ -8,6 +8,7 @@
  * are dropped.
  */
 import { parseHTML } from 'linkedom';
+import { httpRequest, HttpRequestError } from './http-request.js';
 const DDG_ENDPOINT = 'https://html.duckduckgo.com/html/';
 const DEFAULT_COUNT = 10;
 const MAX_COUNT = 20;
@@ -26,51 +27,35 @@ export class DdgSearchError extends Error {
 }
 export async function ddgSearch(query, opts = {}) {
     const count = Math.max(1, Math.min(MAX_COUNT, opts.count ?? DEFAULT_COUNT));
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const fetchImpl = opts.fetchImpl ?? fetch;
     const url = `${DDG_ENDPOINT}?q=${encodeURIComponent(query)}`;
-    const internalController = new AbortController();
-    let userAborted = false;
-    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
-    const onUserAbort = () => {
-        userAborted = true;
-        internalController.abort();
-    };
-    if (opts.signal) {
-        if (opts.signal.aborted)
-            onUserAbort();
-        else
-            opts.signal.addEventListener('abort', onUserAbort, { once: true });
-    }
     try {
-        let response;
-        try {
-            response = await fetchImpl(url, {
-                method: 'GET',
-                headers: {
-                    'user-agent': USER_AGENT,
-                    accept: 'text/html'
-                },
-                signal: internalController.signal
-            });
-        }
-        catch (err) {
-            if (userAborted)
-                throw new DdgSearchError('Search aborted.', 'aborted');
-            throw new DdgSearchError(`DuckDuckGo request failed: ${describeError(err)}`, 'network');
-        }
-        if (response.status === 429 || response.status === 403) {
-            throw new DdgSearchError(`DuckDuckGo is rate-limiting this client (HTTP ${response.status}). Try again in a moment.`, 'rate-limit', response.status);
-        }
-        if (!response.ok) {
-            throw new DdgSearchError(`DuckDuckGo HTTP ${response.status} ${response.statusText}`, 'http', response.status);
-        }
-        return parseDdgHtml(await response.text()).slice(0, count);
+        return await httpRequest(url, {
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            ...(opts.signal === undefined ? {} : { signal: opts.signal }),
+            ...(opts.fetchImpl === undefined ? {} : { fetchImpl: opts.fetchImpl }),
+            method: 'GET',
+            headers: {
+                'user-agent': USER_AGENT,
+                accept: 'text/html'
+            }
+        }, async (response) => {
+            // DDG's own status policy: 429/403 is throttling, not a plain HTTP fault.
+            if (response.status === 429 || response.status === 403) {
+                throw new DdgSearchError(`DuckDuckGo is rate-limiting this client (HTTP ${response.status}). Try again in a moment.`, 'rate-limit', response.status);
+            }
+            if (!response.ok) {
+                throw new DdgSearchError(`DuckDuckGo HTTP ${response.status} ${response.statusText}`, 'http', response.status);
+            }
+            return parseDdgHtml(await response.text()).slice(0, count);
+        });
     }
-    finally {
-        clearTimeout(timeoutHandle);
-        if (opts.signal)
-            opts.signal.removeEventListener('abort', onUserAbort);
+    catch (err) {
+        if (err instanceof HttpRequestError) {
+            throw err.kind === 'aborted' ?
+                new DdgSearchError('Search aborted.', 'aborted')
+                : new DdgSearchError(`DuckDuckGo request failed: ${err.detail}`, 'network');
+        }
+        throw err;
     }
 }
 export function parseDdgHtml(html) {
@@ -123,8 +108,3 @@ function unwrapDdgRedirect(href) {
 function collapse(text) {
     return text.replace(/\s+/g, ' ').trim();
 }
-function describeError(err) {
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}

package/dist/workers/exa-search.d.ts

@@ -7,9 +7,9 @@
  * and the result payload is one text blob of `Title:`/`URL:`/`Text:` blocks
  * separated by `---`, which we parse back into structured results.
  */
+import { type FetchLike } from './http-request.js';
 import type { SearchResult } from './search-types.js';
-/** Injectable fetch — the narrow signature keeps test fakes free of Bun's extras. */
-export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+export type { FetchLike };
 export interface ExaSearchOpts {
     count?: number;
     timeoutMs?: number;

package/dist/workers/exa-search.js

@@ -7,6 +7,7 @@
  * and the result payload is one text blob of `Title:`/`URL:`/`Text:` blocks
  * separated by `---`, which we parse back into structured results.
  */
+import { httpRequest, HttpRequestError } from './http-request.js';
 const EXA_MCP_ENDPOINT = 'https://mcp.exa.ai/mcp';
 const DEFAULT_COUNT = 10;
 const MAX_COUNT = 20;
@@ -24,72 +25,61 @@ export class ExaSearchError extends Error {
 }
 export async function exaSearch(query, opts = {}) {
     const count = Math.max(1, Math.min(MAX_COUNT, opts.count ?? DEFAULT_COUNT));
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const fetchImpl = opts.fetchImpl ?? fetch;
-    const internalController = new AbortController();
-    let userAborted = false;
-    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
-    const onUserAbort = () => {
-        userAborted = true;
-        internalController.abort();
-    };
-    if (opts.signal) {
-        if (opts.signal.aborted)
-            onUserAbort();
-        else
-            opts.signal.addEventListener('abort', onUserAbort, { once: true });
-    }
+    return await request({
+        timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        ...(opts.signal === undefined ? {} : { signal: opts.signal }),
+        ...(opts.fetchImpl === undefined ? {} : { fetchImpl: opts.fetchImpl })
+    }, count, query);
+}
+/** The Exa-specific half: its argv, its status policy, its error type. */
+async function request(bounds, count, query) {
     try {
-        let response;
-        try {
-            response = await fetchImpl(EXA_MCP_ENDPOINT, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json',
-                    accept: 'application/json, text/event-stream'
-                },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 1,
-                    method: 'tools/call',
-                    params: {
-                        name: 'web_search_exa',
-                        arguments: {
-                            query,
-                            numResults: count,
-                            type: 'auto',
-                            livecrawl: 'fallback',
-                            contextMaxCharacters: 3000
-                        }
+        return await httpRequest(EXA_MCP_ENDPOINT, {
+            ...bounds,
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json, text/event-stream'
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'web_search_exa',
+                    arguments: {
+                        query,
+                        numResults: count,
+                        type: 'auto',
+                        livecrawl: 'fallback',
+                        contextMaxCharacters: 3000
                     }
-                }),
-                signal: internalController.signal
-            });
-        }
-        catch (err) {
-            if (userAborted)
-                throw new ExaSearchError('Search aborted.', 'aborted');
-            throw new ExaSearchError(`Exa search request failed: ${describeError(err)}`, 'network');
-        }
-        if (!response.ok) {
-            throw new ExaSearchError(`Exa search HTTP ${response.status} ${response.statusText}`, 'http', response.status);
-        }
-        const rpc = parseRpcBody(await response.text());
-        if (rpc.error) {
-            throw new ExaSearchError(`Exa MCP error${rpc.error.code !== undefined ? ` ${rpc.error.code}` : ''}: ${rpc.error.message ?? 'unknown error'}`, 'protocol');
-        }
-        const text = rpc.result?.content?.find(c => c.type === 'text' && typeof c.text === 'string' && c.text.trim().length > 0)?.text;
-        if (rpc.result?.isError) {
-            throw new ExaSearchError(text?.trim() || 'Exa MCP returned an error result.', 'protocol');
-        }
-        if (!text)
-            throw new ExaSearchError('Exa MCP returned no text content.', 'protocol');
-        return parseResultBlocks(text).slice(0, count);
+                }
+            })
+        }, async (response) => {
+            if (!response.ok) {
+                throw new ExaSearchError(`Exa search HTTP ${response.status} ${response.statusText}`, 'http', response.status);
+            }
+            const rpc = parseRpcBody(await response.text());
+            if (rpc.error) {
+                throw new ExaSearchError(`Exa MCP error${rpc.error.code !== undefined ? ` ${rpc.error.code}` : ''}: ${rpc.error.message ?? 'unknown error'}`, 'protocol');
+            }
+            const text = rpc.result?.content?.find(c => c.type === 'text' && typeof c.text === 'string' && c.text.trim().length > 0)?.text;
+            if (rpc.result?.isError) {
+                throw new ExaSearchError(text?.trim() || 'Exa MCP returned an error result.', 'protocol');
+            }
+            if (!text)
+                throw new ExaSearchError('Exa MCP returned no text content.', 'protocol');
+            return parseResultBlocks(text).slice(0, count);
+        });
     }
-    finally {
-        clearTimeout(timeoutHandle);
-        if (opts.signal)
-            opts.signal.removeEventListener('abort', onUserAbort);
+    catch (err) {
+        if (err instanceof HttpRequestError) {
+            throw err.kind === 'aborted' ?
+                new ExaSearchError('Search aborted.', 'aborted')
+                : new ExaSearchError(`Exa search request failed: ${err.detail}`, 'network');
+        }
+        throw err;
     }
 }
 /**
@@ -157,8 +147,3 @@ function parseResultBlocks(text) {
     }
     return results;
 }
-function describeError(err) {
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}

package/dist/workers/html-clean.js

@@ -2,6 +2,7 @@ import { parseHTML } from 'linkedom';
 import { Readability } from '@mozilla/readability';
 import TurndownService from 'turndown';
 import { readPkgVersion } from '../shared/pkg-version.js';
+import { httpRequest, HttpRequestError, describeError } from './http-request.js';
 const turndown = new TurndownService({
     codeBlockStyle: 'fenced',
     headingStyle: 'atx',
@@ -86,100 +87,83 @@ export class FetchAndCleanError extends Error {
     }
 }
 export async function fetchAndClean(url, opts = {}) {
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
-    const internalController = new AbortController();
     let sizeExceeded = false;
-    let userAborted = false;
-    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
-    const onUserAbort = () => {
-        userAborted = true;
-        internalController.abort();
-    };
-    if (opts.signal) {
-        if (opts.signal.aborted)
-            onUserAbort();
-        else
-            opts.signal.addEventListener('abort', onUserAbort, { once: true });
-    }
     try {
-        let response;
-        try {
-            response = await fetch(url, {
-                headers: { 'user-agent': USER_AGENT },
-                redirect: 'follow',
-                signal: internalController.signal
-            });
-        }
-        catch (err) {
-            if (userAborted) {
-                throw new FetchAndCleanError('Fetch aborted.', 'aborted', err);
+        return await httpRequest(url, {
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            ...(opts.signal === undefined ? {} : { signal: opts.signal }),
+            headers: { 'user-agent': USER_AGENT },
+            redirect: 'follow'
+        }, async (response, ctl) => {
+            if (!response.ok) {
+                throw new FetchAndCleanError(`Fetch failed: HTTP ${response.status} ${response.statusText} for ${url}`, 'http-error');
             }
-            throw new FetchAndCleanError(`Could not fetch ${url}: ${describeError(err)}`, 'network', err);
-        }
-        if (!response.ok) {
-            throw new FetchAndCleanError(`Fetch failed: HTTP ${response.status} ${response.statusText} for ${url}`, 'http-error');
-        }
-        const contentType = response.headers.get('content-type') ?? '';
-        const kind = classifyContentType(contentType);
-        if (kind === 'reject') {
-            throw new FetchAndCleanError(`${url} is ${contentType || 'unknown content type'}, not a text or HTML page that pi-worker-fetch can read.`, 'not-html');
-        }
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new FetchAndCleanError(`Could not fetch ${url}: empty response body`, 'network');
-        }
-        const decoder = decoderFor(contentType);
-        let text = '';
-        let bytesRead = 0;
-        try {
-            while (true) {
-                // response.body's stream type doesn't resolve here, so the chunk
-                // surfaces as `any`; pin it to the Uint8Array the reader yields.
-                const { value, done } = (await reader.read());
-                if (done)
-                    break;
-                if (value) {
-                    bytesRead += value.byteLength;
-                    if (bytesRead > maxBytes) {
-                        sizeExceeded = true;
-                        internalController.abort();
+            const contentType = response.headers.get('content-type') ?? '';
+            const kind = classifyContentType(contentType);
+            if (kind === 'reject') {
+                throw new FetchAndCleanError(`${url} is ${contentType || 'unknown content type'}, not a text or HTML page that pi-worker-fetch can read.`, 'not-html');
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new FetchAndCleanError(`Could not fetch ${url}: empty response body`, 'network');
+            }
+            const decoder = decoderFor(contentType);
+            let text = '';
+            let bytesRead = 0;
+            try {
+                while (true) {
+                    // response.body's stream type doesn't resolve here, so the chunk
+                    // surfaces as `any`; pin it to the Uint8Array the reader yields.
+                    const { value, done } = (await reader.read());
+                    if (done)
                         break;
+                    if (value) {
+                        bytesRead += value.byteLength;
+                        if (bytesRead > maxBytes) {
+                            // OUR abort, told apart from the user's and the clock's
+                            // by the seam — all three abort the same signal.
+                            sizeExceeded = true;
+                            ctl.abort();
+                            break;
+                        }
+                        text += decoder.decode(value, { stream: true });
                     }
-                    text += decoder.decode(value, { stream: true });
                 }
+                text += decoder.decode();
             }
-            text += decoder.decode();
-        }
-        catch (err) {
-            if (sizeExceeded) {
-                // fall through to throw outside the catch
-            }
-            else if (userAborted) {
-                throw new FetchAndCleanError('Fetch aborted.', 'aborted', err);
+            catch (err) {
+                if (sizeExceeded) {
+                    // fall through to throw outside the catch
+                }
+                else if (ctl.userAborted()) {
+                    throw new FetchAndCleanError('Fetch aborted.', 'aborted', err);
+                }
+                else {
+                    throw new FetchAndCleanError(`Could not fetch ${url}: ${describeError(err)}`, 'network', err);
+                }
             }
-            else {
-                throw new FetchAndCleanError(`Could not fetch ${url}: ${describeError(err)}`, 'network', err);
+            if (sizeExceeded) {
+                throw new FetchAndCleanError(`${url} exceeds ${formatBytes(maxBytes)} size cap. Try a more specific URL.`, 'too-large');
             }
-        }
-        if (sizeExceeded) {
-            throw new FetchAndCleanError(`${url} exceeds ${formatBytes(maxBytes)} size cap. Try a more specific URL.`, 'too-large');
-        }
-        const finalUrl = response.url || url;
-        if (kind === 'html') {
-            return cleanHtml(text, finalUrl);
-        }
-        // text-ish formats are already clean — return them verbatim.
-        return {
-            title: hostnameOf(finalUrl),
-            markdown: text.trim(),
-            finalUrl
-        };
+            const finalUrl = response.url || url;
+            if (kind === 'html')
+                return cleanHtml(text, finalUrl);
+            // text-ish formats are already clean — return them verbatim.
+            return {
+                title: hostnameOf(finalUrl),
+                markdown: text.trim(),
+                finalUrl
+            };
+        });
     }
-    finally {
-        clearTimeout(timeoutHandle);
-        if (opts.signal)
-            opts.signal.removeEventListener('abort', onUserAbort);
+    catch (err) {
+        if (err instanceof HttpRequestError) {
+            throw err.kind === 'aborted' ?
+                new FetchAndCleanError('Fetch aborted.', 'aborted', err.cause)
+                : new FetchAndCleanError(`Could not fetch ${url}: ${err.detail}`, 'network', err.cause);
+        }
+        throw err;
     }
 }
 function hostnameOf(url) {
@@ -190,11 +174,6 @@ function hostnameOf(url) {
         return url;
     }
 }
-function describeError(err) {
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}
 function formatBytes(n) {
     if (n >= 1024 * 1024)
         return `${(n / 1024 / 1024).toFixed(1)} MB`;