Track a queued save with a flag, not by comparing timestamps

AppDataStorage.Test/AppDataTests.cs

@@ -389,6 +389,32 @@ public void TestIsSaveQueuedReturnsCorrectValue()
 		Assert.IsTrue(appData.IsSaveQueued(), "Save should be queued after QueueSave is called.");
 	}
 
+	[TestMethod]
+	public void TestQueueSaveIsNotLostWhenTheClockHasNotAdvancedSinceTheLastSave()
+	{
+		using TestAppData appData = CreateTestAppData();
+		appData.Save();
+
+		// Stand in for a clock that reads the same instant for the save and the queue that follows it,
+		// which is what DateTime.UtcNow does on macOS when both land inside one microsecond. A later
+		// LastSaveTime is the same situation with the wall clock set back.
+		appData.LastSaveTime = DateTime.MaxValue;
+		appData.QueueSave();
+
+		Assert.IsTrue(appData.IsSaveQueued(), "A save queued after the last save must be outstanding whatever the clock reads.");
+	}
+
+	[TestMethod]
+	public void TestSaveClearsQueuedSave()
+	{
+		using TestAppData appData = CreateTestAppData();
+		appData.QueueSave();
+
+		appData.Save();
+
+		Assert.IsFalse(appData.IsSaveQueued(), "Saving should satisfy the queued save.");
+	}
+
 	[TestMethod]
 	public async Task TestIsDebounceTimeElapsedReturnsCorrectValue()
 	{

AppDataStorage/AppData.cs

@@ -248,6 +248,7 @@
 		lock (AppData<T>.Lock)
 		{
 			appData.SaveQueuedTime = DateTime.UtcNow;
+			appData.HasQueuedSave = true;
 			appData.EnsureDisposeOnExit();
 		}
 	}
@@ -423,6 +424,20 @@
 	/// </summary>
 	internal DateTime SaveQueuedTime { get; set; } = DateTime.MinValue;
 
+	/// <summary>
+	/// Gets or sets a value indicating whether a save has been queued and not yet written.
+	/// </summary>
+	/// <remarks>
+	/// This is a flag rather than a comparison of <see cref="SaveQueuedTime"/> against <see cref="LastSaveTime"/>,
+	/// because two reads of <see cref="DateTime.UtcNow"/> are not guaranteed to differ. On macOS the clock
+	/// advances in whole microseconds, so a <c>QueueSave</c> issued straight after a
+	/// <see cref="Save"/> can read the same instant, compare as "not after the last save", and be dropped:
+	/// never written by <c>SaveIfRequired</c> and not flushed on dispose either. The wall
+	/// clock can also be set back, which would drop a queued save the same way. Whether a save is outstanding
+	/// is a fact about the order of two calls, not about the time either one happened at.
+	/// </remarks>
+	internal bool HasQueuedSave { get; set; }
+
 	/// <summary>
 	/// Gets the debounce time for saving the app data.
 	/// </summary>
@@ -438,17 +453,17 @@
 	/// </summary>
 #if NET9_0_OR_GREATER
 	[JsonIgnore]
 	public static Lock Lock { get; } = new();
 #else
 	[JsonIgnore]
 	public static object Lock { get; } = new();
 #endif
 
 	internal bool IsSaveQueued()
 	{
 		lock (Lock)
 		{
-			return SaveQueuedTime > LastSaveTime;
+			return HasQueuedSave;
 		}
 	}
 
@@ -470,6 +485,7 @@
 			string jsonString = JsonSerializer.Serialize(this, typeof(T), AppData.JsonSerializerOptions);
 			AppData.WriteText((T)this, jsonString);
 			LastSaveTime = DateTime.UtcNow;
+			HasQueuedSave = false;
 		}
 	}
 

CLAUDE.md

@@ -62,6 +62,7 @@ data.Save();
 - Files stored in `%APPDATA%/{AppDomain.FriendlyName}/` as `{class_name_snake_case}.json`
 - Thread-safe with lock objects (uses `Lock` type on .NET 9+, `object` on earlier versions)
 - Debounced saves via `QueueSave()` / `SaveIfRequired()` (3-second debounce)
+- Whether a save is outstanding is the `HasQueuedSave` flag, set by `QueueSave()` and cleared by a successful `Save()`. It is not `SaveQueuedTime > LastSaveTime`: `DateTime.UtcNow` advances in whole microseconds on macOS, so a queue straight after a save can read the same instant and would be dropped
 - Automatic backup files (`.bk` suffix) with timestamped collision handling
 - Safe write pattern: write to `.tmp`, backup existing, move `.tmp` to final
 - Lazy singleton access via `Get()` backed by `Lazy<T>`