0.9.9: live snapshot details, install-only log rules, faster switches #122

Merged
ethan-hann merged 37 commits from integration-103 into main 2026-10-25 05:42:50 -05:00
Owner

Builds on 0.9.8 (PR #117); merge that first.

  • A watched snapshot stages its files under 128 MiB in groups of at most 2 GiB or 2000 files and every bigger file in one last add, so Details names every file as it is stored and a long copy says which big file it is on (an estimate from store growth). A stopped snapshot's retry counts what was already staged, a file deleted mid-snapshot no longer fails it, and an unreadable file still fails it by name. Closes #108.
  • New games leave out logs and crash dumps (**/.log, **/.dmp, **/*.mdmp) from the game's own folder only, through a new install-only rule list (installIgnorePaths). After play, a session whose only install changes are logs or crash dumps offers to leave them out instead of warning of an update. A game-wide default rule that would hide a file in the saves folder moves to the install-only list at Add, Reconnect, Start fresh and library add, and the player is told. Closes #109. Closes #114.
  • A log file another program holds still gets that offer; a held game file still gets the update note. Closes #115.
  • A switch reads each left-out file once instead of three more times (skip-worktree on the aligned entries until the check ends; 2 GB left-out cache: about 22 s to about 15 s). Every switch, discard and snapshot first clears any mark a killed SavePoint left. A forced switch no longer overwrites a left-out file both points record alike. Closes #110.
  • A capture records removals by name before any add, so a folder that replaced a recorded file can no longer bring left-out files into the store. Closes #121.

The build with warnings as errors and the format check pass locally. - Every pack a capture's add writes gets a .keep, and each routine repack first keeps any pack of at least 128 MiB holding at most 1024 objects, so geometric repacking can no longer roll up and rewrite the big streamed archives (it did on the second routine repack after a big first snapshot, about 85 GiB for Cyberpunk). Free up space removes SavePoint's keeps first, so unreachable big files still go. Closes #120.

  • The start screen centers each line of its buttons, and the sidebar's footer buttons center their wrapped labels. Closes #124.
Builds on 0.9.8 (PR #117); merge that first. - A watched snapshot stages its files under 128 MiB in groups of at most 2 GiB or 2000 files and every bigger file in one last add, so Details names every file as it is stored and a long copy says which big file it is on (an estimate from store growth). A stopped snapshot's retry counts what was already staged, a file deleted mid-snapshot no longer fails it, and an unreadable file still fails it by name. Closes #108. - New games leave out logs and crash dumps (**/*.log, **/*.dmp, **/*.mdmp) from the game's own folder only, through a new install-only rule list (installIgnorePaths). After play, a session whose only install changes are logs or crash dumps offers to leave them out instead of warning of an update. A game-wide default rule that would hide a file in the saves folder moves to the install-only list at Add, Reconnect, Start fresh and library add, and the player is told. Closes #109. Closes #114. - A log file another program holds still gets that offer; a held game file still gets the update note. Closes #115. - A switch reads each left-out file once instead of three more times (skip-worktree on the aligned entries until the check ends; 2 GB left-out cache: about 22 s to about 15 s). Every switch, discard and snapshot first clears any mark a killed SavePoint left. A forced switch no longer overwrites a left-out file both points record alike. Closes #110. - A capture records removals by name before any add, so a folder that replaced a recorded file can no longer bring left-out files into the store. Closes #121. The build with warnings as errors and the format check pass locally. - Every pack a capture's add writes gets a .keep, and each routine repack first keeps any pack of at least 128 MiB holding at most 1024 objects, so geometric repacking can no longer roll up and rewrite the big streamed archives (it did on the second routine repack after a big first snapshot, about 85 GiB for Cyberpunk). Free up space removes SavePoint's keeps first, so unreachable big files still go. Closes #120. - The start screen centers each line of its buttons, and the sidebar's footer buttons center their wrapped labels. Closes #124.
Ten screens taken on the Ubuntu test VM from a clean SavePoint with a
real game (Grounded): first run, adding a game, the first snapshot,
the profile list, the check before playing, the after-play choices,
History with Recently removed, Activity, and Settings. Each image has
alt text describing what it shows.
The after-play "Replace ... with this session" choice named the newest point on
the played profile's saves branch. A profile made with New profile while another
was loaded starts its saves branch on that profile's tip, so the dialog offered
to replace the other profile's snapshot (and the rewritten point took its name).
The target is now the newest point the played profile owns in the saves folder,
else in the install folder, with ownership decided as History decides it (the
first profile in catalog order whose history holds the point). A profile that
owns no point, such as a fresh duplicate, is no longer offered Replace.

Tests added for the other reported symptoms, which pass without a code change:
files rewritten with the same bytes are not changes in status, in a save's file
count, or in the after-play count; a profile made from another offers the saves
it started with; a kept session updates the profile's snapshot count.

Observed red (before the fix):
LaunchUpdateExistingTests.The_replace_choice_names_a_point_of_the_played_profile_not_the_one_whose_saves_it_started_with
  Assert.NotEqual() Failure: Strings are equal (the target was the other
  profile's save point id).
Mutation checks (each failed for the expected reason, then restored):
- ownership as "exclusive to this profile" fails The_profile_another_was_made_from_still_replaces_its_own_point
- no ownership filter fails the duplicate, the replace-result and the App
  journey tests
- diff-index (stat only) in the status listing fails the status test and the
  session count test (expected 0, actual 2)
- a staging listing that includes unchanged tracked files fails the capture
  count test
Replace after play is now offered for the newest point History lists under the
played profile (same grouping and ownership as History, reused from
HistoryReader), and only when, in every folder the save will write (a folder
with something unsaved), that point's commit is the profile's tip there and no
other profile's branch reaches it. Otherwise the dialog offers Keep as a new
snapshot and Not now. This removes the cases where an amend split one capture id
across two commits (a duplicate or a profile made from another continuing from
the rewritten commit), where the offered point was another profile's, and where
a folder was written without the point's commit being its tip (which produced
the "didn't end with the snapshot you chose" card). The target is the newest by
date across both folders rather than the saves folder first.

ListCommitsOnlyOnAsync takes an optional max count; the check reads one commit.

Observed reds (before the change, assertion failures):
- A_replace_is_not_offered_after_a_duplicate_holds_the_snapshot...: Assert.DoesNotContain() Failure: Item found in collection
- In_a_chain_of_profiles_made_from_one_another...: Assert.DoesNotContain() Failure: Item found in collection
- The_profile_another_was_made_from_is_not_offered_a_replace...: Assert.Null() Failure (target Vanilla)
- A_profile_whose_saves_are_another_profile_s_is_not_offered...: Assert.Null() Failure (target Heavy mods)
- The_snapshot_offered_is_the_newest_the_profile_owns_in_either_folder...: Assert.Null() Failure (target Second save)
The D31 test that replaced a saves point while the install changed now asserts
the choice is not offered and is refused.

Mutation checks (each failed the named tests, then restored): other branches
empty fails the duplicate, chain and base-profile tests; oldest instead of
newest fails the "newest" and result tests; skipping a folder without the
point's commit fails the chain, install-only and Heavy tests; reporting kept-as-new
for every amend fails the result-card test; dropping the started-with saves from
the target list fails A_profile_made_from_another_offers_the_saves_it_started_with.
The three "rewritten with the same bytes" tests were mutation-checked earlier:
diff-index in the status listing fails the status and launch tests (expected 0,
actual 2); a staging listing of every tracked file fails the capture count test.
The wiki has no docs/images, so a guide's relative image or link
(images/x.png, ./images/x.png) would not render there. The page transform
now rewrites such targets to <server>/<owner>/<repo>/raw/branch/main/docs/images/x.png,
taking server and repository from the same variables as the source note
(with the same defaults). Alt text and titles are kept; absolute URLs,
anchors, code spans and fenced code are left alone.

Also asserts every relative image a guide shows exists under docs/, and
lists the new pwsh-based tests as may-skip where pwsh is missing.

Observed reds before the change:
- A_relative_image_or_link_into_docs_becomes_a_raw_address_on_main_and_keeps_its_alt_text:
  Assert.Contains() Failure: Sub-string not found (Not found: "![First run screen](https://git.tortal.tech/ethan-...")
- The_raw_address_follows_the_server_and_repository_the_job_sets:
  Assert.EndsWith() Failure (page ended with "![a](images/x.png)")
Mutation checks (first-run passes): dropping the code-span exclusion failed
Code_blocks_code_spans_and_absolute_addresses_keep_their_image_text; a guide
linking images/missing-shot.png failed Every_relative_image_a_guide_shows_exists_under_docs.
A mod loader rewrites its logs on every run, so each session warned that the game's own files had changed "as an update would", added a version-and-mods snapshot, and History read "4 mod files updated". Measured across the Steam and GOG installs on the dev PC, .log, .dmp and .mdmp files are always run-time output (loader and engine logs, crash dumps). Folder names such as crash, cache or shaderCache are not safe: shipped engine tools, shader caches and game data live in folders with those names, and .tmp and .bak files are real content in some games, so only the three extensions are used.

- New games (manual Add, templates, library import) start with the rules **/*.log, **/*.dmp and **/*.mdmp in Files to leave out. They show and remove like any rule, and the editor explains them in plain words. Template rules are kept and not repeated. Existing games and imported definition files are not changed.
- After play, when every changed file in the game's own folder is a log or crash dump, the dialog says so instead of the update note and offers "Leave these out from now on". It adds the matching rules to the game, keeps the dialog open and does not touch the session's choice. Files SavePoint could not read count as not covered.
- History and the switch counts no longer treat logs and crash dumps as mod files, for snapshots already taken as well.

Observed reds (assertion failures, each before its change):
- RunTimeOutputTests.New_games_leave_out_logs_and_crash_dumps: Expected ["**/*.log", "**/*.dmp", "**/*.mdmp"], Actual [] (and 9 more in the class against a stub)
- GamesLibraryTests.A_game_found_in_a_library_starts_out_leaving_out_logs_and_crash_dumps_with_or_without_a_template: Expected ["**/*.log", "**/*.dmp", "**/*.mdmp"], Actual []
- LaunchRunTimeOutputTests.A_session_where_only_logs_changed_in_the_game_folder_names_the_rule_that_covers_them: Expected ["**/*.log"], Actual null
- LaunchRunTimeOutputTests.Adding_the_rule_during_the_dialog_keeps_the_logs_out_of_the_save_that_follows: failed on the missing rule list
- HistoryTests.Logs_and_crash_dumps_inside_a_mod_folder_are_not_counted_as_mod_files: Expected 0, Actual 2
- PostPlayDialogViewModelTests: Files_that_are_only_logs_or_crash_reports_are_said_to_be_that_and_not_an_update (note text), Leaving_the_files_out_adds_the_rule_to_the_game_and_leaves_the_sessions_choice_and_the_dialog_alone (rule list unchanged), When_the_game_cannot_be_changed_the_reason_shows_and_the_offer_stays (Expected True, Actual False), One_log_reads_in_the_singular
- GameEditorFormTests: A_new_game_starts_empty_with_the_create_title_and_Save_unavailable (Expected the three rules, Actual []), A_new_game_says_in_plain_words_why_logs_and_crash_reports_are_left_out (Expected True, Actual False), A_template_that_already_brings_the_rules_has_the_note_too

Tests that passed on their first run were mutation-checked: the template draft tests (defaults dropped from ToDraft), LaunchRunTimeOutputTests.A_log_beside_a_changed_game_or_mod_file_is_still_an_update_and_offers_no_rule (RulesCovering skipping other files: Expected null, Actual ["**/*.log"]) and PostPlayDialogViewModelTests.A_rule_the_game_already_has_is_not_added_twice (no de-duplication: rule listed twice).

Existing tests that described the old draft shape now expect the default rules (GameTemplatesTests draft test, TemplateLibraryHintsTests).
Replace after play is judged by one rule (ReplaceRule), at the end of the
session and again inside the capture job under the game's lock. For each folder
with something unsaved: if the snapshot has no commit there, the files join it
as a new commit and nothing is rewritten; if it has one, that commit must be the
profile's newest there and no other profile may reach it, and then it is
rewritten; otherwise it is refused. Replace is offered, and carried out, only
when no folder refuses and at least one is rewritten; with nothing unsaved it is
not offered. If the rule fails when the save runs, every folder is saved as a new
snapshot and reported as kept as new (only then). This restores replacing a
saves-only snapshot in a session that also wrote the install.

The lineage reads behind the newest-owned lookup are throttled to the existing
parallelism limit, and nothing is grouped when nothing is unsaved.
ListCommitsOnlyOnAsync takes maxCount before the cancellation token.

Observed reds (before the change, assertion failures):
- Nothing_unsaved_at_exit_offers_no_replace: Assert.DoesNotContain() Failure: Item found in collection
- A_change_only_to_files_the_game_ignores_offers_no_replace: same
- A_folder_that_changes_after_exit_and_whose_snapshot_another_profile_holds_is_saved_as_a_new_snapshot_and_says_so: Assert.All() Failure (folders not kept as new)
- An_update_leaves_an_install_only_point_alone_when_the_install_changed_during_play (restored original flow): Assert.Contains() Failure: Item not found in collection
- A_single_profile_can_replace_a_saves_only_snapshot_and_then_one_that_also_wrote_the_install: Assert.Contains() Failure: Item not found in collection
Guards that passed without the change: saves folder gone at exit, replace after a
duplicate once the original has its own snapshot.

Mutation checks (failed for the expected reason, then restored): skipping the
save-time check fails the changes-after-exit test; treating a missing commit as
refuse fails the restored D31 flow and the single-profile test; the empty-written
early return is only a shortcut (the at-least-one-rewrite requirement already
refuses), so its tests are guards.

Existing tests updated deliberately: the LaunchLeftFolder update case (nothing
unsaved at exit, so Replace is refused), the held-file update case (the file is
held when the game closes), the start test (Vanilla's saves are Modded's, so no
Replace), the contract story (both backends offer no replace after a play with
nothing unsaved).
The release source step reused archives already in source/packages when they
matched their pin but never removed ones an older pin list named, so after a
MinGit update stale sources could be published. Both package scripts now delete
the regular files directly inside that folder that build/msys2-sources.json
does not list (links, folders and their contents stay), say which, and refuse an
empty list. The cleanup runs before any download.

package.sh read the list with awk, which depended on the JSON's exact line
layout. It now reads it through the new tools/PackageSources tool (run with the
SDK the script already needs), so reformatting the JSON cannot change what is
read. The helpers moved to build/package-sources.sh and build/package-sources.ps1
so the tests can run them without downloading anything.

Observed reds (PackageSourceScriptTests, run before the implementation):
- Remove-StalePackageSources removes ...: "an archive an older list named goes"
  (assertion failure, file still there)
- The_powershell_script_given_an_empty_list_removes_nothing: "Assert.ThrowsAny()
  Failure: No exception was thrown"
- Each_package_script_cleans_the_folder_before_it_downloads_anything_into_it:
  "package.sh has to clean the packages folder before its first download."
- The_bash_script_no_longer_reads_the_package_list_with_awk: awk found in the script
- Bash reader on a minified list (run by hand in Git Bash, bash tests skip on
  Windows): the old awk read 0 archives, the new reader 50.
The pwsh reader tests passed on first run (existing behavior moved); mutation
check: returning the file name as the url and not lowercasing the hash failed
all four layout cases and the real-list test.
The save-time check judged a replacement folder by folder but did not keep the
result: a retry of a save that half worked started from the original plans and
judged only the folders left, so a first try saved as new could be followed by a
retry that rewrote, and a folder that only joins could be reported as kept as
new. The judgment is now kept by capture id until the save fully works, and a
retry uses it. Each folder's verdict is written into its plan: only a folder
judged to be rewritten keeps its replacement; a folder that only joins, or that
the check skipped as clean and that is written before it is saved, is saved as a
plain commit and never rewrites anything.

Observed reds (before the change, assertion failures):
- A_retry_of_a_replacement_that_was_saved_as_new_stays_new_and_does_not_rewrite_the_folder_that_failed: Assert.All() Failure, the retried folder was not kept as new
- A_retry_of_the_folder_that_only_joins_a_replacement_is_not_reported_as_kept_as_new: Assert.All() Failure, Assert.False() Failure, expected False, actual True
- A_folder_the_check_skipped_as_clean_is_not_rewritten_if_it_is_written_before_it_is_saved: Assert.Equal() Failure, the shared install commit had been rewritten
package.sh still read the "sources" of build/git-manifest.json with awk, which
only worked for one exact line layout. tools/PackageSources now has two
subcommands (archives, tags) and package.sh reads both files through it, so no
awk reads JSON in the packaging scripts. package.ps1 reads the tags through a
new Get-TagSourcePins in build/package-sources.ps1; both readers sort by key and
lowercase the hash, and the notices check stays in package.ps1.

Observed reds, run on the Linux test VM before the change (bash helper still
awk): The_bash_script_reads_the_same_tag_sources_whatever_the_layout_of_the_manifest
failed for Minified, FourSpaces, Tabs and ReorderedWithExtras, and
The_bash_script_no_longer_reads_the_package_list_with_awk failed because awk was
still in the script. The pwsh tag tests passed on first run (existing reader
moved); mutation check: not lowercasing the hash failed all four layout cases.

Linux results after the change, run one class at a time: PackageSourceScriptTests
25 total, 12 passed, 13 skipped (pwsh is not installed there; every bash test
ran, including the symlink case), PackageSourcesTests 7 total, 6 passed,
1 skipped (the Windows-bundle list check).
On a 44.6 GB first snapshot the Activity details listed 4 of 222 changed files and said
nothing about the game folder for minutes. Two causes: names rode on progress reports,
which are throttled to ten a second, so the burst git prints when an add ends was mostly
dropped; and git prints a file's name only when its whole add ends (stdout is buffered
whenever it is not a terminal).

