bunite-core 0.14.0 → 0.16.0

package/src/native/linux/bunite_linux_view.cpp

@@ -10,6 +10,10 @@ namespace {
 
 constexpr const char* kViewIdKey = "bunite-view-id";
 
+// Forward decls — on_create references these to wire popup-minted views.
+gboolean on_decide_policy(WebKitWebView*, WebKitPolicyDecision*, WebKitPolicyDecisionType, gpointer);
+void on_title_changed(GObject*, GParamSpec*, gpointer);
+
 void emit_url(uint32_t view_id, const char* name, WebKitWebView* wv) {
   const char* uri = webkit_web_view_get_uri(wv);
   emitWebviewEvent(view_id, name, uri ? std::string(uri) : std::string{});
@@ -84,13 +88,49 @@ gboolean on_script_dialog(WebKitWebView* /*wv*/, WebKitScriptDialog* dialog, gpo
 }
 
 GtkWidget* on_create(WebKitWebView* wv, WebKitNavigationAction* action, gpointer user_data) {
-  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  const uint32_t opener_view_id = GPOINTER_TO_UINT(user_data);
   WebKitURIRequest* req = webkit_navigation_action_get_request(action);
   const char* uri = webkit_uri_request_get_uri(req);
-  std::string payload = "{\"url\":\"" + escapeJsonString(uri ? uri : "") + "\"}";
-  emitWebviewEvent(view_id, "new-window-open", payload);
-  (void)wv;
-  return nullptr;  // cancel; JS opens via load_url if desired
+  if (g_runtime.popup_blocking) {
+    std::string payload = "{\"url\":\"" + escapeJsonString(uri ? uri : "") + "\"}";
+    emitWebviewEvent(opener_view_id, "new-window-open", payload);
+    return nullptr;
+  }
+  static std::atomic<uint32_t> g_popup_seq{0x80000000u};
+  const uint32_t new_view_id = g_popup_seq.fetch_add(1);
+  // Share network-session + user-content-manager so cookies/preload-injection
+  // carry across the opener boundary.
+  WebKitWebView* popup = WEBKIT_WEB_VIEW(g_object_new(
+      WEBKIT_TYPE_WEB_VIEW,
+      "network-session", webkit_web_view_get_network_session(wv),
+      "user-content-manager", webkit_web_view_get_user_content_manager(wv),
+      nullptr));
+  g_object_ref_sink(popup);
+  g_object_set_data(G_OBJECT(popup), kViewIdKey, GUINT_TO_POINTER(new_view_id));
+  g_signal_connect(popup, "load-changed", G_CALLBACK(on_load_changed), GUINT_TO_POINTER(new_view_id));
+  g_signal_connect(popup, "load-failed", G_CALLBACK(on_load_failed), GUINT_TO_POINTER(new_view_id));
+  g_signal_connect(popup, "load-failed-with-tls-errors", G_CALLBACK(on_load_failed_tls), GUINT_TO_POINTER(new_view_id));
+  g_signal_connect(popup, "decide-policy", G_CALLBACK(on_decide_policy), GUINT_TO_POINTER(new_view_id));
+  g_signal_connect(popup, "create", G_CALLBACK(on_create), GUINT_TO_POINTER(new_view_id));
+  g_signal_connect(popup, "notify::title", G_CALLBACK(on_title_changed), GUINT_TO_POINTER(new_view_id));
+  g_signal_connect(popup, "script-dialog", G_CALLBACK(on_script_dialog), GUINT_TO_POINTER(new_view_id));
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    g_runtime.parked_popups[new_view_id] = popup;
+    auto& st = g_runtime.views[new_view_id];
+    st.webview = popup;
+    st.window_id = 0;  // bound on adoption
+    st.container = GTK_WIDGET(popup);
+  }
+  if (g_runtime.popup_parent) {
+    GtkWidget* box = gtk_window_get_child(g_runtime.popup_parent);
+    if (box) gtk_box_append(GTK_BOX(box), GTK_WIDGET(popup));
+  }
+  std::string payload = "{\"newSurfaceId\":" + std::to_string(new_view_id) +
+                        ",\"url\":\"" + escapeJsonString(uri ? uri : "") +
+                        "\",\"disposition\":\"popup\"}";
+  emitWebviewEvent(opener_view_id, "popup-requested", payload);
+  return GTK_WIDGET(popup);
 }
 
 void on_title_changed(GObject* source, GParamSpec* /*pspec*/, gpointer user_data) {
@@ -120,8 +160,126 @@ gboolean on_decide_policy(WebKitWebView* wv, WebKitPolicyDecision* decision,
   return TRUE;
 }
 
+constexpr const char* kDownloadIdKey = "bunite-download-id";
+std::atomic<uint64_t> g_download_seq{1};
+
+uint32_t viewIdForDownload(WebKitDownload* download) {
+  WebKitWebView* wv = webkit_download_get_web_view(download);
+  if (!wv) return 0;
+  return GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(wv), kViewIdKey));
+}
+
+void on_received_data(WebKitDownload* download, guint64 /*data_length*/, gpointer /*user_data*/) {
+  const uint32_t view_id = viewIdForDownload(download);
+  if (!view_id) return;
+  const uint64_t id = GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(download), kDownloadIdKey));
+  const guint64 received = webkit_download_get_received_data_length(download);
+  WebKitURIResponse* resp = webkit_download_get_response(download);
+  const guint64 total = resp ? webkit_uri_response_get_content_length(resp) : 0;
+  std::string payload = "{\"kind\":\"progress\",\"id\":\"linux-" + std::to_string(id) +
+                        "\",\"receivedBytes\":" + std::to_string(received);
+  if (total > 0) payload += ",\"totalBytes\":" + std::to_string(total);
+  payload += "}";
+  emitWebviewEvent(view_id, "download-event", payload);
+}
+
+void on_download_finished(WebKitDownload* download, gpointer /*user_data*/) {
+  const uint32_t view_id = viewIdForDownload(download);
+  if (!view_id) return;
+  const uint64_t id = GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(download), kDownloadIdKey));
+  const char* dest_uri = webkit_download_get_destination(download);
+  std::string dest = dest_uri ? dest_uri : "";
+  if (dest.rfind("file://", 0) == 0) dest = dest.substr(7);
+  std::string payload = "{\"kind\":\"completed\",\"id\":\"linux-" + std::to_string(id) +
+                        "\",\"localPath\":\"" + escapeJsonString(dest) + "\"}";
+  emitWebviewEvent(view_id, "download-event", payload);
+}
+
+void on_download_failed(WebKitDownload* download, GError* error, gpointer /*user_data*/) {
+  const uint32_t view_id = viewIdForDownload(download);
+  if (!view_id) return;
+  const uint64_t id = GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(download), kDownloadIdKey));
+  std::string reason = error && error->message ? error->message : "unknown";
+  std::string payload = "{\"kind\":\"failed\",\"id\":\"linux-" + std::to_string(id) +
+                        "\",\"reason\":\"" + escapeJsonString(reason) + "\"}";
+  emitWebviewEvent(view_id, "download-event", payload);
+}
+
+// `decide-destination` is the gate: emits `started` / `blocked` and sets path.
+// Returning TRUE tells WebKit we resolved (or cancelled) destination.
+gboolean on_decide_destination(WebKitDownload* download, const gchar* suggested, gpointer /*user_data*/) {
+  const uint32_t view_id = viewIdForDownload(download);
+  if (!view_id) return FALSE;
+  ViewState* st = nullptr;
+  {
+    std::lock_guard<std::mutex> lk(g_runtime.object_mutex);
+    auto it = g_runtime.views.find(view_id);
+    if (it != g_runtime.views.end()) st = &it->second;
+  }
+  if (!st) return FALSE;
+  const uint64_t id = GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(download), kDownloadIdKey));
+  WebKitURIRequest* req = webkit_download_get_request(download);
+  const std::string url = (req && webkit_uri_request_get_uri(req)) ? webkit_uri_request_get_uri(req) : "";
+
+  const int32_t policy = st->download_policy.load();
+  if (policy != 0) {
+    const char* reason = (policy == 1) ? "ask-not-implemented" : "host-policy";
+    std::string payload = "{\"kind\":\"blocked\",\"id\":\"linux-" + std::to_string(id) +
+                          "\",\"url\":\"" + escapeJsonString(url) +
+                          "\",\"reason\":\"" + reason + "\"}";
+    emitWebviewEvent(view_id, "download-event", payload);
+    webkit_download_cancel(download);
+    return TRUE;
+  }
+
+  const std::string sug = suggested ? suggested : "download";
+  WebKitURIResponse* resp = webkit_download_get_response(download);
+  const std::string mime = (resp && webkit_uri_response_get_mime_type(resp)) ? webkit_uri_response_get_mime_type(resp) : "";
+  const guint64 total = resp ? webkit_uri_response_get_content_length(resp) : 0;
+  std::string started = "{\"kind\":\"started\",\"id\":\"linux-" + std::to_string(id) +
+                        "\",\"url\":\"" + escapeJsonString(url) +
+                        "\",\"suggestedFilename\":\"" + escapeJsonString(sug) +
+                        "\",\"mimeType\":\"" + escapeJsonString(mime) + "\"";
+  if (total > 0) started += ",\"sizeBytes\":" + std::to_string(total);
+  started += "}";
+  emitWebviewEvent(view_id, "download-event", started);
+
+  std::string dir = st->download_dir;
+  if (dir.empty()) {
+    const char* d = g_get_user_special_dir(G_USER_DIRECTORY_DOWNLOAD);
+    dir = d ? d : "/tmp";
+  }
+  std::string path = dir + "/" + sug;
+  std::string uri = "file://" + path;
+  webkit_download_set_destination(download, uri.c_str());
+  return TRUE;
+}
+
+void on_download_started(WebKitNetworkSession* /*session*/, WebKitDownload* download, gpointer /*user_data*/) {
+  const uint32_t view_id = viewIdForDownload(download);
+  if (!view_id) {
+    webkit_download_cancel(download);
+    return;
+  }
+  const uint64_t id = g_download_seq.fetch_add(1);
+  g_object_set_data(G_OBJECT(download), kDownloadIdKey, GSIZE_TO_POINTER(id));
+  g_signal_connect(download, "decide-destination", G_CALLBACK(on_decide_destination), nullptr);
+  g_signal_connect(download, "received-data", G_CALLBACK(on_received_data), nullptr);
+  g_signal_connect(download, "finished", G_CALLBACK(on_download_finished), nullptr);
+  g_signal_connect(download, "failed", G_CALLBACK(on_download_failed), nullptr);
+}
+
 }  // namespace
 
