@j0hanz/superfetch 2.6.0 → 2.7.0

package/dist/cache.js

@@ -102,9 +102,12 @@ class InMemoryCacheStore {
         if (!this.isEnabled())
             return [];
         const now = Date.now();
-        return Array.from(this.entries.entries())
-            .filter(([, entry]) => entry.expiresAtMs > now)
-            .map(([key]) => key);
+        const result = [];
+        for (const [key, entry] of this.entries) {
+            if (entry.expiresAtMs > now)
+                result.push(key);
+        }
+        return result;
     }
     onUpdate(listener) {
         const wrapped = (event) => {
@@ -131,7 +134,8 @@ class InMemoryCacheStore {
         const entry = this.entries.get(cacheKey);
         if (!entry)
             return undefined;
-        if (entry.expiresAtMs <= Date.now()) {
+        const now = Date.now();
+        if (entry.expiresAtMs <= now) {
             this.entries.delete(cacheKey);
             return undefined;
         }
@@ -157,12 +161,11 @@ class InMemoryCacheStore {
         };
         this.entries.delete(cacheKey);
         this.entries.set(cacheKey, entry);
-        // Eviction
+        // Eviction (LRU: first insertion-order key)
         if (this.entries.size > this.max) {
             const firstKey = this.entries.keys().next();
-            if (!firstKey.done) {
+            if (!firstKey.done)
                 this.entries.delete(firstKey.value);
-            }
         }
         this.notify(cacheKey);
     }
@@ -170,9 +173,9 @@ class InMemoryCacheStore {
         if (this.updateEmitter.listenerCount('update') === 0)
             return;
         const parts = parseCacheKey(cacheKey);
-        if (parts) {
-            this.updateEmitter.emit('update', { cacheKey, ...parts });
-        }
+        if (!parts)
+            return;
+        this.updateEmitter.emit('update', { cacheKey, ...parts });
     }
     logError(message, cacheKey, error) {
         logWarn(message, {
@@ -231,7 +234,6 @@ function resolveCachedMarkdownText(raw) {
     return raw;
 }
 export function registerCachedContentResource(server, serverIcons) {
-    // Resource Registration
     server.registerResource('cached-content', new ResourceTemplate('superfetch://cache/{namespace}/{urlHash}', {
         list: listCachedResources,
     }), {
@@ -288,7 +290,7 @@ export function registerCachedContentResource(server, serverIcons) {
     store.onUpdate(({ cacheKey }) => {
         if (!server.isConnected() || !initialized)
             return;
-        // Check capabilities via unsafe cast or helper (SDK limitation)
+        // Check capabilities via unsafe cast (SDK limitation)
         const capabilities = server.server.getClientCapabilities();
         const uri = toResourceUri(cacheKey);
         if (capabilities?.resources?.subscribe && uri && subscriptions.has(uri)) {

package/dist/config.js

@@ -3,16 +3,19 @@ import { findPackageJSON } from 'node:module';
 import { isIP } from 'node:net';
 import process from 'node:process';
 import { domainToASCII } from 'node:url';
-const packageJsonPath = findPackageJSON(import.meta.url);
-if (!packageJsonPath) {
-    throw new Error('package.json not found');
-}
-const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-if (typeof packageJson.version !== 'string') {
-    throw new Error('package.json version is missing');
+function readServerVersion(moduleUrl) {
+    const packageJsonPath = findPackageJSON(moduleUrl);
+    if (!packageJsonPath)
+        throw new Error('package.json not found');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    if (typeof packageJson.version !== 'string') {
+        throw new Error('package.json version is missing');
+    }
+    return packageJson.version;
 }
-export const serverVersion = packageJson.version;
+export const serverVersion = readServerVersion(import.meta.url);
 const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+const ALLOWED_LOG_LEVELS = new Set(LOG_LEVELS);
 const DEFAULT_HEADING_KEYWORDS = [
     'overview',
     'introduction',
@@ -34,6 +37,9 @@ const DEFAULT_HEADING_KEYWORDS = [
     'acknowledgments',
     'appendix',
 ];
+class ConfigError extends Error {
+    name = 'ConfigError';
+}
 function isMissingEnvFileError(error) {
     if (!error || typeof error !== 'object')
         return false;
@@ -54,23 +60,20 @@ function loadEnvFileIfAvailable() {
 }
 loadEnvFileIfAvailable();
 const { env } = process;
-class ConfigError extends Error {
-    name = 'ConfigError';
-}
 function buildIpv4(parts) {
     return parts.join('.');
 }
-function formatHostForUrl(hostname) {
-    if (hostname.includes(':') && !hostname.startsWith('['))
-        return `[${hostname}]`;
-    return hostname;
-}
 function stripTrailingDots(value) {
     let result = value;
     while (result.endsWith('.'))
         result = result.slice(0, -1);
     return result;
 }
+function formatHostForUrl(hostname) {
+    if (hostname.includes(':') && !hostname.startsWith('['))
+        return `[${hostname}]`;
+    return hostname;
+}
 function normalizeHostname(value) {
     const trimmed = value.trim();
     if (!trimmed)
@@ -86,24 +89,29 @@ function normalizeHostValue(value) {
     const raw = value.trim();
     if (!raw)
         return null;
+    // Full URL
     if (raw.includes('://')) {
         if (!URL.canParse(raw))
             return null;
         return normalizeHostname(new URL(raw).hostname);
     }
+    // host[:port]
     const candidateUrl = `http://${raw}`;
     if (URL.canParse(candidateUrl)) {
         return normalizeHostname(new URL(candidateUrl).hostname);
     }
     const lowered = raw.toLowerCase();
+    // [::1]:port
     if (lowered.startsWith('[')) {
         const end = lowered.indexOf(']');
         if (end === -1)
             return null;
         return normalizeHostname(lowered.slice(1, end));
     }
+    // Bare IPv6
     if (isIP(lowered) === 6)
         return stripTrailingDots(lowered);
+    // Split host:port (single colon only)
     const firstColon = lowered.indexOf(':');
     if (firstColon === -1)
         return normalizeHostname(lowered);
@@ -159,27 +167,6 @@ function normalizeLocale(value) {
         return undefined;
     return trimmed;
 }
-function parseUrlEnv(value, name) {
-    if (!value)
-        return undefined;
-    if (!URL.canParse(value)) {
-        throw new ConfigError(`Invalid ${name} value: ${value}`);
-    }
-    return new URL(value);
-}
-function readUrlEnv(name) {
-    return parseUrlEnv(env[name], name);
-}
-function parseAllowedHosts(envValue) {
-    const hosts = new Set();
-    for (const entry of parseList(envValue)) {
-        const normalized = normalizeHostValue(entry);
-        if (normalized)
-            hosts.add(normalized);
-    }
-    return hosts;
-}
-const ALLOWED_LOG_LEVELS = new Set(LOG_LEVELS);
 function isLogLevel(value) {
     return ALLOWED_LOG_LEVELS.has(value);
 }
@@ -202,6 +189,26 @@ function parsePort(envValue) {
         return 0;
     return parseInteger(envValue, 3000, 1024, 65535);
 }
+function parseUrlEnv(value, name) {
+    if (!value)
+        return undefined;
+    if (!URL.canParse(value)) {
+        throw new ConfigError(`Invalid ${name} value: ${value}`);
+    }
+    return new URL(value);
+}
+function readUrlEnv(name) {
+    return parseUrlEnv(env[name], name);
+}
+function parseAllowedHosts(envValue) {
+    const hosts = new Set();
+    for (const entry of parseList(envValue)) {
+        const normalized = normalizeHostValue(entry);
+        if (normalized)
+            hosts.add(normalized);
+    }
+    return hosts;
+}
 const MAX_HTML_BYTES = 10 * 1024 * 1024; // 10 MB
 const MAX_INLINE_CONTENT_CHARS = 0;
 const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000;
@@ -216,23 +223,28 @@ const DEFAULT_TOOL_TIMEOUT_MS = DEFAULT_FETCH_TIMEOUT_MS +
     DEFAULT_TOOL_TIMEOUT_PADDING_MS;
 function resolveWorkerResourceLimits() {
     const limits = {};
+    let hasAny = false;
     const maxOldGenerationSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_MAX_OLD_GENERATION_MB, 1);
     const maxYoungGenerationSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_MAX_YOUNG_GENERATION_MB, 1);
     const codeRangeSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_CODE_RANGE_MB, 1);
     const stackSizeMb = parseOptionalInteger(env.TRANSFORM_WORKER_STACK_MB, 1);
     if (maxOldGenerationSizeMb !== undefined) {
         limits.maxOldGenerationSizeMb = maxOldGenerationSizeMb;
+        hasAny = true;
     }
     if (maxYoungGenerationSizeMb !== undefined) {
         limits.maxYoungGenerationSizeMb = maxYoungGenerationSizeMb;
+        hasAny = true;
     }
     if (codeRangeSizeMb !== undefined) {
         limits.codeRangeSizeMb = codeRangeSizeMb;
+        hasAny = true;
     }
     if (stackSizeMb !== undefined) {
         limits.stackSizeMb = stackSizeMb;
+        hasAny = true;
     }
-    return Object.keys(limits).length > 0 ? limits : undefined;
+    return hasAny ? limits : undefined;
 }
 function readOAuthUrls(baseUrl) {
     const issuerUrl = readUrlEnv('OAUTH_ISSUER_URL');
@@ -318,8 +330,8 @@ const host = (env.HOST ?? LOOPBACK_V4).trim();
 const port = parsePort(env.PORT);
 const maxConnections = parseInteger(env.SERVER_MAX_CONNECTIONS, 0, 0);
 const blockPrivateConnections = parseBoolean(env.SERVER_BLOCK_PRIVATE_CONNECTIONS, false);
-const baseUrl = new URL(`http://${formatHostForUrl(host)}:${port}`);
 const allowRemote = parseBoolean(env.ALLOW_REMOTE, false);
+const baseUrl = new URL(`http://${formatHostForUrl(host)}:${port}`);
 const runtimeState = {
     httpMode: false,
 };

package/dist/dom-noise-removal.js

@@ -8,6 +8,7 @@ const DIALOG_MIN_CHARS_FOR_PRESERVATION = 500;
 const NAV_FOOTER_MIN_CHARS_FOR_PRESERVATION = 500;
 // Merged markers for fast rejection
 const HTML_DOCUMENT_MARKERS = /<\s*(?:!doctype|html|head|body)\b/i;
+const HTML_FRAGMENT_MARKERS = /<\s*(?:article|main|section|div|nav|footer|header|aside|table|ul|ol)\b/i;
 // Split into smaller regexes to stay within sonarjs/regex-complexity limit
 const NOISE_PATTERNS = [
     /<\s*(?:script|style|noscript|iframe|nav|footer|header|form|button|input|select|textarea|svg|canvas)\b/i,
@@ -451,7 +452,9 @@ function mayContainNoise(html) {
     return NOISE_PATTERNS.some((re) => re.test(sample));
 }
 export function removeNoiseFromHtml(html, document, baseUrl) {
-    const shouldParse = isFullDocumentHtml(html) || mayContainNoise(html);
+    const shouldParse = isFullDocumentHtml(html) ||
+        mayContainNoise(html) ||
+        HTML_FRAGMENT_MARKERS.test(html);
     if (!shouldParse)
         return html;
     try {

package/dist/fetch.d.ts

@@ -42,4 +42,5 @@ export declare function fetchNormalizedUrl(normalizedUrl: string, options?: Fetc
 export declare function fetchNormalizedUrlBuffer(normalizedUrl: string, options?: FetchOptions): Promise<{
     buffer: Uint8Array;
     encoding: string;
+    truncated: boolean;
 }>;

package/dist/fetch.js

@@ -4,7 +4,9 @@ import diagnosticsChannel from 'node:diagnostics_channel';
 import dns from 'node:dns';
 import { isIP } from 'node:net';
 import { performance } from 'node:perf_hooks';
-import { Readable } from 'node:stream';
+import { PassThrough, Readable, Transform } from 'node:stream';
+import { buffer as consumeBuffer } from 'node:stream/consumers';
+import { finished, pipeline } from 'node:stream/promises';
 import { setTimeout as delay } from 'node:timers/promises';
 import { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib';
 import { config } from './config.js';
@@ -64,10 +66,13 @@ class UrlNormalizer {
         if (trimmedUrl.length > this.constants.maxUrlLength) {
             throw createValidationError(`URL exceeds maximum length of ${this.constants.maxUrlLength} characters`);
         }
-        if (!URL.canParse(trimmedUrl)) {
+        let url;
+        try {
+            url = new URL(trimmedUrl);
+        }
+        catch {
             throw createValidationError('Invalid URL format');
         }
-        const url = new URL(trimmedUrl);
         if (url.protocol !== 'http:' && url.protocol !== 'https:') {
             throw createValidationError(`Invalid protocol: ${url.protocol}. Only http: and https: are allowed`);
         }
@@ -767,6 +772,11 @@ function cancelResponseBody(response) {
         return;
     void cancelPromise.catch(() => undefined);
 }
+class MaxBytesError extends Error {
+    constructor() {
+        super('max-bytes-reached');
+    }
+}
 class RedirectFollower {
     fetchFn;
     normalizeUrl;
@@ -821,10 +831,13 @@ class RedirectFollower {
         throw createMissingRedirectLocationFetchError(currentUrl);
     }
     resolveRedirectTarget(baseUrl, location) {
-        if (!URL.canParse(location, baseUrl)) {
+        let resolved;
+        try {
+            resolved = new URL(location, baseUrl);
+        }
+        catch {
             throw createErrorWithCode('Invalid redirect target', 'EBADREDIRECT');
         }
-        const resolved = new URL(location, baseUrl);
         if (resolved.username || resolved.password) {
             throw createErrorWithCode('Redirect target includes credentials', 'EBADREDIRECT');
         }
@@ -868,6 +881,9 @@ function createDecoder(encoding) {
         return new TextDecoder('utf-8');
     }
 }
+function decodeBuffer(buffer, encoding) {
+    return createDecoder(encoding).decode(buffer);
+}
 function normalizeEncodingLabel(encoding) {
     return encoding?.trim().toLowerCase() ?? '';
 }
@@ -1006,102 +1022,136 @@ function isBinaryContent(buffer, encoding) {
 }
 class ResponseTextReader {
     async read(response, url, maxBytes, signal, encoding) {
-        const { buffer, encoding: effectiveEncoding } = await this.readBuffer(response, url, maxBytes, signal, encoding);
-        const decoder = createDecoder(effectiveEncoding);
-        const text = decoder.decode(buffer);
-        return { text, size: buffer.byteLength };
+        const { buffer, encoding: effectiveEncoding, truncated, } = await this.readBuffer(response, url, maxBytes, signal, encoding);
+        const text = decodeBuffer(buffer, effectiveEncoding);
+        return { text, size: buffer.byteLength, truncated };
     }
     async readBuffer(response, url, maxBytes, signal, encoding) {
         if (signal?.aborted) {
             cancelResponseBody(response);
             throw createAbortedFetchError(url);
         }
-        const limit = maxBytes <= 0 ? Number.POSITIVE_INFINITY : maxBytes;
         if (!response.body) {
-            if (signal?.aborted)
-                throw createCanceledFetchError(url);
-            const arrayBuffer = await response.arrayBuffer();
-            const length = Math.min(arrayBuffer.byteLength, limit);
-            const buffer = new Uint8Array(arrayBuffer, 0, length);
-            const effectiveEncoding = resolveEncoding(encoding, buffer) ?? encoding ?? 'utf-8';
-            if (isBinaryContent(buffer, effectiveEncoding)) {
-                throw new FetchError('Detailed content type check failed: binary content detected', url, 500, { reason: 'binary_content_detected' });
-            }
-            return { buffer, encoding: effectiveEncoding, size: buffer.byteLength };
+            return this.readNonStreamBuffer(response, url, maxBytes, signal, encoding);
         }
-        return this.readStreamToBuffer(response.body, url, limit, signal, encoding);
+        return this.readStreamToBuffer(response.body, url, maxBytes, signal, encoding);
     }
-    async readNext(reader, abortPromise) {
-        return abortPromise
-            ? await Promise.race([reader.read(), abortPromise])
-            : await reader.read();
+    async readNonStreamBuffer(response, url, maxBytes, signal, encoding) {
+        if (signal?.aborted)
+            throw createCanceledFetchError(url);
+        const limit = maxBytes <= 0 ? Number.POSITIVE_INFINITY : maxBytes;
+        const contentLengthHeader = response.headers.get('content-length');
+        if (contentLengthHeader && Number.isFinite(limit)) {
+            const declared = Number.parseInt(contentLengthHeader, 10);
+            if (!Number.isNaN(declared) && declared > limit) {
+                throw new FetchError(`Response exceeds maximum size (${limit} bytes)`, url, 413, {
+                    reason: 'max_content_length',
+                    contentLength: declared,
+                    maxBytes: limit,
+                });
+            }
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const length = Math.min(arrayBuffer.byteLength, limit);
+        const buffer = new Uint8Array(arrayBuffer, 0, length);
+        const effectiveEncoding = resolveEncoding(encoding, buffer) ?? encoding ?? 'utf-8';
+        if (isBinaryContent(buffer, effectiveEncoding)) {
+            throw new FetchError('Detailed content type check failed: binary content detected', url, 500, { reason: 'binary_content_detected' });
+        }
+        const truncated = Number.isFinite(limit)
+            ? arrayBuffer.byteLength > limit
+            : false;
+        return {
+            buffer,
+            encoding: effectiveEncoding,
+            size: buffer.byteLength,
+            truncated,
+        };
     }
     async readStreamToBuffer(stream, url, maxBytes, signal, encoding) {
-        let effectiveEncoding = encoding;
-        let decoder = null;
-        const chunks = [];
+        const byteLimit = maxBytes <= 0 ? Number.POSITIVE_INFINITY : maxBytes;
+        const captureChunks = byteLimit !== Number.POSITIVE_INFINITY;
+        let effectiveEncoding = encoding ?? 'utf-8';
+        let checkedBinary = false;
         let total = 0;
-        const reader = stream.getReader();
-        const abortRace = createAbortRace(signal, () => createAbortedFetchError(url));
-        try {
-            let result = await this.readNext(reader, abortRace.abortPromise);
-            if (!result.done) {
-                effectiveEncoding =
-                    resolveEncoding(encoding, result.value) ?? encoding ?? 'utf-8';
-                decoder = createDecoder(effectiveEncoding);
-            }
-            let checkedBinary = false;
-            while (!result.done) {
-                const chunk = result.value;
-                if (!checkedBinary) {
-                    checkedBinary = true;
-                    if (isBinaryContent(chunk, decoder?.encoding)) {
-                        await this.cancelReaderQuietly(reader);
-                        throw new FetchError('Detailed content type check failed: binary content detected', url, 500, { reason: 'binary_content_detected' });
+        const chunks = [];
+        const source = Readable.fromWeb(stream);
+        const guard = new Transform({
+            transform(chunk, _encoding, callback) {
+                try {
+                    const buf = Buffer.isBuffer(chunk)
+                        ? chunk
+                        : Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+                    if (!checkedBinary) {
+                        checkedBinary = true;
+                        effectiveEncoding =
+                            resolveEncoding(encoding, buf) ?? encoding ?? 'utf-8';
+                        if (isBinaryContent(buf, effectiveEncoding)) {
+                            callback(new FetchError('Detailed content type check failed: binary content detected', url, 500, { reason: 'binary_content_detected' }));
+                            return;
+                        }
                     }
-                }
-                const newTotal = total + chunk.length;
-                if (newTotal > maxBytes) {
-                    const remaining = maxBytes - total;
-                    if (remaining > 0) {
-                        chunks.push(chunk.subarray(0, remaining));
-                        total += remaining;
+                    const newTotal = total + buf.length;
+                    if (newTotal > byteLimit) {
+                        const remaining = byteLimit - total;
+                        if (remaining > 0) {
+                            const slice = buf.subarray(0, remaining);
+                            total += remaining;
+                            if (captureChunks)
+                                chunks.push(slice);
+                            this.push(slice);
+                        }
+                        callback(new MaxBytesError());
+                        return;
                     }
-                    await this.cancelReaderQuietly(reader);
-                    break;
+                    total = newTotal;
+                    if (captureChunks)
+                        chunks.push(buf);
+                    callback(null, buf);
                 }
-                chunks.push(chunk);
-                total = newTotal;
-                result = await this.readNext(reader, abortRace.abortPromise);
-            }
-        }
-        catch (error) {
-            await this.cancelReaderQuietly(reader);
-            this.handleReadingError(error, url, signal);
+                catch (error) {
+                    callback(error instanceof Error ? error : new Error(String(error)));
+                }
+            },
+        });
+        const guarded = source.pipe(guard);
+        const abortHandler = () => {
+            source.destroy();
+            guard.destroy();
+        };
+        if (signal) {
+            signal.addEventListener('abort', abortHandler, { once: true });
         }
-        finally {
-            abortRace.cleanup();
-            reader.releaseLock();
+        try {
+            const buffer = await consumeBuffer(guarded);
+            return {
+                buffer,
+                encoding: effectiveEncoding,
+                size: total,
+                truncated: false,
+            };
         }
-        return {
-            buffer: Buffer.concat(chunks, total),
-            encoding: effectiveEncoding ?? 'utf-8',
-            size: total,
-        };
-    }
-    handleReadingError(error, url, signal) {
-        if (error instanceof FetchError)
+        catch (error) {
+            if (signal?.aborted)
+                throw createAbortedFetchError(url);
+            if (error instanceof FetchError)
+                throw error;
+            if (error instanceof MaxBytesError) {
+                source.destroy();
+                guard.destroy();
+                return {
+                    buffer: Buffer.concat(chunks, total),
+                    encoding: effectiveEncoding,
+                    size: total,
+                    truncated: true,
+                };
+            }
             throw error;
-        if (signal?.aborted)
-            throw createAbortedFetchError(url);
-        throw error;
-    }
-    async cancelReaderQuietly(reader) {
-        try {
-            await reader.cancel();
         }
-        catch {
-            // Ignore cancellation failures; stream teardown must proceed.
+        finally {
+            if (signal) {
+                signal.removeEventListener('abort', abortHandler);
+            }
         }
     }
 }
@@ -1169,8 +1219,12 @@ function isTextLikeMediaType(mediaType) {
 }
 function assertSupportedContentType(contentType, url) {
     const mediaType = resolveMediaType(contentType);
-    if (!mediaType)
+    if (!mediaType) {
+        logDebug('No Content-Type header; relying on binary-content detection', {
+            url: redactUrl(url),
+        });
         return;
+    }
     if (!isTextLikeMediaType(mediaType)) {
         throw new FetchError(`Unsupported content type: ${mediaType}`, url);
     }
@@ -1327,7 +1381,8 @@ async function decodeResponseIfNeeded(response, url, signal) {
         throw createUnsupportedContentEncodingError(url, encodingHeader ?? encoding);
     }
     const sourceStream = Readable.fromWeb(createPumpedStream(initialChunk, reader));
-    const decodedNodeStream = sourceStream.pipe(decompressor);
+    const decodedNodeStream = new PassThrough();
+    const pipelinePromise = pipeline(sourceStream, decompressor, decodedNodeStream);
     const abortHandler = () => {
         sourceStream.destroy();
         decompressor.destroy();
@@ -1336,15 +1391,15 @@ async function decodeResponseIfNeeded(response, url, signal) {
     if (signal) {
         signal.addEventListener('abort', abortHandler, { once: true });
     }
+    void pipelinePromise.catch((error) => {
+        decodedNodeStream.destroy(error instanceof Error ? error : new Error(String(error)));
+    });
     const decodedBody = Readable.toWeb(decodedNodeStream);
     const headers = new Headers(response.headers);
     headers.delete('content-encoding');
     headers.delete('content-length');
     if (signal) {
-        decodedNodeStream.once('close', () => {
-            signal.removeEventListener('abort', abortHandler);
-        });
-        decodedNodeStream.once('error', () => {
+        void finished(decodedNodeStream, { cleanup: true }).finally(() => {
             signal.removeEventListener('abort', abortHandler);
         });
     }
@@ -1365,19 +1420,21 @@ async function readAndRecordDecodedResponse(response, finalUrl, ctx, telemetry,
     assertSupportedContentType(contentType, finalUrl);
     const declaredEncoding = getCharsetFromContentType(contentType ?? null);
     if (mode === 'text') {
-        const { text, size } = await reader.read(decodedResponse, finalUrl, maxBytes, signal, declaredEncoding);
+        const { text, size, truncated } = await reader.read(decodedResponse, finalUrl, maxBytes, signal, declaredEncoding);
         telemetry.recordResponse(ctx, decodedResponse, size);
-        return { kind: 'text', text, size };
+        return { kind: 'text', text, size, truncated };
     }
-    const { buffer, encoding, size } = await reader.readBuffer(decodedResponse, finalUrl, maxBytes, signal, declaredEncoding);
+    const { buffer, encoding, size, truncated } = await reader.readBuffer(decodedResponse, finalUrl, maxBytes, signal, declaredEncoding);
     telemetry.recordResponse(ctx, decodedResponse, size);
-    return { kind: 'buffer', buffer, encoding, size };
+    return { kind: 'buffer', buffer, encoding, size, truncated };
 }
 function extractHostname(url) {
-    if (!URL.canParse(url)) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
         throw createErrorWithCode('Invalid URL', 'EINVAL');
     }
-    return new URL(url).hostname;
 }
 function createDnsPreflight(dnsResolver) {
     return async (url, signal) => {
@@ -1418,7 +1475,11 @@ class HttpFetcher {
             const payload = await readAndRecordDecodedResponse(response, finalUrl, ctx, this.telemetry, this.reader, this.fetcherConfig.maxContentLength, mode, init.signal ?? undefined);
             if (payload.kind === 'text')
                 return payload.text;
-            return { buffer: payload.buffer, encoding: payload.encoding };
+            return {
+                buffer: payload.buffer,
+                encoding: payload.encoding,
+                truncated: payload.truncated,
+            };
         }
         catch (error) {
             const mapped = mapFetchError(error, normalizedUrl, timeoutMs);
@@ -1468,11 +1529,13 @@ export async function fetchWithRedirects(url, init, maxRedirects) {
 }
 export async function readResponseText(response, url, maxBytes, signal, encoding) {
     const decodedResponse = await decodeResponseIfNeeded(response, url, signal);
-    return responseReader.read(decodedResponse, url, maxBytes, signal, encoding);
+    const { text, size } = await responseReader.read(decodedResponse, url, maxBytes, signal, encoding);
+    return { text, size };
 }
 export async function readResponseBuffer(response, url, maxBytes, signal, encoding) {
     const decodedResponse = await decodeResponseIfNeeded(response, url, signal);
-    return responseReader.readBuffer(decodedResponse, url, maxBytes, signal, encoding);
+    const { buffer, encoding: resolvedEncoding, size, } = await responseReader.readBuffer(decodedResponse, url, maxBytes, signal, encoding);
+    return { buffer, encoding: resolvedEncoding, size };
 }
 export async function fetchNormalizedUrl(normalizedUrl, options) {
     return httpFetcher.fetchNormalizedUrl(normalizedUrl, options);