0.9.5: add games from your libraries, 320 game templates, Linux desktop fixes #85

Merged
ethan-hann merged 52 commits from integration-095 into main 2026-10-24 16:06:32 -05:00
Owner

Add games from your libraries (#70, D52): a checklist of the installed Steam and GOG games, matched to templates, confirmed once with every folder named, added through the single add's checks. GOG Galaxy's own folders are protected like Steam's. Games started through a store link get a suggested process name.

Templates for about 320 games (#69, D53): every template checked against its PCGamingWiki page through its Steam app id; 152 carry a saves folder, the rest say why the player picks it. Linux and macOS drafts use only their own entries. The template picker searches and keeps its buttons in view.

Sessions (#74, D48.7): a game started directly that relaunches through Steam is followed to the new copy instead of ending after a second; a normal quit still ends at once, and the wait is never counted as play time.

Toasts float over the shell instead of pushing it up (#73); the page lifts its pinned content above them.

Linux, found on a real Ubuntu 26.04 desktop: GNOME banners now show (one D-Bus connection kept open, #75), a second start raises the first window (#76), the window class matches the desktop entry and a missing display prints a plain message (#78), a case-only name clash on a case-insensitive drive is refused before anything is written (#77), the switch dialog names only what changes, the tour card keeps off the profile rows, and a flaky session test is deterministic (#79).

Bundled git sources move to their own release (git-sources-2.56.0.2), so app releases list only the app downloads (D21).

Each part was reviewed by Opus and the findings fixed here. Version 0.9.5.

Closes #69, closes #70, closes #73, closes #74, closes #75, closes #76, closes #77, closes #78, closes #79

Add games from your libraries (#70, D52): a checklist of the installed Steam and GOG games, matched to templates, confirmed once with every folder named, added through the single add's checks. GOG Galaxy's own folders are protected like Steam's. Games started through a store link get a suggested process name. Templates for about 320 games (#69, D53): every template checked against its PCGamingWiki page through its Steam app id; 152 carry a saves folder, the rest say why the player picks it. Linux and macOS drafts use only their own entries. The template picker searches and keeps its buttons in view. Sessions (#74, D48.7): a game started directly that relaunches through Steam is followed to the new copy instead of ending after a second; a normal quit still ends at once, and the wait is never counted as play time. Toasts float over the shell instead of pushing it up (#73); the page lifts its pinned content above them. Linux, found on a real Ubuntu 26.04 desktop: GNOME banners now show (one D-Bus connection kept open, #75), a second start raises the first window (#76), the window class matches the desktop entry and a missing display prints a plain message (#78), a case-only name clash on a case-insensitive drive is refused before anything is written (#77), the switch dialog names only what changes, the tour card keeps off the profile rows, and a flaky session test is deterministic (#79). Bundled git sources move to their own release (git-sources-2.56.0.2), so app releases list only the app downloads (D21). Each part was reviewed by Opus and the findings fixed here. Version 0.9.5. Closes #69, closes #70, closes #73, closes #74, closes #75, closes #76, closes #77, closes #78, closes #79
A template file can now carry an optional libraryHints block beside the
definition: extra Steam app ids, Steam install folder names, GOG product
ids and folder names, and a saves folder per operating system. The block
is read from the same text and never becomes part of a stored game, so
old templates and exported definitions are unchanged. A draft takes the
saves folder written for its operating system when there is one. The
Skyrim template now names its Steam app id and install folder.

Observed reds (TemplateLibraryHintsTests, hints read as empty and drafts
ignoring the system):
- The_hints_block_is_read_next_to_the_definition: Collections differ,
  expected [4243, 4244], actual [].
- A_draft_uses_the_saves_folder_written_for_its_operating_system: Strings
  differ, expected "{userHome}/.local/share/Alpha/saves", actual
  "{documents}\\Alpha\\Saves".
- The_skyrim_template_names_its_steam_folder_and_app_id: Values differ,
  expected 489830, actual null.
Passed on first run, kept by reasoning (no member to mutate):
The_hints_never_become_part_of_the_stored_definition.
Core can now list the games Steam and GOG Galaxy have installed. Steam: the
client folder's own library plus each library in libraryfolders.vdf, one
appmanifest_*.acf per game, parsed with the key-value reader that
libraryfolders.vdf already used (moved into ValveKeyValues, behavior
unchanged). A game counts as installed when its folder under
steamapps/common exists, because real manifests of installed games carry
StateFlags 518 and 22 while updating. Tools (Steamworks Shared, SteamVR,
Proton, the Steam Linux Runtime) are left out, an installdir that is not a
plain folder name is refused, and a game in two libraries is listed once.
GOG: install records (the Windows registry reader is behind IGogInstalls)
are filtered for add-ons, which GOG records with the base game's folder
(dependsOn, or a goggame-<id>.info whose rootGameId names another game),
missing folders and duplicates. Games with no template get a launch that
passes validation: steam://rungameid/<id>, the recorded program for GOG, or
Galaxy's page for the game. The template matcher tries the store id, then
the install folder name ignoring case.

The Api members (ScanLibrariesAsync, AddLibraryGameAsync) are declared and
stubbed here; their behavior and the fixtures-through-the-backend tests
follow.

Observed reds, all assertion failures against an empty stub:
- SteamInstalledGamesTests.Games_in_the_steam_folder_and_in_a_second_library_are_all_listed:
  Collections differ, expected ["240", "489830"], actual [].
- SteamInstalledGamesTests.Steam_tools_are_not_games(...): expected ["240"],
  actual [] (the game beside the tool was missing too).
- GogInstalledGamesTests.Add_ons_that_share_the_games_folder_are_not_listed_as_games:
  Assert.Single failed, collection was empty.
- TemplateMatcherTests.A_steam_game_matches_the_template_with_its_app_id:
  expected "skyrim", actual null.
Passed on first run, then mutation-checked (check removed, test failed,
check restored): the install folder must exist (Steam and GOG), a folder
name with separators or a drive is refused, blank GOG records are skipped,
and Steam hints must not match a GOG game.
Real data used: 177 manifests in 3 libraries on one PC (state flags 4, 518,
22; the tools; installdir different from name) and the GOG registry records
for Deus Ex GOTY, Soldier of Fortune II and Cyberpunk 2077 with its two
add-ons. The account id in the copied manifest is replaced.
ScanLibrariesAsync reads both stores and answers every installed game with
the template that matched, the saves folder that template names (resolved,
and whether it exists yet), a draft that passes validation, and the id of
the game already in the library when its install folder overlaps one or its
Steam app id matches. AddLibraryGameAsync adds one game through AddAsync, so
validation, path safety, consent markers and overlap checks are the same as
a single add (a Steam library folder is refused with
error.pathSafety.tier2Blocked), and answers a per-game result: Added,
AlreadyAdded, HasOlderHistory (history from a removed game is reported, not
silently reconnected), or Refused with the error. A refusal is a result, so
one game never stops a list. A template's saves folder that does not exist
yet cannot be tracked (adding it fails with error.path.missing), so the game
is added with its install folder only and the result names the folder left
out. Apps that share one Steam install folder (Fallout 4 and its Creation
Kit, the two Modern Warfare 2 apps) are listed once under the lowest app id,
found by scanning the real libraries on this PC: 172 Steam games and 3 GOG
games read back from 177 manifests and 5 GOG records.

BackendOptions gains GogInstalls (null reads the Windows registry on Windows
and nothing elsewhere; the test workspace passes a fake) and an internal
Templates override.

Observed reds, assertion failures against the stub:
- GamesLibraryTests.Steam_games_come_before_gog_games_and_each_has_its_install_folder:
  expected ["steam:240", "steam:489830", "gog:1207658995"], actual [].
- GamesLibraryTests.Adding_a_library_game_adds_it_with_both_folders_confirmed:
  Assert.True failed on added.Ok (stub answered Refused).
- GamesLibraryTests.A_steam_library_folder_is_refused_with_the_reason_and_nothing_is_written:
  expected Refused, actual Added, until the test platform knew where Steam is.
- GamesLibraryTests.A_saves_folder_the_game_has_not_made_yet_is_left_out_and_the_result_says_so:
  expected Added, actual Refused (error.path.missing).
- SteamInstalledGamesTests.Apps_that_share_one_install_folder_are_listed_once_under_the_lowest_app_id:
  expected "377160", actual "10190".
Passed on first run, then mutation-checked (code changed, test failed,
restored): a saves folder that exists is kept, scanning writes nothing, and
a store that is not installed is reported as not found.
Three dialogs, each a view model with its own tests against the fake
backend: a picker (scan, search, sort, hide games already added, select
all or none, a count, nothing checked to start with, games already in the
library cannot be checked), one confirmation that names every game with its
install folder and saves folder in plain words, and a run that adds the
games one at a time with progress, a stop between two games, and a result
list for what needs attention (refusal reasons, snapshots from a removed
game, a saves folder left out because the game has not made it yet).
The game editor now says what a missing saves folder means. The fake games
Api scripts a library scan and the per-game outcomes.

Observed reds, assertion failures against stubs:
- LibraryPickerDialogViewModelTests.Every_game_found_is_listed_with_its_store_folder_and_saves_line
  and 15 more: empty list, wrong counts, wrong order.
- LibraryConfirmDialogViewModelTests.It_names_every_game_with_its_install_folder_and_its_saves_folder:
  expected ["Skyrim", "Fallout 4"], actual [].
- LibraryAddDialogViewModelTests.A_refused_game_is_reported_with_its_reason_and_the_next_game_is_still_added:
  expected ["steam:1", "steam:2"], actual [].
- GameEditorSavesNoteTests.A_game_with_no_saves_folder_gets_a_note_that_explains_what_is_missing:
  expected True, actual False.
Mutation-checked after passing first time: HasNoSavesFolder forced true
(two tests failed), picker dismiss answering an empty list (failed).
The entry sits beside Add a game in the sidebar rail, on the library
layout's shelf header and on the first-run screen. It runs one flow: the
checklist, a single confirmation that names every game's folders, then the
run with progress and a result list; the library refreshes and the first
added game is selected. The three dialogs have views, are listed in the
app-wide accessibility, keyboard, scaled-window and target-size audits (a
5-game state, a 200-game state, the confirmation and the finished run),
and render to render-output/library.

Observed reds: ShellLibraryImportTests (4 tests) failed with "The dialog
never appeared." against a command that did nothing; the finished-run
dialog failed the audit that its help text equals its description until the
description stopped changing with the progress line. The catalog lint
rejected two unused keys and the word "point" in the saves copy; both
fixed.
GameTemplates now discovers the embedded template resources (sorted by name) instead of a hand-kept file list, so adding a template is one new file.

ShippedTemplatesTests checks each template that ships: unique kebab-case id and name, positive Steam ids, single safe store folder names, numeric GOG ids, saves folders that resolve through the real token resolver on the system they are written for, and notes free of banned words and em dashes.

Observed reds, in order:
- Every_embedded_template_file_is_loaded with a second template file present: Assert.Equal() Failure, Expected [skyrim-se, zz-broken], Actual [skyrim-se].
- Saves_folders_resolve_on_the_system_they_are_written_for(zz-broken), a throwaway template using {nowhere}: '{nowhere}\Broken\Saves' does not resolve on windows: validation.path.unknownToken. The throwaway file is not committed.
Each template is one embedded JSON file built from researched facts (installed Steam manifests plus PCGamingWiki): the game name, Steam app id, Steam install folder and GOG id for library matching, a saves folder when one is sourced at high or medium confidence without a per-user id, per-system saves under libraryHints, a launch (the game's exe when known, otherwise steam://rungameid), and plain-word notes for Steam Cloud, anti-cheat, and saves SavePoint cannot name itself.

Saves in Steam's userdata folder, in a folder named after an account id, inside the install folder, or at low confidence get no external folder and a note saying so. Skyrim is unchanged.

GameTemplates sorts by id (file names sort '-' and '.' differently). Observed red for the order test with 320 templates: Templates_come_in_a_fixed_order, Assert.Equal() Failure at index 42, Expected call-of-duty, Actual call-of-duty-black-ops-iii.

The data-driven ShippedTemplatesTests passed on first run over the real data, so it got mutation checks: an unknown-token Linux path in 7-days-to-die failed Saves_folders_resolve..., a banned word and em dash in balatro notes failed Notes_use_plain_words, and a non-positive Steam id plus a GOG id with '..' failed Steam_ids_are_positive and Store_ids_and_folder_names_are_single_safe_names. All restored.
With hundreds of templates the picker needs a way to find one. The list now scrolls, and a search field narrows it to the names that have every typed word at the start of a word, ignoring case, apostrophes and other punctuation, so 'sid meiers civ' finds Sid Meier's Civilization VI. A line says when nothing matches.

Observed reds, with the search members stubbed so the tests compile:
- Searching_keeps_only_the_templates_whose_name_has_every_word_ignoring_case: Expected [The Witcher 3: Wild Hunt, The Witcher 2: Assassins of Kings], Actual all five names.
- A_search_nothing_matches_says_so_and_a_match_does_not: Assert.Empty() Failure, Collection was not empty.
- Three_hundred_templates_filter_to_the_one_asked_for: Expected Skyrim Special Edition, Actual 007 First Light.
- Punctuation_in_a_name_does_not_get_in_the_way_of_a_search: Expected Sid Meier's Civilization VI, Actual The Witcher 3: Wild Hunt.
- The view test (The_template_picker_dialog_lists_the_built_in_templates) failed with 320 templates because Skyrim was not among the rendered rows; it now searches first.

Mutation check: changing All to Any in the filter failed three tests; restored.
ToDraft(OsKind) fell back to the definition's saves folder even on Linux and macOS, where {localLow}, {savedGames} and Windows drive paths mean nothing, so adding such a game failed. The draft now has no saves folder there (the editor already explains an empty one); a per-system entry still wins, and {documents} and the other shared tokens carry over.

Observed red: Draft_leaves_the_saves_folder_blank_when_a_windows_only_token_has_no_meaning_here for Linux and MacOS, Assert.Null() Failure, Actual ExternalLocation { Path = {localLow}\Studio\Game }.

The token sets are checked against the real platform token tables by The_token_names_a_draft_checks_are_the_ones_each_platform_defines, which passed first run; removing localLow from the Windows set failed it and Draft_on_windows_keeps_the_windows_only_tokens, then restored.
The template loader keeps the last of two equal keys without a word, so a pasted duplicate would change a template silently. No_template_file_repeats_a_key parses every embedded template with duplicate properties disallowed.

Observed red: with a throwaway zz-duplicate.json repeating steamAppId (not committed), Assert.Empty() Failure, Collection: [zz-duplicate.json: Duplicate property 'steamAppId'].
The add now puts in only the folders the player was shown: the install folder
the scan named, and the saves folder only when the scan found it and it is
still there. A saves folder that appeared after the confirmation, or a draft
that names other folders, is left out (the result names it). Scan and add use
one rule for "already added": a Steam game is judged by the id it is
installed under (a GOG copy of a templated game is no longer called added
because the Steam copy is), and a saves folder another game already tracks
counts, since adding over it would be refused. A template's program replaces
the store launch only on Windows and when it is in the install folder.
Installed folders that hold another installed game's folder are not offered,
GOG folders must be fully qualified, install folder names Windows would trim
are refused, apps sharing a folder are merged after template matching so the
described app wins, and Snap Steam is found. The scan reads the stores
outside the storage gate and takes a token checked per library and record.
A game added with a store link gets the program to watch from the process
name suggester, so its session can end by itself.

Observed reds (assertion failures):
- A_saves_folder_made_after_the_scan_is_not_added_...: left-out path was null.
- Only_the_folders_the_scan_showed_are_added_...: stored install was the
  draft's, not the scanned folder.
- A_gog_copy_of_a_templated_game_is_not_called_added_...: AlreadyAdded.
- A_steam_edition_matched_by_a_hint_keeps_its_own_app_id_...: expected 778,
  actual 777.
- Where_a_windows_program_cannot_run_the_store_launch_is_used (Linux, macOS):
  expected Uri, actual Exe.
- A_folder_that_holds_another_installed_games_folder_...: expected
  ["gog:2"], actual both.
- A_game_that_starts_through_a_store_link_gets_the_program_to_watch_...:
  process name was null.
- A_folder_that_is_not_fully_qualified_... (3), An_install_folder_name_that_
  windows_would_trim_... ("...", ".. "), Linux_finds_the_snap_package_...
  (expected the snap folder, actual null), A_game_whose_saves_folder_another_
  game_already_tracks_...: all failed on their assertions.
Mutation-checked after passing first time: the scan outside the storage gate
(read it inside the gate, the exclusive-gate test failed) and the token
checks (removed, the cancelled-scan test failed).
Closing the window while games are being added now asks first, like a job
does: the run registers with a tracker, the exit guard asks "SavePoint is
still adding your games", and quitting asks the run to stop after the game
it is on and waits for that game. The run dialog always ends in a state that
can be closed: an exception in one add is reported for that game and the
games not reached count as not tried. Closing the checklist cancels its scan
(the token reaches the per-library and per-record checks) and the flow no
longer waits for a scan the player gave up on, so a dead network drive
cannot keep the command busy. GOG Galaxy's program folder and its Games
folder (read from HKLM ...\GalaxyClient\paths, Windows only) are tier-two
protected like Steam's folders. The confirmation labels the game folder and
uses the single-add wording ("takes snapshots of everything in these
folders") and says plainly that no snapshot is taken now; a row's screen
reader name holds the install folder, so two copies of a game differ. The
checklist was checked to draw only the rows in view for 200 games. The new
rail and shelf entry sits where it is drawn, so the tab-order expectations
now list it before "Add a game".

Observed reds (assertion failures):
- LibraryRunExitTests.Staying_open_leaves_the_run_alone: expected False,
  actual True (no question was asked); Quitting_asks_the_run_to_stop_and_
  waits_for_the_game_it_is_on: Assert.True failed.
- LibraryAddDialogViewModelTests.A_game_whose_add_throws_ends_the_run_cleanly
  _and_can_still_be_closed: InvalidOperationException : boom escaped.
- LibraryPickerDialogViewModelTests.Closing_the_dialog_cancels_the_scan_it_
  started (cancel, dismiss): token not cancelled.
- LibraryImportFlowTests.Backing_out_while_the_scan_is_still_running_ends_
  the_flow_at_once: TimeoutException after 5 s.
- GogFolderProtectionTests.Galaxys_program_folder_and_its_games_folder_are_
  tier_two and the case test: not blocked.
- LibraryConfirmDialogViewModelTests (message wording, install line) and the
  row automation name test: strings differed.
- TabOrderTests, six tests: expected "Add a game", actual "Add games from
  your libraries" (the new entry is drawn first), then updated.
Mutation-checked after passing first time: the tracker registration (two
tests failed), checklist virtualization (a plain StackPanel drew all 200
rows, the test failed), the editor/dialog paths from the previous commit.
A shared token such as {documents} or {appData} says nothing about where a Windows game saves on Linux or macOS (under Proton the saves are inside the game's prefix, and native ports use their own folders), so carrying the Windows default over pointed SavePoint at folders the game never writes. ToDraft now uses the template's savesByOs entry for the system and leaves the folder blank otherwise; Windows keeps the default. The token-set helper and its test are gone because nothing needs them.

Observed red: Draft_leaves_the_saves_folder_blank_without_an_entry_for_that_system (Linux and MacOS), Assert.Null() Failure, Actual ExternalLocation { Path = {documents}\My Games\Game }.

Two existing tests also changed: A_draft_keeps_the_old_shape_when_there_are_no_per_system_folders now drafts for Windows and checks the Linux draft is blank, and A_game_with_no_template_is_offered... failed (Assert.Null() Failure, Actual counter-strike-source) because Counter-Strike: Source now ships as a template, so it uses an app id no template names.
The toast stack had a row of its own below the page, so every toast shrank the shell (rail, page, footer) by its height and the layout jumped when it appeared and again when it went. The stack now floats over the bottom right corner like the job pill. To keep toasts off pinned footers, banners and cards, the page keeps room under its pinned content equal to the stack's height (the pill-room strip and the scroll padding now take their size from the pill and the toasts together), and the pill stands above the toasts when both show.

Observed red: ToastPlacementTests.A_toast_floats_over_the_shell_and_leaves_its_layout_alone failed in all 10 layout and size cases with "ShellRoot moved from 0, 0, 1040, 659 to 0, 0, 1040, 581 when a toast showed (Sidebar, 1040x660)." The pinned-control audit passed on the old layout; it failed with "Button 'Free up space ...' is under the pill" in 5 cases when the room used the stack's height without its margins, so it can fail. The old test that the stack sits outside the page is replaced.
A Steamworks game started directly exits and asks Steam to start it again. The watcher counted the started program itself as the named process, so its own exit looked like the game ending and the session settled after about a second, before the new copy appeared. The started program's pid is now left out of the named-process look, so a same-named process with another pid, however it was started, is what counts, and the grace runs from the exit as for any launcher stub.

Observed reds before the fix:
- GameSessionWatcherTests.A_program_that_exits_and_is_started_again_under_its_own_name_is_followed_to_the_end_of_the_new_copy: Assert.False(IsSettled) Expected False, Actual True
- GameSessionWatcherTests.A_program_that_exits_and_is_not_started_again_settles_when_the_grace_runs_out: same assertion
- RealSessionTests.A_game_that_exits_at_once_and_is_started_again_by_another_program_is_followed_to_the_end_of_the_new_copy: "the session ended after only 00:00:00.70, before the new copy left" (also seen again with the fix reverted)
A started program that is itself the named process and ran for 30 seconds or longer was quit by the player, so its exit ends the session at once instead of waiting the grace for a new copy. Only an exit inside the relaunch window (GameSessionOptions.RelaunchWindow, 30 s) waits for a same-named process with another pid. The session outcome now carries the started pid and the pids followed, and the launch session writes one log line with how it ended.

Observed reds before the change:
- GameSessionWatcherTests.A_program_that_ran_past_the_relaunch_window_and_exits_ends_the_session_at_once: "a game that was quit after a long run must not get the grace"
- GameSessionWatcherTests.A_program_that_exits_and_is_started_again_under_its_own_name_is_followed_to_the_end_of_the_new_copy: Assert.Equal StartedPid, Expected 4242, Actual null
- LaunchActionLogTests.A_session_that_ends_logs_how_it_was_found_over_and_the_pid_of_the_game_it_started: Assert.Single, the collection was empty
New theories over every shipped template:
- A_saves_folder_does_not_end_in_a_file_name_or_a_wildcard
- No_saves_folder_is_another_games_folder (compares each path segment with the other templates' names, ignoring case, spacing and years)
- Linux_and_macos_drafts_use_only_their_own_entry
- A_saves_folder_is_not_one_of_the_platforms_broad_folders (judged against each platform's real denylist)

Observed reds on the data as it stands (fixed in the next commit): minit Linux ends in minit_v1.sav, the Force Unleashed macOS path ends in SWTFU.BIN, Rise of the Tomb Raider's macOS path is the Shadow of the Tomb Raider folder, and Batman: Arkham Asylum GOTY's macOS path is the Arkham City GOTY folder.

Throwaway proofs, not committed: a template with {appData} as its Windows folder and {userHome} and {documents} as its Linux and macOS folders failed the broad-folder test ('{appData}' (windows) is C:\Users\Test\AppData\Roaming; '{userHome}' (linux) is /home/test); making ToDraft carry the Windows default over again failed the draft test for 109 templates.
A profile holding Mods/Foo and Mods/foo, switched onto a folder on an exFAT drive mounted on Linux, wrote both files into one folder and then failed the cleanup with the "something else is holding a file open" message. Nothing compared the names inside one point with each other, only a file against a folder. A switch and a discard now read the point's whole tree before writing and refuse with error.launch.caseClash (names both spellings, writes nothing) when the work tree compares names without case. The probe that finds such a drive now asks about the marker file inside the folder first, so a game folder that is the root of a mounted drive is recognised too (its parent lives on another drive and said nothing).

Observed reds before the fix:
- CaseClashTests.Two_folders_that_differ_only_in_case_clash_at_the_first_part_that_differs: Expected ("Mods/Foo", "Mods/foo") but was null (likewise the two-file and file-and-folder cases)
- CaseClashTests.A_point_holding_two_names_that_differ_only_in_case_is_refused_before_anything_is_written (Switch, ForcedSwitch, Discard): Assert.IsAssignableFrom failure, value is null (the operation succeeded)
- CaseClashTests.A_drive_that_ignores_case_is_found_out_and_the_clash_is_refused_without_being_told: same, on NTFS
- FileFolderCollisionTests.The_root_of_a_drive_that_ignores_case_is_found_out_from_the_marker_file_it_holds and The_marker_file_decides_over_the_folders_parent_when_the_folder_holds_one: Assert.True / Assert.False failures
- ErrorCardViewModelTests.Two_names_that_differ_only_in_case_...: title was "Something went wrong"
Mutation checks: dropping the spelling comparison in FindCaseClash failed the no-clash guard; forcing a clash failed A_point_holding_one_spelling_of_each_name_switches_as_before.
Also run on a Linux VM with the temp folder on an exFAT loop mount: CaseClashTests 9 of 9, FileFolderCollisionTests 54 passed, 2 skipped.
Every template was checked against its wiki page (the page is found by Steam app id and its infobox must name that id). Where the wiki has a Steam row, a Steam-matched template uses it, and is left blank when that row is Steam's userdata folder unless the Windows folder exists on this machine for that game, which shows the Steam copy still saves there.

Fixes: Hades uses {documents}\Saved Games\Hades (not the Saved Games known folder); HITMAN 3 was built from the Hitman: Contracts page, so it is now HITMAN World of Assassination with Steam id 1659040 and no GOG id; Cyberpunk 2077 gets Steam id 1091500; RimWorld uses the RimWorld by Ludeon Studios folder and drops the Linux guess; the Arkham Asylum and Rise of the Tomb Raider macOS paths named other games and are gone, as are the Lies of P macOS, Force Unleashed macOS (a file) and Metro Exodus Enhanced Linux entries the wiki does not support; Minit's Linux and macOS paths name the folder, not minit_v1.sav; Linux paths use {localAppData} and {appData} where the wiki uses the XDG folders; 25 saves folders the wiki gives (Starfield, A Plague Tale: Innocence and others) are added and 13 whose only wiki location is Steam's userdata folder are blanked; the notes say "Steam's userdata folder"; Dead Space and Lords of the Fallen carry their years.

Two tests pin the corrections. Mutation check: putting Hades back to {savedGames}\Hades failed Games_checked_against_their_wiki_page_keep_their_corrected_facts (Strings differ, Expected {documents}\Saved Games\Hades); restored.
GNOME Shell destroys the notification source of an app that has a window as soon as the D-Bus connection that sent it goes away, and SavePoint opened a new connection per notification and closed it right after Notify, so every banner was closed about 20 ms after it arrived (NotificationClosed reason 2). notify-send, which has no window, is not treated that way. The bus now keeps one connection for the life of the app, reconnects after a failure, and is disposable.

Observed reds (Linux VM, Ubuntu 26.04, private session bus):
- DBusNotificationBusTests.The_sender_stays_on_the_bus_after_the_call_so_the_desktop_keeps_the_notification: "the connection that sent the notification was already gone"
- DBusNotificationBusTests.A_second_notification_reuses_the_connection_of_the_first: Assert.True() Failure, Expected: True, Actual: False
Both green after the change; all 7 tests of the class pass on the VM. On GNOME 50 the real app's notification now stays in the tray (no NotificationClosed).
The template picker's 'No games match your search.' line is a polite live region so a screen reader announces it. The test also pins that the search field has the keyboard focus when the picker opens.

Observed red: The_template_picker_dialog_lists_the_built_in_templates, Assert.Equal() Failure, Expected Polite, Actual Off. The focus assertion passed on its first run, so it got a mutation check: Focusable=False on the field failed it ('The search field has the keyboard focus as soon as the picker opens'), then restored.

The folder-confirmation view test took the first template, which was Skyrim only while Skyrim sorted first; it now picks Skyrim by id and drafts for Windows. Observed: it failed with Item not found 'Confirm these folders' once a game with no saves folder sorted first.
The first tour card sat directly under the outlined row, over the rows below it, so the list the player came to use was hidden while the card showed. The card now also tries the spot under the last row, and a row of the list counts as an obstacle for that step. A window too small to hold the card elsewhere keeps the old spot, inside the window. Measuring the wide width and going back on every layout pass kept the layout from settling (Avalonia reported an infinite layout loop once a candidate failed), so the width now starts at the usual one for each new situation and only ever moves on to the wider one.

Observed red before the change: TourViewTests.The_first_card_hides_no_other_row_of_the_profile_list failed for Sidebar and Library at 1040x660 ("the card 269, 201, 340, 176 covers a row of the list 259, 199, 758, 55").
The line read "Going from X, to X" when the game version did not change, naming the same version twice. A version that stays is now left out when only the mods change ("Going from 212 mod files to no mods"), and a switch that changes neither says "Staying on X".

Observed reds before the change:
- LaunchDialogViewModelTests.A_version_that_does_not_change_is_not_named_twice_and_only_the_mods_that_change_are_said: expected "Going from 212 mod files to " but was "Going from 1.6.640 with 212 mod files, to "
- LaunchDialogViewModelTests.A_version_and_mods_that_both_stay_are_said_once_as_staying and ..._with_no_mod_folders_to_count_...: expected "Staying on " but was "Going from ... to "
A shell built over the same data after the tour started reads tourSeen from the settings file and stays quiet. The report that the tour came back after a restart could not be reproduced through the real backend; this keeps the behavior pinned.

No red: the test passed on its first run. Mutation check: replacing the TourSeen condition in StartTourIfDue with a null check made it fail (Assert.False on Tour.IsActive), then restored.
When the started program is itself the named process and it exits with no new copy, the session now ends with kind ChildExited and the end time at the program's exit, for a slow quit and for a quick exit that waited out the grace, so the wait is not counted as play time. A negative relaunch window is refused. A session whose game cannot be followed writes a log line with the error and the started pid. New watcher tests pin the window edge, a copy running before Play, a same-named child, an unreadable list at a slow quit, a program never seen under the name, and the pids of two copies; the real-process test waits for the first copy to be gone instead of sleeping.

Observed reds before the change:
- A_program_that_ran_past_the_relaunch_window_and_exits_ends_the_session_at_once: Assert.Equal, Expected ChildExited, Actual NamedProcessEnded
- A_slow_quit_is_not_settled_on_a_read_that_could_not_be_made_and_ends_at_the_exit_on_the_next_one: same
- A_program_that_exits_and_is_not_started_again_settles_when_the_grace_runs_out: Expected ChildExited, Actual NamedProcessNeverAppeared
- A_negative_relaunch_window_is_refused: Assert.Throws, no exception was thrown
- LaunchActionLogTests.A_session_whose_game_cannot_be_followed_...: Assert.Single, the collection was empty
Mutation checks on the tests that passed first: ">=" changed to ">" failed the exact-window test; dropping the followed-pid union failed four tests.
A second start asks the first copy to show itself, which called Avalonia's Activate. Under X11 that sends _NET_ACTIVE_WINDOW stamped with the time of this process's last event, and GNOME answers a request older than the user's input with a "ready" notice instead of raising the window (checked on the VM: the same message with timestamp 5 leaves the window hidden with DEMANDS_ATTENTION, with timestamp 0 it is restored and focused). The window is now raised with a client message of its own stamped "now", and Avalonia's Activate stays as the fallback when there is no X11 handle or no display.

The window class is now the pack id (SavePointApp), which is what the AppImage's desktop entry names as StartupWMClass, so the shell can match a running window to its entry and icon. The crash window carries the app icon like the other windows.

A start with no usable X display used to leave only a log line. The crash handler now also writes a plain note to stderr (catalog text, with advice about DISPLAY and XAUTHORITY when the failure is XOpenDisplay) before the window step.

Observed reds:
- X11WindowRaiserTests.The_request_is_a_NET_ACTIVE_WINDOW_message_for_the_window: Expected "_NET_ACTIVE_WINDOW", Actual null
- X11WindowRaiserTests.The_request_comes_from_an_application_and_is_stamped_now: Expected 1, Actual 0
- X11WindowRaiserTests.Raising_without_a_window_or_an_X_display_reports_failure_instead_of_throwing: Expected False, Actual True
- PlainCrashNoteTests.The_note_says_what_went_wrong_and_where_the_log_is: Sub-string not found in ""
- PlainCrashNoteTests.A_desktop_with_no_usable_display_gets_advice_in_plain_words: Not found "DISPLAY" in ""
- CrashHandlerTests.A_plain_note_is_made_once_after_the_crash_is_logged_and_before_the_window_shows: Expected "note for boom after 1 logged", Actual "window"
- CrashWindowTests.The_window_carries_the_app_icon: Assert.NotNull() Failure: Value is null
- DesktopIdentityTests.The_window_class_is_the_pack_id_the_AppImage_desktop_entry_names: Expected "SavePoint", Actual "SavePointApp"
Tests that passed on their first run (the negative PlainCrashNote cases) failed under a mutation that made the display advice and the log line unconditional.
The test started the game with --exit-after 2000 and then asserted the game's own process handle said it had exited once the session ended. The watcher decides from the process list, where a game that has exited but is not yet collected by its parent counts as gone, while this process collects finished children from a signal handler on its own schedule; on a loaded four-core machine the handle still said running for a moment (the single gate failure: the session ended while the game was still running). The game now stays until the test stops it, the test waits until the watcher has read the process list twice with the game running, and then asserts the session ended no earlier than the stop.

No red: the flake needs a loaded machine and cannot be forced. Mutation check: making the watcher settle at the first sight of the game left the wait for a second read timing out (TimeoutException after 30 s), then restored.
Every release carried about 55 identical source archives, so its download
list ran to 59 entries. The archives now live in one release per bundled
git version, git-sources-<MinGit version>, which each app release links to.
The toast audit now runs from the job pill audit's full screen and size matrix in both layouts, with toasts alone, with the pill and the toasts together, and with a full stack of long toasts in the smallest window. The first run of that matrix exposed that the stack was too tall for short windows, and that the tour card could sit under a toast.

The toast stack now takes at most a fifth of the window's height (136 px at most) and keeps Dismiss all at the top of its scrolling list, so it no longer adds a fixed row. The tour area ends above the toasts. The tour overlay re-measured its card on every layout pass when the card fit nowhere, which looped forever once the area shrank, so a placement with unchanged inputs is now left alone. The window view reads the pill's margin and room from XAML, throws if the toast strip or pill root is missing, updates the room once at start, skips writes when the room is unchanged, and watches only the pill's visibility.

Observed reds: JobPillPlacementTests No_control_under_the_toasts_..., ..._together_... and A_full_height_toast_stack_... failed in 26 of 82 cases with "Button 'Edit game' ... is under the pill at 184, 241, 440, 163 (pinned)" and similar before the cap; ToastPlacementTests.The_tour_card_stays_clear_of_the_toasts failed with "The tour card at 97, 186, 340, 176 is under the toasts at 184, 241, 440, 163 at step 1 (640x420)." and then with "Infinite layout loop detected" once the tour area was shortened.

Known limit, skipped in the audit: in the library layout, a pinned launch card (banner, running, checking) in a window 460 px tall or less cannot clear a toast.
# Conflicts:
#	src/Savepoint.App/Features/Help/TourOverlay.axaml.cs
The switch dialog now says only what changes ("Going from 2 mod files to ...") and names the target without the word "with". The journey test still expected the old sentence.

Observed red (last full Windows gate): SwitchProfilesJourneyTests.Playing_the_other_profile_rewrites_both_folders_... failed at Assert.EndsWith with expected "with 2 mod files, to " against the dialog's "Going from 2 mod files to ". After the change the test passes.
With 320 templates and a search box the picker is taller than a small window, and Cancel and Open a file... fell below it. The picker now sits in the dialog frame that scrolls the body above a footer that stays in view, and asks the host to pin the footer.

Observed red: PinnedFooterTests.Every_dialogs_buttons_are_in_view_at_a_scaled_size for first-run-templates failed at 200% on 1080p (960x460) with "has buttons out of view: Cancel at 468, 547, 82, 36; Open a file... at 558, 546, 120, 38" and at 150% on 1366x768 (910x432). After the change all 47 cases pass.
Version 0.9.5
Some checks failed
Gate / linux (pull_request) Has been cancelled
e4437247d1
List the two new D-Bus notification tests as skips where no session bus runs
Some checks failed
Gate / linux (pull_request) Failing after 10m8s
6d68f9c167
They need Linux and dbus-daemon; Windows always skips them, and CI runs them
only when its container has a bus.
Give the library tests a Skyrim template with a saves folder on every system
All checks were successful
Gate / linux (pull_request) Successful in 11m6s
Gate / linux (push) Successful in 11m16s
e4c7818774
On Linux and macOS a template's Windows saves folder is no longer used, so the library tests, which rely on the shipped Skyrim template (Windows folder only), got no saves folder there. The fixtures now use the shipped templates with Skyrim given the same token-based saves folder for linux and macos, and the draft path assertion expects the separator of the system it runs on. The product rule is unchanged.

Observed red (Linux CI, before the change): the seven library tests failed with the saves folder null (NullReferenceException at the draft External assertion; expected 2 folders, got 1). Windows stays green.
Sign in to join this conversation.
No reviewers
No milestone
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
ethan-hann/SavePoint!85
No description provided.