fix(tables): audit fixes — column-copy drain, polling scope, merge identity

- Fix polling tick: move Promise.all inside else-branch so dirty[] stays in
  scope; keep hasDirty=true during active mutations so the short interval
  fires while chunked batch-updates are in flight
- Add isColumnSelectionRef branch to handleCopy (mirrors handleCut fix):
  column-header Cmd+C now drains all pages before building clipboard content
- Replace String(updatedAt) comparison in mergePagePreservingIdentity with
  Date.getTime() equality — handles ISO vs +00:00 timezone variants
- Remove redundant batchUpdates.length > 0 guards at chunkBatchUpdates
  callsites (empty-array case is handled inside the function)
- Export _mergePagePreservingIdentity for unit testing
- Add 6 unit tests covering mergePagePreservingIdentity edge cases

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx

@@ -1653,9 +1653,7 @@ export function TableGrid({
           if (undoCells.length > 0) {
             pushUndoRef.current({ type: 'clear-cells', cells: undoCells })
           }
-          if (batchUpdates.length > 0) {
-            await chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current)
-          }
+          await chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current)
         })().catch((error) => {
           logger.error('Failed to clear selected cells', { error })
           toast.error('Failed to clear cells — please try again')
@@ -1882,8 +1880,7 @@ export function TableGrid({
               batchUpdates.push({ rowId: row.id, data: updates })
             }
             if (undoCells.length > 0) pushUndoRef.current({ type: 'clear-cells', cells: undoCells })
-            if (batchUpdates.length > 0)
-              await chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current)
+            await chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current)
           })().catch((error) => {
             logger.error('Failed to clear column values', { error })
             toast.error('Failed to clear column values — please try again')
@@ -1908,12 +1905,10 @@ export function TableGrid({
           undoCells.push({ rowId: row.id, data: previousData })
           batchUpdates.push({ rowId: row.id, data: updates })
         }
-        if (batchUpdates.length > 0) {
-          void chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current).catch((error) => {
-            logger.error('Failed to clear selected cells', { error })
-            toast.error('Failed to clear cells — please try again')
-          })
-        }
+        void chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current).catch((error) => {
+          logger.error('Failed to clear selected cells', { error })
+          toast.error('Failed to clear cells — please try again')
+        })
         if (undoCells.length > 0) {
           pushUndoRef.current({ type: 'clear-cells', cells: undoCells })
         }
@@ -1991,6 +1986,51 @@ export function TableGrid({
       if (!sel) return
 
       e.preventDefault()
+
+      if (isColumnSelectionRef.current) {
+        // Column-header copy spans all rows — drain pages first, then use async
+        // clipboard so we don't block the event before the drain completes.
+        void (async () => {
+          const allRows = await ensureAllRowsLoadedRef.current()
+          const lines: string[] = []
+          for (const row of allRows) {
+            const cells: string[] = []
+            for (let c = sel.startCol; c <= sel.endCol; c++) {
+              const colName = cols[c]?.name
+              if (!colName) continue
+              const value: unknown = row.data[colName]
+              cells.push(
+                value === null || value === undefined
+                  ? ''
+                  : typeof value === 'object'
+                    ? JSON.stringify(value)
+                    : String(value)
+              )
+            }
+            lines.push(cells.join('\t'))
+          }
+          if (!navigator.clipboard) {
+            toast.error('Clipboard access is unavailable in this context')
+            return
+          }
+          try {
+            await navigator.clipboard.writeText(lines.join('\n'))
+          } catch (err) {
+            if (err instanceof DOMException && err.name === 'NotAllowedError') {
+              toast.error(
+                'Clipboard permission expired — press Cmd+C again immediately after selecting'
+              )
+            } else {
+              throw err
+            }
+          }
+        })().catch((error) => {
+          logger.error('Failed to copy column cells', { error })
+          toast.error('Failed to copy — please try again')
+        })
+        return
+      }
+
       const lines: string[] = []
       for (let r = sel.startRow; r <= sel.endRow; r++) {
         const cells: string[] = []
@@ -2127,9 +2167,7 @@ export function TableGrid({
           if (undoCells.length > 0) {
             pushUndoRef.current({ type: 'clear-cells', cells: undoCells })
           }
-          if (batchUpdates.length > 0) {
-            await chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current)
-          }
+          await chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current)
         })().catch((error) => {
           logger.error('Failed to cut column cells', { error })
           toast.error('Failed to cut — please try again')
@@ -2164,12 +2202,10 @@ export function TableGrid({
         batchUpdates.push({ rowId: row.id, data: updates })
       }
       e.clipboardData?.setData('text/plain', lines.join('\n'))
-      if (batchUpdates.length > 0) {
-        void chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current).catch((error) => {
-          logger.error('Failed to cut selected cells', { error })
-          toast.error('Failed to cut — please try again')
-        })
-      }
+      void chunkBatchUpdates(batchUpdates, batchUpdateAsyncRef.current).catch((error) => {
+        logger.error('Failed to cut selected cells', { error })
+        toast.error('Failed to cut — please try again')
+      })
       if (undoCells.length > 0) {
         pushUndoRef.current({ type: 'clear-cells', cells: undoCells })
       }

apps/sim/hooks/queries/tables.test.ts

@@ -82,6 +82,7 @@ vi.mock('@/components/emcn', () => ({
 }))
 
 import {
+  _mergePagePreservingIdentity,
   tableKeys,
   tableRowsInfiniteOptions,
   tableRowsParamsKey,
@@ -370,3 +371,75 @@ describe('tableRowsInfiniteOptions', () => {
     expect(JSON.stringify(opts1.queryKey)).not.toBe(JSON.stringify(opts2.queryKey))
   })
 })
+
+describe('_mergePagePreservingIdentity', () => {
+  const ts = '2024-01-01T00:00:00.000Z'
+  const ts2 = '2024-01-02T00:00:00.000Z'
+
+  function makeRow(id: string, updatedAt: string, extra?: Record<string, unknown>) {
+    return { id, updatedAt, data: { value: id, ...extra } }
+  }
+
+  it('returns fresh when totalCount differs', () => {
+    const prev = { rows: [makeRow('r1', ts)], totalCount: 1, nextOffset: undefined }
+    const fresh = { rows: [makeRow('r1', ts)], totalCount: 2, nextOffset: undefined }
+    const result = _mergePagePreservingIdentity(prev, fresh)
+    expect(result).toBe(fresh)
+  })
+
+  it('returns fresh when row counts differ', () => {
+    const prev = { rows: [makeRow('r1', ts)], totalCount: 2, nextOffset: undefined }
+    const fresh = {
+      rows: [makeRow('r1', ts), makeRow('r2', ts)],
+      totalCount: 2,
+      nextOffset: undefined,
+    }
+    const result = _mergePagePreservingIdentity(prev, fresh)
+    expect(result).toBe(fresh)
+  })
+
+  it('returns prev (same reference) when all rows are unchanged', () => {
+    const row1 = makeRow('r1', ts)
+    const row2 = makeRow('r2', ts)
+    const prev = { rows: [row1, row2], totalCount: 2, nextOffset: undefined }
+    const freshRow1 = makeRow('r1', ts)
+    const fresh = { rows: [freshRow1, makeRow('r2', ts)], totalCount: 2, nextOffset: undefined }
+    const result = _mergePagePreservingIdentity(prev, fresh)
+    expect(result).toBe(prev)
+  })
+
+  it('preserves identity for unchanged rows, uses fresh for updated rows', () => {
+    const row1 = makeRow('r1', ts)
+    const row2 = makeRow('r2', ts)
+    const prev = { rows: [row1, row2], totalCount: 2, nextOffset: undefined }
+    const updatedRow2 = makeRow('r2', ts2, { extra: 'new' })
+    const fresh = { rows: [makeRow('r1', ts), updatedRow2], totalCount: 2, nextOffset: undefined }
+    const result = _mergePagePreservingIdentity(prev, fresh)
+    expect(result).not.toBe(prev)
+    expect(result.rows[0]).toBe(row1)
+    expect(result.rows[1]).toBe(updatedRow2)
+  })
+
+  it('uses fresh row when ID is not found in prev', () => {
+    const row1 = makeRow('r1', ts)
+    const prev = { rows: [row1, makeRow('r2', ts)], totalCount: 2, nextOffset: undefined }
+    const newRow = makeRow('r3', ts)
+    const fresh = { rows: [makeRow('r1', ts), newRow], totalCount: 2, nextOffset: undefined }
+    const result = _mergePagePreservingIdentity(prev, fresh)
+    expect(result.rows[1]).toBe(newRow)
+  })
+
+  it('compares updatedAt as dates, not strings (ISO vs different string forms)', () => {
+    const row1 = makeRow('r1', ts)
+    const prev = { rows: [row1], totalCount: 1, nextOffset: undefined }
+    // Same point in time, different ISO string representation (with trailing Z vs +00:00)
+    const sameTimeDifferentFormat = '2024-01-01T00:00:00+00:00'
+    const fresh = {
+      rows: [makeRow('r1', sameTimeDifferentFormat)],
+      totalCount: 1,
+      nextOffset: undefined,
+    }
+    const result = _mergePagePreservingIdentity(prev, fresh)
+    expect(result).toBe(prev)
+  })
+})

apps/sim/hooks/queries/tables.ts

@@ -251,11 +251,8 @@ export function useTableRows({
   })
 }
 
-/** Merges a freshly-fetched page into the cached page while preserving row
- * object identity for unchanged rows (by `updatedAt`). Returns the original
- * `prev` reference unchanged when nothing has actually changed — callers can
- * use a `===` check to skip a `setQueryData` write entirely. */
-function mergePagePreservingIdentity(
+/** @internal — exported for testing only. */
+export function _mergePagePreservingIdentity(
   prev: TableRowsResponse,
   fresh: TableRowsResponse
 ): TableRowsResponse {
@@ -264,7 +261,8 @@ function mergePagePreservingIdentity(
   let allSame = true
   const nextRows = fresh.rows.map((freshRow) => {
     const prevRow = prevById.get(freshRow.id)
-    if (prevRow && String(prevRow.updatedAt) === String(freshRow.updatedAt)) return prevRow
+    if (prevRow && new Date(prevRow.updatedAt).getTime() === new Date(freshRow.updatedAt).getTime())
+      return prevRow
     allSame = false
     return freshRow
   })
@@ -343,7 +341,12 @@ export function useInfiniteTableRows({
     const tick = async () => {
       if (cancelled) return
       let hasDirty = false
-      if (queryClient.isMutating() === 0) {
+      if (queryClient.isMutating() !== 0) {
+        // Mutation in progress — skip network fetch to avoid racing optimistic
+        // updates, but stay on the short interval so we catch up quickly once
+        // the mutation settles.
+        hasDirty = true
+      } else {
         const data = queryClient.getQueryData<InfiniteData<TableRowsResponse, number>>(queryKey)
         const dirty: number[] = []
         if (data) {
@@ -374,7 +377,7 @@ export function useInfiniteTableRows({
                     if (!prev) return prev
                     const idx = prev.pageParams.indexOf(offset)
                     if (idx === -1) return prev
-                    const merged = mergePagePreservingIdentity(prev.pages[idx], fresh)
+                    const merged = _mergePagePreservingIdentity(prev.pages[idx], fresh)
                     if (merged === prev.pages[idx]) return prev
                     const nextPages = prev.pages.slice()
                     nextPages[idx] = merged