mkdocs2confluence 0.7.10__tar.gz → 0.7.12__tar.gz

{mkdocs2confluence-0.7.10/src/mkdocs2confluence.egg-info → mkdocs2confluence-0.7.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.7.10
+Version: 0.7.12
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.7.10 → mkdocs2confluence-0.7.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.7.10"
+version = "0.7.12"
 description = "Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{mkdocs2confluence-0.7.10 → mkdocs2confluence-0.7.12/src/mkdocs2confluence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.7.10
+Version: 0.7.12
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.7.10 → mkdocs2confluence-0.7.12}/src/mkdocs_to_confluence/emitter/xhtml.py

@@ -23,6 +23,7 @@ from urllib.parse import urlparse
 
 from mkdocs_to_confluence.ir.nodes import (
     AbbrevFootnoteNode,
+    AbbrevGlossaryBlock,
     Admonition,
     BlockQuote,
     BoldNode,
@@ -191,6 +192,8 @@ def _emit_node(node: IRNode) -> str:
         return _emit_front_matter(node)
     if isinstance(node, FootnoteBlock):
         return _emit_footnote_block(node)
+    if isinstance(node, AbbrevGlossaryBlock):
+        return _emit_abbrev_glossary_block(node)
     if isinstance(node, GridCards):
         return _emit_grid_cards(node)
     if isinstance(node, UnsupportedBlock):
@@ -557,17 +560,40 @@ def _emit_footnote_ref(node: FootnoteRef) -> str:
 
 
 def _emit_abbrev_footnote(node: AbbrevFootnoteNode) -> str:
-    """Abbreviation term + inline Confluence footnote macro with its definition."""
+    """Inline: ABBR + superscript anchor-link to the glossary entry."""
+    anchor = html.escape(f"abbr-{node.number}")
+    num = html.escape(str(node.number))
     term = html.escape(node.abbr)
-    defn = html.escape(node.definition)
     return (
         f"{term}"
-        f'<ac:structured-macro ac:name="footnote" ac:schema-version="1">'
-        f"<ac:rich-text-body><p>{defn}</p></ac:rich-text-body>"
-        f"</ac:structured-macro>"
+        f"<sup>"
+        f'<ac:link ac:anchor="{anchor}">'
+        f"<ac:plain-text-link-body><![CDATA[{num}]]></ac:plain-text-link-body>"
+        f"</ac:link>"
+        f"</sup>"
     )
 
 
+def _emit_abbrev_glossary_block(node: AbbrevGlossaryBlock) -> str:
+    """End-of-page abbreviations list with Confluence anchor targets."""
+    parts: list[str] = ["<hr />\n<h6>Abbreviations</h6>\n<ol>\n"]
+    for fn in node.footnoted:
+        anchor = html.escape(f"abbr-{fn.number}")
+        anchor_macro = (
+            f'<ac:structured-macro ac:name="anchor">'
+            f'<ac:parameter ac:name=""><![CDATA[{anchor}]]></ac:parameter>'
+            f"</ac:structured-macro>"
+        )
+        abbr = html.escape(fn.abbr)
+        defn = html.escape(fn.definition)
+        parts.append(f"<li>{anchor_macro}<strong>{abbr}</strong> — {defn}</li>\n")
+    for abbr, defn in node.extras:
+        # No anchor — these only appeared in headings/titles, no inline superscript links here.
+        parts.append(f"<li><strong>{html.escape(abbr)}</strong> — {html.escape(defn)}</li>\n")
+    parts.append("</ol>\n")
+    return "".join(parts)
+
+
 def _emit_footnote_block(node: FootnoteBlock) -> str:
     """Footnotes section: heading + ordered list with anchor targets."""
     items: list[str] = []

{mkdocs2confluence-0.7.10 → mkdocs2confluence-0.7.12}/src/mkdocs_to_confluence/ir/nodes.py

@@ -433,15 +433,33 @@ class FrontMatter(IRNode):
 
 @dataclass(frozen=True)
 class AbbrevFootnoteNode(IRNode):
-    """An abbreviation annotated with an inline Confluence footnote.
+    """Inline: abbreviated term with a superscript anchor-link to the glossary.
 
-    The emitter outputs the abbreviated term immediately followed by a
-    ``footnote`` macro containing the full definition.  Confluence collects
-    all footnote macros and renders their bodies at the bottom of the page.
+    The emitter renders ``ABBR<sup>[N]</sup>`` where ``[N]`` links to the
+    corresponding entry in the end-of-page :class:`AbbrevGlossaryBlock`.
     """
 
     abbr: str
     definition: str
+    number: int  # 1-based, assigned by the transform in order of first encounter
+
+
+@dataclass(frozen=True)
+class AbbrevGlossaryBlock(IRNode):
+    """End-of-page abbreviations reference block.
+
+    Rendered as a numbered list (with Confluence anchor targets for the
+    back-links) followed by an optional bullet list of abbreviations that
+    only appeared in headings or other non-expandable contexts.
+
+    Attributes:
+        footnoted: Abbreviations annotated inline, ordered by first encounter.
+        extras:    ``(abbr, definition)`` pairs for abbreviations that could
+                   not be annotated inline, sorted alphabetically.
+    """
+
+    footnoted: tuple[AbbrevFootnoteNode, ...]
+    extras: tuple[tuple[str, str], ...]
 
 
 # ── Footnotes ────────────────────────────────────────────────────────────────

{mkdocs2confluence-0.7.10 → mkdocs2confluence-0.7.12}/src/mkdocs_to_confluence/transforms/abbrevs.py

@@ -30,13 +30,13 @@ from dataclasses import replace
 
 from mkdocs_to_confluence.ir.nodes import (
     AbbrevFootnoteNode,
+    AbbrevGlossaryBlock,
     Admonition,
     BlockQuote,
     BoldNode,
     BulletList,
     ContentTabs,
     Expandable,
-    HorizontalRule,
     IRNode,
     ItalicNode,
     LinkNode,
@@ -60,13 +60,18 @@ class _State:
 
     def __init__(self, abbrevs: dict[str, str]) -> None:
         self.abbrevs = abbrevs
-        self.expanded: set[str] = set()
+        self._expanded_list: list[str] = []  # ordered by first encounter
+        self._expanded_set: set[str] = set()  # fast membership test
         # Pre-compile word-boundary patterns once.
         self._patterns: dict[str, re.Pattern[str]] = {
             abbr: re.compile(r"\b" + re.escape(abbr) + r"\b")
             for abbr in abbrevs
         }
 
+    @property
+    def expanded(self) -> set[str]:
+        return self._expanded_set
+
     def expand_to_nodes(self, text: str) -> tuple[IRNode, ...]:
         """Split *text* around the first unexpanded abbreviation.
 
@@ -75,7 +80,7 @@ class _State:
         """
         best: tuple[int, int, str] | None = None
         for abbr in self.abbrevs:
-            if abbr in self.expanded:
+            if abbr in self._expanded_set:
                 continue
             m = self._patterns[abbr].search(text)
             if m and (best is None or m.start() < best[0]):
@@ -85,11 +90,13 @@ class _State:
             return (TextNode(text),) if text else ()
 
         start, end, abbr = best
-        self.expanded.add(abbr)
+        self._expanded_list.append(abbr)
+        self._expanded_set.add(abbr)
+        number = len(self._expanded_list)  # 1-based
         nodes: list[IRNode] = []
         if text[:start]:
             nodes.append(TextNode(text[:start]))
-        nodes.append(AbbrevFootnoteNode(abbr=abbr, definition=self.abbrevs[abbr]))
+        nodes.append(AbbrevFootnoteNode(abbr=abbr, definition=self.abbrevs[abbr], number=number))
         nodes.extend(self.expand_to_nodes(text[end:]))
         return tuple(nodes)
 
@@ -197,21 +204,6 @@ def _find_mentioned(text: str, abbrevs: dict[str, str]) -> set[str]:
     }
 
 
-def _build_glossary_section(terms: dict[str, str]) -> tuple[IRNode, ...]:
-    """Return an HR + h6 ``Section`` listing abbreviations that could not be footnoted."""
-    items = tuple(
-        ListItem(children=(Paragraph(children=(TextNode(f"{abbr} — {defn}"),)),))
-        for abbr, defn in sorted(terms.items())
-    )
-    section = Section(
-        level=6,
-        anchor="glossary",
-        title=(TextNode("Glossary"),),
-        children=(BulletList(items=items),),
-    )
-    return (HorizontalRule(), section)
-
-
 # ── Public API ────────────────────────────────────────────────────────────────
 
 
@@ -229,15 +221,15 @@ def apply_abbreviations(
                     :func:`~mkdocs_to_confluence.preprocess.abbrevs.extract_abbreviations`.
         page_text:  The preprocessed page text (after stripping abbreviation
                     definition lines) used to detect which abbreviations are
-                    actually present on the page.  Used to determine which
-                    abbreviations need a glossary entry.
+                    actually present on the page.
 
     Returns:
-        Modified node tuple.  Abbreviations in body text are replaced with an
-        :class:`~mkdocs_to_confluence.ir.nodes.AbbrevFootnoteNode` on first
-        occurrence.  A ``Glossary`` section is appended only for abbreviations
-        that were detected in *page_text* but never footnoted (e.g. they only
-        appeared in headings or table headers).
+        Modified node tuple.  Abbreviations in body text receive an inline
+        superscript anchor-link (:class:`AbbrevFootnoteNode`).  An
+        :class:`AbbrevGlossaryBlock` is appended when any abbreviation was
+        mentioned on the page, listing all footnoted entries (with anchor
+        targets for the back-links) plus any abbreviations that only appeared
+        in headings or other non-expandable contexts.
     """
     if not abbrevs:
         return nodes
@@ -246,15 +238,17 @@ def apply_abbreviations(
     transformed = tuple(_transform_block(n, state) for n in nodes)
 
     mentioned = _find_mentioned(page_text, abbrevs)
-    # Only add a glossary entry for abbreviations that were never footnoted.
-    glossary_needed = {
-        abbr: abbrevs[abbr]
-        for abbr in mentioned
-        if abbr not in state.expanded
-    }
+    footnoted = tuple(
+        AbbrevFootnoteNode(abbr=abbr, definition=abbrevs[abbr], number=i + 1)
+        for i, abbr in enumerate(state._expanded_list)
+    )
+    extras = tuple(
+        (abbr, abbrevs[abbr])
+        for abbr in sorted(mentioned - state._expanded_set)
+    )
 
-    if glossary_needed:
-        transformed = transformed + _build_glossary_section(glossary_needed)
+    if footnoted or extras:
+        transformed = transformed + (AbbrevGlossaryBlock(footnoted=footnoted, extras=extras),)
 
     return transformed
 

{mkdocs2confluence-0.7.10 → mkdocs2confluence-0.7.12}/tests/test_abbrevs.py

@@ -4,11 +4,10 @@ from __future__ import annotations
 
 from mkdocs_to_confluence.ir.nodes import (
     AbbrevFootnoteNode,
+    AbbrevGlossaryBlock,
     Admonition,
     BoldNode,
-    BulletList,
     CodeBlock,
-    HorizontalRule,
     LinkNode,
     Paragraph,
     Section,
@@ -89,17 +88,22 @@ def test_expands_first_occurrence_as_footnote():
     para = result[0]
     assert isinstance(para, Paragraph)
     children = para.children
-    # Should be: TextNode("The ") + AbbrevFootnoteNode + TextNode(" platform handles IAM requests.")
+    # TextNode("The ") + AbbrevFootnoteNode + TextNode(" platform handles IAM requests.")
     assert len(children) == 3
-    assert isinstance(children[0], TextNode)
-    assert children[0].text == "The "
-    assert isinstance(children[1], AbbrevFootnoteNode)
-    assert children[1].abbr == "IAM"
-    assert children[1].definition == "Identity and Access Management"
+    assert isinstance(children[0], TextNode) and children[0].text == "The "
+    fn = children[1]
+    assert isinstance(fn, AbbrevFootnoteNode)
+    assert fn.abbr == "IAM"
+    assert fn.definition == "Identity and Access Management"
+    assert fn.number == 1
     # Second occurrence left as plain text
     assert isinstance(children[2], TextNode)
     assert "IAM requests." in children[2].text
-    assert "Identity and Access Management" not in children[2].text
+    # Glossary block appended
+    glossary = result[1]
+    assert isinstance(glossary, AbbrevGlossaryBlock)
+    assert glossary.footnoted[0].abbr == "IAM"
+    assert glossary.footnoted[0].number == 1
 
 
 def test_expands_multiple_different_abbrevs():
@@ -107,11 +111,12 @@ def test_expands_multiple_different_abbrevs():
     nodes = (_para("Use IAM and RBAC for access control."),)
     result = apply_abbreviations(nodes, abbrevs, page_text="Use IAM and RBAC for access control.")
     para = result[0]
-    assert isinstance(para, Paragraph)
     footnotes = [c for c in para.children if isinstance(c, AbbrevFootnoteNode)]
     abbrs = {fn.abbr for fn in footnotes}
     assert "IAM" in abbrs
     assert "RBAC" in abbrs
+    numbers = sorted(fn.number for fn in footnotes)
+    assert numbers == [1, 2]
 
 
 def test_no_expand_when_no_abbrevs():
@@ -122,65 +127,40 @@ def test_no_expand_when_no_abbrevs():
 
 def test_no_expand_in_section_heading():
     abbrevs = {"IAM": "Identity and Access Management"}
-    section = Section(
-        level=2,
-        anchor="iam",
-        title=(TextNode("IAM Platform"),),
-        children=(),
-    )
+    section = Section(level=2, anchor="iam", title=(TextNode("IAM Platform"),), children=())
     result = apply_abbreviations((section,), abbrevs, page_text="IAM Platform")
     heading_text = result[0].title[0].text  # type: ignore[union-attr]
-    assert heading_text == "IAM Platform"  # not expanded
+    assert heading_text == "IAM Platform"  # not annotated
 
 
-def test_glossary_appended_for_heading_only_abbrev():
+def test_glossary_block_appended_for_heading_only_abbrev():
     abbrevs = {"IAM": "Identity and Access Management"}
-    section = Section(
-        level=2,
-        anchor="iam",
-        title=(TextNode("IAM Platform"),),
-        children=(),
-    )
+    section = Section(level=2, anchor="iam", title=(TextNode("IAM Platform"),), children=())
     result = apply_abbreviations((section,), abbrevs, page_text="IAM Platform")
-    # IAM only in heading (unsafe) → no footnote → glossary fallback appended
-    assert len(result) == 3
-    assert isinstance(result[1], HorizontalRule)
-    glossary = result[2]
-    assert isinstance(glossary, Section)
-    assert glossary.anchor == "glossary"
-    assert glossary.level == 6
-    bullet_list = glossary.children[0]
-    assert isinstance(bullet_list, BulletList)
-    item_text = bullet_list.items[0].children[0].children[0].text  # type: ignore[union-attr]
-    assert "IAM" in item_text
-    assert "Identity and Access Management" in item_text
+    assert len(result) == 2
+    glossary = result[1]
+    assert isinstance(glossary, AbbrevGlossaryBlock)
+    assert len(glossary.footnoted) == 0
+    assert glossary.extras == (("IAM", "Identity and Access Management"),)
 
 
 def test_no_glossary_when_abbrev_footnoted_inline():
     abbrevs = {"IAM": "Identity and Access Management"}
     nodes = (_para("The IAM platform."),)
     result = apply_abbreviations(nodes, abbrevs, page_text="The IAM platform.")
-    # Footnoted inline → no glossary needed
-    assert len(result) == 1
-    assert isinstance(result[0], Paragraph)
+    assert len(result) == 2
+    assert isinstance(result[1], AbbrevGlossaryBlock)
+    assert len(result[1].extras) == 0
 
 
 def test_no_expand_in_table_header_cell():
     abbrevs = {"API": "Application Programming Interface"}
-    header = TableRow(cells=(
-        TableCell(children=(TextNode("API Endpoint"),), is_header=True),
-    ))
-    body = TableRow(cells=(
-        TableCell(children=(TextNode("The API docs"),), is_header=False),
-    ))
+    header = TableRow(cells=(TableCell(children=(TextNode("API Endpoint"),), is_header=True),))
+    body = TableRow(cells=(TableCell(children=(TextNode("The API docs"),), is_header=False),))
     table = Table(header=header, rows=(body,))
     result = apply_abbreviations((table,), abbrevs, page_text="API Endpoint The API docs")
-
-    # Header cell: not expanded
     header_text = result[0].header.cells[0].children[0].text  # type: ignore[union-attr]
     assert header_text == "API Endpoint"
-
-    # Body cell: first occurrence footnoted
     body_children = result[0].rows[0].cells[0].children  # type: ignore[union-attr]
     assert any(isinstance(c, AbbrevFootnoteNode) and c.abbr == "API" for c in body_children)
 
@@ -188,14 +168,11 @@ def test_no_expand_in_table_header_cell():
 def test_no_expand_in_admonition_title():
     abbrevs = {"TLS": "Transport Layer Security"}
     admonition = Admonition(
-        kind="note",
-        title="TLS Configuration",
+        kind="note", title="TLS Configuration",
         children=(_para("Use TLS for encryption."),),
     )
     result = apply_abbreviations((admonition,), abbrevs, page_text="TLS Configuration Use TLS for encryption.")
-    # Title is str, unchanged
     assert result[0].title == "TLS Configuration"  # type: ignore[union-attr]
-    # Body paragraph: TLS footnoted
     body_children = result[0].children[0].children  # type: ignore[union-attr]
     assert any(isinstance(c, AbbrevFootnoteNode) and c.abbr == "TLS" for c in body_children)
 
@@ -203,28 +180,21 @@ def test_no_expand_in_admonition_title():
 def test_no_expand_in_code_block():
     abbrevs = {"SQL": "Structured Query Language"}
     code = CodeBlock(code="SELECT * FROM SQL_table", language="sql")
-    nodes = (code,)
-    result = apply_abbreviations(nodes, abbrevs, page_text="SELECT * FROM SQL_table")
-    assert result[0].code == "SELECT * FROM SQL_table"
+    result = apply_abbreviations((code,), abbrevs, page_text="SELECT * FROM SQL_table")
+    assert result[0].code == "SELECT * FROM SQL_table"  # type: ignore[union-attr]
 
 
 def test_no_expand_in_link_text():
     abbrevs = {"CLI": "Command Line Interface"}
-    link = LinkNode(
-        href="https://example.com",
-        children=(TextNode("CLI tools"),),
-    )
-    para = Paragraph(children=(link,))
-    result = apply_abbreviations((para,), abbrevs, page_text="CLI tools")
-    link_text = result[0].children[0].children[0].text  # type: ignore[union-attr]
-    assert link_text == "CLI tools"  # not expanded inside link
+    link = LinkNode(href="https://example.com", children=(TextNode("CLI tools"),))
+    result = apply_abbreviations((Paragraph(children=(link,)),), abbrevs, page_text="CLI tools")
+    assert result[0].children[0].children[0].text == "CLI tools"  # type: ignore[union-attr]
 
 
 def test_expands_inside_bold():
     abbrevs = {"CI": "Continuous Integration"}
     bold = BoldNode(children=(TextNode("CI pipeline"),))
-    para = Paragraph(children=(bold,))
-    result = apply_abbreviations((para,), abbrevs, page_text="CI pipeline")
+    result = apply_abbreviations((Paragraph(children=(bold,)),), abbrevs, page_text="CI pipeline")
     bold_children = result[0].children[0].children  # type: ignore[union-attr]
     assert any(isinstance(c, AbbrevFootnoteNode) and c.abbr == "CI" for c in bold_children)
 
@@ -234,53 +204,33 @@ def test_word_boundary_not_partial_match():
     nodes = (_para("The RAPID response via API."),)
     result = apply_abbreviations(nodes, abbrevs, page_text="The RAPID response via API.")
     para = result[0]
-    assert isinstance(para, Paragraph)
-    # RAPID should be untouched; API should be footnoted
     all_text = "".join(c.text for c in para.children if isinstance(c, TextNode))
     assert "RAPID" in all_text
-    footnotes = [c for c in para.children if isinstance(c, AbbrevFootnoteNode)]
-    assert any(fn.abbr == "API" for fn in footnotes)
+    assert any(isinstance(c, AbbrevFootnoteNode) and c.abbr == "API" for c in para.children)
 
 
-def test_footnoted_abbrevs_not_in_glossary():
-    # Abbreviations expanded inline via footnote should NOT also appear in a glossary.
+def test_footnoted_abbrevs_not_in_extras():
     abbrevs = {"API": "Application Programming Interface", "IAM": "Identity and Access Management"}
     nodes = (_para("Use the API and IAM to authenticate."),)
-    result = apply_abbreviations(
-        nodes, abbrevs,
-        page_text="Use the API and IAM to authenticate."
-    )
-    # Both footnoted inline → no glossary
-    assert len(result) == 1
-    para = result[0]
-    assert isinstance(para, Paragraph)
-    footnotes = [c for c in para.children if isinstance(c, AbbrevFootnoteNode)]
-    assert {fn.abbr for fn in footnotes} == {"API", "IAM"}
+    result = apply_abbreviations(nodes, abbrevs, page_text="Use the API and IAM to authenticate.")
+    assert len(result) == 2
+    glossary = result[1]
+    assert isinstance(glossary, AbbrevGlossaryBlock)
+    assert {fn.abbr for fn in glossary.footnoted} == {"API", "IAM"}
+    assert len(glossary.extras) == 0
 
 
 def test_abbrev_not_in_text_produces_no_glossary():
     abbrevs = {"XYZ": "Some Definition"}
-    nodes = (_para("Nothing relevant here."),)
-    result = apply_abbreviations(nodes, abbrevs, page_text="Nothing relevant here.")
-    # XYZ never mentioned → no glossary
+    result = apply_abbreviations((_para("Nothing relevant here."),), abbrevs, page_text="Nothing relevant here.")
     assert len(result) == 1
 
 
-def test_glossary_entries_sorted_alphabetically():
+def test_extras_sorted_alphabetically():
     abbrevs = {"RBAC": "Role-Based Access Control", "IAM": "Identity and Access Management"}
-    # Both only in heading (unsafe), so both go to glossary
-    section = Section(
-        level=1,
-        anchor="overview",
-        title=(TextNode("IAM and RBAC Overview"),),
-        children=(),
-    )
-    result = apply_abbreviations(
-        (section,), abbrevs, page_text="IAM and RBAC Overview"
-    )
+    section = Section(level=1, anchor="overview", title=(TextNode("IAM and RBAC Overview"),), children=())
+    result = apply_abbreviations((section,), abbrevs, page_text="IAM and RBAC Overview")
     glossary = result[-1]
-    assert isinstance(glossary, Section)
-    items = glossary.children[0].items  # type: ignore[union-attr]
-    labels = [item.children[0].children[0].text for item in items]  # type: ignore[union-attr]
-    assert labels == sorted(labels)
-
+    assert isinstance(glossary, AbbrevGlossaryBlock)
+    extra_abbrs = [abbr for abbr, _ in glossary.extras]
+    assert extra_abbrs == sorted(extra_abbrs)

{mkdocs2confluence-0.7.10 → mkdocs2confluence-0.7.12}/tests/test_emitter.py

@@ -402,6 +402,24 @@ class TestFootnoteEmitter:
         assert 'fn-1' in html_out
         assert 'My note.' in html_out
 
+    def test_abbrev_glossary_extras_in_ol_not_ul(self) -> None:
+        """Abbreviations only in headings/titles must appear in <ol>, not <ul>."""
+        from mkdocs_to_confluence.emitter.xhtml import emit
+        from mkdocs_to_confluence.ir.nodes import AbbrevFootnoteNode, AbbrevGlossaryBlock
+        fn = AbbrevFootnoteNode(abbr="API", definition="Application Programming Interface", number=1)
+        block = AbbrevGlossaryBlock(
+            footnoted=(fn,),
+            extras=(("AD", "Active Directory"),),
+        )
+        out = emit((block,))
+        assert "<ol>" in out
+        assert "<ul>" not in out
+        assert "AD" in out
+        assert "Active Directory" in out
+        assert "API" in out
+        # extras must NOT get an anchor macro
+        assert out.count('ac:name="anchor"') == 1  # only for the footnoted entry
+
 
 # ── Inline HTML emitters ──────────────────────────────────────────────────────