fix(fetch): Response.json shares ctor init validation; --platform bun accepts null-body-status bodies (#10360)

changelog.d/10368-response-null-body-status.md

@@ -0,0 +1,20 @@
+Fixed `Response.json(value, init)` skipping the `ResponseInit` validation that
+`new Response(body, init)` applies (#10360). Both now share one check, in
+Node's order: status range (`RangeError`), then `statusText` (`TypeError`), then
+the body/null-body-status conflict. So `Response.json({a: 1}, {status: 204})`
+throws Node's `TypeError: Response constructor: Invalid response status code
+204` instead of returning a 204, and `Response.json({}, {status: 600})` throws
+a `RangeError` instead of returning a 600. The fix covers both perry-stdlib and
+perry-ext-fetch.
+
+Programs compiled with `--platform bun` follow Bun instead: a body with a
+null-body status (204/205/304) is accepted by both constructors, so
+`new Response("", {status: 204})` works. The compiler seeds
+`__perry_runtime.setBunPlatform()` into every module's init next to the #9599
+`globalThis.Bun` install, which sets a runtime flag
+(`perry-runtime/src/bun_compat/platform.rs`, `js_set_bun_platform` /
+`js_bun_platform_enabled`) before any dependency's top-level code runs.
+
+Tests: `test-files/test_gap_response_null_body_status_10360.ts` (Node parity)
+and `crates/perry/tests/issue_10360_bun_platform_response_null_body.rs` (Bun
+1.3.14 output under `--platform bun`, plus a node-platform control).

crates/perry-codegen/src/codegen/entry/tests.rs

@@ -536,3 +536,26 @@ fn dylib_closures_keep_native_roots() {
         "dylib roots must not be demoted to the shadow stack:\n{closure}"
     );
 }
+
+/// #10360: `--platform bun` seeds `__perry_runtime.setBunPlatform()` into
+/// module init; it must lower to the runtime flag setter, which the fetch
+/// Response paths read to follow Bun's null-body-status leniency.
+#[test]
+fn set_bun_platform_marker_lowers_to_the_runtime_flag_setter() {
+    let mut module = empty_module();
+    module.init = vec![Stmt::Expr(Expr::NativeMethodCall {
+        module: "__perry_runtime".to_string(),
+        class_name: None,
+        object: None,
+        method: "setBunPlatform".to_string(),
+        args: Vec::new(),
+    })];
+    let ir = String::from_utf8(compile_module(&module, entry_opts("executable")).unwrap())
+        .expect("LLVM IR should be UTF-8");
+    assert!(
+        ir.contains("call void @js_set_bun_platform()"),
+        "expected the Bun platform marker call in module init:\n{ir}"
+    );
+    // Control: the default (node) platform never emits the call.
+    assert!(!emitted_ir("executable").contains("call void @js_set_bun_platform"));
+}

crates/perry-codegen/src/lower_call/native/native_runtime_branch.rs

@@ -173,6 +173,13 @@
                     .block()
                     .call(DOUBLE, "js_has_path_module", &[(DOUBLE, &path)]));
             }
+            // #10360: seeded into every module init under `--platform bun`
+            // so the runtime can follow Bun where its Web APIs differ from
+            // Node's (e.g. the Response null-body-status check).
+            "setBunPlatform" => {
+                ctx.block().call_void("js_set_bun_platform", &[]);
+                return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
+            }
             _ => {}
         }
     }

crates/perry-codegen/src/runtime_decls/objects.rs

@@ -407,6 +407,8 @@ pub fn declare_phase_b_objects(module: &mut LlModule) {
     module.declare_function("js_run_module_init_catching", VOID, &[I64]);
     module.declare_function("js_require_path_module", DOUBLE, &[DOUBLE]);
     module.declare_function("js_has_path_module", DOUBLE, &[DOUBLE]);
+    // #10360: `--platform bun` marker (see `__perry_runtime.setBunPlatform`).
+    module.declare_function("js_set_bun_platform", VOID, &[]);
     // Next.js wall 54 (part 2): register a Deferred module's `__init` address by
     // path so a runtime `require(absolutePath)` can trigger its lazy init.
     module.declare_function("js_register_path_init", VOID, &[PTR, I64, I64]);

crates/perry-ext-fetch/src/lib.rs

@@ -22,8 +22,8 @@ use std::sync::Mutex;
 mod gc;
 mod validation;
 use validation::{
-    is_forbidden_method, is_null_body_status, is_redirect_status, is_valid_status_text,
-    normalize_method, parse_redirect_location, redirect_status_from_value,
+    is_forbidden_method, is_redirect_status, normalize_method, parse_redirect_location,
+    redirect_status_from_value, response_init,
 };
 use validation::{throw_range_error, throw_type_error};
 
@@ -1224,31 +1224,7 @@ pub unsafe extern "C" fn js_response_new(
     let body_opt = read_str(body_ptr);
     let body_present = body_opt.is_some();
     let body = body_opt.unwrap_or_default().into_bytes();
-    // NaN/0.0 are the codegen "no status field" sentinels → default 200.
-    // Otherwise truncate toward zero + range-check 200..=599 (#2640).
-    let status = if status.is_nan() || status == 0.0 {
-        200
-    } else {
-        let truncated = status.trunc();
-        if !(200.0..=599.0).contains(&truncated) {
-            throw_range_error("init[\"status\"] must be in the range of 200 to 599, inclusive.");
-        }
-        truncated as u16
-    };
-    let status_text = match read_str(status_text_ptr) {
-        Some(s) => {
-            if !is_valid_status_text(&s) {
-                throw_type_error("Invalid statusText");
-            }
-            s
-        }
-        None => String::new(),
-    };
-    if body_present && is_null_body_status(status) {
-        throw_type_error(&format!(
-            "Response constructor: Invalid response status code {status}"
-        ));
-    }
+    let (status, status_text) = response_init(status, read_str(status_text_ptr), body_present);
     let headers_id = handle_id(headers_handle);
     let headers = if headers_id != 0 {
         HEADERS_HANDLES
@@ -1419,15 +1395,10 @@ pub unsafe extern "C" fn js_response_static_json(
 ) -> f64 {
     let v = JsValue::from_bits(value.to_bits());
     let body = perry_ffi::json_stringify(v).unwrap_or_default();
-    // #2638: honor `init.status` / `init.statusText` / `init.headers`.
-    let status = if init_status.is_nan() || init_status == 0.0 {
-        200
-    } else {
-        init_status as u16
-    };
-    // Node's `Response.json` leaves statusText "" when not provided — it does
-    // not fall back to the status reason phrase.
-    let status_text = read_str(init_status_text_ptr).unwrap_or_default();
+    // #2638: honor `init.status` / `init.statusText` / `init.headers`, with
+    // the same validation as `new Response` (#10360) — the JSON body is
+    // always present, so a null-body status throws outside Bun mode.
+    let (status, status_text) = response_init(init_status, read_str(init_status_text_ptr), true);
     // Start from any user-provided headers, then add the default content-type
     // only if the init headers didn't already set one.
     let headers_id = handle_id(headers_handle);

crates/perry-ext-fetch/src/validation.rs

@@ -18,6 +18,8 @@ extern "C" {
     fn js_typeerror_new(message: *mut StringHeader) -> *mut u8;
     fn js_rangeerror_new(message: *mut StringHeader) -> *mut u8;
     fn js_throw(value: f64) -> !;
+    // perry-runtime `bun_compat::platform` (#10360): 1 under `--platform bun`.
+    fn js_bun_platform_enabled() -> i32;
 }
 
 pub(crate) unsafe fn throw_type_error(msg: &str) -> ! {
@@ -46,6 +48,46 @@ pub(crate) fn is_null_body_status(status: u16) -> bool {
     matches!(status, 101 | 103 | 204 | 205 | 304)
 }
 
+/// Validate a `ResponseInit` the way Node's `initializeResponse` does, in its
+/// order: status range, then statusText, then the body/null-body-status
+/// conflict. Shared by `new Response` and `Response.json` so the two
+/// construction paths cannot disagree (#10360). Returns (status, statusText).
+///
+/// NaN / 0.0 status are the codegen "no status field" sentinels → 200;
+/// anything else is truncated toward zero and range-checked (#2640). A
+/// missing statusText is "" (#2640). A body under a null-body status is a
+/// TypeError in Node but accepted by Bun, so `--platform bun` skips it.
+pub(crate) unsafe fn response_init(
+    status: f64,
+    status_text: Option<String>,
+    body_present: bool,
+) -> (u16, String) {
+    let status = if status.is_nan() || status == 0.0 {
+        200
+    } else {
+        let truncated = status.trunc();
+        if !(200.0..=599.0).contains(&truncated) {
+            throw_range_error("init[\"status\"] must be in the range of 200 to 599, inclusive.");
+        }
+        truncated as u16
+    };
+    let status_text = match status_text {
+        Some(s) => {
+            if !is_valid_status_text(&s) {
+                throw_type_error("Invalid statusText");
+            }
+            s
+        }
+        None => String::new(),
+    };
+    if body_present && is_null_body_status(status) && js_bun_platform_enabled() == 0 {
+        throw_type_error(&format!(
+            "Response constructor: Invalid response status code {status}"
+        ));
+    }
+    (status, status_text)
+}
+
 /// Web Fetch forbidden request methods — rejected by the Request ctor.
 pub(crate) fn is_forbidden_method(method_upper: &str) -> bool {
     matches!(method_upper, "CONNECT" | "TRACE" | "TRACK")

crates/perry-runtime/src/bun_compat/mod.rs

@@ -27,6 +27,7 @@ mod cli_utils;
 mod cli_utils_stub;
 mod glob;
 mod jsc;
+mod platform;
 mod plugin;
 mod spawn;
 mod string_width;
@@ -51,6 +52,7 @@ pub use cli_utils::*;
 pub use cli_utils_stub::*;
 pub use glob::js_bun_glob_new;
 pub use jsc::js_bun_jsc_heap_stats;
+pub use platform::{js_bun_platform_enabled, js_set_bun_platform};
 pub use plugin::{decorate_bun_plugin, js_bun_plugin};
 pub use spawn::{js_bun_spawn, js_bun_terminal_new};
 pub use string_width::bun_string_width;

crates/perry-runtime/src/bun_compat/platform.rs

@@ -0,0 +1,47 @@
+//! Runtime view of `perry compile --platform bun` (#10360).
+//!
+//! The platform is a compile-time choice, but a few Web APIs differ between
+//! Node and Bun at runtime. Under `--platform bun` the compiler seeds every
+//! module's init with `__perry_runtime.setBunPlatform()` (next to the
+//! `globalThis.Bun` install), so the flag is set before any user code runs.
+//! It is process-global and only ever turns on.
+//!
+//! Both setter and getter are `#[no_mangle]` so perry-stdlib and the ext
+//! crates (which link the runtime by symbol, not by Rust path) all read the
+//! same flag.
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static BUN_PLATFORM: AtomicBool = AtomicBool::new(false);
+
+/// Called from generated module init under `--platform bun`.
+#[no_mangle]
+pub extern "C" fn js_set_bun_platform() {
+    BUN_PLATFORM.store(true, Ordering::Relaxed);
+}
+
+/// 1 when the program was compiled with `--platform bun`, else 0.
+#[no_mangle]
+pub extern "C" fn js_bun_platform_enabled() -> i32 {
+    i32::from(BUN_PLATFORM.load(Ordering::Relaxed))
+}
+
+#[cfg(test)]
+pub(crate) fn reset_bun_platform_for_test() {
+    BUN_PLATFORM.store(false, Ordering::Relaxed);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bun_platform_flag_defaults_off_and_turns_on() {
+        reset_bun_platform_for_test();
+        assert_eq!(js_bun_platform_enabled(), 0);
+        js_set_bun_platform();
+        assert_eq!(js_bun_platform_enabled(), 1);
+        reset_bun_platform_for_test();
+        assert_eq!(js_bun_platform_enabled(), 0);
+    }
+}

crates/perry-stdlib/src/fetch/body_clone.rs

@@ -110,14 +110,11 @@ pub unsafe extern "C" fn js_response_static_json(
     } else {
         string_from_header(str_ptr).unwrap_or_else(|| "null".to_string())
     };
-    let status_u16 = if init_status.is_nan() || init_status == 0.0 {
-        200
-    } else {
-        init_status as u16
-    };
-    // Node's `Response.json` leaves statusText "" when not provided — it does
-    // not fall back to the status reason phrase.
-    let status_text = string_from_header(init_status_text_ptr).unwrap_or_default();
+    // Same init validation as `new Response` (#10360): Node range-checks the
+    // status, validates statusText (default "", not the reason phrase), and
+    // rejects the always-present JSON body under a null-body status.
+    let (status_u16, status_text) =
+        super::response_ctor::response_init(init_status, init_status_text_ptr, true);
     // Start from any user-provided headers, then add the default content-type
     // only if the init headers didn't already set one.
     let headers_id = handle_id(headers_handle);

crates/perry-stdlib/src/fetch/response_ctor.rs

@@ -28,30 +28,24 @@ pub(super) fn alloc_response(
     id
 }
 
-/// new Response(body, statusOpt, statusTextPtrOpt, headersHandleOpt)
-/// - body_ptr: StringHeader for the body, or null for ""
-/// - status: f64 (200 default)
-/// - status_text_ptr: StringHeader for statusText, or null for ""
-/// - headers_handle: f64 numeric handle from js_headers_new, or 0
-#[no_mangle]
-pub unsafe extern "C" fn js_response_new(
-    body_ptr: *const StringHeader,
+/// Validate a `ResponseInit` the way Node's `initializeResponse` does, in its
+/// order: status range, then statusText, then the body/null-body-status
+/// conflict. Shared by `new Response` and `Response.json` so the two
+/// construction paths cannot disagree (#10360). Returns (status, statusText).
+///
+/// - `status`: NaN / 0.0 are the codegen "no status field" sentinels. Node
+///   defaults missing status to 200; any explicit value is truncated toward
+///   zero then range-checked against 200..=599 (199.9 → RangeError, 599.9 →
+///   599). Refs #2640.
+/// - `statusText`: Node defaults it to the empty string (NOT the canonical
+///   reason phrase) and validates the reason-phrase token. Refs #2640.
+/// - A body with a null-body status (204/205/304) is a TypeError in Node, but
+///   Bun accepts it, so `--platform bun` programs skip the check.
+pub(super) unsafe fn response_init(
     status: f64,
     status_text_ptr: *const StringHeader,
-    headers_handle: f64,
-) -> f64 {
-    let body_stream_id = take_pending_fetch_body_stream_id();
-    // Consume before validation so a throwing constructor cannot leak body
-    // metadata into the next Response construction on this thread.
-    let body_content_type = take_pending_fetch_body_content_type();
-    // Lossless raw-byte read so binary bodies survive byte-for-byte (#5435).
-    let body_opt = dispatch::body_bytes_from_header(body_ptr);
-    let body_present = body_opt.is_some() || body_stream_id.is_some();
-    let body = body_opt.unwrap_or_default();
-    // NaN / 0.0 are the codegen "no status field" sentinels. Node defaults
-    // missing status to 200; any explicit value is truncated toward zero
-    // then range-checked against 200..=599 (199.9 → RangeError, 599.9 →
-    // 599). Refs #2640.
+    body_present: bool,
+) -> (u16, String) {
     let status_u16 = if status.is_nan() || status == 0.0 {
         200
     } else {
@@ -63,8 +57,6 @@ pub unsafe extern "C" fn js_response_new(
         }
         truncated as u16
     };
-    // Node defaults statusText to the empty string (NOT the canonical
-    // reason phrase) and validates the reason-phrase token. Refs #2640.
     let status_text = match string_from_header(status_text_ptr) {
         Some(s) => {
             if !is_valid_status_text(&s) {
@@ -74,11 +66,38 @@ pub unsafe extern "C" fn js_response_new(
         }
         None => String::new(),
     };
-    if body_present && is_null_body_status(status_u16) {
+    if body_present
+        && is_null_body_status(status_u16)
+        && perry_runtime::bun_compat::js_bun_platform_enabled() == 0
+    {
         throw_fetch_type_error(&format!(
             "Response constructor: Invalid response status code {status_u16}"
         ));
     }
+    (status_u16, status_text)
+}
+
+/// new Response(body, statusOpt, statusTextPtrOpt, headersHandleOpt)
+/// - body_ptr: StringHeader for the body, or null for ""
+/// - status: f64 (200 default)
+/// - status_text_ptr: StringHeader for statusText, or null for ""
+/// - headers_handle: f64 numeric handle from js_headers_new, or 0
+#[no_mangle]
+pub unsafe extern "C" fn js_response_new(
+    body_ptr: *const StringHeader,
+    status: f64,
+    status_text_ptr: *const StringHeader,
+    headers_handle: f64,
+) -> f64 {
+    let body_stream_id = take_pending_fetch_body_stream_id();
+    // Consume before validation so a throwing constructor cannot leak body
+    // metadata into the next Response construction on this thread.
+    let body_content_type = take_pending_fetch_body_content_type();
+    // Lossless raw-byte read so binary bodies survive byte-for-byte (#5435).
+    let body_opt = dispatch::body_bytes_from_header(body_ptr);
+    let body_present = body_opt.is_some() || body_stream_id.is_some();
+    let body = body_opt.unwrap_or_default();
+    let (status_u16, status_text) = response_init(status, status_text_ptr, body_present);
     let headers_id = handle_id(headers_handle);
     let registered = (headers_id != 0)
         .then(|| HEADERS_REGISTRY.lock().unwrap().get(&headers_id).cloned())

crates/perry/src/commands/compile/collect_modules.rs

@@ -755,6 +755,19 @@ fn collect_module_one(
                 value: Box::new(perry_hir::Expr::NativeModuleRef("bun".to_string())),
             }),
         );
+        // #10360: tell the runtime too, for Web APIs whose Bun behavior
+        // differs from Node's. Same every-module seeding as above, so the
+        // flag is on before any dependency's top-level code runs.
+        hir_module.init.insert(
+            0,
+            perry_hir::Stmt::Expr(perry_hir::Expr::NativeMethodCall {
+                module: "__perry_runtime".to_string(),
+                class_name: None,
+                object: None,
+                method: "setBunPlatform".to_string(),
+                args: Vec::new(),
+            }),
+        );
     }
 
     // Preserve native result types before async lowering splits awaited values