@gjsify/fetch 0.1.15 → 0.3.0

package/lib/xhr.d.ts

@@ -0,0 +1,62 @@
+export declare const UNSENT = 0;
+export declare const OPENED = 1;
+export declare const HEADERS_RECEIVED = 2;
+export declare const LOADING = 3;
+export declare const DONE = 4;
+type EventHandler = ((event: ProgressEvent) => void) | null;
+export declare class XMLHttpRequest extends EventTarget {
+    static UNSENT: number;
+    static OPENED: number;
+    static HEADERS_RECEIVED: number;
+    static LOADING: number;
+    static DONE: number;
+    readonly UNSENT = 0;
+    readonly OPENED = 1;
+    readonly HEADERS_RECEIVED = 2;
+    readonly LOADING = 3;
+    readonly DONE = 4;
+    readyState: number;
+    status: number;
+    statusText: string;
+    responseType: string;
+    responseText: string;
+    response: unknown;
+    responseURL: string;
+    withCredentials: boolean;
+    timeout: number;
+    upload: XMLHttpRequestUpload;
+    onreadystatechange: ((event: Event) => void) | null;
+    onload: EventHandler;
+    onerror: EventHandler;
+    onabort: EventHandler;
+    ontimeout: EventHandler;
+    onloadstart: EventHandler;
+    onloadend: EventHandler;
+    onprogress: EventHandler;
+    private _method;
+    private _url;
+    private _headers;
+    private _responseHeaders;
+    private _controller;
+    private _aborted;
+    private _timeoutId;
+    open(method: string, url: string, _async?: boolean, _user?: string | null, _password?: string | null): void;
+    setRequestHeader(header: string, value: string): void;
+    getResponseHeader(header: string): string | null;
+    getAllResponseHeaders(): string;
+    send(body?: Document | XMLHttpRequestBodyInit | null): void;
+    abort(): void;
+    overrideMimeType(_mime: string): void;
+    private _onTimeout;
+    private _setReadyState;
+}
+export declare class XMLHttpRequestUpload extends EventTarget {
+    onprogress: EventHandler;
+    onloadstart: EventHandler;
+    onloadend: EventHandler;
+    onload: EventHandler;
+    onerror: EventHandler;
+    onabort: EventHandler;
+    ontimeout: EventHandler;
+}
+export {};

package/lib/xhr.js

