Merge pull request #304 from bnema/feat/gtk-history-sidebar

feat(history): add native GTK Ctrl+H sidebar

commit: cbe806a78844d4bdbbdb628bacb737b4ace709a6
author: bnema · 4mo ago · 2026-06-13 09:45 UTC
committer: GitHub · 4mo ago · 2026-06-13 09:45 UTC
merge of: ac3d540 + 217c6f0 · diff against the first parent
signature: GPG UnverifiedB5690EEEBB952194 The key is unknown

31 files · +5035 -88

M .mockery.yaml +1 -0


@@ -65,6 +65,7 @@ packages:
65	65		EntryInputTarget: {}
66	66		HomepageFavorites: {}
67	67		HomepageHistory: {}
	68	+	HistorySidebarHistory: {}
68	69		AllKeybindingsResetter: {}
69	70		KeybindingResetter: {}
70	71		KeybindingSetter: {}

M docs/reference/keybindings.md +2 -2


@@ -83,7 +83,7 @@ These work outside modal modes:
83	83		\| Action \| Keys \|
84	84		\|--------\|------\|
85	85		\| Toggle floating pane \| `Alt+F` \|
86		-	\| Toggle History system view in right split (may conflict with the browser's default History shortcut; behavior can vary by browser) \| `Ctrl+H` \|
	86	+	\| Toggle History sidebar (native GTK sidebar panel only). Ctrl+H may conflict with the browser's default History shortcut; behavior can vary by browser. \| `Ctrl+H` \|
87	87		\| Toggle Favorites system view in right split \| unbound by default \|
88	88		\| Toggle Config system view in right split \| unbound by default \|
89	89		\| Close pane (or release floating pane) \| `Ctrl+W` \|

@@ -96,7 +96,7 @@ These work outside modal modes:
96	96
97	97		- `Alt+F` is the only floating-pane shortcut enabled by default.
98	98		- `Alt+F` toggles floating visibility and keeps floating pane state intact.
99		-	- `Ctrl+H` toggles `dumb://history`: it focuses an existing History pane, opens it in a right split if missing, or closes it when already active. Depending on the browser, the default History shortcut may intercept `Ctrl+H`, so behavior can vary.
	99	+	- `Ctrl+H` toggles the native GTK history sidebar. The sidebar shows browsing history grouped by day with search/filter, keyboard navigation (arrows, Home/End, Ctrl+arrows for day jumps), and activation modes (Enter to navigate while keeping the sidebar open, Ctrl+Enter to navigate while keeping the sidebar open, Shift+Enter to open in a new split). If the native sidebar is unavailable, the shortcut returns an error instead of falling back to `dumb://history`.
100	100		- `Ctrl+W` closes the active pane; when the floating pane is active, it fully releases that floating session.
101	101		- Any URL shortcut (for example `Alt+G`) must be defined explicitly in `workspace.floating_pane.profiles`.
102	102		- Floating profile shortcuts support modifier combos with `ctrl`, `shift`, and `alt` (for example `ctrl+shift+y` or `ctrl+alt+m`).

A internal/application/port/history_sidebar.go +16 -0

@@ -0,0 +1,16 @@
	1	+	package port
	2	+
	3	+	import (
	4	+	"context"
	5	+
	6	+	"github.com/bnema/dumber/internal/application/dto"
	7	+	"github.com/bnema/dumber/internal/domain/entity"
	8	+	)
	9	+
	10	+	// HistorySidebarHistory provides the narrow history operations needed by the
	11	+	// native GTK history sidebar.
	12	+	type HistorySidebarHistory interface {
	13	+	GetRecent(ctx context.Context, limit, offset int) ([]*entity.HistoryEntry, error)
	14	+	Search(ctx context.Context, input dto.HistorySearchInput) (*dto.HistorySearchOutput, error)
	15	+	Delete(ctx context.Context, id int64) error
	16	+	}

M internal/application/usecase/search_history.go +3 -1


@@ -15,8 +15,10 @@ import (
15	15		"github.com/bnema/dumber/internal/logging"
16	16		)
17	17
18		-	// Compile-time check: SearchHistoryUseCase must satisfy port.HomepageHistory.
	18	+	// Compile-time checks: SearchHistoryUseCase must satisfy the application
	19	+	// history ports used by WebUI handlers and the native GTK history sidebar.
19	20		var _ port.HomepageHistory = (*SearchHistoryUseCase)(nil)
	21	+	var _ port.HistorySidebarHistory = (*SearchHistoryUseCase)(nil)
20	22
21	23		const (
22	24		historyWindowDuration = 24 * time.Hour

M internal/infrastructure/config/defaults.go +5 -3


@@ -21,7 +21,8 @@ const (
21	21		defaultMaxLogFiles = 100 // session log files
22	22
23	23		// Appearance defaults
24		-	defaultFontSize = 16 // points
	24	+	defaultSidebarWidth = 320 // px, clamped to [280, 380]
	25	+	defaultFontSize = 16 // points
25	26		defaultExternalThemeProvider = "noctalia"
26	27		defaultExternalThemeFormat = "colors-json"
27	28		defaultExternalThemeColorsFilename = "colors.json"

@@ -251,8 +252,9 @@ func DefaultConfig() *Config {
251	252		GLRenderingMode: GLRenderingModeAuto,
252	253		},
253	254		},
254		-	DefaultWebpageZoom: 1.2, // 120% default zoom for better readability
255		-	DefaultUIScale: defaultUIScale, // 1.0 = 100%, 2.0 = 200%
	255	+	DefaultWebpageZoom: 1.2, // 120% default zoom for better readability
	256	+	DefaultUIScale: defaultUIScale, // 1.0 = 100%, 2.0 = 200%
	257	+	SidebarWidth: defaultSidebarWidth, // 320px, clamped to [280, 380]
256	258		Workspace: WorkspaceConfig{
257	259		NewPaneURL: defaultNewPaneURL,
258	260		SwitchToTabOnMove: true,

M internal/infrastructure/config/loader.go +1 -0


@@ -664,6 +664,7 @@ func (m Manager) setAppearanceDefaults(defaults Config) {
664	664		func (m Manager) setZoomAndScaleDefaults(defaults Config) {
665	665		m.viper.SetDefault("default_webpage_zoom", defaults.DefaultWebpageZoom)
666	666		m.viper.SetDefault("default_ui_scale", defaults.DefaultUIScale)
	667	+	m.viper.SetDefault("sidebar_width", defaults.SidebarWidth)
667	668		}
668	669
669	670		func (m Manager) setWorkspaceDefaults(defaults Config) {

M internal/infrastructure/config/migrate.go +4 -4


@@ -283,10 +283,10 @@ const (
283	283
284	284		// Config format constants.
285	285		const (
286		-	configFormatTOML = "toml"
287		-	configFormatYAML = "yaml"
288		-	configFormatJSON = "json"
289		-	databasePathKey = "database.path"
	286	+	configFormatTOML = "toml"
	287	+	configFormatYAML = "yaml"
	288	+	configFormatJSON = "json"
	289	+	databasePathKey = "database.path"
290	290		)
291	291
292	292		type defaultActionMap struct {

M internal/infrastructure/config/schema.go +3 -0


@@ -95,6 +95,9 @@ type Config struct {
95	95		DefaultWebpageZoom float64 `mapstructure:"default_webpage_zoom" yaml:"default_webpage_zoom" toml:"default_webpage_zoom"`
96	96		// DefaultUIScale sets the default UI scale for GTK widgets (1.0 = 100%, 2.0 = 200%)
97	97		DefaultUIScale float64 `mapstructure:"default_ui_scale" yaml:"default_ui_scale" toml:"default_ui_scale"`
	98	+	// SidebarWidth sets the preferred width (px) for the history sidebar.
	99	+	// Clamped to [280, 380] at runtime. 0 means use default (320).
	100	+	SidebarWidth int `mapstructure:"sidebar_width" yaml:"sidebar_width" toml:"sidebar_width"`
98	101		// Workspace defines workspace, pane, and tab handling behavior.
99	102		Workspace WorkspaceConfig `mapstructure:"workspace" yaml:"workspace" toml:"workspace"`
100	103		// Session controls session persistence and restoration.

M internal/infrastructure/config/schema_provider.go +8 -0


@@ -161,6 +161,14 @@ func (SchemaProvider) getAppearanceKeys(defaults Config) []entity.ConfigKeyInf
161	161		Range: "0.5-3.0",
162	162		Section: SectionAppearance,
163	163		},
	164	+	{
	165	+	Key: "sidebar_width",
	166	+	Type: "int",
	167	+	Default: fmt.Sprintf("%d", defaults.SidebarWidth),
	168	+	Description: "Preferred width (px) for the history sidebar. 0 = default",
	169	+	Range: "0 or 280-380",
	170	+	Section: SectionAppearance,
	171	+	},
164	172		{
165	173		Key: "appearance.light_palette.*",
166	174		Type: "string",

M internal/infrastructure/config/validation.go +3 -0


@@ -104,6 +104,9 @@ func validateAppearance(config *Config) []string {
104	104		if config.DefaultUIScale < 0.5 \|\| config.DefaultUIScale > 3.0 {
105	105		validationErrors = append(validationErrors, "default_ui_scale must be between 0.5 and 3.0")
106	106		}
	107	+	if config.SidebarWidth != 0 && (config.SidebarWidth < 280 \|\| config.SidebarWidth > 380) {
	108	+	validationErrors = append(validationErrors, "sidebar_width must be between 280 and 380, or 0 for default")
	109	+	}
107	110		validationErrors = append(validationErrors, validateExternalTheme(config)...)
108	111		return validationErrors
109	112		}

M internal/ui/app.go +18 -0


@@ -2222,6 +2222,20 @@ func (a App) activeWorkspaceViewForBrowserWindow(bw browserWindow) *component.
2222	2222		return a.workspaceViews[tab.ID]
2223	2223		}
2224	2224
	2225	+	// hideAndRestoreFocusForBrowserWindow hides the sidebar and restores focus to
	2226	+	// the active content pane/webview of the given browser window.
	2227	+	func (a App) hideAndRestoreFocusForBrowserWindow(bw browserWindow) {
	2228	+	if bw == nil {
	2229	+	return
	2230	+	}
	2231	+	bw.hideHistorySidebar()
	2232	+	if wsView := a.activeWorkspaceViewForBrowserWindow(bw); wsView != nil {
	2233	+	if ws := a.activeWorkspaceForBrowserWindow(bw); ws != nil {
	2234	+	wsView.FocusPane(ws.ActivePaneID)
	2235	+	}
	2236	+	}
	2237	+	}
	2238	+
2225	2239		// tabTargetForBrowserWindow returns a coordinator.TabTarget scoped to the given browser window.
2226	2240		// It does not allocate a TabList; callers that mutate tabs should use
2227	2241		// ensureTabTargetForBrowserWindow instead.

@@ -3508,6 +3522,7 @@ func (a *App) wireKeyboardActions() {
3508	3522		}
3509	3523		return a.EjectActivePaneToWindow(ctx, paneID)
3510	3524		})
	3525	+	a.kbDispatcher.SetOnToggleHistorySidebar(a.toggleHistorySidebarAction)
3511	3526		a.kbDispatcher.SetOnToggleFloatingPane(func(ctx context.Context) error {
3512	3527		return a.ToggleFloatingPane(ctx)
3513	3528		})

@@ -5037,6 +5052,9 @@ func (a *App) initConfigWatcher(ctx context.Context) {
5037	5052		if bw == nil {
5038	5053		continue
5039	5054		}
	5055	+	// Reapply sidebar width from live config (reloads after sidebar_width
	5056	+	// changes in the config file).
	5057	+	bw.applySidebarWidthConfig(a)
5040	5058		if bw.keyboardHandler != nil {
5041	5059		bw.keyboardHandler.ReloadShortcuts(ctx, &a.deps.Config.Workspace, &a.deps.Config.Session)
5042	5060		}

M internal/ui/browser_window.go +18 -0


@@ -37,6 +37,8 @@ type browserWindow struct {
37	37		globalShortcutHandler *input.GlobalShortcutHandler
38	38		permissionDialog port.PermissionDialogPresenter
39	39		webrtcIndicator *component.WebRTCPermissionIndicator
	40	+	historySidebar *component.HistorySidebar
	41	+	sidebarVisible bool
40	42		}
41	43
42	44		func (bw *browserWindow) detachInputForDestroy() {

@@ -63,6 +65,12 @@ func (bw *browserWindow) clearShellState() {
63	65		if bw == nil {
64	66		return
65	67		}
	68	+	// Destroy the history sidebar before releasing the reference so its
	69	+	// context, debounce timer, callbacks, and in-flight goroutines are
	70	+	// cleaned up before the window itself is torn down.
	71	+	if bw.historySidebar != nil {
	72	+	bw.historySidebar.Destroy()
	73	+	}
66	74		bw.appToaster = nil
67	75		bw.modeToaster = nil
68	76		bw.borderMgr = nil

@@ -76,6 +84,7 @@ func (bw *browserWindow) clearShellState() {
76	84		bw.globalShortcutHandler = nil
77	85		bw.permissionDialog = nil
78	86		bw.webrtcIndicator = nil
	87	+	bw.historySidebar = nil
79	88		}
80	89
81	90		func (bw browserWindow) initChrome(ctx context.Context, a App) {

@@ -88,6 +97,7 @@ func (bw browserWindow) initChrome(ctx context.Context, a App) {
88	97		bw.initAccentPicker(ctx, a)
89	98		bw.initSessionManager(ctx, a)
90	99		bw.initTabPicker(ctx, a)
	100	+	bw.initHistorySidebar(ctx, a)
91	101		}
92	102
93	103		func (bw browserWindow) initToasterOverlay(a App) {

@@ -259,6 +269,14 @@ func (bw *browserWindow) ensureTabs() {
259	269		}
260	270		}
261	271
	272	+	func (a App) hasBrowserWindow(target browserWindow) bool {
	273	+	if a == nil \|\| target == nil \|\| a.browserWindows == nil {
	274	+	return false
	275	+	}
	276	+	bw, ok := a.browserWindows[target.id]
	277	+	return ok && bw == target
	278	+	}
	279	+
262	280		func (a App) registerBrowserWindow(bw browserWindow) {
263	281		if bw == nil {
264	282		return

A internal/ui/browser_window_history_sidebar.go +152 -0

@@ -0,0 +1,152 @@
	1	+	package ui
	2	+
	3	+	import (
	4	+	"context"
	5	+	"fmt"
	6	+
	7	+	"github.com/bnema/dumber/internal/application/port"
	8	+	"github.com/bnema/dumber/internal/application/usecase"
	9	+	"github.com/bnema/dumber/internal/logging"
	10	+	"github.com/bnema/dumber/internal/ui/component"
	11	+	"github.com/bnema/dumber/internal/ui/window"
	12	+	)
	13	+
	14	+	// initHistorySidebar creates and mounts the history sidebar into the
	15	+	// browser window's sidebar container. The sidebar is hidden by default.
	16	+	func (bw browserWindow) initHistorySidebar(ctx context.Context, a App) {
	17	+	if bw == nil \|\| a == nil \|\| bw.mainWindow == nil \|\| a.deps == nil \|\| a.deps.HistoryUC == nil {
	18	+	return
	19	+	}
	20	+	log := logging.FromContext(ctx)
	21	+
	22	+	cfg := a.buildHistorySidebarConfig(bw)
	23	+
	24	+	sidebar := component.NewHistorySidebar(ctx, cfg)
	25	+	if sidebar == nil {
	26	+	log.Warn().Msg("failed to create history sidebar")
	27	+	return
	28	+	}
	29	+
	30	+	bw.historySidebar = sidebar
	31	+
	32	+	// Mount into the main window's sidebar box.
	33	+	bw.mainWindow.SetSidebarWidget(sidebar.Widget())
	34	+	bw.historySidebar.Hide()
	35	+	bw.mainWindow.SetSidebarVisible(false)
	36	+	bw.sidebarVisible = false
	37	+
	38	+	// Apply sidebar width from config, falling back to the default 320px.
	39	+	// The width is clamped to [280, 380] by SetSidebarWidth internally.
	40	+	bw.applySidebarWidthConfig(a)
	41	+
	42	+	log.Debug().Msg("history sidebar initialized")
	43	+	}
	44	+
	45	+	// buildHistorySidebarConfig constructs the HistorySidebarConfig for the given
	46	+	// browser window. Extracted from initHistorySidebar for testability.
	47	+	func (a App) buildHistorySidebarConfig(bw browserWindow) component.HistorySidebarConfig {
	48	+	var historyUC port.HistorySidebarHistory
	49	+	if a.deps != nil {
	50	+	historyUC = a.deps.HistoryUC
	51	+	}
	52	+
	53	+	return component.HistorySidebarConfig{
	54	+	HistoryUC: historyUC,
	55	+	OnNavigate: func(navCtx context.Context, url string) error {
	56	+	return a.navigateHistorySidebarSelection(navCtx, bw, url)
	57	+	},
	58	+	OnNavigateKeepOpen: func(navCtx context.Context, url string) error {
	59	+	return a.navigateHistorySidebarSelection(navCtx, bw, url)
	60	+	},
	61	+	OnOpenInNewPane: func(splitCtx context.Context, url string) error {
	62	+	if a.wsCoord == nil \|\| !a.hasBrowserWindow(bw) {
	63	+	return nil
	64	+	}
	65	+	a.activateBrowserWindow(bw)
	66	+	return a.wsCoord.SplitWithURL(splitCtx, usecase.SplitRight, url)
	67	+	},
	68	+	OnClose: func() {
	69	+	a.hideAndRestoreFocusForBrowserWindow(bw)
	70	+	},
	71	+	}
	72	+	}
	73	+
	74	+	func (a App) navigateHistorySidebarSelection(ctx context.Context, bw browserWindow, url string) error {
	75	+	if a == nil \|\| bw == nil \|\| !a.hasBrowserWindow(bw) {
	76	+	return nil
	77	+	}
	78	+	return a.navigateFromBrowserWindow(ctx, bw, url)
	79	+	}
	80	+
	81	+	// toggleHistorySidebar toggles sidebar visibility.
	82	+	func (bw *browserWindow) toggleHistorySidebar() {
	83	+	if bw == nil \|\| bw.historySidebar == nil {
	84	+	return
	85	+	}
	86	+
	87	+	if bw.sidebarVisible {
	88	+	bw.hideHistorySidebar()
	89	+	} else {
	90	+	bw.showHistorySidebar()
	91	+	}
	92	+	}
	93	+
	94	+	// showHistorySidebar makes the sidebar visible and grabs focus for the search
	95	+	// entry.
	96	+	func (bw *browserWindow) showHistorySidebar() {
	97	+	if bw == nil \|\| bw.historySidebar == nil \|\| bw.mainWindow == nil {
	98	+	return
	99	+	}
	100	+	bw.historySidebar.Show()
	101	+	bw.mainWindow.SetSidebarVisible(true)
	102	+	bw.sidebarVisible = true
	103	+	}
	104	+
	105	+	// hideHistorySidebar hides the sidebar. Callers should also restore focus
	106	+	// to the active content pane after calling this.
	107	+	func (bw *browserWindow) hideHistorySidebar() {
	108	+	if bw == nil \|\| bw.historySidebar == nil \|\| bw.mainWindow == nil {
	109	+	return
	110	+	}
	111	+	bw.historySidebar.Hide()
	112	+	bw.mainWindow.SetSidebarVisible(false)
	113	+	bw.sidebarVisible = false
	114	+	}
	115	+
	116	+	// historySidebarWidthConfig extracts the config-backed sidebar width and
	117	+	// applies it via the MainWindow.SetSidebarWidth path. It is called during
	118	+	// initialization and can be reused if config is reloaded at runtime.
	119	+	func historySidebarWidthConfig(widthPx int) window.SidebarWidthConfig {
	120	+	cfg := window.SidebarDefaultWidth()
	121	+	if widthPx > 0 {
	122	+	cfg.WidthPx = widthPx
	123	+	}
	124	+	return cfg
	125	+	}
	126	+
	127	+	// applySidebarWidthConfig applies the config-backed sidebar width to the
	128	+	// main window's sidebar.
	129	+	func (bw browserWindow) applySidebarWidthConfig(a App) {
	130	+	if bw == nil \|\| bw.mainWindow == nil \|\| a == nil \|\| a.deps == nil \|\| a.deps.Config == nil {
	131	+	return
	132	+	}
	133	+	bw.mainWindow.SetSidebarWidth(historySidebarWidthConfig(a.deps.Config.SidebarWidth))
	134	+	}
	135	+
	136	+	// toggleHistorySidebarAction is the keyboard-action handler for toggling the
	137	+	// history sidebar on the last focused browser window.
	138	+	func (a *App) toggleHistorySidebarAction(ctx context.Context) error {
	139	+	bw := a.lastFocusedBrowserWindow()
	140	+	if bw == nil {
	141	+	return fmt.Errorf("history sidebar unavailable: no focused browser window")
	142	+	}
	143	+	if bw.historySidebar == nil {
	144	+	return fmt.Errorf("history sidebar unavailable: native sidebar not initialized")
	145	+	}
	146	+	if bw.sidebarVisible {
	147	+	a.hideAndRestoreFocusForBrowserWindow(bw)
	148	+	return nil
	149	+	}
	150	+	bw.toggleHistorySidebar()
	151	+	return nil
	152	+	}

A internal/ui/browser_window_history_sidebar_test.go +891 -0

@@ -0,0 +1,891 @@
	1	+	package ui
	2	+
	3	+	import (
	4	+	"context"
	5	+	"testing"
	6	+
	7	+	"github.com/bnema/dumber/internal/application/usecase"
	8	+	"github.com/bnema/dumber/internal/domain/entity"
	9	+	"github.com/bnema/dumber/internal/infrastructure/config"
	10	+	"github.com/bnema/dumber/internal/ui/component"
	11	+	"github.com/bnema/dumber/internal/ui/coordinator"
	12	+	contentcoord "github.com/bnema/dumber/internal/ui/coordinator/content"
	13	+	"github.com/bnema/dumber/internal/ui/dispatcher"
	14	+	"github.com/bnema/dumber/internal/ui/input"
	15	+	"github.com/bnema/dumber/internal/ui/window"
	16	+	"github.com/stretchr/testify/assert"
	17	+	"github.com/stretchr/testify/require"
	18	+	)
	19	+
	20	+	// =============================================================================
	21	+	// History sidebar integration tests
	22	+	// =============================================================================
	23	+
	24	+	// TestHistorySidebarConfig_OnNavigateNavigatesActivePaneAndKeepsSidebar verifies
	25	+	// that the default OnNavigate callback targets the owning browser window's
	26	+	// active pane and keeps the sidebar visible.
	27	+	func TestHistorySidebarConfig_OnNavigateNavigatesActivePaneAndKeepsSidebar(t *testing.T) {
	28	+	ctx := t.Context()
	29	+
	30	+	// Build two browser windows with independent tabs and panes.
	31	+	tab1 := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(entity.PaneID("pane-1")))
	32	+	tab2 := entity.NewTab(entity.TabID("tab-2"), entity.WorkspaceID("ws-2"), entity.NewPane(entity.PaneID("pane-2")))
	33	+
	34	+	firstTabs := entity.NewTabList()
	35	+	firstTabs.Add(tab1)
	36	+	firstTabs.SetActive(tab1.ID)
	37	+	first := &browserWindow{id: "window-1", tabs: firstTabs}
	38	+
	39	+	secondTabs := entity.NewTabList()
	40	+	secondTabs.Add(tab2)
	41	+	secondTabs.SetActive(tab2.ID)
	42	+	second := &browserWindow{id: "window-2", tabs: secondTabs}
	43	+
	44	+	// Create fake webviews, one per pane.
	45	+	fakeWv1 := &fakeRecordingWebView{id: 1}
	46	+	fakeWv2 := &fakeRecordingWebView{id: 2}
	47	+
	48	+	contentCoord := contentcoord.NewCoordinator(ctx, nil, nil, nil, nil, nil, nil, nil)
	49	+	contentCoord.RegisterPopupWebView(entity.PaneID("pane-1"), fakeWv1)
	50	+	contentCoord.RegisterPopupWebView(entity.PaneID("pane-2"), fakeWv2)
	51	+
	52	+	navCoord := coordinator.NewNavigationCoordinator(ctx, nil, contentCoord)
	53	+
	54	+	app := &App{
	55	+	tabs: entity.NewTabList(),
	56	+	browserWindows: map[string]*browserWindow{first.id: first, second.id: second},
	57	+	lastFocusedWindowID: first.id,
	58	+	contentCoord: contentCoord,
	59	+	navCoord: navCoord,
	60	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	61	+	tab1.ID: {},
	62	+	tab2.ID: {},
	63	+	},
	64	+	}
	65	+	app.tabs.Add(tab1)
	66	+	app.tabs.Add(tab2)
	67	+
	68	+	second.mainWindow = &window.MainWindow{}
	69	+	second.historySidebar = &component.HistorySidebar{}
	70	+	second.sidebarVisible = true
	71	+
	72	+	cfg := app.buildHistorySidebarConfig(second)
	73	+	navigateURL := "https://example.com"
	74	+	err := cfg.OnNavigate(ctx, navigateURL)
	75	+	require.NoError(t, err, "OnNavigate should succeed")
	76	+
	77	+	// The second window's webview must have received the navigation.
	78	+	assert.True(t, fakeWv2.loadURICalled, "second window webview should receive navigation")
	79	+	assert.Equal(t, navigateURL, fakeWv2.loadURILastURI)
	80	+	assert.True(t, second.sidebarVisible, "default history activation should keep the sidebar visible")
	81	+
	82	+	// The first window's webview must NOT have been touched (stale-focus guard).
	83	+	assert.False(t, fakeWv1.loadURICalled, "first window webview must not receive navigation from second window callback")
	84	+	}
	85	+
	86	+	// TestHistorySidebarConfig_OnNavigateKeepOpenNavigatesWithoutClosing verifies
	87	+	// that the OnNavigateKeepOpen callback (Ctrl+Enter) navigates the owning window's
	88	+	// active pane and keeps the sidebar visible.
	89	+	func TestHistorySidebarConfig_OnNavigateKeepOpenNavigatesWithoutClosing(t *testing.T) {
	90	+	ctx := t.Context()
	91	+
	92	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(entity.PaneID("pane-1")))
	93	+	bwTabs := entity.NewTabList()
	94	+	bwTabs.Add(tab)
	95	+	bwTabs.SetActive(tab.ID)
	96	+
	97	+	bw := &browserWindow{
	98	+	id: "window-1",
	99	+	tabs: bwTabs,
	100	+	mainWindow: &window.MainWindow{},
	101	+	historySidebar: &component.HistorySidebar{},
	102	+	sidebarVisible: true,
	103	+	}
	104	+
	105	+	contentCoord := contentcoord.NewCoordinator(ctx, nil, nil, nil, nil, nil, nil, nil)
	106	+	fakeWv := &fakeRecordingWebView{id: 1}
	107	+	contentCoord.RegisterPopupWebView(entity.PaneID("pane-1"), fakeWv)
	108	+	navCoord := coordinator.NewNavigationCoordinator(ctx, nil, contentCoord)
	109	+
	110	+	app := &App{
	111	+	tabs: entity.NewTabList(),
	112	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	113	+	contentCoord: contentCoord,
	114	+	navCoord: navCoord,
	115	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	116	+	tab.ID: {},
	117	+	},
	118	+	}
	119	+	app.tabs.Add(tab)
	120	+
	121	+	cfg := app.buildHistorySidebarConfig(bw)
	122	+	navigateURL := "https://keep-open.com"
	123	+	err := cfg.OnNavigateKeepOpen(ctx, navigateURL)
	124	+	require.NoError(t, err)
	125	+	assert.True(t, fakeWv.loadURICalled)
	126	+	assert.Equal(t, navigateURL, fakeWv.loadURILastURI, "Ctrl+Enter navigation should go to the URL")
	127	+	assert.True(t, bw.sidebarVisible, "Ctrl+Enter navigation should keep the sidebar visible")
	128	+	}
	129	+
	130	+	// TestHistorySidebar_OwnershipOnMultiWindowNavigation verifies that when
	131	+	// multiple browser windows have history sidebars, navigation targets the
	132	+	// correct owning window's active pane. This tests the stale-focus scenario
	133	+	// where a different window is globally focused.
	134	+	func TestHistorySidebar_OwnershipOnMultiWindowNavigation(t *testing.T) {
	135	+	ctx := t.Context()
	136	+
	137	+	// Two windows, each with their own tab and pane.
	138	+	tab1 := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(entity.PaneID("pane-1")))
	139	+	tab2 := entity.NewTab(entity.TabID("tab-2"), entity.WorkspaceID("ws-2"), entity.NewPane(entity.PaneID("pane-2")))
	140	+
	141	+	firstTabs := entity.NewTabList()
	142	+	firstTabs.Add(tab1)
	143	+	firstTabs.SetActive(tab1.ID)
	144	+	first := &browserWindow{id: "window-1", tabs: firstTabs}
	145	+
	146	+	secondTabs := entity.NewTabList()
	147	+	secondTabs.Add(tab2)
	148	+	secondTabs.SetActive(tab2.ID)
	149	+	second := &browserWindow{id: "window-2", tabs: secondTabs}
	150	+
	151	+	fakeWv1 := &fakeRecordingWebView{id: 1}
	152	+	fakeWv2 := &fakeRecordingWebView{id: 2}
	153	+
	154	+	contentCoord := contentcoord.NewCoordinator(ctx, nil, nil, nil, nil, nil, nil, nil)
	155	+	contentCoord.RegisterPopupWebView(entity.PaneID("pane-1"), fakeWv1)
	156	+	contentCoord.RegisterPopupWebView(entity.PaneID("pane-2"), fakeWv2)
	157	+
	158	+	navCoord := coordinator.NewNavigationCoordinator(ctx, nil, contentCoord)
	159	+
	160	+	app := &App{
	161	+	tabs: entity.NewTabList(),
	162	+	browserWindows: map[string]*browserWindow{first.id: first, second.id: second},
	163	+	lastFocusedWindowID: first.id, // STALE: first is globally focused
	164	+	contentCoord: contentCoord,
	165	+	navCoord: navCoord,
	166	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	167	+	tab1.ID: {},
	168	+	tab2.ID: {},
	169	+	},
	170	+	}
	171	+	app.tabs.Add(tab1)
	172	+	app.tabs.Add(tab2)
	173	+
	174	+	// Navigation from the SECOND window should target pane-2 even though
	175	+	// the first window is globally focused (stale focus).
	176	+	err := app.navigateFromBrowserWindow(ctx, second, "https://second-window.com")
	177	+	require.NoError(t, err)
	178	+
	179	+	// Second window's webview must receive the navigation.
	180	+	assert.True(t, fakeWv2.loadURICalled, "second window webview should receive navigation")
	181	+	assert.Equal(t, "https://second-window.com", fakeWv2.loadURILastURI)
	182	+
	183	+	// First window's webview must NOT have been touched.
	184	+	assert.False(t, fakeWv1.loadURICalled, "first window webview should NOT receive navigation when second was targeted")
	185	+	}
	186	+
	187	+	// =============================================================================
	188	+	// History sidebar toggle state tests
	189	+	// =============================================================================
	190	+
	191	+	// TestBrowserWindow_HistorySidebarToggle_NilIsNoOp verifies that when
	192	+	// browserWindow.historySidebar is nil, toggleHistorySidebar is a safe
	193	+	// no-op and sidebarVisible stays / remains false.
	194	+	func TestBrowserWindow_HistorySidebarToggle_NilIsNoOp(t *testing.T) {
	195	+	t.Parallel()
	196	+
	197	+	bw := &browserWindow{id: "test-window", sidebarVisible: false}
	198	+	require.Nil(t, bw.historySidebar, "historySidebar must be nil for this test")
	199	+
	200	+	// Should not panic even though historySidebar is nil.
	201	+	bw.toggleHistorySidebar()
	202	+	assert.False(t, bw.sidebarVisible, "sidebarVisible must remain false when historySidebar is nil")
	203	+
	204	+	// Calling again also safe.
	205	+	bw.toggleHistorySidebar()
	206	+	assert.False(t, bw.sidebarVisible, "sidebarVisible must remain false on second toggle")
	207	+	}
	208	+
	209	+	// TestBrowserWindow_HistorySidebarToggle_FlipsSidebarVisible verifies that
	210	+	// toggleHistorySidebar correctly flips sidebarVisible when the sidebar
	211	+	// has been set. Uses a zero-value HistorySidebar (all nil-checked methods
	212	+	// are safe to call).
	213	+	func TestBrowserWindow_HistorySidebarToggle_FlipsSidebarVisible(t *testing.T) {
	214	+	t.Parallel()
	215	+
	216	+	bw := &browserWindow{
	217	+	id: "test-window",
	218	+	mainWindow: &window.MainWindow{},
	219	+	historySidebar: &component.HistorySidebar{},
	220	+	sidebarVisible: false,
	221	+	}
	222	+
	223	+	bw.toggleHistorySidebar()
	224	+	assert.True(t, bw.sidebarVisible, "sidebarVisible must be true after first toggle")
	225	+
	226	+	bw.toggleHistorySidebar()
	227	+	assert.False(t, bw.sidebarVisible, "sidebarVisible must be false after second toggle")
	228	+
	229	+	bw.toggleHistorySidebar()
	230	+	assert.True(t, bw.sidebarVisible, "sidebarVisible must be true after third toggle")
	231	+	}
	232	+
	233	+	// TestBrowserWindow_HistorySidebarShowHide_TransitionsSidebarVisible
	234	+	// verifies that showHistorySidebar and hideHistorySidebar independently
	235	+	// set sidebarVisible to true and false respectively.
	236	+	func TestBrowserWindow_HistorySidebarShowHide_TransitionsSidebarVisible(t *testing.T) {
	237	+	t.Parallel()
	238	+
	239	+	bw := &browserWindow{
	240	+	id: "test-window",
	241	+	mainWindow: &window.MainWindow{},
	242	+	historySidebar: &component.HistorySidebar{},
	243	+	sidebarVisible: false,
	244	+	}
	245	+
	246	+	// Show sets visible
	247	+	bw.showHistorySidebar()
	248	+	assert.True(t, bw.sidebarVisible, "sidebarVisible must be true after show")
	249	+
	250	+	// Hide clears visible
	251	+	bw.hideHistorySidebar()
	252	+	assert.False(t, bw.sidebarVisible, "sidebarVisible must be false after hide")
	253	+
	254	+	// Redundant hide is idempotent
	255	+	bw.hideHistorySidebar()
	256	+	assert.False(t, bw.sidebarVisible, "sidebarVisible must remain false after redundant hide")
	257	+
	258	+	// Show again
	259	+	bw.showHistorySidebar()
	260	+	assert.True(t, bw.sidebarVisible, "sidebarVisible must be true after second show")
	261	+	}
	262	+
	263	+	// TestBrowserWindow_HistorySidebarShowHide_NilSidebarIsNoOp verifies that
	264	+	// show/hide do not panic when historySidebar is nil.
	265	+	func TestBrowserWindow_HistorySidebarShowHide_NilSidebarIsNoOp(t *testing.T) {
	266	+	t.Parallel()
	267	+
	268	+	bw := &browserWindow{id: "test-window"}
	269	+	require.Nil(t, bw.historySidebar)
	270	+
	271	+	// Should not panic even though historySidebar is nil.
	272	+	bw.showHistorySidebar()
	273	+	assert.False(t, bw.sidebarVisible, "sidebarVisible must remain false when nil")
	274	+
	275	+	bw.hideHistorySidebar()
	276	+	assert.False(t, bw.sidebarVisible, "sidebarVisible must remain false when nil")
	277	+	}
	278	+
	279	+	// =============================================================================
	280	+	// App wiring: toggle handler uses lastFocusedBrowserWindow
	281	+	// =============================================================================
	282	+
	283	+	// TestApp_HistorySidebarToggleHandlerUsesLastFocusedWindow verifies that
	284	+	// the toggle handler wired in App.wireKeyboardActions picks the
	285	+	// lastFocusedBrowserWindow and calls toggleHistorySidebar on it.
	286	+	func TestApp_HistorySidebarToggleHandlerUsesLastFocusedWindow(t *testing.T) {
	287	+	// Two windows, only the focused one has a history sidebar.
	288	+	focusedBW := &browserWindow{
	289	+	id: "focused",
	290	+	mainWindow: &window.MainWindow{},
	291	+	historySidebar: &component.HistorySidebar{},
	292	+	sidebarVisible: false,
	293	+	}
	294	+	otherBW := &browserWindow{
	295	+	id: "other",
	296	+	mainWindow: &window.MainWindow{},
	297	+	}
	298	+
	299	+	app := &App{
	300	+	browserWindows: map[string]*browserWindow{
	301	+	focusedBW.id: focusedBW,
	302	+	otherBW.id: otherBW,
	303	+	},
	304	+	lastFocusedWindowID: focusedBW.id,
	305	+	}
	306	+
	307	+	// Simulate the toggle handler that wireKeyboardActions registers:
	308	+	// a.kbDispatcher.SetOnToggleHistorySidebar(func(ctx context.Context) error {
	309	+	// bw := a.lastFocusedBrowserWindow()
	310	+	// ...
	311	+	// })
	312	+	bw := app.lastFocusedBrowserWindow()
	313	+	require.NotNil(t, bw, "lastFocusedBrowserWindow must not be nil")
	314	+	require.Equal(t, focusedBW.id, bw.id, "must return the focused window")
	315	+	require.NotNil(t, bw.historySidebar, "focused window must have a history sidebar")
	316	+
	317	+	// Toggle on the focused window.
	318	+	bw.toggleHistorySidebar()
	319	+	assert.True(t, bw.sidebarVisible, "sidebar on focused window must become visible")
	320	+
	321	+	// The other window must remain untouched.
	322	+	assert.False(t, otherBW.sidebarVisible, "other window sidebar must remain invisible")
	323	+
	324	+	// Toggle again: focused window sidebar hides.
	325	+	bw.toggleHistorySidebar()
	326	+	assert.False(t, bw.sidebarVisible, "sidebar on focused window must hide on second toggle")
	327	+	}
	328	+
	329	+	// TestApp_HistorySidebarToggleHandler_NilFocusedWindowIsNoOp verifies
	330	+	// that the toggle handler is safe when lastFocusedBrowserWindow returns nil.
	331	+	func TestApp_HistorySidebarToggleHandler_NilFocusedWindowIsNoOp(t *testing.T) {
	332	+	app := &App{
	333	+	browserWindows: make(map[string]*browserWindow),
	334	+	lastFocusedWindowID: "missing",
	335	+	}
	336	+
	337	+	// The handler should return early without error when bw is nil.
	338	+	bw := app.lastFocusedBrowserWindow()
	339	+	require.Nil(t, bw, "lastFocusedBrowserWindow should return nil for missing window")
	340	+	}
	341	+
	342	+	// =============================================================================
	343	+	// History sidebar config callbacks: focus restoration on close
	344	+	// =============================================================================
	345	+
	346	+	// TestHistorySidebarConfig_OnCloseHidesSidebar verifies that the OnClose
	347	+	// callback hides the sidebar for the owning browser window.
	348	+	func TestHistorySidebarConfig_OnCloseHidesSidebar(t *testing.T) {
	349	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(entity.PaneID("pane-1")))
	350	+	bwTabs := entity.NewTabList()
	351	+	bwTabs.Add(tab)
	352	+	bwTabs.SetActive(tab.ID)
	353	+
	354	+	bw := &browserWindow{
	355	+	id: "window-1",
	356	+	tabs: bwTabs,
	357	+	mainWindow: &window.MainWindow{},
	358	+	historySidebar: &component.HistorySidebar{},
	359	+	sidebarVisible: true,
	360	+	}
	361	+
	362	+	app := &App{
	363	+	tabs: entity.NewTabList(),
	364	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	365	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{tab.ID: {}},
	366	+	}
	367	+	app.tabs.Add(tab)
	368	+
	369	+	cfg := app.buildHistorySidebarConfig(bw)
	370	+	cfg.OnClose()
	371	+
	372	+	assert.False(t, bw.sidebarVisible, "sidebar must be hidden by OnClose")
	373	+	}
	374	+
	375	+	// =============================================================================
	376	+	// Dispatcher-backed Ctrl+H integration test
	377	+	// =============================================================================
	378	+
	379	+	// TestApp_HistorySidebar_ToggleThroughKeyboardDispatcher wires the real toggle
	380	+	// handler from App.wireKeyboardActions through the KeyboardDispatcher and
	381	+	// dispatches ActionToggleHistorySystemView, asserting the focused browser
	382	+	// window's sidebar visibility toggles.
	383	+	func TestApp_HistorySidebar_ToggleThroughKeyboardDispatcher(t *testing.T) {
	384	+	ctx := t.Context()
	385	+
	386	+	focusedBW := &browserWindow{
	387	+	id: "focused",
	388	+	mainWindow: &window.MainWindow{},
	389	+	historySidebar: &component.HistorySidebar{},
	390	+	sidebarVisible: false,
	391	+	}
	392	+	otherBW := &browserWindow{
	393	+	id: "other",
	394	+	mainWindow: &window.MainWindow{},
	395	+	}
	396	+
	397	+	app := &App{
	398	+	browserWindows: map[string]*browserWindow{
	399	+	focusedBW.id: focusedBW,
	400	+	otherBW.id: otherBW,
	401	+	},
	402	+	lastFocusedWindowID: focusedBW.id,
	403	+	}
	404	+
	405	+	// Create a KeyboardDispatcher and wire the production toggle handler.
	406	+	kbDispatcher := dispatcher.NewKeyboardDispatcher(
	407	+	ctx,
	408	+	&coordinator.WorkspaceCoordinator{},
	409	+	&coordinator.NavigationCoordinator{},
	410	+	nil, nil,
	411	+	dispatcher.KeyboardActions{},
	412	+	func(context.Context) entity.PaneID { return "" },
	413	+	)
	414	+
	415	+	kbDispatcher.SetOnToggleHistorySidebar(app.toggleHistorySidebarAction)
	416	+
	417	+	// First dispatch: toggle ON.
	418	+	err := kbDispatcher.Dispatch(ctx, input.ActionToggleHistorySystemView)
	419	+	require.NoError(t, err)
	420	+	assert.True(t, focusedBW.sidebarVisible, "focused window sidebar must be visible after toggle")
	421	+	assert.False(t, otherBW.sidebarVisible, "other window sidebar must remain invisible")
	422	+
	423	+	// Second dispatch: toggle OFF.
	424	+	err = kbDispatcher.Dispatch(ctx, input.ActionToggleHistorySystemView)
	425	+	require.NoError(t, err)
	426	+	assert.False(t, focusedBW.sidebarVisible, "focused window sidebar must be hidden after second toggle")
	427	+	}
	428	+
	429	+	// TestApp_HistorySidebar_ToggleThroughDispatcher_UnavailableReturnsError verifies that
	430	+	// when the focused window has no history sidebar, Ctrl+H returns a clean error.
	431	+	func TestApp_HistorySidebar_ToggleThroughDispatcher_UnavailableReturnsError(t *testing.T) {
	432	+	ctx := t.Context()
	433	+
	434	+	bw := &browserWindow{
	435	+	id: "no-sidebar",
	436	+	mainWindow: &window.MainWindow{},
	437	+	// historySidebar is nil
	438	+	}
	439	+
	440	+	app := &App{
	441	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	442	+	lastFocusedWindowID: bw.id,
	443	+	}
	444	+
	445	+	kbDispatcher := dispatcher.NewKeyboardDispatcher(
	446	+	ctx,
	447	+	&coordinator.WorkspaceCoordinator{},
	448	+	&coordinator.NavigationCoordinator{},
	449	+	nil, nil,
	450	+	dispatcher.KeyboardActions{},
	451	+	func(context.Context) entity.PaneID { return "" },
	452	+	)
	453	+
	454	+	kbDispatcher.SetOnToggleHistorySidebar(app.toggleHistorySidebarAction)
	455	+
	456	+	err := kbDispatcher.Dispatch(ctx, input.ActionToggleHistorySystemView)
	457	+	require.Error(t, err)
	458	+	require.ErrorContains(t, err, "history sidebar unavailable")
	459	+	assert.False(t, bw.sidebarVisible, "sidebar must remain invisible when not wired")
	460	+	}
	461	+
	462	+	// TestApp_HistorySidebar_ToggleThroughDispatcher_NilFocusedReturnsError verifies
	463	+	// that the toggle handler returns a clean error when there is no focused window.
	464	+	func TestApp_HistorySidebar_ToggleThroughDispatcher_NilFocusedReturnsError(t *testing.T) {
	465	+	ctx := t.Context()
	466	+
	467	+	app := &App{
	468	+	browserWindows: make(map[string]*browserWindow),
	469	+	lastFocusedWindowID: "missing",
	470	+	}
	471	+
	472	+	kbDispatcher := dispatcher.NewKeyboardDispatcher(
	473	+	ctx,
	474	+	&coordinator.WorkspaceCoordinator{},
	475	+	&coordinator.NavigationCoordinator{},
	476	+	nil, nil,
	477	+	dispatcher.KeyboardActions{},
	478	+	func(context.Context) entity.PaneID { return "" },
	479	+	)
	480	+
	481	+	kbDispatcher.SetOnToggleHistorySidebar(app.toggleHistorySidebarAction)
	482	+
	483	+	err := kbDispatcher.Dispatch(ctx, input.ActionToggleHistorySystemView)
	484	+	require.Error(t, err)
	485	+	require.ErrorContains(t, err, "history sidebar unavailable")
	486	+	}
	487	+
	488	+	// =============================================================================
	489	+	// buildHistorySidebarConfig callback seam tests
	490	+	// =============================================================================
	491	+
	492	+	// TestApp_HistorySidebarConfig_NavigateCallback verifies that the OnNavigate
	493	+	// callback from buildHistorySidebarConfig navigates the owning browser window's
	494	+	// active pane to the given URL.
	495	+	func TestApp_HistorySidebarConfig_NavigateCallbackNavigates(t *testing.T) {
	496	+	ctx := t.Context()
	497	+
	498	+	paneID := entity.PaneID("pane-1")
	499	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(paneID))
	500	+	bwTabs := entity.NewTabList()
	501	+	bwTabs.Add(tab)
	502	+	bwTabs.SetActive(tab.ID)
	503	+
	504	+	bw := &browserWindow{
	505	+	id: "window-1",
	506	+	tabs: bwTabs,
	507	+	mainWindow: &window.MainWindow{},
	508	+	historySidebar: &component.HistorySidebar{},
	509	+	sidebarVisible: true,
	510	+	}
	511	+
	512	+	fakeWv := &fakeRecordingWebView{id: 1}
	513	+	contentCoord := contentcoord.NewCoordinator(ctx, nil, nil, nil, nil, nil, nil, nil)
	514	+	contentCoord.RegisterPopupWebView(paneID, fakeWv)
	515	+	navCoord := coordinator.NewNavigationCoordinator(ctx, nil, contentCoord)
	516	+
	517	+	app := &App{
	518	+	tabs: entity.NewTabList(),
	519	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	520	+	contentCoord: contentCoord,
	521	+	navCoord: navCoord,
	522	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	523	+	tab.ID: {},
	524	+	},
	525	+	}
	526	+	app.tabs.Add(tab)
	527	+
	528	+	// Build the config using the extracted seam.
	529	+	cfg := app.buildHistorySidebarConfig(bw)
	530	+	require.NotNil(t, cfg.OnNavigate, "OnNavigate callback must be non-nil")
	531	+
	532	+	// Invoke the OnNavigate callback.
	533	+	navigateURL := "https://navigated.com"
	534	+	err := cfg.OnNavigate(ctx, navigateURL)
	535	+	require.NoError(t, err)
	536	+
	537	+	// Verify the navigation reached the correct webview.
	538	+	assert.True(t, fakeWv.loadURICalled, "webview must receive navigation")
	539	+	assert.Equal(t, navigateURL, fakeWv.loadURILastURI)
	540	+	assert.True(t, bw.sidebarVisible, "default history navigation should keep the sidebar open")
	541	+	}
	542	+
	543	+	func TestApp_NavigateHistorySidebarSelection_KeepsSidebarVisible(t *testing.T) {
	544	+	ctx := t.Context()
	545	+
	546	+	paneID := entity.PaneID("pane-1")
	547	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(paneID))
	548	+	bwTabs := entity.NewTabList()
	549	+	bwTabs.Add(tab)
	550	+	bwTabs.SetActive(tab.ID)
	551	+
	552	+	bw := &browserWindow{
	553	+	id: "window-1",
	554	+	tabs: bwTabs,
	555	+	mainWindow: &window.MainWindow{},
	556	+	historySidebar: &component.HistorySidebar{},
	557	+	sidebarVisible: true,
	558	+	}
	559	+
	560	+	fakeWv := &fakeRecordingWebView{id: 1}
	561	+	contentCoord := contentcoord.NewCoordinator(ctx, nil, nil, nil, nil, nil, nil, nil)
	562	+	contentCoord.RegisterPopupWebView(paneID, fakeWv)
	563	+	navCoord := coordinator.NewNavigationCoordinator(ctx, nil, contentCoord)
	564	+
	565	+	app := &App{
	566	+	tabs: entity.NewTabList(),
	567	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	568	+	contentCoord: contentCoord,
	569	+	navCoord: navCoord,
	570	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	571	+	tab.ID: {},
	572	+	},
	573	+	}
	574	+	app.tabs.Add(tab)
	575	+
	576	+	err := app.navigateHistorySidebarSelection(ctx, bw, "https://open.com")
	577	+	require.NoError(t, err)
	578	+	assert.True(t, fakeWv.loadURICalled)
	579	+	assert.Equal(t, "https://open.com", fakeWv.loadURILastURI)
	580	+	assert.True(t, bw.sidebarVisible, "history selection navigation should not hide the sidebar")
	581	+	}
	582	+
	583	+	// TestApp_HistorySidebarConfig_NavigateCallbackOwnership verifies that
	584	+	// OnNavigate targets the callback's owning window, not the globally focused
	585	+	// window, when they differ.
	586	+	func TestApp_HistorySidebarConfig_NavigateCallbackOwnership(t *testing.T) {
	587	+	ctx := t.Context()
	588	+
	589	+	tab1 := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(entity.PaneID("pane-1")))
	590	+	tab2 := entity.NewTab(entity.TabID("tab-2"), entity.WorkspaceID("ws-2"), entity.NewPane(entity.PaneID("pane-2")))
	591	+
	592	+	firstTabs := entity.NewTabList()
	593	+	firstTabs.Add(tab1)
	594	+	firstTabs.SetActive(tab1.ID)
	595	+	first := &browserWindow{id: "window-1", tabs: firstTabs}
	596	+
	597	+	secondTabs := entity.NewTabList()
	598	+	secondTabs.Add(tab2)
	599	+	secondTabs.SetActive(tab2.ID)
	600	+	second := &browserWindow{id: "window-2", tabs: secondTabs}
	601	+
	602	+	fakeWv1 := &fakeRecordingWebView{id: 1}
	603	+	fakeWv2 := &fakeRecordingWebView{id: 2}
	604	+
	605	+	contentCoord := contentcoord.NewCoordinator(ctx, nil, nil, nil, nil, nil, nil, nil)
	606	+	contentCoord.RegisterPopupWebView(entity.PaneID("pane-1"), fakeWv1)
	607	+	contentCoord.RegisterPopupWebView(entity.PaneID("pane-2"), fakeWv2)
	608	+	navCoord := coordinator.NewNavigationCoordinator(ctx, nil, contentCoord)
	609	+
	610	+	app := &App{
	611	+	tabs: entity.NewTabList(),
	612	+	browserWindows: map[string]*browserWindow{first.id: first, second.id: second},
	613	+	lastFocusedWindowID: first.id, // STALE: first is globally focused
	614	+	contentCoord: contentCoord,
	615	+	navCoord: navCoord,
	616	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	617	+	tab1.ID: {},
	618	+	tab2.ID: {},
	619	+	},
	620	+	}
	621	+	app.tabs.Add(tab1)
	622	+	app.tabs.Add(tab2)
	623	+
	624	+	// Build config for the SECOND window, even though first is globally focused.
	625	+	cfg := app.buildHistorySidebarConfig(second)
	626	+
	627	+	// Invoke OnNavigate — should navigate through second window's pane-2.
	628	+	err := cfg.OnNavigate(ctx, "https://ownership.com")
	629	+	require.NoError(t, err)
	630	+
	631	+	// Second window's webview must receive navigation.
	632	+	assert.True(t, fakeWv2.loadURICalled, "second window webview must receive navigation")
	633	+	assert.Equal(t, "https://ownership.com", fakeWv2.loadURILastURI)
	634	+
	635	+	// First window's webview must NOT be touched.
	636	+	assert.False(t, fakeWv1.loadURICalled, "first window webview must not receive navigation")
	637	+	}
	638	+
	639	+	// TestApp_HistorySidebarConfig_KeepOpenCallback verifies that
	640	+	// OnNavigateKeepOpen navigates the owning window without hiding the sidebar.
	641	+	func TestApp_HistorySidebarConfig_KeepOpenCallback(t *testing.T) {
	642	+	ctx := t.Context()
	643	+
	644	+	paneID := entity.PaneID("pane-1")
	645	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(paneID))
	646	+	bwTabs := entity.NewTabList()
	647	+	bwTabs.Add(tab)
	648	+	bwTabs.SetActive(tab.ID)
	649	+
	650	+	bw := &browserWindow{
	651	+	id: "window-1",
	652	+	tabs: bwTabs,
	653	+	mainWindow: &window.MainWindow{},
	654	+	historySidebar: &component.HistorySidebar{},
	655	+	sidebarVisible: true,
	656	+	}
	657	+
	658	+	fakeWv := &fakeRecordingWebView{id: 1}
	659	+	contentCoord := contentcoord.NewCoordinator(ctx, nil, nil, nil, nil, nil, nil, nil)
	660	+	contentCoord.RegisterPopupWebView(paneID, fakeWv)
	661	+	navCoord := coordinator.NewNavigationCoordinator(ctx, nil, contentCoord)
	662	+
	663	+	app := &App{
	664	+	tabs: entity.NewTabList(),
	665	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	666	+	contentCoord: contentCoord,
	667	+	navCoord: navCoord,
	668	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	669	+	tab.ID: {},
	670	+	},
	671	+	}
	672	+	app.tabs.Add(tab)
	673	+
	674	+	cfg := app.buildHistorySidebarConfig(bw)
	675	+
	676	+	// OnNavigateKeepOpen navigates but does NOT close the sidebar.
	677	+	navigateURL := "https://keep-open.com"
	678	+	err := cfg.OnNavigateKeepOpen(ctx, navigateURL)
	679	+	require.NoError(t, err)
	680	+
	681	+	assert.True(t, fakeWv.loadURICalled, "webview must receive navigation")
	682	+	assert.Equal(t, navigateURL, fakeWv.loadURILastURI)
	683	+
	684	+	// Sidebar must remain visible (keep-open contract).
	685	+	assert.True(t, bw.sidebarVisible, "sidebar must stay visible after keep-open navigation")
	686	+	}
	687	+
	688	+	// TestApp_HistorySidebarConfig_OpenInNewPaneCallback verifies that
	689	+	// OnOpenInNewPane activates the owning browser window and creates a split
	690	+	// with the target URL.
	691	+	func TestApp_HistorySidebarConfig_OpenInNewPaneCallback(t *testing.T) {
	692	+	ctx := t.Context()
	693	+
	694	+	paneID := entity.PaneID("pane-1")
	695	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(paneID))
	696	+	bwTabs := entity.NewTabList()
	697	+	bwTabs.Add(tab)
	698	+	bwTabs.SetActive(tab.ID)
	699	+
	700	+	ws := entity.NewWorkspace("ws-1", entity.NewPane(paneID))
	701	+	ws.ActivePaneID = paneID
	702	+	tab.Workspace = ws
	703	+
	704	+	bw := &browserWindow{id: "window-1", tabs: bwTabs}
	705	+
	706	+	panesUC := usecase.NewManagePanesUseCase(func() string { return "pane-2" })
	707	+	wsCoord := coordinator.NewWorkspaceCoordinator(ctx, coordinator.WorkspaceCoordinatorConfig{
	708	+	PanesUC: panesUC,
	709	+	GetActiveWS: func() (entity.Workspace, component.WorkspaceView) {
	710	+	return ws, nil
	711	+	},
	712	+	})
	713	+
	714	+	app := &App{
	715	+	tabs: entity.NewTabList(),
	716	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	717	+	wsCoord: wsCoord,
	718	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	719	+	tab.ID: {},
	720	+	},
	721	+	}
	722	+	app.tabs.Add(tab)
	723	+
	724	+	cfg := app.buildHistorySidebarConfig(bw)
	725	+
	726	+	// OnOpenInNewPane should activate the owning window and split with URL.
	727	+	splitURL := "https://shift-enter.com"
	728	+	err := cfg.OnOpenInNewPane(ctx, splitURL)
	729	+	require.NoError(t, err)
	730	+
	731	+	// After split, workspace should have 2 panes.
	732	+	require.Equal(t, 2, ws.PaneCount(), "workspace should have 2 panes after split")
	733	+
	734	+	// The new pane should have the split URL.
	735	+	allPanes := ws.AllPanes()
	736	+	var newPane *entity.Pane
	737	+	for _, p := range allPanes {
	738	+	if p != nil && p.ID != paneID {
	739	+	newPane = p
	740	+	break
	741	+	}
	742	+	}
	743	+	require.NotNil(t, newPane, "new pane must exist after split")
	744	+	assert.Equal(t, splitURL, newPane.URI, "new pane must have the split URL")
	745	+	}
	746	+
	747	+	// TestApp_HistorySidebarConfig_CloseCallback verifies that OnClose hides the
	748	+	// sidebar for the owning browser window and restores focus to the active pane.
	749	+	func TestApp_HistorySidebarConfig_CloseCallback(t *testing.T) {
	750	+	paneID := entity.PaneID("pane-1")
	751	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(paneID))
	752	+	bwTabs := entity.NewTabList()
	753	+	bwTabs.Add(tab)
	754	+	bwTabs.SetActive(tab.ID)
	755	+
	756	+	ws := entity.NewWorkspace("ws-1", entity.NewPane(paneID))
	757	+	ws.ActivePaneID = paneID
	758	+	tab.Workspace = ws
	759	+
	760	+	bw := &browserWindow{
	761	+	id: "window-1",
	762	+	tabs: bwTabs,
	763	+	mainWindow: &window.MainWindow{},
	764	+	historySidebar: &component.HistorySidebar{},
	765	+	sidebarVisible: true,
	766	+	}
	767	+
	768	+	// Create a minimal workspace view.
	769	+	wsView := &component.WorkspaceView{}
	770	+	// We set up the app so that hideAndRestoreFocusForBrowserWindow
	771	+	// can find the wsView and call FocusPane on it.
	772	+	// Since FocusPane is a method on WorkspaceView that requires GTK,
	773	+	// we verify the state changes that happen before FocusPane:
	774	+	// sidebarVisible must be toggled to false.
	775	+
	776	+	app := &App{
	777	+	tabs: entity.NewTabList(),
	778	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	779	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	780	+	tab.ID: wsView,
	781	+	},
	782	+	}
	783	+	cfg := app.buildHistorySidebarConfig(bw)
	784	+
	785	+	// OnClose hides the sidebar.
	786	+	cfg.OnClose()
	787	+
	788	+	assert.False(t, bw.sidebarVisible, "sidebar must be hidden after close")
	789	+	}
	790	+
	791	+	// TestApp_HistorySidebarConfig_CloseWithNoSidebarIsSafe verifies that
	792	+	// OnClose (hideAndRestoreFocusForBrowserWindow) is safe when the browser
	793	+	// window has no sidebar or is nil.
	794	+	func TestApp_HistorySidebarConfig_CloseWithNoSidebarIsSafe(t *testing.T) {
	795	+	bw := &browserWindow{
	796	+	id: "no-sidebar",
	797	+	mainWindow: &window.MainWindow{},
	798	+	// historySidebar is nil
	799	+	}
	800	+
	801	+	app := &App{
	802	+	tabs: entity.NewTabList(),
	803	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	804	+	}
	805	+
	806	+	cfg := app.buildHistorySidebarConfig(bw)
	807	+
	808	+	// Should not panic even with nil sidebar.
	809	+	require.NotPanics(t, func() { cfg.OnClose() })
	810	+	}
	811	+
	812	+	// TestApp_HideAndRestoreFocusForBrowserWindow_HidesSidebar verifies that
	813	+	// hideAndRestoreFocusForBrowserWindow hides the sidebar.
	814	+	func TestApp_HideAndRestoreFocusForBrowserWindow_HidesSidebar(t *testing.T) {
	815	+	paneID := entity.PaneID("pane-1")
	816	+	tab := entity.NewTab(entity.TabID("tab-1"), entity.WorkspaceID("ws-1"), entity.NewPane(paneID))
	817	+	bwTabs := entity.NewTabList()
	818	+	bwTabs.Add(tab)
	819	+	bwTabs.SetActive(tab.ID)
	820	+
	821	+	ws := entity.NewWorkspace("ws-1", entity.NewPane(paneID))
	822	+	ws.ActivePaneID = paneID
	823	+	tab.Workspace = ws
	824	+
	825	+	bw := &browserWindow{
	826	+	id: "window-1",
	827	+	tabs: bwTabs,
	828	+	mainWindow: &window.MainWindow{},
	829	+	historySidebar: &component.HistorySidebar{},
	830	+	sidebarVisible: true,
	831	+	}
	832	+
	833	+	wsView := &component.WorkspaceView{}
	834	+
	835	+	app := &App{
	836	+	tabs: entity.NewTabList(),
	837	+	browserWindows: map[string]*browserWindow{bw.id: bw},
	838	+	workspaceViews: map[entity.TabID]*component.WorkspaceView{
	839	+	tab.ID: wsView,
	840	+	},
	841	+	}
	842	+	app.tabs.Add(tab)
	843	+
	844	+	// Call hideAndRestoreFocusForBrowserWindow directly.
	845	+	app.hideAndRestoreFocusForBrowserWindow(bw)
	846	+
	847	+	// Sidebar must be hidden.
	848	+	assert.False(t, bw.sidebarVisible, "sidebar must be hidden")
	849	+	}
	850	+
	851	+	// TestApp_HideAndRestoreFocusForBrowserWindow_NilBWIsSafe verifies that
	852	+	// hideAndRestoreFocusForBrowserWindow handles nil browser window safely.
	853	+	func TestApp_HideAndRestoreFocusForBrowserWindow_NilBWIsSafe(t *testing.T) {
	854	+	app := &App{}
	855	+	require.NotPanics(t, func() { app.hideAndRestoreFocusForBrowserWindow(nil) })
	856	+	}
	857	+
	858	+	// =============================================================================
	859	+	// Sidebar width config tests
	860	+	// =============================================================================
	861	+
	862	+	func TestHistorySidebarWidthConfig_ConfigValue(t *testing.T) {
	863	+	cfg := historySidebarWidthConfig(350)
	864	+	assert.Equal(t, 350, cfg.WidthPx, "should apply config-backed width of 350px")
	865	+	assert.Equal(t, 280, cfg.MinPx, "should keep default min clamp")
	866	+	assert.Equal(t, 380, cfg.MaxPx, "should keep default max clamp")
	867	+	}
	868	+
	869	+	func TestHistorySidebarWidthConfig_DefaultValue(t *testing.T) {
	870	+	cfg := historySidebarWidthConfig(0)
	871	+	assert.Equal(t, 320, cfg.WidthPx, "should use default width of 320px when config is 0")
	872	+	assert.Equal(t, 280, cfg.MinPx, "should keep default min clamp")
	873	+	assert.Equal(t, 380, cfg.MaxPx, "should keep default max clamp")
	874	+	}
	875	+
	876	+	// TestBrowserWindow_ApplySidebarWidthConfig_NilMainWindowIsSafe verifies
	877	+	// that applySidebarWidthConfig handles nil mainWindow without panic.
	878	+	func TestBrowserWindow_ApplySidebarWidthConfig_NilMainWindowIsSafe(t *testing.T) {
	879	+	bw := &browserWindow{mainWindow: nil}
	880	+	app := &App{deps: &Dependencies{Config: &config.Config{SidebarWidth: 300}}}
	881	+	require.NotPanics(t, func() { bw.applySidebarWidthConfig(app) })
	882	+	}
	883	+
	884	+	// TestBrowserWindow_ApplySidebarWidthConfig_NilDepsIsSafe verifies
	885	+	// that applySidebarWidthConfig handles nil deps without panic.
	886	+	func TestBrowserWindow_ApplySidebarWidthConfig_NilDepsIsSafe(t *testing.T) {
	887	+	mw := &window.MainWindow{}
	888	+	bw := &browserWindow{mainWindow: mw}
	889	+	app := &App{deps: nil}
	890	+	require.NotPanics(t, func() { bw.applySidebarWidthConfig(app) })
	891	+	}

