fix(table): address review — parallel dispatch counts, unfiltered rowCount

- countActiveRunCells: run the per-dispatch COUNT queries + the sidecar count
  in parallel instead of serially (one round-trip per dispatch).
- Optimistic Run-all estimate now reads the table definition's maintained,
  unfiltered rowCount (detail cache) instead of the rows query's filter-scoped
  totalCount — the dispatcher runs every row regardless of the active filter.

Author: TheodoreSpeaks

apps/sim/hooks/queries/tables.ts

@@ -234,22 +234,16 @@ function countNewlyInFlight(before: RowExecutions, after: RowExecutions): number
   return n
 }
 
-/** First-page `totalCount` from the rows infinite-query cache (or `null` when
- *  rows haven't loaded yet). Lets a Run-all estimate the full-table cell count
- *  even though only a page of rows is in memory. */
-function readTotalRowCount(
+/** The table's maintained, unfiltered `rowCount` from the detail cache (or
+ *  `null` when the detail hasn't loaded). This is the right scope for a Run-all
+ *  estimate: the dispatcher runs every row regardless of the active view
+ *  filter, whereas the rows query's `totalCount` is filter-scoped. */
+function readTableRowCount(
   queryClient: ReturnType<typeof useQueryClient>,
   tableId: string
 ): number | null {
-  const entries = queryClient.getQueriesData<InfiniteData<TableRowsResponse, number>>({
-    queryKey: tableKeys.rowsRoot(tableId),
-    exact: false,
-  })
-  for (const [, data] of entries) {
-    const tc = data?.pages?.[0]?.totalCount
-    if (typeof tc === 'number') return tc
-  }
-  return null
+  const def = queryClient.getQueryData<TableDefinition>(tableKeys.detail(tableId))
+  return typeof def?.rowCount === 'number' ? def.rowCount : null
 }
 
 /** Optimistically reflect a run on the "X running" badge + per-row gutter Stop
@@ -1467,7 +1461,7 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
       // Run-all that's the table's totalCount; for a scoped run, the rowIds.
       const scopeRowCount = targetRowIds
         ? targetRowIds.size
-        : (readTotalRowCount(queryClient, tableId) ?? Object.keys(stampedByRow).length)
+        : (readTableRowCount(queryClient, tableId) ?? Object.keys(stampedByRow).length)
       const cellCountDelta = scopeRowCount * targetGroupIds.size
       const bumped = bumpRunState(queryClient, tableId, stampedByRow, cellCountDelta)
       return { snapshots, runStateSnapshot: bumped?.snapshot, didBumpRunState: bumped !== null }

apps/sim/lib/table/dispatcher.ts

@@ -208,13 +208,11 @@ export async function countActiveRunCells(
   dispatches?: DispatchRow[]
 ): Promise<{ total: number; byRowId: Record<string, number> }> {
   const active = dispatches ?? (await listActiveDispatches(tableId))
-  const sidecar = await countRunningCells(tableId)
-  if (active.length === 0) return sidecar
+  if (active.length === 0) return countRunningCells(tableId)
 
-  let total = 0
-  for (const d of active) {
+  const countRowsAhead = async (d: DispatchRow): Promise<number> => {
     const groupCount = d.scope.groupIds.length
-    if (groupCount === 0) continue
+    if (groupCount === 0) return 0
     const filters = [eq(userTableRows.tableId, tableId), gt(userTableRows.position, d.cursor)]
     if (d.scope.rowIds && d.scope.rowIds.length > 0) {
       filters.push(inArray(userTableRows.id, d.scope.rowIds))
@@ -223,8 +221,15 @@ export async function countActiveRunCells(
       .select({ rowsAhead: sql<number>`count(*)::int` })
       .from(userTableRows)
       .where(and(...filters))
-    total += (row?.rowsAhead ?? 0) * groupCount
+    return (row?.rowsAhead ?? 0) * groupCount
   }
+
+  // One round-trip per dispatch + the sidecar count, all in parallel.
+  const [sidecar, perDispatch] = await Promise.all([
+    countRunningCells(tableId),
+    Promise.all(active.map(countRowsAhead)),
+  ])
+  const total = perDispatch.reduce((sum, n) => sum + n, 0)
   return { total, byRowId: sidecar.byRowId }
 }