Function countActiveRunCells

apps/sim/lib/table/dispatcher.ts:273–308

(
  tableId: string,
  dispatches?: DispatchRow[]
)

 *  count when no dispatch is active (orphan stragglers). `byRowId` stays
 *  sidecar-based — the client overlay renders queued rows ahead of the cursor. */
export async function countActiveRunCells(
  tableId: string,
  dispatches?: DispatchRow[]
): Promise<{ total: number; byRowId: Record<string, number> }> {
  const active = dispatches ?? (await listActiveDispatches(tableId))
  if (active.length === 0) return countRunningCells(tableId)

  const countRowsAhead = async (d: DispatchRow): Promise<number> => {
    const groupCount = d.scope.groupIds.length
    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))
    }
    const [row] = await db
      .select({ rowsAhead: sql<number>`count(*)::int` })
      .from(userTableRows)
      .where(and(...filters))
    let rowsAhead = row?.rowsAhead ?? 0
    // A `rows` cap means at most `max - processed` more rows will run, even if
    // many more sit ahead of the cursor — clamp so the badge doesn't over-count.
    if (d.limit?.type === 'rows') {
      rowsAhead = Math.min(rowsAhead, Math.max(0, d.limit.max - d.processedCount))
    }
    return rowsAhead * groupCount
  }

  // Include pre-stamps so `byRowId` matches the live SSE count (which counts
  // `pending`); otherwise the badge flickers 20→0 on each refetch.
  const [sidecar, perDispatch] = await Promise.all([
    countRunningCells(tableId, { includeUnclaimedPreStamps: true }),
    Promise.all(active.map(countRowsAhead)),
  ])
  const total = perDispatch.reduce((sum, n) => sum + n, 0)
  return { total, byRowId: sidecar.byRowId }
}

export async function listActiveDispatches(tableId: string): Promise<DispatchRow[]> {
  const rows = await db