Fix bulk imports adding entries to navigation history

CHANGELOG.md

@@ -60,6 +60,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 ### Fixed
 
 - We fixed an issue where the AI export button was enabled even when the chat history was empty. [#14640](https://github.com/JabRef/jabref/issues/14640)
+- We fixed an issue where bulk import operations polluted the navigation history, making the Back/Forward buttons navigate through imported entries instead of only user-selected entries. [#13878](https://github.com/JabRef/jabref/issues/13878)
 - We fixed an issue where pressing <kbd>ESC</kbd> in the preferences dialog would not always close the dialog. [#8888](https://github.com/JabRef/jabref/issues/8888)
 - We fixed the checkbox in merge dialog "Treat duplicates the same way" to make it functional. [#14224](https://github.com/JabRef/jabref/pull/14224)
 - We fixed the fallback window height (786 → 768) in JabRefGUI. [#14295](https://github.com/JabRef/jabref/pull/14295)

jabgui/src/main/java/org/jabref/gui/LibraryTab.java

@@ -827,14 +827,17 @@ public void insertEntries(final List<BibEntry> entries) {
             return;
         }
 
-        importHandler.importCleanedEntries(null, entries);
-        getUndoManager().addEdit(new UndoableInsertEntries(bibDatabaseContext.getDatabase(), entries));
-        markBaseChanged();
-        stateManager.setSelectedEntries(entries);
-        if (preferences.getEntryEditorPreferences().shouldOpenOnNewEntry()) {
-            showAndEdit(entries.getFirst());
-        } else {
-            clearAndSelect(entries.getFirst());
+        // Suppress navigation history during bulk insert to prevent polluting back/forward navigation
+        try (NavigationHistory.Suppression ignored = navigationHistory.suppressUpdatesIf(entries.size() > 1)) {
+            importHandler.importCleanedEntries(null, entries);
+            getUndoManager().addEdit(new UndoableInsertEntries(bibDatabaseContext.getDatabase(), entries));
+            markBaseChanged();
+            stateManager.setSelectedEntries(entries);
+            if (preferences.getEntryEditorPreferences().shouldOpenOnNewEntry()) {
+                showAndEdit(entries.getFirst());
+            } else {
+                clearAndSelect(entries.getFirst());
+            }
         }
     }
 

jabgui/src/main/java/org/jabref/gui/NavigationHistory.java

@@ -11,19 +11,30 @@
  * Manages the navigation history of viewed entries using two stacks.
  * This class encapsulates the logic of moving back and forward by maintaining a "back" stack for past entries
  * and a "forward" stack for future entries.
+ *
+ * <p>History updates can be suppressed during bulk operations (e.g., file imports, drag-and-drop)
+ * using the {@link #suppressUpdates()} method, which employs a nesting-aware boolean flag to handle
+ * multiple concurrent suppression contexts correctly.</p>
  */
 public class NavigationHistory {
     private final List<BibEntry> previousEntries = new ArrayList<>();
     private final List<BibEntry> nextEntries = new ArrayList<>();
     private BibEntry currentEntry;
+    private boolean suppressNavigation = false;
 
     /**
      * Sets a new entry as the current one, clearing the forward history.
      * The previously current entry is moved to the back stack.
      *
+     * <p>This operation is skipped if navigation updates are currently suppressed.</p>
+     *
      * @param entry The BibEntry to add to the history.
      */
     public void add(BibEntry entry) {
+        if (suppressNavigation) {
+            return;
+        }
+
         if (Objects.equals(currentEntry, entry)) {
             return;
         }
@@ -74,4 +85,69 @@ public boolean canGoBack() {
     public boolean canGoForward() {
         return !nextEntries.isEmpty();
     }
+
+    /**
+     * Suppresses navigation history updates while the returned guard is open.
+     * Handles nesting correctly: if already suppressed, the flag is only cleared when the outermost guard closes.
+     *
+     * @return A {@link Suppression} guard that restores navigation tracking when closed.
+     */
+    public Suppression suppressUpdates() {
+        return new Suppression(this);
+    }
+
+    /**
+     * Convenience helper to suppress updates conditionally.
+     *
+     * @param active If true, returns an active suppression; otherwise returns a no-op suppression.
+     * @return A {@link Suppression} guard.
+     */
+    public Suppression suppressUpdatesIf(boolean active) {
+        return active ? suppressUpdates() : Suppression.noOp();
+    }
+
+    /**
+     * AutoCloseable guard for suppressing navigation history updates.
+     *
+     * <p>Uses a nesting-aware approach: captures the suppression state when created,
+     * and only restores it if this instance was the one that activated suppression.</p>
+     */
+    public static final class Suppression implements AutoCloseable {
+        private static final Suppression NO_OP = new Suppression();
+
+        private final NavigationHistory owner;
+        private boolean closed;
+        private final boolean active;
+        private final boolean wasAlreadySuppressed;
+
+        private Suppression() {
+            this.owner = null;
+            this.active = false;
+            this.wasAlreadySuppressed = false;
+        }
+
+        private Suppression(NavigationHistory owner) {
+            this.owner = owner;
+            this.active = true;
+            this.wasAlreadySuppressed = owner.suppressNavigation;
+            owner.suppressNavigation = true;
+        }
+
+        @Override
+        public void close() {
+            if (closed || !active) {
+                return;
+            }
+            closed = true;
+
+            // Only turn off suppression if we were the ones who turned it on
+            if (!wasAlreadySuppressed) {
+                owner.suppressNavigation = false;
+            }
+        }
+
+        public static Suppression noOp() {
+            return NO_OP;
+        }
+    }
 }

jabgui/src/test/java/org/jabref/gui/NavigationHistoryTest.java

@@ -0,0 +1,60 @@
+package org.jabref.gui;
+
+import java.util.Optional;
+
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.types.StandardEntryType;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class NavigationHistoryTest {
+
+    @Test
+    void addsEntriesAndNavigatesBackAndForward() {
+        NavigationHistory history = new NavigationHistory();
+        BibEntry first = new BibEntry(StandardEntryType.Article);
+        BibEntry second = new BibEntry(StandardEntryType.Book);
+
+        history.add(first);
+        history.add(second);
+
+        assertTrue(history.canGoBack());
+        Optional<BibEntry> back = history.back();
+        assertTrue(back.isPresent());
+        assertEquals(first, back.get());
+
+        assertTrue(history.canGoForward());
+        Optional<BibEntry> forward = history.forward();
+        assertTrue(forward.isPresent());
+        assertEquals(second, forward.get());
+    }
+
+    @Test
+    void suppressedAddsDoNotAffectHistory() {
+        NavigationHistory history = new NavigationHistory();
+        BibEntry initial = new BibEntry(StandardEntryType.Article);
+        BibEntry suppressed = new BibEntry(StandardEntryType.Book);
+        BibEntry later = new BibEntry(StandardEntryType.InProceedings);
+
+        history.add(initial);
+
+        try (NavigationHistory.Suppression ignored = history.suppressUpdates()) {
+            history.add(suppressed);
+        }
+
+        // still only the initial entry is tracked
+        assertFalse(history.canGoBack());
+
+        history.add(later);
+
+        assertTrue(history.canGoBack());
+        Optional<BibEntry> back = history.back();
+        assertTrue(back.isPresent());
+        assertEquals(initial, back.get());
+    }
+}
+