Merge remote-tracking branch 'origin/main' into claude/add-only-failures-flag

Author: pfgithub

docs/runtime/bunfig.md

@@ -284,6 +284,46 @@ junit = "test-results.xml"
 
 This generates a JUnit XML report that can be consumed by CI systems and other tools.
 
+### `test.randomize`
+
+Run tests in random order. Default `false`.
+
+```toml
+[test]
+randomize = true
+```
+
+This helps catch bugs related to test interdependencies by running tests in a different order each time. When combined with `seed`, the random order becomes reproducible.
+
+The `--randomize` CLI flag will override this setting when specified.
+
+### `test.seed`
+
+Set the random seed for test randomization. This option requires `randomize` to be `true`.
+
+```toml
+[test]
+randomize = true
+seed = 2444615283
+```
+
+Using a seed makes the randomized test order reproducible across runs, which is useful for debugging flaky tests. When you encounter a test failure with randomization enabled, you can use the same seed to reproduce the exact test order.
+
+The `--seed` CLI flag will override this setting when specified.
+
+### `test.rerunEach`
+
+Re-run each test file a specified number of times. Default `0` (run once).
+
+```toml
+[test]
+rerunEach = 3
+```
+
+This is useful for catching flaky tests or non-deterministic behavior. Each test file will be executed the specified number of times.
+
+The `--rerun-each` CLI flag will override this setting when specified.
+
 ## Package manager
 
 Package management is a complex issue; to support a range of use cases, the behavior of `bun install` can be configured under the `[install]` section.

src/CLAUDE.md

@@ -1,5 +1,12 @@
 ## Zig
 
+Syntax reminders:
+
+- Private fields are fully supported in Zig with the `#` prefix. `struct { #foo: u32 };` makes a struct with a private field named `#foo`.
+- Decl literals in Zig are recommended. `const decl: Decl = .{ .binding = 0, .value = 0 };`
+
+Conventions:
+
 - Prefer `@import` at the **bottom** of the file.
 - It's `@import("bun")` not `@import("root").bun`
 - You must be patient with the build.

src/bun.js/api/BunObject.zig

@@ -1837,31 +1837,10 @@ pub const JSZstd = struct {
         const input = buffer.slice();
         const allocator = bun.default_allocator;
 
-        // Try to get the decompressed size
-        const decompressed_size = bun.zstd.getDecompressedSize(input);
-
-        if (decompressed_size == std.math.maxInt(c_ulonglong) - 1 or decompressed_size == std.math.maxInt(c_ulonglong) - 2) {
-            // If size is unknown, we'll need to decompress in chunks
-            return globalThis.ERR(.ZSTD, "Decompressed size is unknown. Either the input is not a valid zstd compressed buffer or the decompressed size is too large. If you run into this error with a valid input, please file an issue at https://github.com/oven-sh/bun/issues", .{}).throw();
-        }
-
-        // Allocate output buffer based on decompressed size
-        var output = try allocator.alloc(u8, decompressed_size);
-
-        // Perform decompression
-        const actual_size = switch (bun.zstd.decompress(output, input)) {
-            .success => |actual_size| actual_size,
-            .err => |err| {
-                allocator.free(output);
-                return globalThis.ERR(.ZSTD, "{s}", .{err}).throw();
-            },
+        const output = bun.zstd.decompressAlloc(allocator, input) catch |err| {
+            return globalThis.ERR(.ZSTD, "Decompression failed: {s}", .{@errorName(err)}).throw();
         };
 
-        bun.debugAssert(actual_size <= output.len);
-
-        // mimalloc doesn't care about the self-reported size of the slice.
-        output.len = actual_size;
-
         return jsc.JSValue.createBuffer(globalThis, output);
     }
 
@@ -1918,34 +1897,10 @@ pub const JSZstd = struct {
                 };
             } else {
                 // Decompression path
-                // Try to get the decompressed size
-                const decompressed_size = bun.zstd.getDecompressedSize(input);
-
-                if (decompressed_size == std.math.maxInt(c_ulonglong) - 1 or decompressed_size == std.math.maxInt(c_ulonglong) - 2) {
-                    job.error_message = "Decompressed size is unknown. Either the input is not a valid zstd compressed buffer or the decompressed size is too large";
-                    return;
-                }
-
-                // Allocate output buffer based on decompressed size
-                job.output = allocator.alloc(u8, decompressed_size) catch {
-                    job.error_message = "Out of memory";
+                job.output = bun.zstd.decompressAlloc(allocator, input) catch {
+                    job.error_message = "Decompression failed";
                     return;
                 };
-
-                // Perform decompression
-                switch (bun.zstd.decompress(job.output, input)) {
-                    .success => |actual_size| {
-                        if (actual_size < job.output.len) {
-                            job.output.len = actual_size;
-                        }
-                    },
-                    .err => |err| {
-                        allocator.free(job.output);
-                        job.output = &[_]u8{};
-                        job.error_message = err;
-                        return;
-                    },
-                }
             }
         }
 

