3101cce refactor(cef): simplify popup bridge handling · dumber

M internal/application/port/webview.go +5 -0


@@ -5,11 +5,16 @@ package port
5	5
6	6		import (
7	7		"context"
	8	+	"errors"
8	9		)
9	10
10	11		// WebViewID uniquely identifies a WebView instance.
11	12		type WebViewID uint64
12	13
	14	+	// ErrRelatedWebViewUnsupported reports that the active engine cannot create
	15	+	// a popup WebView related to an existing parent WebView.
	16	+	var ErrRelatedWebViewUnsupported = errors.New("related popup webviews are not supported")
	17	+
13	18		// LoadEvent represents page load state transitions.
14	19		type LoadEvent int
15	20


@@ -5,11 +5,16 @@ package port
5		5
6	import (	6		import (
7	"context"	7		"context"
		8	+	"errors"
8	)	9		)
9		10
10	// WebViewID uniquely identifies a WebView instance.	11		// WebViewID uniquely identifies a WebView instance.
11	type WebViewID uint64	12		type WebViewID uint64
12		13
		14	+	// ErrRelatedWebViewUnsupported reports that the active engine cannot create
		15	+	// a popup WebView related to an existing parent WebView.
		16	+	var ErrRelatedWebViewUnsupported = errors.New("related popup webviews are not supported")
		17	+
13	// LoadEvent represents page load state transitions.	18		// LoadEvent represents page load state transitions.
14	type LoadEvent int	19		type LoadEvent int
15		20

M internal/infrastructure/cef/engine.go +34 -24


