[steipete]

What does this PR do?

Bun's WHATWG ReadableStream prototype did not expose Node's registered stream-state symbols. As a result, node:stream.isReadable(new ReadableStream()) returned null instead of tracking the stream's live state.

This breaks installed Undici on a forced HTTP socket close. Undici gates response-body termination on node:stream.isReadable(), so under Bun an original response and its clone could remain pending forever instead of rejecting with the transport error.

This change exposes nodejs.stream.readable, nodejs.stream.errored, and nodejs.stream.disturbed as read-only prototype accessors backed by Bun's existing stream state. It matches Node's behavior for readable, locked, disturbed, closed, and errored streams.

AI assistance: This change was developed and reviewed with Codex.

How did you verify your code works?

• The new state regression fails 0/2 on the pre-fix custom Bun and passes 2/2 after rebuilding.
• A reduced installed-Undici forced-close probe hangs past 5 seconds before the fix; after the fix, both response.text() and a cloned response reject promptly with TypeError: terminated and the underlying UND_ERR_SOCKET.
• OpenClaw's six managed provider capture lifecycle cases pass with the patched runtime, including clean partial EOF, forced transport failure, idle capture, and caller cancellation.
• Built the release CLI successfully, ran clang-format and Prettier, and completed an independent P0-P2 review with no findings.

[claude]

Claude Code Review

This pull request is from a fork — automated review is disabled. A repository maintainer can comment @claude review to run a one-time review.

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Advanced

Run ID: 27d53b2f-9d1d-4fd8-b39d-14dc38d91fbb

📥 Commits

Reviewing files that changed from the base of the PR and between 1d487c4 and 3253838.

📒 Files selected for processing (2)

• src/jsc/bindings/webcore/streams/JSReadableStream.cpp
• test/js/node/stream/web-stream-state.test.ts

Included review availability: Your plan provides up to 10 included reviews per hour; 9 remain after this review.

---

Walkthrough

The change adds three symbol-keyed ReadableStream prototype accessors for readable, errored, and disturbed state. Each accessor validates its receiver and returns a boolean. Tests cover normal lifecycle transitions and controller-triggered errors.

Changes

ReadableStream state introspection

Layer / File(s)	Summary
Register and implement state accessors src/jsc/bindings/webcore/streams/JSReadableStream.cpp	The ReadableStream prototype registers three read-only symbol-keyed custom accessors. The getters brand-check the receiver and return readable, errored, or disturbed state.
Validate lifecycle state reporting test/js/node/stream/web-stream-state.test.ts	Tests verify state helpers during normal consumption and after a controller reports an error.

Suggested reviewers: robobun

Priority: ➖ Normal

Merge Risk: ⚪ Minimal · up to 32538

The new stream-state accessors match the tested lifecycle and locked-stream behavior, with no remaining merge-blocking risk identified.

🚥 Pre-merge checks | ✅ 4

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description check	✅ Passed	The description includes both required sections. It clearly explains the bug, the implementation, the impact, and the verification results.
Title check	✅ Passed	The title clearly identifies the stream fix and the exposure of Web Stream state to node:stream. It is concise and directly related to the main change.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

---

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

[robobun]

Thank you for this fix. It overlaps with #34624, an earlier attempt at the same bug. That PR added a private intrinsic and special cases inside the four node:stream helpers. The prototype getters in this PR are the better approach. They are what Node does, and code that reads the nodejs.stream.* symbols directly (for example the readable-stream package) also sees the correct state. I closed #34624 in favor of this PR.

I built this branch and compared it with Node v26.3.0. isReadable, isErrored and isDisturbed give the same results for every ReadableStream case I tried:

• fresh, locked, closed, close requested with chunks still queued
• errored before and after a failed read(), cancelled
• tee() branches, byte streams, pipeTo(), async iteration, subclasses
• both sides of a TransformStream (Node does not brand TransformStream itself, and neither does this PR)
• Response, Request, fetch() and Blob bodies, including a fetch() body whose socket is destroyed mid-response

The property descriptors also match Node (get only, not enumerable, configurable). test/js/node/stream/node-stream.test.js and test/js/web/streams/streams.test.js pass with this branch.

One gap: WritableStream

