5163049 refactor(M2): replace any with typed interfaces in Engine port · dumber

M internal/application/port/engine.go +16 -6


@@ -127,10 +127,10 @@ type Engine interface {
127	127		RegisterHandlers(ctx context.Context, deps HandlerDependencies) error
128	128
129	129		// RegisterAccentHandlers registers accent/dead-key input handlers.
130		-	RegisterAccentHandlers(ctx context.Context, handler any) error
	130	+	RegisterAccentHandlers(ctx context.Context, handler AccentKeyHandler) error
131	131
132	132		// ConfigureDownloads sets up download handling for this engine.
133		-	ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler DownloadEventHandler, prepareUC any) error
	133	+	ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler DownloadEventHandler, preparer DownloadPreparer) error
134	134
135	135		// OnToolkitReady is called after the UI toolkit has initialized.
136	136		OnToolkitReady(ctx context.Context) error

@@ -139,15 +139,25 @@ type Engine interface {
139	139		UpdateAppearance(ctx context.Context, r, g, b, alpha float64) error
140	140
141	141		// UpdateSettings applies runtime config changes to engine internals.
142		-	UpdateSettings(ctx context.Context, cfg any) error
	142	+	UpdateSettings(ctx context.Context, update EngineSettingsUpdate) error
	143	+	}
	144	+
	145	+	// EngineSettingsUpdate carries a runtime config change to the engine.
	146	+	// Raw holds the implementation-specific config object; the engine type-asserts
	147	+	// to its concrete type (e.g. *config.Config for the WebKit engine).
	148	+	// This is the only intentional use of `any` in the Engine port.
	149	+	type EngineSettingsUpdate struct {
	150	+	// Raw holds the implementation-specific config.
	151	+	// WebKit engine expects *config.Config.
	152	+	Raw any
143	153		}
144	154
145	155		// HandlerDependencies holds use cases needed by WebUI message handlers.
146	156		type HandlerDependencies struct {
147		-	HistoryUC any
148		-	FavoritesUC any
	157	+	HistoryUC HomepageHistory
	158	+	FavoritesUC HomepageFavorites
149	159		Clipboard Clipboard
150		-	ConfigGetter func() any
	160	+	AutoCopyConfig AutoCopyConfig
151	161		OnClipboardCopied func(textLen int)
152	162		}
153	163

 	RegisterHandlers(ctx context.Context, deps HandlerDependencies) error
 	// RegisterAccentHandlers registers accent/dead-key input handlers.
-	RegisterAccentHandlers(ctx context.Context, handler any) error
+	RegisterAccentHandlers(ctx context.Context, handler AccentKeyHandler) error
 	// ConfigureDownloads sets up download handling for this engine.
-	ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler DownloadEventHandler, prepareUC any) error
+	ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler DownloadEventHandler, preparer DownloadPreparer) error
 	// OnToolkitReady is called after the UI toolkit has initialized.
 	OnToolkitReady(ctx context.Context) error
 	UpdateAppearance(ctx context.Context, r, g, b, alpha float64) error
 	// UpdateSettings applies runtime config changes to engine internals.
-	UpdateSettings(ctx context.Context, cfg any) error
+	UpdateSettings(ctx context.Context, update EngineSettingsUpdate) error
+}
+// EngineSettingsUpdate carries a runtime config change to the engine.
+// Raw holds the implementation-specific config object; the engine type-asserts
+// to its concrete type (e.g. *config.Config for the WebKit engine).
+// This is the only intentional use of `any` in the Engine port.
+type EngineSettingsUpdate struct {
+	// Raw holds the implementation-specific config.
+	// WebKit engine expects *config.Config.
+	Raw any
 }
 // HandlerDependencies holds use cases needed by WebUI message handlers.
 type HandlerDependencies struct {
-	HistoryUC         any
+	HistoryUC         HomepageHistory
-	FavoritesUC       any
+	FavoritesUC       HomepageFavorites
 	Clipboard         Clipboard
-	ConfigGetter      func() any
+	AutoCopyConfig    AutoCopyConfig
 	OnClipboardCopied func(textLen int)
 }

M internal/bootstrap/engine.go +5 -21


