From 2726b793e58aee4b301d91ba1e5017aac695fa89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Morten=20D=C3=A6hli=20Aslesen?= <morten@lagabote.no>
Date: Mon, 28 Sep 2026 20:14:44 +0200
Subject: [PATCH 1/4] fix(html): keep non-li children of lists in document
 order
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Children of <ul>/<ol> other than <li> are invalid HTML, but common in CMS
output. They were dropped, or added directly to the list group in the case
of a nested list, which broke the numbering of the following items.

Content before the first <li> is now emitted before the list, and any other
non-<li> child is nested under the preceding list item, as browsers render it.

Resolves #4424

Signed-off-by: Morten Dæhli Aslesen <morten@lagabote.no>
---
 docling/backend/html_backend.py | 46 +++++++++++++++++++++++++--------
 tests/test_backend_html.py      | 39 ++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+), 11 deletions(-)

diff --git a/docling/backend/html_backend.py b/docling/backend/html_backend.py
index e123f6c107..ecc9a4d2d5 100644
--- a/docling/backend/html_backend.py
+++ b/docling/backend/html_backend.py
@@ -17,6 +17,7 @@
 from email.parser import BytesParser
 from functools import cache
 from io import BytesIO
+from itertools import takewhile
 from pathlib import Path, PureWindowsPath
 from typing import Any, Final, Iterator, Literal, Optional, Union, cast
 from urllib.parse import unquote, urljoin, urlparse
