Give saves a slot, and download into the core's own folder

Two things that between them made save sync a one-way trip.

sync/negotiate only considers saves that carry a slot. We uploaded
without one, so every save this plugin wrote landed on the server
correctly and was then invisible to the sync layer - not offered to any
device, not matched when reported back. Negotiate answered "Save exists
on client but not on server" even for a byte-identical copy of what it
was storing, so the local side always counted as new and won
unconditionally. An empty save could quietly replace a good one; that is
how I lost one while testing this.

Measured against a server holding both kinds: 40 saves with a slot, 27
of them offered for download; 8 without one, none ever offered, to any
device. The slot-less ones were exactly those written by clients that
omit it. Uploading the same file with slot=autosave makes it show up as
a download operation immediately. Other RomM clients use "autosave" for
a game's live save whatever the platform, and the server keys saves by
(rom_id, slot), so a different value here would split one game's save
into two entries that never reconcile.

The second one only surfaces once downloads happen at all. With
sort_savefiles_enable, RetroArch keeps saves in a folder named after the
running core. We resolved the path without a core name, which is
harmless while a local save exists - the recursive search finds it - but
wrong the moment a download has to create the file: it landed beside the
core folders rather than inside one, where RetroArch never looks. The
game then started fresh on a save that was sitting right there, and that
fresh save went back up on exit.

The core comes from the profile Playnite launches with: built-in
RetroArch profiles are named after it, custom ones carry it in the
libretro argument. Where a matching folder already exists its spelling
wins, since RetroArch's own name for a core ("mGBA") is not always how
Playnite spells it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: LxKnsy

RomM.Tests/FileSaveTargetTests.cs

@@ -31,6 +31,15 @@ public void Reports_absent_when_no_save_has_been_written_yet()
             Assert.False(target.Exists);
         }
 