Node also brands WritableStream.prototype, with nodejs.stream.writable and nodejs.stream.errored getters (lib/internal/webstreams/writablestream.js#L181-L187):

get [kIsErrored]() {
  return this[kState].state === 'errored';
}

get [kIsWritable]() {
  return this[kState].state === 'writable';
}

With this PR, isWritable(new WritableStream()) still returns null (Node: true). isErrored() on an errored WritableStream still returns false (Node: true). The same applies to transformStream.writable.

The fix is the mirror image of this diff in JSWritableStream.cpp, backed by m_state == WritableStreamState::Writable and m_state == WritableStreamState::Errored. The Erroring state reports false for both getters, like Node. I applied the patch below on top of this branch. With it, the WritableStream results and descriptors also match Node v26.3.0, and all 11 cases from #34624 pass.

Patch for src/jsc/bindings/webcore/streams/JSWritableStream.cpp

@@ -18,6 +18,7 @@
 #include "WebStreamsInternals.h"
 #include "ZigGlobalObject.h"
 #include <JavaScriptCore/BuiltinNames.h>
+#include <JavaScriptCore/DOMAttributeGetterSetter.h>
 #include <JavaScriptCore/Error.h>
 #include <JavaScriptCore/FunctionPrototype.h>
 #include <JavaScriptCore/JSCInlines.h>
@@ -36,6 +37,8 @@ static JSC_DECLARE_HOST_FUNCTION(jsWritableStreamPrototypeFunction_abort);
 static JSC_DECLARE_HOST_FUNCTION(jsWritableStreamPrototypeFunction_close);
 static JSC_DECLARE_HOST_FUNCTION(jsWritableStreamPrototypeFunction_getWriter);
 static JSC_DECLARE_CUSTOM_GETTER(jsWritableStreamPrototypeGetter_locked);
+static JSC_DECLARE_CUSTOM_GETTER(jsWritableStreamPrototypeGetter_nodeWritable);
+static JSC_DECLARE_CUSTOM_GETTER(jsWritableStreamPrototypeGetter_nodeErrored);
 static JSC_DECLARE_CUSTOM_GETTER(jsWritableStreamPrototypeGetter_constructor);
 static JSC_DECLARE_HOST_FUNCTION(jsWritableStreamPrototype_inspectCustom);
 
@@ -195,6 +198,12 @@ void JSWritableStreamPrototype::finishCreation(VM& vm)
 {
     Base::finishCreation(vm);
     Bun::reifyStaticPropertyTable(vm, JSWritableStream::info(), JSWritableStreamPrototypeTableValues, *this);
+
+    const auto nodeStreamStateAttributes = JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::ReadOnly;
+    const auto nodeStreamStateAnnotation = DOMAttributeAnnotation { JSWritableStream::info(), nullptr };
+    putDirectCustomAccessor(vm, Identifier::fromUid(vm.symbolRegistry().symbolForKey("nodejs.stream.writable"_s)), DOMAttributeGetterSetter::create(vm, jsWritableStreamPrototypeGetter_nodeWritable, nullptr, nodeStreamStateAnnotation), nodeStreamStateAttributes);
+    putDirectCustomAccessor(vm, Identifier::fromUid(vm.symbolRegistry().symbolForKey("nodejs.stream.errored"_s)), DOMAttributeGetterSetter::create(vm, jsWritableStreamPrototypeGetter_nodeErrored, nullptr, nodeStreamStateAnnotation), nodeStreamStateAttributes);
+
     Bun::WebStreams::installInspectCustom(vm, this, jsWritableStreamPrototype_inspectCustom);
     Bun::putToStringTagWithoutTransition(vm, this, info());
 }
@@ -326,6 +335,26 @@ JSC_DEFINE_CUSTOM_GETTER(jsWritableStreamPrototypeGetter_locked, (JSGlobalObject
     return JSValue::encode(jsBoolean(isWritableStreamLocked(stream)));
 }
 
+JSC_DEFINE_CUSTOM_GETTER(jsWritableStreamPrototypeGetter_nodeWritable, (JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, PropertyName))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto* stream = dynamicDowncast<JSWritableStream>(JSValue::decode(thisValue));
+    if (!stream) [[unlikely]]
+        return Bun::ERR::INVALID_THIS(scope, lexicalGlobalObject, "WritableStream"_s);
+    return JSValue::encode(jsBoolean(stream->m_state == WritableStreamState::Writable));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsWritableStreamPrototypeGetter_nodeErrored, (JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, PropertyName))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto* stream = dynamicDowncast<JSWritableStream>(JSValue::decode(thisValue));
+    if (!stream) [[unlikely]]
+        return Bun::ERR::INVALID_THIS(scope, lexicalGlobalObject, "WritableStream"_s);
+    return JSValue::encode(jsBoolean(stream->m_state == WritableStreamState::Errored));
+}
+
 JSC_DEFINE_HOST_FUNCTION(jsWritableStreamPrototypeFunction_abort, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);

WritableStream test cases from #34624, free to adopt

import { isDisturbed, isErrored, isReadable, isWritable } from "node:stream";

const probe = stream => ({
  isReadable: isReadable(stream),
  isWritable: isWritable(stream),
  isErrored: isErrored(stream),
  isDisturbed: isDisturbed(stream),
});

it("WritableStream: writable", () => {
  const ws = new WritableStream({ write() {} });
  expect(probe(ws)).toEqual({ isReadable: null, isWritable: true, isErrored: false, isDisturbed: false });
});

it("WritableStream: closed", async () => {
  const ws = new WritableStream({ write() {} });
  const writer = ws.getWriter();
  await writer.close();
  writer.releaseLock();
  expect(probe(ws)).toEqual({ isReadable: null, isWritable: false, isErrored: false, isDisturbed: false });
});

it("WritableStream: errored", async () => {
  const ws = new WritableStream({
    start(c) {
      c.error(new Error("boom"));
    },
  });
  await ws.getWriter().closed.catch(() => {});
  expect(probe(ws)).toEqual({ isReadable: null, isWritable: false, isErrored: true, isDisturbed: false });
});

Against this branch as it is now, these 3 cases fail and the other 8 cases from #34624 pass.

If you prefer to keep this PR scoped to ReadableStream, that is fine too. The WritableStream half can be a follow-up after this PR lands.

One small note, not blocking. The repo convention (CLAUDE.md, "Test Organization") is to add tests to the existing file for the module and not to create a new file. Here that file is test/js/node/stream/node-stream.test.js.

[robobun]

The WritableStream half is now in #42457 (nodejs.stream.writable and nodejs.stream.errored getters on WritableStream.prototype, same pattern as this PR).