fix(queries): stop a table cell edit throwing, and an upload gate failing shut

Two functional bugs found auditing the query layer.

patchCachedRows walked tableKeys.rowsRoot non-exact, but rowsRoot is a prefix:
the find (search results) and write (pending writes) subtrees hang off it with
non-paged shapes, and the updater's old.pages.map threw on them. It runs inside
onMutate, so the whole cell edit rejected before reaching the server — reachable
as soon as a find entry exists, i.e. after the user searches the table once. The
sibling isDefaultOrderRowsQuery already excluded those subtrees and its docstring
claimed they "never match"; that was only true of the sibling. Both now share one
isRowListQueryKey helper so they cannot drift apart again.

useCloudStorageConfigured combined staleTime: Infinity, retry: false, and the
global retryOnMount: false on a workspace-independent key, so one transient
failure left it errored for the tab's lifetime with no way back — navigating or
switching workspace cannot change the key, and the upload path fails closed, so
cloud-backed uploads stayed disabled until a full reload. useVoiceSettings
carries the same three options and already escapes this with retryOnMount: true;
this one now matches.

Note: hooks/queries/workspace-files.test.tsx cannot load in a git worktree
(pre-existing postcss resolution failure), so CI is the first place that file
runs against this change.

Author: waleedlatif1

apps/sim/hooks/queries/tables.ts

@@ -829,6 +829,18 @@ function withOptimisticAutoFireExec(groups: WorkflowGroup[], row: TableRow): Tab
   return { ...row, executions: nextExecutions }
 }
 
+/**
+ * Whether a cache key under {@link tableKeys.rowsRoot} holds paged row-list data.
+ *
+ * `rowsRoot` is a shared prefix: the `find` (search results) and `write` (pending
+ * writes) subtrees live beneath it with entirely different shapes, so any bulk
+ * update walking the prefix has to exclude them or it will be handed a value whose
+ * `pages` it cannot map.
+ */
+function isRowListQueryKey(queryKey: readonly unknown[]): boolean {
+  return !queryKey.includes('find') && !queryKey.includes('write')
+}
+
 /**
  * Apply a row-level transformation to all cached infinite row queries for this
  * table. Used for cell edits where positions don't change.
@@ -839,9 +851,20 @@ function patchCachedRows(
   patchRow: (row: TableRow) => TableRow
 ) {
   queryClient.setQueriesData<InfiniteData<TableRowsResponse, TableRowsPageParam>>(
-    { queryKey: tableKeys.rowsRoot(tableId), exact: false },
+    {
+      queryKey: tableKeys.rowsRoot(tableId),
+      exact: false,
+      /**
+       * `rowsRoot` is a prefix, not a leaf: `rowWrites` and `find` hang off it and
+       * hold non-paged shapes. Without this they are handed to the updater below,
+       * whose `old.pages.map` throws — and because this runs inside `onMutate`, the
+       * whole cell edit rejects before it reaches the server. Only reachable once a
+       * `find` entry exists, i.e. after the user has searched the table.
+       */
+      predicate: (query) => isRowListQueryKey(query.queryKey),
+    },
     (old) => {
-      if (!old) return old
+      if (!old?.pages) return old
       return {
         ...old,
         pages: old.pages.map((page) => ({ ...page, rows: page.rows.map(patchRow) })),
@@ -859,7 +882,7 @@ function patchCachedRows(
  * `find`/`write` subtrees aren't row-list data and never match.
  */
 function isDefaultOrderRowsQuery(queryKey: readonly unknown[]): boolean {
-  if (queryKey.includes('find') || queryKey.includes('write')) return false
+  if (!isRowListQueryKey(queryKey)) return false
   const last = queryKey[queryKey.length - 1]
   if (typeof last !== 'string') return false
   try {

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

@@ -521,6 +521,16 @@ export function useCloudStorageConfigured(enabled = true) {
     enabled,
     retry: false,
     staleTime: CLOUD_STORAGE_CONFIGURED_STALE_TIME,
+    /**
+     * Escapes the global `retryOnMount: false`, which an infinite `staleTime` and
+     * `retry: false` would otherwise turn into a permanent failure: one transient
+     * error leaves this query errored for the tab's lifetime, and consumers fail
+     * closed — the upload path treats "unknown" as "not configured", so a single
+     * blip would disable cloud-backed uploads until a full reload. The key is
+     * global, so navigating or switching workspace cannot recover it either.
+     * Matches {@link useVoiceSettings}, which carries the same three options.
+     */
+    retryOnMount: true,
   })
 }