fix(tables): preserve virtual table paging and keyboard access

Author: kerrylu

apps/sim/app/api/table/[tableId]/export/route.test.ts

@@ -5,6 +5,7 @@ import { hybridAuthMockFns } from '@sim/testing'
 import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { TableDefinition } from '@/lib/table'
+import { encodeCursor } from '@/lib/table/rows/cursor'
 
 const { mockCheckAccess, mockQueryRows } = vi.hoisted(() => ({
   mockCheckAccess: vi.fn(),
@@ -107,4 +108,51 @@ describe('table export route — id→name translation', () => {
     expect(mockCheckAccess).toHaveBeenCalledWith('tbl_1', 'user-1', 'read')
     expect(mockQueryRows).not.toHaveBeenCalled()
   })
+
+  it('continues a virtual export with the keyset cursor returned by the previous page', async () => {
+    const firstRow = {
+      id: 'r1',
+      data: { col_email: 'first@b.c', legacy: 'x' },
+      executions: {},
+      position: 0,
+      orderKey: '2026-01-02T00:00:00.000Z',
+    }
+    const nextCursor = encodeCursor({
+      lastRow: firstRow,
+      keysetValid: true,
+      nextOffset: 1,
+    })
+    mockQueryRows
+      .mockResolvedValueOnce({
+        rows: [firstRow],
+        rowCount: 1,
+        totalCount: null,
+        limit: 1000,
+        offset: 0,
+        nextCursor,
+      })
+      .mockResolvedValueOnce({
+        rows: [],
+        rowCount: 0,
+        totalCount: null,
+        limit: 1000,
+        offset: 0,
+        nextCursor: null,
+      })
+
+    const res = await callGet('csv')
+    await res.text()
+
+    expect(mockQueryRows).toHaveBeenNthCalledWith(
+      2,
+      expect.anything(),
+      {
+        limit: 1000,
+        offset: 0,
+        after: { orderKey: firstRow.orderKey, id: firstRow.id },
+        includeTotal: false,
+      },
+      expect.any(String)
+    )
+  })
 })

apps/sim/app/api/table/[tableId]/export/route.ts

@@ -11,6 +11,7 @@ import { captureServerEvent } from '@/lib/posthog/server'
 import { namedRowMapper } from '@/lib/table/cell-format'
 import { getColumnId } from '@/lib/table/column-keys'
 import { formatCsvCell } from '@/lib/table/export-format'
+import { decodeCursor } from '@/lib/table/rows/cursor'
 import { queryRows } from '@/lib/table/rows/service'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 
@@ -106,11 +107,12 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
         }
 
         let offset = 0
+        let after: { orderKey: string | null; id: string } | undefined
         let firstJsonRow = true
         while (true) {
           const result = await queryRows(
             table,
-            { limit: EXPORT_BATCH_SIZE, offset, includeTotal: false },
+            { limit: EXPORT_BATCH_SIZE, offset, after, includeTotal: false },
             requestId
           )
 
@@ -128,7 +130,9 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
           // A page can be cut by the byte budget before reaching EXPORT_BATCH_SIZE,
           // so a short page does NOT mean the export is done — only a null cursor does.
           if (!result.nextCursor) break
-          offset += result.rows.length
+          const decoded = decodeCursor(result.nextCursor)
+          after = decoded.after
+          offset = decoded.offset ?? 0
         }
 
         if (format === 'json') controller.enqueue(encoder.encode(']'))

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

