bunite-core 0.12.1 → 0.16.0

package/src/native/mac/bunite_mac_internal.h

@@ -61,6 +61,16 @@ struct ViewState {
   // HTML stashed by load_html; appres handler serves at internal/index.html.
   std::string stored_html;
   std::vector<std::string> navigation_rules;
+
+  // Page-initiated dialogs awaiting host response (alert/confirm/prompt).
+  // WKUIDelegate completion handlers are held in `__strong` blocks until
+  // 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;
 };
 
 // ---------------------------------------------------------------------------
@@ -86,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;
@@ -133,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,

package/src/native/mac/bunite_mac_utils.mm

@@ -100,8 +100,8 @@ std::vector<std::string> parseNavigationRulesJson(NSString* json) {
 }
 
 bool shouldAlwaysAllowNavigationUrl(const std::string& url) {
-  return url == "about:blank" ||
-         url.rfind("appres://app.internal/internal/", 0) == 0;
+  // Exact-match — prefix would let `../../evil` style paths bypass scrutiny.
+  return url == "about:blank" || url == "appres://app.internal/internal/index.html";
 }
 
 bool shouldAllowNavigation(const ViewState* view, const std::string& url) {

package/src/native/mac/bunite_mac_view.mm

@@ -3,6 +3,7 @@
 #import "bunite_mac_internal.h"
 
 #include "webview_storage.h"
+#include <objc/runtime.h>
 
 @implementation BunitePendingPermission
 @end
@@ -27,6 +28,125 @@
 using bunite_mac::g_runtime;
 using bunite_mac::utf8ToNSString;
 
+// WKDownload delegate — decideDestination gates host policy + emits
+// started/blocked, KVO on download.progress emits progress, didFinish/didFail
+// emit terminal events.
+@interface BuniteDownloadDelegate : NSObject <WKDownloadDelegate>
+@property (nonatomic) uint32_t viewId;
+@property (nonatomic) uint64_t downloadId;
+@property (nonatomic, strong) NSString* destinationPath;
+@property (nonatomic, weak) NSProgress* observedProgress;
+@property (nonatomic) int64_t lastReportedBytes;
+@property (atomic) BOOL terminalReached;
+@end
+
+static char kBuniteProgressCtx;
+
+@implementation BuniteDownloadDelegate
+
+- (void)download:(WKDownload*)download
+    decideDestinationUsingResponse:(NSURLResponse*)response
+                 suggestedFilename:(NSString*)suggested
+                 completionHandler:(void (^)(NSURL*))completionHandler
+{
+  auto* st = bunite_mac::findView(self.viewId);
+  if (!st) { completionHandler(nil); return; }
+  const int32_t policy = st->download_policy.load();
+  NSString* url = download.originalRequest.URL.absoluteString ?: @"";
+  std::string url_s = url.UTF8String ?: "";
+  if (policy != 0) {
+    const char* reason = (policy == 1) ? "ask-not-implemented" : "host-policy";
+    std::string payload = "{\"kind\":\"blocked\",\"id\":\"mac-" + std::to_string(self.downloadId) +
+                          "\",\"url\":\"" + bunite_mac::escapeJsonString(url_s) +
+                          "\",\"reason\":\"" + reason + "\"}";
+    bunite_mac::emitWebviewEvent(self.viewId, "download-event", payload);
+    completionHandler(nil);
+    return;
+  }
+  NSString* dirStr = st->download_dir.empty() ? nil : [NSString stringWithUTF8String:st->download_dir.c_str()];
+  if (!dirStr || dirStr.length == 0) {
+    NSArray<NSURL*>* paths = [NSFileManager.defaultManager URLsForDirectory:NSDownloadsDirectory inDomains:NSUserDomainMask];
+    dirStr = paths.firstObject.path ?: NSTemporaryDirectory();
+  }
+  NSString* fname = suggested.length > 0 ? suggested : @"download";
+  NSString* path = [dirStr stringByAppendingPathComponent:fname];
+  self.destinationPath = path;
+  std::string mime = (response.MIMEType ?: @"").UTF8String ?: "";
+  long long total = response.expectedContentLength > 0 ? (long long)response.expectedContentLength : 0;
+  std::string started = "{\"kind\":\"started\",\"id\":\"mac-" + std::to_string(self.downloadId) +
+                        "\",\"url\":\"" + bunite_mac::escapeJsonString(url_s) +
+                        "\",\"suggestedFilename\":\"" + bunite_mac::escapeJsonString(fname.UTF8String ?: "") +
+                        "\",\"mimeType\":\"" + bunite_mac::escapeJsonString(mime) + "\"";
+  if (total > 0) started += ",\"sizeBytes\":" + std::to_string(total);
+  started += "}";
+  bunite_mac::emitWebviewEvent(self.viewId, "download-event", started);
+  NSProgress* prog = download.progress;
+  if (prog) {
+    self.observedProgress = prog;
+    self.lastReportedBytes = 0;
+    [prog addObserver:self
+           forKeyPath:@"completedUnitCount"
+              options:NSKeyValueObservingOptionNew
+              context:&kBuniteProgressCtx];
+  }
+  completionHandler([NSURL fileURLWithPath:path]);
+}
+
+- (void)observeValueForKeyPath:(NSString*)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary*)change
+                       context:(void*)context
+{
+  if (context != &kBuniteProgressCtx) {
+    [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+    return;
+  }
+  if (self.terminalReached) return;
+  NSProgress* prog = (NSProgress*)object;
+  int64_t received = prog.completedUnitCount;
+  int64_t total = prog.totalUnitCount;
+  if (received <= self.lastReportedBytes) return;
+  self.lastReportedBytes = received;
+  std::string payload = "{\"kind\":\"progress\",\"id\":\"mac-" + std::to_string(self.downloadId) +
+                        "\",\"receivedBytes\":" + std::to_string(received);
+  if (total > 0) payload += ",\"totalBytes\":" + std::to_string(total);
+  payload += "}";
+  bunite_mac::emitWebviewEvent(self.viewId, "download-event", payload);
+}
+
+- (void)_detachProgressObserver {
+  NSProgress* prog = self.observedProgress;
+  if (!prog) return;
+  @try {
+    [prog removeObserver:self forKeyPath:@"completedUnitCount" context:&kBuniteProgressCtx];
+  } @catch (NSException* ex) {}  // tolerate over-remove on edge lifecycles
+  self.observedProgress = nil;
+}
+
+- (void)downloadDidFinish:(WKDownload*)download {
+  self.terminalReached = YES;
+  [self _detachProgressObserver];
+  std::string dest = self.destinationPath ? std::string(self.destinationPath.UTF8String ?: "") : "";
+  std::string payload = "{\"kind\":\"completed\",\"id\":\"mac-" + std::to_string(self.downloadId) +
+                        "\",\"localPath\":\"" + bunite_mac::escapeJsonString(dest) + "\"}";
+  bunite_mac::emitWebviewEvent(self.viewId, "download-event", payload);
+}
+
+- (void)download:(WKDownload*)download didFailWithError:(NSError*)error resumeData:(NSData*)resumeData {
+  self.terminalReached = YES;
+  [self _detachProgressObserver];
+  std::string reason = error ? std::string(error.localizedDescription.UTF8String ?: "unknown") : "unknown";
+  std::string payload = "{\"kind\":\"failed\",\"id\":\"mac-" + std::to_string(self.downloadId) +
+                        "\",\"reason\":\"" + bunite_mac::escapeJsonString(reason) + "\"}";
+  bunite_mac::emitWebviewEvent(self.viewId, "download-event", payload);
+}
+
+- (void)dealloc {
+  [self _detachProgressObserver];
+}
+
+@end
+
 @interface BuniteNavigationDelegate : NSObject <WKNavigationDelegate>
 @end
 
@@ -49,14 +169,95 @@ decidePolicyForNavigationAction:(WKNavigationAction*)action
   decisionHandler(allow ? WKNavigationActionPolicyAllow : WKNavigationActionPolicyCancel);
 }
 