Names: the progress reporter keeps every name git prints and attaches the unreported ones
to the next report (FileProgress.NewPaths). The capture combiner turns each into a detail
line once, before the progress that shows the last of them.

Batches: a watched capture now hands git its files in groups (up to 2 GiB or 2000 files,
a file of 1 GiB or more alone), so each group's names arrive when its add ends. An
unwatched capture is still one add. GIT_FLUSH=1 was measured first and changes nothing:
300 files, 7.1 s add, all 300 names in the last 0.5 s with and without it. The cost of
batching is one git start (about 0.3 s) per group; on a 5.5 GB set (2212 files) 4 groups
measured +1% to +5% against one add (run to run noise is about 5%), and 20000 small files
in 8 groups was within noise. The snapshot is the same tree a single add makes (tested).

Quiet stretches: while a large file is added alone, the details say which file and how
much of it is stored; with several files in one add, the folder and how much of it is
stored (git's order inside an add is not known, so no file is named). At most one such
line per 20 s since the last name or detail, never while the capture is only finishing.
New catalog strings: activity.step.capture.fileStart, fileProgress, folderProgress. The
line formatter now shows any step argument starting with "bytes" as a size.

Observed reds (assertion failures, before the change):
- ProgressReporterNamesTests.A_burst_of_names_is_delivered_whole_and_in_order: expected
  222 names, actual [] (also ..._not_repeated_by_the_byte_reports... and
  Names_not_yet_reported_when_the_capture_fails..., both actual []).
- CaptureProgressCombinerTests.Every_name_of_both_folders_becomes_a_line_once_...: expected
  "line:a.bin", actual "progress:c.bin"; ..._large_file_is_announced_when_it_starts_...
  and A_folder_detail_names_the_folder_... expected the step lines, actual [].
- StagingBatchesTests (stub returning one batch): 5 of 8 failed, e.g.
  A_batch_closes_at_the_file_limit and A_large_file_is_a_batch_of_its_own_and_is_marked_solo.
- ProgressReporterDetailTests (no-op BeginBatch/EndBatch): 8 of 11 failed, e.g.
  A_large_file_is_announced_as_soon_as_its_batch_begins expected the Starting detail,
  actual []; The_same_quiet_stretch_is_not_reported_again... expected 2, actual 0.
- CaptureBatchesTests.A_watched_capture_adds_its_files_in_groups_and_stores_every_one:
  expected 4 adds, actual 1; A_groups_names_have_arrived_before_the_next_group_starts
  expected 3, actual 0; A_large_file_is_announced_before_its_add_and_added_alone
  expected the Starting detail, actual null.
- JobLineFormatterTests.Every_byte_count_of_a_step_is_shown_as_a_size: expected "Copying
  Data/big.pak (4.5 GB)...", actual "(4500000000)".

First-run passes were mutation-checked (each mutation failed the named tests, then was
restored): throttling, null names, name delivery in the combiner, batch splitting, last
batch dropped, one-file batches for an unwatched capture, solo threshold, finishing guard,
name resets the quiet timer, registry path dedupe.

Two existing assertions in ProgressReporterBytesTests now ignore NewPaths when comparing
a whole report, since a report that names a file now carries the name.
The fetch step on Linux and macOS matched the manifest line by line with awk, so
minified, tab-indented or reordered JSON made it find nothing. It now asks
tools/PackageSources (new "bundle" command) for the runtime id's url, version,
sha256, archive, layout, entry and its layout's prune patterns, the way
package.sh already reads its lists. The build has the .NET SDK by definition;
python3 and jq are not in the documented prerequisites (bash, tar, curl or wget).

Several projects can reach the fetch at once and each would build the tool, so the
read takes a short lock of its own in .tools/downloads. DOTNET_HOST_PATH (set by
MSBuild) is preferred over dotnet on the path. The read only runs when the stamp
is stale, since MSBuild skips the script otherwise.

Observed reds (Linux VM, FetchGitManifestLayoutTests, before the change):
- The_bash_script_prunes_with_the_list_of_the_runtimes_layout_whatever_the_layout_of_the_manifest
  (Minified, FourSpaces, Tabs, ReorderedWithExtras): Assert.True failed with
  "fetch-git: no bundled git for runtime id 'win-x64'"
- The_bash_script_no_longer_reads_the_manifest_with_awk (Windows and VM):
  Assert.DoesNotContain() Failure: Sub-string found "awk"
Passed on first run, so mutation-checked: refuses_a_manifest_that_is_not_json
(tool made tolerant: NotEqual(0) failed with 0) and names_a_runtime_id (id dropped
from both messages: "linux-riscv" not found).
The leave-out rules apply to every folder of a game, so a rule for logs or crash dumps could silently stop a saves folder from being saved.

- New games: after the folders are set up, each default rule is checked against the saves folder with git's own ignore matching (ls-files -o -i and -c -i against a list of its own, the same matching a capture uses). A default rule that would leave out a file there is not saved with the game, and the editor says which rule was left off. If the check itself cannot run, the defaults are left off rather than risked.
- After play: "Leave these out from now on" asks the new CheckLeaveOutAsync first. It adds only the rules that match nothing in the saves folder, and names the files of any rule it did not add.
- The run-time-only note is decided by git in the install folder (so the folder's core.ignorecase applies, not the platform's), and the offered rules are the ones git agrees cover every changed file.
- The default-rules note in the editor is recomputed whenever the form is loaded, so Import takes it away, and it shows only for a blank new game, not for an edited game, a template or a definition file that happens to hold the same rules.
- A leave-out that fails after the dialog has closed is shown as a message instead of being lost.
- Copy: one file reads "It is only a log or crash report", and the note says the game writes them while it runs.

Observed reds (assertion failures, each before its change):
- GamesLeaveOutTests (stub that asked nothing): A_new_game_drops_the_default_rules_that_would_leave_out_files_in_its_saves_folder Expected "**/*.dmp", Actual "**/*.log"; Asking_about_rules_names_the_safe_ones_and_the_files_the_others_would_leave_out Expected "**/*.mdmp", Actual "**/*.log"; A_save_the_game_already_recorded_blocks_a_rule_too and Only_a_few_names_are_given_for_a_rule_that_matches_many_files failed on the missing blocked rule.
- GameEditorFormTests.A_prefilled_form_has_no_note_even_when_its_rules_are_the_defaults, A_definition_file_that_happens_to_hold_the_default_rules_gets_no_note, GameEditorTransferTests.Importing_a_file_over_a_blank_form_takes_the_default_rules_note_away: Expected False, Actual True.
- GameEditorSaveTests.A_new_game_whose_saves_folder_holds_files_a_default_rule_would_hide_says_which_rule_was_left_off: no message shown.
- PostPlayDialogViewModelTests: A_rule_that_would_leave_out_files_in_the_saves_folder_is_not_added_and_the_files_are_named (Expected the three rules, Actual with "**/*.dmp" added), Only_the_rules_that_match_nothing_in_the_saves_folder_are_added_and_the_others_are_explained (result stopped after "Done"), One_log_reads_in_the_singular and Files_that_are_only_logs_or_crash_reports_are_said_to_be_that_and_not_an_update (old wording), A_failure_that_comes_after_the_dialog_closed_is_shown_as_a_message_instead_of_being_lost (no message).
- The earlier red that came from a null dereference is replaced: with the offered rules forced to null, Adding_the_rule_during_the_dialog_keeps_the_logs_out_of_the_save_that_follows now fails on Expected ["**/*.log"], Actual null, and so do A_log_that_earlier_snapshots_recorded_is_dropped_from_the_next_one_and_kept_in_the_earlier_ones and The_offered_rule_follows_the_folders_own_letter_case_setting.

Passed on the first run, then mutation-checked: GamesLeaveOutTests keep-all cases (a check that blocks everything failed 5), LaunchRunTimeOutputTests.The_offered_rule_follows_the_folders_own_letter_case_setting (exact comparison instead of ignoring case: failed). The existing-game path (a log recorded in earlier snapshots, rewritten, Leave these out) is covered by A_log_that_earlier_snapshots_recorded_is_dropped_from_the_next_one_and_kept_in_the_earlier_ones, and the dialog test now asserts the saved snapshot's files.

Note found on the way: a capture that holds only logs the rule now leaves out records no new install snapshot, so the next install snapshot is the one that no longer holds the log.
build/msys2-sources.ps1 reads etc/package-versions.txt from the extracted
bundle, finds each package's source archive the way build-extra/get-sources.sh
does (Git for Windows pacman-repo release for the exact version first, then
repo.msys2.org as .src.tar.zst then .src.tar.gz), downloads it to a cache
folder, hashes it and writes the list in the existing format. Packages built
from another package's source (libatomic from gcc, curl-winssl from curl) are
looked up under that source. Packages without an archive are reported with the
addresses tried and nothing is written. The network is two injectable
scriptblocks, so the tests never touch it.

Each archive's .sig is verified with gpg in a private home holding only the
keys pinned in build/keys (MSYS2 development key for repo.msys2.org, Git for
Windows release key for the pacman-repo releases). A bad, missing or foreign
signature stops the run and removes what the run downloaded.

Observed reds (Msys2SourcesScriptTests): all 29 first tests failed with
"build/msys2-sources.ps1 does not exist."; the 13 signature tests failed on
the pwsh exit-code assertion ("term not recognized") and on Assert.Contains
"Sub-string not found" for the Find-PackageSources cases; the gitk case
failed on Assert.StartsWith (it was looked up as mingw-w64-gitk, not
mingw-w64-git). Mutation checks: deliberate breakages of the script (dedupe,
alias table, extension order, tag/version match, text cache, failed-url set,
cache reuse, sort orders, missing report, BOM, bundle check, shorter-name
fallback, malformed line, BADSIG, primary fingerprint, signature check,
pinned host, missing signature) each failed at least one test; all restored.
Reconnecting and starting fresh both save through InitAndSaveAsync, which
already runs WithoutRulesThatHideSavesAsync, so the Core behavior needed no
production change on this branch. Tests now pin it for each resolution, plus
the case where nothing matches and all default rules stay. The App fake's
ResolveOrphanAsync now drops blocked defaults like the service, and a test
checks the editor shows the "rule left off" notice after either answer.

Observed reds:
- Core tests passed on first run; mutation (removing the check call in
  InitAndSaveAsync) failed both resolution tests: Expected "**/*.dmp",
  Actual "**/*.log".
- App A_default_rule_left_off_after_the_question_is_said_in_a_notice (both
  cases) failed before the fake change: Expected "**/*.dmp", Actual
  "**/*.log". With the fake fixed it passed; removing the editor's
  SayWhichRulesWereLeftOff call failed it again.
The catalog lint cannot see message arguments, so a job line passing a git
folder path as an argument went unchecked for capture, optimize and launch
lines. One test now drives every JobKind against the real backend with real
git (capture, compact for one and all games, switch, launch, storage move,
clear) and fails on any file path or text argument that has a .git segment
or, in a step argument, an engine folder name (objects, refs, pack, info,
logs, index, HEAD, hooks, packed-refs). Kinds come from the enum, so a new
kind without coverage fails. The checker moved out of the move/clear tests
into a shared helper both use.

The test passed on its first run: no real leaks were found. Mutation checks,
each failing with the expected assertion and then restored:
- compact step game arg set to Play\install.git\objects\pack: "a Compact job
  shows the engine's folders"
- capture step path arg set to "pack": "a Capture job shows the engine's folders"
- launch step game arg set to x/install.git/refs: "a Launch job shows the engine's folders"
A Replace that changed only the saves leaves the snapshot's install commit on the
profile under capture id X and records the old saves commit, also X, as removed.
Bringing that back gave the new profile a saves commit carrying X, which History
folded into the original profile's point X (first profile in catalog order owns it),
so the new profile showed no point for it.

Bring back now copies the recorded commit onto the new profile under a fresh
capture id (same files, parents, name, capture time) when the other folder only
reaches the snapshot through the profile it left and carries the same id, and
drops the superseded record so the snapshot leaves Recently removed. Recently
removed itself is unchanged: such a snapshot is listed as a saves-only snapshot
under its own name.

Observed red: BringBackTests.A_partly_replaced_snapshot_brought_back_is_its_own_point_...
failed with "Assert.Single() Failure: The collection was empty" (the new profile's
History had no point). The listing test passed on its first run; mutation check:
making the saves-only kind VersionAndMods failed it (Expected SaveOnly, Actual
VersionAndMods), and skipping the record drop failed the round trip test
(Assert.Empty: Collection was not empty).

The existing delete-preview test for a snapshot recorded in one folder now expects
the split point counts (4 only here, 2 saves points).
A game's Files to leave out rules name files whose content can differ from the
target. The switch aligns their index entries to the target, so they never match
on stat and git hashed them in the checkout's own refresh, in the refresh after
the switch, and in the verify diff. A 2 GB left-out cache cost three extra full
reads per switch.

The alignment now marks those entries skip-worktree for both kinds of switch
(it did so only for a forced one), which git honors in all three places. The
mark is taken off once the verify pass ends, and also when the switch fails or
is stopped, so a later save cannot miss the file. The alignment's own refresh
stays: it is the one read that tells a file already holding the target's bytes,
and gives it a valid stamp so later comparisons do not read it again.

Reds observed before the change (LeftOutReadOnceTests):
- The_cache_is_marked_skip_worktree_while_the_index_is_refreshed_and_while_the_verify_pass_looks
  (both modes): Expected "update-index sees S", Actual "update-index sees H".
- A_left_out_file_that_already_holds_the_targets_bytes_keeps_a_valid_stamp_in_the_index
  failed against a --no-refresh variant of the alignment ("size: 0" found),
  which is why the refresh stays.
Tests that passed on first run were mutation-checked: removing the clear after
verify fails The_mark_is_gone_when_the_switch_ends...; disabling the clear on
failure fails The_mark_is_taken_off_when_the_verify_pass_gives_up; making verify
skip every file fails A_file_the_patterns_do_not_name_is_still_checked_and_written_again.

Measured on a 4 x 512 MB left-out folder that differs between two snapshots:
switch 21.5 s and 23.8 s before, about 15 s after (the refresh and verify diff
fell from about 4.7 s to 0.2 s, the checkout's own refresh from about 3.5 s to 0).
# Conflicts:
#	docs/developer-guide.md
Version 0.9.8
Some checks failed
Gate / linux (pull_request) Failing after 11m14s
Gate / windows (pull_request) Has been cancelled
8dc5a95465
Each git add writes its own bulk-checkin pack for files over core.bigFileThreshold,
so one add per big file left one-object packs. The routine repack weighs packs by
object count and would rewrite every big archive along with them. All files at or
over the threshold now go into one add, run after the small-file groups (2 GiB or
2000 files each), so a capture writes one pack as before. The live file name is an
estimate: the object store's growth since that add began is laid over the big files
in the order git takes them (tracked changed files first, then new ones, checked
against the bundled git). The batch start is measured when it begins (StoreMeter),
not taken from a sample up to 500 ms old.

Also: a retry counts files an earlier stopped attempt left staged (diff-index
--cached against HEAD), so the closing count is right; a path that vanished between
the listing and its add is dropped unless it is recorded, with what is recorded
asked afresh for each group because adding a file that replaces a folder drops the
folder's files from the index; the finishing flag and stillness timer reset when a
new add begins; a link is sized by its target text on Linux and macOS.

Observed reds (assertion failures before the change):
- StagingBatchesTests.Every_big_file_is_in_one_batch_that_comes_last: expected
  [[f0,f2,f4],[f1,f3,f5]], actual one batch per file; A_big_batch_ignores_the_file_
  and_byte_limits failed too.
- ProgressReporterDetailTests (BeginBatch stubbed): 7 of 13 failed, e.g.
  The_first_big_file_is_announced_as_soon_as_its_batch_begins and
  The_file_git_is_on_is_found_by_adding_up_the_sizes_in_the_order_given.
- StoreMeterTests (stubbed Growth): expected 240, actual null.
- ProgressReporterNamesTests.Files_an_earlier_attempt_already_staged_count_as_done_
  from_the_start: expected 6, actual 0.
- StagingBatchesTests.Git_takes_the_files_it_already_tracks_before_the_new_ones...:
  expected "c", actual "a".
- CaptureBatchesTests: Every_big_file_goes_into_one_pack... (several packs, one per
  big file); A_failure_in_a_later_group... expected 10, actual 4; A_held_file_in_a_
  later_group... expected 10, actual 1; A_capture_stopped_in_a_later_group_is_
  finished_by_the_next_one expected 10, actual 7; A_recorded_file_a_new_file_
  replaced_is_dropped... failed with "fatal: pathspec 'Folder/inner.txt' did not
  match any files" while the recorded set was cached across groups.

Mutations checked and restored: vanish filter bypassed (new-file vanish test and the
messy-change test failed); vanish filter dropping recorded files too (recorded
vanish, deleted-file and messy-change tests failed); last group dropped (12 of 17
CaptureBatchesTests failed, including the tree comparison and the pack test).
Not mutation-checked: A_batch_of_small_files_is_not_announced (nothing to mutate)
and the cancel-then-discard test (an interaction guard that does not depend on
grouping).

The tree comparison now uses a fixture with deletions, a folder turned into a file
and back, excluded files, an empty folder, changed contents and several groups.
Bring back copied the recorded commit under a new capture id and then cleared
the old record, so nothing named the brought-back saves once the new profile was
deleted, and a failed clear could leave a profile row with no branches.

The copy's branch and the record's move (create the copy's record, delete the
old one) are now one ref transaction, so branch creation is the commit point and
the copy is listed in Recently removed again if its profile is deleted. The copy
keeps the original's author and committer dates. The branch-exists check comes
before the commit object is written. The split fires for either folder and for a
saves-only continue as well as a replace, and only when a live profile's branch
(not a branch whose profile row is gone) holds the other folder's commit of the
same id.

Observed reds before the change: the delete-preview test expected 3 points only
here and got 4; "Deleting a profile brought back from a partly replaced snapshot
lists its saves again" failed with "Assert.Single() Failure: The collection was
empty"; the stray-branch test failed on the saves tip (a copy was made); the date
test failed on %aI (2026-10-25T01:19:08 vs 01:19:11); the record test and the
branch-exists test failed on the record staying on the old commit and a commit
object being written. Passing on first run, then mutation-checked: the
capture-id replacement and the marker check (engine tests), the held-by-a-profile
check (stray branch test), and the branch bookkeeping (fault tests) each made a
test fail when broken.

The delete preview now expects 2 snapshots going back to Recently removed (the
install one and the saves one), 3 points only here and 1 saves point.
Every file a rule like **/*.log names is a log, so a game-wide default blocked on any match in the saves folder lost the rule for whole games (Unity keeps Player.log in the folder many games save to), and the copy called that log a save.

Design
- GameDefinition gets InstallIgnorePaths: rules for the game's own folder only. IgnorePaths stays game-wide. Older definition files and games read it as empty and are unchanged. IgnorePathsFor(role) gives each folder its rules (the install folder gets both lists, the saves folder only IgnorePaths); the exclude files, captures, previews, switches and the folder-move check all use it.
- The default rules (logs and crash dumps), the template drafts, the library drafts and the blank new-game form put them in InstallIgnorePaths. A template's own game-wide rules are kept and not repeated.
- After play, Leave these out from now on adds the offered rules to InstallIgnorePaths, so it needs no saves check. CheckLeaveOutAsync is removed. A rule the game already has for both folders is not added again.
- Editor: two lists, "Files to leave out of the game's own folder" (the defaults) and "Files to leave out of both folders" (says it reaches the saves folder too).
- A game-wide rule that is one of the default rules (a definition file, or an older default) is still checked when a game is added, reconnected or started fresh: ListNamedByAsync now does one walk for unrecorded files with all rules, takes the index and the newest point of every profile as candidates, and attributes files to rules with the same index-based check a switch uses. The private pattern list holds only the asked patterns (no marker line), is never the saved exclude file, and is removed afterwards. Rules the player typed that are not defaults are kept, as before.
- When the check cannot run (git, IO or access failure), the game is still added without those rules and AddGameOutcome.Added.LeftOff says SavesHoldFiles = false; the editor shows a different message that does not claim the folder holds such files.
- The exit summary no longer collapses to 0/0 when git cannot be asked about the logs (IO and access errors are caught), and the run-time-only decision is git's, using the folder's own core.ignorecase.
- The default-rules note follows Import and shows only for a blank new game; the toast after a reconnect lists only default rules.

Observed reds (assertion failures; stubs or mutations where the code was written in the same step are named)
- InstallIgnorePathsTests (property present, IgnorePathsFor and equality not): IgnorePathsFor Expected ["**/*.tmp","**/*.log"], Actual ["**/*.tmp"]; Two_definitions_that_differ_only_in_the_install_only_rules_are_not_equal: Expected Not equal; Normalizing_trims...: Expected "**/*.log", Actual "  **/*.log ".
- InstallOnlyRulesTests.An_install_only_rule_keeps_the_log_out_of_the_install_snapshot_and_a_log_in_the_saves_folder_in_the_save failed before the per-folder rules were wired in.
- GameTemplatesTests, TemplateLibraryHintsTests and GamesLibraryTests draft tests: failed with the old behavior put back (rules in IgnorePaths).
- PostPlayDialogViewModelTests: with the offered rule forced into IgnorePaths, Leaving_the_files_out_adds_the_rule_for_the_games_own_folder_only... and A_rule_for_the_games_own_folder_is_added_without_looking_in_the_saves_folder fail.
- GameEditorSaveTests.When_the_saves_folder_could_not_be_checked...: with the Kept message forced, the text differs.
- NamedByTests with the profile loop removed: A_file_only_another_profile_recorded_is_named_while_this_profile_is_loaded; with the cleanup removed: Asking_leaves_the_saved_patterns_byte_for_byte_and_no_working_file_behind and A_failure_part_way_also_leaves_no_working_file_behind.
- GamesLeaveOutTests fallback cases with IOException and UnauthorizedAccessException no longer caught fail (the add is refused); LaunchRunTimeOutputTests.When_git_cannot_be_asked_about_the_logs... with them no longer caught fails with Expected: 1, Actual: 0 (the summary wiped).
- With the offered rules forced to null, Adding_the_rule_during_the_dialog..., A_log_that_earlier_snapshots_recorded... and The_offered_rule_follows_the_folders_own_letter_case_setting fail on Expected ["**/*.log"], Actual null.

Linux: NamedByTests, GamesLeaveOutTests, LaunchRunTimeOutputTests, InstallOnlyRulesTests, RunTimeOutputTests, InstallIgnorePathsTests (55) and the dialog and editor App classes (88) pass on the Ubuntu VM, where core.ignorecase is false.
Covers a failure after the copy folder's ref transaction (the other folder's
branch, and saving the profile) with the branches taken back and the snapshot
listed and brought back under its new id; a record deleted after it was read, so
the transaction's delete check refuses and nothing moves; a branch that appears
after the up-front check and is refused by the transaction's own create; and a
copy of a commit made with +09:00 and -03:30 offsets keeping both.

All of these passed on their first run, so each was mutation-checked: removing
the branch take-back failed both failure tests, dropping the delete line failed
the stale-record test, creating the branch with update instead of create failed
the race test, and normalizing the author date to UTC failed the offset test.
The old test expected the install folder to be kept as new when the replaced snapshot had no commit there. Under the Replace rule that folder joins (a new commit with the session's capture id) and the folder that holds the snapshot as its tip is amended, so nothing is kept as new.

Observed red before the change: A_folder_whose_newest_snapshot_is_not_the_one_replaced_... failed at the install KeptAsNew Assert.True (Expected True, Actual False), on integration-102 and on issue-105-session-attribution alone.

The kept-as-new case is now covered for real: replacing the first snapshot, which has a newer one behind it in both folders, is refused at save time, every folder is saved as a new snapshot and the save carries CaptureFolderKeptAsNew.

Both tests passed on first run. Mutation checks: ReplaceRule returning Refuse instead of Join for a missing commit fails the join test (Assert.False KeptAsNew); dropping Downgraded from the save-time downgrade fails the kept-as-new test (Assert.All KeptAsNew). Both restored.
Merge branch 'issue-111-partial-replace-removed' into integration-102
Some checks failed
Gate / linux (pull_request) Failing after 11m6s
Gate / windows (pull_request) Has been cancelled
6d58b9e066
A switch killed between the alignment and the end of the verify pass left
skip-worktree marks that nothing repaired: a discard kept them, and a save made
after the patterns were dropped silently recorded the old bytes. SavePoint never
wants the bit at rest, so a switch, a discard and a save now list the index
entries that carry it and clear them first, inside the write scope. The same
call replaces the fixed-path clear at the end of a switch, so it also copes with
an index that a refusal restored.

A forced switch overwrote a left-out file that both snapshots record with the
same bytes, because only paths that differ between the trees were protected. A
forced switch now marks the recorded left-out files of the current index too and
the verify pass skips them. A normal switch had no such gap (tested).

The clean-up after a failed or stopped switch now ignores any SavePoint, IO or
access error, so it can no longer replace the error that ended the switch.

Reds observed before the change (LeftOutReadOnceTests):
- A_mark_left_by_a_killed_switch_is_gone_after_a_discard_and_the_next_save_records_the_file:
  Assert.Empty failed, the collection was not empty (marks kept by the discard).
- A_save_clears_a_leftover_mark_before_it_records_the_folder: Expected the edit,
  Actual "profile a's cache".
- A_switch_clears_a_leftover_mark_before_it_looks_for_unsaved_changes: no
  DirtyWorkingTreeException was thrown.
- A_left_out_file_both_snapshots_record_alike_keeps_the_players_bytes_through_a_switch
  (forced): Expected "the player's own bytes", Actual "recorded the same in both".
  The normal-switch case passed.
Tests that passed on first run were mutation-checked: narrowing the catch to
GitOperationException fails A_stop_during_the_refresh... (clearFails); emptying
the alike set fails the forced alike test; removing each of the three start
clears fails its test. The cancellation and refusal tests that pass without a
mutation guard behavior the old fixed-path clear already had.

The tests read the index at the refresh and the verify diff from a copy of the
index taken in the hook, instead of blocking on git inside it.
A file whose attributes could not be read (held by another program, no permission) was
treated as gone and left out of the snapshot silently, where git used to fail and name
it. A path is now dropped only when the file system plainly says it does not exist and
it is not recorded; a file that cannot be looked at, or a name git printed in bytes
that are not valid UTF-8 (read as U+FFFD, so the real file cannot be found by it), stays
in its group so git's own answer reaches the player.

When the object store cannot be read as a group of big files begins, the estimate
started from 0 and named a later file; it now starts from the last figure seen.

The closing report now carries a total that shrank after the last report (a file gone
before its group), which made the closing count differ intermittently on tiny
captures. A link is sized by its target text on Windows too (git stores it as mode
120000 there, and the link's own length reads as 0), so its test runs on Windows.

Observed reds (assertion failures before the change):
- ProgressReporterDetailTests.A_batch_that_could_not_read_the_store_starts_from_the_
  last_figure_seen: expected Data/a.pak 900 of 1000, actual Data/b.pak 2900 of 3000.
- ProgressReporterNamesTests.A_total_that_shrank_after_the_last_report_still_reaches_
  the_closing_report: expected 9, actual 10 (this one was first seen as an intermittent
  failure of CaptureBatchesTests.A_new_file_that_vanishes_before_its_group_is_left_out,
  FilesTotal not equal to FilesDone).
- PathPresenceTests and the unreadable-file engine test were written with the new
  behavior; their sensitivity is shown by the mutations below.

Mutations checked and restored: any path not plainly present treated as gone (engine
test A_file_that_cannot_be_looked_at_stays_in_its_group_so_git_answers_for_it failed);
AsGitTakesThem call removed (The_big_files_are_given_to_git_with_the_recorded_ones_
first failed); look failures treated as gone and the U+FFFD guard disabled (two
PathPresenceTests failed).

Also renamed A_large_file_is_announced_before_its_add_and_added_alone to
The_big_files_are_announced_before_their_one_add and corrected the link test's skip.
Expect the MSYS2 source-list script tests to skip where pwsh is missing
Some checks failed
Gate / linux (pull_request) Successful in 11m46s
Gate / windows (pull_request) Failing after 25m11s
d0f767f617
The Linux CI container has no pwsh, so the 43 Msys2SourcesScriptTests skip there and the skip check failed the gate. They run on Windows. The names are copied from the skip check's own report.
Merges the reconnect and start-fresh saves-check tests (issue-114-reconnect-saves-check) and applies the review of cde0d66.

- A game-wide default rule that would leave out a file of the saves folder is no longer dropped: it moves to InstallIgnorePaths, where the game's own folder still leaves its logs out. Both notices say the rule now applies to the game's own folder only; the "could not check" notice points at the own-folder list.
- ResolveOrphanAsync returns the same Added answer as AddAsync (the game and LeftOff), so after Reconnect or Start fresh a failed check no longer shows a message that claims the saves folder holds such files.
- A library game's result carries RulesLeftOff, and the library dialog lists a notice for it.
- Chip lists: the add button and field have their own accessible names ("Add a rule for the game's own folder", "Add a rule for both folders"), the lists carry their helper text as help text, and each Remove button names its list.
- IgnorePathsFor puts the install-only rules first, so a negation such as !keep.log in the both-folders list can override one.

Observed reds (assertion failures; these were observed by putting the old behavior back after the change, since the change was written in the same step)
- Moving a rule only dropped it: GamesLeaveOutTests (the move, the Skyrim-style game-wide .log, the fallback, the reconnected profile), OrphanTests (Reconnecting_... and Starting_fresh_...), GamesLibraryTests.A_template_rule_that_would_hide_a_file_in_the_saves_folder_moves_...
- ResolveOrphanAsync handing back no LeftOff: GameEditorReconnectTests.A_default_rule_left_off_after_the_question... and When_the_saves_folder_could_not_be_checked_after_the_question... (both reconnect and start fresh).
- AddLibraryGameAsync dropping LeftOff, and the dialog not listing it: LibraryAddDialogViewModelTests.A_rule_that_now_applies_to_the_games_own_folder_only_is_said_in_a_notice (both texts); GamesLibraryTests above.
- Game-wide rules first: InstallIgnorePathsTests.The_install_only_rules_come_first... and The_install_folder_leaves_out_both_lists...; InstallOnlyRulesTests.A_negation_in_the_both_folders_list_keeps_one_file_the_own_folder_list_leaves_out.
- Writing the saves folder's exclude list from the game-wide list only: InstallOnlyRulesTests.Moving_a_rule_between_the_lists_changes_each_folders_exclude_list_and_the_next_snapshot_follows_per_folder.
- The add chip named by its visible text only: GameEditorViewTests.Each_rule_list_names_its_add_button_and_field_and_carries_its_help_text.
- NamedByTests.A_file_a_point_recorded_is_named_even_after_it_left_the_folder now removes the file from the folder and the index, so only the profile walk finds it.

Conflict: tests/Savepoint.App.Tests/Fakes/FakeGamesApi.cs. The fake's rule helper returns the game and what it left off; the resolve calls return the Added answer.
A recorded file that became a folder was passed to `add -A -f` as a literal
pathspec. That pathspec matches everything under the folder, so -f stored
the files the leave-out rules name (the capture dropped them from the index
afterwards, but their contents were already in the object store, and a big
file under the folder was streamed by the group holding the pathspec).

Recorded paths that are gone, or are now a folder, are now dropped with
`update-index --force-remove` before the adds, and add only receives the
files that are really there. The tree is unchanged for deletions, renames,
a folder replaced by a file and empty folders; progress still counts each
removal once.

Observed reds (before the change), in CaptureBatchesTests:
- A_file_that_became_a_folder_never_stores_the_excluded_files_in_it_when_watched: Assert.False() Failure (the excluded file's blob was in the store)
- A_file_that_became_a_folder_never_stores_the_excluded_files_in_it_when_nobody_watches: Assert.False() Failure (same)
- A_big_file_under_a_folder_that_replaced_a_file_is_stored_in_the_one_pack: Assert.False() Failure (same); the single-pack assertion already held.
Mutation: treating present files as removals instead of gone ones failed 8 tests.
After play, a changed file git could not read had no name in the exit
summary, so a session whose only change was a held log got the update
note and no "Leave these out from now on" offer. The status now keeps
the names of those held files (RepoStatus.HeldPaths) and the exit
summary checks them against the log and crash dump rules with the same
git check as every other file. A held file no rule names still means
the update note.

Observed red: LaunchHeldFileTests.A_log_nobody_can_read_still_gets_the_offer_to_leave_logs_out
(both kinds): Assert.Equal() Failure, expected ["**/*.log"], actual null.
Tests that passed on first run (readable new log beside a held log; held
non-log; held log beside held non-log) were mutation checked: replacing
the git agreement check with an unconditional answer made the held log
beside held non-log test fail for both kinds; restored.
A forced switch with only alike left-out files marked the real index after the
switch note was written; a failing mark left a note for a switch that wrote
nothing, and a save then refused with an interrupted switch. The marks now go on
before the note, and a failure clears them.

A forced switch to a new target after an unfinished one marked an index entry
the target lacks (aligned to the unfinished switch's own target), and git
refused the merge ("Entry not uptodate. Cannot merge"). Alike entries are now
limited to those the target holds.

The clear at the end of a switch only runs when the switch marked something. The
clear also reads the index header and skips the listing for a version 2 file,
which cannot hold a flag. The bundled git (2.56.0.windows.2) writes version 4
here, which can, so on this git the start-of-operation listing still runs; the
version tests set the version with update-index --index-version.

Reds observed before the change (LeftOutReadOnceTests):
- A_failure_to_mark_the_alike_file_leaves_no_note_of_an_unfinished_switch: the
  note of an unfinished switch was left.
- A_forced_switch_to_another_target_after_an_unfinished_one_ignores_entries_the_target_lacks:
  GitOperationException, git checkout profile-c exited with code 128: Entry
  'Cache/p.txt' not uptodate. Cannot merge.
- A_switch_that_marks_files_asks_git_once_for_marks_after_it_verified: Expected
  1, Actual 2.
Mutation checks: removing the marks guard fails the "only at the start" and
"once after verified" tests; disabling the version-2 skip fails the version
test. The alike-only forced switch test passed on first run and covers the
newly reachable branch.
# Conflicts:
#	src/Savepoint.Core/Git/ProgressReporter.cs
#	src/Savepoint.Core/Services/Profiles/CaptureRunner.cs
# Conflicts:
#	src/Savepoint.Core/Launch/Orchestration/LaunchOrchestrator.Session.cs
Version 0.9.9
Some checks failed
Gate / windows (pull_request) Has been cancelled
Gate / linux (pull_request) Has been cancelled
fba77268a2
git repack --geometric=2 weighs packs by object count, so the pack a capture
streams its big files into (one or a few objects) is always the lightest and
gets rolled up as soon as two neighbours break the factor of 2. The second
routine repack after a big first snapshot could copy every big archive.

A capture now writes a .keep file beside each pack its add left behind, and a
routine repack also keeps any unkept pack at least as large as the big-file
size, which covers stores made before the keeps existed. Free up space removes
SavePoint's own keeps (identified by their text) before repack -a -d, so a big
file no snapshot reaches still goes and no stale keep remains.

Observed reds (StreamedPackTests, before the change):
- A_capture_streamed_pack_survives_every_routine_repack_unchanged_while_the_small_objects_are_packed:
  "pack-f45d50b6...pack was rewritten by a routine repack"
- A_store_made_before_streamed_packs_were_marked_keeps_them_through_routine_repacks:
  same message
- Free_up_space_removes_a_big_file_...: Assert.NotEmpty() Failure: Collection was empty (no keeps)
Mutations checked: no keep at capture, no sweep, no keep removal at reclaim, and
a sweep that keeps every pack each fail a test.
Let the real-gpg test skip on Windows machines without gpg
Some checks failed
Gate / linux (pull_request) Successful in 12m29s
Gate / windows (pull_request) Successful in 26m47s
Wiki / publish (push) Successful in 50s
Release / linux (push) Failing after 1m34s
Gate / linux (push) Successful in 12m31s
Gate / windows (push) Successful in 27m19s
Release / windows (push) Successful in 2m38s
Release / checksums (push) Has been skipped
9af603939a
The Windows runner has no gpg, so the one test that runs the real gpg skips there and the skip check failed the gate. It runs where gpg is installed.
A keep is now written through AtomicText, so a crash cannot leave a torn one.
Free up space removes a keep that starts with "SavePoint:" or is empty (a cut
short write; nothing else here writes keeps) and leaves any other keep alone.

Marking a capture's packs is best effort: an IOException or
UnauthorizedAccessException there no longer replaces the capture's own result;
the size sweep marks a missed pack at the next routine repack. The sweep and the
reclaim's keep removal translate IO failures to GitOperationException so a
folder's failure is reported per folder; documented on RepackAsync.

The size sweep now also requires at most 1024 objects, read from the pack index
header (fanout[255]; no git process), so a routine-merged pack of small saves
that grows past the big-file size stays in geometric repacking.

Observed reds:
- Free_up_space_removes_a_keep_a_crash_left_empty_...: Assert.Equal collections
  differ, the empty keep of the first pack was still there.
- A_pack_of_many_small_files_that_grows_past_the_big_size_...: Assert.Empty
  failed, the merged pack had been kept.
- A_keep_that_cannot_be_written_does_not_change_how_the_capture_ends_...:
  IOException "The disk is full." escaped the capture.
- A_keep_that_cannot_be_written_at_a_routine_repack_...: expected
  GitOperationException, got UnauthorizedAccessException.
- A_keep_that_cannot_be_removed_at_a_reclaim_...: no exception was thrown.
Mutations checked: no capture keep (fails 6 tests incl. the 1100-file pack and
the watched capture), no object-count bound (fails the merged-pack test).
# Conflicts:
#	src/Savepoint.Core/Git/GitEngine.Capture.cs
Merge branch 'integration-102' into integration-103
Some checks failed
Gate / linux (pull_request) Failing after 11m23s
Gate / windows (pull_request) Has been cancelled
05230d90ae
The three start buttons sit in a WrapPanel that shrinks to its widest line. A button that wrapped onto a shorter line sat at the panel's left edge, so the group looked off-center at the default window size and at every narrower one. ItemsAlignment="Center" centers each wrapped line inside the panel.

Added FirstRunLayoutTests: each line of buttons has equal left and right gaps at 1040, 760, 560 and 420 wide, the narrow window really wraps, and the icon and label are centered in each button (and in How SavePoint works) when the button is wider than its content.

Observed red before the fix: Each_line_of_start_buttons_is_centered_in_the_row, all four widths, e.g. "At width 1040 a line has gaps 0 left and 152 right in a row 411 wide" and "At width 420 ... 0 left and 66 right in a row 259 wide".
The content-centering test passed on its first run; mutation check: HorizontalContentAlignment="Left" on AddFromLibrariesButton failed it ("AddFromLibrariesButton at width 1040 has content gaps 25 left and 96 right"), then restored.
The sidebar's "Add games from your libraries" label wraps onto two lines, and the wrapped lines were left-aligned inside the label's own box. TextAlignment="Center" on both footer labels centers every wrapped line, and the icon-and-label group stays centered in the button. The library layout's shelf buttons hold a single-line label that the button theme already centers.

Added SidebarFooterButtonTests: each text line of the sidebar button labels is centered on the label's box, and the icon-and-label group has equal gaps in each button, in the expanded and the compact sidebar.

Observed red before the fix: Each_line_of_a_sidebar_button_label_is_centered_under_the_others(width: 1040), "RailLibrariesButton at width 1040: a line of 2 is 1.83 px off the label's center".
The group-centering test passed on its first run; mutation check: HorizontalContentAlignment="Left" on RailAddButton failed it ("RailAddButton at width 1040 has gaps 13 left and 103 right"), then restored.
Merge branch 'issue-124-start-screen-centering' into integration-103
All checks were successful
Gate / linux (pull_request) Successful in 13m18s
Gate / windows (pull_request) Successful in 30m53s
0cefcf6106
Merge branch 'main' into integration-103
Some checks failed
Gate / linux (pull_request) Successful in 13m4s
Gate / windows (pull_request) Successful in 30m9s
Wiki / publish (push) Successful in 54s
Release / linux (push) Successful in 2m6s
Gate / linux (push) Successful in 12m37s
Gate / windows (push) Successful in 30m47s
Release / windows (push) Successful in 2m27s
Release / checksums (push) Failing after 33s
5dbb1935d6
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!122
No description provided.