6c7260d fix(favorites): harden tag interaction lifecycle · dumber

M internal/ui/component/favorites_sidebar.go +5 -4


@@ -72,6 +72,7 @@ type FavoritesSidebar struct {
72	72		retainedCallbacks []any
73	73		tagCallbacks []any
74	74		tagPromptCallbacks []any
	75	+	formCallbacks []any
75	76		formTagMatchCallbacks []any
76	77		ctx context.Context
77	78		cancel context.CancelFunc

@@ -232,7 +233,7 @@ func (fs *FavoritesSidebar) createOuterAndSearch() error {
232	233		}
233	234		fs.searchEntry.AddCssClass("sidebar-search")
234	235		fs.searchEntry.AddCssClass("favorites-sidebar-search")
235		-	fs.trackTextInputFocus(&fs.searchEntry.Widget)
	236	+	fs.trackTextInputFocus(&fs.searchEntry.Widget, &fs.retainedCallbacks)
236	237		fs.searchEntry.SetHexpand(true)
237	238		placeholder := "Search favorites..."
238	239		fs.searchEntry.SetPlaceholderText(&placeholder)

@@ -259,8 +260,8 @@ func (fs *FavoritesSidebar) createTagControls() error {
259	260		return nil
260	261		}
261	262
262		-	func (fs FavoritesSidebar) trackTextInputFocus(widget gtk.Widget) {
263		-	if fs == nil \|\| widget == nil {
	263	+	func (fs FavoritesSidebar) trackTextInputFocus(widget gtk.Widget, callbacks *[]any) {
	264	+	if fs == nil \|\| widget == nil \|\| callbacks == nil {
264	265		return
265	266		}
266	267		controller := gtk.NewEventControllerFocus()

@@ -269,7 +270,7 @@ func (fs FavoritesSidebar) trackTextInputFocus(widget gtk.Widget) {
269	270		}
270	271		entered := func(gtk.EventControllerFocus) { fs.setTextInputFocused(widget) }
271	272		left := func(gtk.EventControllerFocus) { fs.clearTextInputFocus(widget) }
272		-	fs.retainedCallbacks = append(fs.retainedCallbacks, entered, left)
	273	+	callbacks = append(callbacks, entered, left)
273	274		controller.ConnectEnter(&entered)
274	275		controller.ConnectLeave(&left)
275	276		widget.AddController(&controller.EventController)

 	retainedCallbacks     []any
 	tagCallbacks          []any
 	tagPromptCallbacks    []any
+	formCallbacks         []any
 	formTagMatchCallbacks []any
 	ctx                   context.Context
 	cancel                context.CancelFunc
 	}
 	fs.searchEntry.AddCssClass("sidebar-search")
 	fs.searchEntry.AddCssClass("favorites-sidebar-search")
-	fs.trackTextInputFocus(&fs.searchEntry.Widget)
+	fs.trackTextInputFocus(&fs.searchEntry.Widget, &fs.retainedCallbacks)
 	fs.searchEntry.SetHexpand(true)
 	placeholder := "Search favorites..."
 	fs.searchEntry.SetPlaceholderText(&placeholder)
 	return nil
 }
-func (fs *FavoritesSidebar) trackTextInputFocus(widget *gtk.Widget) {
+func (fs *FavoritesSidebar) trackTextInputFocus(widget *gtk.Widget, callbacks *[]any) {
-	if fs == nil || widget == nil {
+	if fs == nil || widget == nil || callbacks == nil {
 		return
 	}
 	controller := gtk.NewEventControllerFocus()
 	}
 	entered := func(gtk.EventControllerFocus) { fs.setTextInputFocused(widget) }
 	left := func(gtk.EventControllerFocus) { fs.clearTextInputFocus(widget) }
-	fs.retainedCallbacks = append(fs.retainedCallbacks, entered, left)
+	*callbacks = append(*callbacks, entered, left)
 	controller.ConnectEnter(&entered)
 	controller.ConnectLeave(&left)
 	widget.AddController(&controller.EventController)

M internal/ui/component/favorites_sidebar_form_tags.go +10 -1


@@ -28,7 +28,7 @@ func (fs *FavoritesSidebar) setupFormTagSearch() {
28	28		return
29	29		}
30	30		changed := func(_ gtk.SearchEntry) { fs.renderFormTagMatches(fs.formTagSearch.GetText()) }
31		-	fs.retainedCallbacks = append(fs.retainedCallbacks, changed)
	31	+	fs.formCallbacks = append(fs.formCallbacks, changed)
32	32		fs.formTagSearch.ConnectSearchChanged(&changed)
33	33		}
34	34

@@ -149,23 +149,32 @@ func (fs *FavoritesSidebar) updateFavoriteTags(favoriteID entity.FavoriteID, wan
149	149		wantedSet[id] = struct{}{}
150	150		}
151	151		currentSet := tagIDSet(current)
	152	+	mutated := false
152	153		for id := range currentSet {
153	154		if _, ok := wantedSet[id]; ok {
154	155		continue
155	156		}
156	157		if err := uc.UntagFavorite(ctx, favoriteID, id); err != nil {
	158	+	if mutated {
	159	+	fs.startLoad()
	160	+	}
157	161		fs.setNotice(err.Error())
158	162		return false
159	163		}
	164	+	mutated = true
160	165		}
161	166		for id := range wantedSet {
162	167		if _, ok := currentSet[id]; ok {
163	168		continue
164	169		}
165	170		if err := uc.TagFavorite(ctx, favoriteID, id); err != nil {
	171	+	if mutated {
	172	+	fs.startLoad()
	173	+	}
166	174		fs.setNotice(err.Error())
167	175		return false
168	176		}
	177	+	mutated = true
169	178		}
170	179		return true
171	180		}

 		return
 	}
 	changed := func(_ gtk.SearchEntry) { fs.renderFormTagMatches(fs.formTagSearch.GetText()) }
-	fs.retainedCallbacks = append(fs.retainedCallbacks, changed)
+	fs.formCallbacks = append(fs.formCallbacks, changed)
 	fs.formTagSearch.ConnectSearchChanged(&changed)
 }
 		wantedSet[id] = struct{}{}
 	}
 	currentSet := tagIDSet(current)
