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

src/bun.js/VirtualMachine.zig

@@ -2454,31 +2454,10 @@
         }
     }
 
-    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,28 @@
                 }
             }
         }
+
+        // `AggregateError.errors` is a non-enumerable own property, so the
+        // property iterator above skips it. Walk it manually and queue each
+        // entry 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.?));
+                    if (next_value.jsType() == .ErrorInstance) {
+                        next_value.protect();
+                        bun.handleOom(self.errors_to_append.append(next_value));
+                    }
+                }
+            };
+            var errors_iter = AggregateErrorsIterator{ .errors_to_append = &errors_to_append };
+            error_instance.getErrorsProperty(this.global).forEach(this.global, &errors_iter, AggregateErrorsIterator.visit) catch {
+                if (this.global.hasException()) this.global.clearException();
+            };
+        }
     } 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/regression/issue/29157.test.ts

@@ -0,0 +1,116 @@
+// https://github.com/oven-sh/bun/issues/29157
+//
+// Bun's native `console.dir` / `console.log` formatter early-returned on any
+// AggregateError, walking `.errors` and printing each entry as a top-level
+// error — dropping the AggregateError wrapper's name, message, and stack.
+//
+// `Promise.any([Promise.reject(Error(""))]).catch(console.dir)` should print
+// `AggregateError: ... { [errors]: [ ... ] }` like Node. Bun instead printed
+// just the inner `Error` with no trace of the wrapper.
+//
+// Fix: removed the AggregateError early-return in `printErrorlikeObject` and
+// taught `printErrorInstance` to walk the non-enumerable `.errors` array the
+// same way it already walks `.cause`.
+
+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(exitCode).toBe(0);
+  // The wrapper's name + message must be in the output. Pre-fix, this was
+  // absent — the formatter printed only "error: child1 ... error: child2".
+  expect(stdout).toContain("AggregateError");
+  expect(stdout).toContain("wrapper");
+  // Children must still be printed below the wrapper.
+  expect(stdout).toContain("child1");
+  expect(stdout).toContain("child2");
+});
+
+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(exitCode).toBe(0);
+  // Pre-fix Bun printed `Error:` with no mention of AggregateError at all —
+  // exactly the bug from the issue report.
+  expect(stdout).toContain("AggregateError");
+  expect(stdout).toContain("inner");
+});
+
+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(exitCode).not.toBe(0);
+  // Uncaught rejection goes to stderr. The wrapper must appear there — the
+  // native error-reporter was fanning out `.errors` without printing the
+  // outer AggregateError at all.
+  expect(stderr).toContain("AggregateError");
+  expect(stderr).toContain("a");
+  expect(stderr).toContain("b");
+});
+
+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(exitCode).toBe(0);
+  expect(stdout).toContain("AggregateError");
+  expect(stdout).toContain("wrapper");
+  expect(stdout).toContain("child");
+  expect(stdout).toContain("root cause");
+});