fix(saves): classify a 404 as not_found in copy_save_to_slot

copy_save_to_slot landed on main during PR 1's review; its post-preflight
list_saves collapsed every failure onto server_unreachable — the same
conflation this branch removes, which its own new gate now flags.

The call is rom- AND device-scoped, so a definitive 404 is the #1560 family
(dead ROM or dropped device registration): the server answered. Add a sibling
except RommNotFoundError before the catch-all, returning the discriminated
not_found status and persisting the pre-flight-mutated save_state first,
exactly as the server_unreachable branch does — otherwise that work is lost.
The catch-all keeps server_unreachable for genuine transport failures.

Frontend: add the not_found member to CopySaveToSlotStatus and a case in
useCopyToSlot that neither reports the server offline nor claims the game's
saves are gone (the 404 can be the device registration). Tests pin the
backend branch (incl. that the pre-flight timestamp was persisted) and the
copy rule for the new string.

Author: danielcopper

py_modules/services/saves/copies.py

@@ -20,7 +20,7 @@
 from domain.save_layout import SAVE_SYNC_CONTENT_DIR_REASON
 from domain.save_slot import save_in_slot
 from domain.save_status import compute_multi_file_slot
-from lib.errors import RommConflictError
+from lib.errors import RommConflictError, RommNotFoundError
 from services.saves._helpers import local_save_target
 from services.saves._settings import resolve_default_slot
 
@@ -256,7 +256,10 @@ async def copy_save_to_slot(self, rom_id: int, save_id: int, target_slot: str) -
            unconditionally, to protect its dirty local before the copy overwrites
            it — ``conflict_blocked`` / ``preflight_failed`` on a bad pre-flight.
         7. ``list_saves`` with no slot filter (the source may be in any slot);