@@ -0,0 +1,278 @@
+// XMLHttpRequest — fetch()-backed XHR for GJS.
+// Covers engine.io-client (polling XHR) and Excalibur.js (ImageSource/Sound)
+// use cases. For `responseType === 'blob'` the bytes are written to a GLib
+// temp file and the returned Blob carries a `_tmpPath` that
+// `URL.createObjectURL` turns into a `file://` URL, so that HTMLImageElement
+// / Image / HTMLAudioElement can stream the asset through GdkPixbuf / Gst.
+//
+// Reference: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
+import GLib from 'gi://GLib?version=2.0';
+import fetch from './index.js';
+let _blobCounter = 0;
+function guessBlobExt(url) {
+    const lower = url.toLowerCase().split('?')[0];
+    const dot = lower.lastIndexOf('.');
+    const ext = dot > -1 ? lower.slice(dot) : '';
+    // Restrict to a small safe allow-list; unknown → .bin
+    switch (ext) {
+        case '.png':
+        case '.jpg':
+        case '.jpeg':
+        case '.gif':
+        case '.webp':
+        case '.svg':
+        case '.bmp':
+        case '.ttf':
+        case '.otf':
+        case '.woff':
+        case '.woff2':
+        case '.mp3':
+        case '.wav':
+        case '.ogg':
+        case '.flac':
+        case '.m4a':
+        case '.mp4':
+        case '.webm':
+        case '.mkv':
+        case '.xml':
+        case '.tmx':
+        case '.json':
+            return ext;
+        default:
+            return '.bin';
+    }
+}
+function writeBlobToTempFile(bytes, url) {
+    const tmpPath = GLib.build_filenamev([
+        GLib.get_tmp_dir(),
+        `gjsify-blob-${_blobCounter++}${guessBlobExt(url)}`,
+    ]);
+    GLib.file_set_contents(tmpPath, bytes);
+    return tmpPath;
+}
+export const UNSENT = 0;
+export const OPENED = 1;
+export const HEADERS_RECEIVED = 2;
+export const LOADING = 3;
+export const DONE = 4;
+export class XMLHttpRequest extends EventTarget {
+    static UNSENT = UNSENT;
+    static OPENED = OPENED;
+    static HEADERS_RECEIVED = HEADERS_RECEIVED;
+    static LOADING = LOADING;
+    static DONE = DONE;
+    UNSENT = UNSENT;
+    OPENED = OPENED;
+    HEADERS_RECEIVED = HEADERS_RECEIVED;
+    LOADING = LOADING;
+    DONE = DONE;
+    readyState = UNSENT;
+    status = 0;
+    statusText = '';
+    responseType = '';
+    responseText = '';
+    response = null;
+    responseURL = '';
+    withCredentials = false;
+    timeout = 0;
+    upload = new XMLHttpRequestUpload();
+    onreadystatechange = null;
+    onload = null;
+    onerror = null;
+    onabort = null;
+    ontimeout = null;
+    onloadstart = null;
+    onloadend = null;
+    onprogress = null;
+    _method = 'GET';
+    _url = '';
+    _headers = new Map();
+    _responseHeaders = new Map();
+    _controller = new AbortController();
+    _aborted = false;
+    _timeoutId = null;
+    open(method, url, _async = true, _user, _password) {
+        this._method = method.toUpperCase();
+        this._url = url;
+        this._headers.clear();
+        this._responseHeaders.clear();
+        this._aborted = false;
+        this._controller = new AbortController();
+        this._setReadyState(OPENED);
+    }
+    setRequestHeader(header, value) {
+        if (this.readyState < OPENED)
+            throw new DOMException('Must open first', 'InvalidStateError');
+        this._headers.set(header.toLowerCase(), value);
+    }
+    getResponseHeader(header) {
+        return this._responseHeaders.get(header.toLowerCase()) ?? null;
+    }
+    getAllResponseHeaders() {
+        const lines = [];
+        this._responseHeaders.forEach((v, k) => lines.push(`${k}: ${v}`));
+        return lines.join('\r\n');
+    }
+    send(body) {
+        if (this.readyState !== OPENED)
+            throw new DOMException('Must open first', 'InvalidStateError');
+        if (this._aborted)
+            return;
+        const headersInit = {};
+        this._headers.forEach((v, k) => { headersInit[k] = v; });
+        const fetchOptions = {
+            method: this._method,
+            headers: headersInit,
+            credentials: this.withCredentials ? 'include' : 'omit',
+            signal: this._controller.signal,
+        };
+        if (body != null && this._method !== 'GET' && this._method !== 'HEAD') {
+            fetchOptions.body = body;
+        }
+        if (this.timeout > 0) {
+            this._timeoutId = setTimeout(() => {
+                this._controller.abort();
+                this._onTimeout();
+            }, this.timeout);
+        }
+        this.dispatchEvent(new Event('loadstart'));
+        if (this.onloadstart)
+            this.onloadstart(new ProgressEvent('loadstart'));
+        fetch(this._url, fetchOptions)
+            .then(async (res) => {
+            if (this._aborted)
+                return;
+            if (this._timeoutId) {
+                clearTimeout(this._timeoutId);
+                this._timeoutId = null;
+            }
+            this.status = res.status;
+            this.statusText = res.statusText;
+            this.responseURL = res.url;
+            res.headers.forEach((v, k) => {
+                this._responseHeaders.set(k.toLowerCase(), v);
+            });
+            this._setReadyState(HEADERS_RECEIVED);
+            this._setReadyState(LOADING);
+            switch (this.responseType) {
+                case 'arraybuffer': {
+                    const ab = await res.arrayBuffer();
+                    this.response = ab;
+                    this.responseText = '';
+                    break;
+                }
+                case 'blob': {
+                    // Materialise the body to a GLib temp file so URL.createObjectURL
+                    // can hand Image / Audio / Font consumers a loadable `file://` URL.
+                    const ab = await res.arrayBuffer();
+                    const bytes = new Uint8Array(ab);
+                    const tmpPath = writeBlobToTempFile(bytes, this._url);
+                    const blob = new Blob([ab], {
+                        type: this._responseHeaders.get('content-type') ?? '',
+                    });
+                    blob._tmpPath = tmpPath;
+                    this.response = blob;
+                    this.responseText = '';
+                    break;
+                }
+                case 'json': {
+                    const text = await res.text();
+                    this.responseText = '';
+                    try {
+                        this.response = text.length > 0 ? JSON.parse(text) : null;
+                    }
+                    catch {
+                        this.response = null;
+                    }
+                    break;
+                }
+                case 'document': {
+                    const text = await res.text();
+                    this.responseText = text;
+                    this.response = text;
+                    break;
+                }
+                case '':
+                case 'text':
+                default: {
+                    const text = await res.text();
+                    // Strip UTF-8 BOM (U+FEFF) — browsers do this automatically; required
+                    // for JSON.parse to succeed on BOM-prefixed JSON responses.
+                    const stripped = text.charCodeAt(0) === 0xFEFF ? text.slice(1) : text;
+                    this.responseText = stripped;
+                    this.response = stripped;
+                    break;
+                }
+            }
+            this._setReadyState(DONE);
+            this.dispatchEvent(new ProgressEvent('load'));
+            this.dispatchEvent(new ProgressEvent('loadend'));
+            if (this.onload)
+                this.onload(new ProgressEvent('load'));
+            if (this.onloadend)
+                this.onloadend(new ProgressEvent('loadend'));
+        })
+            .catch((_err) => {
+            if (this._timeoutId) {
+                clearTimeout(this._timeoutId);
+                this._timeoutId = null;
+            }
+            if (this._aborted)
+                return;
+            this._setReadyState(DONE);
+            const ev = new ProgressEvent('error');
+            this.dispatchEvent(ev);
+            if (this.onerror)
+                this.onerror(ev);
+            if (this.onloadend)
+                this.onloadend(new ProgressEvent('loadend'));
+        });
+    }
+    abort() {
+        if (this._aborted)
+            return;
+        this._aborted = true;
+        if (this._timeoutId) {
+            clearTimeout(this._timeoutId);
+            this._timeoutId = null;
+        }
+        this._controller.abort();
+        if (this.readyState !== UNSENT && this.readyState !== DONE) {
+            this._setReadyState(DONE);
+            this.status = 0;
+        }
+        const ev = new ProgressEvent('abort');
+        this.dispatchEvent(ev);
+        if (this.onabort)
+            this.onabort(ev);
+        if (this.onloadend)
+            this.onloadend(new ProgressEvent('loadend'));
+    }
+    overrideMimeType(_mime) { }
+    _onTimeout() {
+        if (this._aborted)
+            return;
+        this._aborted = true;
+        this._setReadyState(DONE);
+        const ev = new ProgressEvent('timeout');
+        this.dispatchEvent(ev);
+        if (this.ontimeout)
+            this.ontimeout(ev);
+    }
+    _setReadyState(state) {
+        this.readyState = state;
+        const ev = new Event('readystatechange');
+        this.dispatchEvent(ev);
+        if (this.onreadystatechange)
+            this.onreadystatechange(ev);
+    }
+}
+export class XMLHttpRequestUpload extends EventTarget {
+    onprogress = null;
+    onloadstart = null;
+    onloadend = null;
+    onload = null;
+    onerror = null;
+    onabort = null;
+    ontimeout = null;
+}

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "@gjsify/fetch",
-  "version": "0.1.15",
+  "version": "0.3.0",
   "description": "Web and Node.js fetch module for Gjs",
   "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.ts",