-- (void)webView:(WKWebView*)wv didFinishNavigation:(WKNavigation*)nav {
+- (void)webView:(WKWebView*)wv didStartProvisionalNavigation:(WKNavigation*)nav {
   (void)nav;
   uint32_t view_id = bunite_mac::viewIdForWebView(wv);
   NSString* url = wv.URL.absoluteString ?: @"";
+  bunite_mac::emitWebviewEvent(view_id, "load-start", url.UTF8String);
+}
+
+- (void)webView:(WKWebView*)wv didCommitNavigation:(WKNavigation*)nav {
+  (void)nav;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  NSString* url = wv.URL.absoluteString ?: @"";
+  // URL commit point — surfaceEvents `navigate` arm. WKWebView fires this
+  // when the document begins loading after server response (post-redirect).
   bunite_mac::emitWebviewEvent(view_id, "did-navigate", url.UTF8String);
+}
+
+- (void)webView:(WKWebView*)wv didFinishNavigation:(WKNavigation*)nav {
+  (void)nav;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  NSString* url = wv.URL.absoluteString ?: @"";
+  bunite_mac::emitWebviewEvent(view_id, "load-finish", url.UTF8String);
   bunite_mac::emitWebviewEvent(view_id, "dom-ready", url.UTF8String);
 }
 
+- (void)webView:(WKWebView*)wv didFailNavigation:(WKNavigation*)nav withError:(NSError*)error {
+  (void)nav;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  NSString* url = wv.URL.absoluteString ?: @"";
+  std::string payload = "{\"url\":\"" + bunite_mac::escapeJsonString(url.UTF8String ?: "") +
+                        "\",\"reason\":\"" + bunite_mac::escapeJsonString(error.localizedDescription.UTF8String ?: "") + "\"}";
+  bunite_mac::emitWebviewEvent(view_id, "load-fail", payload);
+}
+
+- (void)webView:(WKWebView*)wv didFailProvisionalNavigation:(WKNavigation*)nav withError:(NSError*)error {
+  (void)nav;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  NSString* failingUrl = ((NSURL*)error.userInfo[NSURLErrorFailingURLErrorKey]).absoluteString
+                       ?: (wv.URL.absoluteString ?: @"");
+  std::string payload = "{\"url\":\"" + bunite_mac::escapeJsonString(failingUrl.UTF8String ?: "") +
+                        "\",\"reason\":\"" + bunite_mac::escapeJsonString(error.localizedDescription.UTF8String ?: "") + "\"}";
+  bunite_mac::emitWebviewEvent(view_id, "load-fail", payload);
+}
+
+- (void)webView:(WKWebView*)wv navigationAction:(WKNavigationAction*)action didBecomeDownload:(WKDownload*)download {
+  static std::atomic<uint64_t> g_seq{1};
+  BuniteDownloadDelegate* d = [BuniteDownloadDelegate new];
+  d.viewId = bunite_mac::viewIdForWebView(wv);
+  d.downloadId = g_seq.fetch_add(1);
+  download.delegate = d;
+  objc_setAssociatedObject(download, "bunite.dl.delegate", d, OBJC_ASSOCIATION_RETAIN);
+}
+
+- (void)webView:(WKWebView*)wv navigationResponse:(WKNavigationResponse*)response didBecomeDownload:(WKDownload*)download {
+  static std::atomic<uint64_t> g_seq{0x80000000ULL};
+  BuniteDownloadDelegate* d = [BuniteDownloadDelegate new];
+  d.viewId = bunite_mac::viewIdForWebView(wv);
+  d.downloadId = g_seq.fetch_add(1);
+  download.delegate = d;
+  objc_setAssociatedObject(download, "bunite.dl.delegate", d, OBJC_ASSOCIATION_RETAIN);
+}
+
+@end
+
+@interface BuniteTitleObserver : NSObject
++ (instancetype)shared;
+@end
+
+@implementation BuniteTitleObserver
++ (instancetype)shared {
+  static BuniteTitleObserver* o = nil;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{ o = [[BuniteTitleObserver alloc] init]; });
+  return o;
+}
+- (void)observeValueForKeyPath:(NSString*)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary<NSKeyValueChangeKey, id>*)change
+                       context:(void*)context
+{
+  (void)change; (void)context;
+  if (![keyPath isEqualToString:@"title"]) return;
+  WKWebView* wv = (WKWebView*)object;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  if (!view_id) return;
+  NSString* title = wv.title ?: @"";
+  std::string payload = "{\"title\":\"" +
+    bunite_mac::escapeJsonString(title.UTF8String ?: "") + "\"}";
+  bunite_mac::emitWebviewEvent(view_id, "title-changed", payload);
+}
 @end
 
 @interface BuniteUIDelegate : NSObject <WKUIDelegate>
