fix(tables): emit isVirtual in the table list and stop over-blocking locked tables

The `/api/table` list handler maps each table to an explicit field whitelist
and never emitted `isVirtual`, so every list-surface gate evaluated `undefined`:
`canMutateTable`/`canRenameTable` left Delete, Rename, Import CSV and Move
enabled on the Memory row, and the trigger-mode filter in the table selector
matched nothing. The existing list test mocked a Memory table without the flag
and asserted everything but it, which is why the gap shipped.

Two grid gates were also over-broad on persisted tables. The `json` escape in
the update-lock check is dead for virtual tables (they early-return above it)
and only changed behavior for persisted update-locked ones, contradicting the
comment directly above. Routing `onOpenConfig` through the blocked-add-column
handler made a schema-locked table's column config unopenable and showed
"add column" copy for something that was not an add — opening a column config
is metadata, not schema.

Finally, a Memory transcript that alone exceeds the page byte budget no longer
fails the whole query. This mirrors `fetchRowsBounded` on the persisted path,
which always yields at least one row for a bounded page and reserves the throw
for unbounded queries where a short page would be silent truncation.
`queryMemoryTableRows` is always bounded, so the guard was unreachable by
design; without this, one long conversation made the table unreadable with no
way to page past it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: kerrylu

apps/sim/app/api/table/route.test.ts

@@ -176,6 +176,7 @@ describe('GET /api/table folder placement', () => {
       {
         ...CREATED_TABLE,
         id: 'system_memory_workspace-1',
+        isVirtual: true,
         name: 'Memory',
         workspaceId: 'workspace-1',
         createdBy: 'user-1',
@@ -197,6 +198,10 @@ describe('GET /api/table folder placement', () => {
     expect(json.data.tables).toContainEqual(
       expect.objectContaining({
         id: 'system_memory_workspace-1',
+        // The list surfaces (tables page context menu, trigger-mode table
+        // selector) gate on this flag, so dropping it silently re-enables
+        // delete/rename/import/move on a read-only table.
+        isVirtual: true,
         name: 'Memory',
         workspaceId: 'workspace-1',
         locks: {

apps/sim/app/api/table/route.ts

@@ -212,6 +212,7 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
       const schemaData = t.schema as TableSchema
       return {
         id: t.id,
+        isVirtual: t.isVirtual,
         name: t.name,
         description: t.description,
         schema: {

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

@@ -2287,7 +2287,7 @@ export function TableGrid({
       // that silently refuses to save. Only for users who could otherwise edit:
       // without write access the lock isn't why they can't, and they still get
       // the read-only expanded viewer below.
-      if (canEditRef.current && updateLockedRef.current && column?.type !== 'json') {
+      if (canEditRef.current && updateLockedRef.current) {
         onBlockedActionRef.current('edit-cell')
         return
       }
@@ -4225,9 +4225,7 @@ export function TableGrid({
                             workflows={workflows}
                             workflowGroups={tableWorkflowGroups}
                             sourceInfo={columnSourceInfo.get(column.key)}
-                            onOpenConfig={
-                              canMutateSchema ? handleConfigureColumn : handleBlockedAddColumn
-                            }
+                            onOpenConfig={handleConfigureColumn}
                             onViewWorkflow={handleViewWorkflow}
                             isPinned={colIsPinned}
                             onPinToggle={userPermissions.canEdit ? handlePinToggle : undefined}

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

@@ -333,22 +333,28 @@ describe('Memory virtual table', () => {
     expect(result.hasMore).toBe(true)
   })
 
-  it('rejects one transcript that cannot fit in a bounded query response', async () => {
-    queueTableRows(schemaMock.memory, [
-      {
-        id: 'memory-1',
-        key: 'conversation-1',
-        createdAt: CREATED_AT,
-        updatedAt: UPDATED_AT,
-        data: [{ role: 'user', content: 'oversized' }],
-        messageCount: 1,
-        rowBytes: 5 * 1024 * 1024 + 1,
-      },
-    ])
+  it('still returns one transcript that alone exceeds the query byte budget', async () => {
+    const oversized = {
+      id: 'memory-1',
+      key: 'conversation-1',
+      createdAt: CREATED_AT,
+      updatedAt: UPDATED_AT,
+      data: [{ role: 'user', content: 'oversized' }],
+      messageCount: 1,
+      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('exceeds the 5MB query response limit')
+    const result = await queryMemoryTableRows({
+      workspaceId: 'workspace-1',
+      limit: 1000,
+      includeTotal: false,
+    })
+
+    expect(result.rows).toHaveLength(1)
+    expect(result.rows[0]?.id).toBe(oversized.id)
+    expect(result.hasMore).toBe(false)
   })
 
   it('finds matching cells in one storage query and preserves filtered sort ordinals', async () => {

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

@@ -210,12 +210,12 @@ export async function queryMemoryTableRows({
     if (!Number.isFinite(rowBytes) || rowBytes < 0) {
       throw new TableQueryValidationError('Memory table returned an invalid row size')
     }
-    if (selectedCandidates.length === 0 && rowBytes > pageByteBudget) {
-      throw new TableQueryValidationError(
-        `Memory transcript exceeds the ${Math.floor(pageByteBudget / (1024 * 1024))}MB query response limit`,
-        'TABLE_QUERY_RESULT_TOO_LARGE'
-      )
-    }
+    // 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 (selectedCandidates.length > 0 && selectedBytes + rowBytes > pageByteBudget) {
       hasMore = true
       break