+  "types": "lib/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./lib/types/index.d.ts",
+      "types": "./lib/index.d.ts",
       "default": "./lib/esm/index.js"
     },
     "./register": {
-      "types": "./lib/types/register.d.ts",
+      "types": "./lib/register.d.ts",
       "default": "./lib/esm/register.js"
     },
     "./register/fetch": {
       "default": "./lib/esm/register/fetch.js"
     },
-    "./globals": "./globals.mjs"
+    "./register/xhr": {
+      "default": "./lib/esm/register/xhr.js"
+    }
   },
   "sideEffects": [
     "./lib/esm/register.js",
-    "./lib/esm/register/*.js",
-    "./globals.mjs"
+    "./lib/esm/register/*.js"
   ],
   "scripts": {
     "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
@@ -32,9 +33,10 @@
     "build:types": "tsc",
     "build:test": "yarn build:test:gjs && yarn build:test:node",
     "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:browser": "gjsify build src/test.browser.mts --app browser --outfile dist/test.browser.mjs",
     "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
     "test": "yarn build:gjsify && yarn build:test:node && yarn test:node",
-    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:gjs": "gjsify run test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
   "keywords": [
@@ -43,19 +45,19 @@
     "fetch"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.1.15",
-    "@gjsify/unit": "^0.1.15",
+    "@gjsify/cli": "^0.3.0",
+    "@gjsify/unit": "^0.3.0",
     "@types/node": "^25.6.0",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@girs/gio-2.0": "^2.88.0-4.0.0-rc.3",
-    "@girs/gjs": "^4.0.0-rc.3",
-    "@girs/glib-2.0": "^2.88.0-4.0.0-rc.3",
-    "@girs/soup-3.0": "^3.6.6-4.0.0-rc.3",
-    "@gjsify/formdata": "^0.1.15",
-    "@gjsify/http": "^0.1.15",
-    "@gjsify/url": "^0.1.15",
-    "@gjsify/utils": "^0.1.15"
+    "@girs/gio-2.0": "^2.88.0-4.0.0-rc.9",
+    "@girs/gjs": "^4.0.0-rc.9",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-rc.9",
+    "@girs/soup-3.0": "^3.6.6-4.0.0-rc.9",
+    "@gjsify/formdata": "^0.3.0",
+    "@gjsify/http": "^0.3.0",
+    "@gjsify/url": "^0.3.0",
+    "@gjsify/utils": "^0.3.0"
   }
 }

