fix for when images are separated by empty lines

refactor to reduce duplication:
Extract RenderParagraphWithFlowRow
Extract collectConsecutiveImageParagraphs

amethyst/src/main/java/com/vitorpamplona/amethyst/ui/components/RichTextViewer.kt

@@ -329,27 +329,13 @@ fun RenderRegularWithGallery(
 
             if (isImageOnlyParagraph && paragraph.words.isNotEmpty()) {
                 // Collect consecutive image-only paragraphs
-                val imageParagraphs = mutableListOf<ParagraphState>()
+                val (imageParagraphs, totalProcessedCount) = collectConsecutiveImageParagraphs(state.paragraphs, i)
-                var j = i
-                while (j < state.paragraphs.size) {
-                    val currentParagraph = state.paragraphs[j]
-                    val isCurrentImageOnly =
-                        currentParagraph.words.all { word ->
-                            word is ImageSegment || word is Base64Segment
-                        }
-                    if (isCurrentImageOnly && currentParagraph.words.isNotEmpty()) {
-                        imageParagraphs.add(currentParagraph)
-                        j++
-                    } else {
-                        break
-                    }
-                }
 
                 // Combine all image words from consecutive paragraphs
                 val allImageWords = imageParagraphs.flatMap { it.words }.toImmutableList()
 
                 if (allImageWords.size > 1) {
-                    // Multiple images - render as gallery
+                    // Multiple images - render as gallery (no FlowRow wrapper needed)
                     RenderWordsWithImageGallery(
                         allImageWords,
                         state,
@@ -361,6 +347,51 @@ fun RenderRegularWithGallery(
                     )
                 } else {
                     // Single image - render normally
+                    RenderParagraphWithFlowRow(
+                        paragraph,
+                        paragraph.words.toImmutableList(),
+                        spaceWidth,
+                        state,
+                        backgroundColor,
+                        quotesLeft,
+                        callbackUri,
+                        accountViewModel,
+                        nav,
+                    )
+                }
+
+                i += totalProcessedCount // Skip processed paragraphs (including empty ones)
+            } else {
+                // Non-image paragraph - render normally
+                RenderParagraphWithFlowRow(
+                    paragraph,
+                    paragraph.words.toImmutableList(),
+                    spaceWidth,
+                    state,
+                    backgroundColor,
+                    quotesLeft,
+                    callbackUri,
+                    accountViewModel,
+                    nav,
+                )
+                i++
+            }
+        }
+    }
+}
+
+@Composable
+private fun RenderParagraphWithFlowRow(
+    paragraph: ParagraphState,
+    words: ImmutableList<Segment>,
+    spaceWidth: Dp,
+    state: RichTextViewerState,
+    backgroundColor: MutableState<Color>,
+    quotesLeft: Int,
+    callbackUri: String?,
+    accountViewModel: AccountViewModel,
+    nav: INav,
+) {
     CompositionLocalProvider(
         LocalLayoutDirection provides
             if (paragraph.isRTL) {
@@ -371,11 +402,10 @@ fun RenderRegularWithGallery(
         LocalTextStyle provides LocalTextStyle.current,
     ) {
         FlowRow(
-                            modifier = Modifier.align(if (paragraph.isRTL) Alignment.End else Alignment.Start),
             horizontalArrangement = Arrangement.spacedBy(spaceWidth),
         ) {
             RenderWordsWithImageGallery(
-                                paragraph.words.toImmutableList(),
+                words,
                 state,
                 backgroundColor,
                 quotesLeft,
@@ -387,37 +417,43 @@ fun RenderRegularWithGallery(
     }
 }
 
-                i = j // Skip processed paragraphs
+private fun collectConsecutiveImageParagraphs(
-            } else {
+    paragraphs: ImmutableList<ParagraphState>,
-                // Non-image paragraph - render normally
+    startIndex: Int,
-                CompositionLocalProvider(
+): Pair<List<ParagraphState>, Int> {
-                    LocalLayoutDirection provides
+    val imageParagraphs = mutableListOf<ParagraphState>()
-                        if (paragraph.isRTL) {
+    var j = startIndex
-                            LayoutDirection.Rtl
+    while (j < paragraphs.size) {
-                        } else {
+        val currentParagraph = paragraphs[j]
-                            LayoutDirection.Ltr
+        val isEmpty =
-                        },
+            currentParagraph.words.isEmpty() ||
-                    LocalTextStyle provides LocalTextStyle.current,
+                (
-                ) {
+                    currentParagraph.words.size == 1 &&
-                    FlowRow(
+                        currentParagraph.words.first() is RegularTextSegment &&
-                        modifier = Modifier.align(if (paragraph.isRTL) Alignment.End else Alignment.Start),
+                        currentParagraph.words
-                        horizontalArrangement = Arrangement.spacedBy(spaceWidth),
+                            .first()
-                    ) {
+                            .segmentText
-                        RenderWordsWithImageGallery(
+                            .isBlank()
-                            paragraph.words.toImmutableList(),
-                            state,
-                            backgroundColor,
-                            quotesLeft,
-                            callbackUri,
-                            accountViewModel,
-                            nav,
                 )
+
+        val isCurrentImageOnly =
+            currentParagraph.words.isNotEmpty() &&
+                currentParagraph.words.all { word ->
+                    word is ImageSegment || word is Base64Segment
+                }
+
+        if (isCurrentImageOnly) {
+            imageParagraphs.add(currentParagraph)
+            j++
+        } else if (isEmpty) {
+            // Skip empty paragraphs but continue looking for consecutive images
+            j++
+        } else {
+            // Hit a non-empty, non-image paragraph - stop collecting
+            break
         }
     }
-                i++
+    return Pair(imageParagraphs, j - startIndex) // Return paragraphs and total processed count
-            }
-        }
-    }
 }
 
 @OptIn(ExperimentalLayoutApi::class)