as visible text.""" def test_fenced_code_inside_blockquote_renders_pre(self, driver_path): src = ( "> Here is some code:\n" ">\n" "> ```python\n" "> x = 1\n" "> y = 2\n" "> ```\n" ">\n" "> That was the code." ) out = _render(driver_path, src) assert "

" in out and "

" in out, ( f"Fenced code inside blockquote must render as

: {out!r}"
        )
        # The > prefixes must be stripped from the code content, not preserved
        # inside the .
        assert "> x = 1" not in out, (
            f"Code content inside  must not contain > prefixes: {out!r}"
        )
        # Raw  or pre-header tags must NOT appear as visible text
        assert "<pre>" not in out
        assert "<div class="pre-header" not in out
        # Single  wrapping everything (not split by the )
        assert out.count("") == 1, (
            f"Expected ONE , got {out.count('')}: {out!r}"
        )

    def test_fenced_code_with_lang_class(self, driver_path):
        src = "> ```python\n> x = 1\n> ```"
        out = _render(driver_path, src)
        assert 'class="language-python"' in out
        assert "x = 1" in out


class TestFencedCodeFenceLength:
    """CommonMark §4.5 requires the closer to be at least as long as the opener."""

    def test_five_backtick_outer_fence_preserves_inner_triple_fence(self, driver_path):
        src = (
            "- optionally also support fenced code blocks\n\n"
            "`````md\n"
            "`md\n"
            "```novelcrafter\n"
            "{#if novel.hasSeries}\n"
            "...\n"
            "{#endif}\n"
            "```\n"
            "`````\n\n"
            "That is much more correct than pretending"
        )
        out = _render(driver_path, src)
        assert out.count("") == 1
        assert out.count("") == 1
        assert 'md' in out
        assert "```novelcrafter" in out
        assert "{#if novel.hasSeries}" in out
        assert "That is much more correct than pretending" in out
        assert "`````" not in out
        assert "
`````" not in out

    def test_four_backtick_outer_fence_preserves_inner_triple_fence(self, driver_path):
        out = _render(driver_path, "````md\n```inner\nfoo\n```\n````\n")
        assert out.count("
") == 1
        assert out.count("") == 1
        assert 'md' in out
        assert "```inner" in out
        assert "foo" in out
        assert "````" not in out

    def test_three_backtick_fence_still_renders_language_class(self, driver_path):
        out = _render(driver_path, "```js\nconsole.log('ok')\n```")
        assert out.count("
") == 1
        assert 'js' in out
        assert 'class="language-js"' in out
        assert "console.log('ok')" in out


class TestBugBlankContinuationInBlockquote:
    """Bug 2: blank > lines between paragraphs fragmented the blockquote into
    separate elements with literal > characters between them."""

    def test_three_paragraphs_one_blockquote(self, driver_path):
        src = (
            "> First paragraph of the quote.\n"
            ">\n"
            "> Second paragraph of the quote.\n"
            ">\n"
            "> Third paragraph of the quote."
        )
        out = _render(driver_path, src)
        # All three paragraphs in ONE 
        assert out.count("") == 1, (
            f"Expected ONE , got {out.count('')}: {out!r}"
        )
        assert "First paragraph" in out
        assert "Second paragraph" in out
        assert "Third paragraph" in out
        # No literal > between paragraphs (would indicate fragmented blockquote)
        text_only = re.sub(r"<[^>]+>", "", out)
        assert ">" not in text_only, (
            f"Literal > in rendered text indicates fragmented blockquote: {text_only!r}"
        )


class TestBugHeadingsInsideBlockquote:
    """Bug 3: # headings inside blockquotes rendered as literal '##' text
    because the heading pass ran before the blockquote pass."""

    def test_h2_inside_blockquote(self, driver_path):
        src = (
            "> ## Bug description\n"
            ">\n"
            "> The widget is broken.\n"
            ">\n"
            "> ## Steps to reproduce\n"
            ">\n"
            "> Click the button."
        )
        out = _render(driver_path, src)
        assert "Bug description" in out, (
            f"## inside blockquote must render as : {out!r}"
        )
        assert "
Steps to reproduce" in out
        # No literal '##' as visible text
        text_only = re.sub(r"<[^>]+>", "", out)
        assert "##" not in text_only, (
            f"Literal ## in rendered text — heading pass missed it: {text_only!r}"
        )

    def test_h1_h2_h3_all_render(self, driver_path):
        src = "> # H1\n> ## H2\n> ### H3"
        out = _render(driver_path, src)
        assert "H1" in out
        assert "H2" in out
        assert "H3" in out


class TestBugOrderedListInsideBlockquote:
    """Bug 4: ordered (numbered) lists inside blockquotes rendered as plain
    text — the OL pass had no equivalent of the UL branch in the old
    blockquote handler."""

    def test_ordered_list_renders_as_ol(self, driver_path):
        src = (
            "> Steps to reproduce:\n"
            ">\n"
            "> 1. Open the app\n"
            "> 2. Click the button\n"
            "> 3. Observe the crash"
        )
        out = _render(driver_path, src)
        assert "" in out and "" in out, (
            f"Numbered list inside blockquote must render as : {out!r}"
        )
        # All three list items present
        for item in ["Open the app", "Click the button", "Observe the crash"]:
            assert f">{item}" in out, (
                f"Missing {item} in {out!r}"
            )


class TestBugHorizontalRuleInsideBlockquote:
    """Bug 6: --- inside a blockquote rendered as literal text instead of ."""

    def test_hr_renders_inside_blockquote(self, driver_path):
        src = "> Above the rule\n>\n> ---\n>\n> Below the rule"
        out = _render(driver_path, src)
        assert "" in out, (
            f"--- inside blockquote must render as : {out!r}"
        )
        assert "Above the rule" in out
        assert "Below the rule" in out
        # No literal '---' as text
        text_only = re.sub(r"<[^>]+>", "", out)
        assert "---" not in text_only, (
            f"Literal --- in rendered text: {text_only!r}"
        )


class TestBugComplexBlockquoteAllFeatures:
    """Bug 5 (worst-case): a blockquote with headings, paragraphs, inline code,
    fenced code, and an ordered list. Old behaviour collapsed the entire thing
    into a monospace blob with raw markdown syntax leaking everywhere."""

    def test_complex_blockquote_renders_all_constructs(self, driver_path):
        src = (
            "> ## Description\n"
            ">\n"
            "> The widget is broken when X happens.\n"
            ">\n"
            "> ## Root cause\n"
            ">\n"
            "> The `MIME_MAP` in `api/config.py` is missing entries.\n"
            ">\n"
            "> ## Fix\n"
            ">\n"
            "> Add two entries:\n"
            ">\n"
            "> ```python\n"
            '> ".html": "text/html",\n'
            '> ".htm": "text/html",\n'
            "> ```\n"
            ">\n"
            "> ## Workflow rules\n"
            ">\n"
            "> 1. Never edit the file directly\n"
            "> 2. Create a worktree\n"
            "> 3. Run the tests\n"
            ">\n"
            "> Target branch is `master`."
        )
        out = _render(driver_path, src)
        # Multiple  headings
        assert out.count("
") >= 4, (
            f"Expected at least 4 
 headings, got {out.count('
')}: {out!r}"
        )
        # Fenced code block
        assert "" in out
        assert 'class="language-python"' in out
        # Ordered list
        assert "" in out
        # Inline code
        assert "MIME_MAP" in out
        assert "api/config.py" in out
        assert "master" in out
        # No literal markdown syntax leaking
        text_only = re.sub(r"<[^>]+>", "", out)
        assert "##" not in text_only, f"Literal ## in {text_only!r}"
        # Single  wraps everything
        assert out.count("") == 1, (
            f"Expected ONE , got {out.count('')}: {out!r}"
        )
        # No raw / as escaped text
        assert "<pre>" not in out
        assert "<div class="pre-header" not in out


class TestBlockquoteRegressionsDontTouchOutsideContent:
    """Make sure the blockquote pre-pass doesn't grab > -prefixed lines that
    sit inside a non-blockquote fenced code block (e.g. shell prompts in
    ```bash``` examples)."""

    def test_shell_prompt_in_bash_fence_not_treated_as_blockquote(self, driver_path):
        src = "```bash\n> echo hello\n```"
        out = _render(driver_path, src)
        # The > line is part of the bash code, not a blockquote
        assert "" not in out, (
            f"> line inside ```bash``` must NOT become a blockquote: {out!r}"
        )
        assert "" in out
        # Escaped > preserved as code content
        assert "> echo hello" in out

    def test_two_separate_blockquotes_stay_separate(self, driver_path):
        src = "> First quote\n\nSome plain text.\n\n> Second quote"
        out = _render(driver_path, src)
        assert out.count("") == 2, (
            f"Two separated blockquotes must stay separate: {out!r}"
        )
        assert "Some plain text." in out

    def test_nested_double_blockquote(self, driver_path):
        src = "> outer line\n> > inner line"
        out = _render(driver_path, src)
        # Should produce nested 
        assert out.count("") == 2, (
            f"Expected 2 : {out!r}"
        )


class TestBlockquoteEntityEncodedInput:
    """Blockquotes sent as HTML-entity-encoded text must still render correctly.
    LLMs sometimes emit > instead of > — the entity-decode pass must run
    BEFORE the blockquote pre-pass, not after it."""

    def test_amp_gt_prefix_becomes_blockquote(self, driver_path):
        src = "> Hello quote"
        out = _render(driver_path, src)
        assert "" in out, (
            f">-prefixed line must render as : {out!r}"
        )
        text_only = re.sub(r"<[^>]+>", "", out)
        assert "Hello quote" in text_only
        # Should not see a literal > or > in the rendered text
        assert ">" not in out, f"> should have been decoded: {out!r}"

    def test_amp_gt_fenced_code_in_blockquote(self, driver_path):
        src = "> ```python\n> x = 1\n> ```"
        out = _render(driver_path, src)
        assert "" in out, (
            f"Entity-encoded blockquote with fenced code must render: {out!r}"
        )
        assert "" in out, f"Fenced code inside entity-encoded blockquote must render: {out!r}"


class TestMermaidToolOutputGuard:
    """Line-numbered tool excerpts must not be auto-rendered as Mermaid."""

    def test_line_numbered_mermaid_fence_renders_as_code_block(self, driver_path):
        src = "```mermaid\n23|flowchart TB\n24|    A --> B\n```"
        out = _render(driver_path, src)
        assert 'class="mermaid-block"' not in out, (
            f"Line-numbered read_file excerpts are not valid Mermaid and must not auto-render: {out!r}"
        )
        assert 'mermaid' in out
        assert '' in out
        assert '23|flowchart TB' in out

    def test_valid_mermaid_fence_still_creates_mermaid_block(self, driver_path):
        out = _render(driver_path, "```mermaid\nflowchart TB\n    A --> B\n```")
        assert 'class="mermaid-block"' in out, (
            f"Valid Mermaid fences should still be queued for Mermaid rendering: {out!r}"
        )
        assert 'flowchart TB' in out

    def test_valid_mermaid_c4_fence_still_creates_mermaid_block(self, driver_path):
        out = _render(driver_path, "```mermaid\nC4Context\n    title System Context\n```")
        assert 'class="mermaid-block"' in out, (
            f"Valid C4 Mermaid fences should still be queued for Mermaid rendering: {out!r}"
        )
        assert 'C4Context' in out

    def test_valid_mermaid_frontmatter_fence_still_creates_mermaid_block(self, driver_path):
        out = _render(driver_path, "```mermaid\n---\ntitle: Demo\n---\nflowchart TB\n    A --> B\n```")
        assert 'class="mermaid-block"' in out, (
            f"Valid Mermaid fences with frontmatter should still be queued for Mermaid rendering: {out!r}"
        )
        assert 'title: Demo' in out

    def test_prose_mention_of_mermaid_fence_renders_as_code_block(self, driver_path):
        src = "```mermaid\n` fence should not be auto-rendered too aggressively.\n\nSome prose, not a diagram.\n```"
        out = _render(driver_path, src)
        assert 'class="mermaid-block"' not in out, (
            f"Prose captured by a mermaid fence is not valid Mermaid and must not auto-render: {out!r}"
        )
        assert 'mermaid' in out
        assert '' in out
        assert 'Some prose, not a diagram.' in out


class TestRawPreCodePreservation:
    """Raw  HTML from model output should remain structurally intact."""

    def test_multiline_pre_code_blocks_do_not_degrade_to_backticks(self, driver_path):
        src = (
            "line 1\n"
            "line 2\n"
            "\n\n"
            "After paragraph.\n\n"
            "line 3\n"
            "line 4\n"
            "\n\n"
            "Done."
        )
        out = _render(driver_path, src)
        assert out.count("") == 2 and out.count("") == 2, (
            f"Expected two balanced  blocks, got: {out!r}"
        )
        assert out.count("") == 2 and out.count("") == 2, (
            f"Expected two balanced  blocks, got: {out!r}"
        )
        assert "`line 1" not in out and "line 2\n`
" not in out, (
            f" content inside  must not be rewritten to backticks: {out!r}"
        )
        assert "After paragraph." in out and "Done." in out


class TestHeadingLevelsH1ThroughH6:
    """Issue #1258 — `####`, `#####`, `######` previously fell through the
    heading pass and emitted as literal text starting with `#`.  Pin all six
    levels so a future edit cannot silently regress h4–h6 again."""

    def test_all_six_heading_levels_render(self, driver_path):
        src = "# H1\n## H2\n### H3\n#### H4\n##### H5\n###### H6"
        out = _render(driver_path, src)
        assert "H1" in out, f"h1 missing: {out!r}"
        assert "H2" in out, f"h2 missing: {out!r}"
        assert "H3" in out, f"h3 missing: {out!r}"
        assert "H4" in out, f"h4 missing: {out!r}"
        assert "H5" in out, f"h5 missing: {out!r}"
        assert "H6" in out, f"h6 missing: {out!r}"

    def test_h6_does_not_partial_match_as_lower_level(self, driver_path):
        """Replacers must run longest-first; otherwise `###### H6` could be
        captured by the `^### ` rule and emit `### H6`."""
        out = _render(driver_path, "###### H6")
        assert "H6" in out, f"h6 must not be partial-matched: {out!r}"
        assert "" not in out and "###" not in out

    def test_h4_inline_markdown_still_processes(self, driver_path):
        out = _render(driver_path, "#### **bold** in h4")
        assert "
bold in h4" in out, (
            f"inline markdown inside h4 must still render: {out!r}"
        )


class TestBareFileUrlMediaRendering:
    """#3219/#3234: bare file:// artifact links render as media, but file://
    inside fenced/inline code stays literal (the new pass runs AFTER code-stash)."""

    def test_bare_file_url_becomes_media(self, driver_path):
        out = _render(driver_path, "Here is the screenshot file:///tmp/shot.png done")
        # Routed through /api/media as an inline image, not left as a raw path.
        assert "api/media?path=" in out
        assert "msg-media-img" in out or ".
        assert "file:///tmp/shot.png" in out
        assert ").
        assert " inside markdown table cells must be preserved and not split cells across lines."""

    def test_table_cell_with_br_renders_intact(self, driver_path):
        src = (
            "| Feature | Description |\n"
            "| :--- | :--- |\n"
            "| Item 1 | Line one
Line two |\n"
            "| Item 2 | Another row |"
        )
        out = _render(driver_path, src)
        assert "" in out
        assert "Line one
