bunite-core 0.6.0 → 0.8.0

package/src/native/mac/bunite_mac_window.mm

@@ -0,0 +1,187 @@
+// NSWindow lifecycle + delegate. Mirrors win/native_host_runtime.cpp window proc.
+
+#import "bunite_mac_internal.h"
+
+#include <sstream>
+#include <vector>
+
+using bunite_mac::g_runtime;
+using bunite_mac::utf8ToNSString;
+using bunite_mac::bottomLeftToTopLeft;
+
+namespace {
+
+NSString* kHiddenStyle = @"hidden";
+NSString* kHiddenInsetStyle = @"hiddenInset";
+
+NSUInteger styleMaskFor(NSString* tbs) {
+  NSUInteger base = NSWindowStyleMaskClosable | NSWindowStyleMaskResizable | NSWindowStyleMaskMiniaturizable;
+  if ([tbs isEqualToString:kHiddenStyle]) {
+    return base | NSWindowStyleMaskFullSizeContentView;  // no titled
+  }
+  return base | NSWindowStyleMaskTitled;
+}
+
+std::string movePayload(NSWindow* w) {
+  double x, y, ww, hh;
+  bottomLeftToTopLeft(w.frame, &x, &y, &ww, &hh);
+  (void)ww; (void)hh;
+  std::ostringstream o;
+  o << "{\"x\":" << x << ",\"y\":" << y
+    << ",\"maximized\":" << (w.zoomed ? "true" : "false")
+    << ",\"minimized\":" << (w.miniaturized ? "true" : "false") << "}";
+  return o.str();
+}
+
+std::string resizePayload(NSWindow* w) {
+  double x, y, ww, hh;
+  bottomLeftToTopLeft(w.frame, &x, &y, &ww, &hh);
+  std::ostringstream o;
+  o << "{\"x\":" << x << ",\"y\":" << y
+    << ",\"width\":" << ww << ",\"height\":" << hh
+    << ",\"maximized\":" << (w.zoomed ? "true" : "false")
+    << ",\"minimized\":" << (w.miniaturized ? "true" : "false") << "}";
+  return o.str();
+}
+
+} // namespace
+
+// Flipped container so child NSViews use top-left coordinates (matches surface IPC).
+@interface BuniteFlippedView : NSView
+@end
+@implementation BuniteFlippedView
+- (BOOL)isFlipped { return YES; }
+@end
+
+@interface BuniteWindowDelegate : NSObject <NSWindowDelegate>
+@property (nonatomic, assign) uint32_t window_id;
+@end
+
+@implementation BuniteWindowDelegate
+
+- (BOOL)windowShouldClose:(NSWindow*)w {
+  (void)w;
+  bunite_mac::WindowState* state = bunite_mac::findWindow(self.window_id);
+  if (!state) return YES;
+  if (state->close_pending.exchange(true)) return NO;  // already pending
+  bunite_mac::emitWindowEvent(self.window_id, "close-requested");
+  return NO;  // JS responds with bunite_window_destroy or reset_close_pending
+}
+
+- (void)windowWillClose:(NSNotification*)n {
+  (void)n;
+  uint32_t id = self.window_id;
+  bunite_mac::emitWindowEvent(id, "close");
+
+  // Tear down child views before erasing the window so WKWebViews don't outlive their host.
+  std::vector<uint32_t> orphaned;
+  bool windows_empty = false;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    for (auto& [vid, vst] : g_runtime.views) {
+      if (vst.window_id == id) orphaned.push_back(vid);
+    }
+    g_runtime.windows.erase(id);
+    windows_empty = g_runtime.windows.empty();
+  }
+  for (uint32_t vid : orphaned) bunite_mac::removeView(vid);
+  if (windows_empty && !g_runtime.shutting_down.load()) {
+    bunite_mac::emitWindowEvent(0, "all-windows-closed");
+  }
+}
+
+- (void)windowDidBecomeKey:(NSNotification*)n {
+  (void)n;
+  bunite_mac::emitWindowEvent(self.window_id, "focus");
+}
+
+- (void)windowDidResignKey:(NSNotification*)n {
+  (void)n;
+  bunite_mac::emitWindowEvent(self.window_id, "blur");
+}
+
+- (void)windowDidMove:(NSNotification*)n {
+  bunite_mac::WindowState* state = bunite_mac::findWindow(self.window_id);
+  if (!state) return;
+  bunite_mac::emitWindowEvent(self.window_id, "move", movePayload(state->window));
+}
+
+- (void)windowDidResize:(NSNotification*)n {
+  bunite_mac::WindowState* state = bunite_mac::findWindow(self.window_id);
+  if (!state) return;
+  bunite_mac::emitWindowEvent(self.window_id, "resize", resizePayload(state->window));
+}
+
+@end
+
+namespace bunite_mac {
+
+WindowState* findWindow(uint32_t window_id) {
+  std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+  auto it = g_runtime.windows.find(window_id);
+  return it == g_runtime.windows.end() ? nullptr : &it->second;
+}
+
+bool createWindow(uint32_t window_id, double x, double y, double width, double height,
+                  NSString* title, NSString* title_bar_style,
+                  bool transparent, bool hidden, bool minimized, bool maximized) {
+  if (findWindow(window_id)) {
+    BUNITE_WARN("bunite_window_create: id %u already exists.", window_id);
+    return false;
+  }
+
+  NSRect frame = topLeftToBottomLeft(x, y, width, height);
+  NSUInteger style = styleMaskFor(title_bar_style);
+
+  NSWindow* window = [[NSWindow alloc] initWithContentRect:frame
+                                                 styleMask:style
+                                                   backing:NSBackingStoreBuffered
+                                                     defer:NO];
+  window.releasedWhenClosed = NO;  // ARC __strong holds it; AppKit self-release would over-release.
+  window.title = title ?: @"";
+  window.contentView = [[BuniteFlippedView alloc] initWithFrame:frame];
+
+  if ([title_bar_style isEqualToString:kHiddenInsetStyle]) {
+    window.titlebarAppearsTransparent = YES;
+    window.titleVisibility = NSWindowTitleHidden;
+  }
+  if (transparent) {
+    window.opaque = NO;
+    window.backgroundColor = [NSColor clearColor];
+    window.hasShadow = NO;
+  }
+
+  BuniteWindowDelegate* delegate = [[BuniteWindowDelegate alloc] init];
+  delegate.window_id = window_id;
+  window.delegate = delegate;
+
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto& state = g_runtime.windows[window_id];
+    state.window = window;
+    state.delegate = delegate;
+  }
+
+  if (!hidden) {
+    [window makeKeyAndOrderFront:nil];
+    [NSApp activateIgnoringOtherApps:YES];
+  }
+  if (minimized) [window miniaturize:nil];
+  if (maximized && !window.zoomed) [window zoom:nil];
+
+  return true;
+}
+
+void destroyWindow(uint32_t window_id) {
+  __strong NSWindow* window = nil;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto it = g_runtime.windows.find(window_id);
+    if (it == g_runtime.windows.end()) return;
+    window = it->second.window;
+    // Don't erase here — windowWillClose: does it after emitting "close".
+  }
+  if (window) [window close];
+}
+
+} // namespace bunite_mac

