diff --git a/‎collins/editor.py‎
Lines changed: 4 additions & 0 deletions b/‎collins/editor.py‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎scripts/check_editor_save.py‎
Lines changed: 34 additions & 1 deletion b/‎scripts/check_editor_save.py‎
Lines changed: 34 additions & 1 deletion
@@ -903,6 +903,10 @@ def _on_loaded(self, opened: _OpenFile, load_id: int, kind: str, value) -> None:
                 self._notify(
                     _("Couldn't reload {name}: {message}").format(name=opened.path.name, message=failure)
                 )
+                # A `file-changed` that waited for this reload is judged all
+                # the same: the file may be gone or binary now, and that
+                # event is what tells the buffer so (review of PR 609).
+                self._settle_pending_change(opened)
             else:
                 self._notify(
                     _("Couldn't open {name}: {message}").format(name=opened.path.name, message=failure)
 
@@ -16,7 +16,8 @@
 file carries the edit; a clean buffer reloads silently, cursor kept; a
 save over a file that moved underneath is refused `stale` and asks before
 overwriting (the "changed on disk" dialog, stubbed), the file untouched
-until Overwrite; a deleted file is told and marked dirty; a closed tab's
+until Overwrite; a deleted file is told and marked dirty; a change that
+waited for a reload is judged even when the reload fails; a closed tab's
 watch is gone. The pane never opens a file itself.
 
 This is a script, not a pytest test, on purpose: tests/conftest.py blocks
@@ -64,6 +65,8 @@
 Adw.init()
 
 from collins import dialogs, remotefiles  # noqa: E402
+from collins.api import protocol  # noqa: E402
+from collins.api.protocol import RequestRefused  # noqa: E402
 from collins.editor import EditorPane  # noqa: E402
 
 PASSED = 0
@@ -269,6 +272,36 @@ def fake_confirm(parent, heading, body, confirm_label, on_confirm, on_dismiss=No
     check("and its buffer is dirty, so nothing saves over nothing silently", other.buffer.get_modified())
     check("its mtime is forgotten", other.mtime is None)
 
+    # -- a change that waited for a reload is judged even when the reload fails ------
+    # Two external changes racing one reload: the second is queued while the
+    # read is in flight, and the read then fails (the file went away between
+    # the monitor and the read). The queued `gone` is still judged, so the
+    # buffer is told and marked dirty (the review of PR 609).
+    third = os.path.join(root, "third.txt")
+    with open(third, "w") as fh:
+        fh.write("third\n")
+    pane.open_file(third)
+    racing = pane._open[third]
+    if not wait_for(lambda: not racing.loading):
+        print("FAIL  the third read never landed")
+        return 1
+    pane._banner.set_revealed(False)
+    racing.loading = True  # a reload in flight...
+    racing.reloading = True
+    pane._check_external(
+        racing, {"handle": racing.watch_handle, "path": third, "mtime": None, "size": None, "gone": True}
+    )
+    check("a change during a reload waits for it", racing.pending_change is not None and not racing.buffer.get_modified())
+    pane._on_loaded(
+        racing, racing.load_id, "refused", RequestRefused(protocol.ERROR_GONE, "{name} is not there", {"name": "third.txt"})
+    )
+    check("the failed reload is told", pane._banner.get_revealed())
+    check(
+        "and the waiting change is judged after it",
+        racing.pending_change is None and racing.mtime is None and racing.buffer.get_modified(),
+        (racing.pending_change, racing.mtime, racing.buffer.get_modified()),
+    )
+
     # -- closing a tab drops its watch -----------------------------------------------
     handle = other.watch_handle
     pane._close_confirmed.add(pane._pages[second])