@@ -49,8 +49,9 @@ type Engine struct {
49	49		alreadyRunningAppRelaunchHandler func(string)
50	50
51	51		// activeWebViews tracks all live webviews for CSS broadcast.
52		-	activeWebViews sync.Map // map[port.WebViewID]*WebView
53		-	activeCount atomic.Int32
	52	+	activeWebViews sync.Map // map[port.WebViewID]*WebView
	53	+	browserWebViews sync.Map // map[int32]*WebView
	54	+	activeCount atomic.Int32
54	55
55	56		// shutdownNotify is signaled when the active webview count reaches 0
56	57		// during shutdown, replacing the busy-wait poll in closeActiveWebViews.

@@ -145,10 +146,29 @@ func (e Engine) registerWebView(wv WebView) {
145	146		e.activeCount.Add(1)
146	147		}
147	148
	149	+	func (e Engine) bindBrowserWebView(browser purecef.Browser, wv WebView) {
	150	+	if e == nil \|\| browser == nil \|\| wv == nil {
	151	+	return
	152	+	}
	153	+	e.browserWebViews.Store(browser.GetIdentifier(), wv)
	154	+	}
	155	+
	156	+	func (e Engine) unbindBrowserWebView(browserID int32, wv WebView) {
	157	+	if e == nil \|\| browserID == 0 {
	158	+	return
	159	+	}
	160	+	if current, ok := e.browserWebViews.Load(browserID); ok {
	161	+	if existing, ok := current.(*WebView); ok && existing == wv {
	162	+	e.browserWebViews.Delete(browserID)
	163	+	}
	164	+	}
	165	+	}
	166	+
148	167		// unregisterWebView removes a webview from the active tracking map.
149	168		// If the count reaches 0 and a shutdown is in progress, it signals shutdownNotify.
150		-	func (e Engine) unregisterWebView(wv WebView) {
	169	+	func (e Engine) unregisterWebView(wv WebView, browserID int32) {
151	170		e.activeWebViews.Delete(wv.id)
	171	+	e.unbindBrowserWebView(browserID, wv)
152	172		if e.activeCount.Add(-1) == 0 && e.shutdownNotify != nil {
153	173		select {
154	174		case e.shutdownNotify <- struct{}{}:

@@ -432,28 +452,18 @@ func (e *Engine) validateBridgeRequest(browser purecef.Browser, bridgeNonce stri
432	452		return false
433	453		}
434	454
435		-	browserID := browser.GetIdentifier()
436		-	valid := false
437		-	e.activeWebViews.Range(func(_, value any) bool {
438		-	wv, ok := value.(*WebView)
439		-	if !ok \|\| wv == nil {
440		-	return true
441		-	}
	455	+	wv := e.webViewForBrowser(browser)
	456	+	if wv == nil {
	457	+	return false
	458	+	}
442	459
443		-	wv.mu.RLock()
444		-	wvBrowser := wv.browser
445		-	wvBridgeNonce := wv.bridgeNonce
446		-	wv.mu.RUnlock()
447		-	if wvBrowser == nil \|\| wvBridgeNonce == "" \|\| wvBrowser.GetIdentifier() != browserID {
448		-	return true
449		-	}
450		-	if subtle.ConstantTimeCompare([]byte(wvBridgeNonce), []byte(bridgeNonce)) == 1 {
451		-	valid = true
452		-	return false
453		-	}
454		-	return true
455		-	})
456		-	return valid
	460	+	wv.mu.RLock()
	461	+	wvBridgeNonce := wv.bridgeNonce
	462	+	wv.mu.RUnlock()
	463	+	if wvBridgeNonce == "" {
	464	+	return false
	465	+	}
	466	+	return subtle.ConstantTimeCompare([]byte(wvBridgeNonce), []byte(bridgeNonce)) == 1
457	467		}
458	468
459	469		func (e Engine) currentDownloadHandler() downloadHandler {

 	alreadyRunningAppRelaunchHandler func(string)
 	// activeWebViews tracks all live webviews for CSS broadcast.
-	activeWebViews sync.Map // map[port.WebViewID]*WebView
+	activeWebViews  sync.Map // map[port.WebViewID]*WebView
-	activeCount    atomic.Int32
+	browserWebViews sync.Map // map[int32]*WebView
+	activeCount     atomic.Int32
 	// shutdownNotify is signaled when the active webview count reaches 0
 	// during shutdown, replacing the busy-wait poll in closeActiveWebViews.
 	e.activeCount.Add(1)
 }
+func (e *Engine) bindBrowserWebView(browser purecef.Browser, wv *WebView) {
+	if e == nil || browser == nil || wv == nil {
+		return
+	}
+	e.browserWebViews.Store(browser.GetIdentifier(), wv)
+}
+func (e *Engine) unbindBrowserWebView(browserID int32, wv *WebView) {
+	if e == nil || browserID == 0 {
+		return
+	}
+	if current, ok := e.browserWebViews.Load(browserID); ok {
+		if existing, ok := current.(*WebView); ok && existing == wv {
+			e.browserWebViews.Delete(browserID)
+		}
+	}
+}
 // unregisterWebView removes a webview from the active tracking map.
 // If the count reaches 0 and a shutdown is in progress, it signals shutdownNotify.
-func (e *Engine) unregisterWebView(wv *WebView) {
+func (e *Engine) unregisterWebView(wv *WebView, browserID int32) {
 	e.activeWebViews.Delete(wv.id)
+	e.unbindBrowserWebView(browserID, wv)
 	if e.activeCount.Add(-1) == 0 && e.shutdownNotify != nil {
 		select {
 		case e.shutdownNotify <- struct{}{}:
 		return false
 	}
-	browserID := browser.GetIdentifier()
+	wv := e.webViewForBrowser(browser)
-	valid := false
+	if wv == nil {
-	e.activeWebViews.Range(func(_, value any) bool {
+		return false
-		wv, ok := value.(*WebView)
+	}
-		if !ok || wv == nil {
-			return true
-		}
-		wv.mu.RLock()
+	wv.mu.RLock()
-		wvBrowser := wv.browser
+	wvBridgeNonce := wv.bridgeNonce
-		wvBridgeNonce := wv.bridgeNonce
+	wv.mu.RUnlock()
-		wv.mu.RUnlock()
+	if wvBridgeNonce == "" {
-		if wvBrowser == nil || wvBridgeNonce == "" || wvBrowser.GetIdentifier() != browserID {
+		return false
-			return true
+	}
-		}
+	return subtle.ConstantTimeCompare([]byte(wvBridgeNonce), []byte(bridgeNonce)) == 1
-		if subtle.ConstantTimeCompare([]byte(wvBridgeNonce), []byte(bridgeNonce)) == 1 {
-			valid = true
-			return false
-		}
-		return true
-	})
-	return valid
 }
 func (e *Engine) currentDownloadHandler() *downloadHandler {

M internal/infrastructure/cef/engine_popup_bridge.go +30 -29


@@ -12,6 +12,18 @@ func (e Engine) webViewForBrowser(browser purecef.Browser) WebView {
12	12		}
13	13
14	14		browserID := browser.GetIdentifier()
	15	+	if current, ok := e.browserWebViews.Load(browserID); ok {
	16	+	if wv, ok := current.(*WebView); ok && wv != nil {
	17	+	wv.mu.RLock()
	18	+	wvBrowser := wv.browser
	19	+	wv.mu.RUnlock()
	20	+	if wvBrowser != nil && wvBrowser.GetIdentifier() == browserID {
	21	+	return wv
	22	+	}
	23	+	e.unbindBrowserWebView(browserID, wv)
	24	+	}
	25	+	}
	26	+
15	27		var matched *WebView
16	28		e.activeWebViews.Range(func(_, value any) bool {
17	29		wv, ok := value.(*WebView)

@@ -25,52 +37,41 @@ func (e Engine) webViewForBrowser(browser purecef.Browser) WebView {
25	37		return true
26	38		}
27	39		matched = wv
	40	+	e.bindBrowserWebView(browser, wv)
28	41		return false
29	42		})
30	43		return matched
31	44		}
32	45
33		-	func (e *Engine) handlePopupBridgeOpen(browser purecef.Browser, payload rendererBridgePopupOpenPayload) {
34		-	if e == nil {
	46	+	func (e Engine) withBridgeSourceWebView(browser purecef.Browser, proxyID, action string, fn func(WebView)) {
	47	+	if e == nil \|\| browser == nil {
35	48		return
36	49		}
37	50		wv := e.webViewForBrowser(browser)
38	51		if wv == nil {
39	52		logging.FromContext(e.currentContext()).Warn().
40	53		Int32("browser_id", browser.GetIdentifier()).
41		-	Str("proxy_id", payload.ProxyID).
42		-	Msg("cef: popup-open bridge could not resolve source webview")
	54	+	Str("proxy_id", proxyID).
	55	+	Msg("cef: " + action + " bridge could not resolve source webview")
43	56		return
44	57		}
45		-	wv.handleSyntheticPopupOpen(payload.URL, payload.FrameName, payload.ProxyID, payload.UserGesture, payload.NoJavaScriptAccess)
	58	+	fn(wv)
	59	+	}
	60	+
	61	+	func (e *Engine) handlePopupBridgeOpen(browser purecef.Browser, payload rendererBridgePopupOpenPayload) {
	62	+	e.withBridgeSourceWebView(browser, payload.ProxyID, "popup-open", func(wv *WebView) {
	63	+	wv.handleSyntheticPopupOpen(payload.URL, payload.FrameName, payload.ProxyID, payload.UserGesture, payload.NoJavaScriptAccess)
	64	+	})
46	65		}
47	66
48	67		func (e *Engine) handlePopupBridgeNavigate(browser purecef.Browser, payload rendererBridgePopupNavigatePayload) {
49		-	if e == nil {
50		-	return
51		-	}
52		-	wv := e.webViewForBrowser(browser)
53		-	if wv == nil {
54		-	logging.FromContext(e.currentContext()).Warn().
55		-	Int32("browser_id", browser.GetIdentifier()).
56		-	Str("proxy_id", payload.ProxyID).
57		-	Msg("cef: popup-navigate bridge could not resolve source webview")
58		-	return
59		-	}
60		-	wv.handleSyntheticPopupNavigate(payload.ProxyID, payload.URL)
	68	+	e.withBridgeSourceWebView(browser, payload.ProxyID, "popup-navigate", func(wv *WebView) {
	69	+	wv.handleSyntheticPopupNavigate(payload.ProxyID, payload.URL)
	70	+	})
61	71		}
62	72
63	73		func (e *Engine) handlePopupBridgeClose(browser purecef.Browser, payload rendererBridgePopupClosePayload) {
64		-	if e == nil {
65		-	return
66		-	}
67		-	wv := e.webViewForBrowser(browser)
68		-	if wv == nil {
69		-	logging.FromContext(e.currentContext()).Warn().
70		-	Int32("browser_id", browser.GetIdentifier()).
71		-	Str("proxy_id", payload.ProxyID).
72		-	Msg("cef: popup-close bridge could not resolve source webview")
73		-	return
74		-	}
75		-	wv.handleSyntheticPopupClose(payload.ProxyID)
	74	+	e.withBridgeSourceWebView(browser, payload.ProxyID, "popup-close", func(wv *WebView) {
	75	+	wv.handleSyntheticPopupClose(payload.ProxyID)
	76	+	})
76	77		}

 	}
 	browserID := browser.GetIdentifier()
+	if current, ok := e.browserWebViews.Load(browserID); ok {
+		if wv, ok := current.(*WebView); ok && wv != nil {
+			wv.mu.RLock()
+			wvBrowser := wv.browser
+			wv.mu.RUnlock()
+			if wvBrowser != nil && wvBrowser.GetIdentifier() == browserID {
+				return wv
+			}
+			e.unbindBrowserWebView(browserID, wv)
+		}
+	}
 	var matched *WebView
 	e.activeWebViews.Range(func(_, value any) bool {
 		wv, ok := value.(*WebView)
 			return true
 		}
 		matched = wv
+		e.bindBrowserWebView(browser, wv)
 		return false
 	})
 	return matched
 }
-func (e *Engine) handlePopupBridgeOpen(browser purecef.Browser, payload rendererBridgePopupOpenPayload) {
+func (e *Engine) withBridgeSourceWebView(browser purecef.Browser, proxyID, action string, fn func(*WebView)) {
-	if e == nil {
+	if e == nil || browser == nil {
 		return
 	}
 	wv := e.webViewForBrowser(browser)
 	if wv == nil {
 		logging.FromContext(e.currentContext()).Warn().
 			Int32("browser_id", browser.GetIdentifier()).
-			Str("proxy_id", payload.ProxyID).
+			Str("proxy_id", proxyID).
-			Msg("cef: popup-open bridge could not resolve source webview")
+			Msg("cef: " + action + " bridge could not resolve source webview")
 		return
 	}
-	wv.handleSyntheticPopupOpen(payload.URL, payload.FrameName, payload.ProxyID, payload.UserGesture, payload.NoJavaScriptAccess)
+	fn(wv)
+}
+func (e *Engine) handlePopupBridgeOpen(browser purecef.Browser, payload rendererBridgePopupOpenPayload) {
+	e.withBridgeSourceWebView(browser, payload.ProxyID, "popup-open", func(wv *WebView) {
+		wv.handleSyntheticPopupOpen(payload.URL, payload.FrameName, payload.ProxyID, payload.UserGesture, payload.NoJavaScriptAccess)
+	})
 }
 func (e *Engine) handlePopupBridgeNavigate(browser purecef.Browser, payload rendererBridgePopupNavigatePayload) {
-	if e == nil {
+	e.withBridgeSourceWebView(browser, payload.ProxyID, "popup-navigate", func(wv *WebView) {
-		return
+		wv.handleSyntheticPopupNavigate(payload.ProxyID, payload.URL)
-	}
+	})
-	wv := e.webViewForBrowser(browser)
-	if wv == nil {
-		logging.FromContext(e.currentContext()).Warn().
-			Int32("browser_id", browser.GetIdentifier()).
-			Str("proxy_id", payload.ProxyID).
-			Msg("cef: popup-navigate bridge could not resolve source webview")
-		return
-	}
-	wv.handleSyntheticPopupNavigate(payload.ProxyID, payload.URL)
 }
 func (e *Engine) handlePopupBridgeClose(browser purecef.Browser, payload rendererBridgePopupClosePayload) {
-	if e == nil {
+	e.withBridgeSourceWebView(browser, payload.ProxyID, "popup-close", func(wv *WebView) {
-		return
+		wv.handleSyntheticPopupClose(payload.ProxyID)
-	}
+	})
-	wv := e.webViewForBrowser(browser)
-	if wv == nil {
-		logging.FromContext(e.currentContext()).Warn().
-			Int32("browser_id", browser.GetIdentifier()).
-			Str("proxy_id", payload.ProxyID).
-			Msg("cef: popup-close bridge could not resolve source webview")
-		return
-	}
-	wv.handleSyntheticPopupClose(payload.ProxyID)
 }

M internal/infrastructure/cef/renderer_bridge.go +15 -25


@@ -499,46 +499,36 @@ func decodeRendererBridgeExplicitTextCopyPayload(payload []byte) (rendererBridge
499	499		return req, nil
500	500		}
501	501
502		-	func decodeRendererBridgePopupOpenPayload(payload []byte) (rendererBridgePopupOpenPayload, error) {
503		-	var req rendererBridgePopupOpenPayload
	502	+	func decodeRendererBridgePopupPayload[T any](payload []byte, proxyID func(T) string) (T, error) {
	503	+	var req T
504	504		if len(payload) == 0 {
505	505		return req, fmt.Errorf("empty payload")
506	506		}
507	507		if err := json.Unmarshal(payload, &req); err != nil {
508	508		return req, err
509	509		}
510		-	if req.ProxyID == "" {
	510	+	if proxyID(req) == "" {
511	511		return req, fmt.Errorf("missing proxy_id")
512	512		}
513	513		return req, nil
514	514		}
515	515
	516	+	func decodeRendererBridgePopupOpenPayload(payload []byte) (rendererBridgePopupOpenPayload, error) {
	517	+	return decodeRendererBridgePopupPayload(payload, func(req rendererBridgePopupOpenPayload) string {
	518	+	return req.ProxyID
	519	+	})
	520	+	}
	521	+
516	522		func decodeRendererBridgePopupNavigatePayload(payload []byte) (rendererBridgePopupNavigatePayload, error) {
517		-	var req rendererBridgePopupNavigatePayload
518		-	if len(payload) == 0 {
519		-	return req, fmt.Errorf("empty payload")
520		-	}
521		-	if err := json.Unmarshal(payload, &req); err != nil {
522		-	return req, err
523		-	}
524		-	if req.ProxyID == "" {
525		-	return req, fmt.Errorf("missing proxy_id")
526		-	}
527		-	return req, nil
	523	+	return decodeRendererBridgePopupPayload(payload, func(req rendererBridgePopupNavigatePayload) string {
	524	+	return req.ProxyID
	525	+	})
528	526		}
529	527
530	528		func decodeRendererBridgePopupClosePayload(payload []byte) (rendererBridgePopupClosePayload, error) {
531		-	var req rendererBridgePopupClosePayload
532		-	if len(payload) == 0 {
533		-	return req, fmt.Errorf("empty payload")
534		-	}
535		-	if err := json.Unmarshal(payload, &req); err != nil {
536		-	return req, err
537		-	}
538		-	if req.ProxyID == "" {
539		-	return req, fmt.Errorf("missing proxy_id")
540		-	}
541		-	return req, nil
	529	+	return decodeRendererBridgePopupPayload(payload, func(req rendererBridgePopupClosePayload) string {
	530	+	return req.ProxyID
	531	+	})
542	532		}
543	533
544	534		func (e *Engine) handleEditableFocusBridge(browser purecef.Browser) {

 	return req, nil
 }
-func decodeRendererBridgePopupOpenPayload(payload []byte) (rendererBridgePopupOpenPayload, error) {
+func decodeRendererBridgePopupPayload[T any](payload []byte, proxyID func(T) string) (T, error) {
-	var req rendererBridgePopupOpenPayload
+	var req T
 	if len(payload) == 0 {
 		return req, fmt.Errorf("empty payload")
 	}
 	if err := json.Unmarshal(payload, &req); err != nil {
 		return req, err
 	}
-	if req.ProxyID == "" {
+	if proxyID(req) == "" {
 		return req, fmt.Errorf("missing proxy_id")
 	}
 	return req, nil
 }
+func decodeRendererBridgePopupOpenPayload(payload []byte) (rendererBridgePopupOpenPayload, error) {
+	return decodeRendererBridgePopupPayload(payload, func(req rendererBridgePopupOpenPayload) string {
+		return req.ProxyID
+	})
+}
 func decodeRendererBridgePopupNavigatePayload(payload []byte) (rendererBridgePopupNavigatePayload, error) {
-	var req rendererBridgePopupNavigatePayload
+	return decodeRendererBridgePopupPayload(payload, func(req rendererBridgePopupNavigatePayload) string {
-	if len(payload) == 0 {
+		return req.ProxyID
-		return req, fmt.Errorf("empty payload")
+	})
-	}
-	if err := json.Unmarshal(payload, &req); err != nil {
-		return req, err
-	}
-	if req.ProxyID == "" {
-		return req, fmt.Errorf("missing proxy_id")
-	}
-	return req, nil
 }
 func decodeRendererBridgePopupClosePayload(payload []byte) (rendererBridgePopupClosePayload, error) {
-	var req rendererBridgePopupClosePayload
+	return decodeRendererBridgePopupPayload(payload, func(req rendererBridgePopupClosePayload) string {
-	if len(payload) == 0 {
+		return req.ProxyID
-		return req, fmt.Errorf("empty payload")
+	})
-	}
-	if err := json.Unmarshal(payload, &req); err != nil {
-		return req, err
-	}
-	if req.ProxyID == "" {
-		return req, fmt.Errorf("missing proxy_id")
-	}
-	return req, nil
 }
 func (e *Engine) handleEditableFocusBridge(browser purecef.Browser) {

M internal/infrastructure/cef/runtime_config.go +1 -1


@@ -9,7 +9,7 @@ import (
9	9
10	10		var (
11	11		ErrDownloadsUnsupported = errors.New("cef: downloads are not supported yet")
12		-	ErrRelatedWebViewUnsupported = errors.New("cef: related popup webviews are not supported yet")
	12	+	ErrRelatedWebViewUnsupported = port.ErrRelatedWebViewUnsupported
13	13		ErrCookiePolicyUnsupported = errors.New("cef: non-default cookie policy is not supported yet")
14	14		)
15	15


@@ -9,7 +9,7 @@ import (
9			9
10		var (	10		var (
11		ErrDownloadsUnsupported = errors.New("cef: downloads are not supported yet")	11		ErrDownloadsUnsupported = errors.New("cef: downloads are not supported yet")
12	-	ErrRelatedWebViewUnsupported = errors.New("cef: related popup webviews are not supported yet")	12	+	ErrRelatedWebViewUnsupported = port.ErrRelatedWebViewUnsupported
13		ErrCookiePolicyUnsupported = errors.New("cef: non-default cookie policy is not supported yet")	13		ErrCookiePolicyUnsupported = errors.New("cef: non-default cookie policy is not supported yet")
14		)	14		)
15			15

M internal/infrastructure/cef/scheme_handler.go +20 -51


@@ -348,79 +348,48 @@ func (h *dumbSchemeHandler) handleFocusSync(request purecef.Request, browser pur
348	348		return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
349	349		}
350	350
351		-	func (h *dumbSchemeHandler) handlePopupOpen(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
	351	+	func handlePopupBridgeRequest[T any](
	352	+	h *dumbSchemeHandler,
	353	+	request purecef.Request,
	354	+	browser purecef.Browser,
	355	+	action string,
	356	+	decode func([]byte) (T, error),
	357	+	dispatch func(purecef.Browser, T),
	358	+	) purecef.ResourceHandler {
352	359		if browser == nil {
353		-	h.logger.Debug().Msg("cef: popup-open — browser unavailable")
	360	+	h.logger.Debug().Msg("cef: " + action + " — browser unavailable")
354	361		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "browser unavailable"})
355	362		}
356	363		if !h.hasTrustedBridgeNonce(request, browser) {
357		-	h.logger.Warn().Msg("cef: popup-open — rejected request without valid bridge nonce")
	364	+	h.logger.Warn().Msg("cef: " + action + " — rejected request without valid bridge nonce")
358	365		return h.newAPIJSONResourceHandler(http.StatusForbidden, map[string]string{"error": "forbidden"})
359	366		}
360	367		body := readBodyFromHeader(request)
361	368		if body == nil {
362	369		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "empty body"})
363	370		}
364		-	payload, err := decodeRendererBridgePopupOpenPayload(body)
	371	+	payload, err := decode(body)
365	372		if err != nil {
366	373		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": err.Error()})
367	374		}
368		-	if h.onPopupOpen != nil {
369		-	h.onPopupOpen(browser, payload)
	375	+	if dispatch != nil {
	376	+	dispatch(browser, payload)
370	377		} else {
371		-	h.logger.Warn().Msg("cef: popup-open — callback not wired")
	378	+	h.logger.Warn().Msg("cef: " + action + " — callback not wired")
372	379		}
373	380		return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
374	381		}
375	382
	383	+	func (h *dumbSchemeHandler) handlePopupOpen(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
	384	+	return handlePopupBridgeRequest(h, request, browser, "popup-open", decodeRendererBridgePopupOpenPayload, h.onPopupOpen)
	385	+	}
	386	+
376	387		func (h *dumbSchemeHandler) handlePopupNavigate(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
377		-	if browser == nil {
378		-	h.logger.Debug().Msg("cef: popup-navigate — browser unavailable")
379		-	return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "browser unavailable"})
380		-	}
381		-	if !h.hasTrustedBridgeNonce(request, browser) {
382		-	h.logger.Warn().Msg("cef: popup-navigate — rejected request without valid bridge nonce")
383		-	return h.newAPIJSONResourceHandler(http.StatusForbidden, map[string]string{"error": "forbidden"})
384		-	}
385		-	body := readBodyFromHeader(request)
386		-	if body == nil {
387		-	return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "empty body"})
388		-	}
389		-	payload, err := decodeRendererBridgePopupNavigatePayload(body)
390		-	if err != nil {
391		-	return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": err.Error()})
392		-	}
393		-	if h.onPopupNavigate != nil {
394		-	h.onPopupNavigate(browser, payload)
395		-	} else {
396		-	h.logger.Warn().Msg("cef: popup-navigate — callback not wired")
397		-	}
398		-	return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
	388	+	return handlePopupBridgeRequest(h, request, browser, "popup-navigate", decodeRendererBridgePopupNavigatePayload, h.onPopupNavigate)
399	389		}
400	390
401	391		func (h *dumbSchemeHandler) handlePopupClose(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
402		-	if browser == nil {
403		-	h.logger.Debug().Msg("cef: popup-close — browser unavailable")
404		-	return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "browser unavailable"})
405		-	}
406		-	if !h.hasTrustedBridgeNonce(request, browser) {
407		-	h.logger.Warn().Msg("cef: popup-close — rejected request without valid bridge nonce")
408		-	return h.newAPIJSONResourceHandler(http.StatusForbidden, map[string]string{"error": "forbidden"})
409		-	}
410		-	body := readBodyFromHeader(request)
411		-	if body == nil {
412		-	return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "empty body"})
413		-	}
414		-	payload, err := decodeRendererBridgePopupClosePayload(body)
415		-	if err != nil {
416		-	return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": err.Error()})
417		-	}
418		-	if h.onPopupClose != nil {
419		-	h.onPopupClose(browser, payload)
420		-	} else {
421		-	h.logger.Warn().Msg("cef: popup-close — callback not wired")
422		-	}
423		-	return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
	392	+	return handlePopupBridgeRequest(h, request, browser, "popup-close", decodeRendererBridgePopupClosePayload, h.onPopupClose)
424	393		}
425	394
426	395		func (h *dumbSchemeHandler) hasTrustedBridgeNonce(request purecef.Request, browser purecef.Browser) bool {

 	return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
 }
-func (h *dumbSchemeHandler) handlePopupOpen(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
+func handlePopupBridgeRequest[T any](
+	h *dumbSchemeHandler,
+	request purecef.Request,
+	browser purecef.Browser,
+	action string,
+	decode func([]byte) (T, error),
+	dispatch func(purecef.Browser, T),
+) purecef.ResourceHandler {
 	if browser == nil {
-		h.logger.Debug().Msg("cef: popup-open — browser unavailable")
+		h.logger.Debug().Msg("cef: " + action + " — browser unavailable")
 		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "browser unavailable"})
 	}
 	if !h.hasTrustedBridgeNonce(request, browser) {
-		h.logger.Warn().Msg("cef: popup-open — rejected request without valid bridge nonce")
+		h.logger.Warn().Msg("cef: " + action + " — rejected request without valid bridge nonce")
 		return h.newAPIJSONResourceHandler(http.StatusForbidden, map[string]string{"error": "forbidden"})
 	}
 	body := readBodyFromHeader(request)
 	if body == nil {
 		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "empty body"})
 	}
-	payload, err := decodeRendererBridgePopupOpenPayload(body)
+	payload, err := decode(body)
 	if err != nil {
 		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": err.Error()})
 	}
-	if h.onPopupOpen != nil {
+	if dispatch != nil {
-		h.onPopupOpen(browser, payload)
+		dispatch(browser, payload)
 	} else {
-		h.logger.Warn().Msg("cef: popup-open — callback not wired")
+		h.logger.Warn().Msg("cef: " + action + " — callback not wired")
 	}
 	return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
 }
+func (h *dumbSchemeHandler) handlePopupOpen(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
+	return handlePopupBridgeRequest(h, request, browser, "popup-open", decodeRendererBridgePopupOpenPayload, h.onPopupOpen)
+}
 func (h *dumbSchemeHandler) handlePopupNavigate(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
-	if browser == nil {
+	return handlePopupBridgeRequest(h, request, browser, "popup-navigate", decodeRendererBridgePopupNavigatePayload, h.onPopupNavigate)
-		h.logger.Debug().Msg("cef: popup-navigate — browser unavailable")
-		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "browser unavailable"})
-	}
-	if !h.hasTrustedBridgeNonce(request, browser) {
-		h.logger.Warn().Msg("cef: popup-navigate — rejected request without valid bridge nonce")
-		return h.newAPIJSONResourceHandler(http.StatusForbidden, map[string]string{"error": "forbidden"})
-	}
-	body := readBodyFromHeader(request)
-	if body == nil {
-		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "empty body"})
-	}
-	payload, err := decodeRendererBridgePopupNavigatePayload(body)
-	if err != nil {
-		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": err.Error()})
-	}
-	if h.onPopupNavigate != nil {
-		h.onPopupNavigate(browser, payload)
-	} else {
-		h.logger.Warn().Msg("cef: popup-navigate — callback not wired")
-	}
-	return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
 }
 func (h *dumbSchemeHandler) handlePopupClose(request purecef.Request, browser purecef.Browser) purecef.ResourceHandler {
-	if browser == nil {
+	return handlePopupBridgeRequest(h, request, browser, "popup-close", decodeRendererBridgePopupClosePayload, h.onPopupClose)
-		h.logger.Debug().Msg("cef: popup-close — browser unavailable")
-		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "browser unavailable"})
-	}
-	if !h.hasTrustedBridgeNonce(request, browser) {
-		h.logger.Warn().Msg("cef: popup-close — rejected request without valid bridge nonce")
-		return h.newAPIJSONResourceHandler(http.StatusForbidden, map[string]string{"error": "forbidden"})
-	}
-	body := readBodyFromHeader(request)
-	if body == nil {
-		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": "empty body"})
-	}
-	payload, err := decodeRendererBridgePopupClosePayload(body)
-	if err != nil {
-		return h.newAPIJSONResourceHandler(http.StatusBadRequest, map[string]string{"error": err.Error()})
-	}
-	if h.onPopupClose != nil {
-		h.onPopupClose(browser, payload)
-	} else {
-		h.logger.Warn().Msg("cef: popup-close — callback not wired")
-	}
-	return h.newAPIJSONResourceHandler(http.StatusOK, map[string]any{"ok": true})
 }
 func (h *dumbSchemeHandler) hasTrustedBridgeNonce(request purecef.Request, browser purecef.Browser) bool {

M internal/infrastructure/cef/webview_handlers.go +7 -2


@@ -730,6 +730,7 @@ func (h *handlerSet) OnAfterCreated(browser purecef.Browser) {
730	730		if h.wv.engine != nil {
731	731		h.wv.engine.recordBrowserAfterCreated(browser)
732	732		h.wv.engine.registerWebView(h.wv)
	733	+	h.wv.engine.bindBrowserWebView(browser, h.wv)
733	734		}
734	735		host := browser.GetHost()
735	736		if host == nil {

@@ -783,9 +784,13 @@ func (h *handlerSet) DoClose(_ purecef.Browser) bool {
783	784		}
784	785
785	786		// OnBeforeClose fires the OnClose callback.
786		-	func (h *handlerSet) OnBeforeClose(_ purecef.Browser) {
	787	+	func (h *handlerSet) OnBeforeClose(browser purecef.Browser) {
787	788		if h.wv.engine != nil {
788		-	h.wv.engine.unregisterWebView(h.wv)
	789	+	browserID := int32(0)
	790	+	if browser != nil {
	791	+	browserID = browser.GetIdentifier()
	792	+	}
	793	+	h.wv.engine.unregisterWebView(h.wv, browserID)
789	794		}
790	795		h.wv.mu.Lock()
791	796		h.wv.browser = nil

 	if h.wv.engine != nil {
 		h.wv.engine.recordBrowserAfterCreated(browser)
 		h.wv.engine.registerWebView(h.wv)
+		h.wv.engine.bindBrowserWebView(browser, h.wv)
 	}
 	host := browser.GetHost()
 	if host == nil {
 }
 // OnBeforeClose fires the OnClose callback.
-func (h *handlerSet) OnBeforeClose(_ purecef.Browser) {
+func (h *handlerSet) OnBeforeClose(browser purecef.Browser) {
 	if h.wv.engine != nil {
-		h.wv.engine.unregisterWebView(h.wv)
+		browserID := int32(0)
+		if browser != nil {
+			browserID = browser.GetIdentifier()
+		}
+		h.wv.engine.unregisterWebView(h.wv, browserID)
 	}
 	h.wv.mu.Lock()
 	h.wv.browser = nil

M internal/infrastructure/cef/webview_popup_proxy.go +23 -1


@@ -33,12 +33,32 @@ func (wv WebView) syntheticPopupState(proxyID string) syntheticPopupState {
33	33		return state
34	34		}
35	35
	36	+	func (wv WebView) lookupSyntheticPopupState(proxyID string) syntheticPopupState {
	37	+	if wv == nil \|\| proxyID == "" {
	38	+	return nil
	39	+	}
	40	+
	41	+	wv.syntheticPopupMu.Lock()
	42	+	defer wv.syntheticPopupMu.Unlock()
	43	+	return wv.syntheticPopups[proxyID]
	44	+	}
	45	+
	46	+	func (wv *WebView) deleteSyntheticPopupState(proxyID string) {
	47	+	if wv == nil \|\| proxyID == "" {
	48	+	return
	49	+	}
	50	+
	51	+	wv.syntheticPopupMu.Lock()
	52	+	defer wv.syntheticPopupMu.Unlock()
	53	+	delete(wv.syntheticPopups, proxyID)
	54	+	}
	55	+
36	56		func (wv *WebView) handleSyntheticPopupOpen(targetURL, frameName, proxyID string, userGesture, noJavaScriptAccess bool) {
37	57		if wv == nil \|\| proxyID == "" \|\| wv.destroyed.Load() {
38	58		return
39	59		}
40	60
41		-	state := wv.syntheticPopupState(proxyID)
	61	+	state := wv.lookupSyntheticPopupState(proxyID)
42	62		if state != nil {
43	63		wv.syntheticPopupMu.Lock()
44	64		state.NoJavaScriptAccess = noJavaScriptAccess

@@ -54,6 +74,7 @@ func (wv *WebView) handleSyntheticPopupOpen(targetURL, frameName, proxyID string
54	74		cb := wv.callbacks
55	75		wv.mu.RUnlock()
56	76		if cb == nil \|\| cb.OnCreate == nil {
	77	+	wv.deleteSyntheticPopupState(proxyID)
57	78		return
58	79		}
59	80

@@ -65,6 +86,7 @@ func (wv *WebView) handleSyntheticPopupOpen(targetURL, frameName, proxyID string
65	86		ParentViewID: wv.id,
66	87		})
67	88		if popupWV == nil {
	89	+	wv.deleteSyntheticPopupState(proxyID)
68	90		return
69	91		}
70	92

 	return state
 }
+func (wv *WebView) lookupSyntheticPopupState(proxyID string) *syntheticPopupState {
+	if wv == nil || proxyID == "" {
+		return nil
+	}
+	wv.syntheticPopupMu.Lock()
+	defer wv.syntheticPopupMu.Unlock()
+	return wv.syntheticPopups[proxyID]
+}
+func (wv *WebView) deleteSyntheticPopupState(proxyID string) {
+	if wv == nil || proxyID == "" {
+		return
+	}
+	wv.syntheticPopupMu.Lock()
+	defer wv.syntheticPopupMu.Unlock()
+	delete(wv.syntheticPopups, proxyID)
+}
 func (wv *WebView) handleSyntheticPopupOpen(targetURL, frameName, proxyID string, userGesture, noJavaScriptAccess bool) {
 	if wv == nil || proxyID == "" || wv.destroyed.Load() {
 		return
 	}
-	state := wv.syntheticPopupState(proxyID)
+	state := wv.lookupSyntheticPopupState(proxyID)
 	if state != nil {
 		wv.syntheticPopupMu.Lock()
 		state.NoJavaScriptAccess = noJavaScriptAccess
 		cb := wv.callbacks
 		wv.mu.RUnlock()
 		if cb == nil || cb.OnCreate == nil {
+			wv.deleteSyntheticPopupState(proxyID)
 			return
 		}
 			ParentViewID:       wv.id,
 		})
 		if popupWV == nil {
+			wv.deleteSyntheticPopupState(proxyID)
 			return
 		}

M internal/infrastructure/cef/webview_popup_proxy_test.go +17 -0


@@ -66,6 +66,23 @@ func TestHandleSyntheticPopupNavigate_LoadsMappedPopup(t *testing.T) {
66	66		parentWV.handleSyntheticPopupNavigate("popup-2", "https://example.com/finish")
67	67		}
68	68
	69	+	func TestHandleSyntheticPopupOpen_CleansUpStateWhenPopupIsBlocked(t *testing.T) {
	70	+	parentWV := &WebView{
	71	+	ctx: context.Background(),
	72	+	id: port.WebViewID(28),
	73	+	callbacks: &port.WebViewCallbacks{
	74	+	OnCreate: func(port.PopupRequest) port.WebView {
	75	+	return nil
	76	+	},
	77	+	},
	78	+	}
	79	+
	80	+	parentWV.handleSyntheticPopupNavigate("popup-blocked", "https://example.com/blocked")
	81	+	parentWV.handleSyntheticPopupOpen("https://example.com/blocked", "_blank", "popup-blocked", true, false)
	82	+
	83	+	require.Empty(t, parentWV.syntheticPopups)
	84	+	}
	85	+
69	86		func TestHandleSyntheticPopupClose_ClosesMappedPopup(t *testing.T) {
70	87		popupWV := &closeablePopupWebViewStub{MockWebView: portmocks.NewMockWebView(t)}
71	88		parentWV := &WebView{


@@ -66,6 +66,23 @@ func TestHandleSyntheticPopupNavigate_LoadsMappedPopup(t *testing.T) {
66	parentWV.handleSyntheticPopupNavigate("popup-2", "https://example.com/finish")	66		parentWV.handleSyntheticPopupNavigate("popup-2", "https://example.com/finish")
67	}	67		}
68		68
		69	+	func TestHandleSyntheticPopupOpen_CleansUpStateWhenPopupIsBlocked(t *testing.T) {
		70	+	parentWV := &WebView{
		71	+	ctx: context.Background(),
		72	+	id: port.WebViewID(28),
		73	+	callbacks: &port.WebViewCallbacks{
		74	+	OnCreate: func(port.PopupRequest) port.WebView {
		75	+	return nil
		76	+	},
		77	+	},
		78	+	}
		79	+
		80	+	parentWV.handleSyntheticPopupNavigate("popup-blocked", "https://example.com/blocked")
		81	+	parentWV.handleSyntheticPopupOpen("https://example.com/blocked", "_blank", "popup-blocked", true, false)
		82	+
		83	+	require.Empty(t, parentWV.syntheticPopups)
		84	+	}
		85	+
69	func TestHandleSyntheticPopupClose_ClosesMappedPopup(t *testing.T) {	86		func TestHandleSyntheticPopupClose_ClosesMappedPopup(t *testing.T) {
70	popupWV := &closeablePopupWebViewStub{MockWebView: portmocks.NewMockWebView(t)}	87		popupWV := &closeablePopupWebViewStub{MockWebView: portmocks.NewMockWebView(t)}
71	parentWV := &WebView{	88		parentWV := &WebView{

M internal/ui/coordinator/content/coordinator.go +9 -7


@@ -82,13 +82,15 @@ type Coordinator struct {
82	82		gestureActionHandler input.ActionHandler
83	83
84	84		// Popup handling
85		-	factory port.WebViewFactory
86		-	popupConfig *entity.PopupBehaviorConfig
87		-	pendingPopups map[port.WebViewID]*PendingPopup
88		-	namedPopups map[namedPopupKey]*namedPopupState
89		-	popupOAuth map[port.WebViewID]*popupOAuthState
90		-	popupRefresh map[entity.PaneID]*time.Timer
91		-	popupMu sync.RWMutex
	85	+	factory port.WebViewFactory
	86	+	popupConfig *entity.PopupBehaviorConfig
	87	+	pendingPopups map[port.WebViewID]*PendingPopup
	88	+	namedPopups map[namedPopupKey]*namedPopupState
	89	+	popupOAuth map[port.WebViewID]*popupOAuthState
	90	+	popupRefresh map[entity.PaneID]*time.Timer
	91	+	relatedPopupUnsupported bool
	92	+	relatedPopupSupportDetected bool
	93	+	popupMu sync.RWMutex
92	94
93	95		// Callback to insert popup into workspace (avoids circular dependency)
94	96		onInsertPopup func(ctx context.Context, input InsertPopupInput) error


@@ -82,13 +82,15 @@ type Coordinator struct {
82		gestureActionHandler input.ActionHandler	82		gestureActionHandler input.ActionHandler
83			83
84		// Popup handling	84		// Popup handling
85	-	factory port.WebViewFactory	85	+	factory port.WebViewFactory
86	-	popupConfig *entity.PopupBehaviorConfig	86	+	popupConfig *entity.PopupBehaviorConfig
87	-	pendingPopups map[port.WebViewID]*PendingPopup	87	+	pendingPopups map[port.WebViewID]*PendingPopup
88	-	namedPopups map[namedPopupKey]*namedPopupState	88	+	namedPopups map[namedPopupKey]*namedPopupState
89	-	popupOAuth map[port.WebViewID]*popupOAuthState	89	+	popupOAuth map[port.WebViewID]*popupOAuthState
90	-	popupRefresh map[entity.PaneID]*time.Timer	90	+	popupRefresh map[entity.PaneID]*time.Timer
91	-	popupMu sync.RWMutex	91	+	relatedPopupUnsupported bool
			92	+	relatedPopupSupportDetected bool
			93	+	popupMu sync.RWMutex
92			94
93		// Callback to insert popup into workspace (avoids circular dependency)	95		// Callback to insert popup into workspace (avoids circular dependency)
94		onInsertPopup func(ctx context.Context, input InsertPopupInput) error	96		onInsertPopup func(ctx context.Context, input InsertPopupInput) error

M internal/ui/coordinator/content/popup.go +37 -2


@@ -2,6 +2,7 @@ package content
2	2
3	3		import (
4	4		"context"
	5	+	"errors"
5	6		"fmt"
6	7		neturl "net/url"
7	8		"strings"

@@ -218,6 +219,11 @@ func (c *Coordinator) SetPopupConfig(
218	219		c.factory = factory
219	220		c.popupConfig = popupConfig
220	221		c.generateID = generateID
	222	+
	223	+	c.popupMu.Lock()
	224	+	c.relatedPopupUnsupported = false
	225	+	c.relatedPopupSupportDetected = false
	226	+	c.popupMu.Unlock()
221	227		}
222	228
223	229		// SetOnInsertPopup sets the callback to insert popups into the workspace.

@@ -303,6 +309,26 @@ func normalizePopupTargetURIForFallback(rawTargetURI string) string {
303	309		return redirectParsed.String()
304	310		}
305	311
	312	+	func (c *Coordinator) relatedPopupSupportDisabled() bool {
	313	+	c.popupMu.RLock()
	314	+	defer c.popupMu.RUnlock()
	315	+	return c.relatedPopupSupportDetected && c.relatedPopupUnsupported
	316	+	}
	317	+
	318	+	func (c *Coordinator) markRelatedPopupUnsupported() {
	319	+	c.popupMu.Lock()
	320	+	defer c.popupMu.Unlock()
	321	+	c.relatedPopupSupportDetected = true
	322	+	c.relatedPopupUnsupported = true
	323	+	}
	324	+
	325	+	func (c *Coordinator) markRelatedPopupSupported() {
	326	+	c.popupMu.Lock()
	327	+	defer c.popupMu.Unlock()
	328	+	c.relatedPopupSupportDetected = true
	329	+	c.relatedPopupUnsupported = false
	330	+	}
	331	+
306	332		// createPopupWebView prefers a related WebView so popups can share the
307	333		// parent session/context. If the engine does not support related popup views,
308	334		// it gracefully falls back to a regular WebView so target="_blank" and

@@ -320,26 +346,35 @@ func (c *Coordinator) createPopupWebView(
320	346		log := logging.FromContext(ctx)
321	347		relatedErr := error(nil)
322	348
323		-	if !noJavaScriptAccess {
	349	+	if !noJavaScriptAccess && !c.relatedPopupSupportDisabled() {
324	350		popupWV, err := c.factory.CreateRelated(ctx, parentID)
325	351		if err == nil && popupWV != nil {
	352	+	c.markRelatedPopupSupported()
326	353		return popupWV, targetURI, nil
327	354		}
328	355		if err == nil {
329	356		err = fmt.Errorf("related popup webview factory returned nil without error")
330	357		}
331	358		relatedErr = err
	359	+	if errors.Is(err, port.ErrRelatedWebViewUnsupported) {
	360	+	c.markRelatedPopupUnsupported()
	361	+	}
332	362
333	363		log.Debug().
334	364		Err(err).
335	365		Uint64("parent_webview_id", uint64(parentID)).
336	366		Str("target_uri", logging.TruncateURL(targetURI, logURLMaxLen)).
337	367		Msg("related popup webview unavailable, falling back to regular webview")
338		-	} else {
	368	+	} else if noJavaScriptAccess {
339	369		log.Debug().
340	370		Uint64("parent_webview_id", uint64(parentID)).
341	371		Str("target_uri", logging.TruncateURL(targetURI, logURLMaxLen)).
342	372		Msg("popup requested no JavaScript opener access, creating regular webview")
	373	+	} else {
	374	+	log.Debug().
	375	+	Uint64("parent_webview_id", uint64(parentID)).
	376	+	Str("target_uri", logging.TruncateURL(targetURI, logURLMaxLen)).
	377	+	Msg("related popup webviews known unsupported, creating regular webview")
343	378		}
344	379
345	380		popupWV, fallbackErr := c.factory.Create(ctx)

 import (
 	"context"
+	"errors"
 	"fmt"
 	neturl "net/url"
 	"strings"
 	c.factory = factory
 	c.popupConfig = popupConfig
 	c.generateID = generateID
+	c.popupMu.Lock()
+	c.relatedPopupUnsupported = false
+	c.relatedPopupSupportDetected = false
+	c.popupMu.Unlock()
 }
 // SetOnInsertPopup sets the callback to insert popups into the workspace.
 	return redirectParsed.String()
 }
+func (c *Coordinator) relatedPopupSupportDisabled() bool {
+	c.popupMu.RLock()
+	defer c.popupMu.RUnlock()
+	return c.relatedPopupSupportDetected && c.relatedPopupUnsupported
+}
+func (c *Coordinator) markRelatedPopupUnsupported() {
+	c.popupMu.Lock()
+	defer c.popupMu.Unlock()
+	c.relatedPopupSupportDetected = true
+	c.relatedPopupUnsupported = true
+}
+func (c *Coordinator) markRelatedPopupSupported() {
+	c.popupMu.Lock()
+	defer c.popupMu.Unlock()
+	c.relatedPopupSupportDetected = true
+	c.relatedPopupUnsupported = false
+}
 // createPopupWebView prefers a related WebView so popups can share the
 // parent session/context. If the engine does not support related popup views,
 // it gracefully falls back to a regular WebView so target="_blank" and
 	log := logging.FromContext(ctx)
 	relatedErr := error(nil)
-	if !noJavaScriptAccess {
+	if !noJavaScriptAccess && !c.relatedPopupSupportDisabled() {
 		popupWV, err := c.factory.CreateRelated(ctx, parentID)
 		if err == nil && popupWV != nil {
+			c.markRelatedPopupSupported()
 			return popupWV, targetURI, nil
 		}
 		if err == nil {
 			err = fmt.Errorf("related popup webview factory returned nil without error")
 		}
 		relatedErr = err
+		if errors.Is(err, port.ErrRelatedWebViewUnsupported) {
+			c.markRelatedPopupUnsupported()
+		}
 		log.Debug().
 			Err(err).
 			Uint64("parent_webview_id", uint64(parentID)).
 			Str("target_uri", logging.TruncateURL(targetURI, logURLMaxLen)).
 			Msg("related popup webview unavailable, falling back to regular webview")
-	} else {
+	} else if noJavaScriptAccess {
 		log.Debug().
 			Uint64("parent_webview_id", uint64(parentID)).
 			Str("target_uri", logging.TruncateURL(targetURI, logURLMaxLen)).
 			Msg("popup requested no JavaScript opener access, creating regular webview")
+	} else {
+		log.Debug().
+			Uint64("parent_webview_id", uint64(parentID)).
+			Str("target_uri", logging.TruncateURL(targetURI, logURLMaxLen)).
+			Msg("related popup webviews known unsupported, creating regular webview")
 	}
 	popupWV, fallbackErr := c.factory.Create(ctx)

M internal/ui/coordinator/content/popup_test.go +52 -0


@@ -181,6 +181,58 @@ func TestHandlePopupCreate_UsesRegularWebViewWhenPopupDisablesJavaScriptAccess(t
181	181		require.Same(t, popupWV, created)
182	182		}
183	183
	184	+	func TestHandlePopupCreate_SkipsRelatedCreateAfterUnsupportedFactoryError(t *testing.T) {
	185	+	ctx := context.Background()
	186	+	parentPaneID := entity.PaneID("parent-pane")
	187	+	parentWV := mocks.NewMockWebView(t)
	188	+	parentWV.EXPECT().ID().Return(port.WebViewID(101)).Twice()
	189	+
	190	+	firstPopupWV := mocks.NewMockWebView(t)
	191	+	firstPopupWV.EXPECT().ID().Return(port.WebViewID(202)).Once()
	192	+	firstPopupWV.EXPECT().Generation().Return(uint64(1)).Once()
	193	+	firstPopupWV.EXPECT().SetCallbacks(mock.Anything).Once()
	194	+	firstPopupWV.EXPECT().IsLoading().Return(false).Once()
	195	+	firstPopupWV.EXPECT().URI().Return("").Once()
	196	+	firstPopupWV.EXPECT().LoadURI(mock.Anything, "https://example.com/first").Return(nil).Once()
	197	+
	198	+	secondPopupWV := mocks.NewMockWebView(t)
	199	+	secondPopupWV.EXPECT().ID().Return(port.WebViewID(203)).Once()
	200	+	secondPopupWV.EXPECT().Generation().Return(uint64(1)).Once()
	201	+	secondPopupWV.EXPECT().SetCallbacks(mock.Anything).Once()
	202	+	secondPopupWV.EXPECT().IsLoading().Return(false).Once()
	203	+	secondPopupWV.EXPECT().URI().Return("").Once()
	204	+	secondPopupWV.EXPECT().LoadURI(mock.Anything, "https://example.com/second").Return(nil).Once()
	205	+
	206	+	factory := mocks.NewMockWebViewFactory(t)
	207	+	factory.EXPECT().CreateRelated(mock.Anything, port.WebViewID(101)).Return(nil, port.ErrRelatedWebViewUnsupported).Once()
	208	+	factory.EXPECT().Create(mock.Anything).Return(firstPopupWV, nil).Once()
	209	+	factory.EXPECT().Create(mock.Anything).Return(secondPopupWV, nil).Once()
	210	+
	211	+	c := &Coordinator{
	212	+	webViews: make(map[entity.PaneID]port.WebView),
	213	+	pendingPopups: make(map[port.WebViewID]*PendingPopup),
	214	+	popupOAuth: make(map[port.WebViewID]*popupOAuthState),
	215	+	}
	216	+	c.SetPopupConfig(factory, nil, nil)
	217	+	c.SetOnInsertPopup(func(_ context.Context, input InsertPopupInput) error {
	218	+	return nil
	219	+	})
	220	+
	221	+	first := c.handlePopupCreate(ctx, parentPaneID, parentWV, port.PopupRequest{
	222	+	TargetURI: "https://example.com/first",
	223	+	FrameName: "_blank",
	224	+	IsUserGesture: true,
	225	+	})
	226	+	second := c.handlePopupCreate(ctx, parentPaneID, parentWV, port.PopupRequest{
	227	+	TargetURI: "https://example.com/second",
	228	+	FrameName: "_blank",
	229	+	IsUserGesture: true,
	230	+	})
	231	+
	232	+	require.Same(t, firstPopupWV, first)
	233	+	require.Same(t, secondPopupWV, second)
	234	+	}
	235	+
184	236		func TestHandlePopupCreate_FallsBackToRegularWebViewWhenRelatedCreateFails(t *testing.T) {
185	237		ctx := context.Background()
186	238		parentPaneID := entity.PaneID("parent-pane")


@@ -181,6 +181,58 @@ func TestHandlePopupCreate_UsesRegularWebViewWhenPopupDisablesJavaScriptAccess(t
181	require.Same(t, popupWV, created)	181		require.Same(t, popupWV, created)
182	}	182		}
183		183
		184	+	func TestHandlePopupCreate_SkipsRelatedCreateAfterUnsupportedFactoryError(t *testing.T) {
		185	+	ctx := context.Background()
		186	+	parentPaneID := entity.PaneID("parent-pane")
		187	+	parentWV := mocks.NewMockWebView(t)
		188	+	parentWV.EXPECT().ID().Return(port.WebViewID(101)).Twice()
		189	+
		190	+	firstPopupWV := mocks.NewMockWebView(t)
		191	+	firstPopupWV.EXPECT().ID().Return(port.WebViewID(202)).Once()
		192	+	firstPopupWV.EXPECT().Generation().Return(uint64(1)).Once()
		193	+	firstPopupWV.EXPECT().SetCallbacks(mock.Anything).Once()
		194	+	firstPopupWV.EXPECT().IsLoading().Return(false).Once()
		195	+	firstPopupWV.EXPECT().URI().Return("").Once()
		196	+	firstPopupWV.EXPECT().LoadURI(mock.Anything, "https://example.com/first").Return(nil).Once()
		197	+
		198	+	secondPopupWV := mocks.NewMockWebView(t)
		199	+	secondPopupWV.EXPECT().ID().Return(port.WebViewID(203)).Once()
		200	+	secondPopupWV.EXPECT().Generation().Return(uint64(1)).Once()
		201	+	secondPopupWV.EXPECT().SetCallbacks(mock.Anything).Once()
		202	+	secondPopupWV.EXPECT().IsLoading().Return(false).Once()
		203	+	secondPopupWV.EXPECT().URI().Return("").Once()
		204	+	secondPopupWV.EXPECT().LoadURI(mock.Anything, "https://example.com/second").Return(nil).Once()
		205	+
		206	+	factory := mocks.NewMockWebViewFactory(t)
		207	+	factory.EXPECT().CreateRelated(mock.Anything, port.WebViewID(101)).Return(nil, port.ErrRelatedWebViewUnsupported).Once()
		208	+	factory.EXPECT().Create(mock.Anything).Return(firstPopupWV, nil).Once()
		209	+	factory.EXPECT().Create(mock.Anything).Return(secondPopupWV, nil).Once()
		210	+
		211	+	c := &Coordinator{
		212	+	webViews: make(map[entity.PaneID]port.WebView),
		213	+	pendingPopups: make(map[port.WebViewID]*PendingPopup),
		214	+	popupOAuth: make(map[port.WebViewID]*popupOAuthState),
		215	+	}
		216	+	c.SetPopupConfig(factory, nil, nil)
		217	+	c.SetOnInsertPopup(func(_ context.Context, input InsertPopupInput) error {
		218	+	return nil
		219	+	})
		220	+
		221	+	first := c.handlePopupCreate(ctx, parentPaneID, parentWV, port.PopupRequest{
		222	+	TargetURI: "https://example.com/first",
		223	+	FrameName: "_blank",
		224	+	IsUserGesture: true,
		225	+	})
		226	+	second := c.handlePopupCreate(ctx, parentPaneID, parentWV, port.PopupRequest{
		227	+	TargetURI: "https://example.com/second",
		228	+	FrameName: "_blank",
		229	+	IsUserGesture: true,
		230	+	})
		231	+
		232	+	require.Same(t, firstPopupWV, first)
		233	+	require.Same(t, secondPopupWV, second)
		234	+	}
		235	+
184	func TestHandlePopupCreate_FallsBackToRegularWebViewWhenRelatedCreateFails(t *testing.T) {	236		func TestHandlePopupCreate_FallsBackToRegularWebViewWhenRelatedCreateFails(t *testing.T) {
185	ctx := context.Background()	237		ctx := context.Background()
186	parentPaneID := entity.PaneID("parent-pane")	238		parentPaneID := entity.PaneID("parent-pane")