M internal/ui/browser_window_test.go +2 -0


@@ -43,6 +43,7 @@ func TestBrowserWindow_RemoveBrowserWindowClearsShellState(t *testing.T) {
43	43		setShellField(t, removed, "globalShortcutHandler", &input.GlobalShortcutHandler{})
44	44		setShellField(t, removed, "permissionDialog", (*testPermissionDialogPresenter)(nil))
45	45		setShellField(t, removed, "webrtcIndicator", &component.WebRTCPermissionIndicator{})
	46	+	setShellField(t, removed, "historySidebar", &component.HistorySidebar{})
46	47
47	48		app.removeBrowserWindow(removed.id)
48	49

@@ -60,6 +61,7 @@ func TestBrowserWindow_RemoveBrowserWindowClearsShellState(t *testing.T) {
60	61		"globalShortcutHandler",
61	62		"permissionDialog",
62	63		"webrtcIndicator",
	64	+	"historySidebar",
63	65		} {
64	66		if !fieldIsZero(t, removed, name) {
65	67		t.Fatalf("browserWindow.%s was not cleared", name)

A internal/ui/component/history_model.go +304 -0

@@ -0,0 +1,304 @@
	1	+	// Package component provides UI components for the browser.
	2	+	package component
	3	+
	4	+	import (
	5	+	"sort"
	6	+	"strconv"
	7	+	"strings"
	8	+	"time"
	9	+
	10	+	"github.com/bnema/dumber/internal/domain/entity"
	11	+	)
	12	+
	13	+	// historyGroup represents a day-grouped section of history entries.
	14	+	// Groups are ordered newest-first; entries within a group are newest-first.
	15	+	type historyGroup struct {
	16	+	Label string
	17	+	Entries []*entity.HistoryEntry
	18	+	}
	19	+
	20	+	// dayKey identifies a unique calendar day for grouping.
	21	+	type dayKey struct {
	22	+	year int
	23	+	month time.Month
	24	+	day int
	25	+	}
	26	+
	27	+	const (
	28	+	dayLabelToday = "Today"
	29	+	dayLabelYesterday = "Yesterday"
	30	+	dayLabelOtherYearFormat = "January 2, 2006"
	31	+	hoursPerDay = 24
	32	+	)
	33	+
	34	+	// groupHistoryByDay groups entries by calendar day, newest-first.
	35	+	// Days are labeled: "Today", "Yesterday", "Monday, January 2" (current year),
	36	+	// "January 2, 2006" (other years). Within each group entries remain in
	37	+	// the order they arrived (assumed most-recent-first).
	38	+	func groupHistoryByDay(entries []*entity.HistoryEntry) []historyGroup {
	39	+	if len(entries) == 0 {
	40	+	return nil
	41	+	}
	42	+
	43	+	now := time.Now()
	44	+	local := now.Location()
	45	+	todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, local)
	46	+
	47	+	groupsMap := make(map[dayKey]*historyGroup)
	48	+	var keys []dayKey
	49	+
	50	+	for _, entry := range entries {
	51	+	t := entry.LastVisited.In(local)
	52	+	key := dayKey{t.Year(), t.Month(), t.Day()}
	53	+
	54	+	if _, ok := groupsMap[key]; !ok {
	55	+	label := dayLabelForKey(key, todayStart, now)
	56	+	groupsMap[key] = &historyGroup{Label: label}
	57	+	keys = append(keys, key)
	58	+	}
	59	+	groupsMap[key].Entries = append(groupsMap[key].Entries, entry)
	60	+	}
	61	+
	62	+	// Sort keys newest-first
	63	+	sort.Slice(keys, func(i, j int) bool {
	64	+	ki, kj := keys[i], keys[j]
	65	+	ti := time.Date(ki.year, ki.month, ki.day, 0, 0, 0, 0, local)
	66	+	tj := time.Date(kj.year, kj.month, kj.day, 0, 0, 0, 0, local)
	67	+	return ti.After(tj)
	68	+	})
	69	+
	70	+	groups := make([]historyGroup, len(keys))
	71	+	for i, k := range keys {
	72	+	groups[i] = *groupsMap[k]
	73	+	}
	74	+	return groups
	75	+	}
	76	+
	77	+	func dayLabelForKey(key dayKey, todayStart, now time.Time) string {
	78	+	dayStart := time.Date(key.year, key.month, key.day, 0, 0, 0, 0, now.Location())
	79	+	switch {
	80	+	case dayStart.Equal(todayStart):
	81	+	return dayLabelToday
	82	+	case dayStart.Equal(todayStart.AddDate(0, 0, -1)):
	83	+	return dayLabelYesterday
	84	+	case key.year == now.Year():
	85	+	return dayStart.Format("Monday, January 2")
	86	+	default:
	87	+	return dayStart.Format(dayLabelOtherYearFormat)
	88	+	}
	89	+	}
	90	+
	91	+	// readableURL strips the protocol prefix and optional www. for display.
	92	+	func readableURL(rawURL string) string {
	93	+	u := rawURL
	94	+	for _, prefix := range []string{"https://", "http://", "ftp://"} {
	95	+	if strings.HasPrefix(u, prefix) {
	96	+	u = u[len(prefix):]
	97	+	break
	98	+	}
	99	+	}
	100	+	u = strings.TrimPrefix(u, "www.")
	101	+	// Remove trailing slash when there's no path beyond it
	102	+	if slashIdx := strings.IndexByte(u, '/'); slashIdx == -1 \|\| slashIdx == len(u)-1 {
	103	+	u = strings.TrimSuffix(u, "/")
	104	+	}
	105	+	return u
	106	+	}
	107	+
	108	+	// relativeTime returns a compact relative time label for a timestamp.
	109	+	// Examples: "2m ago", "1h ago", "3d ago", "Jan 2".
	110	+	func relativeTime(t time.Time) string {
	111	+	now := time.Now()
	112	+	d := now.Sub(t)
	113	+
	114	+	switch {
	115	+	case d < time.Minute:
	116	+	return "now"
	117	+	case d < time.Hour:
	118	+	m := int(d.Minutes())
	119	+	if m < 2 {
	120	+	return "1m ago"
	121	+	}
	122	+	return strconv.Itoa(m) + "m ago"
	123	+	case d < hoursPerDay*time.Hour:
	124	+	h := int(d.Hours())
	125	+	if h < 2 {
	126	+	return "1h ago"
	127	+	}
	128	+	return strconv.Itoa(h) + "h ago"
	129	+	case d < 7hoursPerDaytime.Hour:
	130	+	days := int(d.Hours() / hoursPerDay)
	131	+	if days < 2 {
	132	+	return "1d ago"
	133	+	}
	134	+	return strconv.Itoa(days) + "d ago"
	135	+	default:
	136	+	if t.Year() == now.Year() {
	137	+	return t.Format("Jan 2")
	138	+	}
	139	+	return t.Format("Jan 2, 2006")
	140	+	}
	141	+	}
	142	+
	143	+	// historyDisplayRowKind identifies the type of row rendered in the sidebar.
	144	+	type historyDisplayRowKind int
	145	+
	146	+	const (
	147	+	historyDisplayRowHeader historyDisplayRowKind = iota
	148	+	historyDisplayRowEntry
	149	+	)
	150	+
	151	+	// historyDisplayRow is the explicit row model rendered by the history sidebar.
	152	+	// It is the only source used for row lookup, selection, activation, and delete.
	153	+	type historyDisplayRow struct {
	154	+	Kind historyDisplayRowKind
	155	+	Label string
	156	+	Entry *entity.HistoryEntry
	157	+	GroupIndex int
	158	+	}
	159	+
	160	+	func buildHistoryDisplayRows(groups []historyGroup) []historyDisplayRow {
	161	+	if len(groups) == 0 {
	162	+	return nil
	163	+	}
	164	+	rows := make([]historyDisplayRow, 0)
	165	+	for gi, group := range groups {
	166	+	rows = append(rows, historyDisplayRow{Kind: historyDisplayRowHeader, Label: group.Label, GroupIndex: gi})
	167	+	for _, entry := range group.Entries {
	168	+	rows = append(rows, historyDisplayRow{Kind: historyDisplayRowEntry, Entry: entry, GroupIndex: gi})
	169	+	}
	170	+	}
	171	+	return rows
	172	+	}
	173	+
	174	+	// keyboardNavModel provides pure functions for keyboard navigation over the
	175	+	// explicit display rows. It has no GTK dependencies and can be tested directly.
	176	+	type keyboardNavModel struct {
	177	+	rows []historyDisplayRow
	178	+	}
	179	+
	180	+	// newKeyboardNavModel creates a keyboardNavModel over day-grouped history.
	181	+	func newKeyboardNavModel(groups []historyGroup) keyboardNavModel {
	182	+	return newKeyboardNavModelFromRows(buildHistoryDisplayRows(groups))
	183	+	}
	184	+
	185	+	func newKeyboardNavModelFromRows(rows []historyDisplayRow) keyboardNavModel {
	186	+	return keyboardNavModel{rows: rows}
	187	+	}
	188	+
	189	+	// totalRows returns the number of explicit display rows.
	190	+	func (m keyboardNavModel) totalRows() int { return len(m.rows) }
	191	+
	192	+	// isSelectable returns true when the display row corresponds to an entry.
	193	+	func (m keyboardNavModel) isSelectable(index int) bool {
	194	+	return index >= 0 && index < len(m.rows) && m.rows[index].Kind == historyDisplayRowEntry && m.rows[index].Entry != nil
	195	+	}
	196	+
	197	+	func (m keyboardNavModel) firstSelectableIndex() int {
	198	+	for i := 0; i < m.totalRows(); i++ {
	199	+	if m.isSelectable(i) {
	200	+	return i
	201	+	}
	202	+	}
	203	+	return -1
	204	+	}
	205	+
	206	+	func (m keyboardNavModel) lastSelectableIndex() int {
	207	+	for i := m.totalRows() - 1; i >= 0; i-- {
	208	+	if m.isSelectable(i) {
	209	+	return i
	210	+	}
	211	+	}
	212	+	return -1
	213	+	}
	214	+
	215	+	func (m keyboardNavModel) nextSelectableIndex(from, dir int) int {
	216	+	if dir != -1 && dir != +1 {
	217	+	return -1
	218	+	}
	219	+	for i := from + dir; i >= 0 && i < m.totalRows(); i += dir {
	220	+	if m.isSelectable(i) {
	221	+	return i
	222	+	}
	223	+	}
	224	+	return -1
	225	+	}
	226	+
	227	+	func (m keyboardNavModel) groupIndexAt(index int) int {
	228	+	if index < 0 \|\| index >= len(m.rows) {
	229	+	return -1
	230	+	}
	231	+	return m.rows[index].GroupIndex
	232	+	}
	233	+
	234	+	func (m keyboardNavModel) maxGroupIndex() int {
	235	+	maxIndex := -1
	236	+	for _, row := range m.rows {
	237	+	if row.GroupIndex > maxIndex {
	238	+	maxIndex = row.GroupIndex
	239	+	}
	240	+	}
	241	+	return maxIndex
	242	+	}
	243	+
	244	+	func (m keyboardNavModel) cumulativeOffsetAtGroup(gi int) int {
	245	+	if gi < 0 {
	246	+	return -1
	247	+	}
	248	+	for i, row := range m.rows {
	249	+	if row.GroupIndex == gi && row.Kind == historyDisplayRowHeader {
	250	+	return i
	251	+	}
	252	+	}
	253	+	return -1
	254	+	}
	255	+
	256	+	func (m keyboardNavModel) firstEntryOfGroup(gi int) int {
	257	+	for i, row := range m.rows {
	258	+	if row.GroupIndex == gi && row.Kind == historyDisplayRowEntry && row.Entry != nil {
	259	+	return i
	260	+	}
	261	+	}
	262	+	return -1
	263	+	}
	264	+
	265	+	func (m keyboardNavModel) previousDayBoundary(from int) int {
	266	+	gi := m.groupIndexAt(from)
	267	+	if gi <= 0 {
	268	+	return -1
	269	+	}
	270	+	return m.firstEntryOfGroup(gi - 1)
	271	+	}
	272	+
	273	+	func (m keyboardNavModel) nextDayBoundary(from int) int {
	274	+	gi := m.groupIndexAt(from)
	275	+	if gi < 0 \|\| gi >= m.maxGroupIndex() {
	276	+	return -1
	277	+	}
	278	+	return m.firstEntryOfGroup(gi + 1)
	279	+	}
	280	+
	281	+	func (m keyboardNavModel) entryAt(index int) *entity.HistoryEntry {
	282	+	if !m.isSelectable(index) {
	283	+	return nil
	284	+	}
	285	+	return m.rows[index].Entry
	286	+	}
	287	+
	288	+	func (m keyboardNavModel) entryURLAt(index int) string {
	289	+	e := m.entryAt(index)
	290	+	if e == nil {
	291	+	return ""
	292	+	}
	293	+	return e.URL
	294	+	}
	295	+
	296	+	func (m keyboardNavModel) entryCount() int {
	297	+	n := 0
	298	+	for i := range m.rows {
	299	+	if m.isSelectable(i) {
	300	+	n++
	301	+	}
	302	+	}
	303	+	return n
	304	+	}

A internal/ui/component/history_model_test.go +741 -0

@@ -0,0 +1,741 @@
	1	+	package component
	2	+
	3	+	import (
	4	+	"fmt"
	5	+	"testing"
	6	+	"time"
	7	+
	8	+	"github.com/bnema/dumber/internal/domain/entity"
	9	+	"github.com/stretchr/testify/assert"
	10	+	"github.com/stretchr/testify/require"
	11	+	)
	12	+
	13	+	func TestGroupHistoryByDay_Empty(t *testing.T) {
	14	+	assert.Nil(t, groupHistoryByDay(nil))
	15	+	assert.Nil(t, groupHistoryByDay([]*entity.HistoryEntry{}))
	16	+	}
	17	+
	18	+	func TestGroupHistoryByDay_SingleEntry(t *testing.T) {
	19	+	now := time.Now()
	20	+	entries := []*entity.HistoryEntry{
	21	+	{ID: 1, URL: "https://example.com", Title: "Example", LastVisited: now},
	22	+	}
	23	+	groups := groupHistoryByDay(entries)
	24	+	require.Len(t, groups, 1)
	25	+	assert.Equal(t, "Today", groups[0].Label)
	26	+	assert.Len(t, groups[0].Entries, 1)
	27	+	}
	28	+
	29	+	func TestGroupHistoryByDay_TodayYesterdayOlder(t *testing.T) {
	30	+	now := time.Now()
	31	+	today := now
	32	+	yesterday := now.AddDate(0, 0, -1)
	33	+	older := now.AddDate(0, 0, -5)
	34	+
	35	+	entries := []*entity.HistoryEntry{
	36	+	{ID: 1, URL: "https://older.com", Title: "Older", LastVisited: older},
	37	+	{ID: 2, URL: "https://yesterday.com", Title: "Yesterday", LastVisited: yesterday},
	38	+	{ID: 3, URL: "https://today.com", Title: "Today", LastVisited: today},
	39	+	}
	40	+	groups := groupHistoryByDay(entries)
	41	+	require.Len(t, groups, 3)
	42	+	assert.Equal(t, "Today", groups[0].Label)
	43	+	assert.Equal(t, "Yesterday", groups[1].Label)
	44	+	assert.NotEmpty(t, groups[2].Label, "older entry should have a formatted date label")
	45	+	assert.Len(t, groups[2].Entries, 1)
	46	+	}
	47	+
	48	+	func TestGroupHistoryByDay_SameDayEntriesGrouped(t *testing.T) {
	49	+	now := time.Now()
	50	+	entries := []*entity.HistoryEntry{
	51	+	{ID: 1, URL: "https://a.com", Title: "A", LastVisited: now},
	52	+	{ID: 2, URL: "https://b.com", Title: "B", LastVisited: now.Add(-time.Hour)},
	53	+	}
	54	+	groups := groupHistoryByDay(entries)
	55	+	require.Len(t, groups, 1)
	56	+	assert.Equal(t, "Today", groups[0].Label)
	57	+	assert.Len(t, groups[0].Entries, 2)
	58	+	}
	59	+
	60	+	func TestReadableURL_StripsProtocol(t *testing.T) {
	61	+	assert.Equal(t, "example.com", readableURL("https://example.com"))
	62	+	assert.Equal(t, "example.com/page", readableURL("http://example.com/page"))
	63	+	assert.Equal(t, "example.com", readableURL("https://www.example.com"))
	64	+	}
	65	+
	66	+	func TestReadableURL_KeepsPath(t *testing.T) {
	67	+	assert.Equal(t, "example.com/path/to/page", readableURL("https://example.com/path/to/page"))
	68	+	}
	69	+
	70	+	func TestRelativeTime_Now(t *testing.T) {
	71	+	assert.Equal(t, "now", relativeTime(time.Now()))
	72	+	}
	73	+
	74	+	func TestRelativeTime_Minutes(t *testing.T) {
	75	+	assert.Equal(t, "1m ago", relativeTime(time.Now().Add(-1*time.Minute)))
	76	+	assert.Equal(t, "5m ago", relativeTime(time.Now().Add(-5*time.Minute)))
	77	+	}
	78	+
	79	+	func TestRelativeTime_Hours(t *testing.T) {
	80	+	assert.Equal(t, "1h ago", relativeTime(time.Now().Add(-1*time.Hour)))
	81	+	assert.Equal(t, "3h ago", relativeTime(time.Now().Add(-3*time.Hour)))
	82	+	}
	83	+
	84	+	func TestRelativeTime_Days(t *testing.T) {
	85	+	assert.Equal(t, "1d ago", relativeTime(time.Now().Add(-25*time.Hour)))
	86	+	assert.Equal(t, "3d ago", relativeTime(time.Now().Add(-72*time.Hour)))
	87	+	}
	88	+
	89	+	func TestGroupHistoryByDay_CrossYearDifferentLabels(t *testing.T) {
	90	+	now := time.Now()
	91	+	thisYear := now
	92	+	lastYear := now.AddDate(-1, 0, 0)
	93	+	twoYearsAgo := now.AddDate(-2, 0, 0)
	94	+
	95	+	entries := []*entity.HistoryEntry{
	96	+	{ID: 1, URL: "https://two-years-ago.com", Title: "Two Years Ago", LastVisited: twoYearsAgo},
	97	+	{ID: 2, URL: "https://last-year.com", Title: "Last Year", LastVisited: lastYear},
	98	+	{ID: 3, URL: "https://this-year.com", Title: "This Year", LastVisited: thisYear},
	99	+	}
	100	+	groups := groupHistoryByDay(entries)
	101	+	require.Len(t, groups, 3)
	102	+	assert.Equal(t, "Today", groups[0].Label)
	103	+	assert.Equal(t, lastYear.Format(dayLabelOtherYearFormat), groups[1].Label)
	104	+	assert.Equal(t, twoYearsAgo.Format(dayLabelOtherYearFormat), groups[2].Label)
	105	+	assert.Len(t, groups[2].Entries, 1)
	106	+	}
	107	+
	108	+	func TestGroupHistoryByDay_MaintainsInputOrderWithinDay(t *testing.T) {
	109	+	now := time.Now()
	110	+	entries := []*entity.HistoryEntry{
	111	+	{ID: 1, URL: "https://first.com", Title: "First", LastVisited: now},
	112	+	{ID: 2, URL: "https://second.com", Title: "Second", LastVisited: now.Add(-30 * time.Minute)},
	113	+	{ID: 3, URL: "https://third.com", Title: "Third", LastVisited: now.Add(-2 * time.Hour)},
	114	+	}
	115	+	groups := groupHistoryByDay(entries)
	116	+	require.Len(t, groups, 1)
	117	+	require.Len(t, groups[0].Entries, 3)
	118	+	// Entries within the same day maintain input order
	119	+	assert.Equal(t, "https://first.com", groups[0].Entries[0].URL)
	120	+	assert.Equal(t, "https://second.com", groups[0].Entries[1].URL)
	121	+	assert.Equal(t, "https://third.com", groups[0].Entries[2].URL)
	122	+	}
	123	+
	124	+	func TestGroupHistoryByDay_LeapYearBoundary(t *testing.T) {
	125	+	// Two consecutive days in a leap year should produce separate groups.
	126	+	// Use local noon on a known leap year to avoid UTC-to-local date
	127	+	// rollover, and check that labels include the year when not the
	128	+	// current year.
	129	+	loc := time.Now().Location()
	130	+	leapYear := 2024
	131	+	feb28 := time.Date(leapYear, time.February, 28, 12, 0, 0, 0, loc)
	132	+	feb29 := time.Date(leapYear, time.February, 29, 12, 0, 0, 0, loc)
	133	+
	134	+	entries := []*entity.HistoryEntry{
	135	+	{ID: 1, URL: "https://feb29.com", Title: "Feb 29", LastVisited: feb29},
	136	+	{ID: 2, URL: "https://feb28.com", Title: "Feb 28", LastVisited: feb28},
	137	+	}
	138	+	groups := groupHistoryByDay(entries)
	139	+	require.Len(t, groups, 2, "Feb 28 and Feb 29 should be in separate groups")
	140	+	// Verify order: newest first
	141	+	// Since 2024 is likely not the current year, labels include year
	142	+	assert.Equal(t, feb29.Format("January 2, 2006"), groups[0].Label)
	143	+	assert.Equal(t, feb28.Format("January 2, 2006"), groups[1].Label)
	144	+	}
	145	+
	146	+	func TestGroupHistoryByDay_SameLocalDay(t *testing.T) {
	147	+	// Two entries on the same calendar day in local timezone should be grouped.
	148	+	loc := time.Now().Location()
	149	+	sameDay := time.Date(2026, time.June, 10, 12, 0, 0, 0, loc)
	150	+	earlier := time.Date(2026, time.June, 10, 8, 0, 0, 0, loc)
	151	+
	152	+	entries := []*entity.HistoryEntry{
	153	+	{ID: 1, URL: "https://later.com", Title: "Later", LastVisited: sameDay},
	154	+	{ID: 2, URL: "https://earlier.com", Title: "Earlier", LastVisited: earlier},
	155	+	}
	156	+	groups := groupHistoryByDay(entries)
	157	+	require.Len(t, groups, 1, "entries on same calendar day should be in one group")
	158	+	assert.Contains(t, groups[0].Label, "June")
	159	+	}
	160	+
	161	+	func TestReadableURL_StripsFTPAndWWW(t *testing.T) {
	162	+	assert.Equal(t, "example.com", readableURL("ftp://example.com"))
	163	+	assert.Equal(t, "example.com", readableURL("http://www.example.com"))
	164	+	assert.Equal(t, "example.com", readableURL("https://www.example.com/"))
	165	+	}
	166	+
	167	+	func TestReadableURL_NoProtocol(t *testing.T) {
	168	+	assert.Equal(t, "example.com", readableURL("example.com"))
	169	+	}
	170	+
	171	+	func TestReadableURL_TrailingSlash(t *testing.T) {
	172	+	assert.Equal(t, "example.com", readableURL("https://example.com/"))
	173	+	assert.Equal(t, "example.com/path/", readableURL("https://example.com/path/"))
	174	+	}
	175	+
	176	+	func TestReadableURL_EmptyOrRoot(t *testing.T) {
	177	+	assert.Empty(t, readableURL(""))
	178	+	assert.Empty(t, readableURL("/"))
	179	+	}
	180	+
	181	+	func TestReadableURL_PreservesPort(t *testing.T) {
	182	+	assert.Equal(t, "example.com:8080", readableURL("https://example.com:8080"))
	183	+	assert.Equal(t, "example.com:3000/path", readableURL("https://example.com:3000/path"))
	184	+	}
	185	+
	186	+	func TestRelativeTime_BoundaryEdgeCases(t *testing.T) {
	187	+	// Just under 1 minute → "now"
	188	+	assert.Equal(t, "now", relativeTime(time.Now().Add(-30*time.Second)))
	189	+	// 59 seconds → "now"
	190	+	assert.Equal(t, "now", relativeTime(time.Now().Add(-59*time.Second)))
	191	+	// 59 minutes 59 seconds → "59m ago"
	192	+	assert.Equal(t, "59m ago", relativeTime(time.Now().Add(-59time.Minute).Add(-59time.Second)))
	193	+	// 23 hours 59 minutes → "23h ago"
	194	+	assert.Equal(t, "23h ago", relativeTime(time.Now().Add(-23time.Hour).Add(-59time.Minute)))
	195	+	// 6 days 23 hours → "6d ago"
	196	+	assert.Equal(t, "6d ago", relativeTime(time.Now().Add(-624time.Hour).Add(-23*time.Hour)))
	197	+	// 7 days → "Jul 8" format (changes by date, just verify not in "Xd ago")
	198	+	result := relativeTime(time.Now().Add(-7 * 24 * time.Hour))
	199	+	assert.NotContains(t, result, "d ago", "7+ days should not use day format")
	200	+	}
	201	+
	202	+	func TestRelativeTime_Future(t *testing.T) {
	203	+	future := time.Now().Add(time.Hour)
	204	+	result := relativeTime(future)
	205	+	// Current implementation returns "now" for negative durations.
	206	+	// This is a known limitation; the test documents the behavior.
	207	+	assert.Equal(t, "now", result, "future times currently reported as 'now' (known limitation)")
	208	+	}
	209	+
	210	+	func TestRelativeTime_DifferentYear(t *testing.T) {
	211	+	// An entry from a previous year should show a date with month abbreviation
	212	+	// and year when not current year.
	213	+	lastYear := time.Now().AddDate(-1, -1, 0)
	214	+	result := relativeTime(lastYear)
	215	+	_, err := time.Parse("Jan 2, 2006", result)
	216	+	assert.NoError(t, err, "old entry should use the Jan 2, 2006 layout, got %q", result)
	217	+	}
	218	+
	219	+	func TestDayLabelForKey_MultiYearAgo(t *testing.T) {
	220	+	// Produce a label for a dayKey that is multiple years ago
	221	+	now := time.Now()
	222	+	todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	223	+	// Two years ago, same month/day
	224	+	past := now.AddDate(-2, 0, -1)
	225	+	key := dayKey{past.Year(), past.Month(), past.Day()}
	226	+	label := dayLabelForKey(key, todayStart, now)
	227	+	assert.Contains(t, label, past.Format("2006"), "multi-year-old day label should include year")
	228	+	}
	229	+
	230	+	func TestDayLabelForKey_WithinCurrentYear(t *testing.T) {
	231	+	now := time.Now()
	232	+	todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	233	+	// Earlier this month
	234	+	past := now.AddDate(0, 0, -10)
	235	+	key := dayKey{past.Year(), past.Month(), past.Day()}
	236	+	label := dayLabelForKey(key, todayStart, now)
	237	+	// Should be weekday format without year
	238	+	assert.NotContains(t, label, "2006", "within-year label should not include year")
	239	+	assert.Contains(t, label, past.Weekday().String(), "within-year label should include weekday")
	240	+	}
	241	+
	242	+	// =============================================================================
	243	+	// keyboardNavModel tests
	244	+	// =============================================================================
	245	+
	246	+	func makeGroups(dayCounts ...int) []historyGroup {
	247	+	now := time.Now()
	248	+	groups := make([]historyGroup, len(dayCounts))
	249	+	for i, count := range dayCounts {
	250	+	entries := make([]*entity.HistoryEntry, count)
	251	+	for j := 0; j < count; j++ {
	252	+	entries[j] = &entity.HistoryEntry{
	253	+	ID: int64(i*100 + j),
	254	+	URL: fmt.Sprintf("https://entry-%d-%d.com", i, j),
	255	+	Title: fmt.Sprintf("Entry %d-%d", i, j),
	256	+	LastVisited: now.Add(-time.Duration(i) * 24 * time.Hour).Add(-time.Duration(j) * time.Minute),
	257	+	}
	258	+	}
	259	+	groups[i] = historyGroup{
	260	+	Label: fmt.Sprintf("Day %d", i),
	261	+	Entries: entries,
	262	+	}
	263	+	}
	264	+	return groups
	265	+	}
	266	+
	267	+	func TestKeyboardNavModel_EmptyGroups(t *testing.T) {
	268	+	m := newKeyboardNavModel(nil)
	269	+	assert.Equal(t, 0, m.totalRows())
	270	+	assert.Equal(t, -1, m.firstSelectableIndex())
	271	+	assert.Equal(t, -1, m.lastSelectableIndex())
	272	+	assert.Nil(t, m.entryAt(0))
	273	+	assert.Empty(t, m.entryURLAt(0))
	274	+
	275	+	m = newKeyboardNavModel([]historyGroup{})
	276	+	assert.Equal(t, 0, m.totalRows())
	277	+	}
	278	+
	279	+	func TestKeyboardNavModel_SingleGroup(t *testing.T) {
	280	+	groups := makeGroups(3) // 1 header + 3 entries = 4 rows
	281	+	m := newKeyboardNavModel(groups)
	282	+
	283	+	assert.Equal(t, 4, m.totalRows())
	284	+
	285	+	// Row 0: header (not selectable)
	286	+	assert.False(t, m.isSelectable(0))
	287	+	assert.Nil(t, m.entryAt(0))
	288	+	assert.Empty(t, m.entryURLAt(0))
	289	+
	290	+	// Rows 1-3: entries (selectable)
	291	+	for i := 1; i <= 3; i++ {
	292	+	assert.True(t, m.isSelectable(i), "row %d should be selectable", i)
	293	+	assert.NotNil(t, m.entryAt(i))
	294	+	assert.Contains(t, m.entryURLAt(i), "entry-0")
	295	+	}
	296	+
	297	+	// first / last
	298	+	assert.Equal(t, 1, m.firstSelectableIndex())
	299	+	assert.Equal(t, 3, m.lastSelectableIndex())
	300	+	}
	301	+
	302	+	func TestKeyboardNavModel_MultipleGroups(t *testing.T) {
	303	+	groups := makeGroups(2, 3) // group0: header+e0+e1, group1: header+e0+e1+e2
	304	+	m := newKeyboardNavModel(groups)
	305	+
	306	+	// Layout: [H0, E0-0, E0-1, H1, E1-0, E1-1, E1-2] = 7 rows
	307	+	assert.Equal(t, 7, m.totalRows())
	308	+
	309	+	// Selectable: rows 1,2,4,5,6
	310	+	assert.False(t, m.isSelectable(0)) // H0
	311	+	assert.True(t, m.isSelectable(1)) // E0-0
	312	+	assert.True(t, m.isSelectable(2)) // E0-1
	313	+	assert.False(t, m.isSelectable(3)) // H1
	314	+	assert.True(t, m.isSelectable(4)) // E1-0
	315	+	assert.True(t, m.isSelectable(5)) // E1-1
	316	+	assert.True(t, m.isSelectable(6)) // E1-2
	317	+
	318	+	assert.Equal(t, 1, m.firstSelectableIndex())
	319	+	assert.Equal(t, 6, m.lastSelectableIndex())
	320	+	}
	321	+
	322	+	func TestKeyboardNavModel_NextPreviousSelectable(t *testing.T) {
	323	+	groups := makeGroups(2, 2) // rows: H0(0), E0-0(1), E0-1(2), H1(3), E1-0(4), E1-1(5)
	324	+	m := newKeyboardNavModel(groups)
	325	+
	326	+	// Next from 0 (header) → 1
	327	+	assert.Equal(t, 1, m.nextSelectableIndex(0, +1))
	328	+	// Next from 1 → 2
	329	+	assert.Equal(t, 2, m.nextSelectableIndex(1, +1))
	330	+	// Next from 2 → 4 (skip header H1 at 3)
	331	+	assert.Equal(t, 4, m.nextSelectableIndex(2, +1))
	332	+	// Next from 5 → -1 (end)
	333	+	assert.Equal(t, -1, m.nextSelectableIndex(5, +1))
	334	+
	335	+	// Previous from 5 (E1-1) → 4
	336	+	assert.Equal(t, 4, m.nextSelectableIndex(5, -1))
	337	+	// Previous from 4 → 2 (skip header H1 at 3)
	338	+	assert.Equal(t, 2, m.nextSelectableIndex(4, -1))
	339	+	// Previous from 1 → -1 (beginning, only header before)
	340	+	assert.Equal(t, -1, m.nextSelectableIndex(1, -1))
	341	+	// Previous from 0 (header) → -1
	342	+	assert.Equal(t, -1, m.nextSelectableIndex(0, -1))
	343	+	}
	344	+
	345	+	func TestKeyboardNavModel_InvalidDirection(t *testing.T) {
	346	+	groups := makeGroups(2)
	347	+	m := newKeyboardNavModel(groups)
	348	+	assert.Equal(t, -1, m.nextSelectableIndex(0, 0))
	349	+	assert.Equal(t, -1, m.nextSelectableIndex(0, 2))
	350	+	assert.Equal(t, -1, m.nextSelectableIndex(0, -2))
	351	+	}
	352	+
	353	+	func TestKeyboardNavModel_DayBoundaries(t *testing.T) {
	354	+	groups := makeGroups(2, 1, 2)
	355	+	// Layout: H0(0), E0-0(1), E0-1(2), H1(3), E1-0(4), H2(5), E2-0(6), E2-1(7)
	356	+	m := newKeyboardNavModel(groups)
	357	+
	358	+	// Previous day from E0-1(2) → E0-1 is in group 0, no previous day.
	359	+	assert.Equal(t, -1, m.previousDayBoundary(2))
	360	+
	361	+	// Previous day from E1-0(4) → first entry in group 0 = row 1
	362	+	assert.Equal(t, 1, m.previousDayBoundary(4))
	363	+
	364	+	// Previous day from first group's entry (E0-0 at 1) → no previous day
	365	+	assert.Equal(t, -1, m.previousDayBoundary(1))
	366	+
	367	+	// Next day from E0-0(1) → first entry in group 1 = row 4
	368	+	assert.Equal(t, 4, m.nextDayBoundary(1))
	369	+
	370	+	// Next day from E0-1(2) → row 4
	371	+	assert.Equal(t, 4, m.nextDayBoundary(2))
	372	+
	373	+	// Next day from E1-0(4) → first entry in group 2 = row 6
	374	+	assert.Equal(t, 6, m.nextDayBoundary(4))
	375	+
	376	+	// Next day from E2-0(6, group 2) → last group, no next day
	377	+	assert.Equal(t, -1, m.nextDayBoundary(6))
	378	+
	379	+	// Next day from E2-1(7, last entry) → no next day
	380	+	assert.Equal(t, -1, m.nextDayBoundary(7))
	381	+	}
	382	+
	383	+	func TestKeyboardNavModel_EntryAtURL(t *testing.T) {
	384	+	groups := makeGroups(1, 1)
	385	+	m := newKeyboardNavModel(groups)
	386	+
	387	+	e0 := m.entryAt(1)
	388	+	require.NotNil(t, e0)
	389	+	assert.Equal(t, "https://entry-0-0.com", e0.URL)
	390	+	assert.Equal(t, "https://entry-0-0.com", m.entryURLAt(1))
	391	+
	392	+	e1 := m.entryAt(3)
	393	+	require.NotNil(t, e1)
	394	+	assert.Equal(t, "https://entry-1-0.com", e1.URL)
	395	+
	396	+	// Header rows return nil / ""
	397	+	assert.Nil(t, m.entryAt(0)) // H0
	398	+	assert.Empty(t, m.entryURLAt(0))
	399	+	assert.Nil(t, m.entryAt(2)) // H1
	400	+	assert.Empty(t, m.entryURLAt(2))
	401	+
	402	+	// Out of range
	403	+	assert.Nil(t, m.entryAt(99))
	404	+	assert.Empty(t, m.entryURLAt(99))
	405	+	assert.Nil(t, m.entryAt(-1))
	406	+	}
	407	+
	408	+	func TestKeyboardNavModel_EntryCount(t *testing.T) {
	409	+	assert.Equal(t, 0, newKeyboardNavModel(nil).entryCount())
	410	+	assert.Equal(t, 0, newKeyboardNavModel([]historyGroup{}).entryCount())
	411	+	assert.Equal(t, 5, newKeyboardNavModel(makeGroups(2, 3)).entryCount())
	412	+	assert.Equal(t, 10, newKeyboardNavModel(makeGroups(3, 3, 4)).entryCount())
	413	+	}
	414	+
	415	+	func TestBuildHistoryDisplayRows_IncludesHeadersAndEntries(t *testing.T) {
	416	+	now := time.Now()
	417	+	entryA := &entity.HistoryEntry{ID: 1, URL: "https://a.com", Title: "A", LastVisited: now}
	418	+	entryB := &entity.HistoryEntry{ID: 2, URL: "https://b.com", Title: "B", LastVisited: now.Add(-time.Hour)}
	419	+	groups := []historyGroup{
	420	+	{Label: "Today", Entries: []*entity.HistoryEntry{entryA, entryB}},
	421	+	{Label: "Yesterday", Entries: nil},
	422	+	}
	423	+
	424	+	rows := buildHistoryDisplayRows(groups)
	425	+	require.Len(t, rows, 4)
	426	+	assert.Equal(t, historyDisplayRowHeader, rows[0].Kind)
	427	+	assert.Equal(t, "Today", rows[0].Label)
	428	+	assert.Equal(t, 0, rows[0].GroupIndex)
	429	+	assert.Equal(t, historyDisplayRowEntry, rows[1].Kind)
	430	+	assert.Same(t, entryA, rows[1].Entry)
	431	+	assert.Equal(t, 0, rows[1].GroupIndex)
	432	+	assert.Equal(t, historyDisplayRowEntry, rows[2].Kind)
	433	+	assert.Same(t, entryB, rows[2].Entry)
	434	+	assert.Equal(t, historyDisplayRowHeader, rows[3].Kind)
	435	+	assert.Equal(t, "Yesterday", rows[3].Label)
	436	+	assert.Equal(t, 1, rows[3].GroupIndex)
	437	+	}
	438	+
	439	+	func TestKeyboardNavModelFromRows_UsesExplicitDisplayRows(t *testing.T) {
	440	+	now := time.Now()
	441	+	entryA := &entity.HistoryEntry{ID: 1, URL: "https://a.com", Title: "A", LastVisited: now}
	442	+	entryB := &entity.HistoryEntry{ID: 2, URL: "https://b.com", Title: "B", LastVisited: now.Add(-24 * time.Hour)}
	443	+	rows := buildHistoryDisplayRows([]historyGroup{
	444	+	{Label: "Today", Entries: []*entity.HistoryEntry{entryA}},
	445	+	{Label: "Yesterday", Entries: []*entity.HistoryEntry{entryB}},
	446	+	})
	447	+
	448	+	m := newKeyboardNavModelFromRows(rows)
	449	+	assert.Equal(t, 4, m.totalRows())
	450	+	assert.False(t, m.isSelectable(0))
	451	+	assert.True(t, m.isSelectable(1))
	452	+	assert.False(t, m.isSelectable(2))
	453	+	assert.True(t, m.isSelectable(3))
	454	+	assert.Same(t, entryA, m.entryAt(1))
	455	+	assert.Equal(t, entryB.URL, m.entryURLAt(3))
	456	+	assert.Equal(t, 3, m.nextDayBoundary(1))
	457	+	assert.Equal(t, 1, m.previousDayBoundary(3))
	458	+	}
	459	+
	460	+	// =============================================================================
	461	+	// Search state transition tests
	462	+	// =============================================================================
	463	+
	464	+	func TestTransitionSearchState_EmptyQuery(t *testing.T) {
	465	+	next := transitionSearchState("", 0)
	466	+	assert.Empty(t, next.Query)
	467	+	assert.False(t, next.HasSearchDone)
	468	+	assert.False(t, next.HasResults)
	469	+	assert.Equal(t, 0, next.ResultCount)
	470	+	}
	471	+
	472	+	func TestTransitionSearchState_NewQuery(t *testing.T) {
	473	+	next := transitionSearchState("example", 5)
	474	+	assert.Equal(t, "example", next.Query)
	475	+	assert.True(t, next.HasSearchDone)
	476	+	assert.True(t, next.HasResults)
	477	+	assert.Equal(t, 5, next.ResultCount)
	478	+	}
	479	+
	480	+	func TestTransitionSearchState_QueryWithNoResults(t *testing.T) {
	481	+	next := transitionSearchState("nonexistent", 0)
	482	+	assert.Equal(t, "nonexistent", next.Query)
	483	+	assert.True(t, next.HasSearchDone)
	484	+	assert.False(t, next.HasResults)
	485	+	assert.Equal(t, 0, next.ResultCount)
	486	+	}
	487	+
	488	+	func TestTransitionSearchState_QueryToQuery(t *testing.T) {
	489	+	next := transitionSearchState("new", 7)
	490	+	assert.Equal(t, "new", next.Query)
	491	+	assert.True(t, next.HasSearchDone)
	492	+	assert.True(t, next.HasResults)
	493	+	assert.Equal(t, 7, next.ResultCount)
	494	+	}
	495	+
	496	+	func TestTransitionSearchState_QueryToEmpty(t *testing.T) {
	497	+	next := transitionSearchState("", 0)
	498	+	assert.Empty(t, next.Query)
	499	+	assert.False(t, next.HasSearchDone)
	500	+	assert.False(t, next.HasResults)
	501	+	assert.Equal(t, 0, next.ResultCount)
	502	+	}
	503	+
	504	+	// =============================================================================
	505	+	// Reload preservation tests
	506	+	// =============================================================================
	507	+
	508	+	func TestApplyReloadState_WithoutQuery(t *testing.T) {
	509	+	s := applyReloadState("")
	510	+	assert.Empty(t, s.PreservedQuery)
	511	+	assert.True(t, s.ResetBrowse)
	512	+	assert.False(t, s.ClearSearch)
	513	+	}
	514	+
	515	+	func TestApplyReloadState_WithQuery(t *testing.T) {
	516	+	s := applyReloadState("search-term")
	517	+	assert.Equal(t, "search-term", s.PreservedQuery)
	518	+	assert.False(t, s.ResetBrowse)
	519	+	assert.True(t, s.ClearSearch)
	520	+	}
	521	+
	522	+	// =============================================================================
	523	+	// keyboardNavModel edge cases
	524	+	// =============================================================================
	525	+
	526	+	func TestKeyboardNavModel_SingleGroupZeroEntries(t *testing.T) {
	527	+	// A group with a header but zero entries.
	528	+	groups := []historyGroup{
	529	+	{Label: "Today", Entries: []*entity.HistoryEntry{}},
	530	+	}
	531	+	m := newKeyboardNavModel(groups)
	532	+
	533	+	assert.Equal(t, 1, m.totalRows()) // header only
	534	+	assert.False(t, m.isSelectable(0))
	535	+	assert.Equal(t, -1, m.firstSelectableIndex())
	536	+	assert.Equal(t, -1, m.lastSelectableIndex())
	537	+	assert.Nil(t, m.entryAt(0))
	538	+	assert.Equal(t, 0, m.entryCount())
	539	+	}
	540	+
	541	+	func TestKeyboardNavModel_MixedEmptyAndNonEmptyGroups(t *testing.T) {
	542	+	// Groups: [A(0 entries), B(2 entries), C(0 entries)]
	543	+	// Layout: H0(0), H1(1), E1-0(2), E1-1(3), H2(4)
	544	+	groups := []historyGroup{
	545	+	{Label: "EmptyA", Entries: []*entity.HistoryEntry{}},
	546	+	{Label: "HasTwo", Entries: []*entity.HistoryEntry{
	547	+	{ID: 1, URL: "https://b1.com", Title: "B1", LastVisited: time.Now()},
	548	+	{ID: 2, URL: "https://b2.com", Title: "B2", LastVisited: time.Now()},
	549	+	}},
	550	+	{Label: "EmptyC", Entries: []*entity.HistoryEntry{}},
	551	+	}
	552	+	m := newKeyboardNavModel(groups)
	553	+
	554	+	assert.Equal(t, 5, m.totalRows())
	555	+	// All headers: 0, 1, 4 are not selectable
	556	+	assert.False(t, m.isSelectable(0))
	557	+	assert.False(t, m.isSelectable(1))
	558	+	assert.False(t, m.isSelectable(4))
	559	+	// Entries: 2, 3 are selectable
	560	+	assert.True(t, m.isSelectable(2))
	561	+	assert.True(t, m.isSelectable(3))
	562	+
	563	+	assert.Equal(t, 2, m.firstSelectableIndex())
	564	+	assert.Equal(t, 3, m.lastSelectableIndex())
	565	+	assert.Equal(t, 2, m.entryCount())
	566	+
	567	+	// next/previous day boundary from group B (index 2) should cross
	568	+	// empty group A header to group C header
	569	+	// previousDayBoundary from entry in B (row 2) → group before B is A (no entries) → -1
	570	+	assert.Equal(t, -1, m.previousDayBoundary(2))
	571	+	// nextDayBoundary from entry in B (row 2) → group after B is C (no entries) → -1
	572	+	assert.Equal(t, -1, m.nextDayBoundary(2))
	573	+	}
	574	+
	575	+	func TestKeyboardNavModel_GroupIndexAt(t *testing.T) {
	576	+	groups := makeGroups(2, 0, 3) // A:2 entries, B:0 entries, C:3 entries
	577	+	// Layout: H0(0), E0-0(1), E0-1(2), H1(3), H2(4), E2-0(5), E2-1(6), E2-2(7)
	578	+	// Groups: A at rows 0-2 (header+2 entries), B at row 3 (header only), C at rows 4-7 (header+3 entries)
	579	+	m := newKeyboardNavModel(groups)
	580	+
	581	+	assert.Equal(t, 0, m.groupIndexAt(0), "row 0 should be in group 0 (A header)")
	582	+	assert.Equal(t, 0, m.groupIndexAt(1), "row 1 should be in group 0 (A entry)")
	583	+	assert.Equal(t, 1, m.groupIndexAt(3), "row 3 should be in group 1 (B header)")
	584	+	assert.Equal(t, 2, m.groupIndexAt(4), "row 4 should be in group 2 (C header)")
	585	+	assert.Equal(t, 2, m.groupIndexAt(7), "row 7 should be in group 2 (last C entry)")
	586	+	assert.Equal(t, -1, m.groupIndexAt(99), "out of range should return -1")
	587	+	}
	588	+
	589	+	func TestKeyboardNavModel_CumulativeOffsetAtGroup(t *testing.T) {
	590	+	groups := makeGroups(2, 0, 3)
	591	+	m := newKeyboardNavModel(groups)
	592	+
	593	+	assert.Equal(t, 0, m.cumulativeOffsetAtGroup(0), "group 0 offset should be 0")
	594	+	// Group 0: 1 header + 2 entries = 3 rows
	595	+	assert.Equal(t, 3, m.cumulativeOffsetAtGroup(1), "group 1 offset should skip group 0")
	596	+	// Group 1: 1 header + 0 entries = 1 row, so group 2 offset = 3 + 1 = 4
	597	+	assert.Equal(t, 4, m.cumulativeOffsetAtGroup(2), "group 2 offset should skip groups 0 and 1")
	598	+	assert.Equal(t, -1, m.cumulativeOffsetAtGroup(99), "out of range should return -1")
	599	+	}
	600	+
	601	+	func TestKeyboardNavModel_FirstEntryOfGroup(t *testing.T) {
	602	+	groups := makeGroups(2, 0, 3)
	603	+	m := newKeyboardNavModel(groups)
	604	+
	605	+	// Group 0: offset=0, first entry = 1
	606	+	assert.Equal(t, 1, m.firstEntryOfGroup(0))
	607	+	// Group 1: offset=3, first entry = 4 (but group has 0 entries -> -1)
	608	+	assert.Equal(t, -1, m.firstEntryOfGroup(1))
	609	+	// Group 2: offset=4, first entry = 5
	610	+	assert.Equal(t, 5, m.firstEntryOfGroup(2))
	611	+	}
	612	+
	613	+	func TestKeyboardNavModel_NextPreviousSelectable_EmptyGroups(t *testing.T) {
	614	+	// All groups have zero entries.
	615	+	groups := []historyGroup{
	616	+	{Label: "A", Entries: []*entity.HistoryEntry{}},
	617	+	{Label: "B", Entries: []*entity.HistoryEntry{}},
	618	+	}
	619	+	m := newKeyboardNavModel(groups)
	620	+
	621	+	assert.Equal(t, -1, m.nextSelectableIndex(0, 1))
	622	+	assert.Equal(t, -1, m.nextSelectableIndex(0, -1))
	623	+	}
	624	+
	625	+	func TestKeyboardNavModel_EntryCountWithEmptyGroups(t *testing.T) {
	626	+	groups := []historyGroup{
	627	+	{Label: "A", Entries: []*entity.HistoryEntry{{
	628	+	ID: 1, URL: "https://a.com", Title: "A", LastVisited: time.Now(),
	629	+	}}},
	630	+	{Label: "B", Entries: []*entity.HistoryEntry{}},
	631	+	{Label: "C", Entries: []*entity.HistoryEntry{{
	632	+	ID: 2, URL: "https://c.com", Title: "C", LastVisited: time.Now(),
	633	+	}}},
	634	+	}
	635	+	m := newKeyboardNavModel(groups)
	636	+	assert.Equal(t, 2, m.entryCount(), "only non-empty groups' entries should count")
	637	+	}
	638	+
	639	+	// =============================================================================
	640	+	// Search generation / stale-result suppression (pure transition model)
	641	+	// =============================================================================
	642	+
	643	+	// TestTransitionSearchState_StaleGenBehavior documents that the search
	644	+	// generation counter (searchGen) is a production-side concern for stale
	645	+	// result suppression. The transitionSearchState pure function only models
	646	+	// query/result transitions; the actual generation guard is enforced by
	647	+	// the GTK idle callback comparing gen vs hs.searchGen.
	648	+	//
	649	+	// We test the callback pattern here by simulating two sequential searches
	650	+	// where a later result arrives after the gen has moved on.
	651	+	func TestTransitionSearchState_SequentialSearches(t *testing.T) {
	652	+	// Search 1: "foo" -> 5 results
	653	+	next1 := transitionSearchState("foo", 5)
	654	+	assert.Equal(t, "foo", next1.Query)
	655	+	assert.True(t, next1.HasSearchDone)
	656	+	assert.True(t, next1.HasResults)
	657	+	assert.Equal(t, 5, next1.ResultCount)
	658	+
	659	+	// Search 2: "foobar" -> 3 results (supersedes search 1)
	660	+	next2 := transitionSearchState("foobar", 3)
	661	+	assert.Equal(t, "foobar", next2.Query)
	662	+	assert.True(t, next2.HasSearchDone)
	663	+	assert.True(t, next2.HasResults)
	664	+	assert.Equal(t, 3, next2.ResultCount)
	665	+	}
	666	+
	667	+	// TestTransitionSearchState_SearchThenClearThenReSearch verifies the
	668	+	// transition from search -> empty -> new search produces correct state.
	669	+	func TestTransitionSearchState_SearchThenClearThenReSearch(t *testing.T) {
	670	+	// Search "term" -> 2 results
	671	+	s := transitionSearchState("term", 2)
	672	+	assert.Equal(t, "term", s.Query)
	673	+	assert.True(t, s.HasSearchDone)
	674	+	assert.True(t, s.HasResults)
	675	+	assert.Equal(t, 2, s.ResultCount)
	676	+
	677	+	// Clear: query becomes ""
	678	+	s = transitionSearchState("", 0)
	679	+	assert.Empty(t, s.Query)
	680	+	assert.False(t, s.HasSearchDone)
	681	+	assert.False(t, s.HasResults)
	682	+	assert.Equal(t, 0, s.ResultCount)
	683	+
	684	+	// Re-search: new term
	685	+	s = transitionSearchState("other", 7)
	686	+	assert.Equal(t, "other", s.Query)
	687	+	assert.True(t, s.HasSearchDone)
	688	+	assert.True(t, s.HasResults)
	689	+	assert.Equal(t, 7, s.ResultCount)
	690	+	}
	691	+
	692	+	// TestApplyReloadState_EmptyAndNonEmpty verifies all reload preservation
	693	+	// states are correctly modeled by the pure function.
	694	+	func TestApplyReloadState_EmptyAndNonEmpty(t *testing.T) {
	695	+	tt := []struct {
	696	+	name string
	697	+	query string
	698	+	wantQuery string
	699	+	wantReset bool
	700	+	wantClear bool
	701	+	}{
	702	+	{name: "empty query", query: "", wantQuery: "", wantReset: true, wantClear: false},
	703	+	{name: "non-empty", query: "search", wantQuery: "search", wantReset: false, wantClear: true},
	704	+	{name: "whitespace only", query: " ", wantQuery: " ", wantReset: false, wantClear: true},
	705	+	{name: "long query", query: "very long search query with many terms", wantQuery: "very long search query with many terms", wantReset: false, wantClear: true},
	706	+	}
	707	+
	708	+	for _, tc := range tt {
	709	+	t.Run(tc.name, func(t *testing.T) {
	710	+	s := applyReloadState(tc.query)
	711	+	assert.Equal(t, tc.wantQuery, s.PreservedQuery)
	712	+	assert.Equal(t, tc.wantReset, s.ResetBrowse)
	713	+	assert.Equal(t, tc.wantClear, s.ClearSearch)
	714	+	})
	715	+	}
	716	+	}
	717	+
	718	+	// TestDayLabelForKey_DifferentYears verifies multi-year scenarios produce
	719	+	// the expected label format.
	720	+	func TestDayLabelForKey_DifferentYears(t *testing.T) {
	721	+	now := time.Now()
	722	+	todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	723	+
	724	+	// Same year, not today/yesterday
	725	+	future := now.AddDate(0, 0, -3)
	726	+	key := dayKey{future.Year(), future.Month(), future.Day()}
	727	+	label := dayLabelForKey(key, todayStart, now)
	728	+	assert.NotContains(t, label, "2006", "within-current-year label should not contain year")
	729	+
	730	+	// Previous year (now.Year()-1)
	731	+	lastYear := now.AddDate(-1, 0, 0)
	732	+	key = dayKey{lastYear.Year(), lastYear.Month(), lastYear.Day()}
	733	+	label = dayLabelForKey(key, todayStart, now)
	734	+	assert.Equal(t, lastYear.Format(dayLabelOtherYearFormat), label)
	735	+
	736	+	// Multiple years ago
	737	+	twoYearsAgo := now.AddDate(-2, 0, 0)
	738	+	key = dayKey{twoYearsAgo.Year(), twoYearsAgo.Month(), twoYearsAgo.Day()}
	739	+	label = dayLabelForKey(key, todayStart, now)
	740	+	assert.Contains(t, label, twoYearsAgo.Format("2006"), "multi-year-old label should include year")
	741	+	}

A internal/ui/component/history_sidebar.go +357 -0

@@ -0,0 +1,357 @@
	1	+	package component
	2	+
	3	+	import (
	4	+	"context"
	5	+	"sync"
	6	+
	7	+	"github.com/bnema/puregotk/v4/glib"
	8	+	"github.com/bnema/puregotk/v4/gtk"
	9	+
	10	+	"github.com/bnema/dumber/internal/application/port"
	11	+	"github.com/bnema/dumber/internal/domain/entity"
	12	+	"github.com/bnema/dumber/internal/logging"
	13	+	"github.com/bnema/dumber/internal/ui/layout"
	14	+	"github.com/rs/zerolog"
	15	+	)
	16	+
	17	+	// sidebar constants
	18	+	const (
	19	+	sidebarMinWidth = 280
	20	+	sidebarDefaultWidth = 320
	21	+	sidebarSearchDebounceMs = 150
	22	+	sidebarPageSize = 100 // entries fetched per page
	23	+	sidebarSearchLimit = 100 // max FTS search results
	24	+	)
	25	+
	26	+	// HistorySidebarKeyboardAction enumerates the possible activation actions
	27	+	// triggered by keyboard Enter variants.
	28	+	type HistorySidebarKeyboardAction int
	29	+
	30	+	const (
	31	+	// SidebarActionCloseOnActivate is the default activation path.
	32	+	// The host currently keeps the sidebar visible for default activation.
	33	+	SidebarActionCloseOnActivate HistorySidebarKeyboardAction = iota
	34	+	// SidebarActionKeepOpenOnActivate navigates but leaves the sidebar visible.
	35	+	SidebarActionKeepOpenOnActivate
	36	+	// SidebarActionNewPaneOnActivate navigates by opening the URL in a new pane/split.
	37	+	SidebarActionNewPaneOnActivate
	38	+	)
	39	+
	40	+	// HistorySidebar is a GTK sidebar component that displays browsing history
	41	+	// grouped by day, with search/filter support and keyboard navigation.
	42	+	// History is loaded page by page with background goroutines to avoid
	43	+	// blocking the GTK main thread.
	44	+	type HistorySidebar struct {
	45	+	// GTK widgets
	46	+	outerBox *gtk.Box
	47	+	searchBox *gtk.Box
	48	+	searchEntry *gtk.SearchEntry
	49	+	scrolledWin *gtk.ScrolledWindow
	50	+	listBox *gtk.ListBox
	51	+
	52	+	// Dependencies
	53	+	historyUC port.HistorySidebarHistory
	54	+	onURL func(ctx context.Context, url string)
	55	+	onOpenInNewPane func(ctx context.Context, url string) error
	56	+	onNavigateKeepOpen func(ctx context.Context, url string)
	57	+	onClose func()
	58	+
	59	+	// Data
	60	+	allEntries []*entity.HistoryEntry // Flat list, most-recent-first
	61	+	groups []historyGroup // Current display groups (filtered)
	62	+	displayRows []historyDisplayRow // Explicit rows currently rendered
	63	+
	64	+	// Paging state (browse mode only)
	65	+	totalLoaded int // how many entries have been fetched so far
	66	+	hasMore bool
	67	+	isLoading bool
	68	+	loadGen uint64 // incremented each new browse load; used for stale-result protection
	69	+
	70	+	// State
	71	+	visible bool
	72	+	currentQuery string
	73	+	loadStarted bool
	74	+	loadDone bool
	75	+	destroyed bool
	76	+	mu sync.RWMutex
	77	+	logger zerolog.Logger
	78	+
	79	+	// Search state
	80	+	searchResults []*entity.HistoryEntry // non-nil when a search has completed
	81	+	searchGen uint64 // incremented each search; used for stale-result protection
	82	+	searchDone bool // true when the last search completed
	83	+	searchErr error // last search error (if any)
	84	+
	85	+	// Scroll/selection preservation
	86	+	prevScrollValue float64
	87	+	prevSelectedURL string
	88	+
	89	+	// Search debounce timer
	90	+	debounceTimer uint
	91	+
	92	+	// Retained callbacks
	93	+	retainedCallbacks []interface{}
	94	+
	95	+	// idleScheduler dispatches work onto the GTK main thread.
	96	+	// Tests may override it to exercise scheduled callbacks deterministically.
	97	+	idleScheduler func(glib.SourceFunc)
	98	+
	99	+	// Context
	100	+	ctx context.Context
	101	+	cancel context.CancelFunc
	102	+	}
	103	+
	104	+	// HistorySidebarConfig holds configuration for creating a HistorySidebar.
	105	+	type HistorySidebarConfig struct {
	106	+	// HistoryUC provides history query and delete operations.
	107	+	HistoryUC port.HistorySidebarHistory
	108	+
	109	+	// OnNavigate is called when the user activates a history entry.
	110	+	// The default Enter / click behavior keeps the sidebar open after navigating.
	111	+	OnNavigate func(ctx context.Context, url string) error
	112	+
	113	+	// OnOpenInNewPane is called when Shift+Enter activates a URL.
	114	+	// Should open the URL in a new pane/split. If nil, Shift+Enter
	115	+	// falls back to the default plain-Enter behavior.
	116	+	OnOpenInNewPane func(ctx context.Context, url string) error
	117	+
	118	+	// OnNavigateKeepOpen is called when Ctrl+Enter activates a URL.
	119	+	// Unlike OnNavigate, the sidebar must NOT be closed after this
	120	+	// callback returns. If nil, Ctrl+Enter falls back to OnNavigate.
	121	+	OnNavigateKeepOpen func(ctx context.Context, url string) error
	122	+
	123	+	// OnClose is called when the sidebar should close itself (e.g. Escape
	124	+	// with empty search). The host should hide the sidebar and restore
	125	+	// focus to the active content pane/webview.
	126	+	OnClose func()
	127	+	}
	128	+
	129	+	// NewHistorySidebar creates a new HistorySidebar component.
	130	+	func NewHistorySidebar(ctx context.Context, cfg HistorySidebarConfig) *HistorySidebar {
	131	+	ctx, cancel := context.WithCancel(ctx)
	132	+	log := logging.FromContext(ctx).With().Str("component", "history-sidebar").Logger()
	133	+
	134	+	hs := &HistorySidebar{
	135	+	historyUC: cfg.HistoryUC,
	136	+	onURL: func(callCtx context.Context, url string) {
	137	+	if cfg.OnNavigate != nil {
	138	+	if err := cfg.OnNavigate(callCtx, url); err != nil {
	139	+	log.Error().Err(err).Str("url", url).Msg("history sidebar navigate failed")
	140	+	}
	141	+	}
	142	+	},
	143	+	onOpenInNewPane: func(callCtx context.Context, url string) error {
	144	+	if cfg.OnOpenInNewPane == nil {
	145	+	// Fall back to regular navigation when no new-pane handler set
	146	+	if cfg.OnNavigate != nil {
	147	+	return cfg.OnNavigate(callCtx, url)
	148	+	}
	149	+	return nil
	150	+	}
	151	+	return cfg.OnOpenInNewPane(callCtx, url)
	152	+	},
	153	+	onNavigateKeepOpen: func(callCtx context.Context, url string) {
	154	+	if cfg.OnNavigateKeepOpen != nil {
	155	+	if err := cfg.OnNavigateKeepOpen(callCtx, url); err != nil {
	156	+	log.Error().Err(err).Str("url", url).Msg("history sidebar keep-open navigate failed")
	157	+	}
	158	+	} else if cfg.OnNavigate != nil {
	159	+	// Fall back to the default navigate path when no dedicated
	160	+	// keep-open callback is configured.
	161	+	if err := cfg.OnNavigate(callCtx, url); err != nil {
	162	+	log.Error().Err(err).Str("url", url).Msg("history sidebar keep-open fallback failed")
	163	+	}
	164	+	}
	165	+	},
	166	+	onClose: func() {
	167	+	if cfg.OnClose != nil {
	168	+	cfg.OnClose()
	169	+	}
	170	+	},
	171	+	logger: log,
	172	+	ctx: ctx,
	173	+	cancel: cancel,
	174	+	hasMore: cfg.HistoryUC != nil,
	175	+	}
	176	+
	177	+	if err := hs.createWidgets(); err != nil {
	178	+	log.Error().Err(err).Msg("failed to create history sidebar widgets")
	179	+	cancel()
	180	+	return nil
	181	+	}
	182	+
	183	+	hs.setupSearchHandler()
	184	+	hs.setupScrollLoadMore()
	185	+	hs.setupKeyboardNavigation()
	186	+
	187	+	log.Debug().Msg("history sidebar created")
	188	+
	189	+	// Start loading history asynchronously (background goroutine)
	190	+	hs.startLoadHistory()
	191	+
	192	+	return hs
	193	+	}
	194	+
	195	+	// Destroy cleans up the sidebar and releases resources.
	196	+	func (hs *HistorySidebar) Destroy() {
	197	+	hs.mu.Lock()
	198	+	if hs.destroyed {
	199	+	hs.mu.Unlock()
	200	+	return
	201	+	}
	202	+	hs.destroyed = true
	203	+	timerID := hs.debounceTimer
	204	+	hs.debounceTimer = 0
	205	+	hs.mu.Unlock()
	206	+
	207	+	if hs.cancel != nil {
	208	+	hs.cancel()
	209	+	}
	210	+
	211	+	if timerID != 0 {
	212	+	glib.SourceRemove(timerID)
	213	+	}
	214	+	}
	215	+
	216	+	// WidgetAsLayout returns the sidebar's outer widget for embedding.
	217	+	func (hs *HistorySidebar) WidgetAsLayout(factory layout.WidgetFactory) layout.Widget {
	218	+	if hs.outerBox == nil {
	219	+	return nil
	220	+	}
	221	+	return factory.WrapWidget(&hs.outerBox.Widget)
	222	+	}
	223	+
	224	+	// Widget returns the raw GTK widget.
	225	+	func (hs HistorySidebar) Widget() gtk.Widget {
	226	+	if hs.outerBox == nil {
	227	+	return nil
	228	+	}
	229	+	return &hs.outerBox.Widget
	230	+	}
	231	+
	232	+	// Show displays the sidebar and focuses the search entry.
	233	+	// History data is refreshed asynchronously so Ctrl+H always shows
	234	+	// current recent visits, not stale data from initialization.
	235	+	func (hs *HistorySidebar) Show() {
	236	+	hs.mu.Lock()
	237	+	if hs.outerBox == nil \|\| hs.destroyed {
	238	+	hs.mu.Unlock()
	239	+	return
	240	+	}
	241	+
	242	+	hs.outerBox.SetVisible(true)
	243	+	hs.visible = true
	244	+	hs.mu.Unlock()
	245	+
	246	+	// Schedule a background reload so the sidebar shows fresh data
	247	+	// when it becomes visible, not stale data captured at init time.
	248	+	reloadCb := glib.SourceFunc(func(uintptr) bool {
	249	+	hs.mu.RLock()
	250	+	destroyed := hs.destroyed
	251	+	hs.mu.RUnlock()
	252	+	if destroyed {
	253	+	return false
	254	+	}
	255	+	hs.Reload()
	256	+	return false
	257	+	})
	258	+	hs.scheduleIdle(reloadCb)
	259	+
	260	+	// Focus search entry via idle callback to ensure layout is stable.
	261	+	cb := glib.SourceFunc(func(uintptr) bool {
	262	+	hs.mu.RLock()
	263	+	destroyed := hs.destroyed
	264	+	entry := hs.searchEntry
	265	+	hs.mu.RUnlock()
	266	+	if destroyed \|\| entry == nil {
	267	+	return false
	268	+	}
	269	+	entry.GrabFocus()
	270	+	return false
	271	+	})
	272	+	hs.scheduleIdle(cb)
	273	+	}
	274	+
	275	+	// Hide hides the sidebar.
	276	+	func (hs *HistorySidebar) Hide() {
	277	+	hs.mu.Lock()
	278	+	defer hs.mu.Unlock()
	279	+
	280	+	if hs.outerBox == nil \|\| hs.destroyed {
	281	+	return
	282	+	}
	283	+
	284	+	hs.outerBox.SetVisible(false)
	285	+	hs.visible = false
	286	+	}
	287	+
	288	+	// IsVisible returns whether the sidebar is visible.
	289	+	func (hs *HistorySidebar) IsVisible() bool {
	290	+	hs.mu.RLock()
	291	+	defer hs.mu.RUnlock()
	292	+	return hs.visible
	293	+	}
	294	+
	295	+	// Reload triggers a fresh load of history data. Preserves the current search
	296	+	// query, scroll position, and selection.
	297	+	func (hs *HistorySidebar) Reload() {
	298	+	hs.mu.Lock()
	299	+	if hs.destroyed {
	300	+	hs.mu.Unlock()
	301	+	return
	302	+	}
	303	+	hs.preserveScrollAndSelection()
	304	+	savedQuery := hs.currentQuery
	305	+
	306	+	// Reset all data state but keep the query preserved so the search entry
	307	+	// text and internal state remain consistent.
	308	+	hs.loadDone = false
	309	+	hs.loadStarted = false
	310	+	hs.totalLoaded = 0
	311	+	hs.hasMore = hs.historyUC != nil
	312	+	hs.isLoading = false
	313	+	hs.allEntries = nil
	314	+	hs.setDisplayGroupsLocked(nil)
	315	+	hs.searchResults = nil
	316	+	hs.searchDone = false
	317	+	hs.searchErr = nil
	318	+
	319	+	if savedQuery == "" {
	320	+	hs.currentQuery = ""
	321	+	hs.mu.Unlock()
	322	+	hs.startLoadHistory()
	323	+	} else {
	324	+	hs.currentQuery = savedQuery
	325	+	hs.searchGen++ // Invalidate any in-flight search
	326	+	gen := hs.searchGen
	327	+	hs.mu.Unlock()
	328	+	hs.scheduleClearList()
	329	+	hs.doFTSearch(savedQuery, gen)
	330	+	}
	331	+	}
	332	+
	333	+	// SetSearchQuery externally sets the search text and triggers filtering.
	334	+	func (hs *HistorySidebar) SetSearchQuery(query string) {
	335	+	hs.mu.RLock()
	336	+	entry := hs.searchEntry
	337	+	hs.mu.RUnlock()
	338	+	if entry != nil {
	339	+	entry.SetText(query)
	340	+	}
	341	+	}
	342	+
	343	+	// ClearSearch clears the search entry text.
	344	+	func (hs *HistorySidebar) ClearSearch() {
	345	+	hs.SetSearchQuery("")
	346	+	}
	347	+
	348	+	// =============================================================================
	349	+	// Helpers
	350	+	// =============================================================================
	351	+
	352	+	func safeSidebarString(s, fallback string) string {
	353	+	if s == "" {
	354	+	return fallback
	355	+	}
	356	+	return s
	357	+	}

A internal/ui/component/history_sidebar_keyboard.go +598 -0

@@ -0,0 +1,598 @@
	1	+	package component
	2	+
	3	+	import (
	4	+	"github.com/bnema/puregotk/v4/gdk"
	5	+	"github.com/bnema/puregotk/v4/glib"
	6	+	"github.com/bnema/puregotk/v4/gtk"
	7	+
	8	+	"github.com/bnema/dumber/internal/domain/entity"
	9	+	)
	10	+
	11	+	// =============================================================================
	12	+	// Keyboard navigation
	13	+	// =============================================================================
	14	+
	15	+	func (hs *HistorySidebar) setupKeyboardNavigation() {
	16	+	if hs.outerBox == nil {
	17	+	return
	18	+	}
	19	+
	20	+	// The ListBox already supports Up/Down arrow navigation natively.
	21	+	// We add a PhaseCapture key controller on the outerBox to intercept
	22	+	// keys before the ListBox processes them.
	23	+	keyController := gtk.NewEventControllerKey()
	24	+	if keyController == nil {
	25	+	return
	26	+	}
	27	+	keyController.SetPropagationPhase(gtk.PhaseCaptureValue)
	28	+
	29	+	keyPressedCb := func(_ gtk.EventControllerKey, keyval uint, _ uint, state gdk.ModifierType) bool {
	30	+	switch keyval {
	31	+	// --- Escape: clear search or close sidebar ---
	32	+	case uint(gdk.KEY_Escape):
	33	+	if hs.searchEntry != nil && hs.searchEntry.GetText() != "" {
	34	+	hs.searchEntry.SetText("")
	35	+	return true
	36	+	}
	37	+	// Close sidebar explicitly and restore focus
	38	+	hs.closeSidebar()
	39	+	return true
	40	+
	41	+	// --- Enter variants ---
	42	+	case uint(gdk.KEY_Return), uint(gdk.KEY_KP_Enter):
	43	+	return hs.handleEnterKey(state)
	44	+
	45	+	// --- Delete: remove selected entry ---
	46	+	case uint(gdk.KEY_Delete), uint(gdk.KEY_KP_Delete):
	47	+	if hs.searchEntry != nil && hs.searchEntry.GetText() != "" {
	48	+	return false
	49	+	}
	50	+	return hs.handleDeleteKey()
	51	+
	52	+	// --- PageUp / PageDown: scroll by page ---
	53	+	case uint(gdk.KEY_Page_Up):
	54	+	hs.scrollByPage(-1)
	55	+	return true
	56	+	case uint(gdk.KEY_Page_Down):
	57	+	hs.scrollByPage(1)
	58	+	return true
	59	+
	60	+	// --- Home / End: jump to first/last selectable row ---
	61	+	case uint(gdk.KEY_Home):
	62	+	hs.jumpToFirstSelectable()
	63	+	return true
	64	+	case uint(gdk.KEY_End):
	65	+	hs.jumpToLastSelectable()
	66	+	return true
	67	+
	68	+	// --- Up / Down: previous / next selectable row ---
	69	+	// Ctrl+Up / Ctrl+Down: previous / next day group jump ---
	70	+	case uint(gdk.KEY_Up):
	71	+	if state&gdk.ControlMaskValue != 0 {
	72	+	hs.jumpToPreviousDay()
	73	+	return true
	74	+	}
	75	+	hs.selectPreviousRow()
	76	+	return true
	77	+	case uint(gdk.KEY_Down):
	78	+	if state&gdk.ControlMaskValue != 0 {
	79	+	hs.jumpToNextDay()
	80	+	return true
	81	+	}
	82	+	hs.selectNextRow()
	83	+	return true
	84	+	}
	85	+
	86	+	return false
	87	+	}
	88	+
	89	+	hs.retainedCallbacks = append(hs.retainedCallbacks, keyPressedCb)
	90	+	keyController.ConnectKeyPressed(&keyPressedCb)
	91	+
	92	+	hs.outerBox.AddController(&keyController.EventController)
	93	+	}
	94	+
	95	+	// handleEnterKey processes Enter, Ctrl+Enter, and Shift+Enter on a selected row.
	96	+	// Returns true if the key was consumed.
	97	+	func (hs *HistorySidebar) handleEnterKey(state gdk.ModifierType) bool {
	98	+	// Determine activation mode from modifiers
	99	+	var action HistorySidebarKeyboardAction
	100	+
	101	+	switch {
	102	+	case state&gdk.ControlMaskValue != 0:
	103	+	// Ctrl+Enter: navigate but keep sidebar open
	104	+	action = SidebarActionKeepOpenOnActivate
	105	+	case state&gdk.ShiftMaskValue != 0:
	106	+	// Shift+Enter: navigate in new pane
	107	+	action = SidebarActionNewPaneOnActivate
	108	+	default:
	109	+	// Plain Enter: navigate using the default activation behavior.
	110	+	action = SidebarActionCloseOnActivate
	111	+	}
	112	+
	113	+	// Find the selected row and its URL
	114	+	row := hs.listBox.GetSelectedRow()
	115	+	if row == nil \|\| !row.GetSelectable() {
	116	+	return false
	117	+	}
	118	+
	119	+	hs.mu.RLock()
	120	+	url := hs.entryURLAtIndex(row.GetIndex())
	121	+	hs.mu.RUnlock()
	122	+	if url == "" {
	123	+	return false
	124	+	}
	125	+
	126	+	// Schedule activation on the GTK main thread
	127	+	switch action {
	128	+	case SidebarActionKeepOpenOnActivate:
	129	+	hs.navigateWithoutClosing(url)
	130	+	case SidebarActionNewPaneOnActivate:
	131	+	hs.navigateToNewPane(url)
	132	+	default:
	133	+	hs.navigateToURL(url)
	134	+	}
	135	+
	136	+	// Consume the key event
	137	+	return true
	138	+	}
	139	+
	140	+	// handleDeleteKey removes the selected history entry and updates the selection.
	141	+	// Returns true if the key was consumed.
	142	+	func (hs *HistorySidebar) handleDeleteKey() bool {
	143	+	row := hs.listBox.GetSelectedRow()
	144	+	if row == nil \|\| !row.GetSelectable() {
	145	+	return false
	146	+	}
	147	+	if hs.historyUC == nil {
	148	+	return false
	149	+	}
	150	+
	151	+	idx := row.GetIndex()
	152	+
	153	+	hs.mu.RLock()
	154	+	url := hs.entryURLAtIndex(idx)
	155	+	entryID := hs.findEntryIDByIndex(idx)
	156	+	nextSelectedURL := ""
	157	+	if nextRow := hs.findNextSelectableAfter(idx); nextRow != -1 {
	158	+	nextSelectedURL = hs.entryURLAtIndex(nextRow)
	159	+	}
	160	+	hs.mu.RUnlock()
	161	+
	162	+	if url == "" \|\| entryID <= 0 {
	163	+	return false
	164	+	}
	165	+
	166	+	go func() {
	167	+	if err := hs.historyUC.Delete(hs.ctx, entryID); err != nil {
	168	+	hs.logger.Error().Err(err).Int64("entry_id", entryID).Msg("failed to delete history entry")
	169	+	return
	170	+	}
	171	+
	172	+	cb := glib.SourceFunc(func(uintptr) bool {
	173	+	hs.mu.Lock()
	174	+	if hs.destroyed {
	175	+	hs.mu.Unlock()
	176	+	return false
	177	+	}
	178	+	hs.applyDeletedEntryLocked(entryID, nextSelectedURL)
	179	+	hs.mu.Unlock()
	180	+
	181	+	hs.rebuildList()
	182	+	return false
	183	+	})
	184	+	hs.scheduleIdle(cb)
	185	+	}()
	186	+
	187	+	return true
	188	+	}
	189	+
	190	+	// applyDeletedEntryLocked updates local sidebar state after a successful
	191	+	// history delete. Must be called with hs.mu write lock held.
	192	+	func (hs *HistorySidebar) applyDeletedEntryLocked(entryID int64, nextSelectedURL string) {
	193	+	hs.preserveScrollAndSelection()
	194	+	hs.prevSelectedURL = nextSelectedURL
	195	+	hs.searchGen++
	196	+	hs.loadGen++
	197	+	hs.isLoading = false
	198	+	hs.loadStarted = false
	199	+	hs.removeFromAllEntries(entryID)
	200	+	hs.totalLoaded = len(hs.allEntries)
	201	+	hs.removeFromSearchResults(entryID)
	202	+	hs.rebuildLocalGroups()
	203	+	}
	204	+
	205	+	// findEntryIDByIndex returns the entry ID for the linear ListBox index.
	206	+	// Must be called with hs.mu read lock held.
	207	+	func (hs *HistorySidebar) findEntryIDByIndex(index int) int64 {
	208	+	entry := newKeyboardNavModelFromRows(hs.displayRows).entryAt(index)
	209	+	if entry == nil {
	210	+	return 0
	211	+	}
	212	+	return entry.ID
	213	+	}
	214	+
	215	+	// rebuildLocalGroups rebuilds hs.groups from the current allEntries and query.
	216	+	// Must be called with hs.mu write lock held.
	217	+	func (hs *HistorySidebar) rebuildLocalGroups() {
	218	+	if hs.currentQuery == "" {
	219	+	hs.setDisplayGroupsLocked(groupHistoryByDay(hs.allEntries))
	220	+	} else if hs.searchResults != nil {
	221	+	hs.setDisplayGroupsLocked(groupHistoryByDay(hs.searchResults))
	222	+	} else {
	223	+	// For search mode, the search results are handled by doFTSearch.
	224	+	// Removing an entry while in search mode would need a re-search.
	225	+	// Fall back to grouping searchResults if they exist.
	226	+	hs.setDisplayGroupsLocked(nil)
	227	+	}
	228	+	}
	229	+
	230	+	// removeFromAllEntries removes all history entries matching the given URL or ID
	231	+	// from hs.allEntries. Must be called with hs.mu write lock held.
	232	+	func (hs *HistorySidebar) removeFromAllEntries(id int64) {
	233	+	filtered := make([]*entity.HistoryEntry, 0, len(hs.allEntries))
	234	+	for _, e := range hs.allEntries {
	235	+	if e != nil && e.ID == id {
	236	+	continue
	237	+	}
	238	+	filtered = append(filtered, e)
	239	+	}
	240	+	hs.allEntries = filtered
	241	+	}
	242	+
	243	+	// removeFromSearchResults removes all history entries matching the given ID
	244	+	// from hs.searchResults. Must be called with hs.mu write lock held.
	245	+	func (hs *HistorySidebar) removeFromSearchResults(id int64) {
	246	+	if hs.searchResults == nil {
	247	+	return
	248	+	}
	249	+	filtered := make([]*entity.HistoryEntry, 0, len(hs.searchResults))
	250	+	for _, e := range hs.searchResults {
	251	+	if e != nil && e.ID == id {
	252	+	continue
	253	+	}
	254	+	filtered = append(filtered, e)
	255	+	}
	256	+	hs.searchResults = filtered
	257	+	}
	258	+
	259	+	// findNextSelectableAfter returns the ListBox index of the next selectable
	260	+	// row after the given index, falling back to the previous selectable row.
	261	+	// Must be called with hs.mu read lock held.
	262	+	func (hs *HistorySidebar) findNextSelectableAfter(idx int) int {
	263	+	model := newKeyboardNavModelFromRows(hs.displayRows)
	264	+	if next := model.nextSelectableIndex(idx, +1); next != -1 {
	265	+	return next
	266	+	}
	267	+	if prev := model.nextSelectableIndex(idx, -1); prev != -1 {
	268	+	return prev
	269	+	}
	270	+	return -1
	271	+	}
	272	+
	273	+	// scrollByPage scrolls the list by one page up or down,
	274	+	// keeping the selection visible.
	275	+	func (hs *HistorySidebar) scrollByPage(direction int) {
	276	+	if hs.scrolledWin == nil {
	277	+	return
	278	+	}
	279	+	vadj := hs.scrolledWin.GetVadjustment()
	280	+	if vadj == nil {
	281	+	return
	282	+	}
	283	+	pageSize := vadj.GetPageSize()
	284	+	current := vadj.GetValue()
	285	+	newVal := current + float64(direction)(pageSize0.9) // 90% page for overlap
	286	+	if newVal < 0 {
	287	+	newVal = 0
	288	+	}
	289	+	upper := vadj.GetUpper() - pageSize
	290	+	if newVal > upper {
	291	+	newVal = upper
	292	+	}
	293	+	if newVal >= 0 {
	294	+	vadj.SetValue(newVal)
	295	+	}
	296	+	}
	297	+
	298	+	// jumpToPreviousDay selects the first entry in the previous day group
	299	+	// relative to the currently selected row.
	300	+	func (hs *HistorySidebar) jumpToPreviousDay() {
	301	+	currentIdx := -1
	302	+	if row := hs.listBox.GetSelectedRow(); row != nil {
	303	+	currentIdx = row.GetIndex()
	304	+	}
	305	+
	306	+	hs.mu.RLock()
	307	+	targetIdx := newKeyboardNavModelFromRows(hs.displayRows).previousDayBoundary(currentIdx)
	308	+	hs.mu.RUnlock()
	309	+	if targetIdx == -1 {
	310	+	hs.jumpToFirstSelectable()
	311	+	return
	312	+	}
	313	+	if row := hs.listBox.GetRowAtIndex(targetIdx); row != nil && row.GetSelectable() {
	314	+	hs.listBox.SelectRow(row)
	315	+	hs.scrollRowIntoView(targetIdx)
	316	+	return
	317	+	}
	318	+	hs.jumpToFirstSelectable()
	319	+	}
	320	+
	321	+	// jumpToNextDay selects the first entry in the next day group
	322	+	// relative to the currently selected row.
	323	+	func (hs *HistorySidebar) jumpToNextDay() {
	324	+	currentIdx := -1
	325	+	if row := hs.listBox.GetSelectedRow(); row != nil {
	326	+	currentIdx = row.GetIndex()
	327	+	}
	328	+
	329	+	hs.mu.RLock()
	330	+	targetIdx := newKeyboardNavModelFromRows(hs.displayRows).nextDayBoundary(currentIdx)
	331	+	hs.mu.RUnlock()
	332	+	if targetIdx == -1 {
	333	+	hs.jumpToLastSelectable()
	334	+	return
	335	+	}
	336	+	if row := hs.listBox.GetRowAtIndex(targetIdx); row != nil && row.GetSelectable() {
	337	+	hs.listBox.SelectRow(row)
	338	+	hs.scrollRowIntoView(targetIdx)
	339	+	return
	340	+	}
	341	+	hs.jumpToLastSelectable()
	342	+	}
	343	+
	344	+	// scrollRowIntoView scrolls the scrolled window to ensure the row at
	345	+	// the given ListBox index is visible.
	346	+	func (hs *HistorySidebar) scrollRowIntoView(index int) {
	347	+	hs.ensureRowVisible(index)
	348	+	}
	349	+
	350	+	// jumpToFirstSelectable selects the first selectable row in the list.
	351	+	func (hs *HistorySidebar) jumpToFirstSelectable() {
	352	+	for i := 0; ; i++ {
	353	+	row := hs.listBox.GetRowAtIndex(i)
	354	+	if row == nil {
	355	+	break
	356	+	}
	357	+	if row.GetSelectable() {
	358	+	hs.listBox.SelectRow(row)
	359	+	hs.ensureRowVisible(i)
	360	+	return
	361	+	}
	362	+	}
	363	+	}
	364	+
	365	+	// jumpToLastSelectable selects the last selectable row in the list.
	366	+	func (hs *HistorySidebar) jumpToLastSelectable() {
	367	+	// Walk backwards through the rows
	368	+	maxIdx := 0
	369	+	var lastRow *gtk.ListBoxRow
	370	+	for i := 0; ; i++ {
	371	+	row := hs.listBox.GetRowAtIndex(i)
	372	+	if row == nil {
	373	+	break
	374	+	}
	375	+	maxIdx = i
	376	+	if row.GetSelectable() {
	377	+	lastRow = row
	378	+	}
	379	+	}
	380	+	// GetRowAtIndex returns nil once the index is past the end of the list,
	381	+	// so this scan terminates naturally at the first missing row.
	382	+	// If we found a selectable row, try it. Otherwise fall back to last row.
	383	+	if lastRow != nil {
	384	+	hs.listBox.SelectRow(lastRow)
	385	+	hs.ensureRowVisible(lastRow.GetIndex())
	386	+	return
	387	+	}
	388	+	// Fallback: last row regardless of selectability
	389	+	if maxIdx > 0 {
	390	+	if row := hs.listBox.GetRowAtIndex(maxIdx); row != nil {
	391	+	hs.listBox.SelectRow(row)
	392	+	hs.ensureRowVisible(maxIdx)
	393	+	}
	394	+	}
	395	+	}
	396	+
	397	+	// =============================================================================
	398	+	// Up/Down row selection (with search entry focus preserved)
	399	+	// =============================================================================
	400	+
	401	+	// selectPreviousRow selects the previous selectable row (skipping headers).
	402	+	// Focus remains in the search entry; the ListBox selection is updated
	403	+	// programmatically and scrolled into view.
	404	+	func (hs *HistorySidebar) selectPreviousRow() {
	405	+	hs.selectAdjacentRow(-1)
	406	+	}
	407	+
	408	+	// selectNextRow selects the next selectable row (skipping headers).
	409	+	// Focus remains in the search entry; the ListBox selection is updated
	410	+	// programmatically and scrolled into view.
	411	+	func (hs *HistorySidebar) selectNextRow() {
	412	+	hs.selectAdjacentRow(1)
	413	+	}
	414	+
	415	+	// selectAdjacentRow moves selection by direction (-1 or +1) to the next
	416	+	// selectable row, skipping non-selectable (header) rows. If nothing is
	417	+	// currently selected, it selects the first (down) or last (up) selectable
	418	+	// row. Focus remains in the search entry.
	419	+	func (hs *HistorySidebar) selectAdjacentRow(direction int) {
	420	+	if hs.listBox == nil {
	421	+	return
	422	+	}
	423	+
	424	+	current := -1
	425	+	if row := hs.listBox.GetSelectedRow(); row != nil {
	426	+	current = row.GetIndex()
	427	+	}
	428	+
	429	+	hs.mu.RLock()
	430	+	model := newKeyboardNavModelFromRows(hs.displayRows)
	431	+	var target int
	432	+	if current < 0 {
	433	+	if direction > 0 {
	434	+	target = model.firstSelectableIndex()
	435	+	} else {
	436	+	target = model.lastSelectableIndex()
	437	+	}
	438	+	} else {
	439	+	target = model.nextSelectableIndex(current, direction)
	440	+	}
	441	+	hs.mu.RUnlock()
	442	+
	443	+	if target == -1 {
	444	+	return
	445	+	}
	446	+	if row := hs.listBox.GetRowAtIndex(target); row != nil && row.GetSelectable() {
	447	+	hs.listBox.SelectRow(row)
	448	+	hs.ensureRowVisible(target)
	449	+	}
	450	+	}
	451	+
	452	+	// ensureRowVisible adjusts the scrolled window so the row at index is
	453	+	// visible, WITHOUT calling GrabFocus (preserving search entry focus).
	454	+	// The Y position is computed by summing the allocated heights of all
	455	+	// preceding rows.
	456	+	func (hs *HistorySidebar) ensureRowVisible(index int) {
	457	+	if hs.scrolledWin == nil \|\| hs.listBox == nil {
	458	+	return
	459	+	}
	460	+	vadj := hs.scrolledWin.GetVadjustment()
	461	+	if vadj == nil {
	462	+	return
	463	+	}
	464	+	row := hs.listBox.GetRowAtIndex(index)
	465	+	if row == nil {
	466	+	return
	467	+	}
	468	+
	469	+	// Sum allocated heights of all preceding rows to estimate Y position.
	470	+	var yPos int
	471	+	for i := 0; i < index; i++ {
	472	+	r := hs.listBox.GetRowAtIndex(i)
	473	+	if r == nil {
	474	+	continue
	475	+	}
	476	+	yPos += r.GetAllocatedHeight()
	477	+	}
	478	+
	479	+	rowHeight := row.GetAllocatedHeight()
	480	+	if rowHeight <= 0 {
	481	+	return
	482	+	}
	483	+
	484	+	pageSize := vadj.GetPageSize()
	485	+	current := vadj.GetValue()
	486	+	rowTop := float64(yPos)
	487	+	rowBottom := rowTop + float64(rowHeight)
	488	+
	489	+	if rowTop < current {
	490	+	// Row is above the visible area — scroll up.
	491	+	vadj.SetValue(rowTop)
	492	+	} else if rowBottom > current+pageSize {
	493	+	// Row is below the visible area — scroll down.
	494	+	vadj.SetValue(rowBottom - pageSize)
	495	+	}
	496	+	}
	497	+
	498	+	// =============================================================================
	499	+	// Row activation (Enter / click)
	500	+	// =============================================================================
	501	+
	502	+	func (hs HistorySidebar) onRowActivated(row gtk.ListBoxRow) {
	503	+	if row == nil \|\| !row.GetSelectable() {
	504	+	return
	505	+	}
	506	+
	507	+	hs.mu.RLock()
	508	+	// Allow activation when browse is loaded or when search results are available.
	509	+	// This prevents a race where the user searches before the initial browse page
	510	+	// finishes loading — browse may be left unloaded, but search results should
	511	+	// still be activatable.
	512	+	hasSearchResults := hs.searchDone && hs.searchResults != nil
	513	+	if (!hs.loadDone && !hasSearchResults) \|\| len(hs.groups) == 0 {
	514	+	hs.mu.RUnlock()
	515	+	return
	516	+	}
	517	+	entry := newKeyboardNavModelFromRows(hs.displayRows).entryAt(row.GetIndex())
	518	+	hs.mu.RUnlock()
	519	+	if entry == nil \|\| entry.URL == "" {
	520	+	return
	521	+	}
	522	+
	523	+	hs.navigateToURL(entry.URL)
	524	+	}
	525	+
	526	+	func (hs *HistorySidebar) navigateToURL(url string) {
	527	+	if hs.onURL == nil \|\| url == "" {
	528	+	return
	529	+	}
	530	+
	531	+	navigateCb := glib.SourceFunc(func(uintptr) bool {
	532	+	hs.mu.RLock()
	533	+	destroyed := hs.destroyed
	534	+	hs.mu.RUnlock()
	535	+	if destroyed {
	536	+	return false
	537	+	}
	538	+	hs.onURL(hs.ctx, url)
	539	+	return false
	540	+	})
	541	+	hs.scheduleIdle(navigateCb)
	542	+	}
	543	+
	544	+	// navigateWithoutClosing navigates to the URL but does NOT close the sidebar.
	545	+	// Used by Ctrl+Enter activation.
	546	+	func (hs *HistorySidebar) navigateWithoutClosing(url string) {
	547	+	if hs.onNavigateKeepOpen == nil \|\| url == "" {
	548	+	return
	549	+	}
	550	+	hs.doNavigateWithoutClose(url)
	551	+	}
	552	+
	553	+	// doNavigateWithoutClose schedules navigation without closing the sidebar.
	554	+	// Uses the dedicated OnNavigateKeepOpen path so hosts can override the
	555	+	// default activation behavior when they need a distinct keep-open action.
	556	+	func (hs *HistorySidebar) doNavigateWithoutClose(url string) {
	557	+	navigateCb := glib.SourceFunc(func(uintptr) bool {
	558	+	hs.mu.RLock()
	559	+	destroyed := hs.destroyed
	560	+	hs.mu.RUnlock()
	561	+	if destroyed {
	562	+	return false
	563	+	}
	564	+	hs.onNavigateKeepOpen(hs.ctx, url)
	565	+	return false
	566	+	})
	567	+	hs.scheduleIdle(navigateCb)
	568	+	}
	569	+
	570	+	// navigateToNewPane navigates to the URL by opening it in a new pane.
	571	+	// The sidebar stays open. Used by Shift+Enter activation.
	572	+	func (hs *HistorySidebar) navigateToNewPane(url string) {
	573	+	if hs.onOpenInNewPane == nil \|\| url == "" {
	574	+	return
	575	+	}
	576	+
	577	+	navigateCb := glib.SourceFunc(func(uintptr) bool {
	578	+	hs.mu.RLock()
	579	+	destroyed := hs.destroyed
	580	+	hs.mu.RUnlock()
	581	+	if destroyed {
	582	+	return false
	583	+	}
	584	+	if err := hs.onOpenInNewPane(hs.ctx, url); err != nil {
	585	+	hs.logger.Error().Err(err).Str("url", url).Msg("history sidebar new-pane navigation failed")
	586	+	}
	587	+	return false
	588	+	})
	589	+	hs.scheduleIdle(navigateCb)
	590	+	}
	591	+
	592	+	// closeSidebar calls the configured OnClose callback to tell the host to
	593	+	// hide the sidebar and restore focus to the active content pane/webview.
	594	+	func (hs *HistorySidebar) closeSidebar() {
	595	+	if hs.onClose != nil {
	596	+	hs.onClose()
	597	+	}
	598	+	}

A internal/ui/component/history_sidebar_loading_search.go +442 -0

@@ -0,0 +1,442 @@
	1	+	package component
	2	+
	3	+	import (
	4	+	"github.com/bnema/puregotk/v4/glib"
	5	+	"github.com/bnema/puregotk/v4/gtk"
	6	+
	7	+	"github.com/bnema/dumber/internal/application/dto"
	8	+	"github.com/bnema/dumber/internal/domain/entity"
	9	+	)
	10	+
	11	+	// =============================================================================
	12	+	// Data loading — background goroutine with paging
	13	+	// =============================================================================
	14	+
	15	+	func (hs *HistorySidebar) startLoadHistory() {
	16	+	hs.mu.Lock()
	17	+	hs.loadGen++
	18	+	gen := hs.loadGen
	19	+	hs.loadStarted = true
	20	+	hs.isLoading = true
	21	+	hs.mu.Unlock()
	22	+
	23	+	// Fetch first page in a background goroutine
	24	+	go hs.fetchPage(0, gen)
	25	+	}
	26	+
	27	+	// fetchPage fetches a page of history entries in a background goroutine
	28	+	// and schedules the UI update on the GTK main thread.
	29	+	func (hs *HistorySidebar) fetchPage(offset int, gen uint64) {
	30	+	hs.mu.RLock()
	31	+	uc := hs.historyUC
	32	+	ctx := hs.ctx
	33	+	hs.mu.RUnlock()
	34	+
	35	+	if uc == nil \|\| ctx == nil {
	36	+	// No provider; show empty state
	37	+	cb := glib.SourceFunc(func(uintptr) bool {
	38	+	hs.mu.Lock()
	39	+	if hs.destroyed {
	40	+	hs.mu.Unlock()
	41	+	return false
	42	+	}
	43	+	hs.loadStarted = false
	44	+	hs.isLoading = false
	45	+	hs.loadDone = true
	46	+	hs.hasMore = false
	47	+	hs.mu.Unlock()
	48	+	hs.scheduleRebuild()
	49	+	return false
	50	+	})
	51	+	hs.scheduleIdle(cb)
	52	+	return
	53	+	}
	54	+
	55	+	entries, err := uc.GetRecent(ctx, sidebarPageSize, offset)
	56	+	if err != nil {
	57	+	hs.logger.Error().Err(err).Int("offset", offset).Msg("failed to load history page")
	58	+	}
	59	+
	60	+	if entries == nil {
	61	+	entries = []*entity.HistoryEntry{}
	62	+	}
	63	+
	64	+	hasMore := len(entries) >= sidebarPageSize
	65	+
	66	+	hs.mu.Lock()
	67	+
	68	+	// If a newer load was started since this fetch began, drop stale results.
	69	+	// Must NOT mutate isLoading/loadStarted — they belong to the current
	70	+	// generation set by startLoadHistory or LoadMore.
	71	+	if gen != hs.loadGen {
	72	+	hs.mu.Unlock()
	73	+	return
	74	+	}
	75	+
	76	+	// If search is active, don't update browse state with stale page data
	77	+	// and don't overwrite search results.
	78	+	if hs.currentQuery != "" {
	79	+	hs.isLoading = false
	80	+	hs.loadStarted = false
	81	+	hs.mu.Unlock()
	82	+	return
	83	+	}
	84	+
	85	+	hs.totalLoaded = offset + len(entries)
	86	+	hs.hasMore = hasMore
	87	+	hs.isLoading = false
	88	+	hs.loadStarted = false
	89	+	hs.loadDone = true
	90	+
	91	+	if offset == 0 {
	92	+	// First page: replace all entries
	93	+	hs.allEntries = entries
	94	+	} else {
	95	+	// Subsequent page: append
	96	+	hs.allEntries = append(hs.allEntries, entries...)
	97	+	}
	98	+
	99	+	// Group for display
	100	+	hs.setDisplayGroupsLocked(groupHistoryByDay(hs.allEntries))
	101	+	hs.mu.Unlock()
	102	+
	103	+	// Schedule UI rebuild on GTK main thread
	104	+	cb := glib.SourceFunc(func(uintptr) bool {
	105	+	hs.rebuildList()
	106	+	return false
	107	+	})
	108	+	hs.scheduleIdle(cb)
	109	+	}
	110	+
	111	+	// LoadMore fetches the next page and appends it to the existing entries.
	112	+	func (hs *HistorySidebar) LoadMore() {
	113	+	hs.mu.Lock()
	114	+	if hs.isLoading \|\| !hs.hasMore \|\| hs.destroyed \|\| hs.currentQuery != "" {
	115	+	hs.mu.Unlock()
	116	+	return
	117	+	}
	118	+	hs.isLoading = true
	119	+	offset := hs.totalLoaded
	120	+	gen := hs.loadGen
	121	+	hs.mu.Unlock()
	122	+
	123	+	hs.logger.Debug().Int("offset", offset).Msg("loading more history entries")
	124	+	go hs.fetchPage(offset, gen)
	125	+	}
	126	+
	127	+	// =============================================================================
	128	+	// Scroll-aware load-more: detects when the user reaches the bottom
	129	+	// =============================================================================
	130	+
	131	+	func (hs *HistorySidebar) setupScrollLoadMore() {
	132	+	if hs.scrolledWin == nil {
	133	+	return
	134	+	}
	135	+
	136	+	vadj := hs.scrolledWin.GetVadjustment()
	137	+	if vadj == nil {
	138	+	return
	139	+	}
	140	+
	141	+	changedCb := func(_ gtk.Adjustment) {
	142	+	hs.mu.RLock()
	143	+	if hs.destroyed \|\| !hs.hasMore \|\| hs.isLoading {
	144	+	hs.mu.RUnlock()
	145	+	return
	146	+	}
	147	+	value := vadj.GetValue()
	148	+	upper := vadj.GetUpper()
	149	+	pageSize := vadj.GetPageSize()
	150	+	hs.mu.RUnlock()
	151	+
	152	+	// Trigger load-more when within 200px of the bottom
	153	+	if pageSize > 0 && value+pageSize >= upper-200.0 {
	154	+	hs.LoadMore()
	155	+	}
	156	+	}
	157	+	hs.retainedCallbacks = append(hs.retainedCallbacks, changedCb)
	158	+	vadj.ConnectValueChanged(&changedCb)
	159	+	}
	160	+
	161	+	// =============================================================================
	162	+	// Scroll/selection preservation
	163	+	// =============================================================================
	164	+
	165	+	// preserveScrollAndSelection saves the current scroll position and selected row
	166	+	// URL before a rebuild. Must be called with hs.mu write lock held.
	167	+	func (hs *HistorySidebar) preserveScrollAndSelection() {
	168	+	hs.prevScrollValue = 0
	169	+	hs.prevSelectedURL = ""
	170	+
	171	+	if hs.scrolledWin != nil {
	172	+	if vadj := hs.scrolledWin.GetVadjustment(); vadj != nil {
	173	+	hs.prevScrollValue = vadj.GetValue()
	174	+	}
	175	+	}
	176	+	if hs.listBox != nil {
	177	+	if selected := hs.listBox.GetSelectedRow(); selected != nil {
	178	+	if url := hs.entryURLAtIndex(selected.GetIndex()); url != "" {
	179	+	hs.prevSelectedURL = url
	180	+	}
	181	+	}
	182	+	}
	183	+	}
	184	+
	185	+	// restoreScrollAndSelection restores the previously saved scroll position and
	186	+	// selection after a rebuild. Called on the GTK main thread.
	187	+	func (hs *HistorySidebar) restoreScrollAndSelection() {
	188	+	// Restore selection first (changes scroll position)
	189	+	if hs.prevSelectedURL != "" {
	190	+	hs.selectRowByURL(hs.prevSelectedURL)
	191	+	}
	192	+
	193	+	// Then restore scroll position if we have one
	194	+	if hs.prevScrollValue > 0 && hs.scrolledWin != nil {
	195	+	if vadj := hs.scrolledWin.GetVadjustment(); vadj != nil {
	196	+	maxVal := vadj.GetUpper() - vadj.GetPageSize()
	197	+	if hs.prevScrollValue > maxVal {
	198	+	hs.prevScrollValue = maxVal
	199	+	}
	200	+	vadj.SetValue(hs.prevScrollValue)
	201	+	}
	202	+	}
	203	+
	204	+	hs.prevScrollValue = 0
	205	+	hs.prevSelectedURL = ""
	206	+	}
	207	+
	208	+	// getRowURL extracts the URL stored in a list box row.
	209	+	func (hs HistorySidebar) getRowURL(row gtk.ListBoxRow) string {
	210	+	if row == nil \|\| !row.GetSelectable() {
	211	+	return ""
	212	+	}
	213	+	child := row.GetChild()
	214	+	if child == nil {
	215	+	return ""
	216	+	}
	217	+
	218	+	// The child is the vertical box. Walk children to find our stored URL.
	219	+	// We store the URL directly on the row as data.
	220	+	// Actually, let's use a simpler approach: walk the list box to find the entry.
	221	+	idx := row.GetIndex()
	222	+	hs.mu.RLock()
	223	+	defer hs.mu.RUnlock()
	224	+
	225	+	return hs.entryURLAtIndex(idx)
	226	+	}
	227	+
	228	+	// entryURLAtIndex returns the URL of the history entry at the given
	229	+	// linear list index (including group headers which return "").
	230	+	func (hs *HistorySidebar) entryURLAtIndex(index int) string {
	231	+	return newKeyboardNavModelFromRows(hs.displayRows).entryURLAt(index)
	232	+	}
	233	+
	234	+	// selectRowByURL finds and selects a row whose URL matches.
	235	+	func (hs *HistorySidebar) selectRowByURL(url string) {
	236	+	if url == "" \|\| hs.listBox == nil {
	237	+	return
	238	+	}
	239	+	for i := 0; ; i++ {
	240	+	row := hs.listBox.GetRowAtIndex(i)
	241	+	if row == nil {
	242	+	break
	243	+	}
	244	+	if !row.GetSelectable() {
	245	+	continue
	246	+	}
	247	+	if hs.getRowURL(row) == url {
	248	+	hs.listBox.SelectRow(row)
	249	+	return
	250	+	}
	251	+	}
	252	+	}
	253	+
	254	+	// =============================================================================
	255	+	// Search / filtering
	256	+	// =============================================================================
	257	+
	258	+	func (hs *HistorySidebar) setupSearchHandler() {
	259	+	if hs.searchEntry == nil {
	260	+	return
	261	+	}
	262	+
	263	+	changedCb := func(_ gtk.SearchEntry) {
	264	+	hs.onSearchChanged()
	265	+	}
	266	+	hs.retainedCallbacks = append(hs.retainedCallbacks, changedCb)
	267	+	hs.searchEntry.ConnectSearchChanged(&changedCb)
	268	+	}
	269	+
	270	+	func (hs *HistorySidebar) onSearchChanged() {
	271	+	hs.mu.Lock()
	272	+	if hs.destroyed {
	273	+	hs.mu.Unlock()
	274	+	return
	275	+	}
	276	+	hs.currentQuery = hs.searchEntry.GetText()
	277	+	hs.preserveScrollAndSelection()
	278	+	oldTimer := hs.debounceTimer
	279	+	hs.debounceTimer = 0
	280	+	hs.mu.Unlock()
	281	+
	282	+	if oldTimer != 0 {
	283	+	glib.SourceRemove(oldTimer)
	284	+	}
	285	+
	286	+	filterCb := glib.SourceFunc(func(uintptr) bool {
	287	+	hs.applyFilter()
	288	+	return false
	289	+	})
	290	+	timerID := glib.TimeoutAdd(uint(sidebarSearchDebounceMs), &filterCb, 0)
	291	+
	292	+	hs.mu.Lock()
	293	+	if hs.destroyed {
	294	+	hs.mu.Unlock()
	295	+	if timerID != 0 {
	296	+	glib.SourceRemove(timerID)
	297	+	}
	298	+	return
	299	+	}
	300	+	hs.debounceTimer = timerID
	301	+	hs.mu.Unlock()
	302	+	}
	303	+
	304	+	func (hs *HistorySidebar) applyFilter() {
	305	+	hs.mu.Lock()
	306	+	hs.debounceTimer = 0
	307	+	query := hs.currentQuery
	308	+
	309	+	if query == "" {
	310	+	// Empty query: use in-memory browse entries (paged getRecent).
	311	+	// Clear search state and invalidate any in-flight search so a late
	312	+	// search result doesn't overwrite browse state.
	313	+	hs.searchResults = nil
	314	+	hs.searchDone = false
	315	+	hs.searchGen++
	316	+	hs.setDisplayGroupsLocked(nil)
	317	+	if !hs.loadDone {
	318	+	// Browse was never fully loaded (e.g., a search superseded the
	319	+	// initial page fetch). Clear the list, show a loading indicator,
	320	+	// and restart loading history in the background.
	321	+	hs.mu.Unlock()
	322	+	hs.scheduleRebuild() // Shows "Loading history…" while fetch runs
	323	+	hs.startLoadHistory()
	324	+	return
	325	+	}
	326	+	hs.setDisplayGroupsLocked(groupHistoryByDay(hs.allEntries))
	327	+	hs.mu.Unlock()
	328	+	hs.scheduleRebuild()
	329	+	return
	330	+	}
	331	+
	332	+	// Non-empty query: use real FTS search via the provider.
	333	+	// Cancel any stale in-flight search via generation counter.
	334	+	hs.searchGen++
	335	+	gen := hs.searchGen
	336	+	hs.searchDone = false
	337	+	hs.searchResults = nil
	338	+	hs.setDisplayGroupsLocked(nil)
	339	+	hs.mu.Unlock()
	340	+
	341	+	// Clear the list immediately to avoid showing stale browse results
	342	+	// while the search is in flight.
	343	+	hs.scheduleClearList()
	344	+
	345	+	hs.doFTSearch(query, gen)
	346	+	}
	347	+
	348	+	// doFTSearch runs a history FTS search in a background goroutine and
	349	+	// updates the display when results arrive. Stale results (from a superseded
	350	+	// search generation) are silently dropped.
	351	+	func (hs *HistorySidebar) doFTSearch(query string, gen uint64) {
	352	+	hs.mu.RLock()
	353	+	uc := hs.historyUC
	354	+	ctx := hs.ctx
	355	+	hs.mu.RUnlock()
	356	+
	357	+	if uc == nil \|\| ctx == nil {
	358	+	return
	359	+	}
	360	+
	361	+	go func() {
	362	+	out, err := uc.Search(ctx, dto.HistorySearchInput{Query: query, Limit: sidebarSearchLimit})
	363	+	var entries []*entity.HistoryEntry
	364	+	if out != nil {
	365	+	entries = make([]*entity.HistoryEntry, len(out.Matches))
	366	+	for i, m := range out.Matches {
	367	+	entries[i] = m.Entry
	368	+	}
	369	+	}
	370	+	if err != nil {
	371	+	hs.logger.Error().Err(err).Str("query", query).Msg("history FTS search failed")
	372	+	}
	373	+	if entries == nil {
	374	+	entries = []*entity.HistoryEntry{}
	375	+	}
	376	+
	377	+	// Apply results on the GTK main thread with stale-result protection
	378	+	cb := glib.SourceFunc(func(uintptr) bool {
	379	+	if hs.applySearchResults(entries, gen, err) {
	380	+	hs.scheduleRebuild()
	381	+	}
	382	+	return false
	383	+	})
	384	+	hs.scheduleIdle(cb)
	385	+	}()
	386	+	}
	387	+
	388	+	// applySearchResults applies search results under the generation guard.
	389	+	// Returns true if results were applied (non-stale), false if the generation
	390	+	// had moved on and the results were dropped.
	391	+	func (hs HistorySidebar) applySearchResults(entries []entity.HistoryEntry, gen uint64, err error) bool {
	392	+	hs.mu.Lock()
	393	+	defer hs.mu.Unlock()
	394	+	if hs.destroyed \|\| gen != hs.searchGen {
	395	+	return false
	396	+	}
	397	+	hs.searchResults = entries
	398	+	hs.searchDone = true
	399	+	hs.searchErr = err
	400	+	hs.setDisplayGroupsLocked(groupHistoryByDay(entries))
	401	+	return true
	402	+	}
	403	+
	404	+	func (hs *HistorySidebar) scheduleIdle(cb glib.SourceFunc) {
	405	+	if hs != nil && hs.idleScheduler != nil {
	406	+	hs.idleScheduler(cb)
	407	+	return
	408	+	}
	409	+	glib.IdleAdd(&cb, 0)
	410	+	}
	411	+
	412	+	// scheduleClearList clears the list box on the GTK main thread.
	413	+	func (hs *HistorySidebar) scheduleClearList() {
	414	+	cb := glib.SourceFunc(func(uintptr) bool {
	415	+	hs.mu.RLock()
	416	+	destroyed := hs.destroyed
	417	+	listBox := hs.listBox
	418	+	hs.mu.RUnlock()
	419	+	if destroyed \|\| listBox == nil {
	420	+	return false
	421	+	}
	422	+	listBox.RemoveAll()
	423	+	return false
	424	+	})
	425	+	hs.scheduleIdle(cb)
	426	+	}
	427	+
	428	+	// scheduleRebuild schedules a list rebuild on the GTK main thread.
	429	+	func (hs *HistorySidebar) scheduleRebuild() {
	430	+	cb := glib.SourceFunc(func(uintptr) bool {
	431	+	hs.rebuildList()
	432	+	return false
	433	+	})
	434	+	hs.scheduleIdle(cb)
	435	+	}
	436	+
	437	+	// setDisplayGroupsLocked updates grouped history and the explicit display-row
	438	+	// model. Caller must hold hs.mu for writing.
	439	+	func (hs *HistorySidebar) setDisplayGroupsLocked(groups []historyGroup) {
	440	+	hs.groups = groups
	441	+	hs.displayRows = buildHistoryDisplayRows(groups)
	442	+	}

A internal/ui/component/history_sidebar_rendering.go +234 -0

@@ -0,0 +1,234 @@
	1	+	package component
	2	+
	3	+	import (
	4	+	"github.com/bnema/puregotk/v4/gtk"
	5	+	"github.com/bnema/puregotk/v4/pango"
	6	+
	7	+	"github.com/bnema/dumber/internal/domain/entity"
	8	+	)
	9	+
	10	+	// =============================================================================
	11	+	// List rendering
	12	+	// =============================================================================
	13	+
	14	+	// rebuildList clears and repopulates the list box from current groups.
	15	+	// Must be called on the GTK main thread. Preserves scroll and selection.
	16	+	func (hs *HistorySidebar) rebuildList() {
	17	+	hs.mu.RLock()
	18	+	if hs.destroyed \|\| hs.listBox == nil {
	19	+	hs.mu.RUnlock()
	20	+	return
	21	+	}
	22	+	rows := hs.displayRows
	23	+	query := hs.currentQuery
	24	+	hasSearchResults := hs.searchResults != nil
	25	+	searchDone := hs.searchDone
	26	+	totalLoaded := hs.totalLoaded
	27	+	hs.mu.RUnlock()
	28	+
	29	+	// Remove all rows
	30	+	hs.listBox.RemoveAll()
	31	+
	32	+	if len(rows) == 0 {
	33	+	if !hasSearchResults && totalLoaded == 0 {
	34	+	// Browse has not loaded yet AND no search has completed.
	35	+	hs.showLoadingOrEmpty(query, searchDone)
	36	+	return
	37	+	}
	38	+	// Search completed with 0 results, or browse loaded but empty (no history).
	39	+	hs.showEmptyState(query)
	40	+	hs.restoreScrollAndSelection()
	41	+	return
	42	+	}
	43	+
	44	+	for _, row := range rows {
	45	+	switch row.Kind {
	46	+	case historyDisplayRowHeader:
	47	+	hs.appendGroupHeader(row.Label)
	48	+	case historyDisplayRowEntry:
	49	+	hs.appendEntryRow(row.Entry)
	50	+	}
	51	+	}
	52	+
	53	+	hs.listBox.Show()
	54	+
	55	+	// Restore previous scroll position and selection
	56	+	hs.restoreScrollAndSelection()
	57	+
	58	+	// If no selection was restored and this is the first load, select first entry
	59	+	hs.ensureAtLeastOneSelection()
	60	+	}
	61	+
	62	+	func (hs *HistorySidebar) showLoadingOrEmpty(query string, searchDone bool) {
	63	+	label := gtk.NewLabel(nil)
	64	+	if label == nil {
	65	+	return
	66	+	}
	67	+	label.AddCssClass("history-sidebar-loading")
	68	+
	69	+	hs.mu.RLock()
	70	+	isLoading := hs.isLoading
	71	+	hs.mu.RUnlock()
	72	+
	73	+	switch {
	74	+	case isLoading && query == "":
	75	+	label.SetText("Loading history...")
	76	+	case query != "" && !searchDone:
	77	+	label.SetText("Searching...")
	78	+	case query != "":
	79	+	label.SetText(noResultsText(query))
	80	+	default:
	81	+	label.SetText("No browsing history")
	82	+	}
	83	+
	84	+	label.SetWrap(false)
	85	+	label.SetXalign(0.0)
	86	+
	87	+	row := gtk.NewListBoxRow()
	88	+	if row == nil {
	89	+	return
	90	+	}
	91	+	row.SetSelectable(false)
	92	+	row.SetCanFocus(false)
	93	+	row.SetActivatable(false)
	94	+	row.SetChild(&label.Widget)
	95	+	hs.listBox.Append(&row.Widget)
	96	+	}
	97	+
	98	+	func noResultsText(query string) string {
	99	+	return "No results for \"" + query + "\""
	100	+	}
	101	+
	102	+	func (hs *HistorySidebar) showEmptyState(query string) {
	103	+	label := gtk.NewLabel(nil)
	104	+	if label == nil {
	105	+	return
	106	+	}
	107	+	label.AddCssClass("history-sidebar-empty")
	108	+
	109	+	if query != "" {
	110	+	label.SetText(noResultsText(query))
	111	+	} else {
	112	+	label.SetText("No browsing history")
	113	+	}
	114	+
	115	+	label.SetWrap(false)
	116	+	label.SetXalign(0.0)
	117	+
	118	+	row := gtk.NewListBoxRow()
	119	+	if row == nil {
	120	+	return
	121	+	}
	122	+	row.SetSelectable(false)
	123	+	row.SetCanFocus(false)
	124	+	row.SetActivatable(false)
	125	+	row.SetChild(&label.Widget)
	126	+	hs.listBox.Append(&row.Widget)
	127	+	}
	128	+
	129	+	// appendGroupHeader adds a non-selectable group header label to the list.
	130	+	func (hs *HistorySidebar) appendGroupHeader(labelText string) {
	131	+	label := gtk.NewLabel(&labelText)
	132	+	if label == nil {
	133	+	return
	134	+	}
	135	+	label.AddCssClass("history-sidebar-group-header")
	136	+	label.SetXalign(0.0)
	137	+	label.SetHexpand(true)
	138	+
	139	+	row := gtk.NewListBoxRow()
	140	+	if row == nil {
	141	+	return
	142	+	}
	143	+	row.SetSelectable(false)
	144	+	row.SetCanFocus(false)
	145	+	row.SetActivatable(false)
	146	+	row.SetChild(&label.Widget)
	147	+	hs.listBox.Append(&row.Widget)
	148	+	}
	149	+
	150	+	// appendEntryRow adds a selectable two-line entry row to the list.
	151	+	func (hs HistorySidebar) appendEntryRow(entry entity.HistoryEntry) {
	152	+	if entry == nil {
	153	+	return
	154	+	}
	155	+	// Outer vertical box for two-line layout
	156	+	rowBox := gtk.NewBox(gtk.OrientationVerticalValue, 1)
	157	+	if rowBox == nil {
	158	+	return
	159	+	}
	160	+	rowBox.SetHexpand(true)
	161	+
	162	+	// Title line (first line)
	163	+	titleLabel := gtk.NewLabel(nil)
	164	+	if titleLabel == nil {
	165	+	return
	166	+	}
	167	+	titleLabel.AddCssClass("history-sidebar-row-title")
	168	+	titleLabel.SetText(safeSidebarString(entry.Title, entry.URL))
	169	+	titleLabel.SetXalign(0.0)
	170	+	titleLabel.SetHexpand(true)
	171	+	titleLabel.SetEllipsize(pango.EllipsizeEndValue)
	172	+
	173	+	// Subtitle line with URL and time
	174	+	subBox := gtk.NewBox(gtk.OrientationHorizontalValue, 0)
	175	+	if subBox == nil {
	176	+	return
	177	+	}
	178	+	subBox.SetHexpand(true)
	179	+
	180	+	urlLabel := gtk.NewLabel(nil)
	181	+	if urlLabel == nil {
	182	+	return
	183	+	}
	184	+	urlLabel.AddCssClass("history-sidebar-row-subtitle")
	185	+	urlLabel.SetText(readableURL(entry.URL))
	186	+	urlLabel.SetXalign(0.0)
	187	+	urlLabel.SetHexpand(true)
	188	+	urlLabel.SetEllipsize(pango.EllipsizeEndValue)
	189	+
	190	+	timeLabel := gtk.NewLabel(nil)
	191	+	if timeLabel == nil {
	192	+	return
	193	+	}
	194	+	timeLabel.AddCssClass("history-sidebar-row-time")
	195	+	timeLabel.SetText(relativeTime(entry.LastVisited))
	196	+	timeLabel.SetXalign(1.0)
	197	+
	198	+	subBox.Append(&urlLabel.Widget)
	199	+	subBox.Append(&timeLabel.Widget)
	200	+
	201	+	rowBox.Append(&titleLabel.Widget)
	202	+	rowBox.Append(&subBox.Widget)
	203	+
	204	+	// Create the list box row
	205	+	row := gtk.NewListBoxRow()
	206	+	if row == nil {
	207	+	return
	208	+	}
	209	+	row.AddCssClass("history-sidebar-row")
	210	+	row.SetSelectable(true)
	211	+	row.SetActivatable(true)
	212	+	row.SetCanFocus(true)
	213	+	row.SetFocusOnClick(true)
	214	+	row.SetChild(&rowBox.Widget)
	215	+
	216	+	hs.listBox.Append(&row.Widget)
	217	+	}
	218	+
	219	+	// ensureAtLeastOneSelection selects the first selectable row if nothing is selected.
	220	+	func (hs *HistorySidebar) ensureAtLeastOneSelection() {
	221	+	if hs.listBox.GetSelectedRow() != nil {
	222	+	return
	223	+	}
	224	+	for i := 0; ; i++ {
	225	+	row := hs.listBox.GetRowAtIndex(i)
	226	+	if row == nil {
	227	+	break
	228	+	}
	229	+	if row.GetSelectable() {
	230	+	hs.listBox.SelectRow(row)
	231	+	return
	232	+	}
	233	+	}
	234	+	}

A internal/ui/component/history_sidebar_search_test.go +391 -0

@@ -0,0 +1,391 @@
	1	+	package component
	2	+
	3	+	import (
	4	+	"context"
	5	+	"errors"
	6	+	"fmt"
	7	+	"sync"
	8	+	"testing"
	9	+	"time"
	10	+
	11	+	"github.com/bnema/dumber/internal/application/dto"
	12	+	"github.com/bnema/dumber/internal/domain/entity"
	13	+	"github.com/bnema/puregotk/v4/glib"
	14	+	"github.com/rs/zerolog"
	15	+	"github.com/stretchr/testify/assert"
	16	+	"github.com/stretchr/testify/require"
	17	+	)
	18	+
	19	+	// =============================================================================
	20	+	// applySearchResults seam tests
	21	+	// =============================================================================
	22	+
	23	+	// newTestSidebarSearchHarness creates a minimal HistorySidebar with only the
	24	+	// fields needed by applySearchResults, avoiding GTK widget construction.
	25	+	func newTestSidebarSearchHarness() *HistorySidebar {
	26	+	return &HistorySidebar{
	27	+	mu: sync.RWMutex{},
	28	+	logger: zerolog.Nop(),
	29	+	}
	30	+	}
	31	+
	32	+	func TestApplySearchResults_NonStaleApplied(t *testing.T) {
	33	+	hs := newTestSidebarSearchHarness()
	34	+	hs.searchGen = 1
	35	+
	36	+	entries := []*entity.HistoryEntry{
	37	+	{ID: 1, URL: "https://example.com", Title: "Example", LastVisited: time.Now()},
	38	+	}
	39	+
	40	+	applied := hs.applySearchResults(entries, 1, nil)
	41	+	assert.True(t, applied, "non-stale results must be applied")
	42	+	assert.True(t, hs.searchDone)
	43	+	require.NoError(t, hs.searchErr)
	44	+	require.NotNil(t, hs.searchResults)
	45	+	assert.Len(t, hs.searchResults, 1)
	46	+	assert.Equal(t, "https://example.com", hs.searchResults[0].URL)
	47	+	require.NotNil(t, hs.groups, "groups must be built from results")
	48	+	assert.Equal(t, "Today", hs.groups[0].Label)
	49	+	}
	50	+
	51	+	func TestApplySearchResults_StaleGenRejected(t *testing.T) {
	52	+	hs := newTestSidebarSearchHarness()
	53	+	hs.searchGen = 2 // Gen has moved on
	54	+
	55	+	entries := []*entity.HistoryEntry{
	56	+	{ID: 1, URL: "https://stale.com", Title: "Stale", LastVisited: time.Now()},
	57	+	}
	58	+
	59	+	applied := hs.applySearchResults(entries, 1, nil) // gen=1 is stale
	60	+	assert.False(t, applied, "stale results must be rejected")
	61	+	assert.False(t, hs.searchDone, "search must not be marked done for stale result")
	62	+	assert.Nil(t, hs.searchResults, "searchResults must remain nil")
	63	+	assert.Nil(t, hs.groups, "groups must remain nil")
	64	+	}
	65	+
	66	+	func TestApplySearchResults_StaleAfterIncrement(t *testing.T) {
	67	+	hs := newTestSidebarSearchHarness()
	68	+	hs.searchGen = 1
	69	+
	70	+	// First result applied as gen=1
	71	+	firstEntries := []*entity.HistoryEntry{
	72	+	{ID: 1, URL: "https://first.com", Title: "First", LastVisited: time.Now()},
	73	+	}
	74	+	applied := hs.applySearchResults(firstEntries, 1, nil)
	75	+	assert.True(t, applied)
	76	+
	77	+	// Second search starts, gen advances
	78	+	hs.searchGen = 2
	79	+
	80	+	// Stale result from gen=1 arrives
	81	+	staleEntries := []*entity.HistoryEntry{
	82	+	{ID: 2, URL: "https://stale.com", Title: "Stale", LastVisited: time.Now()},
	83	+	}
	84	+	applied = hs.applySearchResults(staleEntries, 1, nil)
	85	+	assert.False(t, applied, "stale result must be rejected")
	86	+
	87	+	// The original results must be preserved
	88	+	require.NotNil(t, hs.searchResults)
	89	+	assert.Len(t, hs.searchResults, 1)
	90	+	assert.Equal(t, "https://first.com", hs.searchResults[0].URL)
	91	+	}
	92	+
	93	+	func TestApplySearchResults_ErrorStored(t *testing.T) {
	94	+	hs := newTestSidebarSearchHarness()
	95	+	hs.searchGen = 1
	96	+
	97	+	wantErr := errors.New("search failed")
	98	+	entries := []*entity.HistoryEntry{} // empty but not nil
	99	+
	100	+	applied := hs.applySearchResults(entries, 1, wantErr)
	101	+	assert.True(t, applied)
	102	+	assert.True(t, hs.searchDone)
	103	+	require.ErrorIs(t, hs.searchErr, wantErr)
	104	+	require.NotNil(t, hs.searchResults)
	105	+	assert.Empty(t, hs.searchResults)
	106	+	}
	107	+
	108	+	func TestApplySearchResults_EmptyResultsApplied(t *testing.T) {
	109	+	hs := newTestSidebarSearchHarness()
	110	+	hs.searchGen = 1
	111	+
	112	+	applied := hs.applySearchResults([]*entity.HistoryEntry{}, 1, nil)
	113	+	assert.True(t, applied)
	114	+	assert.True(t, hs.searchDone)
	115	+	require.NoError(t, hs.searchErr)
	116	+	require.NotNil(t, hs.searchResults)
	117	+	assert.Empty(t, hs.searchResults)
	118	+	// Groups from empty entries should be nil or empty
	119	+	assert.Nil(t, hs.groups, "empty entries should produce nil groups")
	120	+	}
	121	+
	122	+	func TestApplyDeletedEntryLocked_RecomputesBrowseState(t *testing.T) {
	123	+	now := time.Now()
	124	+	keepA := &entity.HistoryEntry{ID: 1, URL: "https://keep-a.com", Title: "Keep A", LastVisited: now}
	125	+	deleteMe := &entity.HistoryEntry{ID: 2, URL: "https://delete-me.com", Title: "Delete Me", LastVisited: now.Add(-time.Minute)}
	126	+	keepB := &entity.HistoryEntry{ID: 3, URL: "https://keep-b.com", Title: "Keep B", LastVisited: now.Add(-2 * time.Minute)}
	127	+
	128	+	hs := newTestSidebarSearchHarness()
	129	+	hs.allEntries = []*entity.HistoryEntry{keepA, deleteMe, keepB}
	130	+	hs.totalLoaded = len(hs.allEntries)
	131	+	hs.loadGen = 7
	132	+	hs.isLoading = true
	133	+	hs.loadStarted = true
	134	+	hs.searchResults = []*entity.HistoryEntry{deleteMe, keepB}
	135	+	hs.setDisplayGroupsLocked(groupHistoryByDay(hs.allEntries))
	136	+
	137	+	hs.mu.Lock()
	138	+	hs.applyDeletedEntryLocked(deleteMe.ID, keepB.URL)
	139	+	hs.mu.Unlock()
	140	+
	141	+	assert.Equal(t, uint64(8), hs.loadGen, "deletes must invalidate in-flight browse loads")
	142	+	assert.False(t, hs.isLoading, "delete should clear stale loading state")
	143	+	assert.False(t, hs.loadStarted, "delete should clear stale loadStarted state")
	144	+	assert.Equal(t, 2, hs.totalLoaded, "browse pagination offset must track remaining loaded entries")
	145	+	assert.Equal(t, keepB.URL, hs.prevSelectedURL)
	146	+	assert.Len(t, hs.allEntries, 2)
	147	+	assert.Equal(t, []string{keepA.URL, keepB.URL}, []string{hs.allEntries[0].URL, hs.allEntries[1].URL})
	148	+	assert.Len(t, hs.searchResults, 1)
	149	+	assert.Equal(t, keepB.URL, hs.searchResults[0].URL)
	150	+	require.Len(t, hs.groups, 1)
	151	+	require.Len(t, hs.groups[0].Entries, 2)
	152	+	require.Len(t, hs.displayRows, 3, "one header plus two remaining entries")
	153	+	assert.Equal(t, historyDisplayRowHeader, hs.displayRows[0].Kind)
	154	+	assert.Equal(t, historyDisplayRowEntry, hs.displayRows[1].Kind)
	155	+	assert.Equal(t, historyDisplayRowEntry, hs.displayRows[2].Kind)
	156	+	}
	157	+
	158	+	// =============================================================================
	159	+	// Async search seam: controllable history port fake
	160	+	// =============================================================================
	161	+
	162	+	type fakeHistorySidebarHistory struct {
	163	+	getRecentFn func(ctx context.Context, limit, offset int) ([]*entity.HistoryEntry, error)
	164	+	searchFn func(ctx context.Context, input dto.HistorySearchInput) (*dto.HistorySearchOutput, error)
	165	+	deleteFn func(ctx context.Context, id int64) error
	166	+	}
	167	+
	168	+	func (f fakeHistorySidebarHistory) GetRecent(ctx context.Context, limit, offset int) ([]entity.HistoryEntry, error) {
	169	+	if f.getRecentFn != nil {
	170	+	return f.getRecentFn(ctx, limit, offset)
	171	+	}
	172	+	return nil, fmt.Errorf("unexpected GetRecent call in fakeHistorySidebarHistory")
	173	+	}
	174	+
	175	+	func (f fakeHistorySidebarHistory) Search(ctx context.Context, input dto.HistorySearchInput) (dto.HistorySearchOutput, error) {
	176	+	if f.searchFn != nil {
	177	+	return f.searchFn(ctx, input)
	178	+	}
	179	+	return &dto.HistorySearchOutput{Matches: []entity.HistoryMatch{}}, nil
	180	+	}
	181	+
	182	+	func (f *fakeHistorySidebarHistory) Delete(ctx context.Context, id int64) error {
	183	+	if f.deleteFn != nil {
	184	+	return f.deleteFn(ctx, id)
	185	+	}
	186	+	return nil
	187	+	}
	188	+
	189	+	func TestApplySearchResults_StaleGenerationDropsResultsAfterSearch(t *testing.T) {
	190	+	searchCalled := make(chan struct{}, 1)
	191	+	idleCalled := make(chan glib.SourceFunc, 1)
	192	+
	193	+	history := &fakeHistorySidebarHistory{
	194	+	searchFn: func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {
	195	+	searchCalled <- struct{}{}
	196	+	return &dto.HistorySearchOutput{Matches: []entity.HistoryMatch{
	197	+	{Entry: &entity.HistoryEntry{ID: 1, URL: "https://result.com", Title: "Result", LastVisited: time.Now()}},
	198	+	}}, nil
	199	+	},
	200	+	}
	201	+
	202	+	hs := newTestSidebarSearchHarness()
	203	+	hs.ctx = t.Context()
	204	+	hs.historyUC = history
	205	+	hs.searchGen = 1
	206	+	hs.idleScheduler = func(cb glib.SourceFunc) {
	207	+	idleCalled <- cb
	208	+	}
	209	+
	210	+	// Start search with gen=1.
	211	+	hs.doFTSearch("test", 1)
	212	+	select {
	213	+	case <-searchCalled:
	214	+	case <-time.After(time.Second):
	215	+	t.Fatal("timed out waiting for search use case to be invoked")
	216	+	}
	217	+
	218	+	// Advance gen before the queued UI callback applies results.
	219	+	hs.mu.Lock()
	220	+	hs.searchGen = 2
	221	+	hs.mu.Unlock()
	222	+
	223	+	select {
	224	+	case cb := <-idleCalled:
	225	+	cb(0)
	226	+	case <-time.After(time.Second):
	227	+	t.Fatal("timed out waiting for scheduled idle callback")
	228	+	}
	229	+
	230	+	hs.mu.RLock()
	231	+	defer hs.mu.RUnlock()
	232	+	assert.Nil(t, hs.searchResults)
	233	+	assert.False(t, hs.searchDone)
	234	+	assert.Nil(t, hs.groups)
	235	+	}
	236	+
	237	+	func TestApplySearchResults_CurrentGenerationAppliedAfterSearch(t *testing.T) {
	238	+	searchCalled := make(chan struct{}, 1)
	239	+	idleCalled := make(chan glib.SourceFunc, 1)
	240	+
	241	+	history := &fakeHistorySidebarHistory{
	242	+	searchFn: func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {
	243	+	searchCalled <- struct{}{}
	244	+	return &dto.HistorySearchOutput{Matches: []entity.HistoryMatch{
	245	+	{Entry: &entity.HistoryEntry{ID: 1, URL: "https://live.com", Title: "Live", LastVisited: time.Now()}},
	246	+	}}, nil
	247	+	},
	248	+	}
	249	+
	250	+	hs := newTestSidebarSearchHarness()
	251	+	hs.ctx = t.Context()
	252	+	hs.historyUC = history
	253	+	hs.searchGen = 1
	254	+	hs.idleScheduler = func(cb glib.SourceFunc) {
	255	+	idleCalled <- cb
	256	+	}
	257	+
	258	+	// Start the search and wait for the use case to be invoked.
	259	+	hs.doFTSearch("live", 1)
	260	+	select {
	261	+	case <-searchCalled:
	262	+	case <-time.After(time.Second):
	263	+	t.Fatal("timed out waiting for search use case to be invoked")
	264	+	}
	265	+
	266	+	select {
	267	+	case cb := <-idleCalled:
	268	+	cb(0)
	269	+	case <-time.After(time.Second):
	270	+	t.Fatal("timed out waiting for scheduled idle callback")
	271	+	}
	272	+
	273	+	hs.mu.RLock()
	274	+	require.NotNil(t, hs.searchResults)
	275	+	assert.True(t, hs.searchDone)
	276	+	assert.Len(t, hs.searchResults, 1)
	277	+	assert.Equal(t, "https://live.com", hs.searchResults[0].URL)
	278	+	hs.mu.RUnlock()
	279	+	}
	280	+
	281	+	// =============================================================================
	282	+	// Reload with query preservation
	283	+	// =============================================================================
	284	+
	285	+	// TestHistorySidebar_ReloadPreservesQuery verifies that Reload preserves the
	286	+	// active query while resetting browse/search state before the refreshed load.
	287	+	func TestHistorySidebar_ReloadPreservesQuery(t *testing.T) {
	288	+	searchCalled := make(chan struct{}, 1)
	289	+	history := &fakeHistorySidebarHistory{
	290	+	searchFn: func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {
	291	+	searchCalled <- struct{}{}
	292	+	return &dto.HistorySearchOutput{Matches: []entity.HistoryMatch{}}, nil
	293	+	},
	294	+	}
	295	+
	296	+	hs := newTestSidebarSearchHarness()
	297	+	hs.currentQuery = "preserved"
	298	+	hs.historyUC = history
	299	+	hs.ctx = t.Context()
	300	+
	301	+	hs.mu.Lock()
	302	+	oldGen := hs.searchGen
	303	+	hs.loadDone = true
	304	+	hs.allEntries = []*entity.HistoryEntry{
	305	+	{ID: 1, URL: "https://old.com", Title: "Old", LastVisited: time.Now()},
	306	+	}
	307	+	hs.groups = groupHistoryByDay(hs.allEntries)
	308	+	hs.searchResults = []*entity.HistoryEntry{{ID: 2, URL: "https://stale.com", Title: "Stale", LastVisited: time.Now()}}
	309	+	hs.searchDone = true
	310	+	hs.mu.Unlock()
	311	+
	312	+	hs.Reload()
	313	+
	314	+	select {
	315	+	case <-searchCalled:
	316	+	case <-time.After(time.Second):
	317	+	t.Fatal("timed out waiting for reload search to be invoked")
	318	+	}
	319	+
	320	+	hs.mu.RLock()
	321	+	assert.Equal(t, "preserved", hs.currentQuery, "query must be preserved after Reload")
	322	+	assert.False(t, hs.loadDone, "loadDone must be reset")
	323	+	assert.False(t, hs.loadStarted, "loadStarted must be reset")
	324	+	assert.Nil(t, hs.allEntries, "entries must be cleared")
	325	+	assert.Nil(t, hs.groups, "groups must be cleared")
	326	+	assert.Nil(t, hs.searchResults, "searchResults must be cleared before refreshed search applies")
	327	+	assert.False(t, hs.searchDone, "searchDone must be reset")
	328	+	assert.Equal(t, oldGen+1, hs.searchGen, "searchGen must be incremented")
	329	+	hs.mu.RUnlock()
	330	+	}
	331	+
	332	+	// =============================================================================
	333	+	// fetchPage generation guard: stale browse results must not clear loading state
	334	+	// =============================================================================
	335	+
	336	+	func TestFetchPage_StaleGenerationDoesNotMutateLoadingState(t *testing.T) {
	337	+	t.Parallel()
	338	+
	339	+	// Repo blocks GetRecent until test signals proceed, so we can control
	340	+	// when a stale fetch completes relative to generation changes.
	341	+	getRecentCalled := make(chan struct{})
	342	+	proceed := make(chan struct{})
	343	+
	344	+	history := &fakeHistorySidebarHistory{
	345	+	getRecentFn: func(context.Context, int, int) ([]*entity.HistoryEntry, error) {
	346	+	close(getRecentCalled)
	347	+	<-proceed
	348	+	return []*entity.HistoryEntry{}, nil
	349	+	},
	350	+	}
	351	+
	352	+	hs := newTestSidebarSearchHarness()
	353	+	hs.ctx = t.Context()
	354	+	hs.historyUC = history
	355	+
	356	+	// Simulate: gen 1 started, then gen 2 started (e.g. by Reload/Show).
	357	+	// The second call incremented loadGen and set isLoading/loadStarted.
	358	+	hs.mu.Lock()
	359	+	hs.loadGen = 2
	360	+	hs.isLoading = true
	361	+	hs.loadStarted = true
	362	+	hs.totalLoaded = 0
	363	+	hs.hasMore = true
	364	+	hs.mu.Unlock()
	365	+
	366	+	// Start stale gen 1 fetch in background
	367	+	fetchDone := make(chan struct{})
	368	+	go func() {
	369	+	hs.fetchPage(0, 1) // gen=1 is stale — loadGen is 2
	370	+	close(fetchDone)
	371	+	}()
	372	+
	373	+	// Wait until GetRecent is entered (fetchPage is blocked inside the repo call)
	374	+	<-getRecentCalled
	375	+
	376	+	// Let GetRecent return — this simulates the gen 1 fetch completing
	377	+	// after gen 2 has already taken over.
	378	+	close(proceed)
	379	+
	380	+	// Wait for fetchPage to finish processing the stale return
	381	+	<-fetchDone
	382	+
	383	+	// Verify: stale completion must NOT clear the new generation's loading state
	384	+	hs.mu.RLock()
	385	+	assert.True(t, hs.isLoading, "isLoading must remain true when stale gen completes")
	386	+	assert.True(t, hs.loadStarted, "loadStarted must remain true when stale gen completes")
	387	+	assert.Equal(t, uint64(2), hs.loadGen, "loadGen must remain unchanged")
	388	+	assert.False(t, hs.loadDone, "loadDone must remain false; gen 2 hasn't completed")
	389	+	assert.Equal(t, 0, hs.totalLoaded, "stale results must not update totalLoaded")
	390	+	hs.mu.RUnlock()
	391	+	}

A internal/ui/component/history_sidebar_widgets.go +93 -0

@@ -0,0 +1,93 @@
	1	+	package component
	2	+
	3	+	import (
	4	+	"fmt"
	5	+
	6	+	"github.com/bnema/puregotk/v4/gtk"
	7	+	)
	8	+
	9	+	// =============================================================================
	10	+	// Widget creation
	11	+	// =============================================================================
	12	+
	13	+	func (hs *HistorySidebar) createWidgets() error {
	14	+	if err := hs.initOuterBox(); err != nil {
	15	+	return err
	16	+	}
	17	+	if err := hs.initSearchBox(); err != nil {
	18	+	return err
	19	+	}
	20	+	if err := hs.initListArea(); err != nil {
	21	+	return err
	22	+	}
	23	+	return nil
	24	+	}
	25	+
	26	+	func (hs *HistorySidebar) initOuterBox() error {
	27	+	hs.outerBox = gtk.NewBox(gtk.OrientationVerticalValue, 0)
	28	+	if hs.outerBox == nil {
	29	+	return fmt.Errorf("history sidebar: outer box creation failed")
	30	+	}
	31	+	hs.outerBox.AddCssClass("history-sidebar-outer")
	32	+	hs.outerBox.SetSizeRequest(sidebarMinWidth, -1)
	33	+	hs.outerBox.SetHexpand(false)
	34	+	hs.outerBox.SetVexpand(true)
	35	+	hs.outerBox.SetVisible(false)
	36	+	return nil
	37	+	}
	38	+
	39	+	func (hs *HistorySidebar) initSearchBox() error {
	40	+	hs.searchBox = gtk.NewBox(gtk.OrientationHorizontalValue, 4)
	41	+	if hs.searchBox == nil {
	42	+	return fmt.Errorf("history sidebar: search box creation failed")
	43	+	}
	44	+	hs.searchBox.AddCssClass("history-sidebar-search-box")
	45	+	hs.searchBox.SetHexpand(true)
	46	+
	47	+	hs.searchEntry = gtk.NewSearchEntry()
	48	+	if hs.searchEntry == nil {
	49	+	return fmt.Errorf("history sidebar: search entry creation failed")
	50	+	}
	51	+	hs.searchEntry.AddCssClass("history-sidebar-search")
	52	+	hs.searchEntry.SetHexpand(true)
	53	+	placeholder := "Search history..."
	54	+	hs.searchEntry.SetPlaceholderText(&placeholder)
	55	+
	56	+	hs.searchBox.Append(&hs.searchEntry.Widget)
	57	+	hs.outerBox.Append(&hs.searchBox.Widget)
	58	+	return nil
	59	+	}
	60	+
	61	+	func (hs *HistorySidebar) initListArea() error {
	62	+	hs.scrolledWin = gtk.NewScrolledWindow()
	63	+	if hs.scrolledWin == nil {
	64	+	return fmt.Errorf("history sidebar: scrolled window creation failed")
	65	+	}
	66	+	hs.scrolledWin.SetVexpand(true)
	67	+	hs.scrolledWin.SetHexpand(true)
	68	+	hs.scrolledWin.SetPolicy(gtk.PolicyNeverValue, gtk.PolicyAutomaticValue)
	69	+	hs.scrolledWin.AddCssClass("history-sidebar-groups")
	70	+
	71	+	hs.listBox = gtk.NewListBox()
	72	+	if hs.listBox == nil {
	73	+	return fmt.Errorf("history sidebar: list box creation failed")
	74	+	}
	75	+	hs.listBox.AddCssClass("history-sidebar-groups")
	76	+	hs.listBox.SetActivateOnSingleClick(true)
	77	+	hs.listBox.SetSelectionMode(gtk.SelectionSingleValue)
	78	+
	79	+	// Connect row activation (single-click and keyboard activation)
	80	+	rowActivatedCb := func(_ gtk.ListBox, rowPtr uintptr) {
	81	+	row := gtk.ListBoxRowNewFromInternalPtr(rowPtr)
	82	+	if row == nil {
	83	+	return
	84	+	}
	85	+	hs.onRowActivated(row)
	86	+	}
	87	+	hs.retainedCallbacks = append(hs.retainedCallbacks, rowActivatedCb)
	88	+	hs.listBox.ConnectRowActivated(&rowActivatedCb)
	89	+
	90	+	hs.scrolledWin.SetChild(&hs.listBox.Widget)
	91	+	hs.outerBox.Append(&hs.scrolledWin.Widget)
	92	+	return nil
	93	+	}

A internal/ui/component/history_test_helpers_test.go +39 -0

@@ -0,0 +1,39 @@
	1	+	package component
	2	+
	3	+	// searchStateSnapshot captures the observable state of a history search
	4	+	// at a point in time. This is test-only data for pure transition checks.
	5	+	type searchStateSnapshot struct {
	6	+	Query string
	7	+	HasSearchDone bool
	8	+	HasResults bool
	9	+	ResultCount int
	10	+	}
	11	+
	12	+	// transitionSearchState models a search state transition for tests without GTK.
	13	+	func transitionSearchState(newQuery string, resultCount int) searchStateSnapshot {
	14	+	return searchStateSnapshot{
	15	+	Query: newQuery,
	16	+	HasSearchDone: newQuery != "",
	17	+	HasResults: newQuery != "" && resultCount > 0,
	18	+	ResultCount: resultCount,
	19	+	}
	20	+	}
	21	+
	22	+	// reloadPreservationSnapshot captures the preserved state during a reload.
	23	+	type reloadPreservationSnapshot struct {
	24	+	PreservedQuery string
	25	+	ResetBrowse bool
	26	+	ClearSearch bool
	27	+	}
	28	+
	29	+	// applyReloadState computes the expected state after a reload for test-only
	30	+	// transition checks.
	31	+	func applyReloadState(currentQuery string) reloadPreservationSnapshot {
	32	+	s := reloadPreservationSnapshot{PreservedQuery: currentQuery}
	33	+	if currentQuery == "" {
	34	+	s.ResetBrowse = true
	35	+	} else {
	36	+	s.ClearSearch = true
	37	+	}
	38	+	return s
	39	+	}

M internal/ui/dispatcher/keyboard.go +34 -19


@@ -15,6 +15,10 @@ import (
15	15		)
16	16
17	17		const (
	18	+	// historySystemViewURL is the full-page/systemview history surface.
	19	+	// It remains reachable by direct navigation (for example typing
	20	+	// dumb://history in the omnibox), but Ctrl+H no longer falls back to it.
	21	+	// Ctrl+H is reserved for the native GTK history sidebar only.
18	22		historySystemViewURL = "dumb://history"
19	23		favoritesSystemViewURL = "dumb://favorites"
20	24		configSystemViewURL = "dumb://config"

@@ -32,24 +36,25 @@ type KeyboardActions struct {
32	36
33	37		// KeyboardDispatcher routes keyboard actions to appropriate coordinators.
34	38		type KeyboardDispatcher struct {
35		-	actions KeyboardActions
36		-	wsCoord *coordinator.WorkspaceCoordinator
37		-	navCoord *coordinator.NavigationCoordinator
38		-	zoomUC *usecase.ManageZoomUseCase
39		-	copyURLUC *usecase.CopyURLUseCase
40		-	actionHandlers map[input.Action]func(ctx context.Context) error
41		-	onQuit func()
42		-	onFindOpen func(ctx context.Context) error
43		-	onFindNext func(ctx context.Context) error
44		-	onFindPrev func(ctx context.Context) error
45		-	onFindClose func(ctx context.Context) error
46		-	activePaneID func(ctx context.Context) entity.PaneID
47		-	onSessionOpen func(ctx context.Context, paneID entity.PaneID) error
48		-	onMovePaneToTab func(ctx context.Context, paneID entity.PaneID) error
49		-	onMovePaneToNext func(ctx context.Context, paneID entity.PaneID) error
50		-	onEjectPaneToWindow func(ctx context.Context, paneID entity.PaneID) error
51		-	onToggleFloating func(ctx context.Context) error
52		-	onOpenFloating func(ctx context.Context, target input.FloatingProfileTarget) error
	39	+	actions KeyboardActions
	40	+	wsCoord *coordinator.WorkspaceCoordinator
	41	+	navCoord *coordinator.NavigationCoordinator
	42	+	zoomUC *usecase.ManageZoomUseCase
	43	+	copyURLUC *usecase.CopyURLUseCase
	44	+	actionHandlers map[input.Action]func(ctx context.Context) error
	45	+	onQuit func()
	46	+	onFindOpen func(ctx context.Context) error
	47	+	onFindNext func(ctx context.Context) error
	48	+	onFindPrev func(ctx context.Context) error
	49	+	onFindClose func(ctx context.Context) error
	50	+	activePaneID func(ctx context.Context) entity.PaneID
	51	+	onSessionOpen func(ctx context.Context, paneID entity.PaneID) error
	52	+	onMovePaneToTab func(ctx context.Context, paneID entity.PaneID) error
	53	+	onMovePaneToNext func(ctx context.Context, paneID entity.PaneID) error
	54	+	onEjectPaneToWindow func(ctx context.Context, paneID entity.PaneID) error
	55	+	onToggleHistorySidebar func(ctx context.Context) error
	56	+	onToggleFloating func(ctx context.Context) error
	57	+	onOpenFloating func(ctx context.Context, target input.FloatingProfileTarget) error
53	58		}
54	59
55	60		// NewKeyboardDispatcher creates a new KeyboardDispatcher.

@@ -119,6 +124,10 @@ func (d *KeyboardDispatcher) SetOnEjectPaneToWindow(fn func(ctx context.Context,
119	124		d.onEjectPaneToWindow = fn
120	125		}
121	126
	127	+	func (d *KeyboardDispatcher) SetOnToggleHistorySidebar(fn func(ctx context.Context) error) {
	128	+	d.onToggleHistorySidebar = fn
	129	+	}
	130	+
122	131		func (d *KeyboardDispatcher) SetOnToggleFloatingPane(fn func(ctx context.Context) error) {
123	132		d.onToggleFloating = fn
124	133		}

@@ -243,8 +252,14 @@ func (d *KeyboardDispatcher) initActionHandlers() {
243	252		}
244	253		return d.logNoop(ctx, "toggle floating pane action (no handler)")
245	254		},
	255	+	// ActionToggleHistorySystemView (default Ctrl+H) is intentionally bound
	256	+	// to the native GTK history sidebar only. The dumb://history systemview
	257	+	// remains available through direct navigation, not shortcut fallback.
246	258		input.ActionToggleHistorySystemView: func(ctx context.Context) error {
247		-	return d.wsCoord.ToggleSystemViewRight(ctx, historySystemViewURL)
	259	+	if d.onToggleHistorySidebar == nil {
	260	+	return fmt.Errorf("history sidebar unavailable: toggle handler not wired")
	261	+	}
	262	+	return d.onToggleHistorySidebar(ctx)
248	263		},
249	264		input.ActionToggleFavoritesSystemView: func(ctx context.Context) error {
250	265		return d.wsCoord.ToggleSystemViewRight(ctx, favoritesSystemViewURL)

M internal/ui/dispatcher/keyboard_test.go +44 -26


@@ -2,11 +2,10 @@ package dispatcher
2	2
3	3		import (
4	4		"context"
	5	+	"fmt"
5	6		"testing"
6	7
7		-	"github.com/bnema/dumber/internal/application/usecase"
8	8		"github.com/bnema/dumber/internal/domain/entity"
9		-	"github.com/bnema/dumber/internal/ui/component"
10	9		"github.com/bnema/dumber/internal/ui/coordinator"
11	10		"github.com/bnema/dumber/internal/ui/input"
12	11		"github.com/stretchr/testify/assert"

@@ -64,37 +63,56 @@ func TestKeyboardDispatcher_TabActionsUseInjectedKeyboardActions(t *testing.T) {
64	63		assert.Equal(t, 4, switchedIndex)
65	64		}
66	65
67		-	func TestKeyboardDispatcher_ToggleHistorySystemViewOpensRightSplit(t *testing.T) {
	66	+	func TestKeyboardDispatcher_ToggleHistorySidebarCallsCallback(t *testing.T) {
68	67		ctx := context.Background()
69		-	ids := []string{"pane-2", "split-1"}
70		-	idx := 0
71		-	panesUC := usecase.NewManagePanesUseCase(func() string {
72		-	id := ids[idx]
73		-	idx++
74		-	return id
75		-	})
	68	+	d := NewKeyboardDispatcher(ctx, &coordinator.WorkspaceCoordinator{}, &coordinator.NavigationCoordinator{}, nil, nil, KeyboardActions{}, func(context.Context) entity.PaneID { return "" })
76	69
77		-	initialPane := entity.NewPane("pane-1")
78		-	initialPane.URI = "https://example.com"
79		-	ws := entity.NewWorkspace("ws-1", initialPane)
80		-	wsCoord := coordinator.NewWorkspaceCoordinator(ctx, coordinator.WorkspaceCoordinatorConfig{
81		-	PanesUC: panesUC,
82		-	GetActiveWS: func() (entity.Workspace, component.WorkspaceView) {
83		-	return ws, nil
84		-	},
	70	+	var called bool
	71	+	d.SetOnToggleHistorySidebar(func(context.Context) error {
	72	+	called = true
	73	+	return nil
85	74		})
86	75
87		-	d := NewKeyboardDispatcher(ctx, wsCoord, &coordinator.NavigationCoordinator{}, nil, nil, KeyboardActions{}, func(context.Context) entity.PaneID { return "" })
88		-
89	76		err := d.Dispatch(ctx, input.ActionToggleHistorySystemView)
90	77		require.NoError(t, err)
	78	+	assert.True(t, called, "onToggleHistorySidebar should have been called")
	79	+	}
	80	+
	81	+	func TestKeyboardDispatcher_ToggleHistorySystemViewReturnsErrorWhenHandlerMissing(t *testing.T) {
	82	+	ctx := context.Background()
	83	+	d := NewKeyboardDispatcher(ctx, &coordinator.WorkspaceCoordinator{}, &coordinator.NavigationCoordinator{}, nil, nil, KeyboardActions{}, func(context.Context) entity.PaneID { return "" })
	84	+
	85	+	err := d.Dispatch(ctx, input.ActionToggleHistorySystemView)
	86	+	require.Error(t, err)
	87	+	assert.ErrorContains(t, err, "history sidebar unavailable")
	88	+	}
	89	+
	90	+	func TestKeyboardDispatcher_ToggleHistorySidebarErrorPropagation(t *testing.T) {
	91	+	ctx := context.Background()
	92	+	d := NewKeyboardDispatcher(ctx, &coordinator.WorkspaceCoordinator{}, &coordinator.NavigationCoordinator{}, nil, nil, KeyboardActions{}, func(context.Context) entity.PaneID { return "" })
91	93
92		-	require.Equal(t, 2, ws.PaneCount())
93		-	active := ws.ActivePane()
94		-	require.NotNil(t, active)
95		-	require.NotNil(t, active.Pane)
96		-	assert.Equal(t, entity.PaneID("pane-2"), active.Pane.ID)
97		-	assert.Equal(t, "dumb://history", active.Pane.URI)
	94	+	wantErr := fmt.Errorf("sidebar toggle failed")
	95	+	d.SetOnToggleHistorySidebar(func(context.Context) error {
	96	+	return wantErr
	97	+	})
	98	+
	99	+	err := d.Dispatch(ctx, input.ActionToggleHistorySystemView)
	100	+	require.Error(t, err)
	101	+	assert.ErrorIs(t, err, wantErr, "onToggleHistorySidebar error should propagate")
	102	+	}
	103	+
	104	+	func TestKeyboardDispatcher_ToggleHistorySidebarSetThenUnsetReturnsError(t *testing.T) {
	105	+	ctx := context.Background()
	106	+	d := NewKeyboardDispatcher(ctx, &coordinator.WorkspaceCoordinator{}, &coordinator.NavigationCoordinator{}, nil, nil, KeyboardActions{}, func(context.Context) entity.PaneID { return "" })
	107	+
	108	+	d.SetOnToggleHistorySidebar(func(context.Context) error {
	109	+	return nil
	110	+	})
	111	+	d.SetOnToggleHistorySidebar(nil)
	112	+
	113	+	err := d.Dispatch(ctx, input.ActionToggleHistorySystemView)
	114	+	require.Error(t, err)
	115	+	assert.ErrorContains(t, err, "history sidebar unavailable")
98	116		}
99	117
100	118		func TestKeyboardDispatcher_PassesActivePaneIDToShellCallbacks(t *testing.T) {

M internal/ui/theme/css.go +4 -0


@@ -140,6 +140,10 @@ func GenerateCSSFull(p Palette, _ float64, fonts FontConfig, modeColors ModeColo
140	140
141	141		// Accent picker styling
142	142		sb.WriteString(generateAccentPickerCSS(p))
	143	+	sb.WriteString("\n")
	144	+
	145	+	// History sidebar styling
	146	+	sb.WriteString(generateHistorySidebarCSS(p))
143	147
144	148		return sb.String()
145	149		}

A internal/ui/theme/history_sidebar_css.go +90 -0

@@ -0,0 +1,90 @@
	1	+	package theme
	2	+
	3	+	// generateHistorySidebarCSS creates GTK4 CSS for the history sidebar component.
	4	+	func generateHistorySidebarCSS(_ Palette) string {
	5	+	return `/* ===== History Sidebar Styling ===== */
	6	+
	7	+	.history-sidebar-outer {
	8	+	background-color: var(--surface);
	9	+	border-left: 0.0625em solid var(--border);
	10	+	}
	11	+
	12	+	.history-sidebar-search-box {
	13	+	padding: 0.375em 0.5em;
	14	+	border-bottom: 0.0625em solid var(--border);
	15	+	background-color: var(--surface);
	16	+	}
	17	+
	18	+	.history-sidebar-search {
	19	+	padding: 0.125em 0.375em;
	20	+	font-size: 0.85em;
	21	+	}
	22	+
	23	+	.history-sidebar-groups {
	24	+	background-color: var(--surface);
	25	+	}
	26	+
	27	+	.history-sidebar-group-header {
	28	+	padding: 0.25em 0.625em;
	29	+	padding-top: 0.375em;
	30	+	font-size: 0.75em;
	31	+	font-weight: 600;
	32	+	color: var(--muted);
	33	+	text-transform: uppercase;
	34	+	letter-spacing: 0.04em;
	35	+	background-color: var(--surface-variant);
	36	+	border-bottom: 0.0625em solid var(--border);
	37	+	}
	38	+
	39	+	.history-sidebar-row {
	40	+	padding: 0.1875em 0.625em;
	41	+	min-height: 0;
	42	+	border-bottom: 0.0625em solid alpha(var(--border), 0.4);
	43	+	background-color: var(--surface);
	44	+	transition: background-color 100ms ease;
	45	+	}
	46	+
	47	+	.history-sidebar-row:hover {
	48	+	background-color: alpha(var(--accent), 0.18);
	49	+	}
	50	+
	51	+	.history-sidebar-row:selected {
	52	+	background-color: alpha(var(--accent), 0.18);
	53	+	}
	54	+
	55	+	.history-sidebar-row:focus {
	56	+	background-color: alpha(var(--accent), 0.18);
	57	+	}
	58	+
	59	+	.history-sidebar-row-title {
	60	+	font-size: 0.82em;
	61	+	color: var(--text);
	62	+	font-weight: 500;
	63	+	}
	64	+
	65	+	.history-sidebar-row-subtitle {
	66	+	font-size: 0.72em;
	67	+	color: var(--muted);
	68	+	}
	69	+
	70	+	.history-sidebar-row-time {
	71	+	font-size: 0.68em;
	72	+	color: var(--muted);
	73	+	padding-left: 0.5em;
	74	+	opacity: 0.75;
	75	+	}
	76	+
	77	+	.history-sidebar-empty {
	78	+	padding: 1.5em 0.75em;
	79	+	font-size: 0.82em;
	80	+	color: var(--muted);
	81	+	font-style: italic;
	82	+	}
	83	+
	84	+	.history-sidebar-loading {
	85	+	padding: 1.5em 0.75em;
	86	+	font-size: 0.82em;
	87	+	color: var(--muted);
	88	+	}
	89	+	`
	90	+	}

A internal/ui/theme/history_sidebar_css_test.go +333 -0

@@ -0,0 +1,333 @@
	1	+	package theme
	2	+
	3	+	import (
	4	+	"crypto/sha256"
	5	+	"strings"
	6	+	"testing"
	7	+
	8	+	"github.com/stretchr/testify/assert"
	9	+	)
	10	+
	11	+	func TestGenerateHistorySidebarCSS_ContainsExpectedSelectors(t *testing.T) {
	12	+	css := generateHistorySidebarCSS(DefaultDarkPalette())
	13	+
	14	+	selectors := []string{
	15	+	".history-sidebar-outer",
	16	+	".history-sidebar-search-box",
	17	+	".history-sidebar-search",
	18	+	".history-sidebar-groups",
	19	+	".history-sidebar-group-header",
	20	+	".history-sidebar-row",
	21	+	".history-sidebar-row:hover",
	22	+	".history-sidebar-row:selected",
	23	+	".history-sidebar-row:focus",
	24	+	".history-sidebar-row-title",
	25	+	".history-sidebar-row-subtitle",
	26	+	".history-sidebar-row-time",
	27	+	".history-sidebar-empty",
	28	+	".history-sidebar-loading",
	29	+	}
	30	+
	31	+	for _, sel := range selectors {
	32	+	assert.Contains(t, css, sel+" {",
	33	+	"expected selector %s { in generated CSS", sel)
	34	+	}
	35	+	}
	36	+
	37	+	func TestGenerateHistorySidebarCSS_AccentAlphaInterpolation(t *testing.T) {
	38	+	css := generateHistorySidebarCSS(DefaultDarkPalette())
	39	+
	40	+	expectedAlpha := "alpha(var(--accent), 0.18)"
	41	+	assert.Contains(t, css, expectedAlpha,
	42	+	"expected accent alpha variable usage %q in generated CSS", expectedAlpha)
	43	+	assert.NotContains(t, css, "alpha(#",
	44	+	"history sidebar CSS should not inline hardcoded accent hex values")
	45	+
	46	+	// The accent alpha should appear in hover, selected, and focus blocks.
	47	+	assert.GreaterOrEqual(t, strings.Count(css, expectedAlpha), 3,
	48	+	"expected accent alpha to appear at least 3 times (hover/selected/focus)")
	49	+	}
	50	+
	51	+	func TestGenerateHistorySidebarCSS_DeterministicOutput(t *testing.T) {
	52	+	palette := DefaultDarkPalette()
	53	+
	54	+	css1 := generateHistorySidebarCSS(palette)
	55	+	css2 := generateHistorySidebarCSS(palette)
	56	+
	57	+	hash1 := sha256.Sum256([]byte(css1))
	58	+	hash2 := sha256.Sum256([]byte(css2))
	59	+
	60	+	assert.Equal(t, hash1, hash2, "CSS output must be deterministic for the same palette")
	61	+	}
	62	+
	63	+	func TestGenerateHistorySidebarCSS_UsesPaletteVariablesInsteadOfInliningColors(t *testing.T) {
	64	+	darkCSS := generateHistorySidebarCSS(DefaultDarkPalette())
	65	+	lightCSS := generateHistorySidebarCSS(DefaultLightPalette())
	66	+
	67	+	assert.Equal(t, darkCSS, lightCSS,
	68	+	"history sidebar fragment should be palette-independent when it relies on CSS variables")
	69	+	assert.Contains(t, darkCSS, "alpha(var(--accent), 0.18)")
	70	+	assert.NotContains(t, darkCSS, "alpha(#")
	71	+	}
	72	+
	73	+	func TestGenerateHistorySidebarCSS_ThroughGenerateCSS(t *testing.T) {
	74	+	fullCSS := GenerateCSS(DefaultDarkPalette())
	75	+
	76	+	assert.Contains(t, fullCSS, ".history-sidebar-outer {",
	77	+	"full CSS must contain history sidebar selectors")
	78	+	assert.Contains(t, fullCSS, ".history-sidebar-group-header {",
	79	+	"full CSS must contain group header selector")
	80	+	assert.Contains(t, fullCSS, ".history-sidebar-row-title {",
	81	+	"full CSS must contain row title selector")
	82	+	assert.Contains(t, fullCSS, "History Sidebar Styling",
	83	+	"full CSS must contain the history sidebar comment marker")
	84	+	}
	85	+
	86	+	func TestGenerateHistorySidebarCSS_NoEmptyCSSBlocks(t *testing.T) {
	87	+	css := generateHistorySidebarCSS(DefaultDarkPalette())
	88	+
	89	+	sections := strings.Split(css, "{")
	90	+	for i, section := range sections {
	91	+	if i == 0 {
	92	+	continue
	93	+	}
	94	+	closeIdx := strings.Index(section, "}")
	95	+	if closeIdx < 0 {
	96	+	continue
	97	+	}
	98	+	blockContent := strings.TrimSpace(section[:closeIdx])
	99	+	assert.NotEmpty(t, blockContent, "CSS block must not be empty: section %d", i)
	100	+	}
	101	+	}
	102	+
	103	+	func TestGenerateHistorySidebarCSS_CustomPaletteValuesInterpolated(t *testing.T) {
	104	+	customPalette := Palette{
	105	+	Background: "#111111",
	106	+	Surface: "#222222",
	107	+	SurfaceVariant: "#333333",
	108	+	Text: "#eeeeee",
	109	+	Muted: "#aaaaaa",
	110	+	Accent: "#ff6600",
	111	+	Border: "#444444",
	112	+	Success: "#00cc44",
	113	+	Warning: "#ffaa00",
	114	+	Destructive: "#cc2222",
	115	+	}
	116	+
	117	+	css := generateHistorySidebarCSS(customPalette)
	118	+
	119	+	assert.Contains(t, css, "alpha(var(--accent), 0.18)",
	120	+	"sidebar CSS should use the shared accent variable")
	121	+	assert.NotContains(t, css, "#ff6600",
	122	+	"sidebar fragment should not inline palette-specific accent values")
	123	+
	124	+	assert.Contains(t, css, ".history-sidebar-outer {")
	125	+	assert.Contains(t, css, ".history-sidebar-row-title {")
	126	+	assert.Contains(t, css, ".history-sidebar-row-subtitle {")
	127	+	assert.Contains(t, css, ".history-sidebar-row-time {")
	128	+	assert.Contains(t, css, ".history-sidebar-empty {")
	129	+	}
	130	+
	131	+	func TestGenerateHistorySidebarCSS_ContainsTransition(t *testing.T) {
	132	+	css := generateHistorySidebarCSS(DefaultDarkPalette())
	133	+
	134	+	assert.Contains(t, css, "transition:",
	135	+	"CSS should include transition property for smooth hover effects")
	136	+	assert.Contains(t, css, "background-color 100ms ease",
	137	+	"row transition should specify background-color 100ms ease")
	138	+	}
	139	+
	140	+	func TestGenerateHistorySidebarCSS_ContainsUppercaseGroupHeader(t *testing.T) {
	141	+	css := generateHistorySidebarCSS(DefaultDarkPalette())
	142	+
	143	+	assert.Contains(t, css, "text-transform: uppercase;",
	144	+	"group header should use text-transform uppercase")
	145	+	assert.Contains(t, css, "letter-spacing: 0.04em;",
	146	+	"group header should have letter-spacing")
	147	+	}
	148	+
	149	+	func TestGenerateHistorySidebarCSS_InGenerateCSSFull_DarkPalette(t *testing.T) {
	150	+	fullCSS := GenerateCSSFull(DefaultDarkPalette(), 1.0, DefaultFontConfig(), DefaultModeColors())
	151	+
	152	+	assert.Contains(t, fullCSS, ".history-sidebar-outer {",
	153	+	"GenerateCSSFull must include history sidebar outer selector for dark palette")
	154	+	assert.Contains(t, fullCSS, ".history-sidebar-row-title {",
	155	+	"GenerateCSSFull must include history sidebar row title selector for dark palette")
	156	+	assert.Contains(t, fullCSS, ".history-sidebar-search {",
	157	+	"GenerateCSSFull must include history sidebar search selector for dark palette")
	158	+	assert.Contains(t, fullCSS, ".history-sidebar-empty {",
	159	+	"GenerateCSSFull must include history sidebar empty selector for dark palette")
	160	+	}
	161	+
	162	+	func TestGenerateHistorySidebarCSS_InGenerateCSSFull_LightPalette(t *testing.T) {
	163	+	fullCSS := GenerateCSSFull(DefaultLightPalette(), 1.0, DefaultFontConfig(), DefaultModeColors())
	164	+
	165	+	assert.Contains(t, fullCSS, ".history-sidebar-outer {",
	166	+	"GenerateCSSFull must include history sidebar outer selector for light palette")
	167	+	assert.Contains(t, fullCSS, ".history-sidebar-row-title {",
	168	+	"GenerateCSSFull must include history sidebar row title selector for light palette")
	169	+	assert.Contains(t, fullCSS, ".history-sidebar-search {",
	170	+	"GenerateCSSFull must include history sidebar search selector for light palette")
	171	+	assert.Contains(t, fullCSS, ".history-sidebar-empty {",
	172	+	"GenerateCSSFull must include history sidebar empty selector for light palette")
	173	+	}
	174	+
	175	+	func TestGenerateHistorySidebarCSS_LiveReloadSeamIncludesUpdatedCSS(t *testing.T) {
	176	+	// GenerateCSSFull is the live theme reload entry point called when
	177	+	// the palette changes at runtime. This test proves that switching
	178	+	// palettes produces different history sidebar CSS, confirming the
	179	+	// full generation path includes and re-generates the sidebar styles.
	180	+	darkCSS := GenerateCSSFull(DefaultDarkPalette(), 1.0, DefaultFontConfig(), DefaultModeColors())
	181	+	lightCSS := GenerateCSSFull(DefaultLightPalette(), 1.0, DefaultFontConfig(), DefaultModeColors())
	182	+
	183	+	// Both must contain history sidebar selectors.
	184	+	assert.Contains(t, darkCSS, ".history-sidebar-outer {", "dark CSS must have sidebar styles")
	185	+	assert.Contains(t, lightCSS, ".history-sidebar-outer {", "light CSS must have sidebar styles")
	186	+
	187	+	// The CSS must differ between palettes (different color values).
	188	+	if darkCSS == lightCSS {
	189	+	t.Fatal("dark and light palette should produce different CSS when history sidebar is included")
	190	+	}
	191	+
	192	+	// The dark and light outputs must both be parseable: each '{' has '}'.
	193	+	assert.Equal(t, strings.Count(darkCSS, "{"), strings.Count(darkCSS, "}"),
	194	+	"dark CSS braces must be balanced")
	195	+	assert.Equal(t, strings.Count(lightCSS, "{"), strings.Count(lightCSS, "}"),
	196	+	"light CSS braces must be balanced")
	197	+	}
	198	+
	199	+	func TestGenerateHistorySidebarCSS_InGenerateCSSFull_WithCustomScaleAndFonts(t *testing.T) {
	200	+	customFonts := FontConfig{
	201	+	SansFont: "Noto Sans",
	202	+	MonospaceFont: "JetBrains Mono",
	203	+	GtkFont: "Noto Sans",
	204	+	}
	205	+	customModeColors := ModeColors{
	206	+	PaneMode: "#ff0000",
	207	+	TabMode: "#00ff00",
	208	+	SessionMode: "#0000ff",
	209	+	ResizeMode: "#ffff00",
	210	+	}
	211	+
	212	+	fullCSS := GenerateCSSFull(DefaultDarkPalette(), 2.0, customFonts, customModeColors)
	213	+
	214	+	assert.Contains(t, fullCSS, ".history-sidebar-outer {",
	215	+	"GenerateCSSFull with custom scale/fonts must include history sidebar selectors")
	216	+	assert.Contains(t, fullCSS, ".history-sidebar-row:hover {",
	217	+	"GenerateCSSFull must include hover state for history rows")
	218	+	assert.Contains(t, fullCSS, ".history-sidebar-row:selected {",
	219	+	"GenerateCSSFull must include selected state for history rows")
	220	+	assert.Contains(t, fullCSS, ".history-sidebar-row:focus {",
	221	+	"GenerateCSSFull must include focus state for history rows")
	222	+	}
	223	+
	224	+	// TestGenerateHistorySidebarCSS_LiveReloadFullPath verifies that the
	225	+	// GenerateCSSFull entry point (used by live theme reload) includes the
	226	+	// history sidebar CSS with correct palette values. This is the path that
	227	+	// would be called when the user changes themes at runtime.
	228	+	func TestGenerateHistorySidebarCSS_LiveReloadFullPath(t *testing.T) {
	229	+	darkPalette := DefaultDarkPalette()
	230	+	lightPalette := DefaultLightPalette()
	231	+	customPalette := Palette{
	232	+	Background: "#111111",
	233	+	Surface: "#222222",
	234	+	SurfaceVariant: "#333333",
	235	+	Text: "#eeeeee",
	236	+	Muted: "#aaaaaa",
	237	+	Accent: "#ff6600",
	238	+	Border: "#444444",
	239	+	Success: "#00cc44",
	240	+	Warning: "#ffaa00",
	241	+	Destructive: "#cc2222",
	242	+	}
	243	+
	244	+	// GenerateCSSFull is the exact function called by the live theme reload
	245	+	// path. It generates ALL CSS including the history sidebar selectors.
	246	+	darkCSS := GenerateCSSFull(darkPalette, 1.0, DefaultFontConfig(), DefaultModeColors())
	247	+	lightCSS := GenerateCSSFull(lightPalette, 1.0, DefaultFontConfig(), DefaultModeColors())
	248	+	customCSS := GenerateCSSFull(customPalette, 1.0, DefaultFontConfig(), DefaultModeColors())
	249	+
	250	+	// All three must contain the full set of history sidebar selectors.
	251	+	sidebarSelectors := []string{
	252	+	".history-sidebar-outer",
	253	+	".history-sidebar-search-box",
	254	+	".history-sidebar-search",
	255	+	".history-sidebar-groups",
	256	+	".history-sidebar-group-header",
	257	+	".history-sidebar-row",
	258	+	".history-sidebar-row:hover",
	259	+	".history-sidebar-row:selected",
	260	+	".history-sidebar-row:focus",
	261	+	".history-sidebar-row-title",
	262	+	".history-sidebar-row-subtitle",
	263	+	".history-sidebar-row-time",
	264	+	".history-sidebar-empty",
	265	+	".history-sidebar-loading",
	266	+	}
	267	+
	268	+	for _, sel := range sidebarSelectors {
	269	+	assert.Contains(t, darkCSS, sel+" {", "dark CSS must have selector %s", sel)
	270	+	assert.Contains(t, lightCSS, sel+" {", "light CSS must have selector %s", sel)
	271	+	assert.Contains(t, customCSS, sel+" {", "custom CSS must have selector %s", sel)
	272	+	}
	273	+
	274	+	// Palette-specific values must differ.
	275	+	assert.NotEqual(t, darkCSS, lightCSS, "dark and light GenerateCSSFull output must differ")
	276	+	assert.NotEqual(t, darkCSS, customCSS, "dark and custom GenerateCSSFull output must differ")
	277	+	assert.NotEqual(t, lightCSS, customCSS, "light and custom GenerateCSSFull output must differ")
	278	+
	279	+	// Sidebar CSS should always use the accent variable, while the :root block
	280	+	// carries the palette-specific value that changes on live reload.
	281	+	assert.Contains(t, darkCSS, "alpha(var(--accent), 0.18)")
	282	+	assert.Contains(t, lightCSS, "alpha(var(--accent), 0.18)")
	283	+	assert.Contains(t, customCSS, "alpha(var(--accent), 0.18)")
	284	+	assert.Contains(t, darkCSS, "\n --accent: "+darkPalette.Accent+";\n")
	285	+	assert.Contains(t, lightCSS, "\n --accent: "+lightPalette.Accent+";\n")
	286	+	assert.Contains(t, customCSS, "\n --accent: "+customPalette.Accent+";\n")
	287	+
	288	+	// All three outputs must be syntactically valid: every '{' has a matching '}'.
	289	+	for name, css := range map[string]string{
	290	+	"dark": darkCSS,
	291	+	"light": lightCSS,
	292	+	"custom": customCSS,
	293	+	} {
	294	+	assert.Equal(t, strings.Count(css, "{"), strings.Count(css, "}"),
	295	+	"%s CSS braces must be balanced", name)
	296	+	}
	297	+	}
	298	+
	299	+	// TestGenerateHistorySidebarCSS_LiveReloadPaletteSwitch verifies that
	300	+	// switching palettes at GenerateCSSFull level updates the history sidebar
	301	+	// accent values. This simulates what happens when the theme system applies
	302	+	// a new palette at runtime: the full CSS (including sidebar) is regenerated.
	303	+	func TestGenerateHistorySidebarCSS_LiveReloadPaletteSwitch(t *testing.T) {
	304	+	// Start with dark palette.
	305	+	current := DefaultDarkPalette()
	306	+	cssBefore := GenerateCSSFull(current, 1.0, DefaultFontConfig(), DefaultModeColors())
	307	+
	308	+	// Verify the sidebar section uses the shared accent variable.
	309	+	assert.Contains(t, cssBefore, "alpha(var(--accent), 0.18)",
	310	+	"initial palette should render sidebar CSS through the accent variable")
	311	+	assert.Contains(t, cssBefore, "\n --accent: "+current.Accent+";\n")
	312	+
	313	+	// Switch to light palette (simulating runtime theme change).
	314	+	current = DefaultLightPalette()
	315	+	cssAfter := GenerateCSSFull(current, 1.0, DefaultFontConfig(), DefaultModeColors())
	316	+
	317	+	assert.Contains(t, cssAfter, "alpha(var(--accent), 0.18)",
	318	+	"updated palette should still use the shared accent variable")
	319	+	assert.Contains(t, cssAfter, "\n --accent: "+current.Accent+";\n")
	320	+
	321	+	// The old palette variable definition must not remain after switching.
	322	+	darkAccent := DefaultDarkPalette().Accent
	323	+	if current.Accent != darkAccent {
	324	+	assert.NotContains(t, cssAfter, "\n --accent: "+darkAccent+";\n")
	325	+	}
	326	+
	327	+	// History sidebar selectors must be present in both.
	328	+	assert.Contains(t, cssBefore, ".history-sidebar-row:selected {")
	329	+	assert.Contains(t, cssAfter, ".history-sidebar-row:selected {")
	330	+
	331	+	// The before and after CSS must be different (palette changed).
	332	+	assert.NotEqual(t, cssBefore, cssAfter, "CSS must change when palette switches")
	333	+	}

M internal/ui/window/main_window.go +111 -33


@@ -18,12 +18,24 @@ const (
18	18		)
19	19
20	20		// MainWindow represents the main browser window.
	21	+	//
	22	+	// Layout hierarchy:
	23	+	//
	24	+	// window
	25	+	// rootBox (vertical)
	26	+	// contentOverlay
	27	+	// contentAreaHBox (horizontal)
	28	+	// mainContentBox (vertical, expand) ← workspace tab content
	29	+	// sidebarBox (vertical, fixed width) ← optional sidebar
	30	+	// tabBar (overlay, not measured)
21	31		type MainWindow struct {
22	32		window *gtk.ApplicationWindow
23	33		rootBox *gtk.Box // Vertical: tab bar + content
24	34		tabBar *component.TabBar
25	35		contentOverlay *gtk.Overlay // Overlay for content + omnibox
26		-	contentArea *gtk.Box // Container for workspace content
	36	+	contentAreaBox *gtk.Box // Horizontal: main content + sidebar
	37	+	mainContentBox *gtk.Box // Vertical container for workspace content
	38	+	sidebarBox *gtk.Box // Vertical container for sidebar (hidden by default)
27	39		currentContent *gtk.Widget // Track current content for removal on tab switch
28	40
29	41		tabBarPosition string // "top" or "bottom"

@@ -49,10 +61,26 @@ func New(ctx context.Context, app gtk.Application, tabBarPosition string) (Mai
49	61		mw.window.SetTitle(&title)
50	62		mw.window.SetDefaultSize(defaultWidth, defaultHeight)
51	63
	64	+	if err := mw.initLayoutWidgets(); err != nil {
	65	+	return nil, err
	66	+	}
	67	+
	68	+	mw.contentAreaBox.Append(&mw.mainContentBox.Widget)
	69	+	mw.contentAreaBox.Append(&mw.sidebarBox.Widget)
	70	+	mw.contentOverlay.SetChild(&mw.contentAreaBox.Widget)
	71	+
	72	+	mw.assembleLayout()
	73	+
	74	+	mw.window.SetChild(&mw.rootBox.Widget)
	75	+
	76	+	return mw, nil
	77	+	}
	78	+
	79	+	func (mw *MainWindow) initLayoutWidgets() error {
52	80		mw.rootBox = gtk.NewBox(gtk.OrientationVerticalValue, 0)
53	81		if mw.rootBox == nil {
54	82		mw.window.Unref()
55		-	return nil, ErrWidgetCreationFailed("rootBox")
	83	+	return ErrWidgetCreationFailed("rootBox")
56	84		}
57	85		mw.rootBox.SetHexpand(true)
58	86		mw.rootBox.SetVexpand(true)

@@ -62,40 +90,77 @@ func New(ctx context.Context, app gtk.Application, tabBarPosition string) (Mai
62	90		if mw.tabBar == nil {
63	91		mw.rootBox.Unref()
64	92		mw.window.Unref()
65		-	return nil, ErrWidgetCreationFailed("tabBar")
	93	+	return ErrWidgetCreationFailed("tabBar")
	94	+	}
	95	+
	96	+	if err := mw.initContentWidgets(); err != nil {
	97	+	return err
66	98		}
	99	+	return nil
	100	+	}
67	101
	102	+	func (mw *MainWindow) initContentWidgets() error {
68	103		mw.contentOverlay = gtk.NewOverlay()
69	104		if mw.contentOverlay == nil {
70	105		mw.tabBar.Destroy()
71	106		mw.rootBox.Unref()
72	107		mw.window.Unref()
73		-	return nil, ErrWidgetCreationFailed("contentOverlay")
	108	+	return ErrWidgetCreationFailed("contentOverlay")
74	109		}
75	110		mw.contentOverlay.SetHexpand(true)
76	111		mw.contentOverlay.SetVexpand(true)
77	112		mw.contentOverlay.SetVisible(true)
78	113
79		-	mw.contentArea = gtk.NewBox(gtk.OrientationVerticalValue, 0)
80		-	if mw.contentArea == nil {
	114	+	// Horizontal box to hold both main content and sidebar side by side.
	115	+	mw.contentAreaBox = gtk.NewBox(gtk.OrientationHorizontalValue, 0)
	116	+	if mw.contentAreaBox == nil {
81	117		mw.contentOverlay.Unref()
82	118		mw.tabBar.Destroy()
83	119		mw.rootBox.Unref()
84	120		mw.window.Unref()
85		-	return nil, ErrWidgetCreationFailed("contentArea")
	121	+	return ErrWidgetCreationFailed("contentAreaBox")
86	122		}
87		-	mw.contentArea.SetHexpand(true)
88		-	mw.contentArea.SetVexpand(true)
89		-	mw.contentArea.SetVisible(true)
90		-	mw.contentArea.AddCssClass("content-area")
	123	+	mw.contentAreaBox.SetHexpand(true)
	124	+	mw.contentAreaBox.SetVexpand(true)
	125	+	mw.contentAreaBox.SetVisible(true)
91	126
92		-	mw.contentOverlay.SetChild(&mw.contentArea.Widget)
93		-
94		-	mw.assembleLayout()
	127	+	if err := mw.initContentBoxes(); err != nil {
	128	+	return err
	129	+	}
	130	+	return nil
	131	+	}
95	132
96		-	mw.window.SetChild(&mw.rootBox.Widget)
	133	+	func (mw *MainWindow) initContentBoxes() error {
	134	+	// Main content box (vertical) for workspace content.
	135	+	mw.mainContentBox = gtk.NewBox(gtk.OrientationVerticalValue, 0)
	136	+	if mw.mainContentBox == nil {
	137	+	mw.contentAreaBox.Unref()
	138	+	mw.contentOverlay.Unref()
	139	+	mw.tabBar.Destroy()
	140	+	mw.rootBox.Unref()
	141	+	mw.window.Unref()
	142	+	return ErrWidgetCreationFailed("mainContentBox")
	143	+	}
	144	+	mw.mainContentBox.SetHexpand(true)
	145	+	mw.mainContentBox.SetVexpand(true)
	146	+	mw.mainContentBox.SetVisible(true)
	147	+
	148	+	// Sidebar box (hidden by default).
	149	+	mw.sidebarBox = gtk.NewBox(gtk.OrientationVerticalValue, 0)
	150	+	if mw.sidebarBox == nil {
	151	+	mw.mainContentBox.Unref()
	152	+	mw.contentAreaBox.Unref()
	153	+	mw.contentOverlay.Unref()
	154	+	mw.tabBar.Destroy()
	155	+	mw.rootBox.Unref()
	156	+	mw.window.Unref()
	157	+	return ErrWidgetCreationFailed("sidebarBox")
	158	+	}
	159	+	mw.sidebarBox.SetHexpand(false)
	160	+	mw.sidebarBox.SetVexpand(true)
	161	+	mw.sidebarBox.SetVisible(false)
97	162
98		-	return mw, nil
	163	+	return nil
99	164		}
100	165
101	166		func (mw *MainWindow) assembleLayout() {

@@ -147,21 +212,26 @@ func (mw MainWindow) TabBar() component.TabBar {
147	212		return mw.tabBar
148	213		}
149	214
150		-	// ContentArea returns the main content container widget.
	215	+	// ContentArea returns the main content container widget (the vertical
	216	+	// box where workspace content is placed).
151	217		func (mw MainWindow) ContentArea() gtk.Box {
152		-	return mw.contentArea
	218	+	return mw.mainContentBox
153	219		}
154	220
155		-	// SetContent replaces the current content widget with the given widget.
	221	+	// SetContent replaces the current content widget in the main content area
	222	+	// (the vertical box that holds workspace tab content).
156	223		func (mw MainWindow) SetContent(widget gtk.Widget) {
	224	+	if mw == nil \|\| mw.mainContentBox == nil {
	225	+	return
	226	+	}
157	227		if mw.currentContent != nil {
158		-	mw.contentArea.Remove(mw.currentContent)
	228	+	mw.mainContentBox.Remove(mw.currentContent)
159	229		mw.currentContent = nil
160	230		}
161	231
162	232		if widget != nil {
163	233		widget.SetVisible(true)
164		-	mw.contentArea.Append(widget)
	234	+	mw.mainContentBox.Append(widget)
165	235		mw.currentContent = widget
166	236		}
167	237		}

@@ -201,30 +271,30 @@ func (mw MainWindow) ContentOverlay() gtk.Overlay {
201	271		}
202	272
203	273		// SetTabBarContentInsetVisible adds or removes the tab bar inset CSS class
204		-	// on the content area. Avoids duplicate add/remove if already in the desired state.
	274	+	// on the main content area. Avoids duplicate add/remove if already in the desired state.
205	275		func (mw *MainWindow) SetTabBarContentInsetVisible(visible bool) {
206		-	if mw.contentArea == nil {
	276	+	if mw.mainContentBox == nil {
207	277		return
208	278		}
209	279		class := mw.tabBarContentInsetClass()
210	280		if visible {
211		-	if !mw.contentArea.HasCssClass(class) {
212		-	mw.contentArea.AddCssClass(class)
	281	+	if !mw.mainContentBox.HasCssClass(class) {
	282	+	mw.mainContentBox.AddCssClass(class)
213	283		}
214	284		} else {
215		-	if mw.contentArea.HasCssClass(class) {
216		-	mw.contentArea.RemoveCssClass(class)
	285	+	if mw.mainContentBox.HasCssClass(class) {
	286	+	mw.mainContentBox.RemoveCssClass(class)
217	287		}
218	288		}
219	289		}
220	290
221	291		// HasTabBarContentInset returns whether the tab bar inset CSS class is currently
222		-	// applied to the content area.
	292	+	// applied to the main content area.
223	293		func (mw *MainWindow) HasTabBarContentInset() bool {
224		-	if mw.contentArea == nil {
	294	+	if mw.mainContentBox == nil {
225	295		return false
226	296		}
227		-	return mw.contentArea.HasCssClass(mw.tabBarContentInsetClass())
	297	+	return mw.mainContentBox.HasCssClass(mw.tabBarContentInsetClass())
228	298		}
229	299
230	300		func (mw *MainWindow) tabBarContentInsetClass() string {

@@ -247,9 +317,17 @@ func (mw *MainWindow) Destroy() {
247	317		mw.tabBar.Destroy()
248	318		mw.tabBar = nil
249	319		}
250		-	if mw.contentArea != nil {
251		-	mw.contentArea.Unref()
252		-	mw.contentArea = nil
	320	+	if mw.sidebarBox != nil {
	321	+	mw.sidebarBox.Unref()
	322	+	mw.sidebarBox = nil
	323	+	}
	324	+	if mw.mainContentBox != nil {
	325	+	mw.mainContentBox.Unref()
	326	+	mw.mainContentBox = nil
	327	+	}
	328	+	if mw.contentAreaBox != nil {
	329	+	mw.contentAreaBox.Unref()
	330	+	mw.contentAreaBox = nil
253	331		}
254	332		if mw.rootBox != nil {
255	333		mw.rootBox.Unref()

A internal/ui/window/main_window_sidebar.go +93 -0

@@ -0,0 +1,93 @@
	1	+	package window
	2	+
	3	+	import (
	4	+	"github.com/bnema/puregotk/v4/gtk"
	5	+	)
	6	+
	7	+	// SidebarWidthConfig defines the initial/recommended width range for the sidebar.
	8	+	type SidebarWidthConfig struct {
	9	+	// WidthPx is the preferred sidebar width.
	10	+	WidthPx int
	11	+	// MinPx is the minimum clamped width (default 280).
	12	+	MinPx int
	13	+	// MaxPx is the maximum clamping bound (default 380).
	14	+	MaxPx int
	15	+	}
	16	+
	17	+	// SidebarDefaultWidth returns a sensible default width configuration:
	18	+	// preferred 320px, clamped to [280, 380].
	19	+	func SidebarDefaultWidth() SidebarWidthConfig {
	20	+	return SidebarWidthConfig{
	21	+	WidthPx: 320,
	22	+	MinPx: 280,
	23	+	MaxPx: 380,
	24	+	}
	25	+	}
	26	+
	27	+	// SetSidebarWidth sets the sidebar box width to widthPx, clamped to the
	28	+	// config's [MinPx, MaxPx] bounds. Using the zero-value SidebarWidthConfig{}
	29	+	// sets sensible defaults (320px clamped to [280, 380]).
	30	+	func (mw *MainWindow) SetSidebarWidth(cfg SidebarWidthConfig) {
	31	+	if mw.sidebarBox == nil {
	32	+	return
	33	+	}
	34	+	defaults := SidebarDefaultWidth()
	35	+	if cfg.MinPx == 0 {
	36	+	cfg.MinPx = defaults.MinPx
	37	+	}
	38	+	if cfg.MaxPx == 0 {
	39	+	cfg.MaxPx = defaults.MaxPx
	40	+	}
	41	+	if cfg.WidthPx == 0 {
	42	+	cfg.WidthPx = defaults.WidthPx
	43	+	}
	44	+	if cfg.MinPx > cfg.MaxPx {
	45	+	mw.logger.Warn().Int("min_px", cfg.MinPx).Int("max_px", cfg.MaxPx).Msg("invalid sidebar width bounds; swapping")
	46	+	cfg.MinPx, cfg.MaxPx = cfg.MaxPx, cfg.MinPx
	47	+	}
	48	+	clamped := cfg.WidthPx
	49	+	if clamped < cfg.MinPx {
	50	+	clamped = cfg.MinPx
	51	+	}
	52	+	if clamped > cfg.MaxPx {
	53	+	clamped = cfg.MaxPx
	54	+	}
	55	+	mw.sidebarBox.SetSizeRequest(clamped, -1)
	56	+	mw.logger.Debug().Int("sidebar_width", clamped).Msg("sidebar width set")
	57	+	}
	58	+
	59	+	// SetSidebarVisible shows or hides the sidebar pane.
	60	+	func (mw *MainWindow) SetSidebarVisible(visible bool) {
	61	+	if mw.sidebarBox == nil {
	62	+	return
	63	+	}
	64	+	mw.sidebarBox.SetVisible(visible)
	65	+	mw.logger.Debug().Bool("sidebar_visible", visible).Msg("sidebar visibility changed")
	66	+	}
	67	+
	68	+	// IsSidebarVisible returns whether the sidebar pane is currently visible.
	69	+	func (mw *MainWindow) IsSidebarVisible() bool {
	70	+	if mw.sidebarBox == nil {
	71	+	return false
	72	+	}
	73	+	return mw.sidebarBox.GetVisible()
	74	+	}
	75	+
	76	+	// SetSidebarWidget replaces the current sidebar content widget.
	77	+	func (mw MainWindow) SetSidebarWidget(widget gtk.Widget) {
	78	+	if mw.sidebarBox == nil {
	79	+	return
	80	+	}
	81	+	// Remove existing children
	82	+	for {
	83	+	child := mw.sidebarBox.GetFirstChild()
	84	+	if child == nil {
	85	+	break
	86	+	}
	87	+	mw.sidebarBox.Remove(child)
	88	+	}
	89	+	if widget != nil {
	90	+	widget.SetVisible(true)
	91	+	mw.sidebarBox.Append(widget)
	92	+	}
	93	+	}