+	mutated := false
 	for id := range currentSet {
 		if _, ok := wantedSet[id]; ok {
 			continue
 		}
 		if err := uc.UntagFavorite(ctx, favoriteID, id); err != nil {
+			if mutated {
+				fs.startLoad()
+			}
 			fs.setNotice(err.Error())
 			return false
 		}
+		mutated = true
 	}
 	for id := range wantedSet {
 		if _, ok := currentSet[id]; ok {
 			continue
 		}
 		if err := uc.TagFavorite(ctx, favoriteID, id); err != nil {
+			if mutated {
+				fs.startLoad()
+			}
 			fs.setNotice(err.Error())
 			return false
 		}
+		mutated = true
 	}
 	return true
 }

M internal/ui/component/favorites_sidebar_forms.go +9 -6


@@ -75,12 +75,16 @@ func (fs FavoritesSidebar) renderForm(fav entity.Favorite) {
75	75		return
76	76		}
77	77		clearBoxChildren(fs.formBox)
	78	+	fs.formCallbacks = nil
	79	+	fs.formTagMatchCallbacks = nil
78	80		fs.formURLEntry = gtk.NewSearchEntry()
79	81		fs.formTitleEntry = gtk.NewSearchEntry()
80	82		fs.formTagSearch = gtk.NewSearchEntry()
81	83		fs.formTagMatches = gtk.NewBox(gtk.OrientationHorizontalValue, 3)
82	84		fs.formShortcutEntry = gtk.NewSearchEntry()
	85	+	fs.mu.Lock()
83	86		fs.formTagIDs = tagIDSet(favoriteTags(fav))
	87	+	fs.mu.Unlock()