@@ -54,34 +54,18 @@ func BuildEngine(input EngineInput) (port.Engine, error) {
54	54		input.Ctx, cfg, opts, wkCfg,
55	55		input.ThemeManager, input.ColorResolver, input.Logger,
56	56		func(ctx context.Context, router *webkit.MessageRouter, deps port.HandlerDependencies) error {
57		-	var historyUC port.HomepageHistory
58		-	if deps.HistoryUC != nil {
59		-	historyUC, _ = deps.HistoryUC.(port.HomepageHistory)
60		-	}
61		-	var favoritesUC port.HomepageFavorites
62		-	if deps.FavoritesUC != nil {
63		-	favoritesUC, _ = deps.FavoritesUC.(port.HomepageFavorites)
64		-	}
65		-	var autoCopyConfig port.AutoCopyConfig
66		-	if deps.ConfigGetter != nil {
67		-	autoCopyConfig, _ = deps.ConfigGetter().(port.AutoCopyConfig)
68		-	}
69	57		return handlers.RegisterAll(ctx, router, handlers.Config{
70		-	HistoryUC: historyUC,
71		-	FavoritesUC: favoritesUC,
	58	+	HistoryUC: deps.HistoryUC,
	59	+	FavoritesUC: deps.FavoritesUC,
72	60		Clipboard: deps.Clipboard,
73		-	AutoCopyConfig: autoCopyConfig,
	61	+	AutoCopyConfig: deps.AutoCopyConfig,
74	62		SaveConfig: saveConfigFunc,
75	63		KeybindingsHandler: keybindingsHandler,
76	64		OnClipboardCopied: deps.OnClipboardCopied,
77	65		})
78	66		},
79		-	func(ctx context.Context, router *webkit.MessageRouter, handler any) error {
80		-	accentHandler, ok := handler.(port.AccentKeyHandler)
81		-	if !ok {
82		-	return fmt.Errorf("handler does not implement port.AccentKeyHandler")
83		-	}
84		-	return handlers.RegisterAccentHandlers(ctx, router, accentHandler)
	67	+	func(ctx context.Context, router *webkit.MessageRouter, handler port.AccentKeyHandler) error {
	68	+	return handlers.RegisterAccentHandlers(ctx, router, handler)
85	69		},
86	70		)
87	71		case "cef":

 			input.Ctx, cfg, opts, wkCfg,
 			input.ThemeManager, input.ColorResolver, input.Logger,
 			func(ctx context.Context, router *webkit.MessageRouter, deps port.HandlerDependencies) error {
-				var historyUC port.HomepageHistory
-				if deps.HistoryUC != nil {
-					historyUC, _ = deps.HistoryUC.(port.HomepageHistory)
-				}
-				var favoritesUC port.HomepageFavorites
-				if deps.FavoritesUC != nil {
-					favoritesUC, _ = deps.FavoritesUC.(port.HomepageFavorites)
-				}
-				var autoCopyConfig port.AutoCopyConfig
-				if deps.ConfigGetter != nil {
-					autoCopyConfig, _ = deps.ConfigGetter().(port.AutoCopyConfig)
-				}
 				return handlers.RegisterAll(ctx, router, handlers.Config{
-					HistoryUC:          historyUC,
+					HistoryUC:          deps.HistoryUC,
-					FavoritesUC:        favoritesUC,
+					FavoritesUC:        deps.FavoritesUC,
 					Clipboard:          deps.Clipboard,
-					AutoCopyConfig:     autoCopyConfig,
+					AutoCopyConfig:     deps.AutoCopyConfig,
 					SaveConfig:         saveConfigFunc,
 					KeybindingsHandler: keybindingsHandler,
 					OnClipboardCopied:  deps.OnClipboardCopied,
 				})
 			},
-			func(ctx context.Context, router *webkit.MessageRouter, handler any) error {
+			func(ctx context.Context, router *webkit.MessageRouter, handler port.AccentKeyHandler) error {
-				accentHandler, ok := handler.(port.AccentKeyHandler)
+				return handlers.RegisterAccentHandlers(ctx, router, handler)
-				if !ok {
-					return fmt.Errorf("handler does not implement port.AccentKeyHandler")
-				}
-				return handlers.RegisterAccentHandlers(ctx, router, accentHandler)
 			},
 		)
 	case "cef":

M internal/infrastructure/webkit/download_handler.go +14 -15


@@ -7,7 +7,6 @@ import (
7	7		"sync"
8	8
9	9		"github.com/bnema/dumber/internal/application/port"
10		-	"github.com/bnema/dumber/internal/application/usecase"
11	10		downloadutil "github.com/bnema/dumber/internal/domain/download"
12	11		"github.com/bnema/dumber/internal/logging"
13	12		"github.com/bnema/puregotk-webkit/webkit"

@@ -20,26 +19,26 @@ const (
20	19
21	20		// DownloadHandler manages WebKit downloads and notifies the UI layer.
22	21		type DownloadHandler struct {
23		-	downloadPath string
24		-	eventHandler port.DownloadEventHandler
25		-	prepareDownloadUC *usecase.PrepareDownloadUseCase
26		-	mu sync.RWMutex
	22	+	downloadPath string
	23	+	eventHandler port.DownloadEventHandler
	24	+	preparer port.DownloadPreparer
	25	+	mu sync.RWMutex
27	26		}
28	27
29	28		// NewDownloadHandler creates a new download handler.
30		-	// Panics if prepareDownloadUC is nil (fail fast on misconfiguration).
	29	+	// Panics if preparer is nil (fail fast on misconfiguration).
31	30		func NewDownloadHandler(
32	31		downloadPath string,
33	32		handler port.DownloadEventHandler,
34		-	prepareDownloadUC *usecase.PrepareDownloadUseCase,
	33	+	preparer port.DownloadPreparer,
35	34		) *DownloadHandler {
36		-	if prepareDownloadUC == nil {
37		-	panic("prepareDownloadUC is required")
	35	+	if preparer == nil {
	36	+	panic("preparer is required")
38	37		}
39	38		return &DownloadHandler{
40		-	downloadPath: downloadPath,
41		-	eventHandler: handler,
42		-	prepareDownloadUC: prepareDownloadUC,
	39	+	downloadPath: downloadPath,
	40	+	eventHandler: handler,
	41	+	preparer: preparer,
43	42		}
44	43		}
45	44

@@ -57,7 +56,7 @@ func (h DownloadHandler) HandleDownload(ctx context.Context, download webkit.D
57	56		h.mu.RLock()
58	57		downloadPath := h.downloadPath
59	58		eventHandler := h.eventHandler
60		-	prepareDownloadUC := h.prepareDownloadUC
	59	+	preparer := h.preparer
61	60		h.mu.RUnlock()
62	61
63	62		// Track download state in a dedicated struct to ensure proper isolation.

@@ -80,8 +79,8 @@ func (h DownloadHandler) HandleDownload(ctx context.Context, download webkit.D
80	79		response = &uriResponseAdapter{resp: resp}
81	80		}
82	81
83		-	// Use PrepareDownloadUseCase to resolve filename
84		-	output := prepareDownloadUC.Execute(ctx, usecase.PrepareDownloadInput{
	82	+	// Use DownloadPreparer to resolve filename
	83	+	output := preparer.Execute(ctx, port.DownloadPrepareInput{
85	84		SuggestedFilename: suggestedFilename,
86	85		Response: response,
87	86		DownloadDir: downloadPath,

 	"sync"
 	"github.com/bnema/dumber/internal/application/port"
-	"github.com/bnema/dumber/internal/application/usecase"
 	downloadutil "github.com/bnema/dumber/internal/domain/download"
 	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/puregotk-webkit/webkit"
 // DownloadHandler manages WebKit downloads and notifies the UI layer.
 type DownloadHandler struct {
-	downloadPath      string
+	downloadPath string
-	eventHandler      port.DownloadEventHandler
+	eventHandler port.DownloadEventHandler
-	prepareDownloadUC *usecase.PrepareDownloadUseCase
+	preparer     port.DownloadPreparer
-	mu                sync.RWMutex
+	mu           sync.RWMutex
 }
 // NewDownloadHandler creates a new download handler.
-// Panics if prepareDownloadUC is nil (fail fast on misconfiguration).
+// Panics if preparer is nil (fail fast on misconfiguration).
 func NewDownloadHandler(
 	downloadPath string,
 	handler port.DownloadEventHandler,
-	prepareDownloadUC *usecase.PrepareDownloadUseCase,
+	preparer port.DownloadPreparer,
 ) *DownloadHandler {
-	if prepareDownloadUC == nil {
+	if preparer == nil {
-		panic("prepareDownloadUC is required")
+		panic("preparer is required")
 	}
 	return &DownloadHandler{
-		downloadPath:      downloadPath,
+		downloadPath: downloadPath,
-		eventHandler:      handler,
+		eventHandler: handler,
-		prepareDownloadUC: prepareDownloadUC,
+		preparer:     preparer,
 	}
 }
 	h.mu.RLock()
 	downloadPath := h.downloadPath
 	eventHandler := h.eventHandler
-	prepareDownloadUC := h.prepareDownloadUC
+	preparer := h.preparer
 	h.mu.RUnlock()
 	// Track download state in a dedicated struct to ensure proper isolation.
 			response = &uriResponseAdapter{resp: resp}
 		}
-		// Use PrepareDownloadUseCase to resolve filename
+		// Use DownloadPreparer to resolve filename
-		output := prepareDownloadUC.Execute(ctx, usecase.PrepareDownloadInput{
+		output := preparer.Execute(ctx, port.DownloadPrepareInput{
 			SuggestedFilename: suggestedFilename,
 			Response:          response,
 			DownloadDir:       downloadPath,

M internal/infrastructure/webkit/engine.go +8 -13


@@ -5,7 +5,6 @@ import (
5	5		"fmt"
6	6
7	7		"github.com/bnema/dumber/internal/application/port"
8		-	"github.com/bnema/dumber/internal/application/usecase"
9	8		"github.com/bnema/dumber/internal/infrastructure/config"
10	9		"github.com/bnema/dumber/internal/infrastructure/filtering"
11	10		"github.com/rs/zerolog"

@@ -27,7 +26,7 @@ type Engine struct {
27	26
28	27		// Handler registrars - injected at construction to avoid import cycles.
29	28		handlerRegistrar func(ctx context.Context, router *MessageRouter, deps port.HandlerDependencies) error
30		-	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler any) error
	29	+	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler port.AccentKeyHandler) error
31	30		}
32	31
33	32		// Compile-time check that Engine implements port.Engine.

@@ -112,7 +111,7 @@ func (e *Engine) RegisterHandlers(ctx context.Context, deps port.HandlerDependen
112	111		}
113	112
114	113		// RegisterAccentHandlers registers accent/dead-key input handlers.
115		-	func (e *Engine) RegisterAccentHandlers(ctx context.Context, handler any) error {
	114	+	func (e *Engine) RegisterAccentHandlers(ctx context.Context, handler port.AccentKeyHandler) error {
116	115		if e.messageRouter == nil {
117	116		return fmt.Errorf("message router not initialized")
118	117		}

@@ -123,15 +122,11 @@ func (e *Engine) RegisterAccentHandlers(ctx context.Context, handler any) error
123	122		}
124	123
125	124		// ConfigureDownloads sets up download handling.
126		-	func (e *Engine) ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, prepareUC any) error {
	125	+	func (e *Engine) ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error {
127	126		if e.wkCtx == nil {
128	127		return fmt.Errorf("webkit context not initialized")
129	128		}
130		-	uc, ok := prepareUC.(*usecase.PrepareDownloadUseCase)
131		-	if !ok {
132		-	return fmt.Errorf("prepareUC does not implement PrepareDownloadUseCase")
133		-	}
134		-	handler := NewDownloadHandler(downloadPath, eventHandler, uc)
	129	+	handler := NewDownloadHandler(downloadPath, eventHandler, preparer)
135	130		e.wkCtx.SetDownloadHandler(ctx, handler)
136	131		return nil
137	132		}

@@ -156,13 +151,13 @@ func (e *Engine) UpdateAppearance(_ context.Context, r, g, b, alpha float64) err
156	151		}
157	152
158	153		// UpdateSettings applies runtime config changes to engine settings.
159		-	func (e *Engine) UpdateSettings(ctx context.Context, cfg any) error {
160		-	configCfg, ok := cfg.(*config.Config)
	154	+	func (e *Engine) UpdateSettings(ctx context.Context, update port.EngineSettingsUpdate) error {
	155	+	cfg, ok := update.Raw.(*config.Config)
161	156		if !ok {
162		-	return fmt.Errorf("expected *config.Config, got %T", cfg)
	157	+	return fmt.Errorf("UpdateSettings: expected *config.Config, got %T", update.Raw)
163	158		}
164	159		if e.settings != nil {
165		-	e.settings.UpdateFromConfig(ctx, configCfg)
	160	+	e.settings.UpdateFromConfig(ctx, cfg)
166	161		}
167	162		return nil
168	163		}

 	"fmt"
 	"github.com/bnema/dumber/internal/application/port"
-	"github.com/bnema/dumber/internal/application/usecase"
 	"github.com/bnema/dumber/internal/infrastructure/config"
 	"github.com/bnema/dumber/internal/infrastructure/filtering"
 	"github.com/rs/zerolog"
 	// Handler registrars - injected at construction to avoid import cycles.
 	handlerRegistrar       func(ctx context.Context, router *MessageRouter, deps port.HandlerDependencies) error
-	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler any) error
+	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler port.AccentKeyHandler) error
 }
 // Compile-time check that Engine implements port.Engine.
 }
 // RegisterAccentHandlers registers accent/dead-key input handlers.
-func (e *Engine) RegisterAccentHandlers(ctx context.Context, handler any) error {
+func (e *Engine) RegisterAccentHandlers(ctx context.Context, handler port.AccentKeyHandler) error {
 	if e.messageRouter == nil {
 		return fmt.Errorf("message router not initialized")
 	}
 }
 // ConfigureDownloads sets up download handling.
-func (e *Engine) ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, prepareUC any) error {
+func (e *Engine) ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error {
 	if e.wkCtx == nil {
 		return fmt.Errorf("webkit context not initialized")
 	}
-	uc, ok := prepareUC.(*usecase.PrepareDownloadUseCase)
+	handler := NewDownloadHandler(downloadPath, eventHandler, preparer)
-	if !ok {
-		return fmt.Errorf("prepareUC does not implement PrepareDownloadUseCase")
-	}
-	handler := NewDownloadHandler(downloadPath, eventHandler, uc)
 	e.wkCtx.SetDownloadHandler(ctx, handler)
 	return nil
 }
 }
 // UpdateSettings applies runtime config changes to engine settings.
-func (e *Engine) UpdateSettings(ctx context.Context, cfg any) error {
+func (e *Engine) UpdateSettings(ctx context.Context, update port.EngineSettingsUpdate) error {
-	configCfg, ok := cfg.(*config.Config)
+	cfg, ok := update.Raw.(*config.Config)
 	if !ok {
-		return fmt.Errorf("expected *config.Config, got %T", cfg)
+		return fmt.Errorf("UpdateSettings: expected *config.Config, got %T", update.Raw)
 	}
 	if e.settings != nil {
-		e.settings.UpdateFromConfig(ctx, configCfg)
+		e.settings.UpdateFromConfig(ctx, cfg)
 	}
 	return nil
 }

M internal/infrastructure/webkit/engine_init.go +1 -1


@@ -27,7 +27,7 @@ func NewEngine(
27	27		colorResolver port.ColorSchemeResolver,
28	28		logger zerolog.Logger,
29	29		handlerRegistrar func(ctx context.Context, router *MessageRouter, deps port.HandlerDependencies) error,
30		-	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler any) error,
	30	+	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler port.AccentKeyHandler) error,
31	31		) (*Engine, error) {
32	32		// --- Hardware survey and performance profile resolution ---
33	33		perfSettings := engineSurveyHardwareAndResolveProfile(ctx, cfg, logger)


@@ -27,7 +27,7 @@ func NewEngine(
27		colorResolver port.ColorSchemeResolver,	27		colorResolver port.ColorSchemeResolver,
28		logger zerolog.Logger,	28		logger zerolog.Logger,
29		handlerRegistrar func(ctx context.Context, router *MessageRouter, deps port.HandlerDependencies) error,	29		handlerRegistrar func(ctx context.Context, router *MessageRouter, deps port.HandlerDependencies) error,
30	-	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler any) error,	30	+	accentHandlerRegistrar func(ctx context.Context, router *MessageRouter, handler port.AccentKeyHandler) error,
31		) (*Engine, error) {	31		) (*Engine, error) {
32		// --- Hardware survey and performance profile resolution ---	32		// --- Hardware survey and performance profile resolution ---
33		perfSettings := engineSurveyHardwareAndResolveProfile(ctx, cfg, logger)	33		perfSettings := engineSurveyHardwareAndResolveProfile(ctx, cfg, logger)

M internal/ui/app.go +16 -7


@@ -181,12 +181,10 @@ func New(deps Dependencies) (App, error) {
181	181		}
182	182		// Register message handlers through the engine.
183	183		if err := deps.Engine.RegisterHandlers(ctx, port.HandlerDependencies{
184		-	HistoryUC: deps.HistoryUC,
185		-	FavoritesUC: deps.FavoritesUC,
186		-	Clipboard: deps.Clipboard,
187		-	ConfigGetter: func() any {
188		-	return config.Get()
189		-	},
	184	+	HistoryUC: deps.HistoryUC,
	185	+	FavoritesUC: deps.FavoritesUC,
	186	+	Clipboard: deps.Clipboard,
	187	+	AutoCopyConfig: &configAutoCopyAdapter{},
190	188		OnClipboardCopied: func(textLen int) {
191	189		cb := glib.SourceFunc(func(_ uintptr) bool {
192	190		if app.appToaster != nil {

@@ -621,6 +619,17 @@ func (d *downloadEventAdapter) OnDownloadEvent(ctx context.Context, event port.D
621	619		glib.IdleAdd(&cb, 0)
622	620		}
623	621
	622	+	// configAutoCopyAdapter implements port.AutoCopyConfig by reading the live config.
	623	+	type configAutoCopyAdapter struct{}
	624	+
	625	+	func (a *configAutoCopyAdapter) IsAutoCopyEnabled() bool {
	626	+	cfg := config.Get()
	627	+	if cfg == nil {
	628	+	return false
	629	+	}
	630	+	return cfg.Clipboard.AutoCopyOnSelection
	631	+	}
	632	+
624	633		func (a *App) initKeyboardHandler(ctx context.Context) {
625	634		log := logging.FromContext(ctx)
626	635

@@ -3063,7 +3072,7 @@ func (a App) applyAppearanceConfig(ctx context.Context, cfg config.Config) {
3063	3072		}
3064	3073
3065	3074		if a.engine != nil {
3066		-	_ = a.engine.UpdateSettings(ctx, cfg)
	3075	+	_ = a.engine.UpdateSettings(ctx, port.EngineSettingsUpdate{Raw: cfg})
3067	3076		}
3068	3077
3069	3078		// Apply settings to existing webviews via coordinator

 	}
 	// Register message handlers through the engine.
 	if err := deps.Engine.RegisterHandlers(ctx, port.HandlerDependencies{
-		HistoryUC:   deps.HistoryUC,
+		HistoryUC:      deps.HistoryUC,
-		FavoritesUC: deps.FavoritesUC,
+		FavoritesUC:    deps.FavoritesUC,
-		Clipboard:   deps.Clipboard,
+		Clipboard:      deps.Clipboard,
-		ConfigGetter: func() any {
+		AutoCopyConfig: &configAutoCopyAdapter{},
-			return config.Get()
-		},
 		OnClipboardCopied: func(textLen int) {
 			cb := glib.SourceFunc(func(_ uintptr) bool {
 				if app.appToaster != nil {
 	glib.IdleAdd(&cb, 0)
 }
+// configAutoCopyAdapter implements port.AutoCopyConfig by reading the live config.
+type configAutoCopyAdapter struct{}
+func (a *configAutoCopyAdapter) IsAutoCopyEnabled() bool {
+	cfg := config.Get()
+	if cfg == nil {
+		return false
+	}
+	return cfg.Clipboard.AutoCopyOnSelection
+}
 func (a *App) initKeyboardHandler(ctx context.Context) {
 	log := logging.FromContext(ctx)
 	}
 	if a.engine != nil {
-		_ = a.engine.UpdateSettings(ctx, cfg)
+		_ = a.engine.UpdateSettings(ctx, port.EngineSettingsUpdate{Raw: cfg})
 	}
 	// Apply settings to existing webviews via coordinator