+        // sync/negotiate skips saves without a slot entirely: they upload fine and are then
+        // invisible to every device, including the one that wrote them. "autosave" is what the
+        // other RomM clients use for a game's live save.
+        [Fact]
+        public void Carries_a_slot_so_the_save_is_visible_to_negotiate()
+        {
+            Assert.Equal("autosave", new FileSaveTarget("retroarch", Path_("game.srm"), null).Slot);
+        }
+
         [Fact]
         public void Reports_the_file_it_found_rather_than_the_configured_path()
         {

RomM.Tests/RetroArchSaveHandlerTests.cs

@@ -0,0 +1,54 @@
+using Playnite.SDK.Models;
+using RomM.Saves;
+using Xunit;
+
+namespace RomM.Tests
+{
+    public class RetroArchSaveHandlerTests
+    {
+        // Playnite names its built-in RetroArch profiles after the core, and RetroArch names the
+        // per-core save folder the same way, so the profile name is the value we want verbatim.
+        [Fact]
+        public void Core_name_of_a_builtin_profile_is_its_name()
+        {
+            var profile = new BuiltInEmulatorProfile { Name = "mGBA" };
+
+            Assert.Equal("mGBA", RetroArchSaveHandler.ResolveCoreName(profile));
+        }
+
+        // A custom profile only carries the core in its libretro argument, as a dll path.
+        [Theory]
+        [InlineData("-L \"cores\\mgba_libretro.dll\" \"{ImagePath}\"", "mgba")]
+        [InlineData("-L cores\\snes9x_libretro.dll \"{ImagePath}\"", "snes9x")]
+        [InlineData("-f -L \"D:\\RetroArch\\cores\\gambatte_libretro.dll\"", "gambatte")]
+        public void Core_name_of_a_custom_profile_comes_from_the_libretro_argument(string args, string expected)
+        {
+            var profile = new CustomEmulatorProfile { Arguments = args };
+
+            Assert.Equal(expected, RetroArchSaveHandler.ResolveCoreName(profile));
+        }
+
+        // No core name means the per-core folder is simply left out of the path, which is the
+        // behaviour that existed before — not a reason to fail resolution.
+        [Theory]
+        [InlineData("\"{ImagePath}\"")]
+        [InlineData("")]
+        [InlineData(null)]
+        public void Core_name_is_null_when_the_arguments_carry_none(string args)
+        {
+            Assert.Null(RetroArchSaveHandler.ResolveCoreName(new CustomEmulatorProfile { Arguments = args }));
+        }
+
+        [Fact]
+        public void Core_name_is_null_without_a_profile()
+        {
+            Assert.Null(RetroArchSaveHandler.ResolveCoreName(null));
+        }
+
+        [Fact]
+        public void Builtin_profile_without_a_name_yields_null()
+        {
+            Assert.Null(RetroArchSaveHandler.ResolveCoreName(new BuiltInEmulatorProfile { Name = "  " }));
+        }
+    }
+}

Saves/FileSaveTarget.cs

@@ -29,6 +29,8 @@ public FileSaveTarget(string emulatorTag, string writePath, string existingPath)
 
         public override string EmulatorTag { get; }
 
+        public override string Slot => "autosave";
+
         public override bool Exists => File.Exists(_readPath);
 
         public override string FileName => Path.GetFileName(_readPath);

Saves/ISaveHandler.cs

@@ -37,6 +37,12 @@ internal class SaveTargetRequest
 
         public Emulator Emulator { get; set; }
 
+        /// <summary>
+        /// The profile the game launches with, when one is set. Carries the detail that decides
+        /// where some emulators file a save — for RetroArch, which core is running.
+        /// </summary>
+        public EmulatorProfile Profile { get; set; }
+
         /// <summary>The ROM's path with Playnite's variables already expanded.</summary>
         public string ContentPath { get; set; }
 

Saves/RetroArchSaveHandler.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace RomM.Saves
 {
@@ -50,19 +51,24 @@ public SaveTarget ResolveTarget(SaveTargetRequest request)
                     : new Dictionary<string, string>();
 
                 var baseDir = request.Emulator.InstallDir;
+                var saveRoot = RetroArchConfig.ResolveSaveBaseDirectory(cfg, request.ContentPath, baseDir);
 
-                var expectedPath = RetroArchConfig.ResolveSaveFilePath(cfg, request.ContentPath, null, baseDir);
+                // With sort_savefiles_enable the save sits in a folder named after the running core.
+                // Resolving without that name only matters once a download has to create the file:
+                // it would land beside the core folders instead of inside the right one, where
+                // RetroArch never looks, and the game would start over on a save that is present.
+                var coreName = MatchExistingCoreFolder(saveRoot, ResolveCoreName(request.Profile));
+
+                var expectedPath = RetroArchConfig.ResolveSaveFilePath(cfg, request.ContentPath, coreName, baseDir);
                 if (string.IsNullOrEmpty(expectedPath))
                     return null;
 
                 // The configured path is where RetroArch *would* write. When nothing is there, the
-                // save may still exist under a per-core or per-content subfolder we did not model,
-                // so fall back to searching for it by ROM name before assuming there is none.
+                // save may still exist under a subfolder we did not model, so fall back to
+                // searching for it by ROM name before assuming there is none.
                 var existing = File.Exists(expectedPath)
                     ? expectedPath
-                    : FindExistingSave(
-                        RetroArchConfig.ResolveSaveBaseDirectory(cfg, request.ContentPath, baseDir),
-                        Path.GetFileNameWithoutExtension(request.ContentPath));
+                    : FindExistingSave(saveRoot, Path.GetFileNameWithoutExtension(request.ContentPath));
 
                 return new FileSaveTarget(EmulatorTag, expectedPath, existing);
             }
@@ -73,6 +79,72 @@ public SaveTarget ResolveTarget(SaveTargetRequest request)
             }
         }
 
