fix: make session saving asynchronous with proper queue to prevent race conditions

- Remove await from savePickerSession call in defer block to prevent blocking picker close
- Implement queue-based session saving to preserve chronological order
- Add waitForPendingSaves() for testing to ensure saves complete
- Prevent race conditions when multiple pickers are closed quickly
- Sessions now save in background while picker closes immediately

🤖 Generated with [Claude Code](https://claude.ai/code)

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

Author: lambdalisue

denops/fall/main/picker.ts

@@ -212,15 +212,18 @@ async function startPicker<T extends Detail>(
   stack.defer(() => {
     zindex -= Picker.ZINDEX_ALLOCATION;
   });
-  stack.defer(async () => {
+  stack.defer(() => {
     const name = pickerParams.name;
     if (SESSION_EXCLUDE_SOURCES.includes(name)) {
       return;
     }
-    await savePickerSession({
+    // Save session asynchronously without blocking picker close
+    savePickerSession({
       name,
       args,
       context: itemPicker.context,
+    }).catch((error) => {
+      console.error(`Failed to save picker session: ${error}`);
     });
   });
 

denops/fall/session.ts

@@ -16,6 +16,40 @@ const sessions: PickerSessionCompressed<any>[] = [];
  */
 const MAX_SESSION_COUNT = 100;
 
+/**
+ * Queue to ensure session saves happen in order even when compression times vary.
+ * This prevents race conditions when multiple pickers are closed quickly.
+ */
+const saveQueue: Array<() => Promise<void>> = [];
+let isProcessingQueue = false;
+let queueProcessPromise: Promise<void> | null = null;
+
+/**
+ * Processes the save queue sequentially to maintain chronological order.
+ */
+function processQueue(): Promise<void> {
+  if (isProcessingQueue) return queueProcessPromise!;
+  isProcessingQueue = true;
+
+  queueProcessPromise = (async () => {
+    while (saveQueue.length > 0) {
+      const saveTask = saveQueue.shift();
+      if (saveTask) {
+        try {
+          await saveTask();
+        } catch (error) {
+          console.error(`Failed to save picker session: ${error}`);
+        }
+      }
+    }
+
+    isProcessingQueue = false;
+    queueProcessPromise = null;
+  })();
+
+  return queueProcessPromise;
+}
+
 /**
  * Represents a picker session with all its state information.
  * @template T - The type of item detail in the picker
@@ -101,17 +135,40 @@ export function listPickerSessions(): readonly PickerSessionCompressed<
  * Saves a picker session to the in-memory storage.
  * The session is compressed before storage to reduce memory usage.
  * If the storage exceeds MAX_SESSION_COUNT, the oldest session is removed.
+ * Sessions are saved in chronological order using a queue to prevent race conditions.
  * @template T - The type of item detail in the picker
  * @param session - The session to save
- * @returns A promise that resolves when the session is saved
+ * @returns A promise that resolves when the session save is queued (not when it's actually saved)
  */
-export async function savePickerSession<T extends Detail>(
+export function savePickerSession<T extends Detail>(
   session: PickerSession<T>,
 ): Promise<void> {
-  const compressed = await compressPickerSession(session);
-  sessions.push(compressed);
-  if (sessions.length > MAX_SESSION_COUNT) {
-    sessions.shift(); // Keep only the last MAX_SESSION_COUNT sessions
+  // Add the save task to the queue
+  saveQueue.push(async () => {
+    const compressed = await compressPickerSession(session);
+    sessions.push(compressed);
+    if (sessions.length > MAX_SESSION_COUNT) {
+      sessions.shift(); // Keep only the last MAX_SESSION_COUNT sessions
+    }
+  });
+
+  // Process the queue asynchronously
+  processQueue().catch((error) => {
+    console.error(`Failed to process save queue: ${error}`);
+  });
+
+  // Return immediately to not block the picker close
+  return Promise.resolve();
+}
+
+/**
+ * Waits for all pending session saves to complete.
+ * This is primarily for testing purposes.
+ * @internal
+ */
+export async function waitForPendingSaves(): Promise<void> {
+  if (queueProcessPromise) {
+    await queueProcessPromise;
   }
 }
 

denops/fall/session_test.ts

@@ -6,6 +6,7 @@ import {
   loadPickerSession,
   type PickerSession,
   savePickerSession,
+  waitForPendingSaves,
 } from "./session.ts";
 import type { PickerContext } from "./picker.ts";
 
@@ -46,6 +47,7 @@ Deno.test("session management", async (t) => {
   await t.step("savePickerSession stores a session", async () => {
     const session = createMockSession("test", 1);
     await savePickerSession(session);
+    await waitForPendingSaves();
 
     const sessions = listPickerSessions();
     assertEquals(sessions.length >= 1, true);
@@ -60,6 +62,7 @@ Deno.test("session management", async (t) => {
       await savePickerSession(createMockSession("test1", 1));
       await savePickerSession(createMockSession("test2", 2));
       await savePickerSession(createMockSession("test3", 3));
+      await waitForPendingSaves();
 
       const sessions = listPickerSessions();
       // Most recent session should be first
@@ -73,6 +76,7 @@ Deno.test("session management", async (t) => {
     "loadPickerSession retrieves the most recent session by default",
     async () => {
       await savePickerSession(createMockSession("recent", 99));
+      await waitForPendingSaves();
 
       const session = await loadPickerSession();
       assertExists(session);
@@ -90,6 +94,7 @@ Deno.test("session management", async (t) => {
       for (let i = 0; i < 5; i++) {
         await savePickerSession(createMockSession(`session${i}`, i));
       }
+      await waitForPendingSaves();
 
       // Index 1 = most recent (session4)
       const session0 = await loadPickerSession({ number: 1 });
@@ -115,6 +120,7 @@ Deno.test("session management", async (t) => {
     await savePickerSession(createMockSession("file", 3));
     await savePickerSession(createMockSession("buffer", 4));
     await savePickerSession(createMockSession("file", 5));
+    await waitForPendingSaves();
 
     // Load most recent "file" session
     const fileSession = await loadPickerSession({ name: "file" });
@@ -181,6 +187,7 @@ Deno.test("session management", async (t) => {
       };
 
       await savePickerSession(sessionWithCustomContext);
+      await waitForPendingSaves();
       const loadedSession = await loadPickerSession({
         name: "compression-test",
       });
@@ -213,6 +220,7 @@ Deno.test("session management", async (t) => {
     for (let i = 0; i < 105; i++) {
       await savePickerSession(createMockSession(`session-limit-${i}`, i));
     }
+    await waitForPendingSaves();
 
     const sessions = listPickerSessions();
     // Should only have MAX_SESSION_COUNT sessions
@@ -245,6 +253,7 @@ Deno.test("session management", async (t) => {
     };
 
     await savePickerSession(minimalSession);
+    await waitForPendingSaves();
     const loaded = await loadPickerSession({ name: "minimal-context" });
 
     assertExists(loaded);
@@ -279,6 +288,7 @@ Deno.test("session management", async (t) => {
     };
 
     await savePickerSession(sessionWithSpecialChars);
+    await waitForPendingSaves();
     const loaded = await loadPickerSession({ name: "special-chars" });
 
     assertExists(loaded);