package/src/body.ts

@@ -137,19 +137,31 @@ export default class Body {
 
         // If ReadableStream is available, wrap the Readable into one
         if (typeof ReadableStream !== 'undefined') {
+            let closed = false;
             return new ReadableStream<Uint8Array>({
                 start(controller) {
                     stream.on('data', (chunk: Buffer | Uint8Array) => {
-                        controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+                        if (closed) return;
+                        try {
+                            controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+                        } catch { /* consumer cancelled — drop */ }
                     });
                     stream.on('end', () => {
-                        controller.close();
+                        if (closed) return;
+                        closed = true;
+                        // Defensive: consumer may have cancelled the stream already,
+                        // in which case .close() throws TypeError. Don't surface that
+                        // as an unhandled error in the nextTick queue.
+                        try { controller.close(); } catch { /* already closed/cancelled */ }
                     });
                     stream.on('error', (err: Error) => {
-                        controller.error(err);
+                        if (closed) return;
+                        closed = true;
+                        try { controller.error(err); } catch { /* already closed/cancelled */ }
                     });
                 },
                 cancel() {
+                    closed = true;
                     stream.destroy();
                 }
             });
@@ -162,6 +174,15 @@ export default class Body {
         return this[INTERNALS].stream;
     }
 
+    /** Return the raw body buffer without consuming the stream (used by Request._send). */
+    get _rawBodyBuffer(): Buffer | null {
+        const b = this[INTERNALS].body;
+        if (b === null) return null;
+        if (Buffer.isBuffer(b)) return b;
+        if (b instanceof Uint8Array) return Buffer.from(b.buffer, b.byteOffset, b.byteLength);
+        return null;
+    }
+
     get bodyUsed() {
         return this[INTERNALS].disturbed;
     }

package/src/index.spec.ts

@@ -1,6 +1,10 @@
 import { describe, it, expect, on } from '@gjsify/unit';
 
-import fetch, { Headers, Request, Response, FormData } from 'fetch';
+// fetch / Headers / Request / Response / FormData are accessed off globalThis:
+// on Node they are native, on GJS they are installed by
+// `@gjsify/fetch/register` (pulled in automatically by `--globals auto`).
+// XMLHttpRequest is GJS-only and is likewise read from globalThis inside an
+// on('Gjs', …) gate further below.
 
 export default async () => {
 
@@ -171,9 +175,14 @@ export default async () => {
 			expect(clone.headers.get('x-test')).toBe('value');
 		});
 
-		await it('should create request with null body', async () => {
-			const r = new Request('https://example.com', { body: null });
-			expect(r.body).toBeNull();
+		// Firefox returns a non-null body for new Request(url, { body: null }) — likely
+		// an empty ReadableStream — contrary to the spec (body: null → r.body === null).
+		// Guard to Node.js + GJS where spec-correct behavior is verified.
+		await on(['Node.js', 'Gjs'], async () => {
+			await it('should create request with null body', async () => {
+				const r = new Request('https://example.com', { body: null });
+				expect(r.body).toBeNull();
+			});
 		});
 	});
 
@@ -275,4 +284,56 @@ export default async () => {
 			expect(text).toBe('hello');
 		});
 	});
