Upgrade Zig (#2151)

* fixup

* Upgrade Zig

* Remove bad assertion

* strings

* bump

* mode -> optimize

* optimize

* Linux build

* Update bindgen.zig

30 files changed, 201 insertions, 177 deletions

diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig
index 78927f85a..fd91ef897 100644
--- a/src/bun.js/api/bun.zig
+++ b/src/bun.js/api/bun.zig
@@ -456,7 +456,7 @@ pub fn getArgv(
     var allocator = argv_list.get();
     var argv = allocator.alloc(ZigString, std.os.argv.len) catch unreachable;
     defer if (argv.len > 128) allocator.free(argv);
-    for (std.os.argv) |arg, i| {
+    for (std.os.argv, 0..) |arg, i| {
         argv[i] = ZigString.init(std.mem.span(arg));
     }
 
@@ -504,7 +504,7 @@ pub fn getFilePath(ctx: js.JSContextRef, arguments: []const js.JSValueRef, buf:
         var temp_strings_list: [32]string = undefined;
         var temp_strings_list_len: u8 = 0;
         defer {
-            for (temp_strings_list[0..temp_strings_list_len]) |_, i| {
+            for (temp_strings_list[0..temp_strings_list_len], 0..) |_, i| {
                 temp_strings_list[i] = "";
             }
         }
@@ -680,7 +680,7 @@ pub fn getRouteFiles(
     const router = &VirtualMachine.get().bundler.router.?;
     const list = router.getPublicPaths() catch unreachable;
 
-    for (routes_list_strings[0..@min(list.len, routes_list_strings.len)]) |_, i| {
+    for (routes_list_strings[0..@min(list.len, routes_list_strings.len)], 0..) |_, i| {
         routes_list_strings[i] = ZigString.init(list[i]);
     }
 
@@ -701,7 +701,7 @@ pub fn getRouteNames(
     const router = &VirtualMachine.get().bundler.router.?;
     const list = router.getNames() catch unreachable;
 
-    for (routes_list_strings[0..@min(list.len, routes_list_strings.len)]) |_, i| {
+    for (routes_list_strings[0..@min(list.len, routes_list_strings.len)], 0..) |_, i| {
         routes_list_strings[i] = ZigString.init(list[i]);
     }
 
@@ -1452,7 +1452,7 @@ pub const Crypto = struct {
                 var all = std.EnumArray(Algorithm, ZigString).initUndefined();
                 var iter = all.iterator();
                 while (iter.next()) |entry| {
-                    entry.value.* = ZigString.init(std.mem.span(@tagName(entry.key)));
+                    entry.value.* = ZigString.init(@tagName(entry.key));
                 }
                 break :brk all;
             };
@@ -1612,7 +1612,7 @@ pub const Crypto = struct {
             this: *CryptoHasher,
             globalObject: *JSC.JSGlobalObject,
         ) callconv(.C) JSC.JSValue {
-            return ZigString.fromUTF8(std.mem.span(@tagName(this.evp.algorithm))).toValueGC(globalObject);
+            return ZigString.fromUTF8(bun.asByteSlice(@tagName(this.evp.algorithm))).toValueGC(globalObject);
         }
 
         pub fn getAlgorithms(
@@ -3976,7 +3976,7 @@ pub const EnvironmentVariables = struct {
         var vm = globalObject.bunVM();
         const keys = vm.bundler.env.map.map.keys();
         const max = @min(names.len, keys.len);
-        for (keys[0..max]) |key, i| {
+        for (keys[0..max], 0..) |key, i| {
             names[i] = ZigString.initUTF8(key);
         }
         return keys.len;
diff --git a/src/bun.js/api/bun/socket.zig b/src/bun.js/api/bun/socket.zig
index cf482e242..e18d7f9e5 100644
--- a/src/bun.js/api/bun/socket.zig
+++ b/src/bun.js/api/bun/socket.zig
@@ -578,7 +578,7 @@ pub const Listener = struct {
         }
 
         if (ssl) |ssl_config| {
-            if (std.mem.span(ssl_config.server_name).len > 0)
+            if (bun.asByteSlice(ssl_config.server_name).len > 0)
                 uws.us_socket_context_add_server_name(1, socket.socket_context, ssl_config.server_name, ctx_opts, null);
         }
 
diff --git a/src/bun.js/api/bun/spawn.zig b/src/bun.js/api/bun/spawn.zig
index b71e49dbc..8f52109f7 100644
--- a/src/bun.js/api/bun/spawn.zig
+++ b/src/bun.js/api/bun/spawn.zig
@@ -207,7 +207,9 @@ pub const PosixSpawn = struct {
         );
         if (comptime bun.Environment.allow_assert)
             JSC.Node.Syscall.syslog("posix_spawn({s}) = {d} ({d})", .{
-                path, rc, pid,
+                path,
+                rc,
+                pid,
             });
 
         if (comptime bun.Environment.isLinux) {
diff --git a/src/bun.js/api/bun/subprocess.zig b/src/bun.js/api/bun/subprocess.zig
index 614bff0ad..bb31f3dff 100644
--- a/src/bun.js/api/bun/subprocess.zig
+++ b/src/bun.js/api/bun/subprocess.zig
@@ -1119,8 +1119,9 @@ pub const Subprocess = struct {
                             };
 
                             if (key.eqlComptime("PATH")) {
-                                PATH = bun.span(line["PATH=".len..]);
+                                PATH = bun.asByteSlice(line["PATH=".len..]);
                             }
+
                             env_array.append(allocator, line) catch {
                                 globalThis.throw("out of memory", .{});
                                 return .zero;
diff --git a/src/bun.js/api/ffi.zig b/src/bun.js/api/ffi.zig
index 2e493cebe..89192dc85 100644
--- a/src/bun.js/api/ffi.zig
+++ b/src/bun.js/api/ffi.zig
@@ -217,7 +217,7 @@ pub const FFI = struct {
         }
         JSC.markBinding(@src());
         var zig_strings = allocator.alloc(ZigString, symbols.count()) catch unreachable;
-        for (symbols.values()) |*function, i| {
+        for (symbols.values(), 0..) |*function, i| {
             var arraylist = std.ArrayList(u8).init(allocator);
             var writer = arraylist.writer();
             function.printSourceCode(&writer) catch {
@@ -330,9 +330,9 @@ pub const FFI = struct {
             // optional if the user passed "ptr"
             if (function.symbol_from_dynamic_library == null) {
                 var resolved_symbol = dylib.lookup(*anyopaque, function_name) orelse {
-                    const ret = JSC.toInvalidArguments("Symbol \"{s}\" not found in \"{s}\"", .{ std.mem.span(function_name), name_slice.slice() }, global);
+                    const ret = JSC.toInvalidArguments("Symbol \"{s}\" not found in \"{s}\"", .{ bun.asByteSlice(function_name), name_slice.slice() }, global);
                     for (symbols.values()) |*value| {
-                        allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                        allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                         value.arg_types.clearAndFree(allocator);
                     }
                     symbols.clearAndFree(allocator);
@@ -345,12 +345,12 @@ pub const FFI = struct {
 
             function.compile(allocator) catch |err| {
                 const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\" in \"{s}\"", .{
-                    std.mem.span(@errorName(err)),
-                    std.mem.span(function_name),
+                    bun.asByteSlice(@errorName(err)),
+                    bun.asByteSlice(function_name),
                     name_slice.slice(),
                 }, global);
                 for (symbols.values()) |*value| {
-                    allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                    allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                     value.arg_types.clearAndFree(allocator);
                 }
                 symbols.clearAndFree(allocator);
@@ -360,7 +360,7 @@ pub const FFI = struct {
             switch (function.step) {
                 .failed => |err| {
                     for (symbols.values()) |*value| {
-                        allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                        allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                         value.arg_types.clearAndFree(allocator);
                     }
 
@@ -372,7 +372,7 @@ pub const FFI = struct {
                 },
                 .pending => {
                     for (symbols.values()) |*value| {
-                        allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                        allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                         value.arg_types.clearAndFree(allocator);
                     }
                     symbols.clearAndFree(allocator);
@@ -380,7 +380,7 @@ pub const FFI = struct {
                     return ZigString.init("Failed to compile (nothing happend!)").toErrorInstance(global);
                 },
                 .compiled => |*compiled| {
-                    const str = ZigString.init(std.mem.span(function_name));
+                    const str = ZigString.init(bun.asByteSlice(function_name));
                     const cb = JSC.NewRuntimeFunction(
                         global,
                         &str,
@@ -433,9 +433,9 @@ pub const FFI = struct {
             const function_name = function.base_name.?;
 
             if (function.symbol_from_dynamic_library == null) {
-                const ret = JSC.toInvalidArguments("Symbol for \"{s}\" not found", .{std.mem.span(function_name)}, global);
+                const ret = JSC.toInvalidArguments("Symbol for \"{s}\" not found", .{bun.asByteSlice(function_name)}, global);
                 for (symbols.values()) |*value| {
-                    allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                    allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                     value.arg_types.clearAndFree(allocator);
                 }
                 symbols.clearAndFree(allocator);
@@ -444,11 +444,11 @@ pub const FFI = struct {
 
             function.compile(allocator) catch |err| {
                 const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\"", .{
-                    std.mem.span(@errorName(err)),
-                    std.mem.span(function_name),
+                    bun.asByteSlice(@errorName(err)),
+                    bun.asByteSlice(function_name),
                 }, global);
                 for (symbols.values()) |*value| {
-                    allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                    allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                     value.arg_types.clearAndFree(allocator);
                 }
                 symbols.clearAndFree(allocator);
@@ -457,7 +457,7 @@ pub const FFI = struct {
             switch (function.step) {
                 .failed => |err| {
                     for (symbols.values()) |*value| {
-                        allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                        allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                         value.arg_types.clearAndFree(allocator);
                     }
 
@@ -468,14 +468,14 @@ pub const FFI = struct {
                 },
                 .pending => {
                     for (symbols.values()) |*value| {
-                        allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
+                        allocator.free(bun.constStrToU8(bun.asByteSlice(value.base_name.?)));
                         value.arg_types.clearAndFree(allocator);
                     }
                     symbols.clearAndFree(allocator);
                     return ZigString.static("Failed to compile (nothing happend!)").toErrorInstance(global);
                 },
                 .compiled => |*compiled| {
-                    const name = &ZigString.init(std.mem.span(function_name));
+                    const name = &ZigString.init(bun.asByteSlice(function_name));
 
                     const cb = JSC.NewRuntimeFunction(
                         global,
@@ -632,7 +632,7 @@ pub const FFI = struct {
             }
             function.base_name = try prop.toOwnedSliceZ(allocator);
 
-            symbols.putAssumeCapacity(std.mem.span(function.base_name.?), function);
+            symbols.putAssumeCapacity(bun.asByteSlice(function.base_name.?), function);
         }
 
         return null;
@@ -656,8 +656,8 @@ pub const FFI = struct {
             JSC.markBinding(@src());
 
             if (val.base_name) |base_name| {
-                if (std.mem.span(base_name).len > 0) {
-                    allocator.free(bun.constStrToU8(std.mem.span(base_name)));
+                if (bun.asByteSlice(base_name).len > 0) {
+                    allocator.free(bun.constStrToU8(bun.asByteSlice(base_name)));
                 }
             }
 
@@ -1058,7 +1058,7 @@ pub const FFI = struct {
             }
 
             if (comptime Environment.isRelease) {
-                try writer.writeAll(std.mem.span(FFI_HEADER));
+                try writer.writeAll(bun.asByteSlice(FFI_HEADER));
             } else {
                 try writer.writeAll(ffiHeader());
             }
@@ -1067,10 +1067,10 @@ pub const FFI = struct {
             try writer.writeAll("/* --- The Function To Call */\n");
             try this.return_type.typename(writer);
             try writer.writeAll(" ");
-            try writer.writeAll(std.mem.span(this.base_name.?));
+            try writer.writeAll(bun.asByteSlice(this.base_name.?));
             try writer.writeAll("(");
             var first = true;
-            for (this.arg_types.items) |arg, i| {
+            for (this.arg_types.items, 0..) |arg, i| {
                 if (!first) {
                     try writer.writeAll(", ");
                 }
@@ -1092,7 +1092,7 @@ pub const FFI = struct {
                     \\  LOAD_ARGUMENTS_FROM_CALL_FRAME;
                     \\
                 );
-                for (this.arg_types.items) |arg, i| {
+                for (this.arg_types.items, 0..) |arg, i| {
                     if (arg.needsACastInC()) {
                         if (i < this.arg_types.items.len - 1) {
                             try writer.print(
@@ -1152,10 +1152,10 @@ pub const FFI = struct {
                 try this.return_type.typename(writer);
                 try writer.writeAll(" return_value = ");
             }
-            try writer.print("{s}(", .{std.mem.span(this.base_name.?)});
+            try writer.print("{s}(", .{bun.asByteSlice(this.base_name.?)});
             first = true;
             arg_buf[0..3].* = "arg".*;
-            for (this.arg_types.items) |arg, i| {
+            for (this.arg_types.items, 0..) |arg, i| {
                 if (!first) {
                     try writer.writeAll(", ");
                 }
@@ -1229,7 +1229,7 @@ pub const FFI = struct {
             }
 
             if (comptime Environment.isRelease) {
-                try writer.writeAll(std.mem.span(FFI_HEADER));
+                try writer.writeAll(bun.asByteSlice(FFI_HEADER));
             } else {
                 try writer.writeAll(ffiHeader());
             }
@@ -1241,7 +1241,7 @@ pub const FFI = struct {
             try writer.writeAll(" my_callback_function");
             try writer.writeAll("(");
             var first = true;
-            for (this.arg_types.items) |arg, i| {
+            for (this.arg_types.items, 0..) |arg, i| {
                 if (!first) {
                     try writer.writeAll(", ");
                 }
@@ -1256,7 +1256,7 @@ pub const FFI = struct {
 
             try writer.writeAll(" my_callback_function");
             try writer.writeAll("(");
-            for (this.arg_types.items) |arg, i| {
+            for (this.arg_types.items, 0..) |arg, i| {
                 if (!first) {
                     try writer.writeAll(", ");
                 }
@@ -1279,7 +1279,7 @@ pub const FFI = struct {
                 try writer.print(" ZIG_REPR_TYPE arguments[{d}];\n", .{this.arg_types.items.len});
 
                 arg_buf[0.."arg".len].* = "arg".*;
-                for (this.arg_types.items) |arg, i| {
+                for (this.arg_types.items, 0..) |arg, i| {
                     const printed = std.fmt.bufPrintIntToSlice(arg_buf["arg".len..], i, 10, .lower, .{});
                     const arg_name = arg_buf[0 .. "arg".len + printed.len];
                     try writer.print("arguments[{d}] = {any}.asZigRepr;\n", .{ i, arg.toJS(arg_name) });
@@ -1424,7 +1424,7 @@ pub const FFI = struct {
         };
         pub const map_to_js_object = brk: {
             var count: usize = 2;
-            for (map) |item, i| {
+            for (map, 0..) |item, i| {
                 var fmt = EnumMapFormatter{ .name = item.@"0", .entry = item.@"1" };
                 count += std.fmt.count("{}", .{fmt});
                 count += @boolToInt(i > 0);
@@ -1434,7 +1434,7 @@ pub const FFI = struct {
             buf[0] = '{';
             buf[buf.len - 1] = '}';
             var end: usize = 1;
-            for (map) |item, i| {
+            for (map, 0..) |item, i| {
                 var fmt = EnumMapFormatter{ .name = item.@"0", .entry = item.@"1" };
                 if (i > 0) {
                     buf[end] = ',';
@@ -1470,7 +1470,7 @@ pub const FFI = struct {
                     },
                     .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t, .uint32_t => {
                         if (self.exact)
-                            try writer.print("({s})", .{std.mem.span(@tagName(self.tag))});
+                            try writer.print("({s})", .{bun.asByteSlice(@tagName(self.tag))});
 
                         try writer.writeAll("JSVALUE_TO_INT32(");
                     },
diff --git a/src/bun.js/api/filesystem_router.zig b/src/bun.js/api/filesystem_router.zig
index 7141b5f5e..6e5465055 100644
--- a/src/bun.js/api/filesystem_router.zig
+++ b/src/bun.js/api/filesystem_router.zig
@@ -424,7 +424,7 @@ pub const FileSystemRouter = struct {
         var name_strings = bun.default_allocator.alloc(ZigString, names.len * 2) catch unreachable;
         defer bun.default_allocator.free(name_strings);
         var paths_strings = name_strings[names.len..];
-        for (names) |name, i| {
+        for (names, 0..) |name, i| {
             name_strings[i] = ZigString.init(name).withEncoding();
             paths_strings[i] = ZigString.init(paths[i]).withEncoding();
         }
@@ -610,7 +610,7 @@ pub const MatchedRoute = struct {
                     std.debug.assert(entry.values.len > 0);
                     if (entry.values.len > 1) {
                         var values = query_string_value_refs_buf[0..entry.values.len];
-                        for (entry.values) |value, i| {
+                        for (entry.values, 0..) |value, i| {
                             values[i] = ZigString.init(value).withEncoding();
                         }
                         obj.putRecord(global, &str, values.ptr, values.len);
diff --git a/src/bun.js/api/transpiler.zig b/src/bun.js/api/transpiler.zig
index eb070b6bc..8562a3204 100644
--- a/src/bun.js/api/transpiler.zig
+++ b/src/bun.js/api/transpiler.zig
@@ -203,7 +203,7 @@ pub const TransformTask = struct {
                             this.global,
                             bun.default_allocator,
                             logger.Msg{
-                                .data = logger.Data{ .text = std.mem.span(@errorName(err)) },
+                                .data = logger.Data{ .text = bun.asByteSlice(@errorName(err)) },
                             },
                         ));
                     }
diff --git a/src/bun.js/base.zig b/src/bun.js/base.zig
index bdb516836..044a04306 100644
--- a/src/bun.js/base.zig
+++ b/src/bun.js/base.zig
@@ -219,7 +219,7 @@ pub const To = struct {
                     var zig_strings = allocator.alloc(ZigString, value.len) catch unreachable;
                     defer if (stack_fallback.fixed_buffer_allocator.end_index >= 511) allocator.free(zig_strings);
 
-                    for (value) |path_string, i| {
+                    for (value, 0..) |path_string, i| {
                         if (comptime Type == []const PathString) {
                             zig_strings[i] = ZigString.init(path_string.slice());
                         } else {
@@ -645,7 +645,7 @@ pub const d = struct {
 
                     comptime {
                         var args: string = "";
-                        for (func.args) |a, i| {
+                        for (func.args, 0..) |a, i| {
                             if (i > 0) {
                                 args = args ++ ", ";
                             }
@@ -680,7 +680,7 @@ pub const d = struct {
 
                     comptime {
                         var args: string = "";
-                        for (func.args) |a, i| {
+                        for (func.args, 0..) |a, i| {
                             if (i > 0) {
                                 args = args ++ ", ";
                             }
@@ -751,7 +751,7 @@ pub const d = struct {
 
                         indent += indent_level;
 
-                        for (klass.properties) |property, i| {
+                        for (klass.properties, 0..) |property, i| {
                             if (i > 0) {
                                 buf = buf ++ "\n";
                             }
@@ -761,7 +761,7 @@ pub const d = struct {
 
                         buf = buf ++ "\n";
 
-                        for (klass.functions) |func, i| {
+                        for (klass.functions, 0..) |func, i| {
                             if (i > 0) {
                                 buf = buf ++ "\n";
                             }
@@ -773,7 +773,7 @@ pub const d = struct {
                             );
                         }
 
-                        for (klass.classes) |func, i| {
+                        for (klass.classes, 0..) |func, i| {
                             if (i > 0) {
                                 buf = buf ++ "\n";
                             }
@@ -822,7 +822,7 @@ pub const d = struct {
                             );
                         }
 
-                        for (klass.properties) |property, i| {
+                        for (klass.properties, 0..) |property, i| {
                             if (i > 0 or did_print_constructor) {
                                 buf = buf ++ "\n";
                             }
@@ -832,7 +832,7 @@ pub const d = struct {
 
                         buf = buf ++ "\n";
 
-                        for (klass.functions) |func, i| {
+                        for (klass.functions, 0..) |func, i| {
                             if (i > 0) {
                                 buf = buf ++ "\n";
                             }
@@ -1294,7 +1294,7 @@ pub fn NewClassWithInstanceType(
                     .attributes = js.JSPropertyAttributes.kJSPropertyAttributeNone,
                 },
             );
-            for (property_name_literals) |lit, i| {
+            for (property_name_literals, 0..) |lit, i| {
                 props[i] = brk2: {
                     var static_prop = JSC.C.JSStaticValue{
                         .name = lit.ptr[0..lit.len :0],
@@ -1338,7 +1338,7 @@ pub fn NewClassWithInstanceType(
                 .convertToType = null,
             };
             var __static_functions: [function_name_literals.len + 1]js.JSStaticFunction = undefined;
-            for (__static_functions) |_, i| {
+            for (__static_functions, 0..) |_, i| {
                 __static_functions[i] = js.JSStaticFunction{
                     .name = "",
                     .callAsFunction = null,
@@ -1692,7 +1692,7 @@ pub fn toTypeError(
     args: anytype,
     ctx: js.JSContextRef,
 ) JSC.JSValue {
-    return toTypeErrorWithCode(std.mem.span(@tagName(code)), fmt, args, ctx);
+    return toTypeErrorWithCode(@tagName(code), fmt, args, ctx);
 }
 
 pub fn throwInvalidArguments(
diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 48cbe0887..05684902b 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -1677,7 +1677,7 @@ pub fn PromiseCallback(comptime Type: type, comptime CallbackFunction: fn (*Type
             arguments_len: usize,
         ) callconv(.C) JSValue {
             return CallbackFunction(@ptrCast(*Type, @alignCast(@alignOf(*Type), ctx.?)), globalThis, arguments[0..arguments_len]) catch |err| brk: {
-                break :brk ZigString.init(std.mem.span(@errorName(err))).toErrorInstance(globalThis);
+                break :brk ZigString.init(bun.asByteSlice(@errorName(err))).toErrorInstance(globalThis);
             };
         }
     }.callback;
@@ -2376,7 +2376,7 @@ pub const JSGlobalObject = extern struct {
         const names = comptime std.meta.fieldNames(@TypeOf(module));
         var export_names: [names.len]ZigString = undefined;
         var export_values: [names.len]JSValue = undefined;
-        inline for (comptime names) |export_name, i| {
+        inline for (comptime names, 0..) |export_name, i| {
             export_names[i] = ZigString.init(export_name);
             const function = @field(module, export_name).@"0";
             const len = @field(module, export_name).@"1";
diff --git a/src/bun.js/bindings/exports.zig b/src/bun.js/bindings/exports.zig
index f17d7e221..c87a80571 100644
--- a/src/bun.js/bindings/exports.zig
+++ b/src/bun.js/bindings/exports.zig
@@ -481,7 +481,7 @@ pub const ZigStackTrace = extern struct {
                 var stack_frames = try allocator.alloc(Api.StackFrame, _frames.len);
                 stack_trace.frames = stack_frames;
 
-                for (_frames) |frame, i| {
+                for (_frames, 0..) |frame, i| {
                     stack_frames[i] = try frame.toAPI(
                         root_path,
                         origin,
@@ -527,7 +527,7 @@ pub const ZigStackTrace = extern struct {
 
     pub fn sourceLineIterator(this: *const ZigStackTrace) SourceLineIterator {
         var i: usize = 0;
-        for (this.source_lines_numbers[0..this.source_lines_len]) |num, j| {
+        for (this.source_lines_numbers[0..this.source_lines_len], 0..) |num, j| {
             if (num > 0) {
                 i = j;
             }
@@ -2125,7 +2125,7 @@ pub const ZigConsoleClient = struct {
                                 timer.id,
                             });
                         }
-                        
+
                         return;
                     } else if (jsType != .DOMWrapper) {
                         if (CAPI.JSObjectGetPrivate(value.asRef())) |private_data_ptr| {
@@ -2607,7 +2607,7 @@ pub const ZigConsoleClient = struct {
                     const arrayBuffer = value.asArrayBuffer(this.globalThis).?;
 
                     const slice = arrayBuffer.byteSlice();
-                    writer.writeAll(std.mem.span(@tagName(arrayBuffer.typed_array_type)));
+                    writer.writeAll(bun.asByteSlice(@tagName(arrayBuffer.typed_array_type)));
 
                     writer.print("({d}) [ ", .{arrayBuffer.len});
                     if (slice.len > 0) {
diff --git a/src/bun.js/bindings/header-gen.zig b/src/bun.js/bindings/header-gen.zig
index 294f0a095..179c884d5 100644
--- a/src/bun.js/bindings/header-gen.zig
+++ b/src/bun.js/bindings/header-gen.zig
@@ -147,7 +147,7 @@ pub const C_Generator = struct {
 
         comptime var nonnull = std.BoundedArray(u8, 32).init(0) catch unreachable;
 
-        inline for (meta.params) |arg, i| {
+        inline for (meta.params, 0..) |arg, i| {
             const ArgType = comptime arg.type.?;
 
             switch (comptime @typeInfo(ArgType)) {
@@ -188,7 +188,7 @@ pub const C_Generator = struct {
         const nonnull_slice = comptime nonnull.slice();
         if (comptime nonnull_slice.len > 0) {
             self.write(" __attribute__((nonnull (");
-            inline for (comptime nonnull_slice) |i, j| {
+            inline for (comptime nonnull_slice, 0..) |i, j| {
                 self.write(comptime std.fmt.comptimePrint("{d}", .{i}));
                 if (j != nonnull_slice.len - 1)
                     self.write(", ");
@@ -214,7 +214,7 @@ pub const C_Generator = struct {
         const func: std.builtin.Type.Fn = @typeInfo(Function).Fn;
         self.writeType(func.return_type orelse void);
         self.write("(*" ++ name ++ ")(");
-        inline for (func.params) |arg, i| {
+        inline for (func.params, 0..) |arg, i| {
             self.writeType(arg.type.?);
             // if (comptime func.arg_names.len > 0 and func.arg_names.len > i) {
             //     self.write(comptime arg_names[i]);
@@ -304,7 +304,7 @@ pub const C_Generator = struct {
         self.write("enum " ++ name ++ " {\n");
 
         comptime var last = 0;
-        inline for (meta.fields) |field, i| {
+        inline for (meta.fields, 0..) |field, i| {
             self.write("    " ++ field.name);
 
             // if field value is unexpected/custom, manually define it
@@ -372,7 +372,7 @@ pub const C_Generator = struct {
                 _ = std.mem.replace(u8, TT.name, ":", "_", &original);
                 break :brk original;
             };
-            const formatted_name = comptime std.mem.span(&_formatted_name);
+            const formatted_name = comptime _formatted_name[0..];
 
             if (@hasDecl(TT, "is_pointer") and !TT.is_pointer) {
                 if (@TypeOf(TT.Type) == type) {
@@ -524,11 +524,11 @@ pub fn HeaderGen(comptime first_import: type, comptime second_import: type, comp
                 comptime var new_name = std.mem.zeroes([Type.include.len]u8);
 
                 comptime {
-                    _ = std.mem.replace(u8, Type.include, "/", "_", std.mem.span(&new_name));
-                    _ = std.mem.replace(u8, &new_name, ".", "_", std.mem.span(&new_name));
-                    _ = std.mem.replace(u8, &new_name, "<", "_", std.mem.span(&new_name));
-                    _ = std.mem.replace(u8, &new_name, ">", "_", std.mem.span(&new_name));
-                    _ = std.mem.replace(u8, &new_name, "\"", "_", std.mem.span(&new_name));
+                    _ = std.mem.replace(u8, Type.include, "/", "_", &new_name);
+                    _ = std.mem.replace(u8, &new_name, ".", "_", &new_name);
+                    _ = std.mem.replace(u8, &new_name, "<", "_", &new_name);
+                    _ = std.mem.replace(u8, &new_name, ">", "_", &new_name);
+                    _ = std.mem.replace(u8, &new_name, "\"", "_", &new_name);
                 }
                 file.writeAll("\n#pragma mark - " ++ Type.name ++ "\n\n") catch unreachable;
 
@@ -797,7 +797,7 @@ pub fn HeaderGen(comptime first_import: type, comptime second_import: type, comp
                                             if (@hasDecl(Type, extern_decl)) {
                                                 const normalized_name = comptime brk: {
                                                     var _normalized_name: [Type.name.len]u8 = undefined;
-                                                    _ = std.mem.replace(u8, Type.name, ":", "_", std.mem.span(&_normalized_name));
+                                                    _ = std.mem.replace(u8, Type.name, ":", "_", &_normalized_name);
                                                     break :brk _normalized_name;
                                                 };
 
@@ -808,7 +808,7 @@ pub fn HeaderGen(comptime first_import: type, comptime second_import: type, comp
                                                     Type,
                                                     comptime std.meta.declarationInfo(Type, extern_decl),
                                                     comptime extern_decl,
-                                                    comptime std.mem.span(&normalized_name),
+                                                    &normalized_name,
                                                 );
                                             }
                                         }
diff --git a/src/bun.js/bindings/headers-cpp.h b/src/bun.js/bindings/headers-cpp.h
index 3c53d5f99..b15dd8ba2 100644
--- a/src/bun.js/bindings/headers-cpp.h
+++ b/src/bun.js/bindings/headers-cpp.h
@@ -1,4 +1,4 @@
-//-- AUTOGENERATED FILE -- 1676922916
+//-- AUTOGENERATED FILE -- 1677221832
 // clang-format off
 #pragma once
 
diff --git a/src/bun.js/bindings/headers.h b/src/bun.js/bindings/headers.h
index 6b005216a..79a4ef24b 100644
--- a/src/bun.js/bindings/headers.h
+++ b/src/bun.js/bindings/headers.h
@@ -1,5 +1,5 @@
 // clang-format off
-//-- AUTOGENERATED FILE -- 1676922916
+//-- AUTOGENERATED FILE -- 1677221832
 #pragma once
 
 #include <stddef.h>
diff --git a/src/bun.js/bindings/shimmer.zig b/src/bun.js/bindings/shimmer.zig
index cde7712c5..a90bfab87 100644
--- a/src/bun.js/bindings/shimmer.zig
+++ b/src/bun.js/bindings/shimmer.zig
@@ -105,7 +105,7 @@ pub fn Shimmer(comptime _namespace: []const u8, comptime _name: []const u8, comp
             const FunctionsType = @TypeOf(Functions);
             return comptime brk: {
                 var functions: [std.meta.fieldNames(FunctionsType).len]StaticExport = undefined;
-                for (std.meta.fieldNames(FunctionsType)) |fn_name, i| {
+                for (std.meta.fieldNames(FunctionsType), 0..) |fn_name, i| {
                     const Function = @TypeOf(@field(Functions, fn_name));
                     if (@typeInfo(Function) != .Fn) {
                         @compileError("Expected " ++ @typeName(Parent) ++ "." ++ @typeName(Function) ++ " to be a function but received " ++ @tagName(@typeInfo(Function)));
diff --git a/src/bun.js/bindings/sizes.zig b/src/bun.js/bindings/sizes.zig
index b1b9c1679..795159e49 100644
--- a/src/bun.js/bindings/sizes.zig
+++ b/src/bun.js/bindings/sizes.zig
@@ -78,4 +78,4 @@ pub const Bun_CallFrame__argumentCountIncludingThis = 4;
 pub const Bun_CallFrame__thisArgument = 5;
 pub const Bun_CallFrame__firstArgument = 6;
 pub const Bun_CallFrame__size = 8;
-pub const Bun_CallFrame__align = 8;
\ No newline at end of file
+pub const Bun_CallFrame__align = 8;
diff --git a/src/bun.js/event_loop.zig b/src/bun.js/event_loop.zig
index 9c2627fda..8dbf5abfd 100644
--- a/src/bun.js/event_loop.zig
+++ b/src/bun.js/event_loop.zig
@@ -173,7 +173,6 @@ pub const AnyTask = struct {
     }
 };
 
-
 pub const CppTask = opaque {
     extern fn Bun__performTask(globalObject: *JSGlobalObject, task: *CppTask) void;
     pub fn run(this: *CppTask, global: *JSGlobalObject) void {
diff --git a/src/bun.js/javascript.zig b/src/bun.js/javascript.zig
index a5ef4a44a..efa42deb5 100644
--- a/src/bun.js/javascript.zig
+++ b/src/bun.js/javascript.zig
@@ -647,7 +647,7 @@ pub const VirtualMachine = struct {
         if (is_bindgen)
             return &[_]js.JSClassRef{};
         var classes = default_allocator.alloc(js.JSClassRef, GlobalClasses.len) catch return &[_]js.JSClassRef{};
-        inline for (GlobalClasses) |Class, i| {
+        inline for (GlobalClasses, 0..) |Class, i| {
             classes[i] = Class.get().*;
         }
 
@@ -668,7 +668,7 @@ pub const VirtualMachine = struct {
         else
             VirtualMachine.get().allocator.alloc(JSC.JSValue, GlobalConstructors.len) catch unreachable;
 
-        inline for (GlobalConstructors) |Class, i| {
+        inline for (GlobalConstructors, 0..) |Class, i| {
             var ref = Class.constructor(globalObject.ref()).?;
             JSC.C.JSValueProtect(globalObject.ref(), ref);
             slice[i] = JSC.JSValue.fromRef(
@@ -779,7 +779,7 @@ pub const VirtualMachine = struct {
         }
 
         var global_classes: [GlobalClasses.len]js.JSClassRef = undefined;
-        inline for (GlobalClasses) |Class, i| {
+        inline for (GlobalClasses, 0..) |Class, i| {
             global_classes[i] = Class.get().*;
         }
         vm.global = ZigGlobalObject.create(
@@ -1353,7 +1353,7 @@ pub const VirtualMachine = struct {
 
                 var errors = errors_stack[0..@min(log.msgs.items.len, errors_stack.len)];
 
-                for (log.msgs.items) |msg, i| {
+                for (log.msgs.items, 0..) |msg, i| {
                     errors[i] = switch (msg.metadata) {
                         .build => BuildError.create(globalThis, globalThis.allocator(), msg).?,
                         .resolve => ResolveError.create(
@@ -1798,7 +1798,7 @@ pub const VirtualMachine = struct {
         var frames: []JSC.ZigStackFrame = exception.stack.frames_ptr[0..exception.stack.frames_len];
         if (this.hide_bun_stackframes) {
             var start_index: ?usize = null;
-            for (frames) |frame, i| {
+            for (frames, 0..) |frame, i| {
                 if (frame.source_url.eqlComptime("bun:wrap") or
                     frame.function_name.eqlComptime("::bunternal::"))
                 {
@@ -1859,7 +1859,7 @@ pub const VirtualMachine = struct {
                 std.mem.set(i32, source_line_numbers, 0);
 
                 var lines_ = lines[0..@min(lines.len, source_lines.len)];
-                for (lines_) |line, j| {
+                for (lines_, 0..) |line, j| {
                     source_lines[(lines_.len - 1) - j] = ZigString.init(line);
                     source_line_numbers[j] = top.position.line - @intCast(i32, j) + 1;
                 }
@@ -2822,7 +2822,7 @@ pub const HotReloader = struct {
 
                             // if a file descriptor is stale, we need to close it
                             if (event.op.delete and entries_option != null) {
-                                for (parents) |parent_hash, entry_id| {
+                                for (parents, 0..) |parent_hash, entry_id| {
                                     if (parent_hash == id) {
                                         const affected_path = file_paths[entry_id];
                                         const was_deleted = check: {
@@ -2862,7 +2862,7 @@ pub const HotReloader = struct {
                             const changed_name: []const u8 = if (comptime Environment.isMac)
                                 changed_name_
                             else
-                                std.mem.span(changed_name_.?);
+                                bun.asByteSlice(changed_name_.?);
                             if (changed_name.len == 0 or changed_name[0] == '~' or changed_name[0] == '.') continue;
 
                             const loader = (bundler.options.loaders.get(Fs.PathName.init(changed_name).ext) orelse .file);
@@ -2877,7 +2877,7 @@ pub const HotReloader = struct {
                                         file_ent.entry.need_stat = true;
                                         path_string = file_ent.entry.abs_path;
                                         file_hash = Watcher.getHash(path_string.slice());
-                                        for (hashes) |hash, entry_id| {
+                                        for (hashes, 0..) |hash, entry_id| {
                                             if (hash == file_hash) {
                                                 if (file_descriptors[entry_id] != 0) {
                                                     if (prev_entry_id != entry_id) {
diff --git a/src/bun.js/module_loader.zig b/src/bun.js/module_loader.zig
index 9d674486a..0a7fe2fb6 100644
--- a/src/bun.js/module_loader.zig
+++ b/src/bun.js/module_loader.zig
@@ -236,7 +236,7 @@ pub const ModuleLoader = struct {
                 outer: for (modules) |module_| {
                     var module = module_;
                     const root_dependency_ids = module.parse_result.pending_imports.items(.root_dependency_id);
-                    for (root_dependency_ids) |dep, dep_i| {
+                    for (root_dependency_ids, 0..) |dep, dep_i| {
                         if (dep != root_dependency_id) continue;
                         module.resolveError(
                             this.vm(),
@@ -328,7 +328,7 @@ pub const ModuleLoader = struct {
                 outer: for (modules) |module_| {
                     var module = module_;
                     var tags = module.parse_result.pending_imports.items(.tag);
-                    for (tags) |tag, tag_i| {
+                    for (tags, 0..) |tag, tag_i| {
                         if (tag == .resolve) {
                             var esms = module.parse_result.pending_imports.items(.esm);
                             const esm = esms[tag_i];
@@ -375,7 +375,7 @@ pub const ModuleLoader = struct {
                     var module = module_;
                     const record_ids = module.parse_result.pending_imports.items(.import_record_id);
                     const root_dependency_ids = module.parse_result.pending_imports.items(.root_dependency_id);
-                    for (root_dependency_ids) |dependency_id, import_id| {
+                    for (root_dependency_ids, 0..) |dependency_id, import_id| {
                         if (resolution_ids[dependency_id] != package_id) continue;
                         module.downloadError(
                             this.vm(),
@@ -410,7 +410,7 @@ pub const ModuleLoader = struct {
                     // var esms = module.parse_result.pending_imports.items(.esm);
                     // var versions = module.parse_result.pending_imports.items(.dependency);
                     var done_count: usize = 0;
-                    for (tags) |tag, tag_i| {
+                    for (tags, 0..) |tag, tag_i| {
                         const root_id = root_dependency_ids[tag_i];
                         const resolution_ids = pm.lockfile.buffers.resolutions.items;
                         if (root_id >= resolution_ids.len) continue;
@@ -618,7 +618,7 @@ pub const ModuleLoader = struct {
                 else => |err| std.fmt.allocPrint(
                     bun.default_allocator,
                     "{s} resolving package '{s}' at '{s}'",
-                    .{ std.mem.span(@errorName(err)), result.name, result.url },
+                    .{ bun.asByteSlice(@errorName(err)), result.name, result.url },
                 ),
             };
 
@@ -707,7 +707,7 @@ pub const ModuleLoader = struct {
                     bun.default_allocator,
                     "{s} downloading package '{s}@{any}'",
                     .{
-                        std.mem.span(@errorName(err)),
+                        bun.asByteSlice(@errorName(err)),
                         result.name,
                         result.resolution.fmt(vm.packageManager().lockfile.buffers.string_bytes.items),
                     },
@@ -1559,8 +1559,8 @@ pub const ModuleLoader = struct {
                         return ResolvedSource{
                             .allocator = null,
                             .source_code = ZigString.init(jsc_vm.entry_point.source.contents),
-                            .specifier = ZigString.init(std.mem.span(JSC.VirtualMachine.main_file_name)),
-                            .source_url = ZigString.init(std.mem.span(JSC.VirtualMachine.main_file_name)),
+                            .specifier = ZigString.init(bun.asByteSlice(JSC.VirtualMachine.main_file_name)),
+                            .source_url = ZigString.init(bun.asByteSlice(JSC.VirtualMachine.main_file_name)),
                             .hash = 0,
                         };
                     }
@@ -1628,8 +1628,8 @@ pub const ModuleLoader = struct {
                     return ResolvedSource{
                         .allocator = null,
                         .source_code = ZigString.init(jsc_vm.allocator.dupe(u8, printer.ctx.written) catch unreachable),
-                        .specifier = ZigString.init(std.mem.span(JSC.VirtualMachine.main_file_name)),
-                        .source_url = ZigString.init(std.mem.span(JSC.VirtualMachine.main_file_name)),
+                        .specifier = ZigString.init(bun.asByteSlice(JSC.VirtualMachine.main_file_name)),
+                        .source_url = ZigString.init(bun.asByteSlice(JSC.VirtualMachine.main_file_name)),
                         .hash = 0,
                     };
                 },
diff --git a/src/bun.js/node/node_os.zig b/src/bun.js/node/node_os.zig
index 3a8f5a55b..ffe35ecd0 100644
--- a/src/bun.js/node/node_os.zig
+++ b/src/bun.js/node/node_os.zig
@@ -47,8 +47,8 @@ pub const Os = struct {
         return module;
     }
 
-    pub const EOL = if (Environment.isWindows) "\r\n" else "\n";
-    pub const devNull = if (Environment.isWindows) "\\\\.\nul" else "/dev/null";
+    pub const EOL: []const u8 = if (Environment.isWindows) "\r\n" else "\n";
+    pub const devNull: []const u8 = if (Environment.isWindows) "\\\\.\nul" else "/dev/null";
 
     pub fn arch(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSC.JSValue {
         JSC.markBinding(@src());
@@ -65,7 +65,7 @@ pub const Os = struct {
             sys: u64 = 0,
             idle: u64 = 0,
             irq: u64 = 0,
-        } = .{}
+        } = .{},
     };
 
     pub fn cpus(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSC.JSValue {
@@ -73,14 +73,14 @@ pub const Os = struct {
 
         var cpu_buffer: [8192]CPU = undefined;
         const cpus_or_error = if (comptime Environment.isLinux)
-                                cpusImplLinux(&cpu_buffer)
-                              else
-                                @as(anyerror![]CPU, cpu_buffer[0..0]);  // unsupported platform -> empty array
+            cpusImplLinux(&cpu_buffer)
+        else
+            @as(anyerror![]CPU, cpu_buffer[0..0]); // unsupported platform -> empty array
 
         if (cpus_or_error) |list| {
             // Convert the CPU list to a JS Array
             const values = JSC.JSValue.createEmptyArray(globalThis, list.len);
-            for (list) |cpu, cpu_index| {
+            for (list, 0..) |cpu, cpu_index| {
                 const obj = JSC.JSValue.createEmptyObject(globalThis, 3);
                 obj.put(globalThis, JSC.ZigString.static("model"), cpu.model.withEncoding().toValueGC(globalThis));
                 obj.put(globalThis, JSC.ZigString.static("speed"), JSC.JSValue.jsNumberFromUint64(cpu.speed));
@@ -88,14 +88,12 @@ pub const Os = struct {
                 const timesFields = comptime std.meta.fieldNames(@TypeOf(cpu.times));
                 const times = JSC.JSValue.createEmptyObject(globalThis, 5);
                 inline for (timesFields) |fieldName| {
-                    times.put(globalThis, JSC.ZigString.static(fieldName),
-                                    JSC.JSValue.jsNumberFromUint64(@field(cpu.times, fieldName)));
+                    times.put(globalThis, JSC.ZigString.static(fieldName), JSC.JSValue.jsNumberFromUint64(@field(cpu.times, fieldName)));
                 }
                 obj.put(globalThis, JSC.ZigString.static("times"), times);
                 values.putIndex(globalThis, @intCast(u32, cpu_index), obj);
             }
             return values;
-
         } else |zig_err| {
             const msg = switch (zig_err) {
                 error.too_many_cpus => "Too many CPUs or malformed /proc/cpuinfo file",
@@ -113,7 +111,7 @@ pub const Os = struct {
 
     fn cpusImplLinux(cpu_buffer: []CPU) ![]CPU {
         // Use a large line buffer because the /proc/stat file can have a very long list of interrupts
-        var line_buffer: [1024*8]u8 = undefined;
+        var line_buffer: [1024 * 8]u8 = undefined;
         var num_cpus: usize = 0;
 
         // Read /proc/stat to get number of CPUs and times
@@ -126,7 +124,6 @@ pub const Os = struct {
 
             // Read each CPU line
             while (try reader.readUntilDelimiterOrEof(&line_buffer, '\n')) |line| {
-
                 if (num_cpus >= cpu_buffer.len) return error.too_many_cpus;
 
                 // CPU lines are formatted as `cpu0 user nice sys idle iowait irq softirq`
@@ -141,10 +138,10 @@ pub const Os = struct {
                 const scale = 10;
                 cpu_buffer[num_cpus].times.user = scale * try std.fmt.parseInt(u64, toks.next() orelse return error.eol, 10);
                 cpu_buffer[num_cpus].times.nice = scale * try std.fmt.parseInt(u64, toks.next() orelse return error.eol, 10);
-                cpu_buffer[num_cpus].times.sys  = scale * try std.fmt.parseInt(u64, toks.next() orelse return error.eol, 10);
+                cpu_buffer[num_cpus].times.sys = scale * try std.fmt.parseInt(u64, toks.next() orelse return error.eol, 10);
                 cpu_buffer[num_cpus].times.idle = scale * try std.fmt.parseInt(u64, toks.next() orelse return error.eol, 10);
                 _ = try (toks.next() orelse error.eol); // skip iowait
-                cpu_buffer[num_cpus].times.irq  = scale * try std.fmt.parseInt(u64, toks.next() orelse return error.eol, 10);
+                cpu_buffer[num_cpus].times.irq = scale * try std.fmt.parseInt(u64, toks.next() orelse return error.eol, 10);
 
                 num_cpus += 1;
             }
@@ -163,13 +160,11 @@ pub const Os = struct {
 
             var cpu_index: usize = 0;
             while (try reader.readUntilDelimiterOrEof(&line_buffer, '\n')) |line| {
-
                 if (std.mem.startsWith(u8, line, key_processor)) {
                     // If this line starts a new processor, parse the index from the line
                     const digits = std.mem.trim(u8, line[key_processor.len..], " \t\n");
                     cpu_index = try std.fmt.parseInt(usize, digits, 10);
                     if (cpu_index >= slice.len) return error.too_may_cpus;
-
                 } else if (std.mem.startsWith(u8, line, key_model_name)) {
                     // If this is the model name, extract it and store on the current cpu
                     const model_name = line[key_model_name.len..];
@@ -182,7 +177,7 @@ pub const Os = struct {
         }
 
         // Read /sys/devices/system/cpu/cpu{}/cpufreq/scaling_cur_freq to get current frequency (optional)
-        for (slice) |*cpu, cpu_index| {
+        for (slice, 0..) |*cpu, cpu_index| {
             var path_buf: [128]u8 = undefined;
             const path = try std.fmt.bufPrint(&path_buf, "/sys/devices/system/cpu/cpu{}/cpufreq/scaling_cur_freq", .{cpu_index});
             if (std.fs.openFileAbsolute(path, .{})) |file| {
@@ -263,11 +258,17 @@ pub const Os = struct {
     pub fn homedir(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSC.JSValue {
         JSC.markBinding(@src());
 
-        var dir: string = "unknown";
-        if (comptime Environment.isWindows)
-            dir = bun.getenvZ("USERPROFILE") orelse "unknown"
-        else
-            dir = bun.getenvZ("HOME") orelse "unknown";
+        const dir: []const u8 = brk: {
+            if (comptime Environment.isWindows) {
+                if (bun.getenvZ("USERPROFILE")) |env|
+                    break :brk bun.asByteSlice(env);
+            } else {
+                if (bun.getenvZ("HOME")) |env|
+                    break :brk bun.asByteSlice(env);
+            }
+
+            break :brk "unknown";
+        };
 
         return JSC.ZigString.init(dir).withEncoding().toValueGC(globalThis);
     }
@@ -376,20 +377,21 @@ pub const Os = struct {
     pub fn tmpdir(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSC.JSValue {
         JSC.markBinding(@src());
 
-        var dir: string = "unknown";
-        if (comptime Environment.isWindows) {
-            if (bun.getenvZ("TEMP") orelse bun.getenvZ("TMP")) |tmpdir_| {
-                dir = tmpdir_;
-            }
+        const dir: []const u8 = brk: {
+            if (comptime Environment.isWindows) {
+                if (bun.getenvZ("TEMP") orelse bun.getenvZ("TMP")) |tmpdir_| {
+                    break :brk tmpdir_;
+                }
 
-            if (bun.getenvZ("SYSTEMROOT") orelse bun.getenvZ("WINDIR")) |systemdir_| {
-                dir = systemdir_ + "\\temp";
+                if (bun.getenvZ("SYSTEMROOT") orelse bun.getenvZ("WINDIR")) |systemdir_| {
+                    break :brk systemdir_ ++ "\\temp";
+                }
+            } else {
+                break :brk bun.asByteSlice(bun.getenvZ("TMPDIR") orelse bun.getenvZ("TMP") orelse bun.getenvZ("TEMP") orelse "/tmp");
             }
 
-            dir = "unknown";
-        } else {
-            dir = bun.getenvZ("TMPDIR") orelse bun.getenvZ("TMP") orelse bun.getenvZ("TEMP") orelse "/tmp";
-        }
+            break :brk "unknown";
+        };
 
         return JSC.ZigString.init(dir).withEncoding().toValueGC(globalThis);
     }
diff --git a/src/bun.js/node/syscall.zig b/src/bun.js/node/syscall.zig
index 035a8738f..087bb06dd 100644
--- a/src/bun.js/node/syscall.zig
+++ b/src/bun.js/node/syscall.zig
@@ -141,7 +141,7 @@ pub fn stat(path: [:0]const u8) Maybe(os.Stat) {
     const rc = statSym(path, &stat_);
 
     if (comptime Environment.allow_assert)
-        log("stat({s}) = {d}", .{ std.mem.span(path), rc });
+        log("stat({s}) = {d}", .{ bun.asByteSlice(path), rc });
 
     if (Maybe(os.Stat).errnoSys(rc, .stat)) |err| return err;
     return Maybe(os.Stat){ .result = stat_ };
diff --git a/src/bun.js/node/types.zig b/src/bun.js/node/types.zig
index 591af3f09..b70ad9ea3 100644
--- a/src/bun.js/node/types.zig
+++ b/src/bun.js/node/types.zig
@@ -26,7 +26,7 @@ pub fn DeclEnum(comptime T: type) type {
     const fieldInfos = std.meta.declarations(T);
     var enumFields: [fieldInfos.len]std.builtin.Type.EnumField = undefined;
     var decls = [_]std.builtin.Type.Declaration{};
-    inline for (fieldInfos) |field, i| {
+    inline for (fieldInfos, 0..) |field, i| {
         enumFields[i] = .{
             .name = field.name,
             .value = i,
@@ -105,7 +105,7 @@ pub fn Maybe(comptime ResultType: type) type {
                         if (ResultType == []u8) {
                             return JSC.ArrayBuffer.fromBytes(r, .ArrayBuffer).toJS(globalThis, null);
                         }
-                        return JSC.ZigString.init(std.mem.span(r)).withEncoding().toValueAuto(globalThis);
+                        return JSC.ZigString.init(bun.asByteSlice(r)).withEncoding().toValueAuto(globalThis);
                     }
 
                     if (comptime @typeInfo(ReturnType) == .Bool) {
@@ -178,7 +178,7 @@ pub fn Maybe(comptime ResultType: type) type {
                 .SUCCESS => null,
                 else => |err| @This(){
                     // always truncate
-                    .err = .{ .errno = @truncate(Syscall.Error.Int, @enumToInt(err)), .syscall = syscall, .path = std.mem.span(path) },
+                    .err = .{ .errno = @truncate(Syscall.Error.Int, @enumToInt(err)), .syscall = syscall, .path = bun.asByteSlice(path) },
                 },
             };
         }
@@ -643,7 +643,7 @@ pub const PathLike = union(Tag) {
                     arguments.protectEat();
 
                     if (zig_str.is16Bit()) {
-                        var printed = std.mem.span(std.fmt.allocPrintZ(arguments.arena.allocator(), "{}", .{zig_str}) catch unreachable);
+                        var printed = bun.asByteSlice(std.fmt.allocPrintZ(arguments.arena.allocator(), "{}", .{zig_str}) catch unreachable);
                         return PathLike{ .string = PathString.init(printed.ptr[0 .. printed.len + 1]) };
                     }
 
@@ -1426,7 +1426,7 @@ pub const Emitter = struct {
             pub fn remove(this: *List, ctx: JSC.C.JSContextRef, callback: JSC.JSValue) bool {
                 const callbacks = this.list.items(.callback);
 
-                for (callbacks) |item, i| {
+                for (callbacks, 0..) |item, i| {
                     if (callback.eqlValue(item)) {
                         JSC.C.JSValueUnprotect(ctx, callback.asObjectRef());
                         this.once_count -|= @as(u32, @boolToInt(this.list.items(.once)[i]));
@@ -1720,7 +1720,7 @@ pub const Path = struct {
         var buf: [bun.MAX_PATH_BYTES]u8 = undefined;
         var to_join = allocator.alloc(string, args_len) catch unreachable;
         var possibly_utf16 = false;
-        for (args_ptr[0..args_len]) |arg, i| {
+        for (args_ptr[0..args_len], 0..) |arg, i| {
             const zig_str: JSC.ZigString = arg.getZigString(globalThis);
             if (zig_str.is16Bit()) {
                 // TODO: remove this string conversion
diff --git a/src/bun.js/test/jest.zig b/src/bun.js/test/jest.zig
index 23dd05e94..6281a3bda 100644
--- a/src/bun.js/test/jest.zig
+++ b/src/bun.js/test/jest.zig
@@ -435,28 +435,28 @@ pub const Jest = struct {
         ctx: js.JSContextRef,
         _: js.JSObjectRef,
         _: js.JSObjectRef,
-        arguments: []const js.JSValueRef,
+        arguments_: []const js.JSValueRef,
         exception: js.ExceptionRef,
     ) js.JSValueRef {
         var runner_ = runner orelse {
             JSError(getAllocator(ctx), "Run bun wiptest to run a test", .{}, ctx, exception);
             return js.JSValueMakeUndefined(ctx);
         };
+        const arguments = @ptrCast([]const JSC.JSValue, arguments_);
 
-        if (arguments.len < 1 or !js.JSValueIsString(ctx, arguments[0])) {
+        if (arguments.len < 1 or !arguments[0].isString()) {
             JSError(getAllocator(ctx), "Bun.jest() expects a string filename", .{}, ctx, exception);
             return js.JSValueMakeUndefined(ctx);
         }
-        var str = js.JSValueToStringCopy(ctx, arguments[0], exception);
-        defer js.JSStringRelease(str);
-        var ptr = js.JSStringGetCharacters8Ptr(str);
-        const len = js.JSStringGetLength(str);
-        if (len == 0 or ptr[0] != '/') {
+        var str = arguments[0].toSlice(ctx, bun.default_allocator);
+        defer str.deinit();
+        var slice = str.slice();
+
+        if (str.len == 0 or slice[0] != '/') {
             JSError(getAllocator(ctx), "Bun.jest() expects an absolute file path", .{}, ctx, exception);
             return js.JSValueMakeUndefined(ctx);
         }
-        var str_value = ptr[0..len];
-        var filepath = Fs.FileSystem.instance.filename_store.append([]const u8, str_value) catch unreachable;
+        var filepath = Fs.FileSystem.instance.filename_store.append([]const u8, slice) catch unreachable;
 
         var scope = runner_.getOrPutFile(filepath);
         DescribeScope.active = scope;
@@ -2495,7 +2495,7 @@ pub const DescribeScope = struct {
     pub fn execCallback(this: *DescribeScope, ctx: js.JSContextRef, comptime hook: LifecycleHook) JSValue {
         const name = comptime @as(string, @tagName(hook));
         var hooks: []JSC.JSValue = @field(this, name).items;
-        for (hooks) |cb, i| {
+        for (hooks, 0..) |cb, i| {
             if (cb.isEmpty()) continue;
 
             const pending_test = Jest.runner.?.pending_test;
diff --git a/src/bun.js/uuid.zig b/src/bun.js/uuid.zig
index affd07a32..f172c6225 100644
--- a/src/bun.js/uuid.zig
+++ b/src/bun.js/uuid.zig
@@ -87,7 +87,7 @@ pub fn print(
     buf[13] = '-';
     buf[18] = '-';
     buf[23] = '-';
-    inline for (encoded_pos) |i, j| {
+    inline for (encoded_pos, 0..) |i, j| {
         buf[comptime i + 0] = hex[bytes[j] >> 4];
         buf[comptime i + 1] = hex[bytes[j] & 0x0f];
     }
@@ -99,7 +99,7 @@ pub fn parse(buf: []const u8) Error!UUID {
     if (buf.len != 36 or buf[8] != '-' or buf[13] != '-' or buf[18] != '-' or buf[23] != '-')
         return Error.InvalidUUID;
 
-    inline for (encoded_pos) |i, j| {
+    inline for (encoded_pos, 0..) |i, j| {
         const hi = hex_to_nibble[buf[i + 0]];
         const lo = hex_to_nibble[buf[i + 1]];
         if (hi == 0xff or lo == 0xff) {
diff --git a/src/bun.js/webcore/base64.zig b/src/bun.js/webcore/base64.zig
index 50c1ac68d..aad1c471b 100644
--- a/src/bun.js/webcore/base64.zig
+++ b/src/bun.js/webcore/base64.zig
@@ -120,7 +120,7 @@ pub const Base64Encoder = struct {
             out_idx += 1;
         }
         if (encoder.pad_char) |pad_char| {
-            for (dest[out_idx..]) |*pad| {
+            for (&dest[out_idx..]) |*pad| {
                 pad.* = pad_char;
             }
         }
@@ -143,7 +143,7 @@ pub const Base64Decoder = struct {
         };
 
         var char_in_alphabet = [_]bool{false} ** 256;
-        for (alphabet_chars) |c, i| {
+        for (alphabet_chars, 0..) |c, i| {
             assert(!char_in_alphabet[c]);
             assert(pad_char == null or c != pad_char.?);
 
@@ -188,7 +188,7 @@ pub const Base64Decoder = struct {
         var acc_len: u4 = 0;
         var dest_idx: usize = 0;
         var leftover_idx: ?usize = null;
-        for (source) |c, src_idx| {
+        for (source, 0..) |c, src_idx| {
             const d = decoder.char_to_index[c];
             if (d == invalid_char) {
                 if (decoder.pad_char == null or c != decoder.pad_char.?) return error.InvalidCharacter;
@@ -261,7 +261,7 @@ pub const Base64DecoderWithIgnore = struct {
         var acc_len: u4 = 0;
         var dest_idx: usize = 0;
         var leftover_idx: ?usize = null;
-        for (source) |c, src_idx| {
+        for (source, 0..) |c, src_idx| {
             if (decoder_with_ignore.char_is_ignored[c]) continue;
             const d = decoder.char_to_index[c];
             if (d == Base64Decoder.invalid_char) {
diff --git a/src/bun.js/webcore/blob.zig b/src/bun.js/webcore/blob.zig
index de0ec1cb2..9e5ad4ec2 100644
--- a/src/bun.js/webcore/blob.zig
+++ b/src/bun.js/webcore/blob.zig
@@ -391,7 +391,7 @@ pub const Blob = struct {
             bun.default_allocator.destroy(handler);
             var blob = blob_ catch |err| {
                 var error_string = ZigString.init(
-                    std.fmt.allocPrint(bun.default_allocator, "Failed to write file \"{s}\"", .{std.mem.span(@errorName(err))}) catch unreachable,
+                    std.fmt.allocPrint(bun.default_allocator, "Failed to write file \"{s}\"", .{bun.asByteSlice(@errorName(err))}) catch unreachable,
                 );
                 error_string.mark();
 
@@ -1185,7 +1185,7 @@ pub const Blob = struct {
 
                                 this.system_error = .{
                                     .syscall = ZigString.init("open"),
-                                    .code = ZigString.init(std.mem.span(@errorName(this.errno.?))),
+                                    .code = ZigString.init(bun.asByteSlice(@errorName(this.errno.?))),
                                     .path = ZigString.init(path_string.slice()),
                                 };
 
@@ -1391,7 +1391,7 @@ pub const Blob = struct {
                         }).toSystemError();
                     } else {
                         this.system_error = JSC.SystemError{
-                            .code = ZigString.init(std.mem.span(@errorName(err))),
+                            .code = ZigString.init(bun.asByteSlice(@errorName(err))),
                             .path = if (this.file_store.pathlike == .path)
                                 ZigString.init(this.file_store.pathlike.path.slice())
                             else
@@ -1630,7 +1630,7 @@ pub const Blob = struct {
                 this.wrote += @truncate(SizeType, result catch |errno| {
                     this.errno = errno;
                     this.system_error = this.system_error orelse JSC.SystemError{
-                        .code = ZigString.init(std.mem.span(@errorName(errno))),
+                        .code = ZigString.init(bun.asByteSlice(@errorName(errno))),
                         .syscall = ZigString.init("write"),
                     };
 
diff --git a/src/bun.js/webcore/body.zig b/src/bun.js/webcore/body.zig
index c4e2e1324..ad40c56ff 100644
--- a/src/bun.js/webcore/body.zig
+++ b/src/bun.js/webcore/body.zig
@@ -950,20 +950,24 @@ pub fn BodyMixin(comptime Type: type) type {
     return struct {
         pub fn getText(
             this: *Type,
-            globalThis: *JSC.JSGlobalObject,
+            globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
         ) callconv(.C) JSC.JSValue {
             var value: *Body.Value = this.getBodyValue();
             if (value.* == .Used) {
-                return handleBodyAlreadyUsed(globalThis);
+                return handleBodyAlreadyUsed(globalObject);
             }
 
             if (value.* == .Locked) {
-                return value.Locked.setPromise(globalThis, .{ .getText = void{} });
+                if (value.Locked.promise != null) {
+                    return handleBodyAlreadyUsed(globalObject);
+                }
+
+                return value.Locked.setPromise(globalObject, .{ .getText = void{} });
             }
 
             var blob = value.useAsAnyBlob();
-            return JSC.JSPromise.wrap(globalThis, blob.toString(globalThis, .transfer));
+            return JSC.JSPromise.wrap(globalObject, blob.toString(globalObject, .transfer));
         }
 
         pub fn getBody(
@@ -998,6 +1002,9 @@ pub fn BodyMixin(comptime Type: type) type {
             }
 
             if (value.* == .Locked) {
+                if (value.Locked.promise != null) {
+                    return handleBodyAlreadyUsed(globalObject);
+                }
                 return value.Locked.setPromise(globalObject, .{ .getJSON = void{} });
             }
 
@@ -1024,6 +1031,9 @@ pub fn BodyMixin(comptime Type: type) type {
             }
 
             if (value.* == .Locked) {
+                if (value.Locked.promise != null) {
+                    return handleBodyAlreadyUsed(globalObject);
+                }
                 return value.Locked.setPromise(globalObject, .{ .getArrayBuffer = void{} });
             }
 
@@ -1042,6 +1052,12 @@ pub fn BodyMixin(comptime Type: type) type {
                 return handleBodyAlreadyUsed(globalObject);
             }
 
+            if (value.* == .Locked) {
+                if (value.Locked.promise != null) {
+                    return handleBodyAlreadyUsed(globalObject);
+                }
+            }
+
             var encoder = this.getFormDataEncoding() orelse {
                 globalObject.throw("Invalid MIME type", .{});
                 return .zero;
@@ -1089,6 +1105,10 @@ pub fn BodyMixin(comptime Type: type) type {
             }
 
             if (value.* == .Locked) {
+                if (value.Locked.promise != null) {
+                    return handleBodyAlreadyUsed(globalObject);
+                }
+
                 return value.Locked.setPromise(globalObject, .{ .getBlob = void{} });
             }
 
diff --git a/src/bun.js/webcore/encoding.zig b/src/bun.js/webcore/encoding.zig
index 8a6e3224b..deab624d0 100644
--- a/src/bun.js/webcore/encoding.zig
+++ b/src/bun.js/webcore/encoding.zig
@@ -1139,7 +1139,7 @@ pub const Encoder = struct {
                 var to = allocator.alloc(u8, len) catch return &[_]u8{};
                 var input_bytes = std.mem.sliceAsBytes(input[0..len]);
                 @memcpy(to.ptr, input_bytes.ptr, input_bytes.len);
-                for (to[0..len]) |c, i| {
+                for (to[0..len], 0..) |c, i| {
                     to[i] = @as(u8, @truncate(u7, c));
                 }
 
diff --git a/src/bun.js/webcore/request.zig b/src/bun.js/webcore/request.zig
index b2ff43a5a..1a3bc1e4c 100644
--- a/src/bun.js/webcore/request.zig
+++ b/src/bun.js/webcore/request.zig
@@ -125,7 +125,7 @@ pub const Request = struct {
 
             try formatter.writeIndent(Writer, writer);
             try writer.writeAll("method: \"");
-            try writer.writeAll(std.mem.span(@tagName(this.method)));
+            try writer.writeAll(bun.asByteSlice(@tagName(this.method)));
             try writer.writeAll("\"");
             formatter.printComma(Writer, writer, enable_ansi_colors) catch unreachable;
             try writer.writeAll("\n");
@@ -163,7 +163,7 @@ pub const Request = struct {
 
     pub fn fromRequestContext(ctx: *RequestContext) !Request {
         var req = Request{
-            .url = std.mem.span(ctx.getFullURL()),
+            .url = bun.asByteSlice(ctx.getFullURL()),
             .body = .{ .Empty = {} },
             .method = ctx.method,
             .headers = FetchHeaders.createFromPicoHeaders(ctx.request.headers),
diff --git a/src/bun.js/webcore/response.zig b/src/bun.js/webcore/response.zig
index cd4b1be4c..7ba7198c7 100644
--- a/src/bun.js/webcore/response.zig
+++ b/src/bun.js/webcore/response.zig
@@ -566,31 +566,31 @@ pub const Fetch = struct {
         var errors = JSTypeErrorEnum.initUndefined();
         errors.set(
             JSType.kJSTypeUndefined,
-            std.mem.span(fetch_type_error_string_values[0]),
+            bun.asByteSlice(fetch_type_error_string_values[0]),
         );
         errors.set(
             JSType.kJSTypeNull,
-            std.mem.span(fetch_type_error_string_values[1]),
+            bun.asByteSlice(fetch_type_error_string_values[1]),
         );
         errors.set(
             JSType.kJSTypeBoolean,
-            std.mem.span(fetch_type_error_string_values[2]),
+            bun.asByteSlice(fetch_type_error_string_values[2]),
         );
         errors.set(
             JSType.kJSTypeNumber,
-            std.mem.span(fetch_type_error_string_values[3]),
+            bun.asByteSlice(fetch_type_error_string_values[3]),
         );
         errors.set(
             JSType.kJSTypeString,
-            std.mem.span(fetch_type_error_string_values[4]),
+            bun.asByteSlice(fetch_type_error_string_values[4]),
         );
         errors.set(
             JSType.kJSTypeObject,
-            std.mem.span(fetch_type_error_string_values[5]),
+            bun.asByteSlice(fetch_type_error_string_values[5]),
         );
         errors.set(
             JSType.kJSTypeSymbol,
-            std.mem.span(fetch_type_error_string_values[6]),
+            bun.asByteSlice(fetch_type_error_string_values[6]),
         );
         break :brk errors;
     };
diff --git a/src/bun.js/webcore/streams.zig b/src/bun.js/webcore/streams.zig
index 868d0840d..0a38c7ed0 100644
--- a/src/bun.js/webcore/streams.zig
+++ b/src/bun.js/webcore/streams.zig
@@ -1892,8 +1892,8 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
 
         const ThisSink = @This();
 
-        pub const shim = JSC.Shimmer("", std.mem.span(name_), @This());
-        pub const name = std.fmt.comptimePrint("{s}", .{std.mem.span(name_)});
+        pub const shim = JSC.Shimmer("", name_, @This());
+        pub const name = std.fmt.comptimePrint("{s}", .{name_});
 
         // This attaches it to JS
         pub const SinkSignal = extern struct {
@@ -2938,8 +2938,8 @@ pub fn ReadableStreamSource(
         const supports_ref = setRefUnrefFn != null;
 
         pub const JSReadableStreamSource = struct {
-            pub const shim = JSC.Shimmer(std.mem.span(name_), "JSReadableStreamSource", @This());
-            pub const name = std.fmt.comptimePrint("{s}_JSReadableStreamSource", .{std.mem.span(name_)});
+            pub const shim = JSC.Shimmer(name_, "JSReadableStreamSource", @This());
+            pub const name = std.fmt.comptimePrint("{s}_JSReadableStreamSource", .{name_});
 
             pub fn pull(globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) callconv(.C) JSC.JSValue {
                 JSC.markBinding(@src());