fix(file-editor): retain conflicts with unknown version ordering

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor-state.test.ts

@@ -322,20 +322,61 @@ describe('content-version ordering', () => {
     expect(next.conflict).toEqual(state.conflict)
   })
 
-  it('clears a fetch of its own save once the matching acknowledgement arrives', () => {
-    const state = {
-      ...ready('local trailing', 'original'),
-      savedVersion: version(1),
-      conflict: { version: version(2) },
+  it.each([
+    { fetchedVersion: undefined, savedVersion: version(2) },
+    { fetchedVersion: undefined, savedVersion: undefined },
+    { fetchedVersion: version(2), savedVersion: undefined },
+  ])(
+    'retains conflicts when acknowledgement ordering is unknown: %o',
+    ({ fetchedVersion, savedVersion }) => {
+      const conflicted = syncTextEditorContentState(
+        {
+          ...ready('local trailing', 'original'),
+          savedVersion: version(1),
+        },
+        {
+          canReconcileToFetchedContent: true,
+          fetchedContent: 'remote',
+          fetchedVersion,
+        }
+      )
+      expect(conflicted.conflict).toBeDefined()
+      const acknowledged = textEditorContentReducer(conflicted, {
+        type: 'save-success',
+        content: 'local saved',
+        version: savedVersion,
+      })
+      expect(acknowledged.conflict).toEqual(conflicted.conflict)
+      expect(acknowledged.content).toBe('local trailing')
+      expect(acknowledged.savedContent).toBe('local saved')
+      const reloaded = textEditorContentReducer(acknowledged, {
+        type: 'reload',
+        content: 'latest remote',
+        version: version(3),
+      })
+      expect(reloaded.conflict).toBeUndefined()
+      expect(reloaded.content).toBe('latest remote')
+      expect(reloaded.savedVersion).toBe(version(3))
     }
-    const next = textEditorContentReducer(state, {
-      type: 'save-success',
-      content: 'local saved',
-      version: version(2),
-    })
-    expect(next.content).toBe('local trailing')
-    expect(next.conflict).toBeUndefined()
-  })
+  )
+
+  it.each([2, 3])(
+    'clears a versioned conflict when acknowledgement version %i catches up',
+    (second) => {
+      const state = {
+        ...ready('local trailing', 'original'),
+        savedVersion: version(1),
+        conflict: { version: version(2) },
+      }
+      const next = textEditorContentReducer(state, {
+        type: 'save-success',
+        content: 'local saved',
+        version: version(second),
+      })
+      expect(next.content).toBe('local trailing')
+      expect(next.conflict).toBeUndefined()
+    }
+  )
 })
 
 describe('syncTextEditorContentState — streaming', () => {

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor-state.ts

@@ -288,9 +288,10 @@ export function textEditorContentReducer(
         hasBaseline: true,
         savedVersion: action.version ?? state.savedVersion,
         conflict:
-          state.conflict?.streamInterrupted ||
-          (state.conflict?.version &&
-            action.version &&
+          state.conflict &&
+          (state.conflict.streamInterrupted ||
+            !state.conflict.version ||
+            !action.version ||
             Date.parse(state.conflict.version) > Date.parse(action.version))
             ? state.conflict
             : undefined,

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/use-editable-file-conflicts.test.tsx

@@ -340,6 +340,38 @@ describe('versioned solo-file editing', () => {
     )
   })
 
+  it('keeps an unversioned remote conflict paused after an in-flight save succeeds', async () => {
+    const pending = Promise.withResolvers<{ success: boolean; file: WorkspaceFileRecord }>()
+    mocks.save.mockReturnValueOnce(pending.promise)
+    await render()
+    await edit('local saved')
+    let saving: Promise<void> | undefined
+    act(() => {
+      saving = latest.saveImmediately()
+    })
+    await edit('local trailing')
+    file = { ...FILE, key: 'unknown-version', contentUpdatedAt: null }
+    mocks.query.content = 'remote'
+    await render()
+    expect(latest.hasConflict).toBe(true)
+    await act(async () => {
+      pending.resolve({ success: true, file: { ...FILE, contentUpdatedAt: new Date(V2) } })
+      await saving
+    })
+    expect(latest.hasConflict).toBe(true)
+    expect(latest.content).toBe('local trailing')
+    await advance()
+    await act(async () => latest.saveImmediately())
+    expect(mocks.save).toHaveBeenCalledTimes(1)
+    file = { ...FILE, key: 'immutable-v3', contentUpdatedAt: new Date(V3) }
+    mocks.reload.mockResolvedValueOnce({ content: 'latest remote', file })
+    await act(async () => latest.reloadLatestContent())
+    expect(latest.hasConflict).toBe(false)
+    await edit('resolved')
+    await act(async () => latest.saveImmediately())
+    expect(mocks.save).toHaveBeenLastCalledWith(expect.objectContaining({ expectedUpdatedAt: V3 }))
+  })
+
   it('uses the successful response token for trailing edits before the file-list refetch', async () => {
     const pending = Promise.withResolvers<{ success: boolean; file: WorkspaceFileRecord }>()
     mocks.save.mockReturnValueOnce(pending.promise)