+void wireDownloadHandlers() {
+  static bool wired = false;
+  if (wired) return;
+  WebKitNetworkSession* session = webkit_network_session_get_default();
+  if (!session) return;
+  g_signal_connect(session, "download-started", G_CALLBACK(on_download_started), nullptr);
+  wired = true;
+}
+
 ViewState* findView(uint32_t view_id) {
   std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
   auto it = g_runtime.views.find(view_id);
@@ -167,6 +325,8 @@ bool createView(uint32_t view_id, uint32_t window_id,
     return false;
   }
 
+  wireDownloadHandlers();
+
   WebKitUserContentManager* ucm = webkit_user_content_manager_new();
 
   // Origin-gate the preload so http(s) navigations don't inherit the RPC bridge.
@@ -291,6 +451,52 @@ void applyViewBounds(uint32_t view_id, double x, double y, double w, double h) {
   queueViewRedraw(v->webview);
 }
 
+bool acceptParkedPopup(uint32_t new_view_id, uint32_t host_window_id, double x, double y, double w, double h) {
+  WebKitWebView* popup = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto it = g_runtime.parked_popups.find(new_view_id);
+    if (it == g_runtime.parked_popups.end()) return false;
+    popup = it->second;
+    g_runtime.parked_popups.erase(it);
+  }
+  auto* host = findWindow(host_window_id);
+  if (!host || !host->host) return false;
+  gtk_widget_unparent(GTK_WIDGET(popup));
+  GtkWidget* container = gtk_fixed_new();
+  gtk_widget_set_halign(container, GTK_ALIGN_START);
+  gtk_widget_set_valign(container, GTK_ALIGN_START);
+  gtk_widget_set_overflow(container, GTK_OVERFLOW_HIDDEN);
+  gtk_fixed_put(GTK_FIXED(container), GTK_WIDGET(popup), 0, 0);
+  gtk_overlay_add_overlay(host->host, container);
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto& st = g_runtime.views[new_view_id];
+    st.window_id = host_window_id;
+    st.container = container;
+    st.webview = popup;
+  }
+  applyViewBounds(new_view_id, x, y, w, h);
+  // Re-emit view-ready so TS BrowserView.adopt resolves its waiter — the
+  // initial `did-navigate` fired before the adopter registered.
+  emitWebviewEvent(new_view_id, "view-ready", std::string{});
+  return true;
+}
+
+void dismissParkedPopup(uint32_t new_view_id) {
+  WebKitWebView* popup = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto it = g_runtime.parked_popups.find(new_view_id);
+    if (it == g_runtime.parked_popups.end()) return;
+    popup = it->second;
+    g_runtime.parked_popups.erase(it);
+    g_runtime.views.erase(new_view_id);
+  }
+  gtk_widget_unparent(GTK_WIDGET(popup));
+  g_object_unref(popup);
+}
+
 void detachViewSideState(uint32_t view_id) {
   bunite::WebviewContentStorage::instance().remove(view_id);
   std::vector<uint32_t> request_ids;

package/src/native/mac/bunite_mac_ffi.mm

@@ -20,7 +20,7 @@ using bunite_mac::runOnUiThreadSync;
 
 namespace {
 
-constexpr int32_t kBuniteAbiVersion = 9;
+constexpr int32_t kBuniteAbiVersion = 11;
 
 // warn-once — avoid log spam from tight JS call loops.
 #define BUNITE_MAC_TODO(name)                                       \
@@ -513,8 +513,9 @@ extern "C" BUNITE_EXPORT void bunite_view_remove(uint32_t view_id) {
   runOnUiThreadSync([=]() { bunite_mac::removeView(view_id); });
 }
 
-// Input dispatch — synthesized NSEvent + window sendEvent: (full responder chain).
-// `isTrusted` is false (synthetic), so `nativeInputTrusted` capability stays false.
+// Input dispatch — synthesized NSEvent directly to the WKWebView (not via
+// `[NSApp sendEvent:]` — see ctrl-strip note in `bunite_view_click`). WebKit
+// marks these events `isTrusted=true` on the page; capabilities flag matches.
 namespace {
 
 NSEventModifierFlags macModifiers(uint32_t bits) {
@@ -743,7 +744,280 @@ extern "C" BUNITE_EXPORT uint32_t bunite_view_capabilities(uint32_t view_id) {
          BUNITE_CAP_NATIVE_INPUT_TRUSTED |
          BUNITE_CAP_CLICK | BUNITE_CAP_TYPE | BUNITE_CAP_PRESS | BUNITE_CAP_SCROLL |
          BUNITE_CAP_MOUSE | BUNITE_CAP_DIALOGS | BUNITE_CAP_CONSOLE |
-         BUNITE_CAP_SCREENSHOT | BUNITE_CAP_FORMAT_PNG | BUNITE_CAP_FORMAT_JPEG;
+         BUNITE_CAP_SCREENSHOT | BUNITE_CAP_FORMAT_PNG | BUNITE_CAP_FORMAT_JPEG |
+         BUNITE_CAP_BOUNDING_RECT |
+         BUNITE_CAP_RESOLVE_AND_CLICK | BUNITE_CAP_DOWNLOADS | BUNITE_CAP_POPUPS |
+         BUNITE_CAP_AX | BUNITE_CAP_FRAMES;
+}
+
+namespace {
+
+// JS-bridge ax tree (mirrors linux backend) — WKWebView has no public host-side
+// ax API. Walks DOM + ARIA attrs, emits CDP-shaped flat list so TS-side
+// convertAxTree works unchanged. `ignored` always false (interestingOnly no-op).
+NSString* const kAxScript = @"(function(){"
+  "var nodes=[];"
+  "function add(el,parentId){"
+  "if(!el||el.nodeType!==1)return null;"
+  "var id=String(nodes.length+1);"
+  "var node={nodeId:id,parentId:parentId,"
+  "role:{value:el.getAttribute('role')||el.tagName.toLowerCase()},"
+  "name:{value:el.getAttribute('aria-label')||"
+  "(el.tagName==='INPUT'||el.tagName==='TEXTAREA'?'':"
+  "(el.firstChild&&el.firstChild.nodeType===3?el.firstChild.textContent.trim().slice(0,100):''))},"
+  "properties:[],childIds:[],ignored:false};"
+  "var d=el.getAttribute('aria-description');if(d)node.description={value:d};"
+  "if(el.tagName==='INPUT'||el.tagName==='TEXTAREA'){if(el.value)node.value={value:el.value};}"
+  "if(el.getAttribute('aria-disabled')==='true'||el.disabled)node.properties.push({name:'disabled',value:{value:true}});"
+  "var ck=el.getAttribute('aria-checked');"
+  "if(ck==='true')node.properties.push({name:'checked',value:{value:true}});"
+  "else if(ck==='false')node.properties.push({name:'checked',value:{value:false}});"
+  "else if(ck==='mixed')node.properties.push({name:'checked',value:{value:'mixed'}});"
+  "var pr=el.getAttribute('aria-pressed');"
+  "if(pr==='true')node.properties.push({name:'pressed',value:{value:true}});"
+  "else if(pr==='false')node.properties.push({name:'pressed',value:{value:false}});"
+  "else if(pr==='mixed')node.properties.push({name:'pressed',value:{value:'mixed'}});"
+  "if(el.getAttribute('aria-expanded')==='true')node.properties.push({name:'expanded',value:{value:true}});"
+  "if(el.getAttribute('aria-selected')==='true')node.properties.push({name:'selected',value:{value:true}});"
+  "if(el.getAttribute('aria-required')==='true')node.properties.push({name:'required',value:{value:true}});"
+  "if(el.getAttribute('aria-invalid')==='true')node.properties.push({name:'invalid',value:{value:true}});"
+  "var lv=el.getAttribute('aria-level');if(lv)node.properties.push({name:'level',value:{value:parseInt(lv,10)}});"
+  "if(document.activeElement===el)node.properties.push({name:'focused',value:{value:true}});"
+  "nodes.push(node);"
+  "for(var i=0;i<el.children.length;i++){var cid=add(el.children[i],id);if(cid)node.childIds.push(cid);}"
+  "return id;"
+  "}"
+  "add(document.documentElement,null);"
+  "return JSON.stringify({nodes:nodes});"
+  "})()";
+
+// JS-bridge frame tree — walks window.frames into CDP `Page.getFrameTree` shape.
+NSString* const kFramesScript = @"(function(){"
+  "var id=0;"
+  "function walk(win){"
+  "var fid=String(++id);"
+  "var frame={id:fid,securityOrigin:'',url:''};"
+  "try{frame.url=win.location.href;frame.securityOrigin=win.location.origin;"
+  "if(win.frameElement&&win.frameElement.name)frame.name=win.frameElement.name;}catch(e){}"
+  "var children=[];"
+  "try{for(var i=0;i<win.frames.length;i++)children.push(walk(win.frames[i]));}catch(e){}"
+  "return {frame:frame,childFrames:children};"
+  "}"
+  "return JSON.stringify({frameTree:walk(window)});"
+  "})()";
+
+}  // namespace
+
+extern "C" BUNITE_EXPORT void bunite_view_accessibility_snapshot(uint32_t view_id, uint32_t request_id,
+                                                                  int32_t /*interesting_only*/) {
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_mac::findView(view_id);
+    if (!v || !v->webview) {
+      std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                            ",\"ok\":false,\"code\":\"not_supported\","
+                            "\"message\":\"view not ready\"}";
+      bunite_mac::emitWebviewEvent(view_id, "accessibility-result", payload);
+      return;
+    }
+    [v->webview evaluateJavaScript:kAxScript completionHandler:^(id result, NSError* error) {
+      std::string payload = "{\"requestId\":" + std::to_string(request_id);
+      if (error || ![result isKindOfClass:[NSString class]]) {
+        std::string msg = error ? std::string(error.localizedDescription.UTF8String ?: "evaluate failed")
+                                : std::string("non-string ax result");
+        payload += ",\"ok\":false,\"code\":\"runtime_error\","
+                   "\"message\":\"" + bunite_mac::escapeJsonString(msg) + "\"}";
+      } else {
+        std::string tree_json = ((NSString*)result).UTF8String ?: "{}";
+        payload += ",\"ok\":true,\"tree\":" + tree_json + "}";
+      }
+      bunite_mac::emitWebviewEvent(view_id, "accessibility-result", payload);
+    }];
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_list_frames(uint32_t view_id, uint32_t request_id) {
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_mac::findView(view_id);
+    if (!v || !v->webview) {
+      std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                            ",\"ok\":false,\"code\":\"not_supported\","
+                            "\"message\":\"view not ready\"}";
+      bunite_mac::emitWebviewEvent(view_id, "list-frames-result", payload);
+      return;
+    }
+    [v->webview evaluateJavaScript:kFramesScript completionHandler:^(id result, NSError* error) {
+      std::string payload = "{\"requestId\":" + std::to_string(request_id);
+      if (error || ![result isKindOfClass:[NSString class]]) {
+        std::string msg = error ? std::string(error.localizedDescription.UTF8String ?: "evaluate failed")
+                                : std::string("non-string frames result");
+        payload += ",\"ok\":false,\"code\":\"runtime_error\","
+                   "\"message\":\"" + bunite_mac::escapeJsonString(msg) + "\"}";
+      } else {
+        std::string tree_json = ((NSString*)result).UTF8String ?: "{}";
+        payload += ",\"ok\":true,\"raw\":" + tree_json + "}";
+      }
+      bunite_mac::emitWebviewEvent(view_id, "list-frames-result", payload);
+    }];
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_evaluate_in_frame(uint32_t view_id, uint32_t request_id,
+                                                              const char* script_c, const char* frame_id_c) {
+  std::string script = script_c ? script_c : "";
+  std::string frame_id = frame_id_c ? frame_id_c : "";
+  if (frame_id.empty()) {
+    bunite_view_evaluate(view_id, request_id, script_c);
+    return;
+  }
+  std::string js_target = bunite_mac::escapeJsonString(frame_id);
+  std::string js_script = bunite_mac::escapeJsonString(script);
+  std::string inner =
+    "(function(){var target=\"" + js_target + "\";var id=0;var found=null;"
+    "function walk(win){var fid=String(++id);if(fid===target){found=win;return;}"
+    "try{for(var i=0;i<win.frames.length;i++){walk(win.frames[i]);if(found)return;}}catch(e){}}"
+    "walk(window);"
+    "if(!found)throw new Error('frame not found');"
+    "return found.eval(\"(\"+\"" + js_script + "\"+\")\");"
+    "})()";
+  bunite_view_evaluate(view_id, request_id, inner.c_str());
+}
+
+namespace {
+
+void emitResolveAndClickErrorMac(uint32_t view_id, uint32_t request_id, const char* code, const std::string& msg) {
+  std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                        ",\"ok\":false,\"code\":\"" + code + "\","
+                        "\"message\":\"" + bunite_mac::escapeJsonString(msg) + "\"}";
+  bunite_mac::emitWebviewEvent(view_id, "resolve-and-click-result", payload);
+}
+
+std::string escapeForJsStringMac(const std::string& s) {
+  std::string out; out.reserve(s.size() + 2);
+  for (char c : s) {
+    if (c == '"' || c == '\\') { out.push_back('\\'); out.push_back(c); }
+    else if (c == '\n') out += "\\n";
+    else if (c == '\r') out += "\\r";
+    else if (c == '\t') out += "\\t";
+    else out.push_back(c);
+  }
+  return out;
+}
+
+}  // namespace
+
+extern "C" BUNITE_EXPORT void bunite_view_resolve_and_click(
+    uint32_t view_id, uint32_t request_id,
+    const char* selector_c, const char* frame_id_c,
+    int32_t button, int32_t click_count, uint32_t modifiers) {
+  std::string selector = selector_c ? selector_c : "";
+  std::string frameId = frame_id_c ? frame_id_c : "";
+  if (!frameId.empty()) {
+    // No frame addressing on WKWebView — sync reject before UI hop.
+    emitResolveAndClickErrorMac(view_id, request_id, "not_supported",
+                                "WKWebView has no frame addressing API");
+    return;
+  }
+  if (click_count < 1) click_count = 1;
+  std::string sel_lit = "\"" + escapeForJsStringMac(selector) + "\"";
+  std::string script =
+    "(function(){"
+      "var el=document.querySelector(" + sel_lit + ");"
+      "if(!el)return{ok:false,code:\"not_found\"};"
+      "el.scrollIntoView({block:\"nearest\",inline:\"nearest\",behavior:\"instant\"});"
+      "var r=el.getBoundingClientRect();"
+      "var vis=r.width>0&&r.height>0&&r.bottom>0&&r.right>0"
+      "&&r.top<innerHeight&&r.left<innerWidth;"
+      "if(!vis)return{ok:false,code:\"not_visible\"};"
+      "return{ok:true,x:r.x,y:r.y,w:r.width,h:r.height,"
+      "cx:r.x+r.width/2,cy:r.y+r.height/2};"
+    "})()";
+  NSString* nsScript = [NSString stringWithUTF8String:script.c_str()];
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_mac::findView(view_id);
+    if (!v || !v->webview || !v->webview.window) {
+      emitResolveAndClickErrorMac(view_id, request_id, "runtime_error", "view not ready");
+      return;
+    }
+    [v->webview evaluateJavaScript:nsScript completionHandler:^(id result, NSError* error) {
+      if (error || ![result isKindOfClass:[NSDictionary class]]) {
+        std::string msg = error ? std::string(error.localizedDescription.UTF8String ?: "evaluate failed")
+                                : std::string("evaluate returned non-object");
+        emitResolveAndClickErrorMac(view_id, request_id, "runtime_error", msg);
+        return;
+      }
+      NSDictionary* d = (NSDictionary*)result;
+      id okVal = d[@"ok"];
+      const bool ok = [okVal respondsToSelector:@selector(boolValue)] && [okVal boolValue];
+      if (!ok) {
+        id codeVal = d[@"code"];
+        std::string code = [codeVal isKindOfClass:[NSString class]]
+                             ? std::string([(NSString*)codeVal UTF8String] ?: "runtime_error")
+                             : std::string("runtime_error");
+        emitResolveAndClickErrorMac(view_id, request_id, code.c_str(), "");
+        return;
+      }
+      auto pickD = [&](NSString* k)->double {
+        id x = d[k];
+        return [x respondsToSelector:@selector(doubleValue)] ? [x doubleValue] : 0.0;
+      };
+      double x = pickD(@"x"), y = pickD(@"y"), w = pickD(@"w"), h = pickD(@"h");
+      double cx = pickD(@"cx"), cy = pickD(@"cy");
+      auto* v2 = bunite_mac::findView(view_id);
+      if (!v2 || !v2->webview || !v2->webview.window) {
+        emitResolveAndClickErrorMac(view_id, request_id, "runtime_error", "view destroyed");
+        return;
+      }
+      NSWindow* win = v2->webview.window;
+      NSPoint loc = viewPointToWindow(v2->webview, cx, cy);
+      NSEventModifierFlags flags = macModifiers(modifiers) & ~NSEventModifierFlagControl;
+      for (int i = 1; i <= click_count; ++i) {
+        NSEvent* down = [NSEvent mouseEventWithType:macMouseDownType(button)
+                                           location:loc modifierFlags:flags
+                                          timestamp:[[NSProcessInfo processInfo] systemUptime]
+                                       windowNumber:win.windowNumber context:nil
+                                        eventNumber:0 clickCount:i pressure:1.0];
+        NSEvent* up = [NSEvent mouseEventWithType:macMouseUpType(button)
+                                         location:loc modifierFlags:flags
+                                        timestamp:[[NSProcessInfo processInfo] systemUptime]
+                                     windowNumber:win.windowNumber context:nil
+                                      eventNumber:0 clickCount:i pressure:0.0];
+        if (down) {
+          if (button == 0)      [v2->webview mouseDown:down];
+          else if (button == 2) [v2->webview rightMouseDown:down];
+          else                  [v2->webview otherMouseDown:down];
+        }
+        if (up) {
+          if (button == 0)      [v2->webview mouseUp:up];
+          else if (button == 2) [v2->webview rightMouseUp:up];
+          else                  [v2->webview otherMouseUp:up];
+        }
+      }
+      std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                            ",\"ok\":true,\"rect\":{\"x\":" + std::to_string(x) +
+                            ",\"y\":" + std::to_string(y) +
+                            ",\"width\":" + std::to_string(w) +
+                            ",\"height\":" + std::to_string(h) + "},"
+                            "\"isTrustedEvent\":true}";
+      bunite_mac::emitWebviewEvent(view_id, "resolve-and-click-result", payload);
+    }];
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_download_policy(uint32_t view_id, int32_t policy, const char* download_dir) {
+  auto* st = bunite_mac::findView(view_id);
+  if (!st) return;
+  if (policy < 0 || policy > 2) policy = 2;
+  st->download_policy.store(policy);
+  st->download_dir = download_dir ? download_dir : "";
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_popup_accept(uint32_t new_view_id, uint32_t host_window_id,
+                                                       double x, double y, double w, double h) {
+  runOnUiThreadSync([=]() { bunite_mac::acceptParkedPopup(new_view_id, host_window_id, x, y, w, h); });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_popup_dismiss(uint32_t new_view_id) {
+  runOnUiThreadSync([=]() { bunite_mac::dismissParkedPopup(new_view_id); });
 }
 
 extern "C" BUNITE_EXPORT void bunite_view_screenshot(uint32_t view_id, uint32_t request_id,

package/src/native/mac/bunite_mac_internal.h

@@ -67,6 +67,10 @@ struct ViewState {
   // respondToDialog invokes them; the page execution is paused meanwhile.
   std::unordered_map<uint32_t, void(^)(bool /*accept*/, const std::string& /*text*/)> pending_dialogs;
   uint32_t next_dialog_request_id = 1;
+
+  // Download policy: 0=auto, 1=ask (treated as block), 2=block (default).
+  std::atomic<int32_t> download_policy{2};
+  std::string download_dir;
 };
 
 // ---------------------------------------------------------------------------
@@ -92,6 +96,11 @@ struct RuntimeState {
 
   BuniteWebviewEventHandler webview_event_handler = nullptr;
   BuniteWindowEventHandler window_event_handler = nullptr;
+
+  // Hidden NSWindow — popup-minted WKWebViews park here until adoption.
+  __strong NSWindow* popup_parent = nil;
+  // Parked popup webviews awaiting acceptPopup/dismissPopup. Key = popup view_id (>= 0x80000000).
+  __strong NSMutableDictionary<NSNumber*, WKWebView*>* parked_popups = nil;
 };
 
 extern RuntimeState g_runtime;
@@ -139,6 +148,10 @@ void destroyWindow(uint32_t window_id);
 // Defined in bunite_mac_view.mm.
 ViewState* findView(uint32_t view_id);
 uint32_t viewIdForWebView(WKWebView* wv);  // returns 0 if not tracked
+void registerWebViewId(WKWebView* wv, uint32_t view_id);
+void unregisterWebViewId(WKWebView* wv);
+bool acceptParkedPopup(uint32_t new_view_id, uint32_t host_window_id, double x, double y, double w, double h);
+void dismissParkedPopup(uint32_t new_view_id);
 bool createView(uint32_t view_id, uint32_t window_id,
                 NSString* url, NSString* html, NSString* preload, NSString* appres_root,
                 NSString* navigation_rules_json, NSString* preload_origins_json,