0.9.20: Steam check before launch, live change tracking, game editor cards and pickers, layout fixes #254

Merged
ethan-hann merged 53 commits from integration-0920 into main 2026-10-27 20:08:35 -05:00
Owner

A game installed in a Steam library that runs its program now makes sure Steam is ready before anything is read or switched, and never starts the game through Steam, so Steam cannot update a version the player switched to (#243, D67). Its card offers Start Steam (the client alone, -silent), Play without Steam and Not now; the game's appmanifest is read, never written, before Steam starts, before the switch and before the program starts, and the launch is refused if Steam is updating or changed the build, before the switch when it can be. GOG and retail copies that only carry a Steam app id are not affected. After play, a snapshot is refused while the game still runs, with a short relaunch check and Choose again. Manifest update detection after play is #250; smaller follow-ups are in #251 and #253.

The profile table follows the shown game's folders as they change (#245, D68): watched off the UI thread, one read per burst (750 ms quiet, within 5 s, spaced by the last read's duration), quiet during jobs, play and while the window is in the background, and returning to the window reads only when something may have been missed. The game editor is a column of cards (Game, Saves, Mods, Artwork, More settings) with clear mods wording, per-question text and help links, glob-pattern rules stated as not regex (#242, D19, D7), and Choose files / Choose folders pickers for mod files inside the install folder (#247). The sidebar's games list scrolls alone and the library shelf wraps (#239, #237, D69); a new horizontal overflow audit covers every app state, including the editor and the new Steam cards.

Each change was implemented test-first, reviewed by an Opus code review (one critical: GOG copies forced to the Steam card, fixed) and a gap analysis; their findings and the gate regressions they caused were fixed on this branch.

Local gates on bc260094: Windows gate passed (19099 tests, 0 failed, 75 listed skips); Linux gate on the VM passed (0 failed, 144 listed skips).

Closes #237 #239 #242 #245 #247

A game installed in a Steam library that runs its program now makes sure Steam is ready before anything is read or switched, and never starts the game through Steam, so Steam cannot update a version the player switched to (#243, D67). Its card offers Start Steam (the client alone, -silent), Play without Steam and Not now; the game's appmanifest is read, never written, before Steam starts, before the switch and before the program starts, and the launch is refused if Steam is updating or changed the build, before the switch when it can be. GOG and retail copies that only carry a Steam app id are not affected. After play, a snapshot is refused while the game still runs, with a short relaunch check and Choose again. Manifest update detection after play is #250; smaller follow-ups are in #251 and #253. The profile table follows the shown game's folders as they change (#245, D68): watched off the UI thread, one read per burst (750 ms quiet, within 5 s, spaced by the last read's duration), quiet during jobs, play and while the window is in the background, and returning to the window reads only when something may have been missed. The game editor is a column of cards (Game, Saves, Mods, Artwork, More settings) with clear mods wording, per-question text and help links, glob-pattern rules stated as not regex (#242, D19, D7), and Choose files / Choose folders pickers for mod files inside the install folder (#247). The sidebar's games list scrolls alone and the library shelf wraps (#239, #237, D69); a new horizontal overflow audit covers every app state, including the editor and the new Steam cards. Each change was implemented test-first, reviewed by an Opus code review (one critical: GOG copies forced to the Steam card, fixed) and a gap analysis; their findings and the gate regressions they caused were fixed on this branch. Local gates on bc260094: Windows gate passed (19099 tests, 0 failed, 75 listed skips); Linux gate on the VM passed (0 failed, 144 listed skips). Closes #237 #239 #242 #245 #247
A change made in a game's install, saves or mods folder by another program now reaches the profile table while the Games screen stays open, instead of waiting for a trip to another screen.

- IFolderWatcher / IFolderWatch is the seam; FileSystemFolderWatcher wraps FileSystemWatcher (one per existing folder, subfolders included, 64 KB buffer, events folded into one Changed per 100 ms). A missing folder or one the system cannot watch is skipped and logged once per folder; an error re-arms that folder's watch and raises Faulted.
- The Games screen watches only the folders of the game on screen while it is shown, and stops on another game, leaving the screen (new IScreen.OnHidden, called by the shell on Navigate) and dispose.
- StatusReadScheduler turns signals into one read: 750 ms of quiet, at most 5 s of waiting, never two reads at once, one trailing read for signals that came during one. The read is list plus row stats only, off the UI thread, and a failed read leaves the rows as they were.
- Signals are dropped while a job of the game runs or the launch flow owns the game (the after-play flow and the job end read the status themselves).
- Faulted and the window coming to the front request a read too, which is the fallback where a folder cannot be watched.
- The running app supplies the real watcher through AppServices.FolderWatcher; tests get none unless a rig passes one.

Reds observed before the code: GamesScreenLiveChangesTests (no watch was started: Assert.Single(rig.Watcher.Running) found an empty collection; Activating_the_window_reads_the_status_again expected 3 reads, got 2), FileSystemFolderWatcherTests (The watcher never signalled; A_missing_folder... Assert.Single failed on an empty log; A_watcher_error... expected 1 Faulted, got 0), AppBootstrapTests (FolderWatcher was null), GamesScreenActivationViewTests (expected 3 reads, got 2). Mutation checks: dropping the job, session and screen-shown guards failed the four "reads nothing" tests; dropping the dispose cleanup failed the dispose test; dropping the disposed guard in the real watch failed Nothing_is_raised_after_the_watch_is_disposed.
The editor was one run of fields in two columns, with the optional ones mixed in.
It is now one column of cards in the order a player fills them in: "The game"
(name, install folder, how to start; Required), "Saves" (Recommended), "Mods"
(Optional), Artwork (Optional), and the closed "More settings" card for rules,
extra options, stop detection and the Steam app ID. Each card heading is a level 2
heading and says how much it matters.

Mods: the folder outside the game folder ("Mods outside the game folder", with
"Does my game keep mods outside its folder?") and the list of mod files inside it
("Mod files inside the game folder", with a "When do I need this?" that says when)
now sit together in the Mods card. The mod files no longer hide in More settings.

Rules: the answer names the real pattern syntax (the matcher is the gitignore-style
exclude list, not regular expressions): * ** ? [abc], a leading / or trailing /, a
leading ! and last match wins. A line under the lists says they are patterns, not
regular expressions.

Links: the two mods answers end with "More in How SavePoint works", which opens a
new "Mods inside and outside the game folder" topic. The online-games and Steam app
ID answers have no topic on the page, so they have no link.

Observed reds before the change (assertion failures, not harness errors):
- GameEditorGuidanceTests.The_mods_folder_question_says_which_games_need_one_and_the_mod_file_answer_says_when_to_fill_it_in:
  Expected "Does my game keep mods outside its folder?", Actual "Where do my mods live?"
- GameEditorGuidanceTests.Both_rule_lists_tell_a_screen_reader_that_they_hold_patterns_and_not_regular_expressions:
  Sub-string "not regular expressions" not found
- GameEditorGuidanceTests.More_settings_stays_closed_when_the_edited_game_only_names_mod_files:
  Expected False, Actual True
- GameEditorGuidanceTests.The_list_of_mod_files_is_named_for_the_inside_of_the_game_folder:
  Expected "Mod files inside the game folder", Actual "Folders that hold mods"
- GameEditorCardsViewTests (8 of 11): No Control named GameCard / ModsCard / AdvancedCard /
  GameCardHeading / RulesSyntaxText
Mutation checks for the tests that passed first time: a MinWidth of 1200 on the game
card makes the side-clipping test fail, and an unnamed icon button makes the audit
test fail.
Red observed: SteamClientTests (6 of 15 failed against a stub that answered false):
Windows_is_ready_when_the_registered_process_runs_and_an_account_is_signed_in,
Elsewhere_a_running_client_process_is_ready (Linux, MacOS), Windows_starts_only_the_client_quietly_with_no_game,
MacOS_opens_the_Steam_app_with_no_game: Assert.True() Failure, Expected: True, Actual: False.
The negative cases passed on the stub; mutating the sign-in, process-name and folder checks and the start catch failed 4 of them.

The client starts steam -silent only, never a link or an app id, because Steam installs a pending update before it runs a game.
Red observed: SteamGamesTests, 5 of 9 failed against a stub that answered false: A_game_with_a_Steam_app_id_started_from_its_program_needs_the_client,
A_game_installed_in_a_Steam_library_needs_it_even_without_a_stored_app_id, A_game_that_ships_a_Steam_app_id_file_needs_it,
A_native_program_on_those_systems_needs_it (Linux, MacOS): Assert.True() Failure, Expected: True, Actual: False.
The four negative cases passed on the stub; mutating the method, .exe and detection checks failed all four.

Also adds the launch surface the next change fills in: StartAsync(startSteam), LaunchPreview.SteamNeeded, the two Steam errors,
SteamWaitOptions and the waiting step. Nothing uses them yet.
A Steam game started from its program now needs the client running and signed in before the launch reads or switches a folder.
Without it StartAsync fails at once with error.launch.steamNotRunning (no job, no session); the preview carries the same error
so the App can ask before the launch dialog. StartAsync(startSteam) makes the job start the client alone (never a game, never
through a Steam link), wait a bounded time for the sign-in, then carry on; a timeout, a client that cannot be started, or a cancel
leaves every folder as it was. A switch without play, a game started from a link, and a non-Steam game never ask.

Red observed: LaunchSteamTests, 6 of 11 failed before the change:
A_Steam_game_with_Steam_closed_is_refused_at_once_before_any_folder_is_read (Assert.False() Failure, Expected: False, Actual: True),
A_client_that_never_signs_in_fails_the_launch_and_changes_nothing and A_client_that_cannot_be_started... (Expected: Failed, Actual: Succeeded),
The_preview_says_Steam_is_needed_only_for_a_Steam_game... (Expected: error.launch.steamNotRunning, Actual: null),
Start_Steam_starts_the_client_once... (Expected: 1, Actual: 0), Cancelling_the_wait_for_Steam... (the job never reached the wait step).
The five that passed first time were mutation-checked: a switch that asks failed A_switch_without_play_never_asks_about_Steam,
and a check that ignored the game failed the running, non-Steam, already-up and preview cases.
CompleteSessionAsync now refuses a save with error.launch.sessionStillRunning when the game's process (or the program SavePoint
started) is still alive, and for two process-list looks after the game quit it looks again before trusting the list, so a store
that starts the game again just after it quit is not saved over. Skip is never refused.

Red observed: LaunchCompletionGuardTests, 3 of 4 failed before the change:
A_save_is_refused_while_the_game_is_still_running_and_stored_nothing, The_same_save_goes_through_once_the_game_has_closed and
A_game_started_again_right_after_it_quit_is_not_saved_over: Assert.False() Failure, Expected: False, Actual: True (the save was accepted).
Skipping_the_save_is_allowed_while_the_game_is_still_running passed first time; making Skip run the guard failed it.
Reds observed before the change:
- GameEditorCardsViewTests.Each_card_is_headed_and_says_how_much_it_matters: Expected "Game", Actual "The game".
- GameEditorGuidanceViewTests.The_Steam_app_ID_label_does_not_say_optional_because_everything_in_More_settings_is: Expected "Steam app ID", Actual "Steam app ID (optional)".
- GameEditorGuidanceTests.The_stop_detection_mod_file_and_app_id_questions_each_name_their_field_and_read_the_same_to_a_screen_reader: Expected "When do I need the program name?", Actual "When do I need this?".
- GameEditorGuidanceViewTests.No_two_question_buttons_in_the_editor_show_the_same_text: "When do I list mod files?" not found in the questions.
- GameEditorGuidanceViewTests.A_question_button_starts_at_the_left_edge_of_the_fields_above_it (6 cases): icon offset Actual 10, expected 0.

The three shared "When do I need this?" texts and their accessible-name variants are replaced by one question each, so the visible text and the spoken name agree. Question buttons under a field step back by their own padding.
FakeGame --exit-unless-env <name> quits at once with the exit code (1 when none is given) unless the variable is set, to stand in
for a game whose Steam library fails to start. An end-to-end launch test starts the client first (which sets the variable) and
then the game, which runs.

Red observed: FakeGameTests.Exit_unless_env_quits_at_once_with_failure_when_the_variable_is_not_set (Expected: 1, Actual: 2, an
unknown argument) and Exit_unless_env_quits_with_the_exit_code_given (Expected: 7, Actual: 2). The play-on case and the launch
test passed first time; removing the Steam step from the launch job failed the launch test (and four others).
The sidebar's destinations, search and buttons stay put and only the list of games scrolls, in an area of its own whose scrollbar takes a strip beside the rows instead of floating over titles. A long game name is trimmed to the rail's width. A short window gives up the brand and the "Your games" heading so the list keeps room, and the icon rail drops "No games yet." and trims its rows' padding to fit the scrollbar.

The library shelf's cards and its add tile wrap to the next row when the window narrows. The shelf scrolls vertically in its own area, a row and a half tall (one compact row in a short window), so the page below keeps its room, and nothing scrolls sideways.

A new sideways audit (LayoutAudit.HorizontalProblems) runs over every state in AppStates at 960x460, 910x432 and the 640x420 minimum window. It found and these edits fix: the history timeline's two buttons (now wrap), the history heading (wraps), the Games table's Version, Mod files and Last played cells (wrap), the error card's actions and plain-text supplement (wrap), and the icon rail's "No games yet." label (hidden).

Observed reds, all assertion failures:
- ShellRailScrollTests.The_destinations_keep_their_place_while_the_list_of_games_scrolls(560): Assert.Null() Failure: the nav list still had a ScrollViewer ancestor.
- ShellRailScrollTests.No_game_title_runs_under_the_scrollbar_of_the_list(560, 1040): "The Extraordinarily Long Title..." ends at 564 and the scrollbar starts at 209.
- ShellViewTests.A_long_list_of_games_scrolls_inside_the_rail_and_leaves_Add_a_game_in_view: ScrollViewer #RailScroll has more to show but only 37 px to show it in.
- ShellShelfReflowTests.The_shelf_never_scrolls_sideways_and_leaves_the_page_room_to_show(1040, 660): GameListBoxItem at (886,116 204x128) is outside the 1040x660 window and no scroll area reaches it.
- HorizontalOverflowAuditTests: 13 states failed, for example history-list "Go back without playing" spans 431 to 565 but its area spans 236 to 535, and games-running "41 minutes ago" needs 90 px and gets 86.

Mutation checks: AllowAutoHide back on fails the scrollbar-strip assertion; a horizontal StackPanel for the shelf fails every interface size; a disabled vertical scroll fails the arrow-key tests.
The launch flow shows a card with Start Steam and Not now before any dialog when the preview says Steam is closed, and again if
Steam closes between that check and the start. Start Steam makes the start carry the flag that lets the service start the client
alone; Not now changes nothing. While the service waits for the client the flow shows a Waiting for Steam card with Stop waiting
(the switching dialog and the game-is-starting banner would both be wrong then). Loading files without playing never asks.
The after-play hint and toast for a program that closed right away now tell the player to start Steam, because starting a game
Through Steam lets Steam update it over the version that was switched to.

Red observed: LaunchSteamFlowTests, 7 of 10 failed before the change: the Steam card tests got a LaunchBannerViewModel where an
ErrorCardViewModel was expected, and the two failure-id cases got the title Something went wrong where Steam needs to be running
and Steam isn't ready were expected. PostPlayDialogViewModelTests.A_program_that_closed_right_away_with_an_error_says_so_with_its_code...
failed on the old hint (Expected: ...If this is a Steam game, start..., Actual: ...If the game is in your Steam l...).
Three LaunchSteamFlowTests passed first time and were mutation-checked: always passing the flag, asking for a switch, and not
ending the wait card when switching begins each failed one of them.
Choose files... and Choose folders... sit beside Add a folder or file in the mod files list. Each opens the system picker (several items selectable) in the game's install folder; every picked item inside it becomes an entry written from the install folder with forward slashes, a folder as a folder entry, repeats skipped. Items outside it are not added and one line says how many were left out and why. Without an install folder both are off, with the reason on the line under the list and as the buttons' help text. Folders and files go through two new IDialogs members, so a view model never calls the storage provider. The chip row now inserts and removes single chips instead of redrawing, so the buttons keep keyboard focus after a pick.

The header's buttons moved from a horizontal stack in an Auto column to a wrapping panel that sits under the title in a window narrower than 760 px, in the same order.

Reds observed before the change:
- GameEditorModFilePickTests (12 of 13): entries Actual [] for the pick of root files, a subfolder file and folders; the left-out line Actual "" ; the no-install reason Actual "".
- StoragePickerOptionsTests.A_folder_pick_can_ask_for_several_folders and An_open_pick_can_ask_for_several_files: Expected True, Actual False.
- AvaloniaDialogsTests.Multi_picks_answer_nothing_while_no_window_offers_a_storage_provider: failed against a placeholder answer.
- GameEditorHeaderViewTests.Every_header_button_ends_inside_the_smallest_window: SaveButton ends at 647 (existing game) and 705 (new game), past the window's 640.
- ChipListViewModelTests: the new AddValues and entry tests were red against stubs; the two that first passed (no rebuild of the row, add values) were mutation-checked: always redrawing the row fails Adding_values_slots_the_new_chips_in_before_the_add_chip_without_rebuilding_the_row, an AddValues that adds nothing fails the order and count test.
- Passed on first run, mutation-checked: GameEditorModFilePickViewTests (always redrawing the row fails the focus test; dropping the buttons' help text fails the no-install test), GameEditorModFilePickTests.The_extra_buttons_are_named_for_what_they_pick (swapped name fails), and the wide-window case of GameEditorHeaderViewTests (a threshold of 5000 fails it).
- AppStateAuditTests editor-new and editor-existing failed on the first button names ("shows 'Choose files...' but is named 'Choose mod files in the game folder'"), so the names now start with the visible text.
A save refused with error.launch.sessionStillRunning leaves the session over with no further event, and the plain failure card
had only Dismiss, which stranded the session. The card now offers Choose again, which opens the after-play choices once more.
SteamWaitOptions refuses a polling interval that would spin, and the relaunch test gets a wider margin.

Red observed: LaunchSteamFlowTests.A_save_refused_because_the_game_is_still_open_offers_to_choose_again (Expected: Choose again,
Actual: Dismiss). SteamWaitOptionsTests passed first time; loosening the polling check failed the zero-interval case.
The sideways audit no longer skips editor-existing and editor-new: the header wraps now. No red: the audit passed with the early return removed, so a mutation check followed. Adding MinWidth=900 to the mods Browse button failed both editor rows; reverted.

New pick tests for the install-folder prefix trap (FooBar beside Foo), a pick on another drive, and a pick whose game folder part differs only in case (Windows only; the entry is the path below the game folder in the picked casing). All passed first run, so mutations: a StartsWith(Ordinal) check failed the prefix and case tests; dropping Path.IsPathRooted failed the other-drive test (Actual: [version.dll, Z:/Data/x.dll]). Restored. The two Windows-only tests are listed in the Linux skip list.
The live-tracking tests all used the immediate dispatcher, so dropping the Dispatcher.Post hand-off, turning the debounce into a throttle or shortening the longest wait failed nothing. StatusReadSchedulerTests runs the scheduler against a manual clock and a dispatcher that holds posts.

Reds observed: A_tick_posted_before_a_new_signal_does_not_read_early (Expected: 0, Actual: 1) and The_next_read_waits_twice_as_long_as_the_last_one_took_even_past_the_longest_wait (Expected: 1, Actual: 2).
Mutation checks on the tests that passed first time: calling the tick without Dispatcher.Post fails The_tick_reaches_the_read_only_through_the_dispatcher; a throttle (if waiting, return) fails A_second_signal_moves_the_read_to_a_settle_time_after_it and the longest-wait test; a 1 s cap fails the longest-wait test.
A game started outside SavePoint wrote constantly while SavePoint sat in the background, and each write burst triggered a full status scan of the install. The screen now takes the window's activity as a dependency and blocks reads while it is inactive or minimized; the window coming to the front reads once, replacing the view's Activated hook. The test fake now delivers events after dispose so the two reads-nothing tests prove the screen unsubscribes, and new tests cover the UI-thread hand-off and an event queued from the old game's watch.

Reds observed: Changes_while_the_window_is_in_the_background_are_not_read (Expected: 2, Actual: 3), Coming_back_to_the_window_reads_what_changed_in_the_meantime_once, A_minimized_window_that_is_still_reported_active_reads_nothing and A_read_that_was_waiting_when_the_window_went_to_the_back_is_made_when_the_player_returns (same shape); Activating_the_window_reads_the_status_again (Expected: 3, Actual: 2) before the screen listened to the window.
Mutation checks: posting the watch signal without the dispatcher fails A_change_raised_on_another_thread_reaches_the_scheduler_only_on_the_UI_thread; removing the unsubscribe and the ReferenceEquals guard fails A_change_in_the_old_games_folders_after_picking_another_game_reads_nothing and A_change_queued_from_the_old_games_watch_before_picking_another_game_reads_nothing.
A slow disk or a virus scanner on the CI VM stretches the writes, and the throttle then rightly raises more signals than the fixed limit of 30. The limit is now one signal per throttle gap of elapsed time plus three, below the number of writes.

No red: the test passed on its first run. Mutation check: arming the throttle timer with a zero gap fails it (Range 1 - 9, Actual: 599).
Screen readers: each editor card header (Game, Saves, Mods, Artwork) is now one heading named with its tag ('Game, Required'); the drawn heading and tag are not read again. A TextBlock's peer ignores AutomationProperties.Name, so the name sits on the header grid (AccessibilityView=Content). More settings gets heading level 2 like the other cards. In the icon rail the hidden 'No games yet.' note is carried as the Add a game button's help text, only while compact and empty.

Reds seen: A_screen_reader_hears_how_much_a_card_matters_as_part_of_its_heading ('Game, Required' expected, 'Game' actual), More_settings_is_a_heading_at_the_same_level_as_the_other_cards (2 expected, 0 actual), The_visible_tags_are_not_read_a_second_time (tag was a content element). Rail help text: with the HelpText binding removed the icon-rail test failed (Expected 'No games yet.', Actual 'Add a game' from the tooltip) and the widen test failed (Actual null); restored.

Mod-file picks: naming another game folder clears the left-out line (Expected '', Actual '1 item was left out...'); a folder typed with backslashes is not added again when picked (Expected 'BepInEx', Actual 'Data/Mods').
IFolderWatcher.Watch becomes WatchAsync: the setup runs on the thread pool (on Linux it walks the tree and adds an inotify watch per directory), takes a cancellation token, and ends once every folder is watched or given up on. IFolderWatch.Unwatched lists the folders it does not cover. The screen now starts the watch after the folder list and before the status scan, so a change during the scan is signalled. A reload sets a watch up again when it left a folder out, and so does the read after a fault; the read also looks at the folders first so a folder that appeared is watched. The app passes its window tracker to the screen.

Reds observed: The_new_games_folders_are_watched_while_their_status_is_still_being_read and A_change_made_while_the_status_is_being_read_is_read_afterwards (no watch yet), A_watch_that_could_not_cover_a_folder_is_set_up_again_by_the_next_reload (Expected: True, Actual: False), A_watch_that_lost_a_folder_after_a_fault_is_set_up_again_by_the_read_that_follows (same), A_folder_that_was_missing_and_appears_is_watched_after_the_next_read, The_status_is_not_read_before_the_watch_is_ready (never reached two watches); in the watcher tests The_watch_is_set_up_on_the_scheduler_it_is_given_and_not_by_the_caller (Expected: False, Actual: True), A_missing_folder_is_reported_as_unwatched_and_one_that_exists_is_not and A_folder_deleted_before_its_watch_starts_again_is_reported_as_unwatched (Expected one folder, Actual: empty), A_cancelled_setup_ends_cancelled_and_leaves_nothing_watching.
Mutation checks on tests that passed first time: retrying failed folders at every read fails A_watch_that_could_not_cover_a_folder_is_not_set_up_again_by_every_read; passing AlwaysActiveWindow from the composition fails The_composition_gives_the_games_screen_the_apps_folder_watcher_and_window. The view test that called the platform's Activated callback is removed, since the view no longer hooks activation.
A GOG or retail copy carries the Steam app id of the template it matched, so it was asked for Steam and could not be played with Steam closed. A game now needs the Steam client only when its install folder is in a Steam library (steamapps/common/<game>); an app id or a stray steam_appid.txt no longer counts. The card gains Play without Steam, which starts the program as it is and never starts Steam.

Start Steam only waited for sign-in, so Steam could update the game after the switch. The launch now reads the game's Steam manifest (read only) before Steam starts and again right before the program starts, and stops with error.launch.steamUpdatingGame when the build or update time changed or an update is running. The comment on the wait now says only what it guarantees.

The waiting card ends when Steam is signed in (new steamReady step) and the banner or progress dialog comes back for the folder read. A save after play shows a Checking the game has closed card while the relaunch guard waits. The relaunch guard test is driven by a scripted process list instead of a real second process. The Steam-before-dialog test now uses the Survival profile, which has unsaved saves. Editor, help and error copy no longer point Linux players at Through Steam.

Observed reds:
- SteamGamesTests.A_Steam_app_id_alone_does_not_make_a_game_a_Steam_game_when_the_install_is_outside_a_Steam_library: Assert.False() Failure, Expected False, Actual True.
- SteamGamesTests.A_game_with_a_stray_Steam_app_id_file_outside_a_Steam_library_does_not: Assert.False() Failure, Expected False, Actual True.
- LaunchSteamTests.A_Steam_update_that_starts_as_the_client_comes_up_stops_the_launch_before_the_program_starts, A_new_Steam_build_written_while_the_client_comes_up_..., A_Steam_update_already_running_when_Steam_is_up_...: Assert.Equal() Failure, Expected Failed, Actual Succeeded.
- LaunchSteamTests.Play_without_Steam_starts_the_program_with_Steam_closed_and_never_starts_Steam: SteamNotRunningException, the Steam check ignored the new flag.
- LaunchSteamFlowTests (9 tests): Collections differ at index 1, Expected "Play without Steam", Actual "Not now"; waiting card still ErrorCardViewModel after the ready step; no Checking card (Value is null).
Mutation checks: widening the update flags to include 2 failed A_Steam_game_whose_manifest_stays_as_it_was_starts_even_with_an_update_waiting; adding the app id back to NeedsClient failed A_GOG_copy_with_a_Steam_app_id_outside_a_Steam_library_never_asks_about_Steam; removing the steamReady step failed Start_Steam_starts_the_client_once_...; making the Steam question wait for the banner failed A_Steam_game_with_Steam_closed_asks_to_start_Steam_before_any_dialog_or_start; showing the card for Skip failed Skipping_the_save_shows_no_card_about_checking_the_game; disabling the relaunch delay failed A_game_started_again_right_after_it_quit_is_not_saved_over.
Every return to the SavePoint window ran a full status scan, which on a large install costs a lot for no reason when every folder is watched and nothing was signalled. The screen now reads on activation only when a signal or a due read was dropped while the window was away, a fault happened, or the watch does not cover a folder. When only a folder is missing it checks which folders exist (cheap) and reads only if one appeared. A scheduler tick that threw vanished unobserved; it now reaches the diagnostic log through AppServices.Log. A watcher's error handler is bound to its own instance and registered before the watcher is switched on, so an error from a replaced watcher no longer starts the folder twice.

Reds observed: Activating_the_window_when_every_folder_is_watched_and_nothing_was_signalled_reads_nothing and Activating_the_window_while_a_folder_is_still_missing_reads_nothing (Expected: 2, Actual: 3), Activating_the_window_after_a_fault_while_it_was_away_reads_once (Expected: 3, Actual: 4), A_background_status_read_that_fails_is_noted_in_the_log and A_read_that_throws_is_reported_and_the_next_signal_still_reads (no entry recorded), An_error_from_a_watcher_that_was_already_replaced_is_ignored (Expected: 0, Actual: 1). A_read_that_was_waiting_when_the_window_went_to_the_back_is_made_when_the_player_returns went red (Expected: 3, Actual: 2) once activation became conditional and drove the IsDue check.
The old Activating_the_window_reads_the_status_again relied on the unconditional read; it now sets an uncovered folder first. The two reads-nothing activation tests now have a reason to read, so they prove the block.
After-play save tests ended the session with "I'm done" while the stand-in game was still running. The running-game guard
correctly refuses a snapshot then (sessionStillRunning), so each test now closes the game first, as a player's game would be
closed: ModsLaunchTests.Saving_after_play_writes_a_point_in_all_three_folders, LaunchHeldFileTests (both after-play tests,
InUse and Unreadable), LaunchActionLogTests.A_save_that_skipped_a_folder_logs_which_folder_and_why and the PlayAsync helper
of LaunchRunTimeOutputTests (its two save tests failed on Linux). The guard itself is unchanged.

The editor opened scrolled in the smallest window: the launch choice list scrolled its selected item into view, and now that
the cards put that list just below the fold it moved the form by 26 px (86 px in the Library layout). The list no longer
scrolls to its selection, as the Settings choice lists already do. The scroll check now names the scroll area and its offset.

GameEditorFormTests and GameEditorModsFolderTests asserted help copy the card regrouping reworded; they assert the new copy.

Reds observed on the merged tip: Assert.True() Failure (Expected True, Actual False) at each CompleteSessionAsync call above;
JobPillPlacementTests editor, smallest window: "a scroll area did not start at the top (FormScroll at 26)" and "at 86";
GameEditorFormTests: Strings differ at pos 129 ("Use * for any name" vs "Rules are patterns"); GameEditorModsFolderTests: Expected
"Where do my mods live?" Actual "Does my game keep mods outside its folder?".
Steam was ensured running and the folders switched before the manifest was read again, so an update Steam was already running when Play was pressed wrote while the switch did. Once Steam is up, the manifest is now read first, and an update in progress or a new build refuses the launch with nothing changed (error.launch.steamUpdatingBeforeSwitch). Only the reading taken with Steam running counts, so a stale flag from a crashed update cannot block a launch that starts Steam. The check after the switch stays for an update that begins during it, and its copy now says the files may have changed.

Reds observed: A_Steam_update_already_running_when_Steam_is_up_stops_the_launch_before_any_folder_is_switched, A_Steam_update_that_starts_as_the_client_comes_up_..., A_new_Steam_build_written_while_the_client_comes_up_...: Expected "error.launch.steamUpdatingBeforeSwitch" Actual "error.launch.steamUpdatingGame". The stale-flag and during-switch tests passed first time; mutation checks (post-switch check removed, refusal on the pre-Steam reading added) made both fail.
The layout audits never opened the Steam question card, the waiting-for-Steam card or the "Checking the game has closed" card. Three app states now open them, and a small test checks each state shows the card it is named for (mutation checked: removing the Steam-needed preview or the pending check made those two cases fail). The audits found no layout problem.

The macOS process-name comment no longer carries a to-do, and states plainly that Steam counts as ready where it runs (and signed in on Windows) because Linux's registry.vdf has no signed-in account. The relaunch guard comment now says it covers a quick relaunch only and points at the grace after the start.

Reds: none for the new states (they passed first time; mutation checks above). Format whitespace fix in ErrorTypesTests.
Match the user guide to the Steam refusals and the paused live updates
Some checks failed
Docs / site (pull_request) Successful in 1m29s
Gate / linux (pull_request) Failing after 20m46s
Gate / windows (pull_request) Failing after 34m12s
bc260094b4
Red observed: UiWaitTests.Waiting_on_a_pool_thread_leaves_work_posted_to_the_UI_thread_for_the_UI_thread
failed with 'Assert.Null() Failure: Value is not null ... InvalidOperationException: The calling thread cannot access this object because a different thread owns it' thrown from Dispatcher.RunJobs inside UiWait.UntilAsync, the failure CI showed for LaunchSteamFlowTests (a plain Fact resumes on a pool thread). UiWait now pumps only when it is on the UI thread.
Red observed (with the reporter made to deliver the last name in the final report, as the Windows CI run did):
CaptureProgressTests.A_later_capture_counts_only_the_files_that_changed failed at the progress.Last equality with
'Expected: FileProgress { ... NewPaths = , ...} Actual: FileProgress { ... NewPaths = <>z__ReadOnlyArray[String] ...}'.
Which report carries the name depends on whether the store poll saw the last byte before the add finished, so the test now
compares the numbers with NewPaths set aside and asserts the names once over every report.
Merge ci-fixes-0920 into integration-0920
All checks were successful
Docs / site (pull_request) Successful in 1m22s
Gate / linux (pull_request) Successful in 21m26s
Gate / windows (pull_request) Successful in 36m25s
Docs / site (push) Successful in 1m33s
Release / linux (push) Successful in 2m23s
Release / windows (push) Successful in 2m55s
Release / checksums (push) Successful in 35s
fbc17f5e2c
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!254
No description provided.