fetch: reject network errors as TypeError('fetch failed' / 'terminated') with the system error as cause by robobun · Pull Request #35988 · oven-sh/bun

robobun · 2026-07-26T17:22:22Z

Problem

A fetch() that fails on the network rejects with a TypeError (since fetch: mark body disturbed when a reader fails; reject network errors as TypeError #35855) that carries Bun's own description and code at the top level and has no cause:

try { await fetch(`http://127.0.0.1:${closedPort}/`) } catch (e) {
  // Bun:  TypeError: Unable to connect. Is the computer able to access the url?   code: "ConnectionRefused"   cause: undefined
  // node: TypeError: fetch failed                                                   cause: Error { code: "ECONNREFUSED", errno: -111, syscall: "connect" }
}

Node code that follows the documented shape (err.cause?.code === "ECONNREFUSED") never matches on Bun (fetch() connection-refused error shape differs from Node: no e.cause.code === 'ECONNREFUSED' #34397), and is-network-error (the classifier under p-retry, ky and most retry loops), which checks name === "TypeError" plus a fixed set of messages including "fetch failed" and "terminated", returns false for every Bun failure, so those retry loops never retry on Bun (Native fetch incompatibilities with NodeJS error format and codes #20486).
Cause: FetchTasklet::on_reject (src/runtime/webcore/fetch/FetchTasklet.rs) builds one SystemError and returns it as ValueError::SystemTypeError, which SystemError__toTypeErrorInstance materialises as a single TypeError with the description as its message.

Fix

ValueError::SystemTypeError becomes ValueError::FetchFailed { cause, terminated } (src/runtime/webcore/Body.rs); both on_reject return sites (the DNS path and the general path) produce it, so every network failure gets the same shape. terminated is self.metadata.is_some(): the response headers had already been handed out, so the failure is one of the body, which undici reports as TypeError("terminated") instead of "fetch failed".
SystemError__toFetchFailedInstance (src/jsc/bindings/bindings.cpp) builds the cause with the existing Error constructor (so code, message, path, syscall, hostname, errno are exactly what Bun surfaced at the top level before, and Bun's error printer shows both levels), creates TypeError("fetch failed" | "terminated"), attaches the cause as a non-enumerable property the way new TypeError(msg, { cause }) does, and mirrors code onto the TypeError, so existing Bun code reading err.code keeps working and err.cause?.code ?? err.code is portable. SystemError__toTypeErrorInstance and the errorType parameter fetch: mark body disturbed when a reader fails; reject network errors as TypeError #35855 added for it are removed again; nothing else used them.
The cause uses node's vocabulary where a libuv equivalent exists: a refused connection is code: "ECONNREFUSED", syscall: "connect", errno: -ECONNREFUSED; a dropped connection stays ECONNRESET (already the case on main) and gains the matching negative errno, with no syscall since the failing call is not known there. Every other failure keeps its http::Error name as the code (DEPTH_ZERO_SELF_SIGNED_CERT, TooManyRedirects, Malformed_HTTP_Response, ...); DNS failures keep the getaddrinfo error Report DNS lookup failures from fetch() and Bun.connect as ENOTFOUND #32990 introduced, now on the cause.
Why this is correct: the Fetch spec rejects a network error with a TypeError, and node's shape for that TypeError (message, non-enumerable cause, cause.code) is the one portable code is written against; keeping Bun's description and codes on the cause, plus the code mirror, means no information that was available before is lost, only moved.
Verified with test/js/web/fetch/fetch-network-error.test.ts (6 cases, all failing on the released binary): the full shape, including errno < 0 and the non-enumerable cause, for a refused connection and for a connection dropped before the headers; a malformed response keeping Bun's code on both levels; "terminated" for a body cut short, both through text() and through a body-stream reader; and a hermetic DNS failure (a 64-character label, which the resolver rejects locally) in a child process with the proxy variables cleared. The existing tests that asserted the previous message or ConnectionRefused were updated to assert code / cause (13 files; a few of them were not awaiting the assertion they made). body-mixin-errors, client-fetch, fetch-redirect, fetch-gzip, fetch.tls, fetch.tls.wildcard, fetch-tls-cert, 18413-*, error-name-preservation, undici, html-rewriter and the two test/js/bun/test/parallel/test-http-* scripts were run locally.
Docs: a paragraph under "Error handling" in docs/runtime/networking/fetch.mdx describes the shape.

Consolidation

#34402 and #35998 were alternative fixes for the same issues. Folded in from #34402: syscall/negative errno on the cause and the check that cause is non-enumerable. Folded in from #35998: the "terminated" message for body-stage failures and the hermetic DNS test. Not adopted from #35998: capturing an Error at every fetch() call to give the rejection a caller stack (node does not do this either, its fetch failed stack has no caller frame unless an await chain supplies one, which Bun's existing async-stack attachment also provides; the capture costs an allocation per successful fetch() and had to weaken the serve.test.ts guard against per-request Error allocations), and its renaming of Bun's remaining codes to undici/http-parser names (Timeout -> ETIMEDOUT is unreachable because timeouts become TimeoutError first, InvalidContentLength -> UND_ERR_RES_CONTENT_LENGTH_MISMATCH describes a different failure, and the rest are approximations that would break the existing code checks for no portability gain). The stack being absent on errors created with no JS frames affects all natively created errors, not only fetch(), and is tracked separately.

Not covered here, as in the other two PRs: cases 3 and 4 of #20486 (an invalid URL getting a cause with ERR_INVALID_URL, an unsupported scheme) still reject as they did before, so that issue is left open; cases 1 and 2 are what this PR addresses.

Background

ValueError (Body.rs): the lazily materialised rejection reason stored on a body; it is turned into a JS value (to_js) only when something reads the body or the fetch promise is rejected, and can be duplicated when a Response is cloned, which is why it is a Rust enum rather than a JS value.
SystemError (src/jsc/SystemError.rs): the #[repr(C)] struct (code, message, path, syscall, hostname, errno, ...) that C++ turns into a JS error object; Rust keeps ownership of the strings, C++ only reads them.
metadata on the tasklet is set once the HTTP client has delivered the final response's status and headers; redirects followed internally never set it.

Fixes #34397
Addresses cases 1 and 2 of #20486

no test proof · iteration 7 · platform-specific test(s) that do not run on this machine, deferring to CI, which covers all platforms: test/js/workerd/html-rewriter.test.js, test/js/web/fetch/fetch.test.ts, test/js/bun/http/serve.test.ts, test/js/bun/http/bun-server.test.ts

coderabbitai · 2026-07-26T17:22:29Z

Walkthrough

Fetch network failures now use TypeError("fetch failed") with underlying errors exposed through cause and native codes. Fetch propagation, error-code mapping, and tests were updated across DNS, connection, redirect, stream, TLS, HTTP/2, and related scenarios.

Changes

Fetch network error shape alignment

Layer / File(s)	Summary
SystemError fetch conversion `src/jsc/SystemError.rs`, `src/jsc/bindings/headers.h`, `src/jsc/bindings/bindings.cpp`	Adds conversion support for `TypeError("fetch failed")` with the original error as `cause` and its native code.
Fetch error propagation `src/runtime/webcore/Body.rs`, `src/runtime/webcore/fetch/FetchTasklet.rs`	Adds `FetchError`, preserves its lifecycle, maps network failures to it, and records `code` and `syscall`.
Network error shape tests `test/js/web/fetch/`, `test/js/bun/`, `test/bake/fixtures/deinitialization/test.ts`, `test/js/workerd/html-rewriter.test.js`, `test/vendor.json`	Validates structured fetch errors, nested causes, network codes, redirect failures, stream failures, TLS failures, HTTP/2 failures, connection failures, and an updated temporary test skip.

Possibly related PRs

oven-sh/bun#35998: Changes fetch network error construction to expose TypeError("fetch failed") with the original error as .cause.

Suggested reviewers: jarred-sumner

🚥 Pre-merge checks | ✅ 4

✅ Passed checks (4 passed)

Check name	Status	Explanation
Linked Issues check	✅ Passed	The PR implements the network-error TypeError/cause shape and errno mapping required by `#20486` and `#34397`.
Out of Scope Changes check	✅ Passed	All code and test edits support the fetch error-shape change; no unrelated changes stand out.
Title check	✅ Passed	The title clearly and concisely describes the main fetch network-error change, including the TypeError message and system-error cause.
Description check	✅ Passed	The description thoroughly explains the problem, implementation, verification, and scope, although it uses custom headings instead of the template headings.

_{Comment @coderabbitai help to get the list of available commands.}

robobun · 2026-07-26T17:22:36Z

^{Updated 10:16 PM PT - Aug 23rd, 2026}

❌ @robobun, your commit 54f1f27 has 1 failures in Build #104592 (All Failures):

test/cli/run/require-cache.test.ts - code 1 on 🐧 13 x64-asan

🧪 To try this PR locally:

bunx bun-pr 35988

That installs a local version of the PR into your bun-35988 executable, so you can run:

bun-35988 --bun

github-actions · 2026-07-26T17:28:28Z

This PR may be a duplicate of:

fetch: mark body disturbed when a reader fails; reject network errors as TypeError #35855 - Also rejects fetch network errors as TypeError and modifies the same code paths (FetchTasklet::on_reject, SystemError bindings); references the same issues (Native fetch incompatibilities with NodeJS error format and codes #20486, fetch() connection-refused error shape differs from Node: no e.cause.code === 'ECONNREFUSED' #34397)
fetch: attach a node-style cause to connection-failure errors #34402 - Fixes the same issue (fetch() connection-refused error shape differs from Node: no e.cause.code === 'ECONNREFUSED' #34397) by attaching a .cause to fetch connection-failure errors via the same FetchTasklet and bindings.cpp code paths

🤖 Generated with Claude Code

robobun · 2026-07-26T17:28:51Z

Regarding the duplicate-PR flags:

fetch: mark body disturbed when a reader fails; reject network errors as TypeError #35855 makes fetch network errors TypeError but keeps Bun's descriptive message and no .cause; it also fixes an unrelated body-disturbed bug. This PR supersedes the TypeError half (with the .cause chain and the "fetch failed" message that classifier libraries key on) and leaves the body-disturbed half to fetch: mark body disturbed when a reader fails; reject network errors as TypeError #35855.
fetch: attach a node-style cause to connection-failure errors #34402 attaches a node-style .cause to connection-refused/closed/DNS failures only, keeping the outer as a plain Error. This PR supersedes it: the outer becomes the spec-required TypeError('fetch failed') and every network-error shape gets a .cause, not just those three. fetch: attach a node-style cause to connection-failure errors #34402 is also in a conflicting merge state.

Happy to close #34402 in favour of this once reviewed.

coderabbitai

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@test/js/web/fetch/fetch.test.ts`:
- Around line 2082-2086: Await each asynchronous rejection assertion so test
failures are propagated: update the fetch redirect matcher in
test/js/web/fetch/fetch.test.ts:2082-2086, the ECONNRESET matcher in
test/bake/fixtures/deinitialization/test.ts:61, the ECONNREFUSED matcher in
test/bake/fixtures/deinitialization/test.ts:71, and the res.text() rejection
matcher in test/js/bun/http/serve.test.ts:2679. Return or await each matcher
without changing its expectations.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

Push a commit to this branch (recommended)
Create a new PR with the fixes

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 4b280b01-629f-47aa-9d6c-aa9f51258b3e

📥 Commits

Reviewing files that changed from the base of the PR and between 44f6469 and 646e165.

📒 Files selected for processing (14)

src/jsc/SystemError.rs
src/jsc/bindings/bindings.cpp
src/jsc/bindings/headers.h
src/runtime/webcore/Body.rs
src/runtime/webcore/fetch/FetchTasklet.rs
test/bake/fixtures/deinitialization/test.ts
test/js/bun/http/serve.test.ts
test/js/bun/test/parallel/test-http-should-error-with-faulty-args.ts
test/js/bun/util/error-name-preservation.test.ts
test/js/web/fetch/client-fetch.test.ts
test/js/web/fetch/fetch-network-error.test.ts
test/js/web/fetch/fetch.stream.test.ts
test/js/web/fetch/fetch.test.ts
test/js/workerd/html-rewriter.test.js

claude

All prior feedback addressed — the five follow-up commits (646e165 through d9d67e9) cover every inline comment I left. No new issues found this pass.

Deferring to a human for the API-shape decision: this changes the user-visible rejection contract of fetch() (Error→TypeError, descriptive message→"fetch failed", ConnectionRefused→ECONNREFUSED) and overlaps with #35855 / #34402.

What was reviewed

New SystemError__toFetchTypeErrorInstance C++ binding — the clearException() pattern matches the sibling SystemError__toErrorInstance immediately above it.
ValueError::FetchError variant threaded through reset/to_js/dupe — all three match arms updated.
Grepped remaining ConnectionRefused references in test/ — the survivors are either comments, non-fetch (installer), or already include ECONNREFUSED as an alternative in their regex.

Extended reasoning...

Overview

This PR reshapes every fetch() network-error rejection from a bare Error with a descriptive message into TypeError('fetch failed', {cause: <original Error>}), matching the Fetch spec (§4.1 step 12.3) and Node/undici. It adds a new ValueError::FetchError(SystemError) variant in Body.rs, a new C++ binding SystemError__toFetchTypeErrorInstance in bindings.cpp, routes FetchTasklet::on_reject through it, remaps ConnectionRefused→ECONNREFUSED (with syscall: 'connect'), and updates 12 test files plus adds a dedicated fetch-network-error.test.ts.

Security risks

None identified. This is error-object construction on the rejection path; no new input parsing, no auth/TLS logic changes. The .code mirroring onto the outer TypeError uses putDirect on a freshly-created error object, not user-controlled data.

Level of scrutiny

High — this is a user-visible behavioral change to a core Web API. Code that currently checks err.code === 'ConnectionRefused', err.constructor === Error, or matches on err.message will observe different values. The PR mitigates this by mirroring .code onto the outer error and preserving the descriptive message on .cause.message, but it is still a break for anyone reading the outer .message or the old ConnectionRefused code string. That trade-off (spec/Node compat + is-network-error classifier support vs. Bun-specific back-compat) is a maintainer call.

Other factors

Prior review rounds: I left five rounds of inline findings (test-weakening, missed test updates, un-awaited .rejects, harness conventions), all now addressed by commits 646e165, ca44353, d190934, 3bb2573, d9d67e9. All threads are resolved.
Overlapping PRs: #35855 and #34402 touch the same code paths; the author has explained the relationship in the thread, but which approach lands is a human decision.
Native code: The new C++ function's DECLARE_TOP_EXCEPTION_SCOPE + clearException() on Bun::toJS failures exactly mirrors the existing SystemError__toErrorInstance in the same file (lines ~2375–2418), so it follows local convention rather than introducing a new pattern.
Test coverage: The new fetch-network-error.test.ts covers connection-refused, socket-closed-pre-headers, malformed-response, and body-truncated shapes, plus runs the inlined is-network-error predicate against a real rejection. I re-grepped test/ for remaining ConnectionRefused string matches — none should break (all either non-fetch, comments, or already regex-alternate on ECONNREFUSED).
CI: Build #82742 for the latest commit was still running at review time.

robobun · 2026-07-26T18:35:40Z

Opened #35998 which covers this reshape plus caller-stack capture (so .stack points at the fetch() call site for .catch() consumers too), the 'terminated' body-stage message, and a broader errno-code map (ETIMEDOUT, HPE_INVALID_CONSTANT, HPE_INVALID_CHUNK_SIZE, UND_ERR_HEADERS_OVERFLOW, UND_ERR_RES_CONTENT_LENGTH_MISMATCH, Z_DATA_ERROR). Happy to fold anything from here that #35998 is missing.

claude

The prior review feedback has all been addressed and I didn't find new issues, but this is a user-facing behavioral change to fetch()'s rejection shape (message/name/instanceof/code all change, a vendor test is skipped, and it overlaps with #35855/#34402), so it needs a maintainer to sign off on the API decisions rather than a bot approval.

What was reviewed:

SystemError__toFetchTypeErrorInstance follows the same DECLARE_TOP_EXCEPTION_SCOPE + clearException pattern as the adjacent SystemError__toErrorInstance.
ValueError::FetchError is wired into reset/to_js/dupe alongside SystemError, so no lifecycle path drops it.
All previously-flagged un-awaited .rejects matchers and stale outer-message assertions (bun-server, undici, untrusted-cert, html-rewriter, client-fetch) are fixed in the current diff.

Extended reasoning...

Overview

This PR changes every fetch() network-error rejection from a plain Error with a descriptive message to TypeError('fetch failed', {cause: <original Error>}), matching the Fetch spec §4.1.12.3 and Node/undici. It touches FetchTasklet::on_reject (Rust), adds a ValueError::FetchError variant to Body.rs, adds a new C++ binding SystemError__toFetchTypeErrorInstance, remaps ConnectionRefused→ECONNREFUSED, and updates ~12 test files plus adds a new dedicated shape test and a vendor-test skip.

Security risks

None identified. The change reshapes error objects on the rejection path; it doesn't touch validation, TLS decisions, or any allow/deny gate. The new C++ reads only from the Rust-owned SystemError struct.

Level of scrutiny

High — this is a user-visible breaking change to the most-used Web API. Every existing user check like err.message.includes('Unable to connect'), err.code === 'ConnectionRefused', or err.name === 'Error' changes behavior. The PR itself had to update a dozen tests and skip an elysia vendor test, which is a direct signal of ecosystem impact. REVIEW.md's API-design section calls for maintainer agreement on user-facing surface changes; the specific choices here (mirroring .code onto the outer TypeError when Node does not, mapping only two errors to libuv errno names while keeping Bun names for the rest, the exact 'fetch failed' message) are design calls a human should ratify.

Other factors

Overlapping PRs: #35855 and #34402 cover the same ground with different tradeoffs; a maintainer needs to coordinate which lands and close the others.
Prior feedback addressed: the earlier 🔴 finding (three tests still asserting the old outer message) was fixed in d190934; the un-awaited .rejects matchers were fixed in ca44353 and 3bb2573; the html-rewriter regex weakening was fixed in d9d67e9; the deinitialization test-precision nit was fixed. All inline threads are resolved.
C++ pattern: the new binding's scope.clearException() usage matches the immediately-adjacent SystemError__toErrorInstance byte-for-byte, so it's consistent with local convention for error-construction helpers.
Test coverage: the new fetch-network-error.test.ts is thorough (connection-refused, pre-header close, malformed response, mid-body truncation, and the inlined is-network-error predicate).
CodeRabbit's linked-issues check notes #20486 also covers invalid-URL/protocol TypeError shapes not addressed here; whether to keep that Fixes tag is a maintainer call.

coderabbitai

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@test/js/web/fetch/fetch-http2-client.test.ts`:
- Around line 855-858: Update the subprocess assertions in
test/js/web/fetch/fetch-http2-client.test.ts at lines 855-858, 1157-1160, and
1179-1182: retain concurrent draining of stdout, stderr, and process exit,
assert exitCode is 0, and include stderr alongside stdout in failure diagnostics
while preserving each case’s expected stdout.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

Push a commit to this branch (recommended)
Create a new PR with the fixes

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 3740e85b-adac-4689-b403-d29a483c8309

📥 Commits

Reviewing files that changed from the base of the PR and between d9d67e9 and 592f8b9.

📒 Files selected for processing (2)

test/js/web/fetch/fetch-http2-client.test.ts
test/vendor.json

claude

All earlier review feedback has been addressed and no new issues surfaced this pass, but this is a user-facing change to fetch()'s error shape (outer .message, .code for ConnectionRefused, instanceof TypeError) that breaks existing consumers keying on the old shape — the elysia vendor skip is one example — so it needs a maintainer's call on the compatibility trade-off. Note also that #35998 was opened after this PR and is described as superseding it with a broader errno map and stack capture; worth deciding which one to land.

What was reviewed:

SystemError__toFetchTypeErrorInstance: the scope.clearException() pattern matches the sibling SystemError__toErrorInstance immediately above it, so it's consistent with local convention.
ValueError::FetchError lifecycle: reset/to_js/dupe all handle the new variant symmetrically with SystemError.
Re-checked the three test files flagged in the earlier 🔴 comment (bun-server.test.ts, undici.test.ts, test-http-should-not-accept-untrusted-certificates.ts) plus the html-rewriter regex and the un-awaited .rejects in client-fetch — all now updated to match on .code / .cause and awaited.

Extended reasoning...

Overview

Reshapes every fetch() network-error rejection from a bare Error to TypeError('fetch failed', {cause: <SystemError>}), mirroring the Fetch spec (§4.1.12.3) and Node/undici. Native side: a new ValueError::FetchError variant in Body.rs, a SystemError::to_fetch_type_error_instance bridge in SystemError.rs, the C++ SystemError__toFetchTypeErrorInstance in bindings.cpp, and FetchTasklet::on_reject now returns FetchError and maps ConnectionRefused → ECONNREFUSED with syscall: "connect". Fourteen test files updated for the new shape, one new dedicated test file, and one elysia vendor test skipped.

Security risks

None identified. The change is confined to how an already-constructed error is wrapped before rejection; no new user input reaches parsing, allocation, or auth paths.

Level of scrutiny

High. This is a deliberate, ecosystem-visible behavior change to a core Web API on the hot path: .message goes from descriptive to the fixed string "fetch failed", .code for connection-refused changes from "ConnectionRefused" to "ECONNREFUSED", and instanceof TypeError flips. That is the correct direction per spec/Node, but it will break user code that pattern-matches the old shape (the elysia vendor test being the in-tree example). REVIEW.md's API-design guidance calls for maintainer agreement on user-facing surface changes, which this is.

Other factors

All five of my earlier inline comments (test precision in deinitialization/test.ts, Buffer.alloc vs .repeat, three missed message-asserting tests, un-awaited .rejects in client-fetch, dead regex arms in html-rewriter) are resolved in the current diff, as is CodeRabbit's un-awaited-rejection batch.
The new C++ function's clearException() after toJS follows the exact pattern of SystemError__toErrorInstance a few lines above; not a new violation.
The ValueError::FetchError variant is wired into every lifecycle method (reset, to_js, dupe) symmetrically with SystemError, so no leak/double-free asymmetry.
The author has since opened #35998, described as covering this reshape plus caller-stack capture, a 'terminated' body-stage message, and a broader errno map. There are also two older overlapping PRs (#35855, #34402). A human should decide whether to land this incrementally or consolidate into #35998.

robobun · 2026-07-26T22:06:12Z

Status (updated): rebased onto current main (54f1f27, one commit, 20 files). The only conflicts were mechanical, from #40238 (bun_core::String now owns its WTF ref): the .into() conversions when building the SystemError cause are gone, and ValueError::reset is main's one-line version (drop handles the strings). No behavior change.

CI on 54f1f27 (#104592): 180/181 jobs passed; every fetch-related test file passed on every lane. The one red job is test/cli/run/require-cache.test.ts on debian x64-asan (module-cache leak tests timing out), which CI flags as pre-existing on main and is unrelated to this change; reported for triage separately. The other entries are flaky retries that passed.

Verified locally on the rebased build: test/js/web/fetch/fetch-network-error.test.ts 6/6, plus body-mixin-errors, error-name-preservation, client-fetch, fetch-gzip, undici, html-rewriter (319 pass, 0 fail), the touched fetch-http2-client / fetch.stream / fetch.test subsets, and both test/js/bun/test/parallel/test-http-* scripts.

Ready for review.

claude

All prior review feedback has been addressed and CI is green, but this changes the user-visible fetch() rejection shape (Error→TypeError, descriptive message→"fetch failed", ConnectionRefused→ECONNREFUSED) and overlaps with #35998 — a maintainer should sign off on the API surface and decide which PR to land.

What was reviewed:

SystemError__toFetchTypeErrorInstance follows the same DECLARE_TOP_EXCEPTION_SCOPE / clearException() pattern as its sibling SystemError__toErrorInstance in the same file.
New ValueError::FetchError variant is wired into every match site (reset, to_js, dupe).
All 5 previously-flagged test-assertion issues (missing awaits, weakened assertions, three CI-breaking message checks) are fixed in the current diff.
The vendor.json elysia skip is documented with the upstream fix condition.

Extended reasoning...

Overview

This PR reshapes every fetch() network-error rejection from a bare Error with a descriptive .message into TypeError('fetch failed', {cause: <original Error>}), matching Fetch spec §4.1 step 12.3 and Node/undici. The native change is small (~60 lines across SystemError.rs, bindings.cpp, headers.h, Body.rs, FetchTasklet.rs); the bulk of the diff is 13 test files updated for the new shape plus one new dedicated test file and a vendor.json skip for an elysia test that asserts the old message.

Security risks

None identified. This only changes how already-failing network requests are reported to JS; no new input parsing, no auth/TLS logic changes. The .cause chain preserves all diagnostic fields (.code/.syscall/.path/.hostname) that were previously on the top-level error.

Level of scrutiny

High — user-facing API design. While the implementation is straightforward and well-tested, this is a deliberate behavioral break for a core Web API: existing Bun code checking err.code === 'ConnectionRefused' or err.message.includes('Unable to connect') will stop matching. The PR mitigates this by mirroring .code onto the outer TypeError, but the ConnectionRefused→ECONNREFUSED remap is still a break. REVIEW.md's guidance on API surface changes and the note that #35998 covers a superset of this reshape (plus caller-stack capture, a 'terminated' body-stage message, and a broader errno map) both point to a maintainer decision.