@@ -82,11 +82,17 @@ vi.mock('./table-primitives', () => ({
 vi.mock('./data-row', () => ({
   DataRow: ({
     onDoubleClick,
+    onCellMouseDown,
   }: {
     onDoubleClick: (rowId: string, name: string, key: string) => void
+    onCellMouseDown: (rowIndex: number, colIndex: number, shiftKey: boolean) => void
   }) => (
     <tr>
-      <td data-testid='cell' onDoubleClick={() => onDoubleClick('row-1', 'value', 'value')}>
+      <td
+        data-testid='cell'
+        onMouseDown={() => onCellMouseDown(0, 0, false)}
+        onDoubleClick={() => onDoubleClick('row-1', 'value', 'value')}
+      >
         Cell
       </td>
     </tr>
@@ -204,6 +210,69 @@ describe('TableGrid virtual cells', () => {
     container.remove()
   })
 
+  it.each(['Enter', 'F2', ' '])('opens the read-only viewer with the %s keyboard path', (key) => {
+    const container = document.createElement('div')
+    document.body.appendChild(container)
+    const root = createRoot(container)
+
+    act(() => {
+      root.render(
+        <TableGrid
+          workspaceId='workspace-1'
+          tableId='virtual-table'
+          remoteSelections={[]}
+          emitCellSelection={vi.fn()}
+          locks={{
+            schemaLocked: true,
+            insertLocked: true,
+            updateLocked: true,
+            deleteLocked: true,
+          }}
+          onBlockedAction={mockBlockedAction}
+          sidebarReservedPx={0}
+          onOpenColumnConfig={vi.fn()}
+          onOpenWorkflowConfig={vi.fn()}
+          onOpenEnrichments={vi.fn()}
+          onOpenEnrichmentConfig={vi.fn()}
+          onOpenExecutionDetails={vi.fn()}
+          onOpenEnrichmentDetails={vi.fn()}
+          onOpenRowModal={vi.fn()}
+          onRequestDeleteRows={vi.fn()}
+          onRequestDeleteAllByFilter={vi.fn()}
+          onRequestDeleteColumns={vi.fn()}
+          onRunColumn={vi.fn()}
+          onRunRow={vi.fn()}
+          onRunRows={vi.fn()}
+          onStopRows={vi.fn()}
+          onStopAllRows={vi.fn()}
+          onStopRow={vi.fn()}
+          onSelectionChange={vi.fn()}
+          queryOptions={{}}
+          columnRenameSinkRef={{ current: null }}
+          afterDeleteRowsSinkRef={{ current: null }}
+          afterDeleteAllSinkRef={{ current: null }}
+          confirmDeleteColumnsSinkRef={{ current: null }}
+          pushTableRenameUndoSinkRef={{ current: null }}
+        />
+      )
+    })
+
+    const cell = container.querySelector<HTMLElement>('[data-testid="cell"]')
+    const scroll = container.querySelector<HTMLElement>('[data-table-scroll]')
+    act(() => {
+      cell?.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }))
+    })
+    act(() => {
+      scroll?.dispatchEvent(new KeyboardEvent('keydown', { key, bubbles: true }))
+    })
+
+    expect(container.querySelector('[data-testid="expanded-cell"]')?.textContent).toBe('row-1')
+    expect(mockBlockedAction).not.toHaveBeenCalled()
+
+    act(() => root.unmount())
+    container.remove()
+  })
+
   it('shows row-query failures instead of presenting an empty result', () => {
     const rowsError = new Error('Transcript filtering and sorting are not supported for this table')
     mockUseTable.mockReturnValue(createUseTableResult(rowsError))

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

@@ -2538,6 +2538,16 @@ export function TableGrid({
       }
 
       if (e.key === 'Enter' || e.key === 'F2') {
+        if (isVirtualTableRef.current) {
+          e.preventDefault()
+          const col = cols[anchor.colIndex]
+          const row = currentRows[anchor.rowIndex]
+          if (!col || !row) return
+          setSelectionFocus(null)
+          setIsColumnSelection(false)
+          setExpandedCell({ rowId: row.id, columnName: col.key, columnKey: col.key })
+          return
+        }
         if (!canEditRef.current) return
         e.preventDefault()
         // The primary keyboard edit path — same lock notice as double-click and
@@ -2563,6 +2573,16 @@ export function TableGrid({
       }
 
       if (e.key === ' ' && !e.shiftKey) {
+        if (isVirtualTableRef.current) {
+          e.preventDefault()
+          const col = cols[anchor.colIndex]
+          const row = currentRows[anchor.rowIndex]
+          if (!col || !row) return
+          setSelectionFocus(null)
+          setIsColumnSelection(false)
+          setExpandedCell({ rowId: row.id, columnName: col.key, columnKey: col.key })
+          return
+        }
         if (!canEditRef.current) return
         e.preventDefault()
         // Space opens the same row editor as double-click, so it follows the

apps/sim/lib/virtual-tables/memory-virtual-table.server.test.ts

@@ -333,7 +333,7 @@ describe('Memory virtual table', () => {
     expect(result.hasMore).toBe(true)
   })
 
-  it('still returns one transcript that alone exceeds the query byte budget', async () => {
+  it('rejects a transcript that alone exceeds the query byte budget', async () => {
     const oversized = {
       id: 'memory-1',
       key: 'conversation-1',
@@ -344,17 +344,41 @@ describe('Memory virtual table', () => {
       rowBytes: 5 * 1024 * 1024 + 1,
     }
     queueTableRows(schemaMock.memory, [oversized])
-    queueTableRows(schemaMock.memory, [{ id: oversized.id, data: oversized.data }])
+    await expect(
+      queryMemoryTableRows({
+        workspaceId: 'workspace-1',
+        limit: 1000,
+        includeTotal: false,
+      })
+    ).rejects.toThrow('Memory transcript exceeds the 5MB table query limit')
+
+    expect(dbChainMockFns.select).toHaveBeenCalledTimes(2)
+  })
+
+  it('returns a continuation anchor when every selected transcript disappears during hydration', async () => {
+    const candidate = {
+      id: 'memory-1',
+      key: 'conversation-1',
+      createdAt: CREATED_AT,
+      updatedAt: UPDATED_AT,
+      messageCount: 1,
+      rowBytes: 100,
+    }
+    queueTableRows(schemaMock.memory, [candidate])
+    queueTableRows(schemaMock.memory, [])
 
     const result = await queryMemoryTableRows({
       workspaceId: 'workspace-1',
-      limit: 1000,
+      limit: 1,
       includeTotal: false,
     })
 
-    expect(result.rows).toHaveLength(1)
-    expect(result.rows[0]?.id).toBe(oversized.id)
-    expect(result.hasMore).toBe(false)
+    expect(result.rows).toEqual([])
+    expect(result.hasMore).toBe(true)
+    expect(result.continuation).toEqual({
+      lastRow: { id: candidate.id, orderKey: UPDATED_AT.toISOString() },
+      nextOffset: 1,
+    })
   })
 
   it('finds matching cells in one storage query and preserves filtered sort ordinals', async () => {

apps/sim/lib/virtual-tables/memory-virtual-table.server.ts

@@ -200,22 +200,25 @@ export async function queryMemoryTableRows({
     ? db.select({ value: count() }).from(memoryRows).where(baseWhere)
     : Promise.resolve(null)
   const [candidates, totalRows] = await Promise.all([candidatePromise, totalPromise])
-  const pageByteBudget = getMaxPageBytes() ?? TABLE_LIMITS.MAX_QUERY_RESULT_BYTES
+  const pageByteBudget = Math.min(
+    getMaxPageBytes() ?? TABLE_LIMITS.MAX_QUERY_RESULT_BYTES,
+    TABLE_LIMITS.MAX_QUERY_RESULT_BYTES
+  )
   const selectedCandidates: typeof candidates = []
   let selectedBytes = 0
-  let hasMore = false
+  let hasMore = candidates.length === limit
 
   for (const candidate of candidates) {
     const rowBytes = Number(candidate.rowBytes)
     if (!Number.isFinite(rowBytes) || rowBytes < 0) {
       throw new TableQueryValidationError('Memory table returned an invalid row size')
     }
-    // Matches `fetchRowsBounded` on the persisted path: a bounded page always
-    // yields at least one row, even one that alone exceeds the budget. Memory
-    // transcripts have no write-time size cap (unlike persisted rows, which are
-    // held to MAX_ROW_SIZE_BYTES), so refusing an over-budget first row would
-    // make one long conversation render the whole table unreadable with no way
-    // to page past it.
+    if (rowBytes > pageByteBudget) {
+      throw new TableQueryValidationError(
+        `Memory transcript exceeds the ${Math.floor(pageByteBudget / (1024 * 1024))}MB table query limit`,
+        'TABLE_QUERY_RESULT_TOO_LARGE'
+      )
+    }
     if (selectedCandidates.length > 0 && selectedBytes + rowBytes > pageByteBudget) {
       hasMore = true
       break
@@ -257,12 +260,23 @@ export async function queryMemoryTableRows({
       ),
     ]
   })
+  const lastSelectedCandidate = selectedCandidates[selectedCandidates.length - 1]
 
   return {
     rows,
     totalCount: totalRows ? Number(totalRows[0].value) : null,
     keysetValid: !sort,
     hasMore,
+    continuation:
+      hasMore && lastSelectedCandidate
+        ? {
+            lastRow: {
+              id: lastSelectedCandidate.id,
+              orderKey: lastSelectedCandidate.updatedAt.toISOString(),
+            },
+            nextOffset: offset + selectedCandidates.length,
+          }
+        : undefined,
   }
 }
 /** Searches Memory cells in PostgreSQL while preserving the active view's row ordinals. */

apps/sim/lib/virtual-tables/service.server.test.ts

@@ -152,6 +152,30 @@ describe('virtual table service', () => {
     })
   })
 
+  it('continues after scanned candidates when hydration drops every returned row', async () => {
+    mockQueryMemoryRows.mockResolvedValue({
+      rows: [],
+      totalCount: 2,
+      keysetValid: true,
+      hasMore: true,
+      continuation: {
+        lastRow: { id: 'memory-1', orderKey: '2026-01-02T00:00:00.000Z' },
+        nextOffset: 1,
+      },
+    })
+
+    const result = await queryVirtualTableRows(MEMORY_TABLE, {
+      limit: 1000,
+      offset: 0,
+      includeTotal: true,
+    })
+
+    expect(result.rows).toEqual([])
+    expect(decodeCursor(result.nextCursor as string)).toEqual({
+      after: { orderKey: '2026-01-02T00:00:00.000Z', id: 'memory-1' },
+    })
+  })
+
   it('emits a sort-bound offset cursor when a provider cannot use a keyset', async () => {
     const firstRow = createRow('memory-1', '2026-01-02T00:00:00.000Z')
     const witnessRow = createRow('memory-2', '2026-01-01T00:00:00.000Z')