src/bun.js/bindings/NodeVM.cpp

@@ -736,6 +736,8 @@ Structure* NodeVMGlobalObject::createStructure(JSC::VM& vm, JSC::JSValue prototy
     return JSC::Structure::create(vm, nullptr, prototype, JSC::TypeInfo(JSC::GlobalObjectType, StructureFlags & ~IsImmutablePrototypeExoticObject), info());
 }
 
+void unsafeEvalNoop(JSGlobalObject*, const WTF::String&) {}
+
 const JSC::GlobalObjectMethodTable& NodeVMGlobalObject::globalObjectMethodTable()
 {
     static const JSC::GlobalObjectMethodTable table {
@@ -753,7 +755,7 @@ const JSC::GlobalObjectMethodTable& NodeVMGlobalObject::globalObjectMethodTable(
         &reportUncaughtExceptionAtEventLoop,
         &currentScriptExecutionOwner,
         &scriptExecutionStatus,
-        nullptr, // reportViolationForUnsafeEval
+        &unsafeEvalNoop, // reportViolationForUnsafeEval
         nullptr, // defaultLanguage
         nullptr, // compileStreaming
         nullptr, // instantiateStreaming

src/bun.js/bindings/ZigGlobalObject.cpp

@@ -1240,6 +1240,9 @@ JSC::ScriptExecutionStatus Zig::GlobalObject::scriptExecutionStatus(JSC::JSGloba
     }
     }
 }
+
+void unsafeEvalNoop(JSGlobalObject*, const WTF::String&) {}
+
 const JSC::GlobalObjectMethodTable& GlobalObject::globalObjectMethodTable()
 {
     static const JSC::GlobalObjectMethodTable table = {
@@ -1257,7 +1260,7 @@ const JSC::GlobalObjectMethodTable& GlobalObject::globalObjectMethodTable()
         &reportUncaughtExceptionAtEventLoop,
         &currentScriptExecutionOwner,
         &scriptExecutionStatus,
-        nullptr, // reportViolationForUnsafeEval
+        &unsafeEvalNoop, // reportViolationForUnsafeEval
         nullptr, // defaultLanguage
         &compileStreaming,
         &instantiateStreaming,
@@ -1287,7 +1290,7 @@ const JSC::GlobalObjectMethodTable& EvalGlobalObject::globalObjectMethodTable()
         &reportUncaughtExceptionAtEventLoop,
         &currentScriptExecutionOwner,
         &scriptExecutionStatus,
-        nullptr, // reportViolationForUnsafeEval
+        &unsafeEvalNoop, // reportViolationForUnsafeEval
         nullptr, // defaultLanguage
         &compileStreaming,
         &instantiateStreaming,

src/bun.js/bindings/highway_strings.cpp

@@ -444,7 +444,7 @@ static size_t IndexOfNeedsEscapeForJavaScriptStringImpl(const uint8_t* HWY_RESTR
     // Set up SIMD constants
     const auto vec_backslash = hn::Set(d, uint8_t { '\\' });
     const auto vec_min_ascii = hn::Set(d, uint8_t { 0x20 });
-    const auto vec_max_ascii = hn::Set(d, uint8_t { 127 });
+    const auto vec_max_ascii = hn::Set(d, uint8_t { 0x7E });
     const auto vec_quote = hn::Set(d, quote_char);
 
     const auto vec_dollar = hn::Set(d, uint8_t { '$' });
@@ -482,7 +482,7 @@ static size_t IndexOfNeedsEscapeForJavaScriptStringImpl(const uint8_t* HWY_RESTR
     // Scalar check for the remainder
     for (; i < text_len; ++i) {
         const uint8_t char_ = text[i];
-        if (char_ >= 127 || (char_ < 0x20 && char_ != 0x09) || char_ == '\\' || char_ == quote_char || (is_backtick && char_ == '$')) {
+        if (char_ >= 127 || char_ < 0x20 || char_ == '\\' || char_ == quote_char || (is_backtick && char_ == '$')) {
             return i;
         }
     }

src/bun.js/node/path.zig

@@ -2767,35 +2767,55 @@ pub fn resolve(globalObject: *jsc.JSGlobalObject, isWindows: bool, args_ptr: [*]
     var stack_fallback = std.heap.stackFallback(stack_fallback_size_large, arena.allocator());
     const allocator = stack_fallback.get();
 
-    var paths = try allocator.alloc(string, args_len);
-    defer allocator.free(paths);
-    var path_count: usize = 0;
+    var paths_buf = try allocator.alloc(string, args_len);
+    defer allocator.free(paths_buf);
+    var paths_offset: usize = args_len;
+    var resolved_root = false;
 
-    for (0..args_len, args_ptr) |i, path_ptr| {
-        // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
-        try validateString(globalObject, path_ptr, "paths[{d}]", .{i});
-        const pathZStr = try path_ptr.getZigString(globalObject);
-        if (pathZStr.len > 0) {
-            paths[path_count] = pathZStr.toSlice(allocator).slice();
-            path_count += 1;
+    var i = args_len;
+    while (i > 0) {
+        i -= 1;
+
+        if (resolved_root) {
+            break;
+        }
+
+        const path = args_ptr[i];
+        try validateString(globalObject, path, "paths[{d}]", .{i});
+        const path_str = try path.toBunString(globalObject);
+        defer path_str.deref();
+
+        if (path_str.length() == 0) {
+            continue;
+        }
+
+        paths_offset -= 1;
+        paths_buf[paths_offset] = path_str.toSlice(allocator).slice();
+
+        if (!isWindows) {
+            if (path_str.charAt(0) == CHAR_FORWARD_SLASH) {
+                resolved_root = true;
+            }
         }
     }
 
+    const paths = paths_buf[paths_offset..];
+
     if (comptime Environment.isPosix) {
         if (!isWindows) {
             // Micro-optimization #1: avoid creating a new string when passing no arguments or only empty strings.
-            if (path_count == 0) {
+            if (paths.len == 0) {
                 return Process__getCachedCwd(globalObject);
             }
 
             // Micro-optimization #2: path.resolve(".") and path.resolve("./") === process.cwd()
-            else if (path_count == 1 and (strings.eqlComptime(paths[0], ".") or strings.eqlComptime(paths[0], "./"))) {
+            else if (paths.len == 1 and (strings.eqlComptime(paths[0], ".") or strings.eqlComptime(paths[0], "./"))) {
                 return Process__getCachedCwd(globalObject);
             }
         }
     }
 
-    return resolveJS_T(u8, globalObject, allocator, isWindows, paths[0..path_count]);
+    return resolveJS_T(u8, globalObject, allocator, isWindows, paths);
 }
 
 /// Based on Node v21.6.1 path.win32.toNamespacedPath:

src/bunfig.zig

@@ -334,6 +334,33 @@ pub const Bunfig = struct {
                         this.ctx.test_options.coverage.skip_test_files = expr.data.e_boolean.value;
                     }
 
+                    var randomize_from_config: ?bool = null;
+
+                    if (test_.get("randomize")) |expr| {
+                        try this.expect(expr, .e_boolean);
+                        randomize_from_config = expr.data.e_boolean.value;
+                        this.ctx.test_options.randomize = expr.data.e_boolean.value;
+                    }
+
+                    if (test_.get("seed")) |expr| {
+                        try this.expect(expr, .e_number);
+                        const seed_value = expr.data.e_number.toU32();
+
+                        // Validate that randomize is true when seed is specified
+                        // Either randomize must be set to true in this config, or already enabled
+                        const has_randomize_true = (randomize_from_config orelse this.ctx.test_options.randomize);
+                        if (!has_randomize_true) {
+                            try this.addError(expr.loc, "\"seed\" can only be used when \"randomize\" is true");
+                        }
+
+                        this.ctx.test_options.seed = seed_value;
+                    }
+
+                    if (test_.get("rerunEach")) |expr| {
+                        try this.expect(expr, .e_number);
+                        this.ctx.test_options.repeat_count = expr.data.e_number.toU32();
+                    }
+
                     if (test_.get("concurrentTestGlob")) |expr| {
                         switch (expr.data) {
                             .e_string => |str| {

src/deps/zstd.zig

@@ -33,6 +33,47 @@ pub fn decompress(dest: []u8, src: []const u8) Result {
     return .{ .success = result };
 }
 
+/// Decompress data, automatically allocating the output buffer.
+/// Returns owned slice that must be freed by the caller.
+/// Handles both frames with known and unknown content sizes.
+/// For safety, if the reported decompressed size exceeds 16MB, streaming decompression is used instead.
+pub fn decompressAlloc(allocator: std.mem.Allocator, src: []const u8) ![]u8 {
+    const size = getDecompressedSize(src);
+
+    const ZSTD_CONTENTSIZE_UNKNOWN = std.math.maxInt(c_ulonglong); // 0ULL - 1
+    const ZSTD_CONTENTSIZE_ERROR = std.math.maxInt(c_ulonglong) - 1; // 0ULL - 2
+    const MAX_PREALLOCATE_SIZE = 16 * 1024 * 1024; // 16MB safety limit
+
+    if (size == ZSTD_CONTENTSIZE_ERROR) {
+        return error.InvalidZstdData;
+    }
+
+    // Use streaming decompression if:
+    // 1. Content size is unknown, OR
+    // 2. Reported size exceeds safety limit (to prevent malicious inputs claiming huge sizes)
+    if (size == ZSTD_CONTENTSIZE_UNKNOWN or size > MAX_PREALLOCATE_SIZE) {
+        var list = std.ArrayListUnmanaged(u8){};
+        const reader = try ZstdReaderArrayList.init(src, &list, allocator);
+        defer reader.deinit();
+
+        try reader.readAll(true);
+        return try list.toOwnedSlice(allocator);
+    }
+
+    // Fast path: size is known and within reasonable limits
+    const output = try allocator.alloc(u8, size);
+    errdefer allocator.free(output);
+
+    const result = decompress(output, src);
+    return switch (result) {
+        .success => |actual_size| output[0..actual_size],
+        .err => {
+            allocator.free(output);
+            return error.DecompressionFailed;
+        },
+    };
+}
+
 pub fn getDecompressedSize(src: []const u8) usize {
     return ZSTD_findDecompressedSize(src.ptr, src.len);
 }

src/js/node/zlib.ts

@@ -642,7 +642,7 @@ function Unzip(opts): void {
 }
 $toClass(Unzip, "Unzip", Zlib);
 
-function createConvenienceMethod(ctor, sync, methodName) {
+function createConvenienceMethod(ctor, sync, methodName, isZstd) {
   if (sync) {
     const fn = function (buffer, opts) {
       return zlibBufferSync(new ctor(opts), buffer);
@@ -655,6 +655,25 @@ function createConvenienceMethod(ctor, sync, methodName) {
         callback = opts;
         opts = {};
       }
+      // For zstd compression, we need to set pledgedSrcSize to the buffer size
+      // so that the content size is included in the frame header
+      if (isZstd) {
+        // Calculate buffer size
+        let bufferSize;
+        if (typeof buffer === "string") {
+          bufferSize = Buffer.byteLength(buffer);
+        } else if (isArrayBufferView(buffer)) {
+          bufferSize = buffer.byteLength;
+        } else if (isAnyArrayBuffer(buffer)) {
+          bufferSize = buffer.byteLength;
+        } else {
+          bufferSize = 0;
+        }
+        // Set pledgedSrcSize if not already set
+        if (!opts.pledgedSrcSize && bufferSize > 0) {
+          opts = { ...opts, pledgedSrcSize: bufferSize };
+        }
+      }
       return zlibBuffer(new ctor(opts), buffer, callback);
     };
     ObjectDefineProperty(fn, "name", { value: methodName });
@@ -813,7 +832,7 @@ const zlib = {
   brotliCompressSync: createConvenienceMethod(BrotliCompress, true, "brotliCompressSync"),
   brotliDecompress: createConvenienceMethod(BrotliDecompress, false, "brotliDecompress"),
   brotliDecompressSync: createConvenienceMethod(BrotliDecompress, true, "brotliDecompressSync"),
-  zstdCompress: createConvenienceMethod(ZstdCompress, false, "zstdCompress"),
+  zstdCompress: createConvenienceMethod(ZstdCompress, false, "zstdCompress", true),
   zstdCompressSync: createConvenienceMethod(ZstdCompress, true, "zstdCompressSync"),
   zstdDecompress: createConvenienceMethod(ZstdDecompress, false, "zstdDecompress"),
   zstdDecompressSync: createConvenienceMethod(ZstdDecompress, true, "zstdDecompressSync"),