Address CodeRabbit review feedback

- Serialize snapshot writes per slot. Callers fire these off without awaiting
  them, alongside opening or saving a project, so two projects can race for the
  same slot and whichever write landed last would win it. The recent list is
  updated synchronously as each project opens, so a slow first write finishing
  last would leave the slot holding a project the preference no longer resolves
  to, and the next cold start would find no copy matching the path it asks for.
  Chaining per slot makes the last write started the one that wins, which is the
  one the preference agrees with. The stored link swallows rejections so one
  failed copy cannot strand every later one behind it, while the caller still
  sees the real result. Covered by a test where the first write is delayed past
  the second.

Author: giswqs

apps/geolibre-desktop/src/lib/startup-project-snapshot.ts

@@ -169,6 +169,33 @@ function writeStartupSnapshotIndex(
   }
 }
 
+/**
+ * The write in flight for each slot, so copies land in the order they were
+ * asked for.
+ *
+ * Callers fire these off without awaiting them, alongside opening or saving a
+ * project. Two projects can therefore be racing for the same slot -- open one
+ * project, open another before the first copy has landed -- and whichever write
+ * finished last would win the slot. The recent list is updated synchronously as
+ * each project opens, so a slow first write finishing last would leave the slot
+ * holding a project the preference no longer resolves to, and the next cold
+ * start would find no copy matching the path it asks for. Chaining per slot
+ * makes the last write *started* the one that wins, which is the one the
+ * preference agrees with.
+ */
+const slotWrites = new Map<StartupSnapshotSlot, Promise<unknown>>();
+
+function queueSlotWrite<T>(slot: StartupSnapshotSlot, task: () => Promise<T>): Promise<T> {
+  const next = (slotWrites.get(slot) ?? Promise.resolve()).then(task);
+  // The stored link never rejects, so one failed copy cannot strand every later
+  // one behind it; the caller still sees the real result through `next`.
+  slotWrites.set(
+    slot,
+    next.catch(() => undefined),
+  );
+  return next;
+}
+
 /**
  * The slot a project should be copied into, or null when it is not one the
  * startup preference would reopen.
@@ -222,23 +249,25 @@ export async function writeStartupSnapshot(
     return null;
   }
 
-  const file = startupSnapshotFile(slot);
-  try {
-    await io.write(file, text);
-  } catch (error) {
-    console.warn("Could not keep a restorable copy of the startup project.", error);
-    return null;
-  }
+  return queueSlotWrite(slot, async () => {
+    const file = startupSnapshotFile(slot);
+    try {
+      await io.write(file, text);
+    } catch (error) {
+      console.warn("Could not keep a restorable copy of the startup project.", error);
+      return null;
+    }
 
-  const storage = options?.storage === undefined ? defaultStorage() : options.storage;
-  writeStartupSnapshotIndex(
-    {
-      ...readStartupSnapshotIndex(storage),
-      [slot]: { sourcePath: path, file, savedAt: new Date().toISOString() },
-    },
-    storage,
-  );
-  return slot;
+    const storage = options?.storage === undefined ? defaultStorage() : options.storage;
+    writeStartupSnapshotIndex(
+      {
+        ...readStartupSnapshotIndex(storage),
+        [slot]: { sourcePath: path, file, savedAt: new Date().toISOString() },
+      },
+      storage,
+    );
+    return slot;
+  });
 }
 
 /**

tests/startup-project-snapshot.test.ts

@@ -215,6 +215,39 @@ describe("writeStartupSnapshot", () => {
     assert.equal(warnings.length, 1);
   });
 
+  it("lets the last copy asked for win the slot, not the last one to land", async () => {
+    // Open one project, open another before the first copy has landed. The
+    // recent list already says the second is the most recent, so the slot has to
+    // agree with it however slowly the first write finishes.
+    const storage = makeStorage();
+    const files = new Map<string, string>();
+    const delays = [40, 0];
+    const io = {
+      write: async (file: string, content: string) => {
+        await new Promise((resolve) => setTimeout(resolve, delays.shift() ?? 0));
+        files.set(file, content);
+      },
+      read: async (file: string) => files.get(file) ?? Promise.reject(new Error("missing")),
+    };
+
+    const first = writeStartupSnapshot(CONTENT_URI, "first", settings({ mode: "last" }), io, {
+      storage,
+    });
+    const second = writeStartupSnapshot(
+      OTHER_CONTENT_URI,
+      "second",
+      settings({ mode: "last" }),
+      io,
+      {
+        storage,
+      },
+    );
+    await Promise.all([first, second]);
+
+    assert.equal(files.get(startupSnapshotFile("last")), "second");
+    assert.equal(readStartupSnapshotIndex(storage).last?.sourcePath, OTHER_CONTENT_URI);
+  });
+
   it("swallows a write failure so it cannot fail the save that triggered it", async () => {
     const storage = makeStorage();
     const { io } = makeIo({ writeError: new Error("No space left on device") });