fix(files): surface a failed pre-retype list refresh instead of swallowing it

`invalidateQueries` resolves whether or not the refetch succeeded, so the
refresh reported success while leaving the dead storage key in the cache - the
caller awaiting a usable key could not tell the two apart.

The hook now rejects on a failed refetch. The retype logs and proceeds rather
than aborting: the edits are already durable, the type change is explicit, and
the rename's own invalidation refetches straight after, so the cost of a failed
refresh is one stale first paint - the pre-fix behaviour - not a lost change.

Author: mzxchandra

apps/sim/app/workspace/[workspaceId]/files/files.tsx

@@ -1245,7 +1245,15 @@ export function Files() {
         // The persist minted a new storage key and deleted the previous blob, so the cached record
         // the viewer renders from now points at a key that 404s. Wait for the refreshed list before
         // the rename swaps editors, or the newly mounted viewer reads the dead key.
-        await refreshFiles(workspaceId)
+        try {
+          await refreshFiles(workspaceId)
+        } catch (err) {
+          // Proceed rather than abort: the edits are already durable, the retype is an explicit
+          // action, and the rename's own invalidation refetches immediately after. The cost of a
+          // failed refresh is one stale first paint, which is the pre-fix behaviour - not losing
+          // the user's type change on a transient list fetch.
+          logger.warn('Retyping against a stale file list; the first read may 404', { err })
+        }
       } else {
         // Not an error - `unchanged` means there was nothing to write, and `skipped` means the write
         // did not land in time. The retype proceeds either way; this is the breadcrumb for a stale

apps/sim/hooks/queries/workspace-files.test.tsx

@@ -340,6 +340,40 @@ describe('useRefreshWorkspaceFiles', () => {
     unmount()
   })
 
+  /**
+   * react-query resolves an invalidation whether or not the refetch succeeded. A caller awaiting
+   * this for a usable storage key would otherwise read the dead one back as if it were fresh.
+   */
+  it('rejects when the refetch fails instead of resolving on the stale cache', async () => {
+    let call = 0
+    const queryFn = vi.fn(async () => {
+      call += 1
+      if (call > 1) throw new Error('network down')
+      return [{ id: 'file-1', key: 'workspace/ws-1/old-key' }]
+    })
+
+    const { refresh, queryClient, unmount } = renderRefresh()
+    const queryKey = workspaceFilesKeys.list(WS, 'active')
+    await act(async () => {
+      await queryClient.fetchQuery({ queryKey, queryFn })
+    })
+
+    let rejection: unknown = null
+    await act(async () => {
+      await refresh()(WS).catch((err) => {
+        rejection = err
+      })
+    })
+
+    expect(rejection).toBeInstanceOf(Error)
+    // The stale record is still cached — the caller has to decide what to do about it, not be told
+    // the refresh worked.
+    expect(queryClient.getQueryData<{ key: string }[]>(queryKey)?.[0].key).toBe(
+      'workspace/ws-1/old-key'
+    )
+    unmount()
+  })
+
   it('leaves another workspace list alone', async () => {
     const otherQueryFn = vi.fn(async () => [{ id: 'file-2', key: 'k2' }])
     const { refresh, queryClient, unmount } = renderRefresh()

apps/sim/hooks/queries/workspace-files.ts

@@ -581,25 +581,33 @@ export function useUpdateWorkspaceFileContent() {
 }
 
 /**
- * Refetch the workspace file list and resolve once the fresh records have landed.
+ * Refetch the workspace file list, resolving once the fresh records have landed and **rejecting**
+ * if the refetch failed.
  *
  * Every content write mints a new storage key and deletes the previous blob, so a cached record's
  * `key` is dead the moment one lands. A caller that is about to mount a viewer from that record -
  * a retype, which swaps editors optimistically - has to wait for the refreshed list, or the new
  * viewer fetches a key the store has already deleted.
+ *
+ * The rejection is the point: react-query resolves an invalidation whether or not the refetch
+ * succeeded, so a caller awaiting a usable key cannot otherwise tell fresh records from the dead
+ * ones still sitting in the cache. Callers decide what a failure means for them.
  */
 export function useRefreshWorkspaceFiles() {
   const queryClient = useQueryClient()
 
   return useCallback(
     (workspaceId: string) =>
-      queryClient.invalidateQueries({
-        queryKey: workspaceFilesKeys.workspaceLists(workspaceId),
-        // `all`, not the default `active`: the caller awaits this to get a usable key back, and an
-        // invalidation that only marks an unobserved list stale resolves immediately with the dead
-        // key still cached - the exact staleness this exists to close.
-        refetchType: 'all',
-      }),
+      queryClient.invalidateQueries(
+        {
+          queryKey: workspaceFilesKeys.workspaceLists(workspaceId),
+          // `all`, not the default `active`: the caller awaits this to get a usable key back, and an
+          // invalidation that only marks an unobserved list stale resolves immediately with the dead
+          // key still cached - the exact staleness this exists to close.
+          refetchType: 'all',
+        },
+        { throwOnError: true }
+      ),
     [queryClient]
   )
 }