diff --git a/install.ps1 b/install.ps1
index 5ea6fd3b7..0d73153a0 100644
--- a/install.ps1
+++ b/install.ps1
@@ -11,7 +11,7 @@
 
     $ErrorActionPreference = "Stop"
     $defaultInstallUrl = "https://raw.githubusercontent.com/Abdess/retrobios/main/install.py"
-    $defaultInstallSha256 = "b3363820bb97bec559287f72d9712281e22307387fa752b663f6f7af023a0e33"
+    $defaultInstallSha256 = "50074085810dde029db4cbbc7b520e34d4e70d58fe524570ac2821501772e7d8"
     $maximumInstallerBytes = 2MB
     $installerExit = 0
     $installer = if ($PSScriptRoot) { Join-Path $PSScriptRoot "install.py" } else { $null }
diff --git a/install.py b/install.py
index 7acc9cbb4..74d94fe6e 100644
--- a/install.py
+++ b/install.py
@@ -546,6 +546,12 @@ EVENT_KEYS: dict[str, tuple[str, ...]] = {
     # up to MAX_SCANNED_FILES, truncated past them), and the folders below
     # it on another drive, not entered.
     "scanned": ("folder", "files", "truncated", "other_drives"),
+    # Before the file events of a check: the systems the run's list lets
+    # one choose among, --system aside, in id order (other for the files
+    # no system names). What Choose systems lists, and what the plan counts
+    # a --system out of: it said 12 where Choose systems listed 11. A kind
+    # of its own, since schema 1 never adds a key to check.
+    "choices": ("platform", "systems"),
     # state: present (hash verified), wrong_hash or missing.
     "file": ("platform", "dest", "systems", "size", "state"),
     "system": ("platform", "system", "name", "files", "present", "missing",
@@ -1609,9 +1615,10 @@ def found_label(plat: str, path: Path) -> str:
     moved = "".join(f", {folder}/ at {place}"
                     for folder, place in sorted(_MOVED_FOLDERS.get(path, {}).items())
                     if folder in ("bios", "roms"))
+    folder = shown_path(setup_bios_folder(plat, path))
     if not name or name == shown:
-        return f"{shown} at {shown_path(path)}{moved}"
-    return f"{name} at {shown_path(path)} ({shown} files){moved}"
+        return f"{shown} at {folder}{moved}"
+    return f"{name} at {folder} ({shown} files){moved}"
 
 
 def _android_storage_root() -> Path:
@@ -2111,7 +2118,7 @@ def _rule_path(template: str) -> Path:
 # The registry's executable rules: (os, platform, glob under $HOME or
 # %USERPROFILE%, folder beside the executable that holds the BIOS). BizHawk is
 # a portable archive reading <EmuHawk folder>/Firmware (PathExtensions.cs
-# DataDirectoryPath), wherever it was extracted; ~/.config/BizHawk/Firmware,
+# DataDirectoryPath), wherever it was extracted. ~/.config/BizHawk/Firmware,
 # the old guess, is a folder no build reads.
 _EXE_RULES: tuple[tuple[str, str, tuple[str, ...], str], ...] = (
     ("linux", "bizhawk", ("$HOME/BizHawk*/EmuHawkMono.sh", "$HOME/*/BizHawk*/EmuHawkMono.sh"),
@@ -2245,7 +2252,7 @@ def detect_platforms(os_type: str) -> list[tuple[str, Path]]:
                 # default is a guess, and the user is told so.
                 print(
                     f"Warning: could not read paths.rd_home_path from "
-                    f"{retrodeck_json}; assuming {home / 'retrodeck'}",
+                    f"{retrodeck_json}: assuming {home / 'retrodeck'}",
                     file=sys.stderr,
                 )
             rd_root = Path(rd_home) if rd_home else home / "retrodeck"
@@ -3794,7 +3801,8 @@ def canonical_region(raw: str) -> str:
         hint = f" Did you mean: {', '.join(close)}?" if close else ""
         raise ValueError(
             f"unknown region: {raw.strip()}.{hint} "
-            f"Short forms: {', '.join(REGION_ALIASES)}; regions: {', '.join(sorted(REGIONS))}"
+            f"Short forms: {', '.join(REGION_ALIASES)}. Regions: "
+            f"{', '.join(sorted(REGIONS))}"
         )
     return key
 
@@ -4241,12 +4249,14 @@ def save_directory_for(
 
 def place_save_entries(
     files: list[dict], bios_path: Path, manifest: dict, override: Path | None,
-    display: str,
+    display: str, say: bool = True,
 ) -> tuple[list[dict], list[dict]]:
     """Find the save directory for the entries read below it.
 
     Returns the files to install and, when the save directory is unknown,
-    the entries left out as omissions, said once with the reason.
+    the entries left out as omissions, said once with the reason. Without
+    say nothing is printed or sent: the run says it (say_saves) once a
+    choice of systems has kept the files it counts.
     """
     saved = [entry for entry in files if entry.get("root") == "save"]
     if not saved:
@@ -4259,18 +4269,21 @@ def place_save_entries(
             where += f"{os.sep}<system>"
         if place.by_core:
             where += f"{os.sep}<core>"
-        print(f"  {_plural(len(saved), 'file')} read from {display}'s save directory "
-              f"{'goes' if len(saved) == 1 else 'go'} to {where}")
-        EVENTS.emit("saves", platform=str(manifest.get("platform", "")),
-                    files=len(saved), folder=where)
+        _SAVE_WHERE[bios_path] = where
+        if say:
+            print(f"  {saves_line(display, len(saved), where)}")
+            EVENTS.emit("saves", platform=str(manifest.get("platform", "")),
+                        files=len(saved), folder=where)
         return files, []
-    print(f"  {_plural(len(saved), 'file')} read from {display}'s save directory "
-          f"left out: {place}.")
+    _SAVE_WHY[bios_path] = place
+    if say:
+        print(f"  {_plural(len(saved), 'file')} read from {display}'s save directory "
+              f"left out: {place}.")
     kept = [entry for entry in files if entry.get("root") != "save"]
     unplaced = [
         {"dest": entry["dest"], "name": PurePosixPath(entry["dest"]).name,
-         "system": "", "required": False, "reason": "no_save_directory",
-         "frontend": display,
+         "system": "", "systems": list(entry.get("systems") or []), "required": False,
+         "reason": "no_save_directory", "frontend": display,
          "cores": entry.get("cores"), "root": "save",
          **({"core_folder": entry["core_folder"]} if entry.get("core_folder") else {})}
         for entry in saved
@@ -4278,6 +4291,30 @@ def place_save_entries(
     return kept, unplaced
 
 
+# Per BIOS folder, where its save files go in words, or why that is not
+# known: read by the lines that count them once a choice is made.
+_SAVE_WHERE: dict[Path, str] = {}
+_SAVE_WHY: dict[Path, str] = {}
+
+
+def say_saves(plat: str, files: list[dict], omitted: list[dict], bios_path: Path,
+              display: str, printed: bool) -> None:
+    """The save directory lines and the saves event, over the files the
+    run installs once narrowed: --system sony-playstation said 106 files
+    went to the save directory, none of them a PlayStation file. printed
+    is the menu having said them already."""
+    saved = sum(1 for entry in files if entry.get("root") == "save")
+    where = _SAVE_WHERE.get(bios_path)
+    if saved and where is not None:
+        if not printed:
+            print(f"  {saves_line(display, saved, where)}")
+        EVENTS.emit("saves", platform=plat, files=saved, folder=where)
+    if printed:
+        return
+    for line in save_lines([], omitted, bios_path, display):
+        print(f"  {line}")
+
+
 def _classify_local(entry: dict, dest: Path) -> str:
     """Return 'up_to_date' or 'mismatched' for a file already on disk."""
     expected = {
@@ -5229,6 +5266,10 @@ _VALUED_OPTIONS = (
 )
 
 
+# The options a choice at the questions sets, which replace the command's.
+_CHOICE_OPTIONS = ("--system", "--core", "--region")
+
+
 class Invocation:
     """How this run was started, so that a hint gives the command back whole.
 
@@ -5299,7 +5340,14 @@ class Invocation:
             words += ["--dest", self.word(str(dest.absolute()))]
         elif dest:
             words += ["--dest", dest]
-        for flag, value in [*self.options, *self.chosen.get(plat, [])]:
+        options = self.options
+        if plat in self.chosen:
+            # A choice made at the questions replaces the narrowing the
+            # command line gave: both were printed, and --system named
+            # the systems of the first run and of the second.
+            replaced = {*_CHOICE_OPTIONS, *(flag for flag, _value in self.chosen[plat])}
+            options = [option for option in options if option[0] not in replaced]
+        for flag, value in [*options, *self.chosen.get(plat, [])]:
             if flag in without:
                 continue
             words += [flag] if value is None else [flag, self.word(value)]
@@ -5323,8 +5371,38 @@ def _on_read_only_mount(path: Path) -> bool:
         return False
 
 
-def _write_advice(path: Path, assumed: bool, plat: str = "") -> str:
-    """What to do about a folder this run could not write.
+def read_only_words(path: Path) -> str:
+    """The remedy for a folder on a read-only file system, in one sentence
+    that the plan, the result and line mode all say: root cannot write it
+    either, and the plan offered sudo for it."""
+    place = path.absolute()
+    card = any(mount == place or mount in place.parents for mount in _mounted_cards())
+    return (f"The {'card' if card else 'drive'} is read-only: unlock it or mount it "
+            "read-write, then run again.")
+
+
+def write_remedy(path: Path, plat: str, hint: Invocation, commands: bool = True) -> list[str]:
+    """What the screens say a user can do about a folder they cannot write:
+    the read-only remedy, or the same choice run as an administrator, the
+    command carrying every option of the run (hint). The sudo line dropped
+    --from-pack and --manifest, and stopped at the file list with
+    --offline. commands is False where no command can be typed (a pad)."""
+    if _on_read_only_mount(path):
+        return [read_only_words(path)]
+    if not commands:
+        return []
+    if hint.os_type == "windows":
+        return ["Or run the installer as an administrator."]
+    # sudo changes the home folder, and with it what is detected: the folder
+    # is named so root writes here.
+    return ["Or run it as root, this folder named: "
+            + hint.command(plat, path, elevated=True)]
+
+
+def _write_advice(path: Path, assumed: bool, plat: str = "",
+                  hint: Invocation | None = None) -> str:
+    """What to do about a folder this run could not write, the command
+    built by hint (the run's own invocation by default).
 
     sudo fixes a root-owned BIOS folder on the console itself. On another
     machine it would create that folder on the wrong disk: a platform named
@@ -5333,27 +5411,27 @@ def _write_advice(path: Path, assumed: bool, plat: str = "") -> str:
     termux-setup-storage has run. A read-only mount refuses root as well,
     so sudo is never offered for it.
     """
+    hint = hint or _INVOCATION
     if _on_read_only_mount(path):
-        again = f"\n    {_INVOCATION.command(plat, path)}" if plat else ""
-        return (f"  {path} is on a file system mounted read-only, which no user can "
-                "write, sudo included. Mount it read-write again (a card or drive "
+        again = f"\n    {hint.command(plat, path)}" if plat else ""
+        return (f"  {read_only_words(path)} {path} is on a file system mounted "
+                "read-only, which no user can write, sudo included (a card or drive "
                 "the system switched to read-only after an error needs a check "
-                "first: fsck, or chkdsk on Windows), then run the same command "
-                f"again.{again}")
+                f"first: fsck, or chkdsk on Windows).{again}")
     if assumed:
         return (f"  {path} is where the platform keeps its BIOS on its own system, "
                 "and it was not found here. If this machine prepares its card or "
                 "share, run it again with --dest pointing at that folder:\n"
-                f"    {_INVOCATION.command(plat, '<that folder>')}")
-    if plat and _INVOCATION.os_type == "windows":
+                f"    {hint.command(plat, '<that folder>')}")
+    if plat and hint.os_type == "windows":
         return ("  This user cannot write there. Run it again from a PowerShell window "
                 "opened as administrator:\n"
-                f"    {_INVOCATION.command(plat, path)}\n"
+                f"    {hint.command(plat, path)}\n"
                 "  Or choose another folder with --dest.")
-    if plat and _INVOCATION.os_type == "android":
+    if plat and hint.os_type == "android":
         return ("  This user cannot write there. Run termux-setup-storage once to give "
                 "Termux the shared storage, then run it again:\n"
-                f"    {_INVOCATION.command(plat, path)}\n"
+                f"    {hint.command(plat, path)}\n"
                 "  Or choose another folder with --dest.")
     if plat:
         # sudo resets HOME to root's on Debian, Ubuntu, Arch and SteamOS:
@@ -5361,9 +5439,9 @@ def _write_advice(path: Path, assumed: bool, plat: str = "") -> str:
         # under /root and reported success.
         return ("  This user cannot write there. Run it again with sudo, naming the "
                 "folder so root does not look in its own home:\n"
-                f"    {_INVOCATION.command(plat, path, elevated=True)}\n"
+                f"    {hint.command(plat, path, elevated=True)}\n"
                 "  Or choose another folder with --dest.")
-    if _INVOCATION.os_type == "windows":
+    if hint.os_type == "windows":
         return ("  This user cannot write there: run the same command from a PowerShell "
                 "window opened as administrator, or choose another folder with --dest.")
     return ("  This user cannot write there: run the same command with sudo, "
@@ -5597,7 +5675,7 @@ def _check_fetch_line(fetch: int, beside: str) -> str:
             return "  Run the same command without --check to copy them into place."
         return (f"  {_plural(fetch, 'file')} {'needs' if fetch == 1 else 'need'} the "
                 f"internet, which --offline does not use. {_offline_remedy()}")
-    return ("  Run the same command without --check to fetch them; a file with a wrong "
+    return ("  Run the same command without --check to fetch them. A file with a wrong "
             f"hash is replaced, and the one in place kept in {BACKUP_DIR} beside {beside}.")
 
 
@@ -6408,7 +6486,8 @@ def _line_setups(setups: list | None = None, mounted: set | None = None,
         return ", ".join(names[:3]) + more
 
     choices = []
-    for row in setup_list(setups or [], mounted or set(), "", os_type or detect_os()):
+    for row in setup_list(setups or [], mounted or set(), "", os_type or detect_os(),
+                          LOCAL.serves()):
         name = _row_name(row)
         if row.action == "cardsystem":
             listed = list(_SETUP_DEVICES.get(name, ()))
@@ -6422,13 +6501,24 @@ def _line_setups(setups: list | None = None, mounted: set | None = None,
 
 
 def _line_matches(choices: list[tuple[str, str]], typed: str, setups: list | None = None,
-                  mounted: set | None = None, os_type: str = "") -> list[int]:
-    """The indexes of the choices a typed device or system name finds, with
-    the screen filter's own matcher: "miyoo" was refused, the line menu
-    knowing only setup names."""
-    found = {_row_name(row) for row in setup_list(
-        setups or [], mounted or set(), typed, os_type or detect_os())}
-    return [index for index, (name, _label) in enumerate(choices) if name in found]
+                  mounted: set | None = None, os_type: str = "") -> list[tuple[int, str]]:
+    """(index, label) of the choices a typed device or system name finds,
+    with the screen filter's own matcher: "miyoo" was refused, the line
+    menu knowing only setup names. The label names what was matched first,
+    as the screen's row does on its right: "miyoo mini" listed MinUI with
+    RG28XX, RG34XX and RG34XX SP."""
+    found = {_row_name(row): row for row in setup_list(
+        setups or [], mounted or set(), typed, os_type or detect_os(), LOCAL.serves())}
+    matched = []
+    for index, (name, label) in enumerate(choices):
+        row = found.get(name)
+        if row is None:
+            continue
+        named = row.right.split(", ") if row.right else []
+        more = f", +{len(named) - 3}" if len(named) > 3 else ""
+        matched.append((index, f"{row.label} ({', '.join(named[:3])}{more})" if named
+                        else label))
+    return matched
 
 
 def _choose_platform(title: str, default: str = "", setups: list | None = None,
@@ -6443,6 +6533,10 @@ def _choose_platform(title: str, default: str = "", setups: list | None = None,
     """
     os_type = detect_os()
     choices = _line_setups(setups, mounted, os_type)
+    if default and default not in {name for name, _label in choices}:
+        # A file list for another setup: Enter takes the first row, where
+        # the screen's focus falls (_platform_focus).
+        default = choices[0][0] if choices else ""
     print(f"\n{title}")
     for i, (_name, label) in enumerate(choices, 1):
         print(f"  {i}) {label}")
@@ -6471,12 +6565,12 @@ def _choose_platform(title: str, default: str = "", setups: list | None = None,
                 return name
         found = _line_matches(choices, choice, setups, mounted, os_type) if key else []
         if len(found) == 1:
-            print(f"  {choices[found[0]][1]}")
-            return choices[found[0]][0]
+            print(f"  {found[0][1]}")
+            return choices[found[0][0]][0]
         if found:
             print(f"  {len(found)} setups run on '{choice.strip()}':")
-            for index in found:
-                print(f"  {index + 1}) {choices[index][1]}")
+            for index, label in found:
+                print(f"  {index + 1}) {label}")
             print("  Type the number of yours.")
             default = ""
             continue
@@ -6493,12 +6587,14 @@ def _prompt_manual_platform(os_type: str, ask: bool = True, check_typed: bool =
     A system that runs from its card gets the card's root asked for, as
     --platform rocknix does: /storage/roms/bios was offered on a PC.
     """
-    named = _choose_platform(title or "No supported platform found here. Choose the one to "
-                             "install for:", "retroarch", setups, mounted)
+    named = _choose_platform(title or "Nothing was found here. Which setup?", "retroarch",
+                             setups, mounted)
     plat = normalize_platform(named, say=False)
-    if card_bound(named, plat) is not None:
+    folder, kind = setup_folder(os_type, setups or [], mounted or set(), plat, named)
+    if card_bound(named, plat) is not None and kind != "found":
         return [(plat, card_install_dest(named, plat, True, ask))]
-    return [(plat, ask_platform_folder(os_type, plat, ask, check_typed))]
+    return [(plat, ask_platform_folder(os_type, plat, ask, check_typed,
+                                       folder if kind == "found" else None))]
 
 
 # Systems a computer reaches over the network or on their SHARE drive: their
@@ -6510,6 +6606,21 @@ _SHARE_FOLDERS = {
 }
 
 
+def drive_example(os_type: str, label: str, below: str = "", plat: str = "") -> str:
+    """Where a drive mounted here is, as this system writes it, for the
+    example a refusal gives: macOS mounts it at /Volumes/<label>, WSL at
+    /mnt/<letter>, Windows names a letter. A Linux path with $USER was
+    given on every system, which PowerShell does not expand. plat, a
+    system reached over the network, names its network share on Windows."""
+    if os_type == "windows":
+        if plat in _SHARE_FOLDERS:
+            return _SHARE_FOLDERS[plat]
+        return "E:\\" + below.replace("/", "\\")
+    root = {"darwin": f"/Volumes/{label}", "wsl": "/mnt/e",
+            "android": f"/storage/{label}"}.get(os_type, f"/media/$USER/{label}")
+    return f"{root}/{below}" if below else root
+
+
 def share_words(plat: str) -> str:
     """Where a computer sees the BIOS folder of a system it does not run."""
     return (f"From a computer, {display_name(plat)}'s BIOS folder is bios on its SHARE "
@@ -6533,20 +6644,23 @@ def share_targets(plat: str) -> list[tuple[str, Path]]:
 
 
 def ask_platform_folder(os_type: str, plat: str, ask: bool = True,
-                        check: bool = True) -> Path:
-    """The BIOS folder for a platform found nowhere here, asked as the
-    screen's Which folder? asks it: its usual folder under Enter, the drives
-    mounted here numbered. The usual folder was taken without a word, a
-    mounted card beside it never offered. A system this computer only
-    reaches over the network gets no default: /userdata/bios exists on the
-    Batocera machine alone, and its drives are numbered by their bios
-    folder, the screen's rows (share_targets)."""
+                        check: bool = True, found: Path | None = None) -> Path:
+    """The BIOS folder for a setup chosen from the list, asked as the
+    screen's Which folder? asks it: the folder detection found here (found)
+    or its usual folder under Enter, the drives mounted here numbered. The
+    usual folder was taken without a word, a mounted card beside it never
+    offered. A system this computer only reaches over the network gets no
+    default: /userdata/bios exists on the Batocera machine alone, and its
+    drives are numbered by their bios folder, the screen's rows
+    (share_targets)."""
     name = display_name(plat)
-    shared = plat in _SHARE_FOLDERS
-    default = None if shared else _default_dest(os_type, plat)
+    shared = plat in _SHARE_FOLDERS and found is None
+    default = found if found is not None else None if shared else _default_dest(os_type, plat)
     print(f"\nWhich folder do {name}'s BIOS files go to?")
     if shared:
         print(f"  {share_words(plat)}")
+    elif found is not None:
+        print(f"  {name} reads its BIOS files from: {shown_path(found)}.")
     elif default is not None:
         state = "" if _exists(default) else " (it does not exist yet and will be created)"
         print(f"  {name}'s default BIOS folder: {shown_path(default)}{state}.")
@@ -6564,7 +6678,8 @@ def ask_platform_folder(os_type: str, plat: str, ask: bool = True,
     why = ("" if default is not None or shared
            else " (no default, a folder above could not be opened)"
            if _default_set_aside(os_type, plat) else " (no default on this system)")
-    prompt = (f"BIOS folder{numbers}, q to quit (Enter for the default above): " if default
+    enter = (f"the folder {name} reads" if found is not None else "the default above")
+    prompt = (f"BIOS folder{numbers}, q to quit (Enter for {enter}): " if default
               else f"BIOS folder{numbers}, q to quit{why}: ")
     usage = f"  Type a folder{', a number' if targets else ''}, or q to quit."
     while True:
@@ -6581,6 +6696,9 @@ def ask_platform_folder(os_type: str, plat: str, ask: bool = True,
             # "q" alone said nothing of the folder it was in.
             folder = _typed_folder(raw).absolute()
         choice = card_choice(plat, plat, folder)
+        if choice.refused:
+            print(f"  {choice.refused}. Type {name}'s own folder, or q to quit.")
+            continue
         for line in (choice.found, choice.note):
             if line:
                 print(f"  {line}")
@@ -6716,8 +6834,10 @@ def _prompt_platform_choice(
     print(f"\n{title}")
     named = [(labels or {}).get((name, path)) or _setup_label(name, path)
              for name, path in platforms]
-    for i, ((_name, path), label) in enumerate(zip(platforms, named), 1):
-        print(f"  {i}) {label} ({shown_path(path)})")
+    for i, ((plat, path), label) in enumerate(zip(platforms, named), 1):
+        # The label and its folder, as the screen shows them: "Onion SD card
+        # (ONION) (/media/me/ONION/BIOS)" put two pairs of brackets in a row.
+        print(f"  {i}) {label}: {shown_path(setup_bios_folder(plat, path))}")
     if other is not None:
         print("  o) another setup or folder")
     print("  q) quit")
@@ -6789,19 +6909,20 @@ def _system_sized(files: list[dict]) -> str:
 
 def _pick(
     title: str, rows: list[tuple[str, list[dict]]], ordered: bool = False,
-    sizer: Callable[[list[dict]], str] = _sized,
+    sizer: Callable[[list[dict]], str] = _sized, labels: dict | None = None,
 ) -> list[str]:
     """Numbered list of names. An empty answer keeps every one.
 
-    sizer says what each name holds.
+    sizer says what each name holds, labels how each one is shown.
     """
     if not rows:
         return []
     print(f"\n{title}")
     width = len(str(len(rows)))
-    name_width = min(max(len(name) for name, _files in rows), 32)
+    shown = {name: (labels or {}).get(name, name) for name, _files in rows}
+    name_width = min(max(len(label) for label in shown.values()), 40)
     for index, (name, files) in enumerate(rows, 1):
-        print(f"  {index:>{width}}) {name:<{name_width}}  {sizer(files)}")
+        print(f"  {index:>{width}}) {shown[name]:<{name_width}}  {sizer(files)}")
     hint = "order of preference, e.g. 2,1" if ordered else "e.g. 1,3-5"
     while True:
         text = _ask(f"Numbers ({hint}), Enter for all, q to quit: ")
@@ -6818,6 +6939,136 @@ def _pick(
             return [rows[number - 1][0] for number in chosen]
 
 
+def listed_systems(files: list[dict]) -> list[str]:
+    """The systems Choose systems lists for these files, in id order: each
+    one a file belongs to, and the other systems for a file that names
+    none. The plan, Choose systems and line mode count these: the plan
+    said 12 systems where Choose systems listed 11, a system whose only
+    file was left out counted."""
+    systems = sorted({system for entry in files for system in entry_systems(entry)})
+    if any(not entry_systems(entry) for entry in files):
+        systems.append(OTHER_SYSTEMS)
+    return systems
+
+
+def choosable_systems(files: list[dict], omitted: list[dict],
+                      cores: list[str] = (), regions: list[str] = ()) -> list[str]:
+    """The systems a run with these cores and regions lets one choose
+    among, --system aside: what the check reports (the choices event)."""
+    if cores or regions:
+        files = narrow(files, omitted, [], list(cores), list(regions))[0]
+    return listed_systems(files)
+
+
+def system_title(system: str, manifest: dict | None) -> str:
+    """A system as the screen's Choose systems names it (_tui_system_label)."""
+    names = ((manifest or {}).get("system_names") or {}).get(system)
+    titles = (manifest or {}).get("system_titles")
+    return _tui_system_label({"system": system, "name": ", ".join(names or [system])},
+                             titles if isinstance(titles, dict) else {})
+
+
+def systems_in_order(systems: list[str], files: list[dict], manifest: dict | None,
+                     bios_path: Path | None) -> list[str]:
+    """Systems in the screen's order (_sorted_systems): those with a file
+    to install first, each group by the title a person reads. Line mode
+    listed them by id, nintendo-3ds before nintendo-ds where the screen
+    put it after Nintendo Game Boy Advance. Before the check, a file is
+    taken as in place when it exists."""
+    def in_place(system: str) -> bool:
+        if bios_path is None:
+            return False
+        held = [entry for entry in files if _chosen(entry, {system})]
+        for entry in held:
+            try:
+                where = _entry_path(bios_path, entry)
+            except ValueError:
+                return False
+            if not _exists(where):
+                return False
+        return bool(held)
+
+    return sorted(systems, key=lambda system: (
+        in_place(system), system_title(system, manifest).casefold()))
+
+
+def _space_short(bios_path: Path, files: list[dict]) -> tuple[int, int] | None:
+    """(bytes needed, bytes free) when the files absent from the folder do
+    not fit on its drive, None when they fit or it cannot be told. The
+    screen's plan warns of this before Install, line mode only after Enter."""
+    probe = _nearest_folder(bios_path)
+    try:
+        free = shutil.disk_usage(probe).free
+    except OSError:
+        return None
+    needed = 0
+    for entry in files:
+        try:
+            where = _entry_path(bios_path, entry)
+        except ValueError:
+            continue
+        if not _exists(where):
+            needed += entry.get("size", 0)
+    return (needed, free) if needed > free else None
+
+
+def folder_warnings(plat: str, bios_path: Path, files: list[dict], hint: Invocation,
+                    commands: bool = True, card: bool = False) -> list[str]:
+    """What the plan says of a folder the files cannot go to, before the
+    question that installs them: the folder refused, or too small. card is
+    a setup that runs from that card, whose own folder is the one it reads."""
+    lines = []
+    if not _folder_writable(bios_path):
+        lines.append("You cannot write to this folder: choose another one.")
+        lines += write_remedy(bios_path, plat, hint, commands)
+    short = _space_short(bios_path, files)
+    if short is not None:
+        lines.append(space_words(short[0], short[1], card))
+    return lines
+
+
+def space_words(needed: int, free: int, card: bool) -> str:
+    """Not enough room, and what to do: on a card setup's own card, room is
+    made on the card, another folder being one its system does not read."""
+    if card:
+        return (f"Not enough free space: {format_size(needed)} needed, "
+                f"{format_size(free)} free. Free some space on the card first.")
+    return (f"Not enough free space: {format_size(needed)} needed. Free some, or "
+            "choose another folder.")
+
+
+def saves_line(display: str, count: int, where: str) -> str:
+    """Where the files read from the frontend's save directory go."""
+    return (f"{_plural(count, 'file')} read from {display}'s save directory "
+            f"{'goes' if count == 1 else 'go'} to {where}")
+
+
+def unplaced_line(display: str, count: int, remedy: str) -> str:
+    """The files read from an unknown save directory, left out."""
+    return (f"{_plural(count, 'file')} read from {display}'s save directory left out: "
+            f"its place is not known. {remedy}")
+
+
+def save_lines(files: list[dict], omitted: list[dict], bios_path: Path | None,
+               display: str) -> list[str]:
+    """The save directory lines of a plan, over the files a choice keeps:
+    106 were said to go there for a --system sony-playstation that kept
+    none of them, and ROCKNIX's 44 left out were said only at the end, as
+    "the frontend's"."""
+    lines = []
+    count = sum(1 for entry in files if entry.get("root") == "save")
+    where = _SAVE_WHERE.get(bios_path) if bios_path is not None else None
+    if count and where is not None:
+        lines.append(saves_line(display, count, where))
+    left = sum(1 for entry in omitted if entry.get("reason") == "no_save_directory")
+    if left:
+        why = _SAVE_WHY.get(bios_path) if bios_path is not None else None
+        lines.append(f"{_plural(left, 'file')} read from {display}'s save directory left "
+                     f"out: {why}." if why else
+                     unplaced_line(display, left, "Name it with --save-dir."))
+    return lines
+
+
 INSTALLED_ONLY = "installed"
 
 
@@ -6827,6 +7078,8 @@ def _prompt_custom_selection(
     name: str = "", dry_run: bool = False, data_trees: list[dict] | None = None,
     bios_path: Path | None = None, choosable: bool = True,
     given: tuple[list[str], list[str], list[str]] | None = None,
+    manifest: dict | None = None, narrowed: bool = False,
+    command: Callable[[object], str] | None = None,
 ) -> tuple[list[str], list[str], list[str]] | str | None:
     """Offer to narrow the install by system, core and region.
 
@@ -6838,26 +7091,22 @@ def _prompt_custom_selection(
     installed at once into a folder named only after Done. given is what
     --system, --core and --region named: Enter keeps it, c chooses anew from
     every system. The menu was skipped, and the folder never named.
+
+    A choice made here is counted again before anything is written, as the
+    screen's Confirm counts it: the menu comes back narrowed, with the
+    command that makes the same choice (command, given the choice), and
+    Enter installs. c installed as soon as the cores were answered, "Enter
+    for all" read as a choice. narrowed says the list was narrowed before
+    the menu (--target, --no-game-data): the data trees kept are then those
+    of the systems kept, as the plan and --dry-run count them.
     """
     trees = data_trees or []
-    shown = files
-    if given is not None:
-        shown = narrow(files, omitted, *given)[0]
-    data = sum(len(entry.get("files") or {}) for entry in trees)
-    data_size = sum(meta.get("size", 0) for entry in trees
-                    for meta in (entry.get("files") or {}).values())
-    named = "" if given is None else ", " + ", ".join(filter(None, [
-        f"for {len(given[0])} of {len(available_choices(files, omitted)['systems'])} systems "
-        "(--system)" if given[0] else "",
-        "--core" if given[1] else "", "--region" if given[2] else ""]))
-    print(f"\n{name or display_name(plat)}: {_sized(shown)}"
-          + (f", and {_plural(data, 'data file')} ({format_size(data_size)})" if data else "")
-          + named + ".")
-    if bios_path is not None:
-        # Named before anything is written: line mode said where only after
-        # Done, where the screen names it on every plan.
-        print(f"  BIOS folder: {shown_path(shown_bios_folder(bios_path, files))}")
+    current = given
     while True:
+        _print_menu_head(plat, files, omitted, installed, name, trees, bios_path, current,
+                         given, manifest, narrowed)
+        if current is not given and command is not None:
+            print(f"  Same choice without questions: {command(current)}")
         offline = _offline_only()
         if offline:
             # Said before the menu: "install everything" was offered, then
@@ -6868,7 +7117,7 @@ def _prompt_custom_selection(
         # A dry run installs nothing: "install everything" was asked before it.
         # Offline with nothing to copy from, nothing can be installed but
         # what is in place already.
-        whole = "everything" if given is None else "these"
+        whole = "everything" if current is None else "these"
         if dry_run:
             print(f"  Enter) list {whole}, nothing is written")
         elif offline and LOCAL.folders:
@@ -6878,51 +7127,112 @@ def _prompt_custom_selection(
             print("  Enter) check the BIOS folder, nothing can be downloaded")
         else:
             print(f"  Enter) install {whole}")
-        if installed is not None:
+        if installed is not None and current != INSTALLED_ONLY:
             print(f"  i) only what the installed cores read: {_sized(installed[0])}")
         if choosable:
-            print("  c) choose systems, cores and regions")
+            print("  c) choose systems, cores and regions"
+                  + (" again" if current is not given else ""))
         # The screen's "Copy the BIOS files from your old card or a folder".
         copying = not dry_run
         if copying:
             print("  f) copy from a folder or an old card")
         print("  q) quit")
         keys = ["", "q", *(["c"] if choosable else []),
-                *(["i"] if installed is not None else []),
+                *(["i"] if installed is not None and current != INSTALLED_ONLY else []),
                 *(["f"] if copying else [])]
         answer = _ask("> ").lower()
         while answer not in keys:
             print(f"  Type {', '.join(['Enter', *keys[2:]])} or q.")
             answer = _ask("> ").lower()
         if answer == "":
-            return given
+            return current
         if answer == "q":
             _quit()
         if answer == "i":
-            return INSTALLED_ONLY
-        if answer == "c":
-            break
-        _ask_from_folder(files, bios_path)
+            current = INSTALLED_ONLY
+        elif answer == "c":
+            current = _choose_narrowing(files, omitted, manifest, bios_path)
+        else:
+            _ask_from_folder(files, bios_path)
 
-    choices = available_choices(files, omitted)
-    if OTHER_SYSTEMS in choices["systems"]:
-        print(f"\n'{OTHER_SYSTEMS}' holds what cores load for systems this platform")
+
+def _print_menu_head(
+    plat: str, files: list[dict], omitted: list[dict],
+    installed: tuple[list[dict], list[dict]] | None, name: str, trees: list[dict],
+    bios_path: Path | None, current: object, given: object, manifest: dict | None,
+    narrowed: bool,
+) -> None:
+    """The plan above the line menu: what the choice holds, its folder, what
+    stands in its way and where the save files go, as the screen's plan."""
+    shown, kept_omitted = files, omitted
+    if current == INSTALLED_ONLY and installed is not None:
+        shown, kept_omitted = installed
+    elif isinstance(current, tuple):
+        shown, kept_omitted = narrow(files, omitted, *current)
+    # The trees of the systems kept: 2636 data files of blueMSX, Dolphin
+    # and PPSSPP were counted for every --system tried.
+    kept_trees = select_data_directories({"data_directories": trees}, shown,
+                                         narrowed or current is not None)
+    data = sum(len(entry.get("files") or {}) for entry in kept_trees)
+    data_size = sum(meta.get("size", 0) for entry in kept_trees
+                    for meta in (entry.get("files") or {}).values())
+    named = ""
+    if current == INSTALLED_ONLY:
+        named = ", only what the installed cores read"
+    elif isinstance(current, tuple):
+        systems, cores, regions = current
+        flag = current is given
+        total = len(choosable_systems(files, omitted, cores, regions))
+        named = ", " + ", ".join(filter(None, [
+            f"for {len(systems)} of {total} systems" + (" (--system)" if flag else "")
+            if systems else "",
+            ("--core" if flag else f"{_plural(len(cores), 'core')} chosen") if cores else "",
+            ("--region" if flag else "regions ranked") if regions else ""]))
+        named = "" if named == ", " else named
+    if current is not given:
+        print("\n  Counted again for your choices. Nothing is written before Enter.")
+    print(f"\n{name or display_name(plat)}: {_sized(shown)}"
+          + (f", and {_plural(data, 'data file')} ({format_size(data_size)})" if data else "")
+          + named + ".")
+    if bios_path is None:
+        return
+    # Named before anything is written: line mode said where only after
+    # Done, where the screen names it on every plan.
+    print(f"  BIOS folder: {shown_path(shown_bios_folder(bios_path, files))}")
+    for line in folder_warnings(plat, bios_path, shown, _INVOCATION, True,
+                                on_its_card(plat, bios_path)):
+        print(f"  {line}")
+    for line in save_lines(shown, kept_omitted, bios_path, name or display_name(plat)):
+        print(f"  {line}")
+
+
+def _choose_narrowing(files: list[dict], omitted: list[dict], manifest: dict | None,
+                      bios_path: Path | None) -> tuple[list[str], list[str], list[str]]:
+    """Systems, cores and regions asked one after the other, the systems
+    titled and ordered as the screen's Choose systems lists them."""
+    systems_listed = systems_in_order(listed_systems(files), files, manifest, bios_path)
+    if OTHER_SYSTEMS in systems_listed:
+        print(f"\n'{OTHER_TITLE}' holds what cores load for systems this platform")
         print("does not list, such as game engines and extra computers.")
+    labels = {}
+    for system in systems_listed:
+        title = system_title(system, manifest)
+        labels[system] = title if system in title or system == OTHER_SYSTEMS \
+            else f"{title}  {system}"
     systems = _pick("Systems:", [
-        (name, [f for f in files if _chosen(f, {name})])
-        for name in choices["systems"]
-    ], sizer=_system_sized)
+        (system, [f for f in files if _chosen(f, {system})]) for system in systems_listed
+    ], sizer=_system_sized, labels=labels)
     kept, kept_omitted = narrow(files, omitted, systems, [], [])
 
     cores: list[str] = []
     core_names = available_choices(kept, kept_omitted)["cores"]
     if core_names:
-        print("\nThe platform's own files for these systems are always kept;")
-        print("the extra files each core loads can be narrowed.")
+        print("\nThe platform's own files for these systems are always kept.")
+        print("The extra files each core loads can be narrowed.")
         cores = _pick("Cores:", [
-            (name, _filter_by_target(
-                [f for f in kept if f.get("cores") is not None], [name]))
-            for name in core_names
+            (core, _filter_by_target(
+                [f for f in kept if f.get("cores") is not None], [core]))
+            for core in core_names
         ], sizer=_core_sized)
         kept, kept_omitted = narrow(kept, kept_omitted, [], cores, [])
 
@@ -6932,23 +7242,19 @@ def _prompt_custom_selection(
         print("\nSome systems have one BIOS per region. Keeping only the")
         print("preferred region removes the others where a match exists.")
         regions = _pick("Regions:", [
-            (name, [f for f in kept if name in (f.get("regions") or [])])
-            for name in region_names
-        ], ordered=True)
+            (region, [f for f in kept if region in (f.get("regions") or [])])
+            for region in region_names
+        ], ordered=True, labels={region: region_title(region) for region in region_names})
     return systems, cores, regions
 
 
-def _same_choice_hint(plat: str, systems: list[str], cores: list[str], regions: list[str]) -> str:
-    """The options that repeat a choice made at the prompts."""
-    def quoted(value: str) -> str:
-        return f'"{value}"' if any(c in value for c in " ;&|") else value
-
-    parts = [f"--platform {plat}"]
-    parts += [f"--system {quoted(name)}" for name in systems]
-    parts += [f"--core {quoted(name)}" for name in cores]
-    if regions:
-        parts.append(f"--region {','.join(regions)}")
-    return " ".join(parts)
+def chosen_flags(choice: object) -> list[tuple[str, str | None]]:
+    """The options a choice made at the questions stands for."""
+    if choice == INSTALLED_ONLY:
+        return [("--installed-cores", None)]
+    systems, cores, regions = choice  # type: ignore[misc]
+    return [*(("--system", name) for name in systems), *(("--core", name) for name in cores),
+            *([("--region", ",".join(regions))] if regions else [])]
 
 
 def system_aliases(manifest: dict | None) -> dict[str, str]:
@@ -7135,13 +7441,18 @@ def romm_relayout(
     return moved, bios_path.parent
 
 
-def _older_list_advice() -> str:
+def _older_list_advice(plat: str = "") -> str:
     """How to reach a file list that records what an option needs.
 
     A list without the fields comes from an older release. Pinned with
     RETROBIOS_REF, as the docs suggest for reproducibility, "a newer one"
-    meant unsetting the variable, and nothing said so.
+    meant unsetting the variable, and nothing said so. A pack's own list is
+    the pack's: the one-line installer does not change it, and a current
+    pack was said to come from an older release.
     """
+    if LOCAL.pack is not None and LOCAL.manifest is None:
+        return (f"  The list in {LOCAL.pack.name} does not record it: add --manifest FILE, "
+                f"a copy of install/{plat or '<platform>'}.json, or run without the option.")
     if RELEASE_REF != DEFAULT_RELEASE_REF:
         return (f"  RETROBIOS_REF={RELEASE_REF} selects file lists published before "
                 "this option existed: unset RETROBIOS_REF to use the current ones, "
@@ -7162,7 +7473,7 @@ def _narrow_to_emulators(
     if "system_cores" not in manifest:
         print(f"Error: the {plat} file list does not say which emulators read "
               "which systems, which --emulator needs.", file=sys.stderr)
-        print(_older_list_advice(), file=sys.stderr)
+        print(_older_list_advice(plat), file=sys.stderr)
         sys.exit(1)
     known = sorted(emulator_names(manifest, files, omitted))
     try:
@@ -7204,8 +7515,17 @@ def _requested_narrowing(
             "--system, --core and --region cannot narrow it.",
             file=sys.stderr,
         )
-        print(_older_list_advice(), file=sys.stderr)
+        print(_older_list_advice(plat), file=sys.stderr)
         sys.exit(1)
+    if LOCAL.pack is not None and LOCAL.manifest is None:
+        # A pack records the systems of its files, not their cores or
+        # regions: either filter would keep everything, and is refused.
+        for flag, given in (("--core", args.core), ("--region", args.region)):
+            if given:
+                print(f"Error: {LOCAL.pack.name} records the systems of its files, not "
+                      f"what {flag} narrows by.", file=sys.stderr)
+                print(_older_list_advice(plat), file=sys.stderr)
+                sys.exit(1)
     choices = available_choices(files, omitted)
     try:
         systems = resolve_choices(
@@ -7348,6 +7668,8 @@ class PackSource:
         self.name = f"{first['stem']}.zip" if first else self.files[0].name
         self.archives: list[zipfile.ZipFile] = []
         self.members: dict[str, tuple[zipfile.ZipFile, zipfile.ZipInfo]] = {}
+        # The system titles and names the pack's list records, if any.
+        self.names: dict[str, dict] = {}
         try:
             for path in self.files:
                 archive = zipfile.ZipFile(path)
@@ -7429,6 +7751,16 @@ class PackSource:
         files = data.get("files") if isinstance(data, dict) else None
         if not isinstance(files, list):
             raise ValueError(f"the manifest.json of {self.name} lists no files")
+        # What a pack built since records of its systems (generate_pack.py
+        # pack_systems): --system and Choose systems then work with the pack
+        # alone. An older pack records none, and is read as before.
+        for key in ("system_titles", "system_names"):
+            held = data.get(key)
+            if isinstance(held, dict):
+                self.names[key] = {
+                    str(system): value for system, value in held.items()
+                    if isinstance(value, str) or (isinstance(value, list) and all(
+                        isinstance(name, str) for name in value))}
         listed = []
         for item in files:
             if (
@@ -7438,8 +7770,13 @@ class PackSource:
                 and _SHA1_RE.fullmatch(item["sha1"].lower())
                 and isinstance(item.get("size"), int)
             ):
-                listed.append({"path": item["path"], "sha1": item["sha1"].lower(),
-                               "size": item["size"]})
+                entry = {"path": item["path"], "sha1": item["sha1"].lower(),
+                         "size": item["size"]}
+                systems = item.get("systems")
+                if isinstance(systems, list) and all(isinstance(name, str)
+                                                     for name in systems):
+                    entry["systems"] = list(systems)
+                listed.append(entry)
         return listed
 
     def platforms(self) -> list[str]:
@@ -7450,13 +7787,16 @@ class PackSource:
 
     def manifest(self, plat: str) -> dict:
         """A file list for plat built from the pack's own: the same files at
-        the same places, as extracting the pack would leave them."""
+        the same places, as extracting the pack would leave them, with the
+        systems it records."""
         return {
             "manifest_version": 2,
             "platform": plat,
+            **{key: value for key, value in self.names.items() if value},
             "files": [
                 {"dest": f["path"], "sha1": f["sha1"], "size": f["size"],
-                 "repo_path": f"bios/{f['path']}"}
+                 "repo_path": f"bios/{f['path']}",
+                 **({"systems": f["systems"]} if "systems" in f else {})}
                 for f in self.listed
             ],
         }
@@ -7496,6 +7836,20 @@ class LocalSources:
         self.folders: list[FolderIndex] = []
         # Every folder index of the run still in use, closed at its end.
         self.indexes: weakref.WeakSet[FolderIndex] = weakref.WeakSet()
+        self._serves: tuple = (None, None, frozenset())
+
+    def serves(self) -> frozenset:
+        """The platforms the file list or pack given to this run is for,
+        empty when none is given. The setup list offers those alone: after
+        o, Batocera was listed for a RetroArch list, and refused once its
+        folder was asked."""
+        if self._serves[:2] != (self.manifest, self.pack):
+            named = (local_manifest_platform(self.manifest) if self.manifest is not None
+                     else None)
+            found = ({named} if named else set()) if self.manifest is not None \
+                else set(self.pack.platforms()) if self.pack is not None else set()
+            self._serves = (self.manifest, self.pack, frozenset(found))
+        return self._serves[2]
 
     @property
     def offline(self) -> bool:
@@ -9230,8 +9584,8 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--target",
         metavar="NAME",
-        help="hardware target for core filtering (switch, rpi4, ...); "
-        "on Batocera, Recalbox, ROCKNIX and Lakka the board is read from the system",
+        help="hardware target for core filtering (switch, rpi4, ...). "
+        "On Batocera, Recalbox, ROCKNIX and Lakka the board is read from the system",
     )
     parser.add_argument(
         "--every-board",
@@ -9338,7 +9692,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--yes", "-y",
         action="store_true",
-        help="do not ask before a large download",
+        help="do not ask before a large download, nor anything else (implies --no-input)",
     )
     parser.add_argument(
         "--quiet", "-q",
@@ -9456,6 +9810,10 @@ def main() -> None:
         _RAW_ERRORS.set()
     if args.cores_dir:
         args.installed_cores = True
+    if args.yes:
+        # Asked at a terminal, --yes still waited at Install for: and at
+        # the menu. Yes to every question is no question.
+        args.no_input = True
     _INVOCATION.record(args)
     if os.environ.get(TUI_LIST_ENV):
         # The full screen's own copy of the list, deleted when it closes: a
@@ -9521,7 +9879,7 @@ def main() -> None:
                          f"--{given[0].replace('_', '-')}")
         sys.exit(restore_kept(args.restore, args.dry_run))
     if args.every_board and args.target:
-        parser.error("--every-board installs every board; --target names one")
+        parser.error("--every-board installs every board, and --target names one")
     if args.add_app:
         # Applied or refused, never ignored.
         for given, reason in (
@@ -9724,11 +10082,30 @@ def _ask_from_folder(files: list[dict] | None = None, bios_path: Path | None = N
     line menu had no way to it. What it holds of files is counted, as the
     screen's plan counts it: a folder holding none of them was kept, and
     the menu offered to install what it held."""
+    # The drives mounted here, numbered as the screen's copy browser lists
+    # them, the card being installed to left out: line mode listed none, and
+    # took q for a folder named q.
+    drives = [mount for mount in _mounted_cards() if not copy_source_refusal(mount, bios_path)]
+    if drives:
+        print("\nCopy from:")
+        for index, mount in enumerate(drives, 1):
+            print(f"  {index}) {card_line(mount)}")
+    numbers = "" if not drives else " or 1" if len(drives) == 1 else f" or 1 to {len(drives)}"
     while True:
-        raw = _ask("Folder, old card or ZIP to copy from (Enter to go back): ").strip()
+        raw = _ask(f"Folder, old card or ZIP to copy from{numbers} (Enter to go back, "
+                   "q to quit): ").strip()
         if not raw:
             return
-        label = os.path.normpath(str(_typed_folder(raw).absolute()))
+        if raw.lower() == "q":
+            _quit()
+        if raw.isdigit() and 1 <= int(raw) <= len(drives):
+            label = str(drives[int(raw) - 1])
+        else:
+            label = os.path.normpath(str(_typed_folder(raw).absolute()))
+        refused = copy_source_refusal(Path(label), bios_path)
+        if refused:
+            print(f"  {refused}")
+            continue
         problem = from_folder_problem(label)
         if problem is not None:
             print(f"  {screen_text(shown_path(label))} {problem[1]}.")
@@ -9933,12 +10310,40 @@ def card_system(root: Path) -> tuple[str, Path, str] | None:
     if plat:
         return plat, root, display_name(plat)
     matched = _card_matches(root)
+    if not matched:
+        share = share_drive(root)
+        return (share, root / "bios", display_name(share)) if share else None
     if len({(rule.manifest, rule.bios) for rule in matched}) != 1:
         return None
     rule = matched[0]
     return rule.manifest, root / rule.bios, rule.name
 
 
+# The SHARE drive of a system a computer reaches over the network, by the
+# file the system keeps on it: Batocera's data part (/userdata) holds
+# system/batocera.conf, Recalbox's (/recalbox/share) system/recalbox.conf,
+# and both read bios/ beside it. KNULLI, built on Batocera, writes the same
+# batocera.conf with its own hostname: its rule (_SHARE_RULES) comes first.
+# Typed at the folder question, the drive was taken as the BIOS folder and
+# filled beside roms/ and system/, where neither reads.
+_SHARE_DRIVES: tuple[tuple[str, str], ...] = (
+    ("batocera", "system/batocera.conf"),
+    ("recalbox", "system/recalbox.conf"),
+)
+
+
+def share_drive(root: Path) -> str | None:
+    """The platform whose SHARE drive root is, by its own files, or None."""
+    return next((plat for plat, marker in _SHARE_DRIVES
+                 if _is_file(root / marker) and _on_the_drive(root, marker)), None)
+
+
+def drive_kind(system: tuple[str, Path, str]) -> str:
+    """What a drive card_system read is, in words: an Onion card, a
+    Batocera SHARE drive."""
+    return "SHARE drive" if system[0] in _SHARE_FOLDERS else "card"
+
+
 def _card_matches(root: Path, above: bool = False) -> list[_OsRule]:
     """The card rules root matches, a system another one is built on left
     out for it. above is for a folder above the one named: a rule that is
@@ -10069,6 +10474,14 @@ def shown_bios_folder(bios_path: Path, files: list[dict]) -> Path:
     return bios_path
 
 
+def setup_bios_folder(plat: str, path: Path) -> Path:
+    """The BIOS folder a setup found is announced with, before its list is
+    read: a MinUI card's Bios below its root, the folder found else. The
+    first screen and line mode's Found named /media/me/MINUI, the plan
+    then /media/me/MINUI/Bios."""
+    return path / "Bios" if plat in CARD_PLATFORMS else path
+
+
 def card_setup(named: str, plat: str) -> CardSetup | None:
     """The card setup a name stands for with plat's list: a system by its
     own name, or a list that is one (MinUI). RetroArch names a list, not a
@@ -10094,6 +10507,9 @@ def _card_is(setup: CardSetup, card: Path, above: bool = False) -> tuple[str, st
     names = sorted({rule.name for rule in _card_matches(card, above)})
     if setup.name in names:
         return "own", setup.name
+    if not names and share_drive(card):
+        # A Batocera share is no KNULLI card not started yet.
+        return "other", display_name(share_drive(card))
     return ("other", " and ".join(names)) if names else ("unknown", "")
 
 
@@ -10110,8 +10526,9 @@ def _not_the_card(setup: CardSetup, folder: Path, card: Path, other: str) -> Car
                           f"not of {name}", detail=detail,
                           short=f"That card holds {other} files.", below=setup.below)
     if other:
-        return CardChoice(setup.plat, folder, refused=f"{shown} is {_a(other)} card, not "
-                          f"{_a(name)} card", detail=detail, short=f"That is {_a(other)} card, "
+        kind = "SHARE drive" if share_drive(card) else "card"
+        return CardChoice(setup.plat, folder, refused=f"{shown} is {_a(other)} {kind}, not "
+                          f"{_a(name)} card", detail=detail, short=f"That is {_a(other)} {kind}, "
                           f"not {_a(name)} card.", below=setup.below, other=other)
     return CardChoice(setup.plat, folder, refused=f"{shown} is not {_a(name)} SD card: no "
                       f"{name} files on it", detail=detail,
@@ -10226,9 +10643,21 @@ def _list_card_choice(plat: str, dest: Path) -> CardChoice:
     card is said, the user having named both."""
     found = card_system(dest)
     if found and (not plat or found[0] == plat) and found[1] != dest:
+        if drive_kind(found) != "card":
+            # Its root typed, the drive itself: the files go to its bios.
+            return CardChoice(found[0], found[1],
+                              found=f"{found[2]} SHARE drive: its BIOS folder is "
+                              f"{shown_path(found[1])}")
         return CardChoice(found[0], found[1],
                           found=f"{found[2]} card: {display_name(found[0])} files, "
                           f"in {shown_path(found[1])}")
+    if found and plat in _SHARE_FOLDERS and found[0] != plat and drive_kind(found) != "card":
+        # Another system's drive, never filled beside its own files.
+        shown = shown_path(dest)
+        kind = drive_kind(found)
+        return CardChoice(plat, dest, refused=f"{shown} is {_a(found[2])} {kind}, not "
+                          f"{_a(display_name(plat))} SHARE drive",
+                          short=f"That is {_a(found[2])} {kind}.", other=found[2])
     if found and plat and found[0] != plat:
         shown = shown_path(dest)
         return CardChoice(plat, dest, f"Note: {shown} is {_a(found[2])} card, which reads "
@@ -10361,6 +10790,17 @@ def mounted_cards_of(system: str, plat: str) -> list[Path]:
     return [mount for mount in _mounted_cards() if _card_is(setup, mount)[0] == wanted]
 
 
+def blank_cards_of(system: str, plat: str) -> list[Path]:
+    """The mounted drives no system claims, offered too for a system that
+    fills its card when it first starts (KNULLI, ROCKNIX): such a card is
+    blank until then. Listed after its own cards, never taken by itself.
+    The screen's browser listed a blank stick for KNULLI, line mode none."""
+    setup = card_setup(system, plat)
+    if setup is None or not setup.fresh or not setup.known():
+        return []
+    return [mount for mount in _mounted_cards() if _card_is(setup, mount)[0] == "unknown"]
+
+
 def card_line(mount: Path) -> str:
     """A mounted drive in the line questions, named as the screen names it,
     its path after unless the name is the path: ONION (Onion card,
@@ -10394,8 +10834,7 @@ def card_install_dest(named: str, plat: str, interactive: bool, ask: bool = True
         return dest
     # Pasted, the name of a system in words is two arguments: its key is one.
     word = named.strip() if _name_key(named) == named.strip().lower() else _name_key(named)
-    example = (f"--platform {word or plat} --dest /media/$USER/<card> "
-               "(Windows: --dest E:\\)")
+    example = f"--platform {word or plat} --dest {drive_example(detect_os(), '<card>')}"
     if setup.known() and len(cards) > 1:
         print(f"  {len(cards)} {system} cards are mounted: "
               + ", ".join(_mount_name(card) for card in cards) + ".", file=sys.stderr)
@@ -10413,15 +10852,26 @@ def card_install_dest(named: str, plat: str, interactive: bool, ask: bool = True
              f"RetroBIOS cannot tell {_a(system)} card by its files. ")
           + ("Type its number or its top folder:" if cards
              else "Mount the card, then type its top folder."))
-    for index, mount in enumerate(cards, 1):
-        print(f"    {index}) {card_line(mount)}")
-    numbers = "1" if len(cards) == 1 else f"1 to {len(cards)}"
-    usage = (f"  Type {numbers}, a folder, or q to quit." if cards
-             else "  Type the card's top folder, or q to quit.")
+    listed = _list_cards(cards, blank_cards_of(system, plat))
     while True:
-        raw = _folder_answer("Card root, q to quit: ", usage, False, len(cards))
-        chosen = raw.isdigit() and 1 <= int(raw) <= len(cards)
-        root = cards[int(raw) - 1] if chosen else _typed_folder(raw).absolute()
+        numbers = ("" if not listed else " or 1" if len(listed) == 1
+                   else f" or 1 to {len(listed)}")
+        # Enter looks again, as the screen's Look again does: a card
+        # inserted after the question was never found.
+        raw = _ask(f"Card root{numbers}, Enter to look again, q to quit: ")
+        if not raw:
+            listed = _list_cards(mounted_cards_of(system, plat), blank_cards_of(system, plat),
+                                 f"Still no {system} card is mounted.")
+            continue
+        if raw.lower() == "q":
+            _quit()
+        chosen = raw.isdigit() and 1 <= int(raw) <= len(listed)
+        if raw.isdigit() and not chosen and not _is_dir(_typed_folder(raw)):
+            print(f"  Type a number from 1 to {len(listed)}, a folder, Enter to look "
+                  "again, or q to quit." if listed else
+                  "  Type the card's top folder, Enter to look again, or q to quit.")
+            continue
+        root = listed[int(raw) - 1] if chosen else _typed_folder(raw).absolute()
         choice = card_choice(system, plat, root)
         if choice.refused:
             print(f"  {_refusal_words(choice, setup)}")
@@ -10436,6 +10886,18 @@ def card_install_dest(named: str, plat: str, interactive: bool, ask: bool = True
             return choice.folder
 
 
+def _list_cards(cards: list[Path], blank: list[Path], none: str = "") -> list[Path]:
+    """Number a system's cards, then the blank drives it may take (the
+    screen's rows), and return them in that order. none is said when
+    there is none."""
+    listed = cards + [mount for mount in blank if mount not in cards]
+    for index, mount in enumerate(listed, 1):
+        print(f"    {index}) {card_line(mount)}")
+    if not listed and none:
+        print(f"  {none}")
+    return listed
+
+
 def dest_default(setups: list) -> str:
     """The setup a folder named without a system is offered for, on the
     screen and in line mode: the one found here, else RetroArch."""
@@ -10457,7 +10919,7 @@ def _platform_for_dest(os_type: str, dest: Path, interactive: bool) -> tuple[str
         print(f"  File list: {display_name(card)} (the card's {CARD_MARKER}). "
               f"Same choice without detection: --platform {card}")
         return card, dest
-    print("Detecting platform...")
+    print("Looking for setups here...")
     if interactive:
         # The screen's list for --dest: the setups found here first, in its
         # order and with its default. Without them the cards came after
@@ -10583,7 +11045,7 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
     if args.platform and args.dest:
         platforms = [(args.platform, args.dest)]
     elif args.platform:
-        print("Detecting platform...")
+        print("Looking for setups here...")
         if interactive and not listing:
             # The cards mounted here too, as the screen finds them: a pack's
             # RetroArch list went to this computer's folder past the Onion
@@ -10641,9 +11103,9 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
                        f"{share_words(args.platform)}")
             EVENTS.emit("error", stage="detect", reason="not_found", platform=args.platform,
                         message=message)
+            example = drive_example(os_type, "SHARE", "bios", args.platform)
             print(f"  {message} Name it with --dest, for example: --platform "
-                  f"{args.platform} --dest /media/$USER/SHARE/bios (Windows: --dest "
-                  f"{_SHARE_FOLDERS[args.platform]})", file=sys.stderr)
+                  f"{args.platform} --dest {example}", file=sys.stderr)
             sys.exit(1)
         else:
             default_dest = _default_dest(os_type, args.platform)
@@ -10671,7 +11133,7 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
         plat, args.dest = _platform_for_dest(os_type, args.dest, interactive and not listing)
         platforms = [(plat, args.dest)]
     else:
-        print("Detecting platform...")
+        print("Looking for setups here...")
         frontends = detect_frontends(os_type)
         if "esde" in frontends:
             print("  Found ES-DE (BIOS files go to each emulator, not to ES-DE itself)")
@@ -10686,7 +11148,10 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
         else:
             platforms = detect_platforms(os_type)
         if not platforms:
-            print("  No supported platform detected.")
+            # The screen's words where a person answers: "platform" was said
+            # nowhere else.
+            print("  Nothing was found here." if interactive and not listing
+                  else "  No supported platform detected.")
             EVENTS.emit("detect", os=os_type, os_name=_os_name(), platforms=[])
             # Standalone emulators read their BIOS from folders of their own,
             # which the file lists name: an ES-DE user with DuckStation and
@@ -10816,7 +11281,7 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
             cores_found[(plat_name, bios_path)] = installed_cores(searched)
         elif args.installed_cores:
             print(
-                f"Error: {plat_name} ships its cores with the system; "
+                f"Error: {plat_name} ships its cores with the system. "
                 f"--installed-cores applies to {', '.join(CORE_PLATFORMS)}",
                 file=sys.stderr,
             )
@@ -10861,7 +11326,7 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
                 # install the game data it was asked to leave out.
                 print(f"Error: the {plat_name} file list records no file category, "
                       "which --no-game-data needs.", file=sys.stderr)
-                print(_older_list_advice(), file=sys.stderr)
+                print(_older_list_advice(plat_name), file=sys.stderr)
                 sys.exit(1)
             before = len(files)
             files, omitted_files, left_out = leave_out_game_data(files, omitted_files)
@@ -10925,7 +11390,7 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
                 sys.exit(1)
             elif target_info.get("cores") is None:
                 print(
-                    f"  Target '{target}' publishes no core list; "
+                    f"  Target '{target}' publishes no core list: "
                     "installing every file"
                 )
             else:
@@ -10947,7 +11412,7 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
                     "read which systems, which --installed-cores needs.",
                     file=sys.stderr,
                 )
-                print(_older_list_advice(), file=sys.stderr)
+                print(_older_list_advice(plat_name), file=sys.stderr)
                 sys.exit(1)
             before = len(files)
             files, omitted_files = narrow_to_cores(
@@ -10965,30 +11430,45 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
             )
 
         # Before the menu: it offered 23 files, then 22 were checked, the
-        # one read from an unknown save directory left out.
+        # one read from an unknown save directory left out. Said once the
+        # choice is made, over the files it keeps (say_saves).
+        display = display_name(plat_name, manifest)
         files, unplaced = place_save_entries(
-            files, bios_path, manifest, args.save_dir, display_name(plat_name, manifest)
-        )
-        if unplaced:
-            total_omitted += len(unplaced)
-            omitted_seen.extend(unplaced)
+            files, bios_path, manifest, args.save_dir, display, say=False)
 
         # What --core resolves against, for advice that names one.
         core_choices = set(available_choices(files, omitted_files)["cores"])
         selection = _requested_narrowing(args, plat_name, files, omitted_files, manifest)
+        # What the systems are counted out of, on the plan and in Choose
+        # systems: the screen reads it from this event.
+        EVENTS.emit("choices", platform=plat_name, systems=choosable_systems(
+            files, omitted_files, *(selection[1:] if selection else ())))
         # What declining the size question points back at, when it was asked.
         smaller = ""
         given = selection
-        if interactive and not args.check and not listing:
+        menu = interactive and not args.check and not listing
+        if menu:
             installed = (
                 narrow_to_cores(manifest, found_cores, files, omitted_files)
                 if found_cores and not args.installed_cores else None
             )
+            listed = len(manifest.get("files", [])) + len(variants if case_kept else [])
+
+            def command_for(choice: object, plat: str = plat_name,
+                            folder: Path = bios_path) -> str:
+                # The choice made at the questions, every other option of the
+                # run kept: --dest, --from-pack and --manifest were dropped.
+                _INVOCATION.chosen[plat] = chosen_flags(choice)
+                return _INVOCATION.command(plat, folder)
+
             selection = _prompt_custom_selection(
-                plat_name, files, omitted_files, installed,
-                detected_os(plat_name, bios_path) or display_name(plat_name, manifest),
+                plat_name, files, omitted_files + unplaced, installed,
+                detected_os(plat_name, bios_path) or display,
                 args.dry_run, manifest.get("data_directories") or [], bios_path,
-                records_selection(files), given,
+                records_selection(files), given, manifest,
+                bool(target or args.installed_cores or args.declared_only
+                     or len(files) + game_data_cut + len(unplaced) != listed),
+                command_for,
             )
             if selection is None and LOCAL.pack is not None:
                 smaller = "  Nothing copied."
@@ -11001,27 +11481,21 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
                 smaller += "."
             if selection == INSTALLED_ONLY:
                 files, omitted_files = installed
-                print("\n  Same choice without questions: "
-                      f"--platform {plat_name} --installed-cores"
-                      + (" --no-game-data" if args.no_game_data else "")
-                      + (" --declared-only" if args.declared_only else ""))
-                _INVOCATION.chosen[plat_name] = [("--installed-cores", None)]
+                _INVOCATION.chosen[plat_name] = chosen_flags(INSTALLED_ONLY)
                 selection = None
             elif selection is not None and selection != given:
-                print("\n  Same choice without questions: "
-                      + _same_choice_hint(plat_name, *selection)
-                      + (" --no-game-data" if args.no_game_data else "")
-                      + (" --declared-only" if args.declared_only else ""))
-                systems, cores, regions = selection
-                _INVOCATION.chosen[plat_name] = [
-                    *(("--system", name) for name in systems),
-                    *(("--core", name) for name in cores),
-                    *([("--region", ",".join(regions))] if regions else []),
-                ]
+                _INVOCATION.chosen[plat_name] = chosen_flags(selection)
+            else:
+                _INVOCATION.chosen.pop(plat_name, None)
         if selection is not None:
             before = len(files)
             files, omitted_files = narrow(files, omitted_files, *selection)
+            unplaced = narrow([], unplaced, *selection)[1]
             print(f"  Narrowed {before} to {len(files)} files")
+        if unplaced:
+            total_omitted += len(unplaced)
+            omitted_seen.extend(unplaced)
+        say_saves(plat_name, files, omitted_files + unplaced, bios_path, display, menu)
 
         if args.list_systems or args.list_cores:
             _print_choices(plat_name, files, omitted_files, args.list_systems, manifest)
@@ -11046,7 +11520,12 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
                 f"({required_omitted} required, {reason_summary})."
             )
             total_omitted += len(omitted_files)
-            omitted_seen.extend(omitted_files)
+            # Named for the end of the run: ROCKNIX's own list leaves them out,
+            # and the end said "the frontend's save directory".
+            omitted_seen.extend({**entry, "frontend": display}
+                                if entry.get("reason") == "no_save_directory"
+                                and not entry.get("frontend") else entry
+                                for entry in omitted_files)
 
         if plat_name == "romm":
             try:
@@ -11264,7 +11743,7 @@ def _install(args: argparse.Namespace, real_stdout: TextIO) -> None:
                 print(_write_advice(bios_path, bios_path in assumed_dests, plat_name),
                       file=sys.stderr)
                 # The documented code for a folder that cannot be written,
-                # as when it exists read-only; 1 once an earlier platform
+                # as when it exists read-only. 1 once an earlier platform
                 # of the run installed something.
                 sys.exit(1 if total_downloaded else 2)
             if created:
@@ -11721,6 +12200,12 @@ def _folded(text: str) -> str:
     return "".join(char for char in decomposed if not unicodedata.combining(char)).casefold()
 
 
+# What a check run tells the screen, kept whole when Choose systems widens a
+# --system plan: Back with the same ticks gives that plan back.
+_CHECK_FIELDS = ("check", "files", "systems", "choices", "found", "scanned", "unreadable",
+                 "saves", "check_summary", "checked_flags", "cli_systems", "facts", "ticked")
+
+
 class TuiState:
     """Everything the screens show. Nothing here touches the terminal."""
 
@@ -11792,6 +12277,8 @@ class TuiState:
         # Choose systems asked on a plan --system narrowed: the systems are
         # opened once the check of every system is in.
         self.widen: bool = False
+        # The --system plan Choose systems widened, by _CHECK_FIELDS.
+        self.widened_from: dict | None = None
         # (files read, files to read) while the check hashes what is in place.
         self.reading: tuple | None = None
         # Folders to copy BIOS files from (--from), and what the check found.
@@ -11813,6 +12300,8 @@ class TuiState:
         self.started: float = 0.0
         self.checked_flags: list = []
         self.check: dict | None = None
+        # The systems the check's list lets one choose among (choices event).
+        self.choices: list | None = None
         self.files: list = []
         self.systems: list = []
         self.facts: dict = {}
@@ -11896,7 +12385,7 @@ class TuiRoute(NamedTuple):
 
     bar maps a key of the bottom line, written in the "both" form ("A/Enter
     Install"), to the route's own name, None for a key the route lacks: a PC
-    user read "A/Enter", a muOS player was told a Start+Select that muxterm
+    user read "A/Enter", a muOS player was told a Select+Start that muxterm
     does not have. help names each action of the help screen, the buttons
     first, then the keys a keyboard plugged in also has, None for an action
     the route lacks. stop is what stops an install the second time, then the
@@ -11909,15 +12398,15 @@ class TuiRoute(NamedTuple):
 
 
 # retrobios.gptk: A Enter, B Esc, X Space, Y Tab, L1 and R1 a page, Start
-# Enter, Select Esc, Start+Select the kill.
+# Enter, Select Esc, Select then Start the kill.
 _GPTOKEYB = TuiRoute(
     {"A/Enter": "A", "B/Esc": "B", "X/Space": "X", "Y/o": "Y", "?": None, "/": None,
-     "Ctrl-C": "Start+Select", "Enter": "A", "Esc": "B", "Ctrl-U": None},
+     "Ctrl-C": "Select+Start", "Enter": "A", "Esc": "B", "Ctrl-U": None},
     {"move": "D-pad, Up/Down", "page": "L1/R1, PgUp/PgDn", "ok": "A, Start, Enter",
      "tick": "X, Space, Right/Left", "options": "Y, Tab, o", "back": "B, Select, Esc",
      "stop": "B, Esc, Ctrl-C", "kill": "Select, then Start", "enter": "A, Enter",
      "esc": "B, Esc"},
-    ("B", "B or Start+Select"))
+    ("B", "B or Select+Start"))
 # keys is a keyboard's, and both names the button and the key where nothing
 # says which one is held. The others are the values of RETROBIOS_PAD.
 TUI_ROUTES: dict[str, TuiRoute] = {
@@ -11931,8 +12420,8 @@ TUI_ROUTES: dict[str, TuiRoute] = {
         {},
         {"move": "Up/Down, k/j", "page": "PgUp/PgDn, L1/R1", "ok": "A/Enter, Start",
          "tick": "X, Space, Right/Left", "options": "Y, o, Tab", "back": "B/Esc, Backspace",
-         "stop": "B/Esc, Ctrl-C", "kill": "Start+Select", "enter": "Enter", "esc": "Esc"},
-        ("B or Ctrl-C", "B, Ctrl-C or Start+Select")),
+         "stop": "B/Esc, Ctrl-C", "kill": "Select+Start", "enter": "Enter", "esc": "Esc"},
+        ("B or Ctrl-C", "B, Ctrl-C or Select+Start")),
     "gptokeyb": _GPTOKEYB,
     # gptokeyb2 with retrobios.gptk inside muxterm, which no longer reads the
     # pad: the gptokeyb buttons. muxterm keeps PgUp and PgDn for its
@@ -12113,8 +12602,8 @@ def tui_blocker(
         ("--list-platforms", args.list_platforms), ("--list-targets", args.list_targets),
         ("--list-systems", args.list_systems), ("--list-cores", args.list_cores),
         ("--list-emulators", args.list_emulators), ("--events", args.events),
-        ("--quiet", args.quiet), ("--no-input", args.no_input),
-        ("--restore", args.restore is not None), ("--yes", args.yes),
+        ("--quiet", args.quiet), ("--yes", args.yes), ("--no-input", args.no_input),
+        ("--restore", args.restore is not None),
     ):
         if given:
             return f"{flag} runs without questions"
@@ -12200,8 +12689,9 @@ def tui_argv(state: TuiState, run: str, python: str, script: str) -> list[str]:
     return argv + _TUI_MODES[run]
 
 
-def tui_command(state: TuiState) -> str:
-    """The same choice as one command, in the form the run was started with."""
+def tui_hint(state: TuiState) -> Invocation:
+    """The command the screen's choices make, every option of the run in
+    it: what "Same choice without questions" and the sudo advice give."""
     hint = Invocation()
     hint.os_type = state.os_type
     hint.options = ([("--manifest", str(state.manifest_path))]
@@ -12209,7 +12699,12 @@ def tui_command(state: TuiState) -> str:
     hint.options += tui_flags(state)
     if state.add_app and _tui_app_ready(state):
         hint.options.append(("--add-app", None))
-    return hint.command(state.platform, state.dest)
+    return hint
+
+
+def tui_command(state: TuiState) -> str:
+    """The same choice as one command, in the form the run was started with."""
+    return tui_hint(state).command(state.platform, state.dest)
 
 
 def _tui_card(state: TuiState) -> CardApp | None:
@@ -12256,6 +12751,9 @@ class TuiRow(NamedTuple):
     # A name cut to the room left when no form of narrow but a count fits:
     # "1 device" named nothing where "TrimUI Smart P..." fits.
     cut: str = ""
+    # The right-hand text is never cut: the label is, once its shortest
+    # form does not fit beside it (a system's size).
+    keep_right: bool = False
 
 
 # Screens that scroll text instead of listing rows.
@@ -12341,6 +12839,15 @@ def tui_choices(state: TuiState) -> dict[str, list[str]]:
     return available_choices(manifest.get("files", []), manifest.get("omitted_files", []))
 
 
+def tui_systems(state: TuiState) -> list[str]:
+    """The systems Choose systems lists for the run, as the check counted
+    them (listed_systems): the file list's own count took in a system
+    whose only file the run leaves out."""
+    if state.choices is not None:
+        return state.choices
+    return tui_choices(state)["systems"]
+
+
 def tui_rows(state: TuiState) -> list[TuiRow]:
     """The rows of the current screen, in the order they are shown."""
     screen = state.screen
@@ -12360,18 +12867,32 @@ def tui_rows(state: TuiState) -> list[TuiRow]:
             rows += [TuiRow("share", label, value=folder)
                      for label, folder in share_targets(state.platform)]
         if not bound:
+            # The drives mounted here, as line mode numbers them at the same
+            # question: a stick in the reader was offered there and not here.
+            drives = [] if state.folder_kind == "share" else [
+                TuiRow("drive", f"{_mount_name(mount)} ({_card_what(mount)})", value=mount)
+                for mount in _mounted_cards()]
             return rows + [TuiRow("browse", "Browse for a folder"),
-                           TuiRow("type", "Type a path")]
+                           TuiRow("type", "Type a path")] + drives
         # Only the cards whose own files say they run the system: A on the
         # first mount wrote Onion's layout on a muOS card.
         mounts = (state.cards if state.cards is not None
                   else mounted_cards_of(bound[0], state.platform))
         cards = [TuiRow("card", f"{_mount_name(mount)} ({_card_what(mount)})", value=mount)
                  for mount in mounts]
-        rows += cards + [TuiRow("browse", "Browse for a folder"), TuiRow("type", "Type a path")]
         # On the device itself its folder is found, and no card is looked for.
         here = state.folder_default is not None and state.folder_kind == "found"
-        return rows + ([] if cards or here else [TuiRow("rescan", "Look again")])
+        blank = [] if here else [
+            TuiRow("card", f"{_mount_name(mount)} ({_card_what(mount)})", value=mount)
+            for mount in blank_cards_of(bound[0], state.platform) if mount not in mounts]
+        rescan = [] if cards or here else [TuiRow("rescan", "Look again")]
+        if blank:
+            # A blank drive is listed for a system that fills its card when
+            # it first starts, after Look again: A never takes a stick.
+            return rows + cards + rescan + blank + [TuiRow("browse", "Browse for a folder"),
+                                                    TuiRow("type", "Type a path")]
+        rows += cards + [TuiRow("browse", "Browse for a folder"), TuiRow("type", "Type a path")]
+        return rows + rescan
     if screen == "browse":
         return list(state.browse_rows)
     if screen == "create":
@@ -12493,29 +13014,22 @@ def _system_rows(state: TuiState) -> list[TuiRow]:
             right = "in place"
         elif not count:
             right = f"{_plural(need, 'file')}, {format_size(row['bytes_needed'])}"
-            narrow = (format_size(row["bytes_needed"]), _compact_size(row["bytes_needed"]))
+            narrow = (format_size(row["bytes_needed"]),)
         elif not own:
             # Two spellings of shared, never cut: "+ 28 sh." and ", shared"
             # sat beside "+ 1689 shared" on one 40-column screen.
             right = f"{_plural(need, 'file')}, {format_size(size)}, all shared"
-            narrow = (f"{format_size(size)}, all shared", format_size(size),
-                      _compact_size(size))
+            narrow = (f"{format_size(size)}, all shared", format_size(size))
         else:
             right = f"{_plural(own, 'file')}, {format_size(own_size)} + {count} shared"
-            narrow = (f"{format_size(own_size)} + {count} shared", format_size(own_size),
-                      _compact_size(own_size))
+            narrow = (f"{format_size(own_size)} + {count} shared", format_size(own_size))
+        # The size is never rounded to fit: 2.7 KB read 3 KB at 40 columns,
+        # beside a total of 2.7 KB. The name is cut instead.
         rows.append(TuiRow("system", f"{box} {label}", right, row["system"],
-                           "" if need else "dim", narrow))
+                           "" if need else "dim", narrow, keep_right=bool(need)))
     return rows
 
 
-def _compact_size(size: int) -> str:
-    """A size in whole units, for a row too narrow for its decimal: at 40
-    columns Nintendo Game Boy Advance lost its size, 16 KB fitting."""
-    number, unit = format_size(size).split(" ")
-    return f"{round(float(number))} {unit}"
-
-
 def _shared_needed(state: TuiState) -> dict[str, tuple[int, int]]:
     """Per system, the files to download that other systems carry too, and
     their size: `3DO 1704 files, 349.0 MB` read as the 3DO BIOS, when 1689
@@ -12621,6 +13135,14 @@ def _back(state: TuiState) -> list[tuple]:
         # Install the run refused.
         state.ticked = set(state.ticked_before)
     chose = state.screen == "systems" and state.ticked != (state.ticked_before or set())
+    if state.screen == "systems" and state.widened_from is not None:
+        before, state.widened_from = state.widened_from, None
+        if state.ticked == {row["system"] for row in before["systems"]}:
+            # The systems --system named, ticked again: the exact plan of
+            # their own check, not an estimate over every system.
+            for field, value in before.items():
+                setattr(state, field, value)
+            chose = False
     state.stack.pop()
     if chose and state.screen == "plan":
         # The systems chosen, the next press is Install: Back left the focus
@@ -12671,6 +13193,7 @@ def _start_run(state: TuiState, run: str) -> list[tuple]:
         # The systems of an earlier check go first: ticks read against them
         # dropped the --system the command line gave.
         state.check, state.files, state.systems, state.reading = None, [], [], None
+        state.choices = None
         state.found, state.scanned, state.unreadable = [], [], []
         state.check_summary = state.saves = None
         state.checked_flags = tui_flags(state)
@@ -12766,6 +13289,11 @@ def _card_folder(state: TuiState, folder: Path) -> CardChoice | None:
     bios added to it), or when the folder is inside a MinUI card, whose
     root _choose offers."""
     bound = _tui_card_bound(state)
+    if bound is None and state.platform:
+        # Read as line mode reads a folder typed (ask_platform_folder): a
+        # Batocera SHARE drive's root goes to its bios folder, another
+        # system's drive is refused, a card's root is said.
+        return card_choice(state.platform, state.platform, folder)
     if bound is None or (state.platform in CARD_PLATFORMS and card_root_above(folder)):
         return None
     if state.folder_kind == "found" and state.folder_default is not None:
@@ -12790,9 +13318,12 @@ def _card_status(state: TuiState, choice: CardChoice, given: bool = False) -> No
         # The top folder of a card, only another system's: "Choose the
         # card's top folder" sent the user back to the same one.
         bound = _tui_card_bound(state)
-        then = (f"Insert the {bound[0] if bound else 'right'} card, or go back and choose "
+        kind = "SHARE drive" if "SHARE drive" in choice.short else "card"
+        then = (f"Choose the {display_name(state.platform)} SHARE drive, or go back and "
+                f"choose {choice.other}." if kind != "card" and not bound else
+                f"Insert the {bound[0] if bound else 'right'} card, or go back and choose "
                 f"{choice.other}.")
-        short = f"That is {_a(choice.other)} card."
+        short = f"That is {_a(choice.other)} {kind}."
     else:
         then = "Choose the card's top folder."
         short = choice.short or choice.refused + "."
@@ -12853,14 +13384,30 @@ def _take_card(state: TuiState, choice: CardChoice, root: Path) -> list[tuple]:
     elif state.card_bound:
         # A card no file names, chosen as ArkOS's: titled ArkOS, not RetroArch.
         _DETECTED_OS.setdefault((choice.plat, choice.folder), state.card_bound[0])
-    effects = _choose(state, choice.plat, choice.folder)
-    state.card_note = " ".join(filter(None, (choice.note, state.card_note)))
+    # The system's folder below a card that exists is made as line mode
+    # makes it (_missing_dest, one level): the screen asked Create the
+    # folder? for KNULLI's bios on a blank stick, line mode did not.
+    below = choice.folder != root and _is_dir(choice.folder.parent)
+    effects = _choose(state, choice.plat, choice.folder, proposed=below)
+    # Said once: a note that names the folder already says where the files go.
+    named = bool(choice.note) and shown_path(choice.folder) in choice.note
+    state.card_note = choice.note if named else " ".join(filter(None, (choice.note,
+                                                                       state.card_note)))
     return effects
 
 
 def _open_folder_screen(state: TuiState, default: Path | None,
-                        kind: str = "usual") -> list[tuple]:
+                        kind: str = "usual", rebind: bool = False) -> list[tuple]:
+    """The folder screen for the chosen setup. rebind is another folder
+    asked for from the plan: a card setup found mounted (an Onion card) is
+    asked for its card again, never for any folder. A folder off the card
+    is one Onion does not read, and the screen said RetroArch."""
     state.folder_default, state.folder_kind = default, kind
+    # On the device itself its folder is no card in a reader.
+    system = (detected_os(state.platform, state.dest)
+              if rebind and dest_drive(state.dest) is not None else "")
+    if system and not state.card_bound and card_bound(system, state.platform):
+        state.card_bound = card_bound(system, state.platform)
     # The cards are looked for when the screen opens and on Look again: a
     # card inserted meanwhile moved the rows under the focus.
     state.cards = None
@@ -12871,7 +13418,11 @@ def _open_folder_screen(state: TuiState, default: Path | None,
                                     or _short_of_space(state, state.check or {}))
     # A folder just refused as full or read-only: Browse, not Use this
     # folder, is under A, or A, A came back to the same warning.
-    return _push(state, "folder", 1 if refused and default is not None else 0)
+    _push(state, "folder")
+    if refused and default is not None:
+        state.focus["folder"] = next((index for index, row in enumerate(tui_rows(state))
+                                      if row.action == "browse"), 1)
+    return []
 
 
 def _mount_name(mount: Path) -> str:
@@ -12924,7 +13475,7 @@ def _tui_card_bound(state: TuiState) -> tuple[str, str] | None:
 def _card_what(mount: Path) -> str:
     """What a mounted card is, as its own files say."""
     system = card_system(mount)
-    return f"{system[2]} card" if system else "card or drive"
+    return f"{system[2]} {drive_kind(system)}" if system else "card or drive"
 
 
 def _browse_rows(folder: Path | None, zips: bool = False) -> tuple[list[TuiRow], str]:
@@ -12937,7 +13488,10 @@ def _browse_rows(folder: Path | None, zips: bool = False) -> tuple[list[TuiRow],
     rows = [TuiRow("use", "Use this folder"), TuiRow("up", "..", value=folder.parent)]
     for card in _mounted_cards():
         if card != folder:
-            rows.append(TuiRow("dir", f"{card} ({_card_what(card)})", value=card))
+            # Under WSL by its letter, as every other screen writes D:\BIOS.
+            name = _mount_name(card)
+            rows.append(TuiRow("dir", f"{name if name.endswith(':') else card} "
+                               f"({_card_what(card)})", value=card))
     try:
         entries = list(os.scandir(folder))
     except OSError as exc:
@@ -12994,14 +13548,21 @@ def _browse_to(state: TuiState, folder: Path | None, came_from: Path | None = No
                       and row.label == f"{row.value.name}/"
                       and not _os_folder(row.value, folder)), 0)
         if not focus and not state.status:
-            state.status = ("No setup reads BIOS files in your home folder." if
-                            folder == state.home else
-                            "No setup reads BIOS files at a drive's root.")
+            state.status = _no_setup_reads(state, folder)
+            # Never on the row the sentence warns against: A, A, A put a
+            # BizHawk install into the home folder. The first folder below
+            # it, hidden ones too, else the folder above.
+            focus = next((index for index, row in enumerate(state.browse_rows)
+                          if row.action == "dir" and isinstance(row.value, Path)
+                          and row.label == f"{row.value.name}/"), 0) or next(
+                (index for index, row in enumerate(state.browse_rows)
+                 if row.action == "up"), 0)
     if (folder is not None and state.browse_for == "from" and came_from is None
             and folder in (state.home, Path(folder.anchor))):
         # The old card is most often a mounted one: the docs say the copy
         # browser opens on them, and A on Use this folder read all of HOME.
-        mounts = _mounted_cards()
+        # Not the card being installed to: it was focused first, and taken.
+        mounts = [mount for mount in _mounted_cards() if mount != _dest_card(state)]
         focus = next((index for index, row in enumerate(state.browse_rows)
                       if row.action == "dir" and row.value in mounts), focus)
     for index, row in enumerate(state.browse_rows):
@@ -13010,6 +13571,64 @@ def _browse_to(state: TuiState, folder: Path | None, came_from: Path | None = No
     state.focus["browse"] = focus
 
 
+def _on_its_card(state: TuiState) -> bool:
+    """Whether the BIOS folder is on the SD card of the setup it is for, a
+    system that reads that card alone: room is made there, another folder
+    being one it never reads."""
+    if state.dest is None:
+        return False
+    return on_its_card(state.platform, state.dest,
+                       state.card_bound[0] if state.card_bound else "")
+
+
+def on_its_card(plat: str, dest: Path, system: str = "") -> bool:
+    """Whether dest, a card mounted here, is the SD card of the system it
+    is for (system, else the one detection names): line mode and the
+    screen say "free some space on the card" alike."""
+    system = system or detected_os(plat, dest)
+    return bool(system and card_bound(system, plat) and dest_drive(dest) is not None)
+
+
+def _dest_card(state: TuiState) -> Path | None:
+    """The mounted card or drive the BIOS folder is on, None for none."""
+    return dest_drive(state.dest)
+
+
+def dest_drive(dest: Path | None) -> Path | None:
+    """The mounted card or drive dest is on, None for none."""
+    if dest is None:
+        return None
+    place = dest.absolute()
+    return next((mount for mount in _mounted_cards()
+                 if mount == place or mount in place.parents), None)
+
+
+def copy_source_refusal(chosen: Path | None, dest: Path | None) -> str:
+    """Why a folder cannot be copied from, "" when it can: the card being
+    installed to, or the BIOS folder itself. The copy browser focused that
+    card, and choosing it was taken without a word."""
+    if chosen is None or dest is None:
+        return ""
+    place = chosen.absolute()
+    if place == dest.absolute():
+        return "That is the BIOS folder being installed to: choose the old card or a backup."
+    if place == dest_drive(dest):
+        return "That is the card being installed to: choose the old card or a backup."
+    return ""
+
+
+def _no_setup_reads(state: TuiState, folder: Path | None) -> str:
+    """Why folder is no BIOS folder, "" when it may be one: no frontend
+    reads its BIOS files in the home folder or at a drive's root."""
+    if folder is None:
+        return ""
+    if folder == state.home:
+        return "No setup reads BIOS files in your home folder."
+    if folder == Path(folder.anchor):
+        return "No setup reads BIOS files at a drive's root."
+    return ""
+
+
 def _nearest_folder(path: Path) -> Path:
     """The deepest folder on path that exists and can be looked at."""
     probe = path.absolute()
@@ -13070,35 +13689,20 @@ def _activate(state: TuiState, row: TuiRow) -> list[tuple]:
                 state.platform, state.card_bound = "", None
                 return []
             return _take_card(state, choice, state.dest_given)
-        if state.card_bound:
-            # On the device itself, the folder detection found there: a
-            # KNULLI was asked for its own card. A card in a reader is
-            # looked for, as any card is.
-            found = _device_setup(state, plat, state.card_bound[0])
-            return _open_folder_screen(state, found, "found" if found else "usual")
-        # The folder detected here before the built-in one: the built-in
-        # default was offered as where RetroArch reads, when the
-        # retroarch.cfg found here names another. A card in a reader is
-        # its own system's, never this computer's RetroArch.
-        found = next((path for plat, path, _label in state.setups if plat == row.value
-                      and (plat, path) not in state.mounted_setups), None)
-        if found is not None:
-            return _open_folder_screen(state, found, "found")
-        if row.value in _SHARE_FOLDERS:
-            # /userdata/bios exists on the Batocera machine alone: a computer
-            # sees its share drive or its network share.
-            return _open_folder_screen(state, None, "share")
-        return _open_folder_screen(state, _default_dest(state.os_type, row.value))
+        return _open_folder_screen(state, *setup_folder(
+            state.os_type, state.setups, state.mounted_setups, plat, system))
     if screen == "folder":
         if action == "default":
             return _choose(state, state.platform, state.folder_default, proposed=True)
         if action == "share":
             return _choose(state, state.platform, row.value, proposed=True)
+        if action == "drive":
+            return _choose_card(state, row.value)
         if action in ("card", "rescan"):
             if action == "rescan":
                 state.cards = mounted_cards_of(_tui_card_bound(state)[0], state.platform)
                 cards = [index for index, item in enumerate(tui_rows(state))
-                         if item.action == "card"]
+                         if item.action == "card" and item.value in state.cards]
                 state.focus["folder"] = cards[0] if cards else state.focus.get("folder", 0)
                 state.status = ("" if cards else f"Still no {_tui_card_bound(state)[0]} card "
                                 "is mounted.")
@@ -13143,6 +13747,10 @@ def _activate(state: TuiState, row: TuiRow) -> list[tuple]:
             return _start_check(state)
         if action in ("use", "zip") and state.browse_for == "from":
             chosen = state.browse_dir if action == "use" else row.value
+            refused = copy_source_refusal(chosen, state.dest)
+            if refused:
+                state.status = refused
+                return []
             if chosen not in state.from_folders:
                 state.from_folders.append(chosen)
             state.browse_for = "dest"
@@ -13177,14 +13785,16 @@ def _activate(state: TuiState, row: TuiRow) -> list[tuple]:
         if action == "quit":
             return tui_quit(state)
         if action == "folder":
-            return _open_folder_screen(state, state.dest, "chosen")
+            return _open_folder_screen(state, state.dest, "chosen", rebind=True)
         if action == "fromcard":
             return _open_from_browser(state)
         if action in ("misplaced", "unreadable"):
             return _push(state, action)
         if action == "systems" and state.cli_systems:
             # The check read only what --system named: it is read again for
-            # every system, those named ticked.
+            # every system, those named ticked. Its exact plan is kept, to
+            # come back to when the ticks do not change (_back).
+            state.widened_from = {field: getattr(state, field) for field in _CHECK_FIELDS}
             state.keep_ticked = {row["system"] for row in state.systems}
             state.cli_systems, state.widen = [], True
             return _start_check(state)
@@ -13465,7 +14075,7 @@ def _setup_matches(plat: str, systems: list[str], needle: str,
                if _device_found(device, needle)]
     named = [system for system in systems if _name_found(system, needle) or any(
         _device_found(device, needle) for device in _SETUP_DEVICES.get(system, ()))]
-    return devices + named or None
+    return _computer_named(plat, needle) + devices + named or None
 
 
 def _system_matches(name: str, needle: str) -> list[str] | None:
@@ -13517,8 +14127,35 @@ def _found_device(setups: list, mounted: set, plat: str, system: str) -> Path |
                  and detected_os(name, path) == system), None)
 
 
+def setup_folder(os_type: str, setups: list, mounted: set, plat: str,
+                 system: str) -> tuple[Path | None, str]:
+    """(folder, kind) offered for a setup taken from the setup list, on the
+    screen's Which folder? and at line mode's folder question. kind is
+    "found" (detected here), "share" (a system a computer reaches on its
+    SHARE drive, no folder of its own here) or "usual" (its built-in one).
+
+    The folder detected here comes before the built-in one: line mode, by
+    o then RetroArch, offered ~/.config/retroarch/system and filled it,
+    when the retroarch.cfg found here names another folder. A card in a
+    reader is its own system's, never this computer's RetroArch, and a
+    system that runs from its card is found on the device itself only."""
+    bound = card_bound(system, plat)
+    if bound:
+        found = _found_device(setups, mounted, plat, bound[0])
+        return found, "found" if found else "usual"
+    found = next((path for name, path, _label in setups if name == plat
+                  and (name, path) not in mounted), None)
+    if found is not None:
+        return found, "found"
+    if plat in _SHARE_FOLDERS:
+        # /userdata/bios exists on the Batocera machine alone: a computer
+        # sees its share drive or its network share.
+        return None, "share"
+    return _default_dest(os_type, plat), "usual"
+
+
 def setup_list(setups: list, mounted: set, needle: str = "",
-               os_type: str = "") -> list[TuiRow]:
+               os_type: str = "", serves: frozenset = frozenset()) -> list[TuiRow]:
     """The setup list, the screen's and the numbered one of line mode: each
     platform, then each system that runs from its SD card, with what the
     filter named. setups and mounted are what detection found here, as
@@ -13532,14 +14169,18 @@ def setup_list(setups: list, mounted: set, needle: str = "",
     "Onion, SD card" beside "RetroArch files" said nothing to a Miyoo Mini
     owner. With nothing found here the card rows come right after RetroArch
     (_cards_first). Line mode listed them in another order, and its 8 was
-    the screen's 19.
+    the screen's 19. serves, when not empty, keeps the setups that read
+    the file list given (LocalSources.serves).
     """
-    cards_setups = card_setups()
-    cards = {setup.name for setup in cards_setups}
+    every_card = card_setups()
+    cards = {setup.name for setup in every_card}
+    cards_setups = [setup for setup in every_card if not serves or setup.plat in serves]
     systems = _systems_reading()
     desktop: list[TuiRow] = []
     handheld: list[tuple[str, TuiRow]] = []
     for plat in AVAILABLE_PLATFORMS:
+        if serves and plat not in serves:
+            continue
         others = [name for name in systems.get(plat, []) if name not in cards]
         named = _setup_matches(plat, others, needle, os_type)
         if named is None:
@@ -13574,17 +14215,52 @@ def setup_list(setups: list, mounted: set, needle: str = "",
     handheld.sort(key=lambda item: item[0].casefold())
     cards_rows = [row for _label, row in handheld]
     if _cards_first(setups):
-        lead = [row for row in desktop if row.value == "retroarch"]
-        rest = [row for row in desktop if row.value != "retroarch"]
+        # The setups this computer runs lead, before the cards: RetroBat
+        # was row 27 of 34 on Windows, after 23 SD card rows.
+        here = _DESKTOP_LEAD.get(os_type, ("retroarch",))
+        lead = sorted((row for row in desktop if row.value in here),
+                      key=lambda row: here.index(row.value))
+        rest = [row for row in desktop if row.value not in here]
         return [*lead, *cards_rows, *rest]
     return [*desktop, *cards_rows]
 
 
+# The setups a computer runs, by its system, first in the setup list when
+# nothing was found here. RetroBat runs on Windows alone (retrobat.org), and
+# under WSL its folder is the Windows side's (_os_default_dests). EmuDeck has
+# a Windows edition (emudeck-we).
+_DESKTOP_LEAD: dict[str, tuple[str, ...]] = {
+    "windows": ("retroarch", "retrobat", "emudeck"),
+    "wsl": ("retroarch", "retrobat", "emudeck"),
+}
+
+# The computer systems people type in the setup filter, with the setups each
+# one runs: "windows" and "mac" matched nothing. RetroArch runs on the three
+# (retroarch.com), RetroBat on Windows only, EmuDeck has a Windows edition
+# and a Linux one (SteamOS), RetroDECK is a Linux Flatpak, BizHawk publishes
+# Windows and Linux builds, RetroPie runs on Debian and Ubuntu.
+_COMPUTER_SYSTEMS: dict[str, tuple[tuple[str, ...], tuple[str, ...]]] = {
+    "Windows": (("windows",), ("retroarch", "retrobat", "emudeck", "bizhawk")),
+    "macOS": (("macos", "mac", "osx", "macbook"), ("retroarch",)),
+    "Linux": (("linux", "ubuntu", "debian", "steamos"),
+              ("retroarch", "emudeck", "retrodeck", "bizhawk", "retropie")),
+}
+
+
+def _computer_named(plat: str, needle: str) -> list[str]:
+    """The computer systems the filter names that run plat."""
+    key = _device_key(needle)
+    if len(key) < 3:
+        return []
+    return [name for name, (words, plats) in _COMPUTER_SYSTEMS.items()
+            if plat in plats and any(word.startswith(key) for word in words)]
+
+
 def _platform_rows(state: TuiState) -> list[TuiRow]:
     """The setup list of the screen, under its filter row (setup_list)."""
     return [_filter_row(state), *setup_list(
         state.setups, state.mounted_setups, state.filters.get("platforms", ""),
-        state.os_type)]
+        state.os_type, LOCAL.serves())]
 
 
 def _cards_first(setups: list) -> bool:
@@ -13622,7 +14298,7 @@ def _option(state: TuiState, action: str, step: int) -> list[tuple]:
     elif action in ("regions", "command"):
         return _push(state, action)
     elif action == "folder":
-        return _open_folder_screen(state, state.dest, "chosen")
+        return _open_folder_screen(state, state.dest, "chosen", rebind=True)
     elif action == "from" and step < 0:
         # Said, and the screen stays: Back to the plan counts again.
         if state.from_folders:
@@ -13865,6 +14541,11 @@ def tui_update(state: TuiState, key: TuiKey) -> list[tuple]:
     screen = state.screen
     if screen == "path":
         return _path_key(state, key)
+    if state.editing and key.name == "f1":
+        # ? is typed into the filter, F1 opens the help: it ended the typing
+        # and opened nothing. The typing goes on once the help closes.
+        state.help = True
+        return []
     if state.editing:
         return _filter_key(state, key)
     if state.pad == "miyoo":
@@ -13927,7 +14608,10 @@ def tui_update(state: TuiState, key: TuiKey) -> list[tuple]:
     elif (name == "tab" or char == "o") and screen in ("plan", "systems", "confirm"):
         return _push(state, "options")
     elif char == "/" and any(item.action == "filter" for item in rows):
+        # The focus goes to the field typed into: it stayed on None, and the
+        # bar named None's keys while letters went into the filter.
         state.editing = screen
+        state.focus[screen] = next(i for i, item in enumerate(rows) if item.action == "filter")
         return []
     elif screen == "regions" and (name == "enter" or char == " "):
         return _activate(state, row)
@@ -14018,6 +14702,8 @@ def _take_event(state: TuiState, event: dict) -> None:
         state.scanned.append(event)
     elif kind == "unreadable" and state.run == "check":
         state.unreadable.append(event)
+    elif kind == "choices" and state.run == "check":
+        state.choices = list(event["systems"])
     elif kind == "saves" and state.run == "check":
         state.saves = event
     elif kind == "saves" and state.run in ("confirm", "preview"):
@@ -14224,12 +14910,22 @@ _ROW_VERBS = {
     "jobs": "Change", "retry": "Try again", "back": "Back", "stay": "Stay",
     "fromcard": "Choose", "from": "Add a folder", "misplaced": "Show", "zip": "Copy from it",
     "unreadable": "Show", "exit": "Exit", "addapp": "Put it on the card",
-    "cardsystem": "Choose", "rescan": "Look again", "elsewhere": "Choose",
+    "cardsystem": "Choose", "rescan": "Look again", "elsewhere": "Choose", "drive": "Choose",
 }
 
 
 def _row_line(row: TuiRow, focused: bool, width: int) -> TuiLine:
     left = ("> " if focused else "  ") + row.label
+    if row.keep_right and row.right:
+        whole = width - cell_width(left) - 2
+        forms = (row.right, *row.narrow)
+        right = next((form for form in forms if cell_width(form) <= whole), "")
+        if not right:
+            right = forms[-1]
+            room = width - cell_width(right) - 2
+            if room >= 8:
+                left = fit(left, room - 3).rstrip() + "..."
+        return _styled(_columns(left, right, width), "focus" if focused else row.style)
     if row.narrow or row.cut:
         # The name first: the longest right-hand form that leaves it whole,
         # else none at all when that is what keeps it whole. Nintendo Game
@@ -14478,6 +15174,9 @@ def _plan_lines(check: dict, dest: Path | None, state: TuiState) -> list:
     ]
     if state.facts.get("writable") is False:
         lines.append("You cannot write to this folder: choose another one.")
+    # Said again where it is the BIOS folder: the browser said it, and the
+    # plan named ~ alone.
+    lines += filter(None, [_no_setup_reads(state, dest)])
     counts = (f"{check['present']} in place, {check['missing']} missing, "
               f"{wrong} wrong {'copy' if wrong == 1 else 'copies'}")
     lines.append(counts)
@@ -14505,8 +15204,7 @@ def _plan_lines(check: dict, dest: Path | None, state: TuiState) -> list:
     if free is not None:
         lines.append(f"Free space: {format_size(free)}")
         if check["bytes_needed"] > free:
-            lines.append(f"Not enough free space: {format_size(check['bytes_needed'])} "
-                         "needed. Free some, or choose another folder.")
+            lines.append(space_words(check["bytes_needed"], free, _on_its_card(state)))
     backup = wrong and not (offline and not copied)
     misplaced = _tui_misplaced(state) if check is state.check else []
     if misplaced:
@@ -14523,17 +15221,9 @@ def _plan_lines(check: dict, dest: Path | None, state: TuiState) -> list:
         lines.insert(count_at, f"The {wrong} wrong {'copy' if wrong == 1 else 'copies'} "
                      f"{'is' if wrong == 1 else 'are'} replaced, the old "
                      f"{'one' if wrong == 1 else 'ones'} kept in a backup folder.")
-    if state.facts.get("writable") is False:
-        if state.os_type == "windows":
-            lines.append("Or run the installer as an administrator.")
-        else:
-            # sudo changes the home folder, and with it what is detected:
-            # the folder is named so root writes here.
-            hint = Invocation()
-            hint.os_type = state.os_type
-            hint.options = [("--offline", None)] if offline_requested() else []
-            lines.append("Or run it as root, this folder named: "
-                         + hint.command(state.platform, dest, elevated=True))
+    if state.facts.get("writable") is False and dest is not None:
+        lines += write_remedy(dest, state.platform, tui_hint(state),
+                              state.pad not in TUI_PAD_ROUTES)
     if check is state.check:
         lines += _scan_lines(state)
     if check.get("not_installable"):
@@ -14601,7 +15291,7 @@ def _unplaced_lines(summary: dict | None, state: TuiState,
 def _view_setup(state: TuiState, width: int, height: int) -> tuple:
     rows = tui_rows(state)
     focus = rows[min(state.focus.get("setup", 0), len(rows) - 1)]
-    after = ([f"BIOS folder: {shown_path(state.setups[focus.value][1])}"]
+    after = ([f"BIOS folder: {shown_path(setup_bios_folder(*state.setups[focus.value][:2]))}"]
              if focus.action == "setup" else [])
     before = ["Found on this machine:" if state.setups else "Nothing was found here."]
     status = [state.status] if state.status else []
@@ -14806,10 +15496,15 @@ def _view_plan(state: TuiState, width: int, height: int) -> tuple:
         lines[0] = _styled(f"About {_plural(len(chosen), 'file')}, "
                            f"{format_size(sum(e['size'] for e in chosen))}, for "
                            f"{len(state.ticked)} of {len(state.systems)} systems", "title")
+        # The in place and missing counts are the whole list's: under an
+        # estimate for some systems they read as its own.
+        whole = (f"{check['present']} in place, {check['missing']} missing, "
+                 f"{check['wrong_hash']} wrong ")
+        lines = [line for line in lines if not str(line).startswith(whole)]
     lines[2:2] = choice
     if state.cli_systems and state.systems:
         # Named on the command line: said, and widened by Choose systems.
-        lines[2:2] = [f"For {len(state.systems)} of {len(tui_choices(state)['systems'])} "
+        lines[2:2] = [f"For {len(state.systems)} of {len(tui_systems(state))} "
                       "systems (--system)."]
     if state.card_note and state.card_note != state.status:
         # Under the folder it is about: a stick no file names, taken for
@@ -14960,7 +15655,9 @@ def _pager_items(state: TuiState) -> list:
     elif state.dry is None:
         items = state.tail or ["The preview did not finish."]
     else:
-        items = [f"{_plural(_needed(state.dry), 'file')} to download, "
+        # From a pack nothing is downloaded, as the plan says.
+        verb = "to install from the pack" if LOCAL.pack is not None else "to download"
+        items = [f"{_plural(_needed(state.dry), 'file')} {verb}, "
                  f"{format_size(state.dry['bytes_needed'])}. Nothing is written.", ""]
         items += [f"{_STATE_WORDS.get(event['state'], event['state']):<10} "
                   f"{format_size(event['size']):>9}  {event['dest']}"
@@ -14970,22 +15667,30 @@ def _pager_items(state: TuiState) -> list:
     return items
 
 
+def _scroll(state: TuiState, items: list, width: int, height: int) -> tuple:
+    """The bar's Scroll entry, only for a text taller than the screen: it
+    was named over nine lines that fit, Down pressed 13 times doing nothing."""
+    return ("Up/Down Scroll",) if _pager_starts(state, items, width)[-1] > height else ()
+
+
 def _view_preview(state: TuiState, width: int, height: int) -> tuple:
     # The count and the blank line above the files are not among them.
     lead = 2 if state.dry is not None and not state.running else 0
-    return ("Preview", _pager(state, width, height, _pager_items(state), lead),
-            ("A/Enter Back", "Up/Down Scroll"))
+    items = _pager_items(state)
+    return ("Preview", _pager(state, width, height, items, lead),
+            ("A/Enter Back", *_scroll(state, items, width, height)))
 
 
 def _view_unreadable(state: TuiState, width: int, height: int) -> tuple:
-    return ("Files that could not be read",
-            _pager(state, width, height, _pager_items(state)),
-            ("A/Enter Back", "Up/Down Scroll"))
+    items = _pager_items(state)
+    return ("Files that could not be read", _pager(state, width, height, items),
+            ("A/Enter Back", *_scroll(state, items, width, height)))
 
 
 def _view_misplaced(state: TuiState, width: int, height: int) -> tuple:
-    return ("Files in the wrong place", _pager(state, width, height, _pager_items(state), 2),
-            ("A/Enter Back", "Up/Down Scroll"))
+    items = _pager_items(state)
+    return ("Files in the wrong place", _pager(state, width, height, items, 2),
+            ("A/Enter Back", *_scroll(state, items, width, height)))
 
 
 def _view_command(state: TuiState, width: int, height: int) -> tuple:
@@ -15009,8 +15714,9 @@ def _view_confirm(state: TuiState, width: int, height: int) -> tuple:
             lines.insert(0, "Counted again for your choices. Nothing is written before "
                          "Install.")
     if not any(row.action == "install" for row in tui_rows(state)) and state.dry is not None:
-        # Back alone: one Back on the bar, and no word of an Install.
-        return ("Confirm", _compose(state, width, height, lines, tui_rows(state)),
+        # Back alone: one Back on the bar, and no word of an Install. Titled
+        # for what it is: "Confirm" over nothing to confirm.
+        return ("Nothing to install", _compose(state, width, height, lines, tui_rows(state)),
                 ("A/Enter Back", "? Help"))
     return ("Confirm", _compose(state, width, height, lines, tui_rows(state)),
             ("A/Enter Install", "B/Esc Back", "? Help"))
@@ -15232,7 +15938,8 @@ def tui_outcome(state: TuiState) -> tuple[str, list[str]]:
     if installed + up_to_date:
         lines += _saves_lines(state, state.done_saves)
     if space:
-        lines.append("Free some space, or run again and choose another folder.")
+        lines.append("Free some space on the card, then run again." if _on_its_card(state)
+                     else "Free some space, or run again and choose another folder.")
     causes: dict[str, list[str]] = {}
     for failure in failed:
         causes.setdefault(failure["reason"], []).append(failure["dest"])
@@ -15249,8 +15956,14 @@ def tui_outcome(state: TuiState) -> tuple[str, list[str]]:
             shown += 1
     if shown > 20:
         lines.append(f"  ... and {shown - 20} more")
+    if state.dest is not None and any(failure["reason"] == NOT_WRITABLE
+                                      for failure in failed):
+        # The plan's own advice: the result offered nothing after 22 files
+        # failed on a read-only card.
+        lines += write_remedy(state.dest, state.platform, tui_hint(state),
+                              state.pad not in TUI_PAD_ROUTES)
     if not summary and not space and state.code != 130:
-        # A stop asked for (Ctrl-C, Start+Select, the window closed) is said
+        # A stop asked for (Ctrl-C, Select+Start, the window closed) is said
         # by the line above: the log's last lines are for a run that died.
         lines += [f"  {line}" for line in state.tail[-8:]]
     run = Invocation()
@@ -15308,7 +16021,8 @@ def _view_result(state: TuiState, width: int, height: int) -> tuple:
                 ("A/Enter Choose", "B/Esc Exit"))
     if state.app_running:
         return (title, _pager(state, width, height, lines), ("Writing to the card...",))
-    return (title, _pager(state, width, height, lines), ("A/Enter Exit", "Up/Down Scroll"))
+    return (title, _pager(state, width, height, lines),
+            ("A/Enter Exit", *_scroll(state, lines, width, height)))
 
 
 def _view_error(state: TuiState, width: int, height: int) -> tuple:
@@ -15472,6 +16186,10 @@ def tui_view(state: TuiState, cols: int, rows: int) -> list[str]:
     primary = _primary(state) if not state.help and hint[0].startswith("A/Enter") else None
     if primary:
         hint = (primary, *hint[1:])
+    if state.editing == state.screen and not state.help:
+        # Typing: Space and ? go into the filter, so the bar names the two
+        # keys that end it, not Tick and Help.
+        hint = ("Enter Done", "Esc Clear")
     hint = _route_hint(state, _back_hint(state, hint))
     lines = [_styled(fit(f" RetroBIOS: {title}", cols), "title"), _styled("")]
     lines += [_styled(fit(" " + line, cols), line.style) for line in body[:height]]
@@ -15552,7 +16270,8 @@ def found_setups(os_type: str) -> tuple[list[tuple[str, Path, str]], set]:
         if card and (card[0], card[1]) not in found and card[2] not in here:
             _DETECTED_OS.setdefault((card[0], card[1]), card[2])
             mounted.add((card[0], card[1]))
-            setups.append((card[0], card[1], f"{card[2]} SD card ({_mount_name(mount)})"))
+            kind = "SHARE drive" if drive_kind(card) != "card" else "SD card"
+            setups.append((card[0], card[1], f"{card[2]} {kind} ({_mount_name(mount)})"))
     return tell_apart(setups), mounted
 
 
@@ -15565,7 +16284,10 @@ def tui_start(
     state.cli_systems = list(args.system or [])
     state.regions = resolve_regions(args.region) if args.region else []
     state.cli_regions = list(state.regions)
-    state.from_folders = [Path(folder).absolute() for folder in getattr(args, "from") or []]
+    # Resolved as written, .. taken out: the copy browser opened on t/.., and
+    # a link stays the link typed (os.path.normpath reads no folder).
+    state.from_folders = [Path(os.path.normpath(Path(folder).absolute()))
+                          for folder in getattr(args, "from") or []]
     state.cores = list(dict.fromkeys(
         token.strip() for value in args.core or [] for token in value.split(",")
         if token.strip()))
@@ -15695,6 +16417,20 @@ class _EngineRun:
     def running(self) -> bool:
         return self.proc.poll() is None
 
+    def pause(self, stopped: bool) -> None:
+        """Stop the child where it is, or let it carry on. It runs in a
+        session of its own, which a Ctrl-Z stopping the terminal's process
+        group never reaches: an install went on writing for as long as the
+        screen was suspended."""
+        if os.name == "nt" or not self.running():
+            return
+        try:
+            os.killpg(self.proc.pid, signal.SIGSTOP if stopped  # type: ignore[attr-defined]
+                      else signal.SIGCONT)  # type: ignore[attr-defined]
+        except ProcessLookupError:
+            # It ended between the two calls: there is nothing to stop.
+            return
+
     def interrupt(self, from_key: bool) -> None:
         if not self.running():
             return
@@ -16028,6 +16764,28 @@ def _closing_lines(state: TuiState) -> list[str]:
     return ["RetroBIOS: stopped. Nothing was installed."]
 
 
+def tui_suspend(runs: list[_EngineRun], whole: bool) -> None:
+    """Stop the screen and the runs it started until fg continues them.
+
+    whole is a Ctrl-Z typed on the screen, which stops what the terminal's
+    Ctrl-Z stops: every process of the foreground group. The installer
+    stopping alone left install.sh, run as `sh install.sh` or `curl | sh`,
+    waiting on it, and the shell never got its prompt back. A kill -TSTP
+    sent to the installer stops the installer alone. The runs are stopped
+    either way, an install having gone on writing behind a stopped screen.
+    """
+    for run in runs:
+        run.pause(True)
+    if whole:
+        # SIGSTOP and not SIGTSTP: a group no shell watches over (the
+        # installer started on a terminal of its own) discards SIGTSTP.
+        os.killpg(os.getpgrp(), signal.SIGSTOP)  # type: ignore[attr-defined]
+    else:
+        os.kill(os.getpid(), signal.SIGSTOP)  # type: ignore[attr-defined]
+    for run in runs:
+        run.pause(False)
+
+
 def run_tui(args: argparse.Namespace) -> int:
     """The full-screen interface, until it closes: the exit code it ends with."""
     flags = {"interrupt": False, "resized": False, "suspend": False, "resume": False,
@@ -16038,7 +16796,7 @@ def run_tui(args: argparse.Namespace) -> int:
         flags["term"] = flags["term"] or signum
 
     # Before the start, whose detection and pack opening take seconds on a
-    # handheld: a Start+Select then ended on the default action, without a
+    # handheld: a Select+Start then ended on the default action, without a
     # word or the terminal put back.
     for name in ("SIGTERM", "SIGHUP"):
         number = getattr(signal, name, None)
@@ -16074,7 +16832,7 @@ def run_tui(args: argparse.Namespace) -> int:
     inbox: queue.Queue = queue.Queue()
     current: list[_EngineRun] = []
     written: dict[str, Path] = {}
-    # Start+Select on a handheld is gptokeyb's pkill: SIGTERM, then SIGKILL
+    # Select+Start on a handheld is gptokeyb's pkill: SIGTERM, then SIGKILL
     # 3 s later. The install gets 2 s to say what it wrote.
     terminating = {"signal": 0, "deadline": 0.0}
     ignore_interrupt_until = [0.0]
@@ -16156,11 +16914,12 @@ def run_tui(args: argparse.Namespace) -> int:
             perform(effects)
         while state.exit_code is None:
             if flags["suspend"]:
-                # Stopped from outside (kill -TSTP): the shell gets its
-                # terminal back as it lent it, and the screen returns on fg.
+                # The shell gets its terminal back as it lent it, and the
+                # screen returns on fg.
+                whole = flags["suspend"] == "key"
                 flags["suspend"] = False
                 terminal.leave()
-                os.kill(os.getpid(), signal.SIGSTOP)  # type: ignore[attr-defined]
+                tui_suspend(current, whole)
                 flags["resume"] = True
             if flags["resume"]:
                 flags["resume"] = False
@@ -16175,10 +16934,10 @@ def run_tui(args: argparse.Namespace) -> int:
             terminal.draw(tui_view(state, cols, rows), cols)
             for key in terminal.keys(TUI_FRAME):
                 if key.name == "ctrl-z":
-                    # ISIG is off, so Ctrl-Z comes as a key: it stops the run
-                    # as kill -TSTP does, where the system has job control.
+                    # ISIG is off, so Ctrl-Z comes as a key: it stops what
+                    # the terminal's would, where the system has job control.
                     if hasattr(signal, "SIGSTOP"):
-                        flags["suspend"] = True
+                        flags["suspend"] = "key"
                         break
                     continue
                 pressed = True
diff --git a/install.sh b/install.sh
index 27bcceaf4..627f2a8c4 100755
--- a/install.sh
+++ b/install.sh
@@ -18,7 +18,7 @@ esac
 TEMP_INSTALLER=""
 TEMP_DIRECTORY=""
 DEFAULT_INSTALL_URL="https://raw.githubusercontent.com/Abdess/retrobios/main/install.py"
-DEFAULT_INSTALL_SHA256="b3363820bb97bec559287f72d9712281e22307387fa752b663f6f7af023a0e33"
+DEFAULT_INSTALL_SHA256="50074085810dde029db4cbbc7b520e34d4e70d58fe524570ac2821501772e7d8"
 MAX_INSTALLER_BYTES=2097152
 
 cleanup() {
diff --git a/install/launchers/index.json b/install/launchers/index.json
index c943862b0..a9ddae10f 100644
--- a/install/launchers/index.json
+++ b/install/launchers/index.json
@@ -27,8 +27,8 @@
         {
           "dest": "roms/ports/retrobios/install.py",
           "repo_path": "install.py",
-          "size": 734772,
-          "sha256": "b3363820bb97bec559287f72d9712281e22307387fa752b663f6f7af023a0e33",
+          "size": 774265,
+          "sha256": "50074085810dde029db4cbbc7b520e34d4e70d58fe524570ac2821501772e7d8",
           "executable": false
         },
         {
@@ -71,8 +71,8 @@
     "muos": {
       "archive": {
         "dest": "ARCHIVE/RetroBIOS.muxapp",
-        "size": 787321,
-        "sha256": "45366e0a225d8143f7b359fd04cd6b341a21f43057b7d5a41ad8f734f765f142"
+        "size": 826814,
+        "sha256": "2f31cccaa60c3d75dcaf7b82b1db21003c8a26965982f224790aceec6708b3da"
       },
       "members": [
         {
@@ -92,8 +92,8 @@
         {
           "name": "RetroBIOS/install.py",
           "repo_path": "install.py",
-          "size": 734772,
-          "sha256": "b3363820bb97bec559287f72d9712281e22307387fa752b663f6f7af023a0e33",
+          "size": 774265,
+          "sha256": "50074085810dde029db4cbbc7b520e34d4e70d58fe524570ac2821501772e7d8",
           "executable": false
         },
         {
@@ -166,8 +166,8 @@
         {
           "dest": ".config/modules/retrobios/install.py",
           "repo_path": "install.py",
-          "size": 734772,
-          "sha256": "b3363820bb97bec559287f72d9712281e22307387fa752b663f6f7af023a0e33",
+          "size": 774265,
+          "sha256": "50074085810dde029db4cbbc7b520e34d4e70d58fe524570ac2821501772e7d8",
           "executable": false
         },
         {
diff --git a/schemas/install-events.schema.json b/schemas/install-events.schema.json
index 180fa24b3..2ffaefdfe 100644
--- a/schemas/install-events.schema.json
+++ b/schemas/install-events.schema.json
@@ -15,6 +15,7 @@
         "detect",
         "error",
         "scanned",
+        "choices",
         "file",
         "system",
         "checking",
@@ -50,6 +51,9 @@
     {
       "$ref": "#/$defs/scanned"
     },
+    {
+      "$ref": "#/$defs/choices"
+    },
     {
       "$ref": "#/$defs/file"
     },
@@ -240,6 +244,29 @@
         }
       }
     },
+    "choices": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "event",
+        "platform",
+        "systems"
+      ],
+      "properties": {
+        "event": {
+          "const": "choices"
+        },
+        "platform": {
+          "type": "string"
+        },
+        "systems": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
     "file": {
       "type": "object",
       "additionalProperties": false,
diff --git a/schemas/pack-manifest.schema.json b/schemas/pack-manifest.schema.json
index 54a36b23a..e836ccd33 100644
--- a/schemas/pack-manifest.schema.json
+++ b/schemas/pack-manifest.schema.json
@@ -22,7 +22,8 @@
           "md5": { "type": "string", "pattern": "^[a-f0-9]{32}$" },
           "size": { "type": "integer", "minimum": 0 },
           "status": { "enum": ["verified", "verified_md5", "verified_rebuild", "verified_data", "verified_members", "untracked"] },
-          "name": { "type": "string" }
+          "name": { "type": "string" },
+          "systems": { "type": "array", "items": { "type": "string", "minLength": 1 } }
         }
       }
     },
@@ -37,6 +38,11 @@
         "errors": { "type": "integer", "minimum": 0 }
       }
     },
-    "errors": { "type": "array", "items": { "type": "string" } }
+    "errors": { "type": "array", "items": { "type": "string" } },
+    "system_titles": { "type": "object", "additionalProperties": { "type": "string" } },
+    "system_names": {
+      "type": "object",
+      "additionalProperties": { "type": "array", "items": { "type": "string" } }
+    }
   }
 }
diff --git a/scripts/generate_installer_doc.py b/scripts/generate_installer_doc.py
index ea89da6a6..f96ec9c4d 100644
--- a/scripts/generate_installer_doc.py
+++ b/scripts/generate_installer_doc.py
@@ -170,7 +170,8 @@ def render(page: str) -> str:
         if name not in writers:
             raise MissingProse(f"no table is written for the marker {name!r}")
         seen.append(name)
-        return f"{match.group('open')}\n{writers[name](match.group('body'))}\n{match.group('close')}"
+        table = writers[name](match.group("body"))
+        return f"{match.group('open')}\n{table}\n{match.group('close')}"
 
     text = BLOCK.sub(write, page)
     absent = sorted(set(writers) - set(seen))
diff --git a/scripts/generate_pack.py b/scripts/generate_pack.py
index a568f0e80..69b057a27 100644
--- a/scripts/generate_pack.py
+++ b/scripts/generate_pack.py
@@ -2802,6 +2802,10 @@ def _run_platform_packs(
 ) -> None:
     """Generate ZIP packs for platform groups and verify."""
     variants = ALL_VARIANTS if args.all_variants else ((args.source, args.required_only),)
+    registry_path = os.path.join(args.platforms_dir, "_registry.yml")
+    # Per pack, the systems each of its files is for, written into its
+    # manifest.json once the pack is verified (pack_systems).
+    systems_for: dict[str, dict] = {}
 
     failed: list[str] = []
     for source, required_only in variants:
@@ -2902,6 +2906,20 @@ def _run_platform_packs(
                 # the output directory already held and exit 0.
                 if not _produced(args.split, zip_path, zip_paths):
                     failed.append(representative)
+                elif zip_path and not system_filter:
+                    # The install list of the same choices names each file's
+                    # systems: the pack records them, so a pack alone (a
+                    # handheld without Wi-Fi) can be narrowed by system.
+                    systems_for[os.path.basename(zip_path)] = pack_systems(generate_manifest(
+                        representative, args.platforms_dir, db, args.bios_dir,
+                        registry_path, emulators_dir=args.emulators_dir,
+                        zip_contents=zip_contents, emu_profiles=emu_profiles,
+                        target_cores=tc, source=source,
+                        regions=getattr(args, "regions", None), target_name=named_target,
+                        offline=args.offline, required_only=required_only,
+                        data_registry=data_registry,
+                        no_game_data=getattr(args, "no_game_data", False),
+                    ))
 
     print("\nVerifying packs and generating manifests...")
     skip_conf = bool(system_filter or args.split)
@@ -2910,6 +2928,7 @@ def _run_platform_packs(
         db,
         platforms_dir=args.platforms_dir,
         emulators_dir=args.emulators_dir,
+        pack_systems_by_name=systems_for,
         skip_conformance=skip_conf,
         data_registry=data_registry,
         regions=getattr(args, "regions", None),
@@ -4731,6 +4750,37 @@ def _manifest_core_index(
 
 
 
+def pack_systems(install_manifest: dict) -> dict:
+    """What a pack's manifest.json records of its systems, from the install
+    list built with the same choices: each file's systems, by its path in
+    the pack, and the names a person reads for them.
+
+    A pack recorded none: the installer refused --system with a pack alone
+    ("the file list comes from an older release") and offered no Choose
+    systems, the route of a handheld without Wi-Fi.
+    """
+    return {
+        "files": {entry["dest"]: list(entry.get("systems") or [])
+                  for entry in install_manifest.get("files", []) if "systems" in entry},
+        "system_titles": dict(install_manifest.get("system_titles") or {}),
+        "system_names": dict(install_manifest.get("system_names") or {}),
+    }
+
+
+def annotate_pack_systems(manifest: dict, systems: dict | None) -> None:
+    """Write pack_systems into a pack's manifest: a systems list on each
+    file the install list names, the titles and names beside."""
+    if not systems:
+        return
+    for entry in manifest.get("files", []):
+        held = systems["files"].get(entry["path"])
+        if held is not None:
+            entry["systems"] = held
+    for key in ("system_titles", "system_names"):
+        if systems.get(key):
+            manifest[key] = systems[key]
+
+
 def inject_manifest(zip_path: str, manifest: dict) -> None:
     """Inject manifest.json into an existing ZIP pack.
 
@@ -4952,9 +5002,13 @@ def verify_and_finalize_packs(
     target_name: str | None = None,
     emulators_dir: str = "emulators",
     no_game_data: bool = False,
+    pack_systems_by_name: dict[str, dict] | None = None,
 ) -> bool:
     """Verify all packs, inject manifests, generate SHA256SUMS.
 
+    pack_systems_by_name gives, per pack file name, the systems its
+    manifest.json records (pack_systems).
+
     Two-stage verification:
     1. Hash check against database.json (integrity)
     2. Extract + verify against platform config (conformance)
@@ -4994,6 +5048,7 @@ def verify_and_finalize_packs(
                 print(f"    ERROR: {err}")
             all_ok = False
             failing.append(name)
+        annotate_pack_systems(manifest, (pack_systems_by_name or {}).get(name))
         inject_manifest(zip_path, manifest)
 
         # Stage 2: platform conformance (extract + verify)
diff --git a/tests/fixtures/tui/installing-120x40.txt b/tests/fixtures/tui/installing-120x40.txt
index 1f81f09d4..ff7651b12 100644
--- a/tests/fixtures/tui/installing-120x40.txt
+++ b/tests/fixtures/tui/installing-120x40.txt
@@ -4,7 +4,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B, Ctrl-C or Start+Select stops. What is done stays done.
+ B, Ctrl-C or Select+Start stops. What is done stays done.
 
  FAILED scph5500.bin (HTTP 404)
  ok     gba_bios.bin
diff --git a/tests/fixtures/tui/installing-40x12.txt b/tests/fixtures/tui/installing-40x12.txt
index ff117ddb7..5750b4633 100644
--- a/tests/fixtures/tui/installing-40x12.txt
+++ b/tests/fixtures/tui/installing-40x12.txt
@@ -4,7 +4,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B, Ctrl-C or Start+Select stops. What
+ B, Ctrl-C or Select+Start stops. What
    is done stays done.
 
  FAILED scph5500.bin (HTTP 404)
diff --git a/tests/fixtures/tui/installing-40x15.txt b/tests/fixtures/tui/installing-40x15.txt
index 1cb62307e..51aeca7c0 100644
--- a/tests/fixtures/tui/installing-40x15.txt
+++ b/tests/fixtures/tui/installing-40x15.txt
@@ -4,7 +4,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B, Ctrl-C or Start+Select stops. What
+ B, Ctrl-C or Select+Start stops. What
    is done stays done.
 
  FAILED scph5500.bin (HTTP 404)
diff --git a/tests/fixtures/tui/installing-80x24.txt b/tests/fixtures/tui/installing-80x24.txt
index 77f015602..fdd275588 100644
--- a/tests/fixtures/tui/installing-80x24.txt
+++ b/tests/fixtures/tui/installing-80x24.txt
@@ -4,7 +4,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B, Ctrl-C or Start+Select stops. What is done stays done.
+ B, Ctrl-C or Select+Start stops. What is done stays done.
 
  FAILED scph5500.bin (HTTP 404)
  ok     gba_bios.bin
diff --git a/tests/fixtures/tui/preview-120x40.txt b/tests/fixtures/tui/preview-120x40.txt
index 16259be57..b15d4161e 100644
--- a/tests/fixtures/tui/preview-120x40.txt
+++ b/tests/fixtures/tui/preview-120x40.txt
@@ -37,4 +37,4 @@
 
 
 
- A/Enter Back  Up/Down Scroll
+ A/Enter Back
diff --git a/tests/fixtures/tui/preview-40x12.txt b/tests/fixtures/tui/preview-40x12.txt
index 03ab2914e..507cf8b5d 100644
--- a/tests/fixtures/tui/preview-40x12.txt
+++ b/tests/fixtures/tui/preview-40x12.txt
@@ -9,4 +9,4 @@
  missing      16.0 KB  gba_bios.bin
 
 
- A/Enter Back  Up/Down Scroll
+ A/Enter Back
diff --git a/tests/fixtures/tui/preview-40x15.txt b/tests/fixtures/tui/preview-40x15.txt
index e5dff4e0d..110e70660 100644
--- a/tests/fixtures/tui/preview-40x15.txt
+++ b/tests/fixtures/tui/preview-40x15.txt
@@ -12,4 +12,4 @@
 
 
 
- A/Enter Back  Up/Down Scroll
+ A/Enter Back
diff --git a/tests/fixtures/tui/preview-80x24.txt b/tests/fixtures/tui/preview-80x24.txt
index 0c8588c25..b7a1586a4 100644
--- a/tests/fixtures/tui/preview-80x24.txt
+++ b/tests/fixtures/tui/preview-80x24.txt
@@ -21,4 +21,4 @@
 
 
 
- A/Enter Back  Up/Down Scroll
+ A/Enter Back
diff --git a/tests/fixtures/tui/result-120x40.txt b/tests/fixtures/tui/result-120x40.txt
index 16b4dffc4..de7a4e732 100644
--- a/tests/fixtures/tui/result-120x40.txt
+++ b/tests/fixtures/tui/result-120x40.txt
@@ -37,4 +37,4 @@
 
 
 
- A/Enter Exit  Up/Down Scroll
+ A/Enter Exit
diff --git a/tests/fixtures/tui/result-80x24.txt b/tests/fixtures/tui/result-80x24.txt
index ee5cd165f..9ec8aec5b 100644
--- a/tests/fixtures/tui/result-80x24.txt
+++ b/tests/fixtures/tui/result-80x24.txt
@@ -21,4 +21,4 @@
 
 
 
- A/Enter Exit  Up/Down Scroll
+ A/Enter Exit
diff --git a/tests/fixtures/tui/route-evmapy.txt b/tests/fixtures/tui/route-evmapy.txt
index c20a363e4..21813258f 100644
--- a/tests/fixtures/tui/route-evmapy.txt
+++ b/tests/fixtures/tui/route-evmapy.txt
@@ -766,7 +766,7 @@
  missing      16.0 KB  gba_bios.bin
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 40x15
  RetroBIOS: Preview
 
@@ -782,7 +782,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 80x24
  RetroBIOS: Preview
 
@@ -807,7 +807,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === command 40x12
  RetroBIOS: Command line
 
@@ -982,7 +982,7 @@
    retrobios-backup/2026-10-23_1200
  Details: /tmp/retrobios-x/install.log
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 40x15
  RetroBIOS: Finished with errors
 
@@ -998,7 +998,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 80x24
  RetroBIOS: Finished with errors
 
@@ -1023,7 +1023,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === error 40x12
  RetroBIOS: Something went wrong
 
diff --git a/tests/fixtures/tui/route-gptokeyb.txt b/tests/fixtures/tui/route-gptokeyb.txt
index 6fd42e2bb..cf6839b66 100644
--- a/tests/fixtures/tui/route-gptokeyb.txt
+++ b/tests/fixtures/tui/route-gptokeyb.txt
@@ -388,7 +388,7 @@
 
 
 
- Start+Select Quit  B Quit
+ Select+Start Quit  B Quit
 === checking 40x15
  RetroBIOS: Checking
 
@@ -404,7 +404,7 @@
 
 
 
- Start+Select Quit  B Quit
+ Select+Start Quit  B Quit
 === checking 80x24
  RetroBIOS: Checking
 
@@ -429,7 +429,7 @@
 
 
 
- Start+Select Quit  B Quit
+ Select+Start Quit  B Quit
 === plan 40x12
  RetroBIOS: RetroArch
 
@@ -766,7 +766,7 @@
  missing      16.0 KB  gba_bios.bin
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 40x15
  RetroBIOS: Preview
 
@@ -782,7 +782,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 80x24
  RetroBIOS: Preview
 
@@ -807,7 +807,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === command 40x12
  RetroBIOS: Command line
 
@@ -923,7 +923,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B or Start+Select stops. What is done
+ B or Select+Start stops. What is done
    stays done.
 
  FAILED scph5500.bin (HTTP 404)
@@ -936,7 +936,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B or Start+Select stops. What is done
+ B or Select+Start stops. What is done
    stays done.
 
  FAILED scph5500.bin (HTTP 404)
@@ -952,7 +952,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B or Start+Select stops. What is done stays done.
+ B or Select+Start stops. What is done stays done.
 
  FAILED scph5500.bin (HTTP 404)
  ok     gba_bios.bin
@@ -982,7 +982,7 @@
    retrobios-backup/2026-10-23_1200
  Details: /tmp/retrobios-x/install.log
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 40x15
  RetroBIOS: Finished with errors
 
@@ -998,7 +998,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 80x24
  RetroBIOS: Finished with errors
 
@@ -1023,7 +1023,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === error 40x12
  RetroBIOS: Something went wrong
 
diff --git a/tests/fixtures/tui/route-gptokeyb_muxterm.txt b/tests/fixtures/tui/route-gptokeyb_muxterm.txt
index 6fd42e2bb..cf6839b66 100644
--- a/tests/fixtures/tui/route-gptokeyb_muxterm.txt
+++ b/tests/fixtures/tui/route-gptokeyb_muxterm.txt
@@ -388,7 +388,7 @@
 
 
 
- Start+Select Quit  B Quit
+ Select+Start Quit  B Quit
 === checking 40x15
  RetroBIOS: Checking
 
@@ -404,7 +404,7 @@
 
 
 
- Start+Select Quit  B Quit
+ Select+Start Quit  B Quit
 === checking 80x24
  RetroBIOS: Checking
 
@@ -429,7 +429,7 @@
 
 
 
- Start+Select Quit  B Quit
+ Select+Start Quit  B Quit
 === plan 40x12
  RetroBIOS: RetroArch
 
@@ -766,7 +766,7 @@
  missing      16.0 KB  gba_bios.bin
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 40x15
  RetroBIOS: Preview
 
@@ -782,7 +782,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 80x24
  RetroBIOS: Preview
 
@@ -807,7 +807,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === command 40x12
  RetroBIOS: Command line
 
@@ -923,7 +923,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B or Start+Select stops. What is done
+ B or Select+Start stops. What is done
    stays done.
 
  FAILED scph5500.bin (HTTP 404)
@@ -936,7 +936,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B or Start+Select stops. What is done
+ B or Select+Start stops. What is done
    stays done.
 
  FAILED scph5500.bin (HTTP 404)
@@ -952,7 +952,7 @@
  528.0 KB of 1.0 MB
  128.9 KB/s, 0:04 left
  2 of 4 files
- B or Start+Select stops. What is done stays done.
+ B or Select+Start stops. What is done stays done.
 
  FAILED scph5500.bin (HTTP 404)
  ok     gba_bios.bin
@@ -982,7 +982,7 @@
    retrobios-backup/2026-10-23_1200
  Details: /tmp/retrobios-x/install.log
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 40x15
  RetroBIOS: Finished with errors
 
@@ -998,7 +998,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 80x24
  RetroBIOS: Finished with errors
 
@@ -1023,7 +1023,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === error 40x12
  RetroBIOS: Something went wrong
 
diff --git a/tests/fixtures/tui/route-keys.txt b/tests/fixtures/tui/route-keys.txt
index ac112d2ac..6ec4b4720 100644
--- a/tests/fixtures/tui/route-keys.txt
+++ b/tests/fixtures/tui/route-keys.txt
@@ -712,7 +712,7 @@
  missing      16.0 KB  gba_bios.bin
 
 
- Enter Back  Up/Down Scroll
+ Enter Back
 === preview 40x15
  RetroBIOS: Preview
 
@@ -728,7 +728,7 @@
 
 
 
- Enter Back  Up/Down Scroll
+ Enter Back
 === preview 80x24
  RetroBIOS: Preview
 
@@ -753,7 +753,7 @@
 
 
 
- Enter Back  Up/Down Scroll
+ Enter Back
 === command 40x12
  RetroBIOS: Command line
 
@@ -969,7 +969,7 @@
 
 
 
- Enter Exit  Up/Down Scroll
+ Enter Exit
 === error 40x12
  RetroBIOS: Something went wrong
 
diff --git a/tests/fixtures/tui/route-miyoo.txt b/tests/fixtures/tui/route-miyoo.txt
index 79b94f156..1b33c6920 100644
--- a/tests/fixtures/tui/route-miyoo.txt
+++ b/tests/fixtures/tui/route-miyoo.txt
@@ -766,7 +766,7 @@
  missing      16.0 KB  gba_bios.bin
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 40x15
  RetroBIOS: Preview
 
@@ -782,7 +782,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === preview 80x24
  RetroBIOS: Preview
 
@@ -807,7 +807,7 @@
 
 
 
- A Back  Up/Down Scroll
+ A Back
 === command 40x12
  RetroBIOS: Command line
 
@@ -982,7 +982,7 @@
    retrobios-backup/2026-10-23_1200
  Details: /tmp/retrobios-x/install.log
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 40x15
  RetroBIOS: Finished with errors
 
@@ -998,7 +998,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === result 80x24
  RetroBIOS: Finished with errors
 
@@ -1023,7 +1023,7 @@
 
 
 
- A Exit  Up/Down Scroll
+ A Exit
 === error 40x12
  RetroBIOS: Something went wrong
 
diff --git a/tests/fixtures/tui/route-muxterm.txt b/tests/fixtures/tui/route-muxterm.txt
index 2eee3d5bc..5e414ed37 100644
--- a/tests/fixtures/tui/route-muxterm.txt
+++ b/tests/fixtures/tui/route-muxterm.txt
@@ -766,7 +766,7 @@
  missing      16.0 KB  gba_bios.bin
 
 
- Start Back  Up/Down Scroll
+ Start Back
 === preview 40x15
  RetroBIOS: Preview
 
@@ -782,7 +782,7 @@
 
 
 
- Start Back  Up/Down Scroll
+ Start Back
 === preview 80x24
  RetroBIOS: Preview
 
@@ -807,7 +807,7 @@
 
 
 
- Start Back  Up/Down Scroll
+ Start Back
 === command 40x12
  RetroBIOS: Command line
 
@@ -982,7 +982,7 @@
    retrobios-backup/2026-10-23_1200
  Details: /tmp/retrobios-x/install.log
 
- Start Exit  Up/Down Scroll
+ Start Exit
 === result 40x15
  RetroBIOS: Finished with errors
 
@@ -998,7 +998,7 @@
 
 
 
- Start Exit  Up/Down Scroll
+ Start Exit
 === result 80x24
  RetroBIOS: Finished with errors
 
@@ -1023,7 +1023,7 @@
 
 
 
- Start Exit  Up/Down Scroll
+ Start Exit
 === error 40x12
  RetroBIOS: Something went wrong
 
diff --git a/tests/test_install.py b/tests/test_install.py
index 55151f917..e51f38487 100644
--- a/tests/test_install.py
+++ b/tests/test_install.py
@@ -3945,8 +3945,8 @@ class PlatformsAreNamedAsTheyNameThemselves(unittest.TestCase):
                 contextlib.redirect_stdout(out):
             install._prompt_platform_choice(
                 [("misterfpga", Path("/m")), ("retrodeck", Path("/r"))])
-        self.assertIn("MiSTer FPGA (/m)", out.getvalue())
-        self.assertIn("RetroDECK (/r)", out.getvalue())
+        self.assertIn("MiSTer FPGA: /m", out.getvalue())
+        self.assertIn("RetroDECK: /r", out.getvalue())
         self.assertEqual(install.display_name("romm", {"display_name": "RomM"}), "RomM")
         self.assertEqual(install.display_name("romm", {"display_name": "\x1b[2J"}), "RomM")
 
@@ -5176,6 +5176,9 @@ class EventsDescribeTheRun(unittest.TestCase, _SyntheticTree):
             {"event": "detect", "os": "linux", "os_name": install._os_name(),
              "platforms": [{"platform": "retroarch", "name": "RetroArch",
                             "bios_dir": str(self.bios)}]},
+            # The systems Choose systems lists, before the files are read.
+            {"event": "choices", "platform": "retroarch",
+             "systems": ["sys-a", "sys-b", "other"]},
             # a.bin and b.bin are in place: the first read and the last.
             {"event": "checking", "files_done": 1, "files_total": 2},
             {"event": "checking", "files_done": 2, "files_total": 2},
diff --git a/tests/test_install_cores.py b/tests/test_install_cores.py
index 6c0ec22c2..edd7c07df 100644
--- a/tests/test_install_cores.py
+++ b/tests/test_install_cores.py
@@ -479,12 +479,12 @@ class TheOneLinerReadsInstalledCores(unittest.TestCase):
             command = " ".join(shlex.quote(part) for part in repo.command())
             proc = subprocess.run(
                 ["script", "-qec", command, "/dev/null"],
-                input="i\n", env=repo.env(), capture_output=True,
+                input="i\n\n", env=repo.env(), capture_output=True,
                 text=True, timeout=60, check=False,
             )
             self.assertEqual(proc.returncode, 0, proc.stdout + proc.stderr)
             self.assertIn("i) only what the installed cores read: 2 files", proc.stdout)
-            self.assertIn("--platform retroarch --installed-cores", proc.stdout)
+            self.assertRegex(proc.stdout, r"--platform retroarch --dest \S+ --installed-cores")
             self.assertEqual(repo.installed(), ["gba_bios.bin", "mgba/extra.bin"])
 
 
diff --git a/tests/test_install_selection.py b/tests/test_install_selection.py
index a9bb23570..142ed304a 100644
--- a/tests/test_install_selection.py
+++ b/tests/test_install_selection.py
@@ -421,7 +421,7 @@ class ACoreWithNoFileOfItsOwn(unittest.TestCase):
         self.assertIn("1 file, 9 B", self._line(out.getvalue(), "duckstation"))
 
     def test_the_cores_step_says_so_too(self):
-        answers = iter(["c", "", ""])
+        answers = iter(["c", "", "", ""])
         out = io.StringIO()
         with mock.patch("builtins.input", lambda _prompt="": next(answers)), \
                 contextlib.redirect_stdout(out):
@@ -458,7 +458,7 @@ class FilesSharedBySystemsAreCountedApart(unittest.TestCase):
         self.assertTrue(lines["nintendo-gba"].endswith("1 file, 8 B"))
 
     def test_the_systems_step(self):
-        answers = iter(["c", ""])
+        answers = iter(["c", "", ""])
         out = io.StringIO()
         with mock.patch("builtins.input", lambda _prompt="": next(answers)), \
                 contextlib.redirect_stdout(out):
@@ -680,7 +680,7 @@ class TheOneLinerNarrows(unittest.TestCase):
             command = " ".join(shlex.quote(part) for part in repo.command())
             proc = subprocess.run(
                 ["script", "-qec", command, "/dev/null"],
-                input="c\n2\n\n2\n", env=repo.env(), capture_output=True,
+                input="c\n2\n\n2\n\n", env=repo.env(), capture_output=True,
                 text=True, timeout=60, check=False,
             )
             out = proc.stdout
diff --git a/tests/test_install_tui.py b/tests/test_install_tui.py
index a3d7ce42a..cc946f44a 100644
--- a/tests/test_install_tui.py
+++ b/tests/test_install_tui.py
@@ -22,8 +22,10 @@ import os
 import queue
 import re
 import select
+import shlex
 import shutil
 import struct
+import subprocess
 import sys
 import tempfile
 import termios
@@ -32,6 +34,7 @@ import time
 import types
 import unittest
 import warnings
+import zipfile
 from pathlib import Path, PureWindowsPath
 from unittest import mock
 
@@ -1025,8 +1028,8 @@ def _bar_keys(line: str) -> set:
 # closes this help", <> and ^v are the narrow forms of Left/Right, Up/Down.
 ROUTE_KEYS = {
     "keys": {"Enter", "Esc", "Space", "o", "?", "/", "Ctrl-C", "Ctrl-U"},
-    "gptokeyb": {"A", "B", "X", "Y", "Start+Select"},
-    "gptokeyb_muxterm": {"A", "B", "X", "Y", "Start+Select"},
+    "gptokeyb": {"A", "B", "X", "Y", "Select+Start"},
+    "gptokeyb_muxterm": {"A", "B", "X", "Y", "Select+Start"},
     "evmapy": {"A", "B", "X", "Y"},
     "muxterm": {"Start", "B", "Y", "Menu", "Select"},
     "miyoo": {"A", "Start", "R2", "L2"},
@@ -1095,8 +1098,8 @@ class PadRoutes(unittest.TestCase):
 
     def test_the_install_says_what_stops_it_there(self):
         expected = {
-            "both": "B, Ctrl-C or Start+Select stops.", "keys": "Esc or Ctrl-C stops.",
-            "gptokeyb": "B or Start+Select stops.", "evmapy": "B stops.",
+            "both": "B, Ctrl-C or Select+Start stops.", "keys": "Esc or Ctrl-C stops.",
+            "gptokeyb": "B or Select+Start stops.", "evmapy": "B stops.",
             "muxterm": "B stops.", "miyoo": "R2 stops.",
         }
         for route, words in expected.items():
@@ -1120,7 +1123,7 @@ class PadRoutes(unittest.TestCase):
         for words in ("D-pad, Up/Down", "A, Start, Enter", "B, Select, Esc", "Y, Tab, o",
                       "Select, then Start", "Quit at once", "q, Ctrl-C"):
             self.assertIn(words, gptk)
-        self.assertNotIn("Start+Select", help_text("evmapy"))
+        self.assertNotIn("Select+Start", help_text("evmapy"))
         keys = help_text("keys")
         for words in ("Enter", "Esc, Backspace", "o, Tab"):
             self.assertIn(words, keys)
@@ -1130,7 +1133,7 @@ class PadRoutes(unittest.TestCase):
         for words in ("Start, Enter", "B, Esc, Backspace", "Keyboard on or off",
                       "Close the terminal"):
             self.assertIn(words, muxterm)
-        self.assertNotIn("Start+Select", muxterm)
+        self.assertNotIn("Select+Start", muxterm)
         # gptokeyb2 owns the pad inside muxterm, which keeps PgUp and PgDn
         # for its scrollback: the gptokeyb buttons, Left and Right to page.
         in_muxterm = help_text("gptokeyb_muxterm", "preview")
@@ -2115,9 +2118,10 @@ class AuditRoundThree(unittest.TestCase):
 
     def test_p1_1_a_card_nothing_names_is_left_alone(self):
         self.assertIsNone(install.card_system(self.card({"roms/": "", "BIOS/": ""})))
-        # Batocera's share and a KNULLI board seeded with its name read alike.
-        self.assertIsNone(install.card_system(self.card({
-            "system/batocera.conf": "system.hostname=BATOCERA\n"})))
+        # code_audit_17 P2-3: Batocera's own share is its SHARE drive, read
+        # by a batocera.conf that names no KNULLI.
+        share = self.card({"system/batocera.conf": "system.hostname=BATOCERA\n"})
+        self.assertEqual(install.card_system(share), ("batocera", share / "bios", "Batocera"))
 
     def test_p1_1_the_card_rules_are_the_device_rules(self):
         # The folder and the marker come from the rule the device reads, so
@@ -2855,7 +2859,7 @@ class ACardSystemNamedOnAComputer(unittest.TestCase):
             f'system_directory = "{system}"\n', encoding="utf-8")
         with FakeRepository() as repo:
             proc = install_run("--platform", "onion", "--yes",
-                               env={**repo.env(), "HOME": str(home)})
+                               env={**repo.env(), "HOME": str(home), "RETROBIOS_OS": "linux"})
         self.assertEqual(proc.returncode, 1, proc.stdout + proc.stderr)
         self.assertIn("Onion keeps its BIOS files on its SD card, not on this machine.",
                       proc.stderr)
@@ -2909,7 +2913,8 @@ class ACardSystemNamedOnAComputer(unittest.TestCase):
         self.assertEqual(dest, onion / "BIOS")
         self.assertEqual(len(asked), 3)
         # No card is listed: 8 is no number of the list, and no folder.
-        self.assertIn("Type the card's top folder, or q to quit.", out.getvalue())
+        self.assertIn("Type the card's top folder, Enter to look again, or q to quit.",
+                      out.getvalue())
         self.assertIn("NEXT does not exist, or is not a folder. Type the top folder of the "
                       "Onion card.", out.getvalue())
         self.assertFalse((REPO_ROOT / "tmp" / "no-such").exists())
@@ -2945,7 +2950,7 @@ class ACardSystemNamedOnAComputer(unittest.TestCase):
         muos, blank = self.card({"MUOS/bios/x": ""}), self.card({"roms/a": ""})
         first, second = (self.card({"system/batocera.conf": "system.hostname=KNULLI\n"})
                          for _card in range(2))
-        patcher, asked = self.ask("3", "2")
+        patcher, asked = self.ask("4", "2")
         with mock.patch.object(install, "_mounted_cards",
                                return_value=[muos, first, blank, second]), \
                 patcher, contextlib.redirect_stdout(io.StringIO()) as out:
@@ -2954,8 +2959,11 @@ class ACardSystemNamedOnAComputer(unittest.TestCase):
         self.assertIn(f"1) {first.name} (KNULLI card, {first})", out.getvalue())
         self.assertIn(f"2) {second.name} (KNULLI card, {second})", out.getvalue())
         self.assertNotIn(str(muos), out.getvalue())
-        self.assertNotIn(str(blank), out.getvalue())
-        self.assertIn("Type 1 to 2, a folder, or q to quit.", out.getvalue())
+        # tui_audit_10 P3-8: KNULLI fills its card when it first starts, and
+        # a blank drive is listed after its own cards, as on the screen.
+        self.assertIn(f"3) {blank.name} (card or drive, {blank})", out.getvalue())
+        self.assertIn("Type a number from 1 to 3, a folder, Enter to look again, or q to "
+                      "quit.", out.getvalue())
 
     def test_creating_several_folders_on_the_card_is_asked(self):
         """tui_audit_6 P3-8: N to the question ended the whole run where it
@@ -2971,7 +2979,7 @@ class ACardSystemNamedOnAComputer(unittest.TestCase):
             dest = install.card_install_dest("rocknix", "rocknix", interactive=True)
         self.assertEqual(dest, card / "roms" / "bios")
         self.assertIn("[y/N]", asked[1])
-        self.assertEqual(asked[2], "Card root, q to quit: ")
+        self.assertEqual(asked[2], "Card root, Enter to look again, q to quit: ")
         self.assertIn("Not created.", out.getvalue())
         self.assertFalse((rocknix / "roms").exists())
 
@@ -2986,7 +2994,7 @@ class ACardSystemNamedOnAComputer(unittest.TestCase):
                 contextlib.redirect_stdout(io.StringIO()):
             chosen = install._prompt_manual_platform("linux")
         self.assertEqual(chosen, [("rocknix", card / "roms" / "bios")])
-        self.assertEqual(asked, ["Card root, q to quit: "])
+        self.assertEqual(asked, ["Card root, Enter to look again, q to quit: "])
 
     def test_a_card_of_another_system_is_not_offered(self):
         """tui_audit_5 P1-1: A on the first mount wrote Onion's BIOS/ on a
@@ -3690,9 +3698,19 @@ class NarrowSystemNames(unittest.TestCase):
         for cols, rows in ((40, 15), (40, 12), (52, 15)):
             with self.subTest(size=f"{cols}x{rows}"):
                 text = "\n".join(install.tui_view(state, cols, rows))
-                for name in names.values():
-                    self.assertIn(name, text)
-                self.assertNotIn("...", text)
+                # tui_audit_10 P3-14: the size stays as the total counts it,
+                # 30.0 MB, and a name too long beside it is cut where the
+                # three still read apart.
+                lines = [line for line in text.splitlines() if "[x]" in line]
+                self.assertEqual(len(lines), 4, text)
+                self.assertTrue(all(line.rstrip().endswith(("30.0 MB", "30.0 MB + 27 shared"))
+                                    for line in lines), text)
+                labels = [line.split("[x] ")[1].split("30.0 MB", 1)[0].strip()
+                          for line in lines]
+                self.assertEqual(len(set(labels)), 4, text)
+                for label, name in zip(labels, names.values()):
+                    stem = label[:-3] if label.endswith("...") else label
+                    self.assertTrue(name.startswith(stem), (label, name))
                 for line in text.splitlines():
                     self.assertLessEqual(install.cell_width(line), cols)
         # Wide, the full form stays.
@@ -3963,12 +3981,15 @@ class AGoesIntoASubfolder(unittest.TestCase):
         self.assertEqual(self.focused().label, "Games/")
         self.assertEqual(self.state.status, "")
 
-    def test_with_no_visible_subfolder_use_stays_and_says_where(self):
+    def test_with_no_visible_subfolder_a_folder_below_takes_the_focus(self):
+        """tui_audit_10 P2-5: the focus stayed on Use this folder under the
+        sentence that warns against it, and A, A, A installed BizHawk into
+        the home folder."""
         (self.home / ".cache").mkdir()
         (self.home / ".config").mkdir()
         with mock.patch.object(install, "_mounted_cards", return_value=[self.card]):
             install._browse_to(self.state, self.home)
-        self.assertEqual(self.focused().action, "use")
+        self.assertEqual(self.focused().label, ".cache/")
         self.assertIn("No setup reads BIOS files in your home folder", self.state.status)
         screen = " ".join(" ".join(install.tui_view(self.state, 80, 24)).split())
         self.assertIn("No setup reads BIOS files in your home folder.", screen)
@@ -4153,7 +4174,10 @@ class WindowsHasNoPosixModules(unittest.TestCase):
 class Pty:
     """install.py on a pseudo-terminal, its screen read back through pyte."""
 
-    def __init__(self, args: list[str], env: dict, cols: int = 80, rows: int = 24) -> None:
+    def __init__(self, args: list[str], env: dict, cols: int = 80, rows: int = 24,
+                 program: list[str] | None = None) -> None:
+        """program runs instead of this Python on install.py: the wrapper
+        a user runs, install.sh."""
         self.screen = pyte.Screen(cols, rows)
         self.stream = pyte.ByteStream(self.screen)
         self.raw = b""
@@ -4163,8 +4187,8 @@ class Pty:
             warnings.simplefilter("ignore", DeprecationWarning)
             self.pid, self.fd = pty.fork()
         if self.pid == 0:
-            os.execve(sys.executable, [sys.executable, str(REPO_ROOT / "install.py"), *args],
-                      env)
+            argv = program or [sys.executable, str(REPO_ROOT / "install.py")]
+            os.execve(argv[0], [*argv, *args], env)
         self.resize(cols, rows)
         self.status: int | None = None
 
@@ -5165,6 +5189,72 @@ class TheTerminalComesBack(unittest.TestCase):
         self.assertGivenBack(term)
         self.assertModesBack(term.modes)
 
+    @staticmethod
+    def proc_state(pid: int) -> str:
+        """The state letter Linux gives a process (T is stopped)."""
+        text = Path(f"/proc/{pid}/stat").read_text()
+        return text[text.rindex(")") + 2]
+
+    @staticmethod
+    def children(pid: int) -> list[int]:
+        found = []
+        for entry in Path("/proc").iterdir():
+            if not entry.name.isdigit():
+                continue
+            try:
+                text = (entry / "stat").read_text()
+            except OSError:
+                continue
+            if int(text[text.rindex(")") + 2:].split()[1]) == pid:
+                found.append(int(entry.name))
+        return found
+
+    @unittest.skipUnless(Path("/proc/self/stat").exists(), "reads process states in /proc")
+    def test_ctrl_z_through_install_sh_stops_the_wrapper_and_the_install(self):
+        """code_audit_17 P2-1: Ctrl-Z stopped the installer alone. install.sh,
+        which runs it as a child, kept waiting, the shell never got its prompt
+        back, and the install run behind the screen kept writing."""
+        import signal
+
+        repo = self.repo(GameDataRepository, slow=True)
+        self.env["PATH"] = f"{Path(sys.executable).parent}{os.pathsep}{self.env['PATH']}"
+        term = Pty(["--jobs", "1"], self.env, program=["/bin/sh", str(REPO_ROOT / "install.sh")])
+        self.addCleanup(lambda: term.status is None and os.killpg(term.pid, 9))
+        term.wait("Where do you play?")
+        term.send("\r")
+        term.wait("to download")
+        term.send("\r")
+        term.wait("Installing")
+        time.sleep(0.8)
+        installer = self.children(term.pid)
+        self.assertEqual(len(installer), 1, installer)
+        runs = self.children(installer[0])
+        self.assertTrue(runs, "no install run")
+        term.send("\x1a")
+        end, stopped = time.monotonic() + 10, False
+        while time.monotonic() < end and not stopped:
+            term._pump(0.05)
+            pid, status = os.waitpid(term.pid, os.WNOHANG | os.WUNTRACED)
+            stopped = bool(pid) and os.WIFSTOPPED(status)
+        # The wrapper is stopped: a shell's job of it is reported stopped.
+        self.assertTrue(stopped, term.text())
+        self.assertEqual(self.proc_state(installer[0]), "T")
+        self.assertEqual([self.proc_state(run) for run in runs], ["T"] * len(runs))
+        written = sorted(repo.dest.rglob("*"))
+        time.sleep(2)
+        self.assertEqual(sorted(repo.dest.rglob("*")), written)
+        # fg continues the job's group: the screen comes back and the install
+        # carries on to its end.
+        mark = len(term.raw)
+        os.killpg(term.pid, signal.SIGCONT)
+        end = time.monotonic() + 5
+        while b"\x1b[?1049h" not in term.raw[mark:] and time.monotonic() < end:
+            term._pump(0.05)
+        self.assertIn(b"\x1b[?1049h", term.raw[mark:])
+        term.wait("files installed", timeout=30)
+        term.send("\r")
+        self.assertEqual(term.close(), 0)
+
 
 class TheFolderScreenSaysWhatItOffers(unittest.TestCase):
     """The folder screen said "usually reads its BIOS files from" for any
@@ -5771,7 +5861,8 @@ class AuditSix(unittest.TestCase):
                 contextlib.redirect_stdout(io.StringIO()) as out:
             dest = install.card_install_dest("onion", "retroarch", True)
         self.assertEqual(dest, other / "BIOS")
-        self.assertEqual(out.getvalue().count("Type 1 to 2, a folder, or q to quit."), 2)
+        self.assertEqual(out.getvalue().count(
+            "Type a number from 1 to 2, a folder, Enter to look again, or q to quit."), 2)
 
     def test_the_articles_read(self):
         self.assertEqual([install._a(name) for name in ("Onion", "Allium", "ArkOS", "muOS",
@@ -5825,10 +5916,14 @@ class AuditSix(unittest.TestCase):
         self.assertNotEqual(state.screen, "error")
 
     def test_a_long_name_keeps_a_size_at_40_columns(self):
-        """tui_audit_6 P3-5: Nintendo Game Boy Advance lost its size."""
+        """tui_audit_6 P3-5: Nintendo Game Boy Advance lost its size.
+        tui_audit_10 P3-14: and kept it rounded, 3 KB beside a total of
+        2.7 KB. The size stays whole, the name is cut."""
         row = install.TuiRow("system", "[x] Nintendo Game Boy Advance", "1 file, 16.0 KB",
-                             "nintendo-gba", narrow=("16.0 KB", install._compact_size(16384)))
-        self.assertTrue(str(install._row_line(row, False, 38)).rstrip().endswith("16 KB"))
+                             "nintendo-gba", narrow=("16.0 KB",), keep_right=True)
+        line = str(install._row_line(row, False, 38)).rstrip()
+        self.assertTrue(line.endswith("16.0 KB"), line)
+        self.assertRegex(line, r"Nintendo Game Boy A?d?\.\.\.")
 
     def test_the_shared_note_keeps_its_line(self):
         """tui_audit_6 P3-5: the page held 4, 3 and 5 systems as the note
@@ -5889,11 +5984,15 @@ class AuditSevenOneCardReading(unittest.TestCase):
                 state = self.start(platform=named, dest=str(stick))
                 self.assertEqual(state.dest, stick / below)
                 self.assertEqual(state.card_note, note)
-                # Kept on Create the folder? and on the plan.
-                self.assertEqual(state.screen, "create")
-                self.assertIn(note.split(":")[0],
-                              " ".join(" ".join(install.tui_view(state, 120, 40)).split()))
-                install.tui_update(state, Key("enter"))
+                # tui_audit_10 P3-8: one rule with line mode, whose question
+                # creates one missing level and says it. Two are asked, and
+                # the note is kept on Create the folder? and on the plan.
+                one = (stick / below).parent.is_dir()
+                self.assertEqual(state.screen, "checking" if one else "create")
+                if not one:
+                    self.assertIn(note.split(":")[0],
+                                  " ".join(" ".join(install.tui_view(state, 120, 40)).split()))
+                    install.tui_update(state, Key("enter"))
                 self.assertEqual(state.card_note, note)
 
     def test_the_minui_family_refuses_a_blank_dest(self):
@@ -6380,6 +6479,60 @@ def screen_decision(args: argparse.Namespace) -> tuple[str, Path]:
     raise AssertionError(f"the screen chose nothing: {state.stack}")
 
 
+def screen_keys(args: argparse.Namespace, presses: list,
+                until: tuple = ("fetch", "run")) -> install.TuiState:
+    """The full screen for args once the keys are pressed, stopped as soon
+    as it fetches the list or starts a run (until)."""
+    install.LOCAL.reset()
+    with mock.patch.object(install, "detect_os", return_value="linux"), \
+            mock.patch.dict(os.environ, {install.OFFLINE_VARIABLE: "1"}), \
+            contextlib.redirect_stdout(io.StringIO()), \
+            contextlib.redirect_stderr(io.StringIO()):
+        try:
+            state, effects = install._tui_startup(args)
+            for key in presses:
+                if any(effect[0] in until for effect in effects):
+                    break
+                effects = install.tui_update(state, key if isinstance(key, Key) else Key(key))
+            return state
+        finally:
+            install.LOCAL.reset()
+
+
+def engine_events(args: argparse.Namespace) -> tuple[list[dict], str]:
+    """(events, text) of the line engine run in this process with --events,
+    the run the screen starts for its check."""
+    stream = io.StringIO()
+    install.LOCAL.reset()
+    try:
+        with mock.patch.object(install.EVENTS, "stream", stream), \
+                mock.patch.object(install, "detect_os", return_value="linux"), \
+                mock.patch.dict(os.environ, {install.OFFLINE_VARIABLE: "1"}), \
+                contextlib.redirect_stdout(io.StringIO()) as out, \
+                contextlib.redirect_stderr(io.StringIO()), \
+                contextlib.suppress(SystemExit):
+            install._install(args, io.StringIO())
+    finally:
+        install.LOCAL.reset()
+    return [json.loads(line) for line in stream.getvalue().splitlines()], out.getvalue()
+
+
+def screen_plan(args: argparse.Namespace, manifest: dict, events: list[dict],
+                facts: dict | None = None) -> tuple[install.TuiState, str]:
+    """The plan screen fed the events of a check run, as the screen reads
+    its child: (state, text at 120x40)."""
+    state, _effects = install.tui_start(args, "linux", detect=False)
+    state.manifest, state.manifest_for = manifest, state.platform
+    state.stack = ["checking"]
+    install._start_run(state, "check")
+    for event in events:
+        install.tui_receive(state, ("event", state.run_id, event))
+    with mock.patch.object(install, "_tui_folder_facts", return_value=facts or {
+            "free": 50 * 1024 ** 3, "writable": True, "cores": []}):
+        install.tui_receive(state, ("ended", state.run_id, 0, []))
+    return state, " ".join(" ".join(install.tui_view(state, 120, 40)).split())
+
+
 class LineModeAndScreenDecideAlike(unittest.TestCase):
     """tui_audit_8 P1-1, P2-1 and code_audit_15 P2-2: line mode looked at
     this machine alone, took this computer's default folder with a card in
@@ -6526,6 +6679,809 @@ class LineModeAndScreenDecideAlike(unittest.TestCase):
         self.assertNotIn("c) choose systems", text)
         self.assertNotIn("Copying", text)
 
+    # code_audit_17 and tui_audit_10: every line-mode finding, each answered
+    # by line mode and the screen from one decision.
+
+    def line_run(self, args: argparse.Namespace, answers: list, mounts: list = (),
+                 found: list = ()) -> tuple[str, list]:
+        """(text, prompts) of line mode at a terminal for args, the answers
+        given in turn: the run stops at the first question left unanswered."""
+        given, asked = iter(answers), []
+
+        def answer(prompt: str) -> str:
+            asked.append(prompt)
+            try:
+                return next(given)
+            except StopIteration:
+                raise _Decided(prompt) from None
+
+        install.LOCAL.reset()
+        self.addCleanup(install.LOCAL.reset)
+        # The options the run was started with, as main() records them.
+        invocation = install.Invocation()
+        invocation.os_type = "linux"
+        invocation.record(args)
+        with mock.patch.object(install, "_INVOCATION", invocation), \
+                mock.patch.object(install, "_mounted_cards", return_value=list(mounts)), \
+                mock.patch.object(install, "_mount_points", return_value=frozenset()), \
+                mock.patch.object(install, "detect_platforms", return_value=list(found)), \
+                mock.patch.object(install, "detect_frontends", return_value=[]), \
+                mock.patch.object(install, "detect_os", return_value="linux"), \
+                mock.patch.object(install.sys.stdin, "isatty", return_value=True), \
+                mock.patch.object(install, "_is_terminal", return_value=True), \
+                mock.patch.object(install, "_ask", side_effect=answer), \
+                contextlib.redirect_stdout(io.StringIO()) as out, \
+                contextlib.redirect_stderr(io.StringIO()) as err, \
+                contextlib.suppress(_Decided, SystemExit):
+            install._install(args, io.StringIO())
+        return out.getvalue() + err.getvalue(), asked
+
+    def listing(self, plat: str, files: list, **extra) -> Path:
+        path = self.root / f"{plat}-{len(list(self.root.glob('*.json')))}.json"
+        path.write_text(json.dumps({"manifest_version": 2, "platform": plat,
+                                    "files": files, **extra}))
+        return path
+
+    @staticmethod
+    def entry(dest: str, payload: bytes, systems: list, **extra) -> dict:
+        return {"dest": dest, "sha1": hashlib.sha1(payload).hexdigest(),
+                "size": len(payload), "repo_path": f"bios/{dest}", "cores": None,
+                "systems": systems, **extra}
+
+    def test_o_then_the_setup_found_offers_the_folder_it_reads(self):
+        """code_audit_17 P2-2, tui_audit_10 P1-1: o then RetroArch offered
+        its built-in folder, and Enter filled it, where the screen keeps the
+        folder retroarch.cfg names."""
+        pc = [("retroarch", self.here)]
+        args = dict(manifest=self.list, declared_only=False, offline=False)
+        text, asked = self.line_run(_args(**args), ["o", "", ""], found=pc)
+        self.assertIn(f"RetroArch reads its BIOS files from: {self.here}.", text)
+        self.assertIn("(Enter for the folder RetroArch reads)", asked[2])
+        self.assertNotIn("default BIOS folder", text)
+        with mock.patch.object(install, "_mounted_cards", return_value=[]), \
+                mock.patch.object(install, "detect_platforms", return_value=pc), \
+                mock.patch.object(install, "detect_frontends", return_value=[]):
+            install._DETECTED_OS.clear()
+            given = iter(["o", "", ""])
+            line, _text = line_decision(_args(**args), lambda _prompt: next(given))
+            install._DETECTED_OS.clear()
+            state = screen_keys(_args(**args), ["end", "enter", "enter", "enter"])
+        self.assertEqual(tuple(line[0]), ("retroarch", self.here))
+        self.assertEqual((state.platform, state.dest), ("retroarch", self.here))
+
+    def test_a_share_drive_typed_is_read_as_its_bios_folder(self):
+        """code_audit_17 P2-3, tui_audit_10 P3-11: the SHARE drive's root,
+        typed for Batocera or Recalbox, was the BIOS folder, beside roms/
+        and system/. Another system's drive is refused, in both modes."""
+        shares = {}
+        for plat, marker in (("batocera", "system/batocera.conf"),
+                             ("recalbox", "system/recalbox.conf")):
+            share = self.root / "media" / f"SHARE-{plat}"
+            (share / "system").mkdir(parents=True)
+            (share / "roms").mkdir()
+            (share / marker).write_text("system.hostname=SHARE\n")
+            shares[plat] = share
+        for plat, share in shares.items():
+            other = shares["recalbox" if plat == "batocera" else "batocera"]
+            listing = self.listing(plat, [])
+            with self.subTest(platform=plat):
+                text, _asked = self.line_run(_args(manifest=listing, declared_only=False),
+                                             [str(other), str(share)])
+                self.assertIn(f"{other} is a {install.display_name(install.share_drive(other))}"
+                              " SHARE drive", text)
+                self.assertIn(f"SHARE drive: its BIOS folder is {share / 'bios'}", text)
+                with mock.patch.object(install, "_mounted_cards", return_value=[]), \
+                        mock.patch.object(install, "detect_platforms", return_value=[]), \
+                        mock.patch.object(install, "detect_frontends", return_value=[]):
+                    line, _text = line_decision(_args(manifest=listing, declared_only=False),
+                                                lambda _prompt, typed=str(share): typed)
+                    refused = screen_keys(_args(manifest=listing), [
+                        "end", "enter", Key("paste", str(other)), "enter"])
+                    state = screen_keys(_args(manifest=listing), [
+                        "end", "enter", Key("paste", str(share)), "enter"])
+                self.assertEqual(tuple(line[0]), (plat, share / "bios"))
+                self.assertEqual((state.platform, state.dest), (plat, share / "bios"))
+                self.assertIn("SHARE drive", refused.status)
+                self.assertEqual(refused.screen, "path")
+
+    def test_the_setups_found_are_labelled_alike(self):
+        """code_audit_17 P3-1, tui_audit_10 P3-3, P3-13: "Onion SD card
+        (ONION) (/media/me/ONION/BIOS)", two pairs of brackets, and a MinUI
+        card named by its root where its BIOS folder is Bios."""
+        onion, minui = self.card("ONION", "Onion"), self.card("MINUI", "MinUI")
+        mounts, pc = [onion, minui], [("retroarch", self.here)]
+        text, _asked = self.line_run(_args(declared_only=False), [], mounts, pc)
+        self.assertNotIn(") (", text)
+        self.assertIn(f"Found MinUI at {minui / 'Bios'}", text)
+        with mock.patch.object(install, "_mounted_cards", return_value=mounts), \
+                mock.patch.object(install, "_mount_points", return_value=frozenset()), \
+                mock.patch.object(install, "detect_platforms", return_value=pc), \
+                mock.patch.object(install, "detect_frontends", return_value=[]):
+            install._DETECTED_OS.clear()
+            setups, _mounted = install.found_setups("linux")
+            state = install.TuiState(os_type="linux", home=HOME)
+            state.setups = setups
+            for index, (plat, path, label) in enumerate(setups):
+                state.focus["setup"] = index
+                screen = " ".join(install.tui_view(state, 120, 40))
+                folder = install.setup_bios_folder(plat, path)
+                with self.subTest(setup=label):
+                    self.assertIn(f"{index + 1}) {label}: {folder}", text)
+                    self.assertIn(f"BIOSfolder:{folder}", screen.replace(" ", ""))
+
+    def test_both_count_the_systems_out_of_the_same_list(self):
+        """code_audit_17 P3-2: the plan said 1 of 12 systems where Choose
+        systems and line mode listed 11, a system whose only file is read
+        from an unknown save directory counted."""
+        payload = b"gba"
+        files = [self.entry("gba_bios.bin", payload, ["nintendo-gba"]),
+                 self.entry("ds.bin", b"ds", ["nintendo-ds"]),
+                 self.entry("Azahar/keys.txt", b"keys", ["nintendo-3ds"], root="save")]
+        # No retroarch.cfg, and a BIOS folder not named as the list's: the
+        # save directory is not known, and keys.txt is left out.
+        manifest = {"base_destination": "RetroArch",
+                    "save_directory": {"folder": "saves", "by_core": False}}
+        listing = self.listing("retroarch", files, **manifest)
+        args = dict(manifest=listing, dest=self.here, declared_only=False,
+                    system=["nintendo-gba"])
+        text, _asked = self.line_run(_args(**args), [])
+        self.assertIn("for 1 of 2 systems (--system).", text)
+        events, _out = engine_events(_args(**args, check=True, events=True, no_input=True))
+        choices = next(event for event in events if event["event"] == "choices")
+        self.assertEqual(choices["systems"], ["nintendo-ds", "nintendo-gba"])
+        manifest = json.loads(listing.read_text())
+        state, screen = screen_plan(_args(**args), manifest, events)
+        self.assertIn("For 1 of 2 systems (--system).", screen)
+        # Choose systems, opened from that plan, lists the same two.
+        self.assertEqual(len(install.tui_systems(state)), 2)
+
+    def test_after_o_the_list_offers_the_setups_its_file_list_serves(self):
+        """code_audit_17 P3-3: Batocera was offered for a RetroArch list,
+        and refused once its folder had been asked."""
+        install.LOCAL.reset()
+        self.addCleanup(install.LOCAL.reset)
+        install.LOCAL.manifest = self.list
+        line = [name for name, _label in install._line_setups([], set(), "linux")]
+        state = install.TuiState(os_type="linux", home=HOME)
+        state.stack = ["platforms"]
+        screen = [install._row_name(row) for row in install.tui_rows(state)
+                  if row.action != "filter"]
+        self.assertEqual(line, screen)
+        self.assertIn("retroarch", line)
+        self.assertIn("Onion", line)
+        self.assertNotIn("batocera", line)
+        self.assertNotIn("knulli", line)
+
+    def test_a_choice_of_systems_is_confirmed_before_anything_is_written(self):
+        """tui_audit_10 P2-1, code_audit_17 P2-4: c installed as soon as the
+        last list was answered, and its command left out --dest and
+        --manifest. The menu comes back counted, as the screen's Confirm."""
+        files = [self.entry("gba_bios.bin", b"gba", ["nintendo-gba"]),
+                 self.entry("scph5501.bin", b"psx", ["sony-playstation"])]
+        listing = self.listing("retroarch", files)
+        args = _args(manifest=listing, dest=self.here, declared_only=False)
+        text, asked = self.line_run(args, ["c", "1"])
+        self.assertIn("Counted again for your choices. Nothing is written before Enter.", text)
+        self.assertIn("RetroArch: 1 file, 3 B, for 1 of 2 systems.", text)
+        self.assertIn("Enter) install these", text)
+        self.assertEqual(asked[-1], "> ")
+        command = next(line for line in text.splitlines()
+                       if "Same choice without questions:" in line)
+        for option in (f"--dest {self.here}", f"--manifest {listing}",
+                       "--system nintendo-gba"):
+            self.assertIn(option, command)
+        self.assertNotIn("Copying", text)
+        self.assertEqual(list(self.here.iterdir()), [])
+        # The screen: Choose systems, A on one system, then Confirm.
+        state = checked_state()
+        press(state, "down", "enter")
+        self.assertEqual(state.screen, "systems")
+        effects = press(state, "enter")
+        self.assertEqual((state.screen, effects), ("confirm", [("run", "confirm")]))
+
+    def tree(self, ref: str, systems: list, count: int) -> dict:
+        return {"ref": ref, "url": "https://example.org/tree.zip", "type": "zip",
+                "systems": systems, "dest": ref,
+                "files": {f"f{n}.dat": {"sha1": "a" * 40, "size": 10} for n in range(count)}}
+
+    def test_both_count_the_data_files_of_the_systems_kept(self):
+        """tui_audit_10 P2-2: line mode counted 2636 data files of other
+        systems for every --system tried, where the screen counts none."""
+        files = [self.entry("gba_bios.bin", b"gba", ["nintendo-gba"]),
+                 self.entry("scph5501.bin", b"psx", ["sony-playstation"])]
+        trees = [self.tree("gba-tree", ["nintendo-gba"], 2),
+                 self.tree("psx-tree", ["sony-playstation"], 5)]
+        listing = self.listing("retroarch", files, data_directories=trees)
+        args = dict(manifest=listing, dest=self.here, declared_only=False)
+        for system, count in (("nintendo-gba", 2), ("sony-playstation", 5)):
+            with self.subTest(system=system):
+                text, _asked = self.line_run(_args(**args, system=[system]), [])
+                self.assertIn(f"and {count} data files (", text)
+                events, _out = engine_events(_args(**args, system=[system], check=True,
+                                                   events=True, no_input=True))
+                data = next(event for event in events if event["event"] == "data")
+                self.assertEqual(data["files"], count)
+        text, _asked = self.line_run(_args(**args), [])
+        self.assertIn("and 7 data files (", text)
+
+    @unittest.skipUnless(hasattr(os, "statvfs"), "statvfs reads mount flags")
+    def test_a_read_only_card_gets_one_remedy_and_no_sudo(self):
+        """tui_audit_10 P2-3: the plan offered sudo for a read-only mount,
+        with a command that dropped --from-pack and --manifest, and the
+        result offered nothing. One advice, line mode before its menu, the
+        plan and the result."""
+        listing = self.listing("retroarch", [self.entry("a.bin", b"a", ["x"])])
+        args = _args(manifest=listing, dest=self.here, declared_only=False)
+        words = install.read_only_words(self.here)
+        with mock.patch.object(install, "_on_read_only_mount", return_value=True), \
+                mock.patch.object(install, "_folder_writable", return_value=False):
+            text, _asked = self.line_run(args, [])
+            state = checked_state({"free": 10 ** 9, "writable": False, "cores": []})
+            plan = " ".join(" ".join(install.tui_view(state, 120, 40)).split())
+            state.summary = {"installed": 0, "up_to_date": 0, "pending": 1, "kept": [],
+                             "failed": [{"dest": "a.bin", "reason": install.NOT_WRITABLE}],
+                             "skipped": [], "left_out": [], "interrupted": False}
+            state.code = 2
+            _title, result = install.tui_outcome(state)
+        menu = text[:text.index("Enter)")]
+        for said in (menu, plan, " ".join(result)):
+            self.assertIn(words, said)
+            self.assertNotIn("sudo", said)
+
+    def test_the_sudo_command_keeps_every_option_of_the_run(self):
+        """tui_audit_10 P2-3: the plan's sudo line dropped --from-pack and
+        --manifest, and with --offline stopped at the file list."""
+        state = checked_state({"free": 10 ** 9, "writable": False, "cores": []})
+        state.manifest_path, state.manifest_given = Path("/l/retroarch.json"), True
+        state.passthrough = [("--from-pack", "/p/RetroArch_BIOS_Pack.zip")]
+        with mock.patch.object(install, "_on_read_only_mount", return_value=False):
+            plan = " ".join(str(line) for line in install._plan_lines(state.check, state.dest,
+                                                                       state))
+        line = plan[plan.index("Or run it as root"):]
+        for option in ("--manifest /l/retroarch.json", "--from-pack /p/RetroArch_BIOS_Pack.zip",
+                       f"--dest {SYSTEM_DIR}"):
+            self.assertIn(option, line)
+
+    def test_the_save_files_are_counted_after_the_choice(self):
+        """tui_audit_10 P3-2: --system sony-playstation said 106 files went
+        to the save directory, none of them PlayStation's."""
+        here = self.root / "pc" / "system"
+        files = [self.entry("gba_bios.bin", b"gba", ["nintendo-gba"]),
+                 self.entry("Azahar/keys.txt", b"keys", ["nintendo-3ds"], root="save")]
+        listing = self.listing("retroarch", files, base_destination="system",
+                               save_directory={"folder": "saves", "by_core": False})
+        for system, count in ((["nintendo-gba"], 0), (["nintendo-3ds"], 1), (None, 1)):
+            args = dict(manifest=listing, dest=here, declared_only=False, system=system)
+            with self.subTest(system=system):
+                text, _asked = self.line_run(_args(**args), [])
+                events, _out = engine_events(_args(**args, check=True, events=True,
+                                                   no_input=True))
+                saves = [event for event in events if event["event"] == "saves"]
+                if count:
+                    self.assertIn("1 file read from RetroArch's save directory goes to", text)
+                    self.assertEqual([event["files"] for event in saves], [1])
+                else:
+                    self.assertNotIn("save directory", text)
+                    self.assertEqual(saves, [])
+
+    def test_a_list_that_leaves_out_save_files_says_so_before_the_menu(self):
+        """tui_audit_10 P3-4: ROCKNIX's 44 files left out were said after
+        the install only, as the frontend's, where the plan says them."""
+        omitted = [{"dest": f"saves/{n}.key", "name": f"{n}.key", "system": "",
+                    "systems": [], "required": False, "reason": "no_save_directory",
+                    "cores": None} for n in range(3)]
+        listing = self.listing("rocknix", [self.entry("a.bin", b"a", ["x"])],
+                               omitted_files=omitted)
+        card = self.card("ROCKNIX", "ROCKNIX")
+        args = _args(manifest=listing, dest=card, declared_only=False)
+        text, _asked = self.line_run(args, [])
+        said = "3 files read from ROCKNIX's save directory left out"
+        self.assertLess(text.index(said), text.index("Enter)"))
+        state = checked_state()
+        state.platform = "rocknix"
+        summary = {"skipped": [{"reason": "no_save_directory", "files": 3}]}
+        self.assertIn(said, " ".join(install._unplaced_lines(summary, state)))
+        # And the end of the run names it as the plan does.
+        seen = [{**entry, "frontend": "ROCKNIX"} for entry in omitted]
+        with contextlib.redirect_stdout(io.StringIO()) as out, \
+                contextlib.suppress(SystemExit):
+            install._report_outcome([self.here], 1, 0, 0, 3, False, omitted_entries=seen)
+        self.assertIn(said, out.getvalue())
+
+    def test_the_drives_mounted_here_are_offered_in_both(self):
+        """tui_audit_10 P3-6: the copy question listed no drive and took q
+        as a folder, and the screen's Which folder? listed none where line
+        mode numbered them."""
+        stick, onion = self.root / "media" / "USBSTICK", self.card("ONION", "Onion")
+        stick.mkdir(parents=True)
+        mounts = [stick]
+        with mock.patch.object(install, "_mounted_cards", return_value=mounts), \
+                contextlib.redirect_stdout(io.StringIO()) as out, \
+                mock.patch.object(install, "_ask", side_effect=["q"]), \
+                self.assertRaises(SystemExit) as stop:
+            install._ask_from_folder([], onion / "BIOS")
+        self.assertEqual(stop.exception.code, 130)
+        self.assertIn(f"1) {install.card_line(stick)}", out.getvalue())
+        with mock.patch.object(install, "_mounted_cards", return_value=[stick, onion]), \
+                contextlib.redirect_stdout(io.StringIO()) as out, \
+                mock.patch.object(install, "_ask", side_effect=["2", ""]):
+            install._ask_from_folder([], onion / "BIOS")
+        # The card installed to is not offered to copy from.
+        self.assertNotIn(str(onion), out.getvalue())
+        with mock.patch.object(install, "_mounted_cards", return_value=mounts), \
+                contextlib.redirect_stdout(io.StringIO()) as out, \
+                mock.patch.object(install, "_ask", side_effect=["1"]), \
+                mock.patch.object(install, "_missing_dest", return_value=True):
+            folder = install.ask_platform_folder("linux", "retroarch")
+        self.assertEqual(folder, stick)
+        state = install.TuiState(os_type="linux", home=HOME)
+        state.platform, state.stack = "retroarch", ["folder"]
+        state.folder_default, state.folder_kind = SYSTEM_DIR, "usual"
+        with mock.patch.object(install, "_mounted_cards", return_value=mounts):
+            rows = install.tui_rows(state)
+        self.assertEqual([row.value for row in rows if row.action == "drive"], [stick])
+
+    def test_the_systems_are_listed_by_title_in_the_screen_order(self):
+        """tui_audit_10 P3-7: line mode listed ids, nintendo-3ds before
+        nintendo-ds, where the screen lists titles."""
+        titles = {"nintendo-ds": "Nintendo DS", "nintendo-gba": "Nintendo Game Boy Advance"}
+        files = [self.entry("ds.bin", b"ds", ["nintendo-ds"]),
+                 self.entry("gba.bin", b"gba", ["nintendo-gba"]),
+                 self.entry("3ds.bin", b"3ds", ["nintendo-3ds"])]
+        manifest = {"system_titles": titles}
+        listing = self.listing("retroarch", files, **manifest)
+        text, _asked = self.line_run(_args(manifest=listing, dest=self.here,
+                                           declared_only=False), ["c"])
+        listed = text[text.index("Systems:"):]
+        places = [listed.index(label) for label in (
+            "1) Nintendo DS  nintendo-ds", "2) Nintendo Game Boy Advance  nintendo-gba",
+            "3) nintendo-3ds")]
+        self.assertEqual(places, sorted(places))
+        state = install.TuiState(os_type="linux", home=HOME)
+        state.manifest = {"files": files, **manifest}
+        state.systems = [{"system": system, "name": system, "missing": 1, "wrong_hash": 0,
+                          "bytes_needed": 2} for system in ("nintendo-3ds", "nintendo-ds",
+                                                            "nintendo-gba")]
+        order = [row["system"] for row in install._sorted_systems(state)]
+        self.assertEqual(order, ["nintendo-ds", "nintendo-gba", "nintendo-3ds"])
+
+    def test_the_card_question_looks_again_and_lists_blank_drives(self):
+        """tui_audit_10 P3-8: Enter at Card root never looked again, a
+        blank stick was listed for KNULLI on the screen alone, and the two
+        modes differed on creating its bios."""
+        onion = self.card("ONION", "Onion")
+        seen: list = []
+        answers = iter(["", "1"])
+
+        def answer(_prompt: str) -> str:
+            value = next(answers)
+            if not value:
+                # The card goes in while the question waits.
+                seen.append(onion)
+            return value
+
+        with mock.patch.object(install, "_mounted_cards", side_effect=lambda: list(seen)), \
+                mock.patch.object(install, "_mount_points", return_value=frozenset()), \
+                mock.patch.object(install, "_ask", side_effect=answer), \
+                contextlib.redirect_stdout(io.StringIO()) as out:
+            dest = install.card_install_dest("onion", "retroarch", True)
+        self.assertEqual(dest, onion / "BIOS")
+        self.assertIn(f"1) {install.card_line(onion)}", out.getvalue())
+        # KNULLI fills its card when it first starts: a blank drive is
+        # listed in both, after Look again on the screen, and its bios is
+        # created without a question in both.
+        stick = self.root / "media" / "USBSTICK"
+        stick.mkdir(parents=True)
+        with mock.patch.object(install, "_mounted_cards", return_value=[stick]), \
+                mock.patch.object(install, "_mount_points", return_value=frozenset()), \
+                mock.patch.object(install, "detect_platforms", return_value=[]), \
+                mock.patch.object(install, "detect_frontends", return_value=[]), \
+                mock.patch.object(install, "_ask", side_effect=["1"]), \
+                contextlib.redirect_stdout(io.StringIO()) as out:
+            dest = install.card_install_dest("knulli", "knulli", True)
+            state = screen_keys(_args(platform="knulli"), [])
+            rows = install.tui_rows(state)
+            self.assertEqual([row.action for row in rows][:2], ["rescan", "card"])
+            self.assertEqual(rows[state.focus["folder"]].action, "rescan")
+            press(state, "down", "enter")
+        self.assertEqual(dest, stick / "bios")
+        self.assertIn(f"1) {install.card_line(stick)}", out.getvalue())
+        self.assertEqual((state.dest, state.screen), (stick / "bios", "checking"))
+
+    def test_a_full_or_read_only_folder_is_said_before_enter(self):
+        """tui_audit_10 P3-9, P3-19: line mode showed Enter) install
+        everything over a full card and refused after it. On a card setup
+        both say to free space on the card."""
+        onion = self.card("ONION", "Onion")
+        listing = self.listing("retroarch", [self.entry("a.bin", b"a" * 4096, ["x"])])
+        usage = mock.Mock(free=1024)
+        with mock.patch.object(install.shutil, "disk_usage", return_value=usage), \
+                mock.patch.object(install, "dest_drive", return_value=onion):
+            install._DETECTED_OS[("retroarch", onion / "BIOS")] = "Onion"
+            text, _asked = self.line_run(_args(manifest=listing, dest=onion / "BIOS",
+                                               platform="retroarch", declared_only=False),
+                                         [], [onion])
+            state = checked_state({"free": 1024, "writable": True, "cores": []})
+            state.dest = onion / "BIOS"
+            install._DETECTED_OS[("retroarch", state.dest)] = "Onion"
+            plan = " ".join(" ".join(install.tui_view(state, 120, 40)).split())
+        menu = text[:text.index("Enter)")]
+        self.assertIn("Not enough free space: 4.0 KB needed, 1.0 KB free. Free some space "
+                      "on the card first.", menu)
+        self.assertIn("Free some space on the card first.", plan)
+
+    def test_a_device_typed_is_named_first(self):
+        """tui_audit_10 P3-12: "miyoo mini" listed MinUI with RG28XX, RG34XX
+        and RG34XX SP, where the screen's row names the Miyoo Mini."""
+        install.LOCAL.reset()
+        choices = install._line_setups([], set(), "linux")
+        found = install._line_matches(choices, "miyoo mini", [], set(), "linux")
+        rows = {install._row_name(row): row
+                for row in install.setup_list([], set(), "miyoo mini", "linux")}
+        self.assertTrue(found)
+        for index, label in found:
+            name = choices[index][0]
+            with self.subTest(setup=name):
+                self.assertIn("Miyoo Mini", label.split("(", 1)[1])
+                first = rows[name].right.split(", ")[0]
+                self.assertTrue(label.split("(", 1)[1].startswith(first), (label, first))
+
+    def test_line_mode_says_setup_where_the_screen_does(self):
+        """tui_audit_10 P3-13: "Detecting platform..." and "No supported
+        platform found here", where the screen says setup and "Nothing was
+        found here.\""""
+        text, _asked = self.line_run(_args(declared_only=False), [])
+        self.assertIn("Looking for setups here...", text)
+        self.assertIn("Nothing was found here. Which setup?", text)
+        self.assertNotIn("Detecting platform", text)
+        self.assertNotIn("No supported platform", text)
+        state = install.TuiState(os_type="linux", home=HOME)
+        state.stack = ["platforms"]
+        self.assertIn("Nothing was found here.", " ".join(install.tui_view(state, 80, 24)))
+
+    def test_yes_at_a_terminal_asks_nothing(self):
+        """tui_audit_10 P3-20: --yes waited at Install for: and at the menu."""
+        seen = []
+        with mock.patch.object(sys, "argv", ["install.py", "--yes", "--plain"]), \
+                mock.patch.object(install, "_run", side_effect=seen.append):
+            install.main()
+        self.assertTrue(seen[0].no_input)
+        self.assertIn("implies --no-input",
+                      " ".join(install.build_parser().format_help().split()))
+        # Asked nothing, with two setups found where the screen offers both.
+        pc = [("retroarch", self.here), ("retroarch", self.root / "other")]
+        seen[0].manifest = self.list
+        with mock.patch.dict(os.environ, {install.OFFLINE_VARIABLE: "1"}):
+            _text, asked = self.line_run(seen[0], [], found=pc)
+        self.assertEqual(asked, [])
+
+
+class AuditSeventeenAndTen(unittest.TestCase):
+    """code_audit_17 and tui_audit_10: what the screen, the packs, the
+    wording and the docs answer, line mode's parity being in
+    LineModeAndScreenDecideAlike."""
+
+    def setUp(self):
+        self.root = Path(tempfile.mkdtemp(dir=REPO_ROOT / "tmp"))
+        self.addCleanup(shutil.rmtree, self.root, True)
+        install.LOCAL.reset()
+        self.addCleanup(install.LOCAL.reset)
+
+    @unittest.skipUnless(pyte and pty and hasattr(pty, "fork") and shutil.which("script"),
+                         "the line mode run needs a pty")
+    def test_the_printed_command_makes_the_same_choice(self):
+        """code_audit_17 P2-4, tui_audit_10 P2-1: "Same choice without
+        questions" left out the folder chosen at a question and the file
+        list, and installed elsewhere or was refused. Run as printed, it
+        finds every file of the choice in place and nothing else."""
+        with FakeRepository() as repo:
+            home = repo.root / "home"
+            home.mkdir()
+            listing = repo.root / "install" / "retroarch.json"
+            env = {**repo.env(), "HOME": str(home), "RETROBIOS_OS": "linux", "TERM": "xterm",
+                   "XDG_CONFIG_HOME": str(home / ".config")}
+            env.pop("RETROBIOS_BOOTSTRAP", None)
+            command = " ".join(shlex.quote(part) for part in [
+                sys.executable, str(REPO_ROOT / "install.py"), "--plain",
+                "--manifest", str(listing)])
+            proc = subprocess.run(
+                ["script", "-qec", command, "/dev/null"],
+                input=f"{repo.dest}\nc\n2\n\n2\n\n", env=env, capture_output=True,
+                text=True, timeout=120, check=False)
+            self.assertEqual(proc.returncode, 0, proc.stdout + proc.stderr)
+            installed = repo.installed()
+            self.assertEqual(installed, ["pcsx/extra.bin", "scph5501.bin"])
+            printed = re.search(r"Same choice without questions: (.+)", proc.stdout)[1]
+            words = shlex.split(printed.strip())
+            self.assertEqual(words[:2], ["python3", "install.py"])
+            for option in ("--dest", "--manifest", "--system"):
+                self.assertIn(option, words)
+            again = subprocess.run(
+                [sys.executable, str(REPO_ROOT / "install.py"), *words[2:], "--dry-run",
+                 "--events"], env=env, capture_output=True, text=True, timeout=120,
+                check=False, stdin=subprocess.DEVNULL)
+            files = [json.loads(line) for line in again.stdout.splitlines()
+                     if '"event": "file"' in line]
+            self.assertEqual(sorted(event["dest"] for event in files), installed)
+            self.assertTrue(all(event["state"] == "present" for event in files))
+
+    # tui_audit_10 P2-4: a pack's own list records its systems.
+
+    def test_a_pack_records_the_systems_of_its_files(self):
+        sys.path.insert(0, str(REPO_ROOT / "scripts"))
+        self.addCleanup(sys.path.remove, str(REPO_ROOT / "scripts"))
+        import generate_pack  # noqa: PLC0415
+
+        install_list = {"files": [{"dest": "a.bin", "systems": ["3do"]},
+                                  {"dest": "b/c.bin", "systems": []}],
+                        "system_titles": {"3do": "3DO Interactive Multiplayer"},
+                        "system_names": {"3do": ["3do"]}}
+        manifest = {"files": [{"path": "a.bin"}, {"path": "b/c.bin"}, {"path": "README.md"}]}
+        generate_pack.annotate_pack_systems(manifest, generate_pack.pack_systems(install_list))
+        self.assertEqual([entry.get("systems") for entry in manifest["files"]],
+                         [["3do"], [], None])
+        self.assertEqual(manifest["system_titles"], {"3do": "3DO Interactive Multiplayer"})
+        source = (REPO_ROOT / "scripts" / "generate_pack.py").read_text(encoding="utf-8")
+        self.assertIn("pack_systems_by_name=systems_for", source)
+        schema = json.loads((REPO_ROOT / "schemas" / "pack-manifest.schema.json").read_text())
+        self.assertIn("systems", schema["properties"]["files"]["items"]["properties"])
+
+    def pack(self, systems: bool) -> Path:
+        from test_install_offline import GBA, US  # noqa: PLC0415
+
+        members = {"scph5501.bin": US, "gba_bios.bin": GBA}
+        listed = [{"path": path, "sha1": hashlib.sha1(data).hexdigest(),
+                   "md5": hashlib.md5(data).hexdigest(), "size": len(data),
+                   "status": "verified", "name": path,
+                   **({"systems": ["sony-playstation" if "scph" in path else "nintendo-gba"]}
+                      if systems else {})} for path, data in members.items()]
+        folder = self.root / ("new" if systems else "old")
+        folder.mkdir()
+        path = folder / "RetroArch_v1_BIOS_Pack.zip"
+        with zipfile.ZipFile(path, "w") as archive:
+            for member, data in members.items():
+                archive.writestr(member, data)
+            archive.writestr("manifest.json", json.dumps({
+                "files": listed, **({"system_titles": {"nintendo-gba": "Game Boy Advance"}}
+                                    if systems else {})}))
+        return path
+
+    def test_system_works_with_a_pack_alone(self):
+        dest = self.root / "system"
+        dest.mkdir()
+        new = self.pack(True)
+        events, _text = engine_events(_args(from_pack=[new], dest=dest, platform="retroarch",
+                                            system=["nintendo-gba"], check=True, events=True,
+                                            no_input=True, declared_only=False))
+        files = [event["dest"] for event in events if event["event"] == "file"]
+        self.assertEqual(files, ["gba_bios.bin"])
+        # The screen offers Choose systems with that pack, titled from it.
+        install.LOCAL.pack = install.PackSource([new])
+        manifest = install.LOCAL.pack.manifest("retroarch")
+        self.assertEqual(manifest["system_titles"], {"nintendo-gba": "Game Boy Advance"})
+        state = checked_state()
+        state.manifest = manifest
+        self.assertIn("systems", [row.action for row in install.tui_rows(state)])
+        # An older pack names the remedy that works.
+        old = self.pack(False)
+        install.LOCAL.reset()
+        err = io.StringIO()
+        install.LOCAL.pack = install.PackSource([old])
+        with contextlib.redirect_stderr(err), self.assertRaises(SystemExit):
+            install._requested_narrowing(_args(system=["nintendo-gba"]), "retroarch",
+                                         install.LOCAL.pack.manifest("retroarch")["files"], [])
+        self.assertIn("add --manifest FILE, a copy of install/retroarch.json", err.getvalue())
+        self.assertNotIn("older release", err.getvalue())
+
+    def test_the_home_folder_is_said_on_the_plan(self):
+        """tui_audit_10 P2-5: the plan named ~ and said nothing more."""
+        state = checked_state()
+        state.dest = state.home
+        lines = " ".join(str(line) for line in install._plan_lines(state.check, state.dest,
+                                                                     state))
+        self.assertIn("No setup reads BIOS files in your home folder.", lines)
+
+    def test_systems_seen_and_left_unchanged_keep_the_exact_plan(self):
+        """tui_audit_10 P3-1: opening Choose systems on a --system plan and
+        going back turned the exact plan into an estimate."""
+        state = checked_state()
+        state.cli_systems = ["nintendo-gba"]
+        state.systems = [row for row in state.systems if row["system"] == "nintendo-gba"]
+        state.ticked = {"nintendo-gba"}
+        state.checked_flags = install.tui_flags(state)
+        exact = install.tui_view(state, 80, 24)
+        rows = install.tui_rows(state)
+        state.focus["plan"] = next(i for i, row in enumerate(rows) if row.action == "systems")
+        press(state, "enter")
+        self.assertEqual(state.screen, "checking")
+        # The check of every system comes back, the ticks kept.
+        for event in [*FILES, *SYSTEMS, CHECK]:
+            install.tui_receive(state, ("event", state.run_id, event))
+        with mock.patch.object(install, "_tui_folder_facts", return_value={
+                "free": 50 * 1024 ** 3, "writable": True, "cores": []}):
+            install.tui_receive(state, ("ended", state.run_id, 0, []))
+        self.assertEqual((state.screen, state.ticked), ("systems", {"nintendo-gba"}))
+        press(state, "esc")
+        self.assertEqual(state.screen, "plan")
+        self.assertEqual(install.tui_view(state, 80, 24), exact)
+        # Ticks changed: an estimate, without the whole list's counts.
+        state.focus["plan"] = next(i for i, row in enumerate(install.tui_rows(state))
+                                   if row.action == "systems")
+        press(state, "enter")
+        for event in [*FILES, *SYSTEMS, CHECK]:
+            install.tui_receive(state, ("event", state.run_id, event))
+        with mock.patch.object(install, "_tui_folder_facts", return_value={
+                "free": 50 * 1024 ** 3, "writable": True, "cores": []}):
+            install.tui_receive(state, ("ended", state.run_id, 0, []))
+        state.ticked = {"sony-playstation"}
+        press(state, "esc")
+        text = " ".join(install.tui_view(state, 120, 40))
+        self.assertIn("About", text)
+        self.assertNotIn(f"{CHECK['present']} in place,", text)
+
+    def test_the_copy_browser_leaves_the_card_being_installed_to(self):
+        """tui_audit_10 P3-5: the card installed to was focused and taken,
+        and WSL rows read /mnt/d where every other screen writes D:."""
+        dest_card, old = self.root / "d", self.root / "e"
+        make_card(dest_card, "Onion")
+        old.mkdir()
+        state = install.TuiState(os_type="wsl", home=self.root / "home")
+        (self.root / "home").mkdir()
+        state.platform, state.dest = "retroarch", dest_card / "BIOS"
+        with mock.patch.object(install, "_mounted_cards", return_value=[dest_card, old]), \
+                mock.patch.dict(install._WSL, {"active": True, "root": str(self.root)}):
+            install._open_from_browser(state)
+            rows = install.tui_rows(state)
+            self.assertEqual(rows[state.focus["browse"]].value, old)
+            self.assertIn("D: (Onion card)", [row.label for row in rows])
+            state.focus["browse"] = next(i for i, row in enumerate(rows)
+                                         if row.value == dest_card)
+            press(state, "enter")
+            press(state, "enter")
+        self.assertEqual(state.screen, "browse")
+        self.assertIn("That is the card being installed to", state.status)
+        self.assertEqual(state.from_folders, [])
+
+    def test_typing_a_filter_names_the_keys_that_end_it(self):
+        """tui_audit_10 P3-10: while typing, the bar named Tick and Help,
+        the focus stayed on None, F1 ended the typing, and a filter that
+        matched nothing said nothing."""
+        state = checked_state()
+        press(state, "down", "enter")
+        self.assertEqual(state.screen, "systems")
+        press(state, "/")
+        rows = install.tui_rows(state)
+        self.assertEqual(rows[state.focus["systems"]].action, "filter")
+        bar = install.tui_view(state, 80, 24)[-1]
+        self.assertEqual(bar.strip(), "Enter Done  Esc Clear")
+        press(state, "s", "e", "g", "a", " ", "?")
+        self.assertEqual(state.filters["systems"], "sega ?")
+        self.assertIn("No system matches 'sega ?'.", " ".join(install.tui_view(state, 80, 24)))
+        press(state, "f1")
+        self.assertTrue(state.help)
+        press(state, "x")
+        self.assertEqual((state.help, state.editing), (False, "systems"))
+
+    def test_a_computer_finds_its_own_setups(self):
+        """tui_audit_10 P3-11: windows and mac matched nothing, RetroBat
+        came 27th on Windows, and a Batocera SHARE drive was not found."""
+        names = {install._row_name(row) for row in install.setup_list([], set(), "windows",
+                                                                      "windows")}
+        self.assertEqual(names, {"retroarch", "retrobat", "emudeck", "bizhawk"})
+        self.assertEqual({install._row_name(row) for row in install.setup_list(
+            [], set(), "mac", "darwin")}, {"retroarch"})
+        for os_type in ("windows", "wsl"):
+            rows = [install._row_name(row) for row in install.setup_list([], set(), "", os_type)]
+            self.assertEqual(rows[:3], ["retroarch", "retrobat", "emudeck"], os_type)
+        share = self.root / "SHARE"
+        (share / "system").mkdir(parents=True)
+        (share / "system" / "batocera.conf").write_text("system.hostname=BATOCERA\n")
+        with mock.patch.object(install, "_mounted_cards", return_value=[share]), \
+                mock.patch.object(install, "_mount_points", return_value=frozenset()), \
+                mock.patch.object(install, "detect_platforms", return_value=[]), \
+                mock.patch.dict(install._DETECTED_OS, {}):
+            setups, mounted = install.found_setups("linux")
+        self.assertEqual(setups, [("batocera", share / "bios", "Batocera SHARE drive (SHARE)")])
+        self.assertEqual(mounted, {("batocera", share / "bios")})
+
+    def test_a_pack_preview_installs_from_the_pack(self):
+        """tui_audit_10 P3-15: "23 files to download" on a --from-pack run."""
+        state = checked_state()
+        state.stack.append("preview")
+        state.dry = dict(CHECK)
+        install.LOCAL.pack = mock.Mock(name="pack")
+        self.assertIn("to install from the pack", install._pager_items(state)[0])
+
+    def test_scroll_is_named_only_where_the_text_scrolls(self):
+        """tui_audit_10 P3-16: "Up/Down Scroll" over nine lines that fit."""
+        state = checked_state()
+        state.stack = ["result"]
+        state.summary = {"installed": 1, "up_to_date": 0, "pending": 0, "failed": [],
+                         "kept": [], "skipped": [], "left_out": [], "interrupted": False}
+        state.code = 0
+        self.assertNotIn("Scroll", install.tui_view(state, 80, 40)[-1])
+        state.summary["failed"] = [{"dest": f"f{n}.bin", "reason": f"r{n}"} for n in range(20)]
+        self.assertIn("Scroll", install.tui_view(state, 80, 12)[-1])
+
+    def test_gptokeyb_names_select_then_start(self):
+        """tui_audit_10 P3-17: "Start+Select" on the bars, "Select, then
+        Start" in the help and the docs."""
+        state = checked_state()
+        state.pad = "gptokeyb"
+        state.stack.append("checking")
+        self.assertIn("Select+Start Quit", install.tui_view(state, 80, 24)[-1])
+        self.assertEqual(install.TUI_ROUTES["gptokeyb"].stop[1], "B or Select+Start")
+
+    def test_nothing_to_confirm_is_titled_so(self):
+        """tui_audit_10 P3-18: Confirm over nothing to confirm, offline."""
+        state = checked_state()
+        state.stack.append("confirm")
+        state.dry = dict(CHECK)
+        with mock.patch.dict(os.environ, {install.OFFLINE_VARIABLE: "1"}):
+            self.assertIn("Nothing to install", install.tui_view(state, 80, 24)[0])
+
+    def test_another_folder_for_a_card_setup_asks_for_its_card(self):
+        """tui_audit_10 P3-19: a full Onion card offered another folder for
+        RetroArch, and the result said to choose another folder."""
+        onion = self.root / "ONION"
+        make_card(onion, "Onion")
+        state = checked_state({"free": 1024, "writable": True, "cores": []})
+        state.dest = onion / "BIOS"
+        with mock.patch.object(install, "_mounted_cards", return_value=[onion]), \
+                mock.patch.dict(install._DETECTED_OS, {("retroarch", onion / "BIOS"): "Onion"}):
+            plan = " ".join(install.tui_view(state, 120, 40))
+            self.assertIn("Free some space on the card first.", plan)
+            rows = install.tui_rows(state)
+            state.focus["plan"] = next(i for i, row in enumerate(rows) if row.action == "folder")
+            press(state, "enter")
+            view = " ".join(install.tui_view(state, 120, 40))
+            state.stack = ["result"]
+            state.tail = ["Needed: 87.9 KB. Free: 36.0 KB."]
+            _title, lines = install.tui_outcome(state)
+        self.assertEqual(state.card_bound, ("Onion", "BIOS"))
+        self.assertIn("The BIOS folder chosen for Onion:", view)
+        self.assertIn("Free some space on the card, then run again.", lines)
+
+    def test_the_dest_example_is_this_systems(self):
+        """code_audit_17 P3-4: /media/$USER/SHARE/bios on macOS and Windows."""
+        self.assertEqual(install.drive_example("darwin", "SHARE", "bios"), "/Volumes/SHARE/bios")
+        self.assertEqual(install.drive_example("wsl", "SHARE", "bios"), "/mnt/e/bios")
+        self.assertEqual(install.drive_example("windows", "SHARE", "bios", "batocera"),
+                         "\\\\BATOCERA\\share\\bios")
+        self.assertEqual(install.drive_example("windows", "<card>"), "E:\\")
+        self.assertEqual(install.drive_example("linux", "<card>"), "/media/$USER/<card>")
+
+    def test_the_copy_browser_opens_on_a_path_without_dot_dot(self):
+        """code_audit_17 P3-5: --from t/../packx opened the browser on t/.."""
+        packx = self.root / "packx"
+        packx.mkdir()
+        state, _effects = install.tui_start(
+            _args(**{"from": [str(self.root / "t" / ".." / "packx")]}), "linux", detect=False)
+        self.assertEqual(state.from_folders, [packx])
+
+    def test_no_clause_semicolon_in_what_the_installer_prints(self):
+        """code_audit_17 P3-6."""
+        self.assertNotIn("; ", " ".join(install.build_parser().format_help().split()))
+        source = Path(install.__file__).read_text(encoding="utf-8")
+        for said in ("to fetch them; a file", "every board; --target", "with the system; ",
+                     "no core list; ", "{retrodeck_json}; assuming", "REGION_ALIASES)}; ",
+                     "extracted; ~/.config", "read-only; 1 once"):
+            self.assertNotIn(said, source)
+
+    def test_the_docs_say_what_the_installer_does(self):
+        """code_audit_17 P3-7."""
+        page = (REPO_ROOT / "wiki" / "installer.md").read_text(encoding="utf-8")
+        menu = page[page.index("RetroArch: 8069 files, 6.5 GB."):]
+        menu = menu[:menu.index("```")]
+        self.assertIn("BIOS folder:", menu)
+        self.assertIn("f) copy from a folder or an old card", menu)
+        env = page[page.index("## Environment overrides"):]
+        self.assertIn("`TERMINFO`", env)
+        self.assertIn("`TERMINFO_DIRS`", env)
+        script = (REPO_ROOT / "scripts" / "generate_installer_doc.py").read_text(encoding="utf-8")
+        self.assertEqual([n for n, line in enumerate(script.splitlines(), 1) if len(line) > 100],
+                         [])
+
 
 class OneDeviceRegistry(unittest.TestCase):
     """code_audit_15 P2-1, tui_audit_8 P3-2, P3-3, P3-4: one device spelled
@@ -6584,7 +7540,8 @@ class OneDeviceRegistry(unittest.TestCase):
         for setups in ([], [("retroarch", SYSTEM_DIR, "RetroArch")]):
             with self.subTest(found=bool(setups)):
                 rows = install.setup_list(setups, set(), "", "linux")
-                self.assertEqual([name for name, _label in install._line_setups(setups)],
+                self.assertEqual([name for name, _label in install._line_setups(setups, None,
+                                                                                 "linux")],
                                  [install._row_name(row) for row in rows])
         labels = dict(install._line_setups())
         self.assertIn("RG28XX", labels["minui"])
@@ -6931,7 +7888,7 @@ class AuditSixteenAndNineLineMode(unittest.TestCase):
                 self.assertRaises(SystemExit) as stop:
             install.card_install_dest("rocknix", "rocknix", interactive=True)
         self.assertEqual(stop.exception.code, 130)
-        self.assertEqual(asked, ["Card root, q to quit: "])
+        self.assertEqual(asked, ["Card root, Enter to look again, q to quit: "])
 
     def test_install_for_takes_enter_and_offers_another_setup(self):
         """tui_audit_9 P2-3, P3-11: no Enter default, an All the screen does
diff --git a/tests/test_site_r2_wiki.py b/tests/test_site_r2_wiki.py
index 3ceac2a95..173439b68 100644
--- a/tests/test_site_r2_wiki.py
+++ b/tests/test_site_r2_wiki.py
@@ -301,7 +301,7 @@ class TroubleshootingLines(unittest.TestCase):
     def test_the_installer_names_what_to_run(self):
         source = (REPO_ROOT / "install.py").read_text(encoding="utf-8")
         advice = source[source.index("def _write_advice"):source.index("def _plural")]
-        self.assertIn("_INVOCATION.command(plat, path, elevated=True)", advice)
+        self.assertIn("hint.command(plat, path, elevated=True)", advice)
 
 
 class DiagramText(unittest.TestCase):
diff --git a/wiki/installer.md b/wiki/installer.md
index bb74c8f9b..0778d34f8 100644
--- a/wiki/installer.md
+++ b/wiki/installer.md
@@ -177,7 +177,7 @@ install starts.
 | Options | `o`, Tab | Y |
 | Filter a long list | `/` then type, Enter on a lone match chooses it | muxterm: Select shows a keyboard. Elsewhere none (the setup list puts the SD cards after RetroArch) |
 | Keys of the screen | `?`, F1 | |
-| Stop an install | Esc, `q`, Ctrl+C | B, Start+Select (B alone with muxterm's own keys) |
+| Stop an install | Esc, `q`, Ctrl+C | B, Select+Start (B alone with muxterm's own keys) |
 | Quit | `q`, Ctrl+C | B on the first screen |
 | Pause, back with `fg` (Linux, macOS) | Ctrl+Z | |
 
@@ -193,7 +193,7 @@ on a console no launcher named, it gives both spellings (`A/Enter`, `B/Esc`),
 and a narrow screen shortens them to `A`, `B` and `X`. On the
 regions screen, Left and Right move the region under the cursor up and down the
 order of preference. During the download, a stop waits for the files in
-progress, and a second one stops at once. Start+Select on a handheld ends the
+progress, and a second one stops at once. Select+Start on a handheld ends the
 installer with a signal (SIGTERM), which stops it the same way. Either way the
 result says how many files were installed, and it stays printed in the terminal
 once the screen closes, with the command that repeats the run. A run that failed
@@ -329,7 +329,7 @@ command never writes one.
 ```
 RetroBIOS 8c0e9c762d2f
 
-Detecting platform...
+Looking for setups here...
   Found Batocera at /userdata/bios
 ```
 
@@ -600,9 +600,11 @@ same choice comes as questions after detection:
 
 ```
 RetroArch: 8069 files, 6.5 GB.
+  BIOS folder: /home/me/.config/retroarch/system
   Enter) install everything
   i) only what the installed cores read: 100 files, 44.2 MB
   c) choose systems, cores and regions
+  f) copy from a folder or an old card
   q) quit
 ```
 
@@ -615,10 +617,12 @@ the rule `--installed-cores` applies.
 `c` walks through three numbered lists, each answered with numbers such as
 `1,4,7-9`, or Enter to keep everything on that axis.
 
-- **Systems.** The consoles and computers the platform declares. A last
-  entry, `other`, holds what cores load for systems the platform does not
-  list, such as game engines and extra computers. Choosing systems leaves it
-  out unless it is chosen too, as `generate_pack.py --system` does.
+- **Systems.** The consoles and computers the platform declares, titled and
+  ordered as the full screen's Choose systems lists them, the id `--system`
+  takes after each title. A last entry, `Other systems and game engines`,
+  holds what cores load for systems the platform does not list, such as game
+  engines and extra computers. Choosing systems leaves it out unless it is
+  chosen too, as `generate_pack.py --system` does.
 - **Cores.** The platform's own BIOS list for the chosen systems is always
   kept. This narrows only the extra files each emulator core loads beyond it.
   Asked only when the chosen systems have such files.
@@ -626,9 +630,12 @@ the rule `--installed-cores` applies.
   numbers give an order of preference: `2,1` keeps the second region where a
   file for it exists, and the first one elsewhere.
 
-The run then prints the options that repeat the same choice without
-questions, for instance
-`--platform retroarch --system sony-playstation --region north-america`.
+Nothing is written yet: the menu comes back counted for the choice, as the
+full screen's Confirm does, with the command that makes the same choice
+without questions, every other option of the run in it, for instance
+`python3 install.py --platform retroarch --dest /home/me/.config/retroarch/system
+--system sony-playstation --region north-america`. Enter then installs, and
+`c` chooses again.
 
 The same choices on the command line:
 
@@ -1212,7 +1219,7 @@ gets the column that names both:
 | Options | o, Tab | Y, o, Tab | Y, Tab, o | Y, Tab, o | o, Tab | Y, Tab, o | L2, Tab, o |
 | Back, and quit on the first screen | Esc, Backspace | B/Esc, Backspace | B, Select, Esc | B, Select, Esc | B, Esc, Backspace | B, Select, Esc | R2, Esc, Backspace |
 | Stop an install | Esc, Ctrl-C | B/Esc, Ctrl-C | B, Esc, Ctrl-C | B, Esc, Ctrl-C | B, Esc, Ctrl-C | B, Esc, Ctrl-C | R2, Esc, Ctrl-C |
-| Quit at once | none | Start+Select | Select, then Start | Select, then Start | none | none | none |
+| Quit at once | none | Select+Start | Select, then Start | Select, then Start | none | none | none |
 | Use the folder typed | Enter | Enter | A, Enter | A, Enter | Start, Enter | A, Enter | Start, Enter |
 | Clear a filter, leave the folder typed | Esc | Esc | B, Esc | B, Esc | Esc | B, Esc | Esc |
 
@@ -1417,7 +1424,7 @@ fields, the installer refuses to narrow rather than install everything.
 
 <!-- /generated: exit-codes -->
 
-The full screen ended by SIGTERM (Start+Select on a handheld) before any
+The full screen ended by SIGTERM (Select+Start on a handheld) before any
 install exits `143`. During an install it stops the install first, and exits
 `130`. Its window or terminal closed (SIGHUP) exits `129`, during an install
 too: the install is stopped as Ctrl+C stops it, and the last lines go
@@ -1459,6 +1466,7 @@ other schemas under `api/v1/schemas/`.
 | `detect` | `os`, `os_name`, `platforms` | Once the platforms are known. `os_name` comes from `/etc/os-release`. `platforms` lists `{platform, name, bios_dir}`, and is empty when nothing supported was found |
 | `error` | `stage`, `reason`, `platform`, `message` | The file list could not be read (`stage` is `manifest`): `reason` is `network`, `not_found` or `invalid`, `clock` when the server's certificate was refused and the system clock reads a date before the installer was written, `no_ca` when the machine holds no list of trusted certificates (`SSL_CERT_FILE` names one), or `offline` when `--offline` forbids the request. A folder named with `--from` cannot be read (`stage` is `from`, `reason` `not_found`, `not_a_folder` for a file that is no ZIP, `unreadable`, or `system` for the root of the system, `/proc`, `/sys` or `/dev`). The BIOS folder sits under a folder this user cannot open (`stage` is `dest`, `reason` `unreadable`), and the run ends with code 1 before anything is written. The BIOS folder cannot be created (`stage` is `dest`, `reason` `not_writable`): a `summary` follows with what the run installed before it. Two systems are detected on one machine and no `--dest` names the folder (`stage` is `detect`, `reason` `conflict`). The platform named with `--platform` is found nowhere and no folder can be assumed for it: a card system with no card named, a portable emulator, Batocera or Recalbox named on a computer (their folder is the `bios` folder of their SHARE drive), or no usual folder on this system or one set aside behind a folder this user cannot open (`stage` is `detect`, `reason` `not_found`). A `--dest` refused as the card of the system named carries the same `stage` and `reason`: another system's card, a folder inside a card, a drive with none of the files its card always has, or a folder that does not exist. `message` says it in words, and is the only thing that tells these cases apart |
 | `scanned` | `folder`, `files`, `truncated`, `other_drives` | Each folder named with `--from`, once read and before `detect`. `files` counts the files found, `truncated` is true when the search stopped at 200,000 of them, and `other_drives` lists the folders below it on another drive, which were not entered |
+| `choices` | `platform`, `systems` | Before `checking`: the systems the run's list lets one choose among, sorted by id, `other` last for the files no system names. The run's other options apply (`--core`, `--region`, `--no-game-data`, the files left out for an unknown save directory), `--system` does not: these are the systems a screen lists to choose from, and the count a `--system` is out of |
 | `file` | `platform`, `dest`, `systems`, `size`, `state` | Each file of the list after the check. `state` is `present` (hash verified), `wrong_hash` or `missing` |
 | `system` | `platform`, `system`, `name`, `files`, `present`, `missing`, `wrong_hash`, `bytes_needed` | Each system, sorted by id, and with `--system` only the systems named. Files with no system count under `other`. `name` is the platform's own name for it |
 | `checking` | `files_done`, `files_total` | While the files already in the folder are read and hashed, at most every half second and once at the end. `files_total` counts the files found in place |
@@ -1467,7 +1475,7 @@ other schemas under `api/v1/schemas/`.
 | `data` | `platform`, `files`, `bytes` | Right after `declared`: the data-tree files to fetch (the `data_missing` of `check`) and the bytes they write once in place |
 | `found` | `platform`, `dest`, `folder`, `path`, `member`, `reason` | Each file to install that this machine already holds, after `check` and before anything is written, in `--check` and `--dry-run` too. `folder` is the `--from` folder as given, or the `bios_dir` of the check when the BIOS folder holds the file at another place, and then `reason` says where in words (`nested folder: ...` for a misplaced file, `the same file is at ...` for one the list installs there too). `path` is the file, and `member` the ZIP member holding the bytes when `path` is an archive, an empty string otherwise. Its copy is reported by a `downloaded` event |
 | `unreadable` | `platform`, `folder`, `path`, `member`, `reason` | Each file in a `--from` folder that could not be read and may be one the run still needs, right after the `found` events: its size is that of a file no copy was found for, or unknown (a folder that could not be listed, a ZIP that would not open). `member` names the ZIP member, or is empty. `reason` says why in words (`Permission denied`, `it is encrypted, a password is needed`) |
-| `saves` | `platform`, `files`, `folder` | After `detect` and before `checking`, when the list holds files read from the frontend's save directory and that directory is known: how many, and the `folder` they go to, where `<system>` and `<core>` stand for one folder per system or per core. When it is not known, the files are counted in the summary's `skipped` instead (`no_save_directory`) |
+| `saves` | `platform`, `files`, `folder` | After `choices` and before `checking`, when the files the run installs (once `--system` and the other choices narrowed the list) hold some read from the frontend's save directory and that directory is known: how many, and the `folder` they go to, where `<system>` and `<core>` stand for one folder per system or per core. When it is not known, the files are counted in the summary's `skipped` instead (`no_save_directory`) |
 | `download` | `platform`, `files`, `bytes` | Before the downloads start. Counts the files copied from this machine too |
 | `progress` | `files_done`, `files_total`, `bytes_done`, `bytes_total` | At most every half second while bytes arrive |
 | `transfer` | `bytes_local`, `bytes_network` | Right after each `progress` event, and once when the files of a `download` event are done. It splits `bytes_done`: `bytes_local` came from this machine (a copy found by `--from` or in the BIOS folder, the pack, a partial copy resumed), `bytes_network` from the network. A download speed is `bytes_network` over the time elapsed |
@@ -1509,6 +1517,7 @@ RetroArch folder that holds only `scph5501.bin`, in the order written:
 | `RETROBIOS_INSTALL_SHA256` | The SHA-256 the bootstrap requires of that installer, 64 hex characters. When either of these two is set and the fingerprint does not match, the error names the variable instead of suggesting a retry |
 | `RETROBIOS_BOOTSTRAP` | Set by `install.sh` (`sh`) and `install.ps1` (`ps1`) for the temporary installer they run, so that its hints give back the one-line command rather than `python3 install.py` |
 | `NO_COLOR` | Plain text, no colour, even at a terminal, when set to any value but an empty one. `TERM=dumb`, or no `TERM` outside Windows, also turns the live progress line and the colour off, as does a terminal whose description moves no cursor the ANSI way (`TERM=vt52`). The full screen draws no colour at all: the row in focus is marked with `>` as well as reverse video, and every state is written in words |
+| `TERM`, `TERMINFO`, `TERMINFO_DIRS` | Decide whether the full screen opens. `TERM` unset or `dumb` (outside Windows) gives the questions line by line. Otherwise the terminal's description is read where ncurses reads it: `TERMINFO`, then `~/.terminfo`, then each folder of `TERMINFO_DIRS`, then the system's own. A description whose cursor moves are not the ANSI ones the screen writes (`TERM=vt52`) gives the questions too, and `--tui` there stops with the reason |
 | `FORCE_COLOR`, `CLICOLOR_FORCE` | Colour even when the output is a pipe or a file, set to any value but `0` or an empty one. `NO_COLOR` wins over both, and the progress line stays one line per file |
 | `SSL_CERT_FILE`, `SSL_CERT_DIR` | The trusted certificates to check servers with, for a Python that finds none of its own |
 | `RETROBIOS_PLAIN`, `ACCESSIBLE` | Set to anything but `0`: the questions come line by line, as with `--plain`, instead of the full-screen interface |