[autofix.ci] apply automated fixes

- Await response.arrayBuffer() instead of setTimeout()
- Verify response contains remapped stack trace data
- More reliable and faster test execution
- Maintains same test coverage and verification

src/bake/DevServer.zig

@@ -22,6 +22,7 @@ pub const Options = struct {
     framework: bake.Framework,
     bundler_options: bake.SplitBundlerOptions,
     broadcast_console_log_from_browser_to_server: bool,
+    enable_uncaught_exception_reporting_from_browser_to_terminal: bool,
 
     // Debugging features
     dump_sources: ?[]const u8 = if (Environment.isDebug) ".bake-debug" else null,
@@ -232,6 +233,7 @@ assume_perfect_incremental_bundling: bool = false,
 /// - Echoing browser console logs to the server for debugging
 /// - WebKit Inspector remote debugging integration
 broadcast_console_log_from_browser_to_server: bool,
+enable_uncaught_exception_reporting_from_browser_to_terminal: bool,
 
 pub const internal_prefix = "/_bun";
 /// Assets which are routed to the `Assets` storage.
@@ -318,6 +320,7 @@ pub fn init(options: Options) bun.JSOOM!*DevServer {
             bun.getRuntimeFeatureFlag(.BUN_ASSUME_PERFECT_INCREMENTAL),
         .testing_batch_events = .disabled,
         .broadcast_console_log_from_browser_to_server = options.broadcast_console_log_from_browser_to_server,
+        .enable_uncaught_exception_reporting_from_browser_to_terminal = options.enable_uncaught_exception_reporting_from_browser_to_terminal,
         .server_transpiler = undefined,
         .client_transpiler = undefined,
         .ssr_transpiler = undefined,
@@ -667,6 +670,7 @@ pub fn deinit(dev: *DevServer) void {
             .enable_after_bundle => {},
         },
         .broadcast_console_log_from_browser_to_server = {},
+        .enable_uncaught_exception_reporting_from_browser_to_terminal = {},
 
         .magic = {
             bun.debugAssert(dev.magic == .valid);

src/bake/DevServer/ErrorReportRequest.zig

@@ -225,17 +225,19 @@ pub fn runWithBody(ctx: *ErrorReportRequest, body: []const u8, r: AnyResponse) !
         .browser_url = .init(browser_url),
     };
 
-    const stderr = Output.errorWriterBuffered();
-    defer Output.flush();
-    switch (Output.enable_ansi_colors_stderr) {
-        inline else => |ansi_colors| ctx.dev.vm.printExternallyRemappedZigException(
-            &exception,
-            null,
-            @TypeOf(stderr),
-            stderr,
-            true,
-            ansi_colors,
-        ) catch {},
+    if (ctx.dev.enable_uncaught_exception_reporting_from_browser_to_terminal) {
+        const stderr = Output.errorWriterBuffered();
+        defer Output.flush();
+        switch (Output.enable_ansi_colors_stderr) {
+            inline else => |ansi_colors| ctx.dev.vm.printExternallyRemappedZigException(
+                &exception,
+                null,
+                @TypeOf(stderr),
+                stderr,
+                true,
+                ansi_colors,
+            ) catch {},
+        }
     }
 
     var out: std.ArrayList(u8) = .init(ctx.dev.allocator());

src/bake/DevServer/memory_cost.zig

@@ -57,6 +57,7 @@ pub fn memoryCostDetailed(dev: *DevServer) MemoryCost {
         .bundler_options = {},
         .allocation_scope = {},
         .broadcast_console_log_from_browser_to_server = {},
+        .enable_uncaught_exception_reporting_from_browser_to_terminal = {},
         // to be counted.
         .root = {
             other_bytes += dev.root.len;

src/bun.js/api/server.zig

@@ -1640,6 +1640,7 @@ pub fn NewServer(protocol_enum: enum { http, https }, development_kind: enum { d
                     .bundler_options = bake_options.bundler_options,
                     .vm = global.bunVM(),
                     .broadcast_console_log_from_browser_to_server = config.broadcast_console_log_from_browser_to_server_for_bake,
+                    .enable_uncaught_exception_reporting_from_browser_to_terminal = config.enable_uncaught_exception_reporting_from_browser_to_terminal_for_bake,
                 })
             else
                 null;

src/bun.js/api/server/ServerConfig.zig

@@ -34,6 +34,7 @@ sni: ?bun.BabyList(SSLConfig) = null,
 max_request_body_size: usize = 1024 * 1024 * 128,
 development: DevelopmentOption = .development,
 broadcast_console_log_from_browser_to_server_for_bake: bool = false,
+enable_uncaught_exception_reporting_from_browser_to_terminal_for_bake: bool = true,
 
 /// Enable automatic workspace folders for Chrome DevTools
 /// https://chromium.googlesource.com/devtools/devtools-frontend/+/main/docs/ecosystem/automatic_workspace_folders.md
@@ -469,6 +470,7 @@ pub fn fromJS(
 
                 if (try dev.getBooleanStrict(global, "console")) |console| {
                     args.broadcast_console_log_from_browser_to_server_for_bake = console;
+                    args.enable_uncaught_exception_reporting_from_browser_to_terminal_for_bake = console;
                 }
 
                 if (try dev.getBooleanStrict(global, "chromeDevToolsAutomaticWorkspaceFolders")) |enable_chrome_devtools_automatic_workspace_folders| {

test/bake/dev/console-false-disables-error-reporting.test.ts

@@ -0,0 +1,162 @@
+import { expect } from "bun:test";
+import { devTest, minimalFramework } from "../bake-harness";
+
+devTest("error reporting is enabled by default", {
+  framework: minimalFramework,
+  files: {
+    "routes/index.ts": `
+export default function (req, meta) {
+  return new Response("Hello World");
+}
+`,
+  },
+  async test(dev) {
+    // Test that server starts
+    const response = await dev.fetch("/");
+    expect(response.status).toBe(200);
+
+    // Simulate client-side error by posting to /_bun/report_error endpoint
+    // This tests the ErrorReportRequest.zig code path directly
+    const errorData = createErrorReportData(
+      "TestError",
+      "Test client-side error - should be printed",
+      "http://localhost/test",
+    );
+
+    const reportResponse = await dev.fetch("/_bun/report_error", {
+      method: "POST",
+      body: errorData,
+    });
+
+    // The error reporting endpoint should process the request
+    expect(reportResponse.status).toBe(200);
+
+    // Await the response data to ensure the error processing is complete
+    // The response contains remapped stack trace data
+    const responseData = await reportResponse.arrayBuffer();
+    expect(responseData.byteLength).toBeGreaterThan(0);
+
+    // With default configuration, the error should be printed to terminal
+    // (visible in test output as "frontend TestError: Test client-side error - should be printed")
+  },
+});
+
+devTest("error reporting is disabled with console: false", {
+  files: {
+    "minimal.server.ts": `
+import { Bake } from "bun";
+
+export function render(req: Request, meta: Bake.RouteMetadata) {
+  if (typeof meta.pageModule.default !== "function") {
+    console.error("pageModule === ", meta.pageModule);
+    throw new Error("Expected default export to be a function");
+  }
+  return meta.pageModule.default(req, meta);
+}
+
+export function registerClientReference(value: any, file: any, uid: any) {
+  return {
+    value,
+    file,
+    uid,
+  };
+}
+`,
+    "bun.app.ts": `
+export default {
+  port: 0,
+  app: {
+    framework: {
+      fileSystemRouterTypes: [
+        {
+          root: "routes",
+          style: "nextjs-pages",
+          serverEntryPoint: "./minimal.server.ts",
+        },
+      ],
+      serverComponents: {
+        separateSSRGraph: false,
+        serverRuntimeImportSource: "./minimal.server.ts",
+        serverRegisterClientReferenceExport: "registerClientReference",
+      },
+    },
+  },
+  development: {
+    console: false,
+  },
+};
+`,
+    "routes/index.ts": `
+export default function (req, meta) {
+  return new Response("Hello World with console false");
+}
+`,
+  },
+  async test(dev) {
+    // Test that server starts with console: false
+    const response = await dev.fetch("/");
+    expect(response.status).toBe(200);
+
+    // Simulate client-side error by posting to /_bun/report_error endpoint
+    const errorData = createErrorReportData(
+      "TestError",
+      "Test client-side error - should be suppressed",
+      "http://localhost/test",
+    );
+
+    const reportResponse = await dev.fetch("/_bun/report_error", {
+      method: "POST",
+      body: errorData,
+    });
+
+    // The error reporting endpoint should still process the request
+    expect(reportResponse.status).toBe(200);
+
+    // Await the response data to ensure the error processing is complete
+    // The response contains remapped stack trace data
+    const responseData = await reportResponse.arrayBuffer();
+    expect(responseData.byteLength).toBeGreaterThan(0);
+
+    // With console: false, the error should NOT be printed to terminal
+    // (no "frontend TestError" output should appear in test output)
+  },
+});
+
+// Helper function to create binary error report data matching the protocol
+function createErrorReportData(name: string, message: string, browserUrl: string): ArrayBuffer {
+  // Simple implementation that matches the protocol described in ErrorReportRequest.zig
+  const encoder = new TextEncoder();
+  const nameBytes = encoder.encode(name);
+  const messageBytes = encoder.encode(message);
+  const urlBytes = encoder.encode(browserUrl);
+
+  // Calculate buffer size: 3 length fields + string data + frame count (0 frames for simplicity)
+  const bufferSize = 4 + nameBytes.length + 4 + messageBytes.length + 4 + urlBytes.length + 4;
+  const buffer = new ArrayBuffer(bufferSize);
+  const view = new DataView(buffer);
+
+  let offset = 0;
+
+  // Write name
+  view.setUint32(offset, nameBytes.length, true);
+  offset += 4;
+  new Uint8Array(buffer, offset, nameBytes.length).set(nameBytes);
+  offset += nameBytes.length;
+
+  // Write message
+  view.setUint32(offset, messageBytes.length, true);
+  offset += 4;
+  new Uint8Array(buffer, offset, messageBytes.length).set(messageBytes);
+  offset += messageBytes.length;
+
+  // Write browser URL
+  view.setUint32(offset, urlBytes.length, true);
+  offset += 4;
+  new Uint8Array(buffer, offset, urlBytes.length).set(urlBytes);
+  offset += urlBytes.length;
+
+  // Write frame count (0 frames)
+  view.setUint32(offset, 0, true);
+
+  return buffer;
+}