84	88		entries := []struct {
85	89		entry *gtk.SearchEntry
86	90		label string

@@ -96,7 +100,7 @@ func (fs FavoritesSidebar) renderForm(fav entity.Favorite) {
96	100		}
97	101		placeholder := item.label
98	102		item.entry.SetPlaceholderText(&placeholder)
99		-	fs.trackTextInputFocus(&item.entry.Widget)
	103	+	fs.trackTextInputFocus(&item.entry.Widget, &fs.formCallbacks)
100	104		fs.formBox.Append(&item.entry.Widget)
101	105		}
102	106		if fs.formTagMatches != nil {

@@ -109,7 +113,7 @@ func (fs FavoritesSidebar) renderForm(fav entity.Favorite) {
109	113		cb := func(_ gtk.Button) {
110	114		fs.submitForm()
111	115		}
112		-	fs.retainedCallbacks = append(fs.retainedCallbacks, cb)
	116	+	fs.formCallbacks = append(fs.formCallbacks, cb)
113	117		fs.formSaveButton.ConnectClicked(&cb)
114	118		fs.formBox.Append(&fs.formSaveButton.Widget)
115	119		}

@@ -179,12 +183,11 @@ func (fs *FavoritesSidebar) cancelManagement() bool {
179	183		if fs.formBox != nil {
180	184		fs.formBox.SetVisible(false)
181	185		clearBoxChildren(fs.formBox)
	186	+	fs.formCallbacks = nil
	187	+	fs.formTagMatchCallbacks = nil
182	188		}
183	189		if fs.tagPromptBox != nil {
184		-	fs.clearTagPromptContent()
185		-	fs.tagPromptBox.SetVisible(false)
186		-	fs.tagNameEntry = nil
187		-	fs.tagPromptSaveBtn = nil
	190	+	fs.hideTagPrompt()
188	191		}
189	192		fs.rebuildList()
190	193		return active

 		return
 	}
 	clearBoxChildren(fs.formBox)
+	fs.formCallbacks = nil
+	fs.formTagMatchCallbacks = nil
 	fs.formURLEntry = gtk.NewSearchEntry()
 	fs.formTitleEntry = gtk.NewSearchEntry()
 	fs.formTagSearch = gtk.NewSearchEntry()
 	fs.formTagMatches = gtk.NewBox(gtk.OrientationHorizontalValue, 3)
 	fs.formShortcutEntry = gtk.NewSearchEntry()
+	fs.mu.Lock()
 	fs.formTagIDs = tagIDSet(favoriteTags(fav))
+	fs.mu.Unlock()
 	entries := []struct {
 		entry *gtk.SearchEntry
 		label string
 		}
 		placeholder := item.label
 		item.entry.SetPlaceholderText(&placeholder)
-		fs.trackTextInputFocus(&item.entry.Widget)
+		fs.trackTextInputFocus(&item.entry.Widget, &fs.formCallbacks)
 		fs.formBox.Append(&item.entry.Widget)
 	}
 	if fs.formTagMatches != nil {
 		cb := func(_ gtk.Button) {
 			fs.submitForm()
 		}
-		fs.retainedCallbacks = append(fs.retainedCallbacks, cb)
+		fs.formCallbacks = append(fs.formCallbacks, cb)
 		fs.formSaveButton.ConnectClicked(&cb)
 		fs.formBox.Append(&fs.formSaveButton.Widget)
 	}
 	if fs.formBox != nil {
 		fs.formBox.SetVisible(false)
 		clearBoxChildren(fs.formBox)
+		fs.formCallbacks = nil
+		fs.formTagMatchCallbacks = nil
 	}
 	if fs.tagPromptBox != nil {
-		fs.clearTagPromptContent()
+		fs.hideTagPrompt()
-		fs.tagPromptBox.SetVisible(false)
-		fs.tagNameEntry = nil
-		fs.tagPromptSaveBtn = nil
 	}
 	fs.rebuildList()
 	return active

M internal/ui/component/favorites_sidebar_keyboard.go +3 -2