@@ -2052,7 +2053,7 @@ def parse_table_data(
                     doc.add_table_cell(table_item=docling_table, cell=simple_cell)
         return data
 
-    def _walk(self, element: Tag, doc: DoclingDocument) -> list[RefItem]:  # noqa: C901
+    def _walk(self, element: Tag, doc: DoclingDocument) -> list[RefItem]:
         """Parse an XML tag by recursively walking its content.
 
         While walking, the method buffers inline text across tags like <b> or <span>,
@@ -2062,6 +2063,18 @@ def _walk(self, element: Tag, doc: DoclingDocument) -> list[RefItem]:  # noqa: C
             element: The XML tag to parse.
             doc: The Docling document to be updated with the parsed content.
         """
+        return self._walk_nodes(element, element.contents, doc)
+
+    def _walk_nodes(  # noqa: C901
+        self, element: Tag, nodes: list[PageElement], doc: DoclingDocument
+    ) -> list[RefItem]:
+        """Parse some children of an XML tag, like `_walk` does for all of them.
+
+        Args:
+            element: The XML tag whose children are parsed.
+            nodes: The children of `element` to parse.
+            doc: The Docling document to be updated with the parsed content.
+        """
         added_refs: list[RefItem] = []
         buffer: AnnotatedTextList = AnnotatedTextList()
 
@@ -2128,7 +2141,7 @@ def _flush_buffer() -> None:
                     if inline_ref is not None:
                         added_refs.append(inline_ref)
 
-        for node in element.contents:
+        for node in nodes:
             if isinstance(node, Tag):
                 name = node.name.lower()
                 if form_field := self._consume_form_field_for_tag(node):
@@ -2920,6 +2933,19 @@ def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
         else:
             name = "list"
 
+        # Children of <ul>/<ol> other than <li> are invalid HTML, but common in CMS
+        # output. Browsers render them in place: those before the first <li> precede
+        # the list, the others are nested under the preceding list item.
+        leading: list[PageElement] = []
+        if not is_description:
+            leading = list(
+                takewhile(
+                    lambda node: not (isinstance(node, Tag) and node.name == "li"),
+                    tag.contents,
+                )
+            )
+            self._walk_nodes(tag, leading, doc)
+
         # Create the list container
         list_group = doc.add_list_group(
             name=name,
@@ -3006,15 +3032,12 @@ def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
             self.level -= 1
             return list_group.get_ref()
 
-        # For each top-level <li> in this list (ul/ol)
-        for li in tag.find_all({"li", "ul", "ol"}, recursive=False):
-            if not isinstance(li, Tag):
-                continue
-
-            # sub-list items should be indented under main list items, but temporarily
-            # addressing invalid HTML (docling-core/issues/357)
-            if li.name in {"ul", "ol"}:
-                self._handle_block(li, doc)
+        # For each child of this list (ul/ol) after the leading content
+        prev_item: Optional[RefItem] = None
+        for li in tag.contents[len(leading) :]:
+            if not (isinstance(li, Tag) and li.name == "li"):
+                with self._use_list_item_context(prev_item):
+                    self._walk_nodes(tag, [li], doc)
 
             else:
                 # 1) determine the marker using the counter
@@ -3063,6 +3086,7 @@ def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
                 # Increment counter only when a list item is actually added
                 if list_item:
                     list_item_counter += 1
+                    prev_item = list_item
 
                 if list_item or inputs_in_li or custom_checkboxes_in_li:
                     if task_list_inputs:
diff --git a/tests/test_backend_html.py b/tests/test_backend_html.py
index c789dec204..c61b23b47b 100644
--- a/tests/test_backend_html.py
+++ b/tests/test_backend_html.py
@@ -543,6 +543,45 @@ def test_nested_table_in_list_item():
     assert md.count("Fault type.") == 1
 
 
+def test_list_non_li_children():
+    """Regression for #4424: children of <ul>/<ol> other than <li> are kept in
+    document order. They are invalid HTML, but common in CMS output.
+
+    Previously <p> and <table> children were dropped, and a <ol> child was added
+    directly to the parent list group, which broke the numbering.
+    """
+    html = (
+        b"<html><body><ol>"
+        b"<p>Intro.</p>"
+        b"<li>First.</li>"
+        b"<p>About the first.</p>"
+        b"<li>Second.</li>"
+        b"<table><tbody><tr><td>A</td><td>B</td></tr></tbody></table>"
+        b"<ol><li>Nested.</li></ol>"
+        b"<li>Third.</li>"
+        b"</ol></body></html>"
+    )
+    in_doc = InputDocument(
+        path_or_stream=BytesIO(html),
+        format=InputFormat.HTML,
+        backend=HTMLDocumentBackend,
+        filename="test",
+    )
+    backend = HTMLDocumentBackend(in_doc=in_doc, path_or_stream=BytesIO(html))
+    doc: DoclingDocument = backend.convert()
+    texts = {item.text: item for item in doc.texts}
+
+    # Content before the first <li> precedes the list.
+    assert texts["Intro."].parent.resolve(doc) == doc.body
+    # Other content is nested under the preceding list item.
+    assert texts["About the first."].parent.cref == texts["First."].self_ref
+    assert doc.tables[0].parent.cref == texts["Second."].self_ref
+    nested_list = texts["Nested."].parent.resolve(doc)
+    assert nested_list.parent.cref == texts["Second."].self_ref
+
+    assert "3. Third." in doc.export_to_markdown()
+
+
 @pytest.mark.parametrize(
     "inner",
     [

From acd0576dd3c5895aecbc1347e5f900a16bfd3ae6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Morten=20D=C3=A6hli=20Aslesen?= <morten@lagabote.no>
Date: Wed, 30 Sep 2026 07:42:47 +0200
Subject: [PATCH 2/4] fix(html): close the list at non-li children and continue
 the numbering after them
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow the convention of the DOCX backend (#3896) for the content between
list items: the list group is closed, the content is emitted at the parent
level, and the following items open a new list group whose numbering
continues from the running counter. Nested lists stay sub-lists of the
preceding item.

Signed-off-by: Morten Dæhli Aslesen <morten@lagabote.no>
---
 docling/backend/html_backend.py | 69 +++++++++++++++++++++++++--------
 tests/test_backend_html.py      | 27 +++++++++----
 2 files changed, 71 insertions(+), 25 deletions(-)

diff --git a/docling/backend/html_backend.py b/docling/backend/html_backend.py
index ecc9a4d2d5..9b2ddfdd09 100644
--- a/docling/backend/html_backend.py
+++ b/docling/backend/html_backend.py
@@ -40,6 +40,7 @@
     GraphLinkLabel,
     GroupItem,
     GroupLabel,
+    ListGroup,
     PictureClassificationLabel,
     PictureClassificationMetaField,
     PictureClassificationPrediction,
@@ -2916,7 +2917,9 @@ def _description_list_children(dl: Tag) -> list[PageElement]:
                 children.append(child)
         return children
 
-    def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
+    def _handle_list(  # noqa: C901
+        self, tag: Tag, doc: DoclingDocument
+    ) -> RefItem:
         tag_name = tag.name.lower()
         start: Optional[int] = None
         name: str = ""
@@ -2934,8 +2937,10 @@ def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
             name = "list"
 
         # Children of <ul>/<ol> other than <li> are invalid HTML, but common in CMS
-        # output. Browsers render them in place: those before the first <li> precede
-        # the list, the others are nested under the preceding list item.
+        # output. Those before the first <li> precede the list. The others interrupt
+        # it, like the interleaved blocks of the DOCX backend (#3896): the list is
+        # closed, the content is emitted at the parent level, and the following items
+        # open a new list group that continues the numbering.
         leading: list[PageElement] = []
         if not is_description:
             leading = list(
@@ -2947,16 +2952,24 @@ def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
             self._walk_nodes(tag, leading, doc)
 
         # Create the list container
-        list_group = doc.add_list_group(
-            name=name,
-            parent=self.parents[self.level],
-            content_layer=self.content_layer,
-        )
-        self.parents[self.level + 1] = list_group
-        self.ctx.list_ordered_flag_by_ref[list_group.self_ref] = is_ordered
-        if is_ordered and start is not None:
-            self.ctx.list_start_by_ref[list_group.self_ref] = start
-        self.level += 1
+        def open_list_group(group_start: Optional[int]) -> ListGroup:
+            group_name = name
+            if is_ordered and group_start is not None:
+                group_name = f"ordered list start {group_start}"
+            group = doc.add_list_group(
+                name=group_name,
+                parent=self.parents[self.level],
+                content_layer=self.content_layer,
+            )
+            self.parents[self.level + 1] = group
+            self.ctx.list_ordered_flag_by_ref[group.self_ref] = is_ordered
+            if is_ordered and group_start is not None:
+                self.ctx.list_start_by_ref[group.self_ref] = group_start
+            self.level += 1
+            return group
+
+        list_group: Optional[ListGroup] = open_list_group(start)
+        first_group = list_group
 
         # Track the number of list items added (not all children)
         list_item_counter: int = 0
@@ -3035,11 +3048,32 @@ def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
         # For each child of this list (ul/ol) after the leading content
         prev_item: Optional[RefItem] = None
         for li in tag.contents[len(leading) :]:
+            if isinstance(li, NavigableString) and (
+                isinstance(li, PreformattedString) or not li.strip()
+            ):
+                continue
+
             if not (isinstance(li, Tag) and li.name == "li"):
-                with self._use_list_item_context(prev_item):
+                if isinstance(li, Tag) and li.name in {"ul", "ol"} and prev_item:
+                    # A nested list is a sub-list of the preceding list item
+                    with self._use_list_item_context(prev_item):
+                        self._walk_nodes(tag, [li], doc)
+                else:
+                    if list_group is not None:
+                        self.parents[self.level + 1] = None
+                        self.level -= 1
+                        list_group = None
                     self._walk_nodes(tag, [li], doc)
+                    prev_item = None
 
             else:
+                if list_group is None:
+                    if is_ordered and start is None:
+                        start = 1
+                    list_group = open_list_group(
+                        start + list_item_counter if start is not None else None
+                    )
+
                 # 1) determine the marker using the counter
                 marker: str = (
                     f"{start + list_item_counter}."
@@ -3118,9 +3152,10 @@ def _handle_list(self, tag: Tag, doc: DoclingDocument) -> RefItem:
                             if not has_list_ancestor:
                                 self._handle_block(sublist, doc)
 
-        self.parents[self.level + 1] = None
-        self.level -= 1
-        return list_group.get_ref()
+        if list_group is not None:
+            self.parents[self.level + 1] = None
+            self.level -= 1
+        return first_group.get_ref()
 
     @staticmethod
     def get_html_table_row_col(tag: Tag) -> tuple[int, int]:
diff --git a/tests/test_backend_html.py b/tests/test_backend_html.py
index c61b23b47b..7e04100433 100644
--- a/tests/test_backend_html.py
+++ b/tests/test_backend_html.py
@@ -13,7 +13,12 @@
 import pytest
 import requests
 from bs4 import BeautifulSoup
-from docling_core.types.doc import DocItemLabel, PictureItem, RichTableCell
+from docling_core.types.doc import (
+    DocItemLabel,
+    GroupLabel,
+    PictureItem,
+    RichTableCell,
+)
 from docling_core.types.doc.document import ContentLayer
 from pydantic import AnyUrl, ValidationError
 
@@ -556,8 +561,8 @@ def test_list_non_li_children():
         b"<li>First.</li>"
         b"<p>About the first.</p>"
         b"<li>Second.</li>"
-        b"<table><tbody><tr><td>A</td><td>B</td></tr></tbody></table>"
         b"<ol><li>Nested.</li></ol>"
+        b"<table><tbody><tr><td>A</td><td>B</td></tr></tbody></table>"
         b"<li>Third.</li>"
         b"</ol></body></html>"
     )
@@ -571,14 +576,20 @@ def test_list_non_li_children():
     doc: DoclingDocument = backend.convert()
     texts = {item.text: item for item in doc.texts}
 
-    # Content before the first <li> precedes the list.
-    assert texts["Intro."].parent.resolve(doc) == doc.body
-    # Other content is nested under the preceding list item.
-    assert texts["About the first."].parent.cref == texts["First."].self_ref
-    assert doc.tables[0].parent.cref == texts["Second."].self_ref
+    # Content before the first <li> precedes the list. Any other content closes
+    # the list and is emitted at the parent level, like in the DOCX backend.
+    assert [child.resolve(doc).label for child in doc.body.children] == [
+        DocItemLabel.TEXT,
+        GroupLabel.LIST,
+        DocItemLabel.TEXT,
+        GroupLabel.LIST,
+        DocItemLabel.TABLE,
+        GroupLabel.LIST,
+    ]
+    # A nested list stays a sub-list of the preceding list item.
     nested_list = texts["Nested."].parent.resolve(doc)
     assert nested_list.parent.cref == texts["Second."].self_ref
-
+    # The list items that follow an interruption continue the numbering.
     assert "3. Third." in doc.export_to_markdown()
 
 

From ab68818dddb0fe63006dfbcd2b9046343d9787fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Morten=20D=C3=A6hli=20Aslesen?= <morten@lagabote.no>
Date: Wed, 30 Sep 2026 11:44:20 +0200
Subject: [PATCH 3/4] fix(html): keep the content around a split list in its
 container
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

_handle_list returns every item it adds at the current level, so the content
emitted around a split list stays in a table cell. A child that adds nothing,
like a <br>, no longer closes the list.

Signed-off-by: Morten Dæhli Aslesen <morten@lagabote.no>
---
 docling/backend/html_backend.py | 26 +++++++++++++++++---------
 tests/test_backend_html.py      | 32 ++++++++++++++++++++++++++++++--
 2 files changed, 47 insertions(+), 11 deletions(-)

diff --git a/docling/backend/html_backend.py b/docling/backend/html_backend.py
index 9b2ddfdd09..57db701776 100644
--- a/docling/backend/html_backend.py
+++ b/docling/backend/html_backend.py
@@ -2919,7 +2919,9 @@ def _description_list_children(dl: Tag) -> list[PageElement]:
 
     def _handle_list(  # noqa: C901
         self, tag: Tag, doc: DoclingDocument
-    ) -> RefItem:
+    ) -> list[RefItem]:
+        """Parse a list tag and return the items added at the current level."""
+        added_refs: list[RefItem] = []
         tag_name = tag.name.lower()
         start: Optional[int] = None
         name: str = ""
@@ -2949,7 +2951,7 @@ def _handle_list(  # noqa: C901
                     tag.contents,
                 )
             )
-            self._walk_nodes(tag, leading, doc)
+            added_refs.extend(self._walk_nodes(tag, leading, doc))
 
         # Create the list container
         def open_list_group(group_start: Optional[int]) -> ListGroup:
@@ -2961,6 +2963,7 @@ def open_list_group(group_start: Optional[int]) -> ListGroup:
                 parent=self.parents[self.level],
                 content_layer=self.content_layer,
             )
+            added_refs.append(group.get_ref())
             self.parents[self.level + 1] = group
             self.ctx.list_ordered_flag_by_ref[group.self_ref] = is_ordered
             if is_ordered and group_start is not None:
@@ -2969,7 +2972,6 @@ def open_list_group(group_start: Optional[int]) -> ListGroup:
             return group
 
         list_group: Optional[ListGroup] = open_list_group(start)
-        first_group = list_group
 
         # Track the number of list items added (not all children)
         list_item_counter: int = 0
@@ -3043,7 +3045,7 @@ def open_list_group(group_start: Optional[int]) -> ListGroup:
 
             self.parents[self.level + 1] = None
             self.level -= 1
-            return list_group.get_ref()
+            return added_refs
 
         # For each child of this list (ul/ol) after the leading content
         prev_item: Optional[RefItem] = None
@@ -3062,9 +3064,16 @@ def open_list_group(group_start: Optional[int]) -> ListGroup:
                     if list_group is not None:
                         self.parents[self.level + 1] = None
                         self.level -= 1
+                    parent = self.parents[self.level] or doc.body
+                    n_children = len(parent.children)
+                    added_refs.extend(self._walk_nodes(tag, [li], doc))
+                    if list_group is not None and len(parent.children) == n_children:
+                        # Nothing was added, e.g. a <br>: the list stays open
+                        self.parents[self.level + 1] = list_group
+                        self.level += 1
+                    else:
                         list_group = None
-                    self._walk_nodes(tag, [li], doc)
-                    prev_item = None
+                        prev_item = None
 
             else:
                 if list_group is None:
@@ -3155,7 +3164,7 @@ def open_list_group(group_start: Optional[int]) -> ListGroup:
         if list_group is not None:
             self.parents[self.level + 1] = None
             self.level -= 1
-        return first_group.get_ref()
+        return added_refs
 
     @staticmethod
     def get_html_table_row_col(tag: Tag) -> tuple[int, int]:
@@ -3230,8 +3239,7 @@ def _handle_block(self, tag: Tag, doc: DoclingDocument) -> list[RefItem]:  # noq
             added_refs.extend(heading_refs)
 
         elif tag_name in {"ul", "ol", "dl"}:
-            list_ref = self._handle_list(tag, doc)
-            added_refs.append(list_ref)
+            added_refs.extend(self._handle_list(tag, doc))
 
         elif tag_name in {"p", "address", "summary"}:
             text_list = self._extract_text_and_hyperlink_recursively(
diff --git a/tests/test_backend_html.py b/tests/test_backend_html.py
index 7e04100433..f71aa1ce57 100644
--- a/tests/test_backend_html.py
+++ b/tests/test_backend_html.py
@@ -560,7 +560,7 @@ def test_list_non_li_children():
         b"<p>Intro.</p>"
         b"<li>First.</li>"
         b"<p>About the first.</p>"
-        b"<li>Second.</li>"
+        b"<li>Second.</li><br>"
         b"<ol><li>Nested.</li></ol>"
         b"<table><tbody><tr><td>A</td><td>B</td></tr></tbody></table>"
         b"<li>Third.</li>"
@@ -577,7 +577,8 @@ def test_list_non_li_children():
     texts = {item.text: item for item in doc.texts}
 
     # Content before the first <li> precedes the list. Any other content closes
-    # the list and is emitted at the parent level, like in the DOCX backend.
+    # the list and is emitted at the parent level, like in the DOCX backend. A
+    # <br> adds nothing and does not close the list.
     assert [child.resolve(doc).label for child in doc.body.children] == [
         DocItemLabel.TEXT,
         GroupLabel.LIST,
@@ -593,6 +594,33 @@ def test_list_non_li_children():
     assert "3. Third." in doc.export_to_markdown()
 
 
+def test_list_non_li_children_stay_in_table_cell():
+    """#4424: the content emitted around a split list stays in its table cell."""
+    html = (
+        b"<html><body><table><tbody><tr>"
+        b"<td><ul><li>First.</li><p>Between.</p><li>Second.</li></ul></td>"
+        b"</tr></tbody></table><p>After.</p></body></html>"
+    )
+    in_doc = InputDocument(
+        path_or_stream=BytesIO(html),
+        format=InputFormat.HTML,
+        backend=HTMLDocumentBackend,
+        filename="test",
+    )
+    backend = HTMLDocumentBackend(in_doc=in_doc, path_or_stream=BytesIO(html))
+    doc: DoclingDocument = backend.convert()
+    texts = {item.text: item for item in doc.texts}
+
+    cell_group = texts["Between."].parent.resolve(doc)
+    assert cell_group.parent.cref == doc.tables[0].self_ref
+    assert [child.resolve(doc).label for child in cell_group.children] == [
+        GroupLabel.LIST,
+        DocItemLabel.TEXT,
+        GroupLabel.LIST,
+    ]
+    assert texts["After."].parent.resolve(doc) == doc.body
+
+
 @pytest.mark.parametrize(
     "inner",
     [

From ccad85e8b07b443aac148f727d11d58078f407af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Morten=20D=C3=A6hli=20Aslesen?= <morten@lagabote.no>
Date: Sat, 3 Oct 2026 07:11:35 +0200
Subject: [PATCH 4/4] test(html): add a paragraph between list items to the
 ground truth
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A paragraph directly inside a <ul> is invalid HTML, but common in CMS output.
The example of #4424 shows the expected tree and Markdown export: the
paragraph closes the list, and the item that follows opens a new list.

Signed-off-by: Morten Dæhli Aslesen <morten@lagabote.no>
---
 .../html_nested_block_in_list_item.html.itxt  |   9 +-
 .../html_nested_block_in_list_item.html.json  | 111 +++++++++++++++++-
 .../html_nested_block_in_list_item.html.md    |  12 +-
 .../html_nested_block_in_list_item.html       |  11 ++
 4 files changed, 140 insertions(+), 3 deletions(-)

diff --git a/tests/data/html/groundtruth/html_nested_block_in_list_item.html.itxt b/tests/data/html/groundtruth/html_nested_block_in_list_item.html.itxt
index c35d2c394a..565671fb4b 100644
--- a/tests/data/html/groundtruth/html_nested_block_in_list_item.html.itxt
+++ b/tests/data/html/groundtruth/html_nested_block_in_list_item.html.itxt
@@ -30,4 +30,11 @@ item-0 at level 0: unspecified: group _root_
         item-29 at level 4: list_item: Step instruction text
           item-30 at level 5: list: group list
             item-31 at level 6: list_item: Nested detail 1
-            item-32 at level 6: list_item: Nested detail 2
\ No newline at end of file
+            item-32 at level 6: list_item: Nested detail 2
+    item-33 at level 2: section_header: Paragraph between list items
+      item-34 at level 3: list: group list
+        item-35 at level 4: list_item: First item
+      item-36 at level 3: text: A paragraph placed directly inside the list.
+      item-37 at level 3: list: group list
+        item-38 at level 4: list_item: Second item
+      item-39 at level 3: text: After.
\ No newline at end of file
diff --git a/tests/data/html/groundtruth/html_nested_block_in_list_item.html.json b/tests/data/html/groundtruth/html_nested_block_in_list_item.html.json
index 22b17473c1..fd6b6a6d00 100644
--- a/tests/data/html/groundtruth/html_nested_block_in_list_item.html.json
+++ b/tests/data/html/groundtruth/html_nested_block_in_list_item.html.json
@@ -4,7 +4,7 @@
   "name": "html_nested_block_in_list_item",
   "origin": {
     "mimetype": "text/html",
-    "binary_hash": 2267456859147812713,
+    "binary_hash": 2633762625787780656,
     "filename": "html_nested_block_in_list_item.html"
   },
   "furniture": {
@@ -40,6 +40,9 @@
         },
         {
           "$ref": "#/texts/17"
+        },
+        {
+          "$ref": "#/texts/21"
         }
       ],
       "content_layer": "body",
@@ -187,6 +190,34 @@
       "content_layer": "body",
       "name": "list",
       "label": "list"
+    },
+    {
+      "self_ref": "#/groups/9",
+      "parent": {
+        "$ref": "#/texts/21"
+      },
+      "children": [
+        {
+          "$ref": "#/texts/22"
+        }
+      ],
+      "content_layer": "body",
+      "name": "list",
+      "label": "list"
+    },
+    {
+      "self_ref": "#/groups/10",
+      "parent": {
+        "$ref": "#/texts/21"
+      },
+      "children": [
+        {
+          "$ref": "#/texts/24"
+        }
+      ],
+      "content_layer": "body",
+      "name": "list",
+      "label": "list"
     }
   ],
   "texts": [
@@ -517,6 +548,84 @@
       "text": "Nested detail 2",
       "enumerated": false,
       "marker": ""
+    },
+    {
+      "self_ref": "#/texts/21",
+      "parent": {
+        "$ref": "#/groups/0"
+      },
+      "children": [
+        {
+          "$ref": "#/groups/9"
+        },
+        {
+          "$ref": "#/texts/23"
+        },
+        {
+          "$ref": "#/groups/10"
+        },
+        {
+          "$ref": "#/texts/25"
+        }
+      ],
+      "content_layer": "body",
+      "label": "section_header",
+      "prov": [],
+      "orig": "Paragraph between list items",
+      "text": "Paragraph between list items",
+      "level": 1
+    },
+    {
+      "self_ref": "#/texts/22",
+      "parent": {
+        "$ref": "#/groups/9"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "list_item",
+      "prov": [],
+      "orig": "First item",
+      "text": "First item",
+      "enumerated": false,
+      "marker": ""
+    },
+    {
+      "self_ref": "#/texts/23",
+      "parent": {
+        "$ref": "#/texts/21"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "A paragraph placed directly inside the list.",
+      "text": "A paragraph placed directly inside the list."
+    },
+    {
+      "self_ref": "#/texts/24",
+      "parent": {
+        "$ref": "#/groups/10"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "list_item",
+      "prov": [],
+      "orig": "Second item",
+      "text": "Second item",
+      "enumerated": false,
+      "marker": ""
+    },
+    {
+      "self_ref": "#/texts/25",
+      "parent": {
+        "$ref": "#/texts/21"
+      },
+      "children": [],
+      "content_layer": "body",
+      "label": "text",
+      "prov": [],
+      "orig": "After.",
+      "text": "After."
     }
   ],
   "pictures": [
diff --git a/tests/data/html/groundtruth/html_nested_block_in_list_item.html.md b/tests/data/html/groundtruth/html_nested_block_in_list_item.html.md
index 041ff3c238..4bbf15f4ec 100644
--- a/tests/data/html/groundtruth/html_nested_block_in_list_item.html.md
+++ b/tests/data/html/groundtruth/html_nested_block_in_list_item.html.md
@@ -19,4 +19,14 @@
 
 - Step instruction text
     - Nested detail 1
-    - Nested detail 2
\ No newline at end of file
+    - Nested detail 2
+
+## Paragraph between list items
+
+- First item
+
+A paragraph placed directly inside the list.
+
+- Second item
+
+After.
\ No newline at end of file
diff --git a/tests/data/html/sources/html_nested_block_in_list_item.html b/tests/data/html/sources/html_nested_block_in_list_item.html
index 85d337ae38..580d0949f9 100644
--- a/tests/data/html/sources/html_nested_block_in_list_item.html
+++ b/tests/data/html/sources/html_nested_block_in_list_item.html
@@ -34,5 +34,16 @@ <h2>Nested list in divs</h2>
     </div>
   </li>
 </ul>
+
+<!-- Test case 4: Paragraph directly inside a list. This is not valid HTML, but it
+     is common in CMS output: the paragraph closes the list, and the items that
+     follow open a new list. -->
+<h2>Paragraph between list items</h2>
+<ul>
+  <li>First item</li>
+  <p>A paragraph placed directly inside the list.</p>
+  <li>Second item</li>
+</ul>
+<p>After.</p>
 </body>
 </html>
\ No newline at end of file