fix(files): key discard state to raw draftKey, make failed corrections retryable

Cursor Bugbot round 3 caught 2 more real gaps:

- The document-change reset added last round compared effectiveDraftKey
  (draftKey gated by enabled), so toggling enabled alone for the SAME
  document — e.g. a streaming lock — looked identical to switching files.
  That cleared discardedRef mid-correction, which skipped the correction's
  own setSaveStatus('error'/'idle') (gated on discardedRef to avoid
  clobbering a newer edit's status), silently stranding the hook on
  'saving' with no visible retry affordance. Now keyed off the raw
  draftKey, which enabled toggling never touches.

- After a failed correction, content already equals savedContent (that's
  what discard reverted to), so saveImmediately()'s retry going through
  save() hit its dirty-check and was a complete no-op — the error toast's
  Retry button did nothing. Extracted the correction logic into
  runCorrection(target), shared by discard() and by saveImmediately when a
  failed correction is pending, so retry pushes the reverted baseline
  again instead of bailing on a check that assumes retries are always for
  dirty content.

Author: waleedlatif1

apps/sim/hooks/use-autosave.test.tsx

@@ -1027,6 +1027,107 @@ describe('useAutosave', () => {
       expect(onSave).toHaveBeenLastCalledWith()
     })
 
+    it('does not lift discard suppression when only `enabled` toggles for the same document', async () => {
+      const resolvers: Array<() => void> = []
+      const rejecters: Array<(error: Error) => void> = []
+      const onSave = vi.fn(
+        () =>
+          new Promise<void>((resolve, reject) => {
+            resolvers.push(resolve)
+            rejecters.push(reject)
+          })
+      )
+      const { handle } = renderAutosave({
+        content: 'a',
+        savedContent: 'a',
+        onSave,
+        draftKey: 'file-discard-14',
+      })
+
+      handle.rerender({ content: 'a1' })
+      await act(async () => {
+        vi.advanceTimersByTime(1500)
+      })
+      await flush()
+      expect(onSave).toHaveBeenCalledTimes(1)
+      act(() => handle.discard())
+      handle.rerender({ content: 'a' })
+
+      // The correction starts once the original save settles.
+      await act(async () => {
+        resolvers[0]?.()
+      })
+      await flush()
+      expect(onSave).toHaveBeenCalledTimes(2)
+
+      // A streaming lock (or any other reason `enabled` flips) toggles for the SAME document
+      // while the correction is still in flight — this must not be mistaken for switching files
+      // and clear discard's ownership of saveStatus.
+      handle.rerender({ enabled: false })
+      handle.rerender({ enabled: true })
+
+      // Without keying off the raw draftKey, the `enabled` round-trip would have cleared
+      // discardedRef, so the correction's failure handler would skip setSaveStatus('error') and
+      // leave the hook stuck on 'saving' with no visible retry affordance.
+      await act(async () => {
+        rejecters[1]?.(new Error('network down'))
+      })
+      await flush()
+      expect(handle.status()).toBe('error')
+    })
+
+    it('retries a failed discard correction via saveImmediately instead of silently no-opping', async () => {
+      const resolvers: Array<() => void> = []
+      const rejecters: Array<(error: Error) => void> = []
+      let callCount = 0
+      const onSave = vi.fn(() => {
+        callCount += 1
+        if (callCount === 1) return new Promise<void>((resolve) => resolvers.push(resolve))
+        if (callCount === 2) return new Promise<void>((_, reject) => rejecters.push(reject))
+        return Promise.resolve()
+      })
+      const onDiscardCorrectionFailed = vi.fn()
+      const { handle } = renderAutosave({
+        content: 'a',
+        savedContent: 'a',
+        onSave,
+        draftKey: 'file-discard-15',
+        onDiscardCorrectionFailed,
+      })
+
+      handle.rerender({ content: 'a1' })
+      await act(async () => {
+        vi.advanceTimersByTime(1500)
+      })
+      await flush()
+      act(() => handle.discard())
+      handle.rerender({ content: 'a' })
+
+      await act(async () => {
+        resolvers[0]?.()
+      })
+      await flush()
+      expect(onSave).toHaveBeenCalledTimes(2)
+
+      await act(async () => {
+        rejecters[0]?.(new Error('network down'))
+      })
+      await flush()
+      expect(onDiscardCorrectionFailed).toHaveBeenCalledTimes(1)
+      expect(handle.status()).toBe('error')
+
+      // Content already equals savedContent (that's what discard reverted to), so a naive retry
+      // through save()'s dirty-check would be a silent no-op. saveImmediately must still push
+      // the reverted baseline again.
+      await act(async () => {
+        await handle.saveImmediately()
+      })
+      await flush()
+      expect(onSave).toHaveBeenCalledTimes(3)
+      expect(onSave).toHaveBeenLastCalledWith('a')
+      expect(handle.status()).toBe('idle')
+    })
+
     it('serializes IndexedDB writes and deletes so a slow write cannot resurrect a discarded draft', async () => {
       let resolveWrite: (() => void) | undefined
       const idbKeyval = await import('idb-keyval')

apps/sim/hooks/use-autosave.ts

@@ -96,7 +96,6 @@ export function useAutosave({
 
   const effectiveDraftKey = enabled ? draftKey : undefined
   const draftKeyRef = useRef(effectiveDraftKey)
-  const draftKeyChanged = draftKeyRef.current !== effectiveDraftKey
   draftKeyRef.current = effectiveDraftKey
   const onRestoreDraftRef = useRef(onRestoreDraft)
   onRestoreDraftRef.current = onRestoreDraft
@@ -108,12 +107,23 @@ export function useAutosave({
 
   const discardedRef = useRef(false)
   const discardTargetRef = useRef<string | null>(null)
-  // A hook instance reused across draftKeys (today's callers all remount per file instead) must
-  // not carry a discard suppression from the previous file into the new one.
-  if (draftKeyChanged) discardedRef.current = false
+  const failedCorrectionTargetRef = useRef<string | null>(null)
+  // Keyed off the raw `draftKey`, not `effectiveDraftKey` — the latter also flips with `enabled`
+  // (e.g. a streaming lock toggling for the SAME document), which must not be mistaken for a
+  // hook instance being reused across documents (today's callers all remount per file instead).
+  const documentKeyRef = useRef(draftKey)
+  const documentChanged = documentKeyRef.current !== draftKey
+  documentKeyRef.current = draftKey
+  if (documentChanged) {
+    discardedRef.current = false
+    failedCorrectionTargetRef.current = null
+  }
 
   const isDirty = content !== savedContent
-  if (discardedRef.current && content !== discardTargetRef.current) discardedRef.current = false
+  if (discardedRef.current && content !== discardTargetRef.current) {
+    discardedRef.current = false
+    failedCorrectionTargetRef.current = null
+  }
 
   const persistLocalDraft = useCallback(() => {
     const key = draftKeyRef.current
@@ -283,34 +293,21 @@ export function useAutosave({
     }
   }, [effectiveDraftKey, clearLocalDraft])
 
-  const saveImmediately = useCallback(async () => {
-    clearTimeout(timerRef.current)
-    await save()
-  }, [save])
-
-  const discard = useCallback(() => {
-    discardedRef.current = true
-    discardTargetRef.current = savedContentRef.current
-    clearTimeout(timerRef.current)
-    clearTimeout(localDraftTimerRef.current)
-    clearLocalDraft()
-    const pendingSave = inFlightRef.current
-    if (!pendingSave) return
-    const target = discardTargetRef.current
-    const contentAtDiscard = contentRef.current
-    void pendingSave.then(() => {
-      const current = contentRef.current
-      if (inFlightRef.current || (current !== target && current !== contentAtDiscard)) return
+  /** Pushes `target` (the reverted baseline) to the server. Used both by `discard()`'s initial correction and by `saveImmediately`'s retry of a correction that previously failed — content already equals `target` in both cases, so this bypasses `save()`'s dirty-check entirely rather than special-casing it there. */
+  const runCorrection = useCallback(
+    (target: string) => {
       savingRef.current = true
       const correctionRun = onSaveRef
         .current(target)
         .then(
           () => {
+            failedCorrectionTargetRef.current = null
             // Only ours to set if nothing has since un-suppressed discard (a newer edit) — that
             // flow owns status once it takes over.
             if (!unmountedRef.current && discardedRef.current) setSaveStatus('idle')
           },
           (error) => {
+            failedCorrectionTargetRef.current = target
             logger.warn('Corrective save after discard failed', { error })
             onDiscardCorrectionFailedRef.current?.()
             if (!unmountedRef.current && discardedRef.current) setSaveStatus('error')
@@ -327,8 +324,39 @@ export function useAutosave({
         })
       inFlightRef.current = correctionRun
       return correctionRun
+    },
+    [save]
+  )
+
+  const saveImmediately = useCallback(async () => {
+    clearTimeout(timerRef.current)
+    // Retrying after a failed correction: content already equals savedContent (that's what
+    // discard reverted to), so save()'s own dirty-check would treat this as a no-op and the
+    // error's retry button would silently do nothing.
+    if (failedCorrectionTargetRef.current !== null) {
+      await runCorrection(failedCorrectionTargetRef.current)
+      return
+    }
+    await save()
+  }, [save, runCorrection])
+
+  const discard = useCallback(() => {
+    discardedRef.current = true
+    discardTargetRef.current = savedContentRef.current
+    failedCorrectionTargetRef.current = null
+    clearTimeout(timerRef.current)
+    clearTimeout(localDraftTimerRef.current)
+    clearLocalDraft()
+    const pendingSave = inFlightRef.current
+    if (!pendingSave) return
+    const target = discardTargetRef.current
+    const contentAtDiscard = contentRef.current
+    void pendingSave.then(() => {
+      const current = contentRef.current
+      if (inFlightRef.current || (current !== target && current !== contentAtDiscard)) return
+      runCorrection(target)
     })
-  }, [clearLocalDraft, save])
+  }, [clearLocalDraft, runCorrection])
 
   return { saveStatus, saveImmediately, isDirty, discard }
 }