-           failure is ``server_unreachable``.
+           a transport failure is ``server_unreachable``, a definitive 404 (the
+           server answered that it has no such ROM or device id) is ``not_found``
+           — distinct so the copy surface never reports an answering server
+           offline (#1570).
         8. The copy proper runs in :meth:`_copy_save_to_slot_io`.
 
         A dedup pre-check between the ``list_saves`` and the copy short-circuits
@@ -267,7 +270,7 @@ async def copy_save_to_slot(self, rom_id: int, save_id: int, target_slot: str) -
         Returns a discriminated-status dict (mirrors ``RollbackStatus``):
         ``ok | already_present{existing_id} | not_configured | invalid_slot_name |
         rom_not_installed | version_deleted | unsupported{reason?} |
-        server_unreachable{message} | conflict_blocked{conflicts} |
+        server_unreachable{message} | not_found{message} | conflict_blocked{conflicts} |
         preflight_failed{errors} | target_slot_busy{message} | copy_failed{message}``.
         """
         rom_id = int(rom_id)
@@ -332,6 +335,15 @@ async def copy_save_to_slot(self, rom_id: int, save_id: int, target_slot: str) -
                     None,
                     lambda: self._retry.with_retry(lambda: self._romm_api.list_saves(rom_id, device_id=device_id)),
                 )
+            except RommNotFoundError as e:
+                # The server ANSWERED: it has no such ROM (or no such device id).
+                # ``list_saves`` is rom- AND device-scoped, so this is the #1560
+                # family. Not a connectivity verdict — the copy surface must not
+                # report the server offline (#1570).
+                self._log_debug(f"copy_save_to_slot: server has no such entity: {e}")
+                # Persist whatever the pre-flight mutated before bailing.
+                await self._loop.run_in_executor(None, self._write_save_state, rom_id, save_state)
+                return {"status": "not_found", "message": str(e)}
             except Exception as e:
                 self._log_debug(f"copy_save_to_slot: failed to list saves: {e}")
                 # Persist whatever the pre-flight mutated before bailing.

src/components/saves/useCopyToSlot.test.tsx

@@ -136,6 +136,7 @@ describe("useCopyToSlot", () => {
     { result: { status: "not_configured" }, needle: "Set up save slots" },
     { result: { status: "invalid_slot_name" }, needle: "valid slot name" },
     { result: { status: "server_unreachable", message: "boom" }, needle: "Couldn't reach RomM" },
+    { result: { status: "not_found", message: "HTTP 404" }, needle: "couldn't find this game's save data" },
     { result: { status: "preflight_failed", errors: ["net"] }, needle: "Sync failed before copy" },
     { result: { status: "copy_failed", message: "oops" }, needle: "Couldn't copy the save" },
     { result: { status: "unsupported", reason: "savefiles_in_content_dir" }, needle: "writes saves next to the ROM" },
@@ -151,6 +152,20 @@ describe("useCopyToSlot", () => {
     expect(dataChanged).not.toHaveBeenCalled();
   });
 
+  it("not_found: names what RomM couldn't find, never a reachability or no-saves claim", async () => {
+    // The 404 means the server ANSWERED (#1560 family). Same rule as every
+    // other 404 surface in #1570: no offline blame, and no claim the game's
+    // saves are gone (the 404 can be the device registration).
+    await runCopy({ status: "not_found", message: "HTTP 404: Not Found" });
+
+    const toastCalls = vi.mocked(toaster.toast).mock.calls;
+    const body = String(toastCalls[toastCalls.length - 1]![0].body ?? "");
+    expect(body).not.toMatch(/couldn't reach|check your connection|unreachable|not reachable|offline/i);
+    expect(body).not.toMatch(/no saves|has no save|without saves/i);
+    // A refusal never refreshes the views.
+    expect(dataChanged).not.toHaveBeenCalled();
+  });
+
   it("swallows a rejected copy call and surfaces the generic failure toast", async () => {
     vi.mocked(backend.copySaveToSlot).mockRejectedValue(new Error("network down"));
     const hook = renderHook(() => useCopyToSlot(42, SLOTS));

src/components/saves/useCopyToSlot.ts

@@ -60,6 +60,13 @@ async function handleResult(result: CopySaveToSlotStatus, target: string, romId:
     case "server_unreachable":
       toaster.toast({ title: TITLE, body: "Couldn't reach RomM. Check your connection and try again." });
       return;
+    case "not_found":
+      // The server answered — it has no such ROM or device id (#1560 family).
+      // A retry can't help, so the copy must not send the user to check their
+      // connection, and must not claim the saves are gone: the 404 can be the
+      // device registration rather than the ROM (#1570).
+      toaster.toast({ title: TITLE, body: "RomM couldn't find this game's save data — nothing was copied." });
+      return;
     case "version_deleted":
       toaster.toast({ title: TITLE, body: "This save no longer exists on the server." });
       return;

src/types/saves.ts

@@ -260,6 +260,8 @@ export type CopySaveToSlotStatus =
   | { status: "version_deleted" }
   | { status: "unsupported"; reason?: string }
   | { status: "server_unreachable"; message: string }
+  // See RollbackStatus — the server answered, it just has no such entry.
+  | { status: "not_found"; message: string }
   | { status: "conflict_blocked"; conflicts: SyncConflict[] }
   | { status: "preflight_failed"; errors: string[] }
   | { status: "target_slot_busy"; message: string }

tests/services/saves/test_copies.py

@@ -12,6 +12,7 @@
 import pytest
 
 from domain.save_layout import ContentDir
+from lib.errors import RommNotFoundError
 from tests.services.saves._helpers import (
     _create_save,
     _enable_sync_with_device,
@@ -387,6 +388,46 @@ def fail_second_list(*args, **kwargs):
         assert "unreachable" in result.get("message", "").lower()
         assert "error" not in result
 
+    @pytest.mark.asyncio
+    async def test_definitive_404_on_post_preflight_list_is_not_found(self, tmp_path):
+        """A 404 on the post-preflight ``list_saves`` → not_found, not offline (#1570).
+
+        ``list_saves`` is rom- AND device-scoped, so a definitive 404 is the
+        #1560 family (dead ROM or dropped device registration) — the server
+        answered. It must read as ``not_found`` rather than ``server_unreachable``,
+        and — like the transport branch — it must still persist whatever the
+        pre-flight mutated before bailing, or that work is lost.
+        """
+        svc, fake = make_service(tmp_path)
+        _create_save(tmp_path)
+        local_hash = _file_md5(str(tmp_path / "saves" / "gba" / "pokemon.srm"))
+        _setup_configured(svc, tmp_path, active_slot="autosave", tracked_id=100, last_sync_hash=local_hash)
+        fake.saves[100] = _tracked_save(100, slot="autosave")
+        # Seeded state has no sync-check timestamp; the pre-flight sets one.
+        assert _require_save_state(svc, 42).last_sync_check_at is None
+
+        original_list = fake.list_saves
+        call_count = {"n": 0}
+
+        def fail_second_list(*args, **kwargs):
+            call_count["n"] += 1
+            if call_count["n"] >= 2:
+                raise RommNotFoundError("HTTP 404: Not Found")
+            return original_list(*args, **kwargs)
+
+        fake.list_saves = fail_second_list  # type: ignore[method-assign]
+        try:
+            result = await svc.copy_save_to_slot(42, 100, TARGET)
+        finally:
+            fake.list_saves = original_list  # type: ignore[method-assign]
+
+        assert result["status"] == "not_found"
+        assert result["status"] != "server_unreachable"
+        assert "message" in result
+        # The pre-flight mutation was persisted before bailing (mark_sync_evaluated
+        # ran, so the seeded-None timestamp is now set on disk).
+        assert _require_save_state(svc, 42).last_sync_check_at is not None
+
     @pytest.mark.asyncio
     async def test_target_slot_busy_on_409(self, tmp_path):
         """The target slot has a newer foreign save this device hasn't synced → 409 → target_slot_busy."""