Line two" in out or "Line one
Line two" in out
        assert "Item 2" in out
        assert out.count("") == 3  # 1 header + 2 data rows


class TestBulletListItalicCollision:
    """Asterisk bullet lists followed by italic words must not collide or escape tags."""

    def test_bullet_list_with_italic_does_not_swallow_tags(self, driver_path):
        src = "* **Label:** Normal text with *italic* words."
        out = _render(driver_path, src)
        assert "<strong>" not in out
        assert "Label:" in out
        assert "italic" in out


class TestRendererGateRegressions7618:
    """Regressions for the two defects the release gate found in the #7618 fix.

    Both were SILENT: they produced wrong output with no error, and neither was
    covered by the PR's own tests.
    """

    def test_literal_br_sentinel_in_prose_is_not_rewritten(self, driver_path):
        """A user typing the sentinel must not have it turned into a 
.

        The first implementation stashed table-row 
 as a fixed \\x00BR\\x00
        token and unconditionally rewrote that token back to 
 afterwards, so
        attacker/user-supplied text containing the literal token was corrupted.
        """
        out = _render(driver_path, "literal \x00BR\x00 text")
        assert "
" not in out
        assert "\x00BR\x00" in out

    def test_literal_br_sentinel_inside_link_does_not_corrupt_anchor(self, driver_path):
        """The sentinel inside a URL must not break out of the href attribute."""
        out = _render(driver_path, '[x](https://example.test/\x00BR\x00tail)')
        # The anchor must stay well-formed: no attribute text leaking into the body.
        assert 'target="_blank"' not in out
        assert '>tail" target=' not in out

    def test_literal_br_sentinel_in_table_cell_stays_literal(self, driver_path):
        src = "| a | b |\n|---|---|\n| \x00BR\x00 | c |"
        out = _render(driver_path, src)
        assert "" in out
        assert "