package/src/native/shared/ffi_exports.h

@@ -18,13 +18,21 @@ extern "C" {
 BUNITE_EXPORT int32_t bunite_abi_version(void);
 BUNITE_EXPORT void bunite_set_log_level(int32_t level);
 BUNITE_EXPORT bool bunite_init(
-	const char* process_helper_path,
-	const char* cef_dir,
+	const char* engine_dir,
 	bool hide_console,
 	bool popup_blocking,
-	const char* chromium_flags_json
+	const char* engine_config_json
 );
+BUNITE_EXPORT const char* bunite_engine_name(void);
+BUNITE_EXPORT const char* bunite_engine_version(void);
 BUNITE_EXPORT void bunite_run_loop(void);
+/**
+ * Drive one non-blocking iteration of the engine's UI event queue. Required on
+ * engines where the UI loop must share the main thread with Bun's libuv loop
+ * (macOS WKWebView, Linux WebKitGTK). On engines that own a dedicated UI thread
+ * (Windows CEF), this is a no-op.
+ */
+BUNITE_EXPORT void bunite_pump_once(void);
 BUNITE_EXPORT void bunite_quit(void);
 BUNITE_EXPORT void bunite_free_cstring(const char* value);
 BUNITE_EXPORT void bunite_set_webview_event_handler(BuniteWebviewEventHandler handler);
@@ -85,6 +93,8 @@ BUNITE_EXPORT void bunite_register_appres_route(const char* path);
 BUNITE_EXPORT void bunite_unregister_appres_route(const char* path);
 BUNITE_EXPORT void bunite_complete_route_request(uint32_t request_id, const char* html);
 BUNITE_EXPORT void bunite_view_set_visible(uint32_t view_id, bool visible);
+BUNITE_EXPORT void bunite_view_set_input_passthrough(uint32_t view_id, bool passthrough);
+BUNITE_EXPORT void bunite_view_set_mask_region(uint32_t view_id, const double* rects, uint32_t count);
 BUNITE_EXPORT void bunite_view_bring_to_front(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_set_bounds(
 	uint32_t view_id,
@@ -108,16 +118,6 @@ BUNITE_EXPORT void bunite_view_open_devtools(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_close_devtools(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_toggle_devtools(uint32_t view_id);
 BUNITE_EXPORT void bunite_complete_permission_request(uint32_t request_id, uint32_t state);
-BUNITE_EXPORT int32_t bunite_show_message_box(
-	uint32_t window_id,
-	const char* type,
-	const char* title,
-	const char* message,
-	const char* detail,
-	const char* buttons,
-	int32_t default_id,
-	int32_t cancel_id
-);
 #ifdef __cplusplus
 }
 #endif

package/src/native/shared/permissions.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stdint.h>
+
+// Engine-agnostic permission bitmask. Adapters translate to native types.
+
+#define BUNITE_PERMISSION_MICROPHONE      ((uint32_t)(1u << 0))
+#define BUNITE_PERMISSION_CAMERA          ((uint32_t)(1u << 1))
+#define BUNITE_PERMISSION_GEOLOCATION     ((uint32_t)(1u << 2))
+#define BUNITE_PERMISSION_NOTIFICATIONS   ((uint32_t)(1u << 3))
+#define BUNITE_PERMISSION_CLIPBOARD       ((uint32_t)(1u << 4))
+#define BUNITE_PERMISSION_SCREEN_CAPTURE  ((uint32_t)(1u << 5))
+#define BUNITE_PERMISSION_POINTER_LOCK    ((uint32_t)(1u << 6))
+#define BUNITE_PERMISSION_MIDI_SYSEX      ((uint32_t)(1u << 7))

package/src/native/shared/webview_storage.h

@@ -27,6 +27,11 @@ public:
     return it == content_.end() ? std::string{} : it->second;
   }
 
+  bool has(uint32_t webview_id) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return content_.find(webview_id) != content_.end();
+  }
+
   void remove(uint32_t webview_id) {
     std::lock_guard<std::mutex> lock(mutex_);
     content_.erase(webview_id);
@@ -39,9 +44,7 @@ private:
   std::map<uint32_t, std::string> content_;
 };
 
-// Tracks which appres:// paths have registered dynamic handlers on the Bun side.
-// The actual handler function lives in JS; this only stores the set of registered paths
-// and completed route responses.
+// Registered dynamic appres:// paths + completed route responses. JS owns the handler.
 class AppResRouteStorage {
 public:
   static AppResRouteStorage& instance() {

package/src/native/win/native_host_cef.cpp

@@ -102,8 +102,7 @@ public:
     CefRefPtr<CefDictionaryValue>&,
     bool*
   ) override {
-    // Inject our tracked client so F12, Ctrl+Shift+I, and Inspect Element
-    // all go through BuniteDevToolsClient for proper shutdown sequencing.
+    // Route F12/Ctrl+Shift+I/Inspect through BuniteDevToolsClient for shutdown ordering.
     client = new BuniteDevToolsClient();
   }
 
@@ -273,7 +272,7 @@ public:
       view_->id,
       "permission-requested",
       "{\"requestId\":" + std::to_string(request_id) +
-        ",\"kind\":" + std::to_string(requested_permissions) +
+        ",\"kind\":" + std::to_string(bunite_win::cefPermissionsToBuniteKind(requested_permissions)) +
         ",\"url\":\"" + bunite_win::escapeJsonString(requesting_origin.ToString()) + "\"}"
     );
     return true;
@@ -302,7 +301,7 @@ public:
       view_->id,
       "permission-requested",
       "{\"requestId\":" + std::to_string(request_id) +
-        ",\"kind\":" + std::to_string(requested_permissions) +
+        ",\"kind\":" + std::to_string(bunite_win::cefMediaAccessToBuniteKind(requested_permissions)) +
         ",\"url\":\"" + bunite_win::escapeJsonString(requesting_origin.ToString()) + "\"}"
     );
     return true;
@@ -449,8 +448,7 @@ void closeViewHost(ViewHost* view) {
     return;
   }
 
-  // Browser not yet created — OnAfterCreated will check closing flag.
-  // Safety net: if CreateBrowser failed entirely, clean up on CEF thread.
+  // Browser not yet created — OnAfterCreated handles closing; fallback cleanup if CreateBrowser failed.
   postCefUiTask([view]() {
     if (view->browser) {
       view->browser->GetHost()->CloseBrowser(true);
@@ -819,8 +817,6 @@ bool createBrowserForView(ViewHost* view) {
     }
   }
 
-  // CreateBrowser (async) — can be called from any browser process thread.
-  // Browser instance will be available in OnAfterCreated callback.
   return CefBrowserHost::CreateBrowser(
     window_info,
     view->client,

package/src/native/win/native_host_ffi.cpp

@@ -1,24 +1,89 @@
 #include "native_host_internal.h"
 
+#include "include/cef_version.h"
+#include "include/cef_version_info.h"
+
 using bunite_win::runOnUiThreadSync;
 using bunite_win::runOnCefUiThreadSync;
 
-static constexpr int32_t BUNITE_ABI_VERSION = 2;
+static constexpr int32_t BUNITE_ABI_VERSION = 4;
+
+namespace {
+
+std::string wideToUtf8(const std::wstring& value) {
+  if (value.empty()) return {};
+  const int bytes = WideCharToMultiByte(
+    CP_UTF8, 0, value.data(), static_cast<int>(value.size()), nullptr, 0, nullptr, nullptr);
+  std::string out(static_cast<size_t>(bytes), '\0');
+  WideCharToMultiByte(
+    CP_UTF8, 0, value.data(), static_cast<int>(value.size()),
+    out.data(), bytes, nullptr, nullptr);
+  return out;
+}
+
+std::string resolveProcessHelperPath() {
+  std::wstring buffer(MAX_PATH, L'\0');
+  DWORD len = GetModuleFileNameW(
+    bunite_win::getCurrentModuleHandle(),
+    buffer.data(),
+    static_cast<DWORD>(buffer.size()));
+  while (len == buffer.size() && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+    buffer.resize(buffer.size() * 2);
+    len = GetModuleFileNameW(
+      bunite_win::getCurrentModuleHandle(),
+      buffer.data(),
+      static_cast<DWORD>(buffer.size()));
+  }
+  buffer.resize(len);
+
+  std::filesystem::path dll_path(buffer);
+  std::filesystem::path helper_path = dll_path.parent_path() / L"process_helper.exe";
+  if (!std::filesystem::exists(helper_path)) {
+    BUNITE_ERROR("process_helper.exe not found alongside libBuniteNative.dll at: %s",
+                 helper_path.string().c_str());
+    return {};
+  }
+  return wideToUtf8(helper_path.wstring());
+}
+
+} // namespace
 
 extern "C" BUNITE_EXPORT int32_t bunite_abi_version(void) {
   return BUNITE_ABI_VERSION;
 }
 
+extern "C" BUNITE_EXPORT const char* bunite_engine_name(void) {
+  return "cef";
+}
+
+extern "C" BUNITE_EXPORT const char* bunite_engine_version(void) {
+  // Prefer runtime libcef.dll version — same-major fallback may load a different CEF than headers. Compile-time before init.
+  static std::string cached;
+  static std::once_flag once;
+  std::call_once(once, []() {
+    if (g_runtime.cef_initialized) {
+      char buf[128];
+      std::snprintf(buf, sizeof(buf), "%d.%d.%d+chromium-%d.%d.%d.%d",
+        cef_version_info(0), cef_version_info(1), cef_version_info(2),
+        cef_version_info(4), cef_version_info(5), cef_version_info(6),
+        cef_version_info(7));
+      cached = buf;
+    } else {
+      cached = CEF_VERSION;
+    }
+  });
+  return cached.c_str();
+}
+
 extern "C" BUNITE_EXPORT void bunite_set_log_level(int32_t level) {
   buniteSetLogLevel(static_cast<BuniteLogLevel>(level));
 }
 
 extern "C" BUNITE_EXPORT bool bunite_init(
-  const char* process_helper_path,
-  const char* cef_dir,
+  const char* engine_dir,
   bool hide_console,
   bool popup_blocking,
-  const char* chromium_flags_json
+  const char* engine_config_json
 ) {
   {
     std::lock_guard<std::mutex> lock(g_runtime.lifecycle_mutex);
@@ -30,11 +95,11 @@ extern "C" BUNITE_EXPORT bool bunite_init(
     g_runtime.shutdown_complete = false;
     g_runtime.shutdown_finalize_posted.store(false);
     g_runtime.shutting_down.store(false);
-    g_runtime.process_helper_path = process_helper_path ? process_helper_path : "";
-    g_runtime.cef_dir = cef_dir ? cef_dir : "";
+    g_runtime.process_helper_path = resolveProcessHelperPath();
+    g_runtime.cef_dir = engine_dir ? engine_dir : "";
     g_runtime.popup_blocking = popup_blocking;
     g_runtime.chromium_flags = bunite_win::parseChromiumFlagsJson(
-      chromium_flags_json ? chromium_flags_json : "");
+      engine_config_json ? engine_config_json : "");
   }
 
   if (hide_console) {
@@ -61,6 +126,10 @@ extern "C" BUNITE_EXPORT void bunite_run_loop(void) {
   // The native UI thread owns the Win32 + CEF loop after bunite_init succeeds.
 }
 
+extern "C" BUNITE_EXPORT void bunite_pump_once(void) {
+  // No-op (dedicated UI thread). ABI parity with mac/linux cooperative pumps.
+}
+
 extern "C" BUNITE_EXPORT void bunite_free_cstring(const char* value) {
   std::free(const_cast<char*>(value));
 }
@@ -817,119 +886,3 @@ extern "C" BUNITE_EXPORT void bunite_complete_permission_request(uint32_t reques
   });
 }
 
-extern "C" BUNITE_EXPORT int32_t bunite_show_message_box(
-  uint32_t window_id,
-  const char* type,
-  const char* title,
-  const char* message,
-  const char* detail,
-  const char* buttons,
-  int32_t default_id,
-  int32_t cancel_id
-) {
-  return runOnUiThreadSync<int32_t>([=]() -> int32_t {
-    std::string composed_message = message ? message : "";
-    if (detail && std::strlen(detail) > 0) {
-      if (!composed_message.empty()) {
-        composed_message += "\n\n";
-      }
-      composed_message += detail;
-    }
-
-    UINT flags = MB_OK;
-    const std::string type_name = type ? type : "info";
-    if (type_name == "none") {
-      // Intentionally no icon flag.
-    } else if (type_name == "warning") {
-      flags |= MB_ICONWARNING;
-    } else if (type_name == "error") {
-      flags |= MB_ICONERROR;
-    } else if (type_name == "question") {
-      flags |= MB_ICONQUESTION;
-    } else {
-      flags |= MB_ICONINFORMATION;
-    }
-
-    const std::vector<std::string> labels = bunite_win::splitButtonLabels(buttons ? buttons : "");
-    std::vector<std::string> normalized_labels;
-    normalized_labels.reserve(labels.size());
-    for (const std::string& label : labels) {
-      normalized_labels.push_back(bunite_win::toLowerAscii(bunite_win::trimAsciiWhitespace(label)));
-    }
-
-    if (normalized_labels.size() == 2) {
-      if (normalized_labels[0] == "yes" && normalized_labels[1] == "no") {
-        flags = (flags & ~MB_OK) | MB_YESNO;
-      } else {
-        flags = (flags & ~MB_OK) | MB_OKCANCEL;
-      }
-    } else if (
-      normalized_labels.size() >= 3 &&
-      normalized_labels[0] == "yes" &&
-      normalized_labels[1] == "no" &&
-      normalized_labels[2] == "cancel"
-    ) {
-      flags = (flags & ~MB_OK) | MB_YESNOCANCEL;
-    }
-
-    if (default_id == 1) {
-      flags |= MB_DEFBUTTON2;
-    } else if (default_id >= 2) {
-      flags |= MB_DEFBUTTON3;
-    }
-
-    const std::wstring window_title = bunite_win::utf8ToWide(title ? title : "");
-    const std::wstring window_message = bunite_win::utf8ToWide(composed_message);
-    HWND owner = nullptr;
-    if (window_id != 0) {
-      auto* window = bunite_win::getWindowHostById(window_id);
-      if (window && window->hwnd && IsWindow(window->hwnd)) {
-        owner = window->hwnd;
-      }
-    }
-
-    // Center the message box on the owner window via CBT hook.
-    static thread_local HWND s_center_on = nullptr;
-    static thread_local HHOOK s_cbt_hook = nullptr;
-    s_center_on = owner;
-    if (owner) {
-      s_cbt_hook = SetWindowsHookExW(WH_CBT, [](int code, WPARAM wp, LPARAM) -> LRESULT {
-        if (code == HCBT_ACTIVATE && s_center_on) {
-          HWND dlg = reinterpret_cast<HWND>(wp);
-          RECT owner_rect{}, dlg_rect{};
-          if (GetWindowRect(s_center_on, &owner_rect) && GetWindowRect(dlg, &dlg_rect)) {
-            int dw = dlg_rect.right - dlg_rect.left;
-            int dh = dlg_rect.bottom - dlg_rect.top;
-            int ow = owner_rect.right - owner_rect.left;
-            int oh = owner_rect.bottom - owner_rect.top;
-            SetWindowPos(dlg, nullptr,
-              owner_rect.left + (ow - dw) / 2,
-              owner_rect.top + (oh - dh) / 2,
-              0, 0, SWP_NOSIZE | SWP_NOZORDER);
-          }
-          s_center_on = nullptr;
-        }
-        return CallNextHookEx(s_cbt_hook, code, wp, 0);
-      }, nullptr, GetCurrentThreadId());
-    }
-
-    const int result = MessageBoxW(owner, window_message.c_str(), window_title.c_str(), flags);
-
-    if (s_cbt_hook) {
-      UnhookWindowsHookEx(s_cbt_hook);
-      s_cbt_hook = nullptr;
-    }
-
-    switch (result) {
-      case IDOK:
-      case IDYES:
-        return 0;
-      case IDNO:
-        return 1;
-      case IDCANCEL:
-        return cancel_id >= 0 ? cancel_id : (labels.size() > 2 ? 2 : 1);
-      default:
-        return cancel_id >= 0 ? cancel_id : -1;
-    }
-  });
-}

package/src/native/win/native_host_internal.h

@@ -2,6 +2,7 @@
 
 #include "../shared/ffi_exports.h"
 #include "../shared/log.h"
+#include "../shared/permissions.h"
 #include "../shared/webview_storage.h"
 
 #include <windows.h>
@@ -185,10 +186,11 @@ void uiThreadMain();                                        // [spawned thread]
 
 std::wstring utf8ToWide(const std::string& value);
 std::string escapeJsonString(const std::string& value);
-std::vector<std::string> splitButtonLabels(const std::string& buttons_csv);
-std::string trimAsciiWhitespace(const std::string& value);
-std::string toLowerAscii(std::string value);
 bool globMatchCaseInsensitive(const std::string& pattern, const std::string& value);
+
+// CEF emits permission bits via two disjoint enums per delegate — two mappers. Unknown bits drop (kind=0 → JS denies).
+uint32_t cefPermissionsToBuniteKind(uint32_t cef_bits);  // cef_permission_request_types_t (OnShowPermissionPrompt)
+uint32_t cefMediaAccessToBuniteKind(uint32_t cef_bits);  // cef_media_access_permission_types_t (OnRequestMediaAccessPermission)
 std::vector<std::string> parseNavigationRulesJson(const std::string& rules_json);
 std::map<std::string, std::string> parseChromiumFlagsJson(const std::string& json);
 bool shouldAlwaysAllowNavigationUrl(const std::string& url);

package/src/native/win/native_host_runtime.cpp

@@ -216,12 +216,8 @@ void uiThreadMain() {
         reinterpret_cast<LONG_PTR>(messageWindowProc)
       );
 
-      // Consume a hostile STARTUPINFO.wShowWindow override.
-      // When launched via `bun run`, the child receives STARTF_USESHOWWINDOW
-      // with wShowWindow=SW_HIDE, which overrides the nCmdShow parameter of
-      // the first ShowWindow call in the process.  We only consume the
-      // override when it would hide windows; legitimate values like
-      // SW_SHOWMAXIMIZED are left for the first real window to honour.
+      // `bun run` passes STARTF_USESHOWWINDOW + SW_HIDE which overrides nCmdShow on the first ShowWindow.
+      // Consume only when it would hide; legitimate values (SW_SHOWMAXIMIZED) pass through.
       {
         STARTUPINFOW si{};
         si.cb = sizeof(si);