fix(undo-redo): close two more review findings

- Block setItem/removeItem on the first getItem (hydration read) so a
  state change cannot persist an empty in-memory snapshot over the
  IndexedDB payload before zustand's persist middleware finishes
  rehydration. Without this guard, switching from synchronous
  localStorage to async IndexedDB introduced a race that could wipe
  undo history after reload (Cursor Bugbot, medium).
- Propagate IndexedDB errors from clearPersistedUndoRedo so a delete
  failure surfaces to clearUserData's outer try/catch instead of
  silently leaving a previous user's payload behind (Cursor Bugbot,
  medium).
- Add tests for the hydration-read ordering and the error propagation.

Signed-off-by: JaeHyung Jang <jaehyung.jang@navercorp.com>

Author: Sprexatura

apps/sim/stores/undo-redo/storage.test.ts

@@ -176,12 +176,41 @@ describe('undo-redo IndexedDB storage adapter', () => {
       expect(idbStore.get(MIGRATION_KEY)).toBe(true)
     })
 
-    it('swallows IndexedDB errors so sign-out does not crash', async () => {
+    it('propagates IndexedDB errors so callers can surface the failure', async () => {
       const { clearPersistedUndoRedo, migrationReady } = await loadFreshModule()
       await migrationReady
 
       idbDel.mockRejectedValueOnce(new Error('idb delete failed'))
-      await expect(clearPersistedUndoRedo()).resolves.toBeUndefined()
+      await expect(clearPersistedUndoRedo()).rejects.toThrow('idb delete failed')
+    })
+  })
+
+  describe('hydration race', () => {
+    it('blocks setItem until the first getItem resolves', async () => {
+      const { indexedDBStorage, migrationReady } = await loadFreshModule()
+      await migrationReady
+      idbStore.set(STORE_KEY, 'persisted-snapshot')
+
+      let releaseRead: ((value: 'persisted-snapshot') => void) | null = null
+      idbGet.mockImplementationOnce(
+        () =>
+          new Promise<'persisted-snapshot'>((resolve) => {
+            releaseRead = resolve
+          })
+      )
+
+      const readPromise = indexedDBStorage.getItem(STORE_KEY)
+      const writePromise = indexedDBStorage.setItem(STORE_KEY, 'empty-state')
+
+      // Give the microtask queue a chance to process; the write must still be pending.
+      await Promise.resolve()
+      expect(idbStore.get(STORE_KEY)).toBe('persisted-snapshot')
+
+      releaseRead?.('persisted-snapshot')
+      await readPromise
+      await writePromise
+
+      expect(idbStore.get(STORE_KEY)).toBe('empty-state')
     })
   })
 })

apps/sim/stores/undo-redo/storage.ts

@@ -9,6 +9,14 @@ const MIGRATION_KEY = 'workflow-undo-redo-migrated'
 
 let migrationPromiseInternal: Promise<void> | null = null
 
+/**
+ * Resolves with the first `getItem` result that goes through the adapter.
+ * Used to gate writes until the initial rehydration read completes — without
+ * this, a `setItem` triggered before the async `getItem` returns would
+ * overwrite the IndexedDB snapshot with an empty in-memory state.
+ */
+let hydrationReadPromise: Promise<string | null> | null = null
+
 /**
  * Migrates existing undo/redo data from localStorage to IndexedDB.
  * Runs once on first load; subsequent loads short-circuit on MIGRATION_KEY.
@@ -55,11 +63,23 @@ async function awaitMigration(): Promise<void> {
   }
 }
 
+async function awaitHydrationRead(): Promise<void> {
+  if (hydrationReadPromise) {
+    try {
+      await hydrationReadPromise
+    } catch {
+      // The read promise already swallowed its own errors; ignore here.
+    }
+  }
+}
+
 /**
  * Removes the persisted undo/redo payload from IndexedDB.
  *
  * Called from `clearUserData` on sign-out so undo history does not
- * survive across user sessions on the same device.
+ * survive across user sessions on the same device. Errors are
+ * propagated so callers can decide how to react (the default
+ * `clearUserData` already wraps this call in a try/catch).
  */
 export async function clearPersistedUndoRedo(): Promise<void> {
   if (typeof window === 'undefined') return
@@ -69,6 +89,7 @@ export async function clearPersistedUndoRedo(): Promise<void> {
     await del(STORE_KEY)
   } catch (error) {
     logger.warn('Failed to clear persisted undo-redo', { error })
+    throw error
   }
 }
 
@@ -77,18 +98,28 @@ export const indexedDBStorage: StateStorage = {
     if (typeof window === 'undefined') return null
     await awaitMigration()
 
-    try {
-      const value = await get<string>(name)
-      return value ?? null
-    } catch (error) {
-      logger.warn('IndexedDB read failed', { name, error })
-      return null
+    const readPromise = (async () => {
+      try {
+        const value = await get<string>(name)
+        return value ?? null
+      } catch (error) {
+        logger.warn('IndexedDB read failed', { name, error })
+        return null
+      }
+    })()
+
+    // Record the first read so concurrent writes can wait for it to complete.
+    if (!hydrationReadPromise) {
+      hydrationReadPromise = readPromise
     }
+
+    return await readPromise
   },
 
   setItem: async (name: string, value: string): Promise<void> => {
     if (typeof window === 'undefined') return
     await awaitMigration()
+    await awaitHydrationRead()
 
     try {
       await set(name, value)
@@ -100,6 +131,7 @@ export const indexedDBStorage: StateStorage = {
   removeItem: async (name: string): Promise<void> => {
     if (typeof window === 'undefined') return
     await awaitMigration()
+    await awaitHydrationRead()
 
     try {
       await del(name)