@@ -69,14 +270,118 @@ createWebViewWithConfiguration:(WKWebViewConfiguration*)config
               forNavigationAction:(WKNavigationAction*)action
                    windowFeatures:(WKWindowFeatures*)features
 {
-  (void)config; (void)features;
-  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  (void)features;
+  uint32_t opener_view_id = bunite_mac::viewIdForWebView(wv);
   NSString* url = action.request.URL.absoluteString ?: @"";
-  // Match win OnBeforePopup/OnOpenURLFromTab: emit, cancel; JS decides via load_url.
-  std::string payload = "{\"url\":\"" +
-    bunite_mac::escapeJsonString(url.UTF8String ?: "") + "\"}";
-  bunite_mac::emitWebviewEvent(view_id, "new-window-open", payload);
-  return nil;
+  if (bunite_mac::g_runtime.popup_blocking) {
+    std::string payload = "{\"url\":\"" + bunite_mac::escapeJsonString(url.UTF8String ?: "") + "\"}";
+    bunite_mac::emitWebviewEvent(opener_view_id, "new-window-open", payload);
+    return nil;
+  }
+  static std::atomic<uint32_t> g_popup_seq{0x80000000u};
+  const uint32_t new_view_id = g_popup_seq.fetch_add(1);
+  WKWebView* popup = [[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 1, 1) configuration:config];
+  popup.navigationDelegate = wv.navigationDelegate;
+  popup.UIDelegate = wv.UIDelegate;
+  if (!bunite_mac::g_runtime.parked_popups) {
+    bunite_mac::g_runtime.parked_popups = [NSMutableDictionary dictionary];
+  }
+  if (!bunite_mac::g_runtime.popup_parent) {
+    bunite_mac::g_runtime.popup_parent =
+        [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 1, 1)
+                                    styleMask:NSWindowStyleMaskBorderless
+                                      backing:NSBackingStoreBuffered
+                                        defer:YES];
+  }
+  bunite_mac::g_runtime.parked_popups[@(new_view_id)] = popup;
+  [bunite_mac::g_runtime.popup_parent.contentView addSubview:popup];
+  bunite_mac::registerWebViewId(popup, new_view_id);
+  {
+    std::lock_guard<std::mutex> lock(bunite_mac::g_runtime.object_mutex);
+    auto& st = bunite_mac::g_runtime.views[new_view_id];
+    st.webview = popup;
+    st.container = nil;       // bound on adoption
+    st.window_id = 0;
+  }
+  std::string payload = "{\"newSurfaceId\":" + std::to_string(new_view_id) +
+                        ",\"url\":\"" + bunite_mac::escapeJsonString(url.UTF8String ?: "") +
+                        "\",\"disposition\":\"popup\"}";
+  bunite_mac::emitWebviewEvent(opener_view_id, "popup-requested", payload);
+  return popup;
+}
+
+// --- Dialog handlers (alert / confirm / prompt). beforeunload is not
+//     surfaced by WKUIDelegate on macOS — the cancel/proceed decision is made
+//     through the navigation-policy delegate's `decidePolicyForNavigationAction:`
+//     which we already drive via the `will-navigate` allow-list. Hence no
+//     beforeunload arm on this backend.
+
+- (void)webView:(WKWebView*)wv
+  runJavaScriptAlertPanelWithMessage:(NSString*)message
+                    initiatedByFrame:(WKFrameInfo*)frame
+                   completionHandler:(void (^)(void))completionHandler
+{
+  (void)frame;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  auto* v = bunite_mac::findView(view_id);
+  if (!v) { completionHandler(); return; }
+  uint32_t rid = v->next_dialog_request_id++;
+  v->pending_dialogs[rid] = ^(bool /*accept*/, const std::string& /*text*/) {
+    completionHandler();
+  };
+  std::string payload = "{\"requestId\":" + std::to_string(rid) +
+    ",\"kind\":\"alert\",\"message\":\"" +
+    bunite_mac::escapeJsonString(message.UTF8String ?: "") + "\"}";
+  // Post emit to next runloop turn so a heavy host-side listener cannot stall
+  // the cooperative pump while the page is awaiting the completion handler.
+  dispatch_async(dispatch_get_main_queue(), ^{
+    bunite_mac::emitWebviewEvent(view_id, "dialog", payload);
+  });
+}
+
+- (void)webView:(WKWebView*)wv
+  runJavaScriptConfirmPanelWithMessage:(NSString*)message
+                      initiatedByFrame:(WKFrameInfo*)frame
+                     completionHandler:(void (^)(BOOL))completionHandler
+{
+  (void)frame;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  auto* v = bunite_mac::findView(view_id);
+  if (!v) { completionHandler(NO); return; }
+  uint32_t rid = v->next_dialog_request_id++;
+  v->pending_dialogs[rid] = ^(bool accept, const std::string& /*text*/) {
+    completionHandler(accept ? YES : NO);
+  };
+  std::string payload = "{\"requestId\":" + std::to_string(rid) +
+    ",\"kind\":\"confirm\",\"message\":\"" +
+    bunite_mac::escapeJsonString(message.UTF8String ?: "") + "\"}";
+  dispatch_async(dispatch_get_main_queue(), ^{
+    bunite_mac::emitWebviewEvent(view_id, "dialog", payload);
+  });
+}
+
+- (void)webView:(WKWebView*)wv
+  runJavaScriptTextInputPanelWithPrompt:(NSString*)prompt
+                            defaultText:(NSString*)defaultText
+                       initiatedByFrame:(WKFrameInfo*)frame
+                      completionHandler:(void (^)(NSString*))completionHandler
+{
+  (void)frame;
+  uint32_t view_id = bunite_mac::viewIdForWebView(wv);
+  auto* v = bunite_mac::findView(view_id);
+  if (!v) { completionHandler(nil); return; }
+  uint32_t rid = v->next_dialog_request_id++;
+  v->pending_dialogs[rid] = ^(bool accept, const std::string& text) {
+    completionHandler(accept ? [NSString stringWithUTF8String:text.c_str()] : nil);
+  };
+  std::string payload = "{\"requestId\":" + std::to_string(rid) +
+    ",\"kind\":\"prompt\",\"message\":\"" +
+    bunite_mac::escapeJsonString(prompt.UTF8String ?: "") +
+    "\",\"defaultPrompt\":\"" +
+    bunite_mac::escapeJsonString(defaultText.UTF8String ?: "") + "\"}";
+  dispatch_async(dispatch_get_main_queue(), ^{
+    bunite_mac::emitWebviewEvent(view_id, "dialog", payload);
+  });
 }
 
 - (void)webView:(WKWebView*)wv