@@ -307,9 +307,10 @@ func shouldFocusSearchForSlash(searchFocused bool) bool { return !searchFocused
307	307
308	308		// shouldDeferToTextInput keeps the sidebar controller from treating text typed
309	309		// into a descendant entry as a global sidebar command.
310		-	// Tab remains the one sidebar command that deliberately traverses focus.
	310	+	// Tab traverses focus and Escape cancels sidebar management while text is focused.
311	311		func shouldDeferToTextInput(textEditing bool, keyval uint) bool {
312		-	return textEditing && keyval != uint(gdk.KEY_Tab) && keyval != uint(gdk.KEY_ISO_Left_Tab)
	312	+	return textEditing && keyval != uint(gdk.KEY_Tab) &&
	313	+	keyval != uint(gdk.KEY_ISO_Left_Tab) && keyval != uint(gdk.KEY_Escape)
313	314		}
314	315
315	316		func (fs *FavoritesSidebar) routeDirectionalFocus(keyval uint) bool {

 // shouldDeferToTextInput keeps the sidebar controller from treating text typed
 // into a descendant entry as a global sidebar command.
-// Tab remains the one sidebar command that deliberately traverses focus.
+// Tab traverses focus and Escape cancels sidebar management while text is focused.
 func shouldDeferToTextInput(textEditing bool, keyval uint) bool {
-	return textEditing && keyval != uint(gdk.KEY_Tab) && keyval != uint(gdk.KEY_ISO_Left_Tab)
+	return textEditing && keyval != uint(gdk.KEY_Tab) &&
+		keyval != uint(gdk.KEY_ISO_Left_Tab) && keyval != uint(gdk.KEY_Escape)
 }
 func (fs *FavoritesSidebar) routeDirectionalFocus(keyval uint) bool {

M internal/ui/component/favorites_sidebar_tags.go +18 -6


@@ -12,7 +12,7 @@ func (fs *FavoritesSidebar) showCreateTagPrompt() {
12	12		if fs == nil \|\| fs.tagPromptBox == nil {
13	13		return
14	14		}
15		-	fs.clearTagPromptContent()
	15	+	fs.hideTagPrompt()
16	16		entry := gtk.NewEntry()
17	17		if entry == nil {
18	18		return

@@ -20,15 +20,17 @@ func (fs *FavoritesSidebar) showCreateTagPrompt() {
20	20		placeholder := "New tag name"
21	21		entry.SetPlaceholderText(&placeholder)
22	22		entry.AddCssClass("favorites-sidebar-tag-name")
23		-	fs.trackTextInputFocus(&entry.Widget)
	23	+	callbacks := make([]any, 0, 4)
	24	+	fs.trackTextInputFocus(&entry.Widget, &callbacks)
24	25		entry.SetHexpand(true)
25		-	callbacks := make([]any, 0, 2)
26	26		activateCb := func(gtk.Entry) { fs.submitTagName(entry.GetText()) }
27	27		callbacks = append(callbacks, activateCb)
28	28		entry.ConnectActivate(&activateCb)
	29	+	fs.storeTagPromptCallbacks(callbacks)
29	30
30	31		save := gtk.NewButtonWithLabel("Create")
31	32		if save == nil {
	33	+	fs.hideTagPrompt()
32	34		return
33	35		}
34	36		save.AddCssClass("favorites-sidebar-tag-create")

@@ -201,22 +203,32 @@ func favoriteHasTag(fav *entity.Favorite, tagID entity.TagID) bool {
201	203		}
202	204
203	205		func (fs *FavoritesSidebar) focusTagControl(index int) {
204		-	if fs == nil \|\| index < 0 \|\| index >= len(fs.tagControls) \|\| fs.tagControls[index] == nil {
	206	+	if fs == nil \|\| index < 0 {
205	207		return
206	208		}
	209	+	fs.mu.RLock()
	210	+	controls := append([]*gtk.Button(nil), fs.tagControls...)
	211	+	fs.mu.RUnlock()
	212	+	if index >= len(controls) \|\| controls[index] == nil {
	213	+	return
	214	+	}
	215	+	control := controls[index]
207	216		fs.mu.Lock()
208	217		if !fs.destroyed {
209	218		fs.focusZone = favoritesSidebarFocusTags
210	219		}
211	220		fs.mu.Unlock()
212		-	fs.tagControls[index].GrabFocus()
	221	+	control.GrabFocus()
213	222		}
214	223
215	224		func (fs *FavoritesSidebar) focusedTagControlIndex() int {
216	225		if fs == nil {
217	226		return -1
218	227		}
219		-	for index, control := range fs.tagControls {
	228	+	fs.mu.RLock()
	229	+	controls := append([]*gtk.Button(nil), fs.tagControls...)
	230	+	fs.mu.RUnlock()
	231	+	for index, control := range controls {
220	232		if control != nil && control.HasFocus() {
221	233		return index
222	234		}

 	if fs == nil || fs.tagPromptBox == nil {
 		return
 	}
-	fs.clearTagPromptContent()
+	fs.hideTagPrompt()
 	entry := gtk.NewEntry()
 	if entry == nil {
 		return
 	placeholder := "New tag name"
 	entry.SetPlaceholderText(&placeholder)
 	entry.AddCssClass("favorites-sidebar-tag-name")
-	fs.trackTextInputFocus(&entry.Widget)
+	callbacks := make([]any, 0, 4)
+	fs.trackTextInputFocus(&entry.Widget, &callbacks)
 	entry.SetHexpand(true)
-	callbacks := make([]any, 0, 2)
 	activateCb := func(gtk.Entry) { fs.submitTagName(entry.GetText()) }
 	callbacks = append(callbacks, activateCb)
 	entry.ConnectActivate(&activateCb)
+	fs.storeTagPromptCallbacks(callbacks)
 	save := gtk.NewButtonWithLabel("Create")
 	if save == nil {
+		fs.hideTagPrompt()
 		return
 	}
 	save.AddCssClass("favorites-sidebar-tag-create")
 }
 func (fs *FavoritesSidebar) focusTagControl(index int) {
-	if fs == nil || index < 0 || index >= len(fs.tagControls) || fs.tagControls[index] == nil {
+	if fs == nil || index < 0 {
 		return
 	}
+	fs.mu.RLock()
+	controls := append([]*gtk.Button(nil), fs.tagControls...)
+	fs.mu.RUnlock()
+	if index >= len(controls) || controls[index] == nil {
+		return
+	}
+	control := controls[index]
 	fs.mu.Lock()
 	if !fs.destroyed {
 		fs.focusZone = favoritesSidebarFocusTags
 	}
 	fs.mu.Unlock()
-	fs.tagControls[index].GrabFocus()
+	control.GrabFocus()
 }
 func (fs *FavoritesSidebar) focusedTagControlIndex() int {
 	if fs == nil {
 		return -1
 	}
-	for index, control := range fs.tagControls {
+	fs.mu.RLock()
+	controls := append([]*gtk.Button(nil), fs.tagControls...)
+	fs.mu.RUnlock()
+	for index, control := range controls {
 		if control != nil && control.HasFocus() {
 			return index
 		}

M internal/ui/component/favorites_sidebar_test.go +46 -1


@@ -41,6 +41,9 @@ type fakeFavoritesSidebarUC struct {
41	41		}
42	42		err error
43	43		errOnSetShortcut error
	44	+	errOnTag map[entity.TagID]error
	45	+	errOnUntag map[entity.TagID]error
	46	+	failUntagOnCall int
44	47		getAllCalled chan struct{}
45	48		}
46	49

@@ -99,6 +102,9 @@ func (f *fakeFavoritesSidebarUC) TagFavorite(_ context.Context, favID entity.Fav
99	102		favID entity.FavoriteID
100	103		tagID entity.TagID
101	104		}{favID: favID, tagID: tagID})
	105	+	if err := f.errOnTag[tagID]; err != nil {
	106	+	return err
	107	+	}
102	108		return f.err
103	109		}
104	110		func (f *fakeFavoritesSidebarUC) UntagFavorite(_ context.Context, favID entity.FavoriteID, tagID entity.TagID) error {

@@ -106,6 +112,12 @@ func (f *fakeFavoritesSidebarUC) UntagFavorite(_ context.Context, favID entity.F
106	112		favID entity.FavoriteID
107	113		tagID entity.TagID
108	114		}{favID: favID, tagID: tagID})
	115	+	if err := f.errOnUntag[tagID]; err != nil {
	116	+	return err
	117	+	}
	118	+	if f.failUntagOnCall > 0 && len(f.untagged) == f.failUntagOnCall {
	119	+	return errors.New("untag failed")
	120	+	}
109	121		return f.err
110	122		}
111	123

@@ -412,6 +424,22 @@ func TestFormTagCandidatesMatchesNamesAndKeepsSelectedTagsVisible(t *testing.T)
412	424		assert.Equal(t, []entity.Tag{reading}, formTagCandidates([]entity.Tag{dev, news, reading}, selected, "read"))
413	425		}
414	426
	427	+	func TestFavoritesSidebarReloadsAfterPartiallyApplyingTagChanges(t *testing.T) {
	428	+	first := entity.Tag{ID: 10, Name: "first"}
	429	+	second := entity.Tag{ID: 11, Name: "second"}
	430	+	fav := &entity.Favorite{ID: 5, URL: "https://go.dev", Tags: []entity.Tag{first, second}}
	431	+	fs := newFavoritesSidebarHarness([]*entity.Favorite{fav}, nil)
	432	+	uc := fs.favoritesUC.(*fakeFavoritesSidebarUC)
	433	+	uc.failUntagOnCall = 2
	434	+	fs.allFavorites = []*entity.Favorite{fav}
	435	+	fs.loadGen = 4
	436	+
	437	+	assert.False(t, fs.updateFavoriteTags(fav.ID, nil))
	438	+	assert.Len(t, uc.untagged, 2)
	439	+	assert.Equal(t, uint64(5), fs.loadGen, "a partial tag mutation must refresh stale favorites")
	440	+	assert.Equal(t, "untag failed", fs.notice)
	441	+	}
	442	+
415	443		func TestFavoritesSidebarFormTagSelectionAndEditSynchronization(t *testing.T) {
416	444		dev := entity.Tag{ID: 10, Name: "dev"}
417	445		news := entity.Tag{ID: 11, Name: "news"}

@@ -426,21 +454,34 @@ func TestFavoritesSidebarFormTagSelectionAndEditSynchronization(t *testing.T) {
426	454		assert.True(t, fs.updateFavoriteTags(fav.ID, fs.formTagIDsSnapshot()))
427	455		require.Len(t, uc.tagged, 1)
428	456		assert.Equal(t, news.ID, uc.tagged[0].tagID)
	457	+	fav.Tags = []entity.Tag{dev, news}
429	458
430	459		fs.toggleFormTag(dev.ID)
431	460		assert.True(t, fs.updateFavoriteTags(fav.ID, fs.formTagIDsSnapshot()))
432	461		require.Len(t, uc.untagged, 1)
433	462		assert.Equal(t, dev.ID, uc.untagged[0].tagID)
	463	+	assert.Len(t, uc.tagged, 1, "the synchronized persisted tags must not be added again")
434	464		}
435	465
436	466		func TestFavoritesSidebarDirectionalFocusMovesDirectlyBetweenSearchAndFirstFavorite(t *testing.T) {
437	467		fav := &entity.Favorite{ID: 1, URL: "https://go.dev"}
438	468		fs := newFavoritesSidebarHarness([]*entity.Favorite{fav}, nil)
	469	+	if !gtk.InitCheck() {
	470	+	t.Skip("GTK native display prerequisite unavailable (gtk.InitCheck returned false)")
	471	+	}
	472	+	listBox := gtk.NewListBox()
	473	+	require.NotNil(t, listBox)
	474	+	row := gtk.NewListBoxRow()
	475	+	require.NotNil(t, row)
	476	+	row.SetSelectable(true)
	477	+	listBox.Append(&row.Widget)
	478	+	fs.listBox = listBox
439	479		fs.displayRows = []favoriteSidebarDisplayRow{{FavoriteID: fav.ID, Favorite: fav, URL: fav.URL, Selectable: true}}
440	480		fs.focusZone = favoritesSidebarFocusSearch
441	481
442	482		assert.True(t, fs.routeDirectionalFocus(uint(gdk.KEY_Down)))
443	483		assert.Equal(t, favoritesSidebarFocusList, fs.focusZone)
	484	+	assert.Equal(t, row, fs.listBox.GetSelectedRow())
444	485		assert.True(t, fs.routeDirectionalFocus(uint(gdk.KEY_Up)))
445	486		assert.Equal(t, favoritesSidebarFocusSearch, fs.focusZone)
446	487		}

@@ -549,6 +590,10 @@ func TestFavoritesSidebarExplicitTextInputFocusControlsKeyboardRouting(t *testin
549	590		fs.setTextInputFocused(input)
550	591		assert.True(t, fs.inTextEditContext())
551	592		assert.True(t, shouldDeferToTextInput(fs.inTextEditContext(), uint(gdk.KEY_e)))
	593	+	assert.False(t, fs.handleSingleKeyCommand(uint(gdk.KEY_e), 0))
	594	+	fs.mode = favoritesSidebarModeAdd
	595	+	assert.True(t, fs.cancelManagement())
	596	+	assert.Equal(t, favoritesSidebarModeNone, fs.mode)
552	597
553	598		fs.clearTextInputFocus(input)
554	599		assert.False(t, fs.inTextEditContext())

@@ -565,13 +610,13 @@ func TestFavoritesSidebarTextInputDefersSidebarCommands(t *testing.T) {
565	610		uint(gdk.KEY_t),
566	611		uint(gdk.KEY_plus),
567	612		uint(gdk.KEY_Up),
568		-	uint(gdk.KEY_Escape),
569	613		uint(gdk.KEY_Return),
570	614		} {
571	615		assert.Truef(t, shouldDeferToTextInput(true, key), "key %d must reach the text input", key)
572	616		}
573	617		assert.False(t, shouldDeferToTextInput(true, uint(gdk.KEY_Tab)))
574	618		assert.False(t, shouldDeferToTextInput(true, uint(gdk.KEY_ISO_Left_Tab)))
	619	+	assert.False(t, shouldDeferToTextInput(true, uint(gdk.KEY_Escape)))
575	620		assert.False(t, shouldDeferToTextInput(false, uint(gdk.KEY_e)))
576	621		}
577	622

 	}
 	err              error
 	errOnSetShortcut error
+	errOnTag         map[entity.TagID]error
+	errOnUntag       map[entity.TagID]error
+	failUntagOnCall  int
 	getAllCalled     chan struct{}
 }
 		favID entity.FavoriteID
 		tagID entity.TagID
 	}{favID: favID, tagID: tagID})
+	if err := f.errOnTag[tagID]; err != nil {
+		return err
+	}
 	return f.err
 }
 func (f *fakeFavoritesSidebarUC) UntagFavorite(_ context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
 		favID entity.FavoriteID
 		tagID entity.TagID
 	}{favID: favID, tagID: tagID})
+	if err := f.errOnUntag[tagID]; err != nil {
+		return err
+	}
+	if f.failUntagOnCall > 0 && len(f.untagged) == f.failUntagOnCall {
+		return errors.New("untag failed")
+	}
 	return f.err
 }
 	assert.Equal(t, []*entity.Tag{reading}, formTagCandidates([]*entity.Tag{dev, news, reading}, selected, "read"))
 }
+func TestFavoritesSidebarReloadsAfterPartiallyApplyingTagChanges(t *testing.T) {
+	first := entity.Tag{ID: 10, Name: "first"}
+	second := entity.Tag{ID: 11, Name: "second"}
+	fav := &entity.Favorite{ID: 5, URL: "https://go.dev", Tags: []entity.Tag{first, second}}
+	fs := newFavoritesSidebarHarness([]*entity.Favorite{fav}, nil)
+	uc := fs.favoritesUC.(*fakeFavoritesSidebarUC)
+	uc.failUntagOnCall = 2
+	fs.allFavorites = []*entity.Favorite{fav}
+	fs.loadGen = 4
+	assert.False(t, fs.updateFavoriteTags(fav.ID, nil))
+	assert.Len(t, uc.untagged, 2)
+	assert.Equal(t, uint64(5), fs.loadGen, "a partial tag mutation must refresh stale favorites")
+	assert.Equal(t, "untag failed", fs.notice)
+}
 func TestFavoritesSidebarFormTagSelectionAndEditSynchronization(t *testing.T) {
 	dev := entity.Tag{ID: 10, Name: "dev"}
 	news := entity.Tag{ID: 11, Name: "news"}
 	assert.True(t, fs.updateFavoriteTags(fav.ID, fs.formTagIDsSnapshot()))
 	require.Len(t, uc.tagged, 1)
 	assert.Equal(t, news.ID, uc.tagged[0].tagID)
+	fav.Tags = []entity.Tag{dev, news}
 	fs.toggleFormTag(dev.ID)
 	assert.True(t, fs.updateFavoriteTags(fav.ID, fs.formTagIDsSnapshot()))
 	require.Len(t, uc.untagged, 1)
 	assert.Equal(t, dev.ID, uc.untagged[0].tagID)
+	assert.Len(t, uc.tagged, 1, "the synchronized persisted tags must not be added again")
 }
 func TestFavoritesSidebarDirectionalFocusMovesDirectlyBetweenSearchAndFirstFavorite(t *testing.T) {
 	fav := &entity.Favorite{ID: 1, URL: "https://go.dev"}
 	fs := newFavoritesSidebarHarness([]*entity.Favorite{fav}, nil)
+	if !gtk.InitCheck() {
+		t.Skip("GTK native display prerequisite unavailable (gtk.InitCheck returned false)")
+	}
+	listBox := gtk.NewListBox()
+	require.NotNil(t, listBox)
+	row := gtk.NewListBoxRow()
+	require.NotNil(t, row)
+	row.SetSelectable(true)
+	listBox.Append(&row.Widget)
+	fs.listBox = listBox
 	fs.displayRows = []favoriteSidebarDisplayRow{{FavoriteID: fav.ID, Favorite: fav, URL: fav.URL, Selectable: true}}
 	fs.focusZone = favoritesSidebarFocusSearch
 	assert.True(t, fs.routeDirectionalFocus(uint(gdk.KEY_Down)))
 	assert.Equal(t, favoritesSidebarFocusList, fs.focusZone)
+	assert.Equal(t, row, fs.listBox.GetSelectedRow())
 	assert.True(t, fs.routeDirectionalFocus(uint(gdk.KEY_Up)))
 	assert.Equal(t, favoritesSidebarFocusSearch, fs.focusZone)
 }
 	fs.setTextInputFocused(input)
 	assert.True(t, fs.inTextEditContext())
 	assert.True(t, shouldDeferToTextInput(fs.inTextEditContext(), uint(gdk.KEY_e)))
+	assert.False(t, fs.handleSingleKeyCommand(uint(gdk.KEY_e), 0))
+	fs.mode = favoritesSidebarModeAdd
+	assert.True(t, fs.cancelManagement())
+	assert.Equal(t, favoritesSidebarModeNone, fs.mode)
 	fs.clearTextInputFocus(input)
 	assert.False(t, fs.inTextEditContext())
 		uint(gdk.KEY_t),
 		uint(gdk.KEY_plus),
 		uint(gdk.KEY_Up),
-		uint(gdk.KEY_Escape),
 		uint(gdk.KEY_Return),
 	} {
 		assert.Truef(t, shouldDeferToTextInput(true, key), "key %d must reach the text input", key)
 	}
 	assert.False(t, shouldDeferToTextInput(true, uint(gdk.KEY_Tab)))
 	assert.False(t, shouldDeferToTextInput(true, uint(gdk.KEY_ISO_Left_Tab)))
+	assert.False(t, shouldDeferToTextInput(true, uint(gdk.KEY_Escape)))
 	assert.False(t, shouldDeferToTextInput(false, uint(gdk.KEY_e)))
 }