+        /// <summary>
+        /// The core a profile runs, as far as it can be told from Playnite. Built-in RetroArch
+        /// profiles are named after the core ("mGBA"); a custom profile carries it in the libretro
+        /// argument (`-L "cores\mgba_libretro.dll"`). Null when neither yields anything, which
+        /// leaves the per-core folder out of the path exactly as before.
+        /// </summary>
+        internal static string ResolveCoreName(EmulatorProfile profile)
+        {
+            var builtIn = profile as BuiltInEmulatorProfile;
+            if (builtIn != null)
+                return string.IsNullOrWhiteSpace(builtIn.Name) ? null : builtIn.Name.Trim();
+
+            var custom = profile as CustomEmulatorProfile;
+            if (custom != null)
+                return CoreFromArguments(custom.Arguments);
+
+            return null;
+        }
+
+        private static readonly Regex LibretroArgument =
+            new Regex(@"-L\s+""?(?<path>[^""\s]+)""?", RegexOptions.IgnoreCase);
+
+        private static string CoreFromArguments(string arguments)
+        {
+            if (string.IsNullOrEmpty(arguments))
+                return null;
+
+            var match = LibretroArgument.Match(arguments);
+            if (!match.Success)
+                return null;
+
+            var name = Path.GetFileNameWithoutExtension(match.Groups["path"].Value);
+            if (string.IsNullOrEmpty(name))
+                return null;
+
+            if (name.EndsWith("_libretro", StringComparison.OrdinalIgnoreCase))
+                name = name.Substring(0, name.Length - "_libretro".Length);
+
+            return name.Length == 0 ? null : name;
+        }
+
+        /// <summary>
+        /// RetroArch names the folder after the core's own display name, which is not always how
+        /// Playnite spells it — a profile can yield "mgba" where the folder on disk is "mGBA".
+        /// Where a matching folder already exists its spelling wins, so a download joins the saves
+        /// RetroArch is already writing instead of creating a near-duplicate beside them.
+        /// </summary>
+        private static string MatchExistingCoreFolder(string saveRoot, string coreName)
+        {
+            if (string.IsNullOrEmpty(coreName) || string.IsNullOrEmpty(saveRoot) || !Directory.Exists(saveRoot))
+                return coreName;
+
+            try
+            {
+                var match = Directory.EnumerateDirectories(saveRoot)
+                    .Select(Path.GetFileName)
+                    .FirstOrDefault(n => string.Equals(n, coreName, StringComparison.OrdinalIgnoreCase));
+
+                return match ?? coreName;
+            }
+            catch
+            {
+                return coreName;
+            }
+        }
+
         private static string FindConfig(Emulator emulator)
         {
             if (!string.IsNullOrEmpty(emulator.InstallDir))

Saves/SaveSyncService.cs

@@ -140,7 +140,7 @@ private RomMSyncNegotiateResponse Negotiate(string deviceId, int romId, SaveTarg
                 {
                     RomId = romId,
                     FileName = target.FileName,
-                    Slot = null,
+                    Slot = target.Slot,
                     Emulator = target.EmulatorTag,
                     ContentHash = target.ContentHash(),
                     UpdatedAt = target.UpdatedAtUtc,
@@ -254,6 +254,7 @@ private bool Upload(RomMSyncOperation op, string deviceId, int sessionId, SaveTa
                 {
                     var url = RomMUrl.Combine(Settings.RomMHost,
                         $"api/saves?rom_id={op.RomId}&emulator={target.EmulatorTag}" +
+                        $"&slot={WebUtility.UrlEncode(target.Slot)}" +
                         $"&device_id={WebUtility.UrlEncode(deviceId)}&session_id={sessionId}");
                     response = HttpClientSingleton.Instance.PostAsync(url, content).GetAwaiter().GetResult();
                 }
@@ -404,22 +405,37 @@ private SaveTarget ResolveTarget(Game game)
             {
                 Game = game,
                 Emulator = emulator,
+                Profile = ResolveProfile(game, emulator),
                 ContentPath = _romM.Playnite.ExpandGameVariables(game, contentPath),
                 Logger = Logger,
             });
         }
 
         private Emulator ResolveEmulator(Game game)
         {
-            var action = game.GameActions?.FirstOrDefault(a => a.IsPlayAction && a.Type == GameActionType.Emulator)
-                         ?? game.GameActions?.FirstOrDefault(a => a.Type == GameActionType.Emulator);
+            var action = EmulatorAction(game);
 
             if (action != null && action.EmulatorId != Guid.Empty)
                 return _romM.Playnite.Database.Emulators?.FirstOrDefault(e => e.Id == action.EmulatorId);
 
             return null;
         }
 
+        private static EmulatorProfile ResolveProfile(Game game, Emulator emulator)
+        {
+            var profileId = EmulatorAction(game)?.EmulatorProfileId;
+            if (string.IsNullOrEmpty(profileId))
+                return null;
+
+            return emulator.SelectableProfiles?.FirstOrDefault(p => p.Id == profileId);
+        }
+
+        private static GameAction EmulatorAction(Game game)
+        {
+            return game.GameActions?.FirstOrDefault(a => a.IsPlayAction && a.Type == GameActionType.Emulator)
+                   ?? game.GameActions?.FirstOrDefault(a => a.Type == GameActionType.Emulator);
+        }
+
         #endregion
 
         #region HTTP helper

Saves/SaveTarget.cs

@@ -23,6 +23,15 @@ internal abstract class SaveTarget
         /// </summary>
         public abstract string EmulatorTag { get; }
 
+        /// <summary>
+        /// The slot the save is filed under. Not optional in practice: `sync/negotiate` only
+        /// considers saves that carry one, so a slot-less upload lands on the server correctly and
+        /// is then invisible to every device, including the one that wrote it. Other RomM clients
+        /// use "autosave" for a game's live save regardless of platform, and matching that is what
+        /// keeps the same save reconcilable across them.
+        /// </summary>
+        public abstract string Slot { get; }
+
         /// <summary>Whether there is anything locally to report or upload yet.</summary>
         public abstract bool Exists { get; }