fix(console): print AggregateError wrapper instead of dropping it

src/bun.js/VirtualMachine.zig

@@ -2454,31 +2454,10 @@ pub fn printErrorlikeObject(
         }
     }
 
-    if (value.isAggregateError(this.global)) {
-        const AggregateErrorIterator = struct {
-            writer: Writer,
-            current_exception_list: ?*ExceptionList = null,
-            formatter: *ConsoleObject.Formatter,
-
-            pub fn iteratorWithColor(vm: *VM, globalObject: *JSGlobalObject, ctx: ?*anyopaque, nextValue: JSValue) callconv(.c) void {
-                iterator(vm, globalObject, nextValue, ctx.?, true);
-            }
-            pub fn iteratorWithOutColor(vm: *VM, globalObject: *JSGlobalObject, ctx: ?*anyopaque, nextValue: JSValue) callconv(.c) void {
-                iterator(vm, globalObject, nextValue, ctx.?, false);
-            }
-            fn iterator(_: *VM, _: *JSGlobalObject, nextValue: JSValue, ctx: ?*anyopaque, comptime color: bool) void {
-                const this_ = @as(*@This(), @ptrFromInt(@intFromPtr(ctx)));
-                VirtualMachine.get().printErrorlikeObject(nextValue, null, this_.current_exception_list, this_.formatter, Writer, this_.writer, color, allow_side_effects);
-            }
-        };
-        var iter = AggregateErrorIterator{ .writer = writer, .current_exception_list = exception_list, .formatter = formatter };
-        if (comptime allow_ansi_color) {
-            value.getErrorsProperty(this.global).forEach(this.global, &iter, AggregateErrorIterator.iteratorWithColor) catch return; // TODO: properly propagate exception upwards
-        } else {
-            value.getErrorsProperty(this.global).forEach(this.global, &iter, AggregateErrorIterator.iteratorWithOutColor) catch return; // TODO: properly propagate exception upwards
-        }
-        return;
-    }
+    // AggregateError is handled by printErrorInstance, which prints the
+    // wrapper (name / message / stack) and then fans out the non-enumerable
+    // `errors` array via the errors_to_append queue — see the cause block
+    // there for the same pattern.
 
     was_internal = this.printErrorFromMaybePrivateData(
         value,
@@ -3289,6 +3268,26 @@ fn printErrorInstance(
                 }
             }
         }
+
+        // `AggregateError.errors` is a non-enumerable own property, so the
+        // property iterator above skips it. Walk it manually and queue each
+        // entry (of any type — Promise.any can reject with non-Error values)
+        // so the wrapper gets printed first, matching Node's `[errors]: [...]`
+        // format instead of the errors replacing it.
+        if (error_instance.isAggregateError(this.global)) {
+            const AggregateErrorsIterator = struct {
+                errors_to_append: *std.array_list.Managed(JSValue),
+
+                pub fn visit(_: *VM, _: *JSGlobalObject, ctx: ?*anyopaque, next_value: JSValue) callconv(.c) void {
+                    const self: *@This() = @ptrCast(@alignCast(ctx.?));
+                    next_value.protect();
+                    bun.handleOom(self.errors_to_append.append(next_value));
+                }
+            };
+            var errors_iter = AggregateErrorsIterator{ .errors_to_append = &errors_to_append };
+            const errors_array = error_instance.getErrorsProperty(this.global);
+            try errors_array.forEach(this.global, &errors_iter, AggregateErrorsIterator.visit);
+        }
     } else if (mode == .js and error_instance != .zero) {
         // If you do reportError([1,2,3]] we should still show something at least.
         const tag = try jsc.Formatter.Tag.getAdvanced(

test/internal/ban-limits.json

@@ -17,7 +17,7 @@
   "EXCEPTION_ASSERT(!scope.exception())": 0,
   "JSValue.false": 0,
   "JSValue.true": 0,
-  "TODO: properly propagate exception upwards": 114,
+  "TODO: properly propagate exception upwards": 112,
   "alloc.ptr !=": 0,
   "alloc.ptr ==": 0,
   "allocator.ptr !=": 1,

test/regression/issue/29157.test.ts

@@ -0,0 +1,75 @@
+// https://github.com/oven-sh/bun/issues/29157
+
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe } from "harness";
+
+test("console.dir on AggregateError prints the wrapper, not just the inner errors", async () => {
+  await using proc = Bun.spawn({
+    cmd: [
+      bunExe(),
+      "-e",
+      `const err = new AggregateError([new Error("child1"), new Error("child2")], "wrapper");
+       console.dir(err);`,
+    ],
+    env: bunEnv,
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  expect(stdout).toContain("AggregateError");
+  expect(stdout).toContain("wrapper");
+  expect(stdout).toContain("child1");
+  expect(stdout).toContain("child2");
+  expect(stderr).toBe("");
+  expect(exitCode).toBe(0);
+});
+
+test("Promise.any rejection surfaces as an AggregateError, not a stray inner error", async () => {
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "-e", `await Promise.any([Promise.reject(new Error("inner"))]).catch(console.dir);`],
+    env: bunEnv,
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  expect(stdout).toContain("AggregateError");
+  expect(stdout).toContain("inner");
+  expect(stderr).toBe("");
+  expect(exitCode).toBe(0);
+});
+
+test("uncaught AggregateError rejection still shows the wrapper", async () => {
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "-e", `await Promise.any([Promise.reject(new Error("a")), Promise.reject(new Error("b"))]);`],
+    env: bunEnv,
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  expect(stderr).toContain("AggregateError");
+  expect(stderr).toContain("a");
+  expect(stderr).toContain("b");
+  expect(exitCode).not.toBe(0);
+});
+
+test("AggregateError with a cause chain prints wrapper + errors + cause", async () => {
+  await using proc = Bun.spawn({
+    cmd: [
+      bunExe(),
+      "-e",
+      `const cause = new Error("root cause");
+       const err = new AggregateError([new Error("child")], "wrapper", { cause });
+       console.dir(err);`,
+    ],
+    env: bunEnv,
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  expect(stdout).toContain("AggregateError");
+  expect(stdout).toContain("wrapper");
+  expect(stdout).toContain("child");
+  expect(stdout).toContain("root cause");
+  expect(stderr).toBe("");
+  expect(exitCode).toBe(0);
+});