@@ -142,6 +447,14 @@ uint32_t viewIdForWebView(WKWebView* wv) {
   return id ? id.unsignedIntValue : 0;
 }
 
+void registerWebViewId(WKWebView* wv, uint32_t view_id) {
+  [webviewIdTable() setObject:@(view_id) forKey:wv];
+}
+
+void unregisterWebViewId(WKWebView* wv) {
+  [webviewIdTable() removeObjectForKey:wv];
+}
+
 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,
@@ -196,6 +509,7 @@ bool createView(uint32_t view_id, uint32_t window_id,
   static __strong BuniteUIDelegate* uiDelegate = [[BuniteUIDelegate alloc] init];
   wv.navigationDelegate = navDelegate;
   wv.UIDelegate = uiDelegate;
+  [wv addObserver:[BuniteTitleObserver shared] forKeyPath:@"title" options:NSKeyValueObservingOptionNew context:NULL];
 
   [container addSubview:wv];
   [window_state->window.contentView addSubview:container];
@@ -226,6 +540,50 @@ bool createView(uint32_t view_id, uint32_t window_id,
   return true;
 }
 
+bool acceptParkedPopup(uint32_t new_view_id, uint32_t host_window_id, double x, double y, double w, double h) {
+  WKWebView* popup = nil;
+  if (g_runtime.parked_popups) {
+    popup = g_runtime.parked_popups[@(new_view_id)];
+    if (popup) [g_runtime.parked_popups removeObjectForKey:@(new_view_id)];
+  }
+  if (!popup) return false;
+  WindowState* host = findWindow(host_window_id);
+  if (!host || !host->window) return false;
+  [popup removeFromSuperview];
+  BunitePassthroughContainer* container = [[BunitePassthroughContainer alloc] init];
+  container.frame = NSMakeRect(x, y, w, h);
+  popup.frame = NSMakeRect(0, 0, w, h);
+  popup.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+  [container addSubview:popup];
+  [host->window.contentView addSubview:container];
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    auto& st = g_runtime.views[new_view_id];
+    st.container = container;
+    st.webview = popup;
+    st.window_id = host_window_id;
+  }
+  // Re-emit view-ready so TS BrowserView.adopt resolves — the initial
+  // did-navigate fired before the adopter registered.
+  emitWebviewEvent(new_view_id, "view-ready", "");
+  return true;
+}
+
+void dismissParkedPopup(uint32_t new_view_id) {
+  WKWebView* popup = nil;
+  if (g_runtime.parked_popups) {
+    popup = g_runtime.parked_popups[@(new_view_id)];
+    if (popup) [g_runtime.parked_popups removeObjectForKey:@(new_view_id)];
+  }
+  if (!popup) return;
+  [popup removeFromSuperview];
+  unregisterWebViewId(popup);
+  {
+    std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+    g_runtime.views.erase(new_view_id);
+  }
+}
+
 void removeView(uint32_t view_id) {
   __strong WKWebView* wv = nil;
   __strong NSView* container = nil;
@@ -272,7 +630,11 @@ void removeView(uint32_t view_id) {
     for (BunitePendingPermission* p in to_deny) p.handler(WKPermissionDecisionDeny);
   }
 
-  if (wv) [webviewIdTable() removeObjectForKey:wv];
+  if (wv) {
+    @try { [wv removeObserver:[BuniteTitleObserver shared] forKeyPath:@"title"]; }
+    @catch (NSException*) { /* never registered (race) */ }
+    [webviewIdTable() removeObjectForKey:wv];
+  }
   if (container) [container removeFromSuperview];
 }