wip use wrapper for managing process

CMakeLists.txt

@@ -1287,6 +1287,7 @@ endif()
 
 if(USE_CUSTOM_LSHPACK)
     include_directories(${BUN_DEPS_DIR}/ls-hpack)
+
     if(WIN32)
         include_directories(${BUN_DEPS_DIR}/ls-hpack/compat/queue)
         target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/lshpack.lib")

packages/bun-types/bun.d.ts

@@ -3921,7 +3921,16 @@ declare module "bun" {
       /**
        * If true, the subprocess will have a hidden window.
        */
-      // windowsHide?: boolean;
+      windowsHide?: boolean;
+
+      /**
+       * Path to the executable to run in the subprocess. This defaults to `cmds[0]`.
+       *
+       * One use-case for this is for applications which wrap other applications or to simulate a symlink.
+       *
+       * @default cmds[0]
+       */
+      argv0?: string;
     }
 
     type OptionsToSubprocess<Opts extends OptionsObject> = Opts extends OptionsObject<infer In, infer Out, infer Err>

packages/bun-usockets/src/eventing/epoll_kqueue.c

@@ -298,7 +298,7 @@ int kqueue_change(int kqfd, int fd, int old_events, int new_events, void *user_d
         EV_SET64(&change_list[change_length++], fd, EVFILT_WRITE, (new_events & LIBUS_SOCKET_WRITABLE) ? EV_ADD : EV_DELETE, 0, 0, (uint64_t)(void*)user_data, 0, 0);
     }
 
-    int ret = kevent64(kqfd, change_list, change_length, NULL, 0, 0, NULL);
+    int ret = kevent64(kqfd, change_list, change_length, change_list, change_length, KEVENT_FLAG_ERROR_EVENTS, NULL);
 
     // ret should be 0 in most cases (not guaranteed when removing async)
 
@@ -468,7 +468,7 @@ void us_timer_close(struct us_timer_t *timer, int fallthrough) {
 
     struct kevent64_s event;
     EV_SET64(&event, (uint64_t) (void*) internal_cb, EVFILT_TIMER, EV_DELETE, 0, 0, (uint64_t)internal_cb, 0, 0);
-    kevent64(internal_cb->loop->fd, &event, 1, NULL, 0, 0, NULL);
+    kevent64(internal_cb->loop->fd, &event, 1, &event, 1, KEVENT_FLAG_ERROR_EVENTS, NULL);
 
     /* (regular) sockets are the only polls which are not freed immediately */
     if(fallthrough){
@@ -487,7 +487,7 @@ void us_timer_set(struct us_timer_t *t, void (*cb)(struct us_timer_t *t), int ms
     struct kevent64_s event;
     uint64_t ptr = (uint64_t)(void*)internal_cb;
     EV_SET64(&event, ptr, EVFILT_TIMER, EV_ADD | (repeat_ms ? 0 : EV_ONESHOT), 0, ms, (uint64_t)internal_cb, 0, 0);
-    kevent64(internal_cb->loop->fd, &event, 1, NULL, 0, 0, NULL);
+    kevent64(internal_cb->loop->fd, &event, 1, &event, 1, KEVENT_FLAG_ERROR_EVENTS, NULL);
 }
 #endif
 
@@ -565,7 +565,7 @@ void us_internal_async_close(struct us_internal_async *a) {
     struct kevent64_s event;
     uint64_t ptr = (uint64_t)(void*)internal_cb;
     EV_SET64(&event, ptr, EVFILT_MACHPORT, EV_DELETE, 0, 0, (uint64_t)(void*)internal_cb, 0,0);
-    kevent64(internal_cb->loop->fd, &event, 1, NULL, 0, 0, NULL);
+    kevent64(internal_cb->loop->fd, &event, 1, &event, 1, KEVENT_FLAG_ERROR_EVENTS, NULL);
 
     mach_port_deallocate(mach_task_self(), internal_cb->port);
     us_free(internal_cb->machport_buf);
@@ -593,7 +593,7 @@ void us_internal_async_set(struct us_internal_async *a, void (*cb)(struct us_int
     event.ext[1] = MACHPORT_BUF_LEN;
     event.udata = (uint64_t)(void*)internal_cb;
 
-    int ret = kevent64(internal_cb->loop->fd, &event, 1, NULL, 0, 0, NULL);
+    int ret = kevent64(internal_cb->loop->fd, &event, 1, &event, 1, KEVENT_FLAG_ERROR_EVENTS, NULL);
 
     if (UNLIKELY(ret == -1)) {
        abort();

src/allocators.zig

@@ -5,12 +5,18 @@ const Environment = @import("./env.zig");
 const FixedBufferAllocator = std.heap.FixedBufferAllocator;
 const bun = @import("root").bun;
 
-/// Checks if a slice's pointer is contained within another slice.
-pub inline fn isSliceInBuffer(comptime T: type, slice: []const T, buffer: []const T) bool {
+inline fn isSliceInBufferT(comptime T: type, slice: []const T, buffer: []const T) bool {
     return (@intFromPtr(buffer.ptr) <= @intFromPtr(slice.ptr) and
         (@intFromPtr(slice.ptr) + slice.len) <= (@intFromPtr(buffer.ptr) + buffer.len));
 }
 
+/// Checks if a slice's pointer is contained within another slice.
+///
+/// If you need to make this generic, use isSliceInBufferT.
+pub inline fn isSliceInBuffer(slice: []const u8, buffer: []const u8) bool {
+    return isSliceInBufferT(u8, slice, buffer);
+}
+
 pub fn sliceRange(slice: []const u8, buffer: []const u8) ?[2]u32 {
     return if (@intFromPtr(buffer.ptr) <= @intFromPtr(slice.ptr) and
         (@intFromPtr(slice.ptr) + slice.len) <= (@intFromPtr(buffer.ptr) + buffer.len))
@@ -309,7 +315,7 @@ pub fn BSSStringList(comptime _count: usize, comptime _item_length: usize) type
         }
 
         pub fn exists(self: *const Self, value: ValueType) bool {
-            return isSliceInBuffer(u8, value, &self.backing_buf);
+            return isSliceInBuffer(value, &self.backing_buf);
         }
 
         pub fn editableSlice(slice: []const u8) []u8 {

src/analytics/analytics_thread.zig

@@ -277,6 +277,8 @@ pub const GenerateHeader = struct {
         var platform_: ?Analytics.Platform = null;
         pub const Platform = Analytics.Platform;
 
+        var linux_kernel_version: Semver.Version = undefined;
+
         pub fn forOS() Analytics.Platform {
             if (platform_ != null) return platform_.?;
 
@@ -285,6 +287,11 @@ pub const GenerateHeader = struct {
                 return platform_.?;
             } else if (comptime Environment.isPosix) {
                 platform_ = forLinux();
+
+                const release = bun.sliceTo(&linux_os_name.release, 0);
+                const sliced_string = Semver.SlicedString.init(release, release);
+                const result = Semver.Version.parse(sliced_string);
+                linux_kernel_version = result.version.min();
             } else {
                 platform_ = Platform{
                     .os = Analytics.OperatingSystem.windows,
@@ -301,11 +308,9 @@ pub const GenerateHeader = struct {
                 @compileError("This function is only implemented on Linux");
             }
             _ = forOS();
-            const release = bun.sliceTo(&linux_os_name.release, 0);
-            const sliced_string = Semver.SlicedString.init(release, release);
-            const result = Semver.Version.parse(sliced_string);
+
             // we only care about major, minor, patch so we don't care about the string
-            return result.version.min();
+            return linux_kernel_version;
         }
 
         pub fn forLinux() Analytics.Platform {