" not in out

    def test_html_em_with_boundary_whitespace_still_italicises(self, driver_path):
        """` x ` must stay emphasis.

        The stricter italic regex (which correctly stops `a * b * c` from
        italicising) also rejected the `* x *` that the HTML pre-pass produced
        for ` x `, degrading supported emphasis into literal asterisks
        — and into a bullet list when it started a line.
        """
        out = _render(driver_path, " italic ")
        assert "italic" in out
        assert "" not in out
        assert "" not in out

    def test_html_i_with_boundary_whitespace_still_italicises(self, driver_path):
        out = _render(driver_path, " spaced ")
        assert "spaced" in out
        assert "" not in out

    def test_spaced_asterisks_still_not_italicised(self, driver_path):
        """The original #7618 fix must survive the boundary-whitespace repair."""
        out = _render(driver_path, "2 * 3 * 4 = 24")
        assert "" not in out
        assert "2 * 3 * 4 = 24" in out

    def test_pipe_wrapped_prose_keeps_heading_rendering(self, driver_path):
        """`| note
# heading |` is NOT a table — it must keep heading rendering.

        The table-row guard must use the same grammar as the downstream table
        parser (a pipe-line run whose SECOND line is a separator). A naive
        per-line "looks pipe-wrapped" test silently stripped heading/list
        rendering from pipe-delimited prose.
        """
        out = _render(driver_path, "| prose
# heading |")
        assert "" in out

    def test_pipe_wrapped_prose_keeps_list_rendering(self, driver_path):
        out = _render(driver_path, "| prose
- item |")
        assert "" in out and "" in out

    def test_pipe_rows_without_separator_are_not_treated_as_table(self, driver_path):
        """Two pipe lines with no separator row are prose, so 
 still converts."""
        out = _render(driver_path, "| a | b |\n| c | d |")
        assert "
" not in out

    def test_multi_row_table_preserves_br_in_every_data_row(self, driver_path):
        src = (
            "| Feature | Notes | Status |\n"
            "|---|---|---|\n"
            "| Auth | OAuth
API keys
tokens | shipped |\n"
            "| Cache | LRU
60s TTL | in review |"
        )
        out = _render(driver_path, src)
        assert out.count("") == 3
        assert "OAuth
API keys
tokens" in out
        assert "LRU
60s TTL" in out

    def test_row_with_trailing_text_after_closing_pipe_matches_master(self, driver_path):
        """Pins parity with master for a malformed row that has text past the last pipe.

        The downstream table regex lacks an end-of-line anchor, so it accepts a
        prefix the physical-line guard rejects. Master does NOT render this as a
        table either, so preserving prose here is parity, not a regression. Pinned
        so a future table-guard change has to make a deliberate decision about it.
        """
        out = _render(driver_path, "| h
x | n |\n|---|---| trailing")
        assert "
" not in out

    def test_indented_and_padded_table_still_preserves_br(self, driver_path):
        out = _render(driver_path, "  | a | b |\n  |---|---|\n  | x
y | z |")
        assert "
" in out
        assert "x
y" in out

Heading

Bug description

: {out!r}" ) assert "

Steps to reproduce

H1

H2

H3

headings assert out.count("

") >= 4, ( f"Expected at least 4

headings, got {out.count('

H1

H2

H3

H4

H5

H6

### H6

H6

" not in out and "###" not in out def test_h4_inline_markdown_still_processes(self, driver_path): out = _render(driver_path, "#### **bold** in h4") assert "

bold in h4

" not in out and "###" not in out def test_h4_inline_markdown_still_processes(self, driver_path): out = _render(driver_path, "#### bold in h4") assert "