+
+	await on('Gjs', async () => {
+		await describe('XMLHttpRequest responseType', async () => {
+			// Regression: Excalibur.js sets responseType='arraybuffer' for audio and
+			// 'blob' for images. Before this fix XHR ignored responseType and always
+			// returned text, which crashed gst_memory_new_wrapped on audio decode and
+			// broke URL.createObjectURL on image load.
+			//
+			// XMLHttpRequest is accessed off globalThis (not imported). On GJS it's
+			// registered by `@gjsify/fetch/register/xhr` (pulled in by --globals
+			// auto when the detector sees `new XMLHttpRequest()`); on Node there
+			// is no native XMLHttpRequest, so the suite is gated with on('Gjs', …).
+			const XHR = (globalThis as any).XMLHttpRequest;
+
+			const runXhr = (init: (xhr: any) => void) => new Promise<any>((resolve, reject) => {
+				const xhr = new XHR();
+				xhr.open('GET', 'data:text/plain;base64,aGVsbG8=');
+				init(xhr);
+				xhr.onload = () => resolve(xhr);
+				xhr.onerror = () => reject(new Error('xhr error'));
+				xhr.send();
+			});
+
+			await it('responseType="arraybuffer" yields ArrayBuffer', async () => {
+				const xhr = await runXhr((x) => { x.responseType = 'arraybuffer'; });
+				expect(xhr.response instanceof ArrayBuffer).toBe(true);
+				expect((xhr.response as ArrayBuffer).byteLength).toBe(5);
+			});
+
+			await it('responseType="text" yields decoded string', async () => {
+				const xhr = await runXhr((x) => { x.responseType = 'text'; });
+				expect(xhr.response).toBe('hello');
+				expect(xhr.responseText).toBe('hello');
+			});
+
+			await it('default responseType "" yields text', async () => {
+				const xhr = await runXhr(() => { /* responseType left at "" */ });
+				expect(xhr.response).toBe('hello');
+				expect(xhr.responseText).toBe('hello');
+			});
+
+			await it('responseType="blob" attaches _tmpPath for URL.createObjectURL', async () => {
+				const xhr = await runXhr((x) => { x.responseType = 'blob'; });
+				const blob = xhr.response as Blob & { _tmpPath?: string };
+				expect(blob instanceof Blob).toBe(true);
+				expect(typeof blob._tmpPath).toBe('string');
+				const url = URL.createObjectURL(blob);
+				expect(url.startsWith('file://')).toBe(true);
+				URL.revokeObjectURL(url);
+			});
+		});
+	});
 };

package/src/index.ts

@@ -28,6 +28,7 @@ import { URL } from '@gjsify/url';
 
 export { FormData, Headers, Request, Response, FetchError, AbortError, isRedirect };
 export { Blob, File };
+export { XMLHttpRequest, XMLHttpRequestUpload } from './xhr.js';
 
 import type { SystemError } from './types/index.js';
 
@@ -153,8 +154,10 @@ export default async function fetch(url: RequestInfo | URL | Request, init: Requ
     }
   };
 
-  // Listen for cancellation
-  cancellable.connect('cancelled', () => {
+  // Listen for cancellation.
+  // Gio.Cancellable.connect() is g_cancellable_connect() — pass callback + DestroyNotify (or null).
+  // NOT a GObject signal: do NOT pass a signal name as the first argument.
+  cancellable.connect(() => {
     readable.destroy(new AbortError('The operation was aborted.'));
   });
 

package/src/register/xhr.ts

@@ -0,0 +1,20 @@
+// Registers XMLHttpRequest / XMLHttpRequestUpload on globalThis.
+//
+// The Blob → file:// URL chain required by Excalibur's ImageSource / FontFace
+// is split across two packages:
+//   - `@gjsify/fetch` XHR (this package): when responseType='blob', materialise
+//     the response to a GLib temp file and attach `_tmpPath` to the returned
+//     Blob.
+//   - `@gjsify/url` URL class: `URL.createObjectURL(blob)` reads `_tmpPath`
+//     and returns a `file://` URL that HTMLImageElement etc. can load.
+//
+// There is no URL monkey-patching here — URL owns createObjectURL natively.
+
+import { XMLHttpRequest, XMLHttpRequestUpload } from '../xhr.js';
+
+if (typeof globalThis.XMLHttpRequest === 'undefined') {
+  globalThis.XMLHttpRequest = XMLHttpRequest as unknown as typeof globalThis.XMLHttpRequest;
+}
+if (typeof globalThis.XMLHttpRequestUpload === 'undefined') {
+  globalThis.XMLHttpRequestUpload = XMLHttpRequestUpload as unknown as typeof globalThis.XMLHttpRequestUpload;
+}

package/src/register.ts

@@ -1,4 +1,5 @@
-// Catch-all side-effect module: registers fetch/Headers/Request/Response.
-// For granular imports use '@gjsify/fetch/register/fetch'.
+// Catch-all side-effect module: registers fetch/Headers/Request/Response + XMLHttpRequest.
+// For granular imports use '@gjsify/fetch/register/fetch' or '@gjsify/fetch/register/xhr'.
 
 import './register/fetch.js';
+import './register/xhr.js';

package/src/request.ts

@@ -277,8 +277,24 @@ export class Request extends Body {
       throw new Error('Cannot send request: no Soup session (non-HTTP URL?)');
     }
 
+    // Soup auto-adds ContentDecoder to new sessions, but it decodes the body
+    // without removing the Content-Encoding header, causing double-decompression
+    // if we also run DecompressionStream below. Remove it so our JS-level
+    // decompression in index.ts handles everything correctly.
+    try { session.remove_feature_by_type(Soup.ContentDecoder.$gtype); } catch { /* not present */ }
+
     options.headers._appendToSoupMessage(message);
 
+    // Attach the request body to the Soup message (needed for POST/PUT/PATCH).
+    // Use _rawBodyBuffer to read the body without consuming the stream (the
+    // `body` getter may have already put the internal Readable into flowing mode,
+    // draining its buffer before we get here).
+    const rawBuf = this._rawBodyBuffer;
+    if (rawBuf !== null && rawBuf.byteLength > 0) {
+      const contentType = options.headers.get('content-type') || null;
+      message.set_request_body_from_bytes(contentType, new GLib.Bytes(rawBuf));
+    }
+
     const cancellable = new Gio.Cancellable();
 
     this[INTERNALS].inputStream = await soupSendAsync(session, message, GLib.PRIORITY_DEFAULT, cancellable);
@@ -380,9 +396,11 @@ export const getSoupRequestOptions = (request: Request) => {
 		headers.set('User-Agent', 'gjsify-fetch');
 	}
 
-	// HTTP-network-or-cache fetch step 2.15
+	// HTTP-network-or-cache fetch step 2.15. Brotli ('br') is omitted: SpiderMonkey
+	// 128's DecompressionStream supports only 'gzip' and 'deflate', so advertising
+	// 'br' would let servers respond with bodies we cannot decode.
 	if (request.compress && !headers.has('Accept-Encoding')) {
-		headers.set('Accept-Encoding', 'gzip, deflate, br');
+		headers.set('Accept-Encoding', 'gzip, deflate');
 	}
 
 	let { agent } = request;