From a85ead109f43cbe2458308590e2f284c08de4dea Mon Sep 17 00:00:00 2001
From: Gordon Woodhull <gordon.woodhull@posit.co>
Date: Thu, 3 Sep 2026 18:01:42 -0400
Subject: [PATCH] Parse markdown adjacent to a raw HTML block line
 (bd-block-html-adjacent-markdown-unparsed-0qnjuwuy)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Since 0.29.0 a line of prose immediately after a raw HTML block line was
emitted verbatim — backticks, asterisks and every other inline construct
survived into the page as literal text:

    <details>
    <summary>Example custom instructions</summary>
    This example demonstrates how a `quarto.instructions.md` file shapes …

Quarto 1 parses that, as does pandoc 3.8.1, and so did q2 0.28.0. A blank line
was where the parser recovered, so to an author it read like a content typo
rather than an engine bug.

The lift added in bd-block-html-wrapped-in-p-w8qebxig turned a paragraph
opening with a block-level HTML tag into a `RawBlock` by re-reading its source
text verbatim. The extent was right — a paragraph and a CommonMark type-6 HTML
block both run to the next blank line — but re-reading the source also switched
off inline parsing inside it. That conflated two pandoc extensions: dropping
`native_divs` costs the `<p>` wrapper and the `Div` node, which was intended;
dropping `markdown_in_html_blocks` costs inline parsing, which was not. Measured
on a tight `<div>`, q2's output was byte-identical to
`pandoc -f markdown-native_divs-markdown_in_html_blocks`, and its AST was one
verbatim `RawBlock` where `-native_divs` alone gives `RawBlock`/`Plain`/
`RawBlock`.

`process_paragraph` already held the fully-parsed inlines and discarded them.
It now partitions that vector instead: runs of block-level raw HTML coalesce
into a `RawBlock`, the text between them becomes a `Plain`, and the parts are
returned as `IntermediateSection`, which every block container already splices.
Each inline is classified on its own — no tag matching, no lookahead — so this
stays inside the no-backtracking constraint in `dev-docs/syntax-notes.md`. Two
details earn their comments: the tag test runs on trimmed text, because
tree-sitter folds preceding whitespace into a non-first `RawInline`; and each
part gets its own span, since cloning the paragraph's onto all of them gives
siblings overlapping ranges and misleads the incremental writer.

`<pre>`, `<script>`, `<style>` and `<textarea>` are exempt and stay verbatim.
They are CommonMark's raw-text elements, pandoc does not parse markdown inside
them, and all four are in `BLOCK_TAGS` — without the exemption a split would
parse markdown inside a `<script>`.

Block-level raw HTML is now written bare rather than inside a ```{=html} fence,
which reverses the normalisation the lift originally shipped with. The fence is
kept for anything else, gated on whether the text would re-read as the same
single `RawBlock`: a pure run of block tags, or a raw-text element. Without that
gate an author's own ```{=html} block loses its fence and its contents are
parsed on the next read — a backtick becoming `Code`, a `#` line becoming a
`Header`.

Writing the AST back out does not reproduce the `Plain`. Blocks are always
separated by a blank line, so a lifted interior re-reads as a `Paragraph` and
gains a `<p>`; for `<div>` that matches Quarto 1, and for a phrasing-only
element such as `<summary>` it is invalid, though only after a write/read cycle
and never on first render (bd-8md6k9dv). Preserving the `Plain` would mean
writing it tight against the neighbouring tag, which requires knowing the two
blocks came from one paragraph. The AST does not record that. A rule that
inferred it from block types alone — as pandoc's writer does, licensed by a
reader invariant we do not have — merged a `Plain` with a following *unrelated*
`<script>` so its JavaScript was parsed as markdown, let a closing tag fall back
inside a paragraph, and collapsed filter-produced blocks into one. The writer
does not guess.

Interiors are always `Plain`, never `Paragraph`. Pandoc chooses between them by
tracking which element is still open, which needs the balanced matching
`syntax-notes.md` rejects. Every resulting difference is a `<p>` wrapper — the
`native_divs` gap qmd already accepts — and against Quarto 1 this matches on
every markdown-parsing question. Documented in `dev-docs/syntax-notes.md` and
`crates/pampa/README.md`.

`incremental_writer_tests::roundtrip_comment_in_blockquote` no longer uses
`assert_roundtrip`, which demands full structural equality after a rewrite.
That guarantee genuinely no longer holds, so it asserts what does: tags in block
position, prose parsed, shape stable from the first rewrite.

Snapshots: 2 modified, both the same class — `html-comment-17` and
`html-comment-44`, where a comment followed by text on the same line is now
`RawBlock` + `Plain` instead of one verbatim `RawBlock`. Rendering was checked
before accepting: neither the old nor the new output carries the `<p>` Quarto 1
emits there, so the comment simply moves onto its own line, closer to Q1.

Not fixed, filed as bd-495qnexy: a block-level tag mid-paragraph still does not
interrupt the paragraph, so a trailing `</details>` lands inside a `<p>`.
Pre-existing and byte-identical on 0.28.0, 0.29.0 and main.

Tests: workspace 13697 passed, 0 failed, 199 skipped — baseline 13676, and +21
is exactly the tests added here. Clippy, cargo fmt and cargo xtask lint clean;
cargo xtask verify passes all 14 steps including the WASM leg. Both repro
fixtures are green and q2 matches Quarto 1 on all four rows of the regression
repro; verified end-to-end through `q2 render` with the output inspected.
---
 ...4-block-html-adjacent-markdown-unparsed.md | 294 ++++++++
 ...3-block-html-adjacent-markdown-unparsed.md | 233 +++++++
 crates/pampa/README.md                        |   5 +-
 ...html-comment-17-comment-at-line-start.snap |   2 +-
 ...t-44-comment-starts-at-block-boundary.snap |   2 +-
 .../src/pandoc/treesitter_utils/html_block.rs |  61 +-
 .../src/pandoc/treesitter_utils/paragraph.rs  | 198 +++++-
 crates/pampa/src/writers/qmd.rs               | 121 +++-
 .../integration/incremental_writer_tests.rs   |  99 ++-
 .../tests/integration/test_html_block_lift.rs | 637 +++++++++++++++++-
 .../pampa/tests/integration/test_warnings.rs  |   9 +-
 dev-docs/syntax-notes.md                      |  46 ++
 12 files changed, 1648 insertions(+), 59 deletions(-)
 create mode 100644 claude-notes/plans/2026-09-04-block-html-adjacent-markdown-unparsed.md
 create mode 100644 claude-notes/research/2026-09-03-block-html-adjacent-markdown-unparsed.md

diff --git a/claude-notes/plans/2026-09-04-block-html-adjacent-markdown-unparsed.md b/claude-notes/plans/2026-09-04-block-html-adjacent-markdown-unparsed.md
new file mode 100644
index 000000000..d145d6363
--- /dev/null
+++ b/claude-notes/plans/2026-09-04-block-html-adjacent-markdown-unparsed.md
@@ -0,0 +1,294 @@
+# Fix: markdown adjacent to a raw HTML block is emitted verbatim
+
+Strand: `bd-block-html-adjacent-markdown-unparsed-0qnjuwuy`
+Exploration: `claude-notes/research/2026-09-03-block-html-adjacent-markdown-unparsed.md`
+Regression from: PR #646 / `bdacd1122`
+
+## Goal
+
+A paragraph opening with a block-level HTML tag is currently lifted to a
+single **verbatim** `RawBlock`, which switched off inline markdown parsing
+inside it — pandoc's `markdown_in_html_blocks`. Keep the lift and its extent,
+but split the paragraph so tag runs stay raw and the intervening text goes
+back through the inline parser.
+
+Target AST, matching `pandoc -f markdown-native_divs`:
+
+```
+<div class="x">          RawBlock html "<div class=\"x\">"
+text with `code`    ->   Plain [ ... Code ... ]
+</div>                   RawBlock html "</div>"
+```
+
+## Decisions (Gordon, 2026-09-04)
+
+- **Match pandoc on round-trip.** A block-level html `RawBlock` writes
+  **verbatim**, not as a ` ```{=html} ` fence. This reverses PR #646's
+  deliberate normalisation to the documented spelling; the round-trip
+  stability it buys is worth more. No adjacency rule needed.
+- **Q-2-9 diagnostic change is fine.** *(Correction, after review: there is no
+  diagnostic change. Q-2-9 is emitted per `html_element` node in
+  `treesitter.rs`, which this branch does not touch, and the count is still 2
+  for an open/close pair — verified against `main`. What changed is the
+  `RawBlock.text` that `test_warnings` asserted on. The decision was sound but
+  the thing being decided did not exist.)*
+- **`Plain` always for split interiors** (recommended, not pandoc-exact).
+  Pandoc's `Plain`/`Para` choice needs open-element tracking, which
+  `dev-docs/syntax-notes.md` rejects. Every resulting difference is a `<p>`
+  wrapper — the already-accepted `native_divs` gap. Documented, not chased.
+
+## Phase 1 — Tests first
+
+- [x] Reader: tight `<div>` splits to RawBlock/Plain/RawBlock with parsed `Code`/`Emph`
+- [x] Reader: `<details>`/`<summary>` shape from the real bug report
+- [x] Reader: leading-whitespace classifier — `<!-- a --> <!-- b --> <!-- c -->` stays one run
+- [x] Reader: raw-text exemption — `pre`, `script`, `style`, `textarea` stay one verbatim RawBlock
+- [x] Reader: tag-only paragraph still emits exactly one RawBlock (PR #646 unchanged)
+- [x] Reader: each split part carries its own non-overlapping `SourceInfo`
+- [x] Writer: block-html RawBlock writes verbatim; round-trip is byte-stable and reparses identically
+- [x] Writer: round-trip inside a block quote (the incremental-writer failure)
+- [x] Verify all the above fail before implementing
+
+## Phase 2 — Reader
+
+- [x] Raw-text-element guard (first-inline check) in `html_block.rs`
+- [x] Split into `RawBlock`/`Plain` runs in `paragraph.rs`; return `IntermediateSection`
+- [x] Classify on `text.trim_start()`
+- [x] Per-part `SourceInfo` from child nodes, not cloned from the paragraph
+- [x] Single-part result still returns one `IntermediateBlock`
+
+## Phase 3 — Writer
+
+- [x] `write_rawblock`: block-html html RawBlock verbatim (generalises the `is_html_comment` case)
+- [x] `Plain` is tight — suppress the inter-block blank line at **every** block container
+- [x] Retire `naked_block_round_trips_as_an_explicit_raw_fence` (decision above)
+
+## Phase 4 — Reconcile existing expectations
+
+- [x] `test_html_block_lift` — three tests asserting merged behaviour
+- [x] `test_warnings::test_block_level_html_elements` — asserts the split tags,
+      not a changed diagnostic (see the correction above)
+- [x] `incremental_writer_tests::roundtrip_comment_in_blockquote`
+- [x] Snapshot review (expect ~1); report count + summary per CLAUDE.md
+- [x] Document the `Plain`/`Para` and `native_divs` divergences
+
+## Phase 5 — Verify
+
+- [x] `cargo clippy -p pampa --all-targets -- -D warnings`
+- [x] `cargo nextest run --workspace` — 13684 passed / 199 skipped / 0 failed.
+      Baseline 13676 passed; +8 is exactly the tests added here.
+- [x] `cargo xtask lint`
+- [x] `cargo xtask verify` — full run (not `--skip-hub-build`), all 14 steps pass,
+      including the WASM/hub-client leg, since pampa is in that dependency chain
+- [x] Both repros green simultaneously
+- [x] End-to-end through the `q2` binary; inspect output (see below)
+
+## Writer separator rule — measured, not assumed
+
+The first attempt made `Plain` tight on both sides. That is *not* pandoc's
+rule, and it removed a blank line between a `Table` and a following `Plain`,
+reddening `quarto-core::llms_txt::llms_companion_rich_content_snapshot`. The
+workspace run caught it; the per-crate pampa run did not.
+
+Pandoc's markdown writer, measured over a 5x5 block matrix:
+
+| prev | next | separator |
+| --- | --- | --- |
+| RawBlock | Plain | **tight** |
+| Plain | RawBlock | **tight** |
+| RawBlock | RawBlock | **tight** |
+| everything else | | blank line |
+
+We take the first two and deliberately **not** the third. Our reader's HTML
+block extent is the paragraph, so two adjacent `RawBlock`s came from two
+separate paragraphs; the blank line between them is what keeps them separate,
+and writing them tight would merge them into one raw run on the next read.
+The `RawBlock` side is further narrowed to blocks `write_rawblock` emits bare,
+so a ```` ```{=html} ```` fence is never pulled tight against its neighbour.
+
+## End-to-end verification
+
+    $ q2 render index.qmd --to html
+
+on the reported shape (`<details>`/`<summary>` then prose with no blank line):
+
+    <details>
+    <summary>
+    Example custom instructions
+    </summary>
+    This example demonstrates how a <code>quarto.instructions.md</code> file shapes Positron
+    Assistant behavior for anything ending with <code>.instructions.md</code>.
+
+Output inspected: the code spans are parsed and no literal backticks remain
+(`grep -c` for the backticked forms returns 0). Both repro fixtures are green
+simultaneously, and q2 now matches Quarto 1 on all four rows of the regression
+repro.
+
+The trailing `</details></p>` in that same render is **pre-existing** — it is
+byte-identical on 0.28.0, 0.29.0 and `main`, and is PR #646's documented
+mid-paragraph gap. Filed as bd-495qnexy, linked `discovered-from` this strand.
+
+## Snapshots
+
+Two modified, both the same class: `html-comment-17-comment-at-line-start` and
+`html-comment-44-comment-starts-at-block-boundary`. A comment followed by text
+on the same line now parses as `RawBlock` + `Plain` instead of one verbatim
+`RawBlock`. Rendering was checked before accepting: neither the old nor the new
+output carries the `<p>` that Quarto 1 emits there, so this is not a
+regression — the comment simply moves onto its own line, closer to Q1.
+
+## Review round (2026-09-04)
+
+A reviewer subagent over `914f20697..d7a6eb067` found three real defects. All
+were reproduced through the binary before being fixed, and each has a
+regression test.
+
+**Critical — `Inline::LineBreak` was not treated as a separator.** Trailing
+spaces on a tag line are invisible in the source but make the reader emit a
+hard break rather than a `SoftBreak`. It fell into the content run, so
+`<div class="x">··\ntext\n</div>` rendered `<br />text`, and
+`<div>···\n</div>` invented a `Plain` holding the break alone (printing a
+stray backslash). Both were new regressions on the default render path — `main`
+renders them correctly. `LineBreak` now joins `Space`/`SoftBreak` in both the
+separator arm and the trailing-pop. q2 is byte-identical to pandoc on both.
+
+**Important — the bare-writing test was far too broad.** `writes_bare_html`
+de-fenced *any* `RawBlock` starting with a block tag, including author-written
+```` ```{=html} ```` fences. Their contents were then parsed on re-read: a
+backticked word became `Code`, and a `#` line after a blank line became a real
+`Header` — content corruption through any AST -> qmd -> read cycle. The comment
+claiming "exactly the texts written bare are the ones the reader lifts back"
+was false for anything but a pure tag run.
+
+`round_trips_bare_html` now tests the whole text, not its first tag: bare is
+allowed only for the two shapes the lift actually produces — a pure run of
+block tags (`line_is_only_tags` on every line, quoted attribute values
+skipped), or a raw-text element whose interior the reader leaves unparsed —
+and never when a blank line would end the block. The writer and the blank-line
+rule now share one predicate, `html_writes_bare`, so they cannot drift.
+
+**Important — `write_orderedlist` was missed.** It has its own block loop,
+separate from `write_bulletlist`'s, so an ordered item's split interior came
+back as a `Paragraph` while a bullet item's stayed `Plain`. The plan's claim of
+"every block container" was wrong. Fixed.
+
+### Containers: the complete list, and what needs nothing
+
+`IntermediateSection` is spliced at exactly six sites — `treesitter.rs:340`
+(list item), `section.rs`, `document.rs`, `block_quote.rs`,
+`fenced_div_block.rs`, `note_definition_fenced_block.rs` — so a split can only
+land in: the document (`write_impl` and `write_impl_tracked`), a block quote, a
+fenced div, a bullet-list item, an ordered-list item, and a fenced note
+definition. All seven writer loops now apply the rule; sections flatten into
+the document.
+
+Two sites the reviewer flagged were checked and deliberately need no change:
+
+- **`write_definitionlist`** — definition lists are not a splice site, so a
+  lifted paragraph cannot reach one. (Separately, a definition's block content
+  does not survive the reader at all today; that is pre-existing and identical
+  on `main`, including for plain prose, so it is not this change's concern.)
+- **the metadata block loop** — a front-matter value stays a YAML scalar and
+  never becomes `PandocBlocks` holding a lifted paragraph; verified with an
+  `abstract:` holding a tight `<div>`.
+
+### Follow-ups taken from the review's Minor findings
+
+- **`span_of`** no longer clones the run to compute a span (it takes the
+  `SourceInfo`s directly), refuses to union offsets across different files, and
+  `debug_assert!`s on the no-`Original` arm. That arm is unreachable — this runs
+  in the reader, before any filter — but if a change made it reachable, two
+  adjacent runs would fall back to the paragraph span and get the overlapping
+  siblings the function exists to prevent. Better loud than quiet.
+- **`tag_name`** is now factored out of `starts_block_html` and shared with
+  `starts_raw_text_element`, which had been a second copy missing the
+  tag-name-boundary check (`starts_raw_text_element("<pre-wrap>")` was true;
+  unreachable behind the `starts_block_html` guard, but a live drift hazard).
+  It also carries a closing-tag flag, so `</pre>` correctly does *not* start a
+  raw-text exemption — CommonMark's type-1 start condition is the opening tag.
+  Both behaviours now have tests.
+- **Tests added** for the raw-text exemption inside a block quote, and for the
+  closing-tag case above.
+
+### Two source reflows worth naming
+
+Neither changes the AST, but both change bytes on an AST -> qmd write:
+
+- A blank line between a `Plain` and a following bare `RawBlock` is dropped:
+  `<div>\ntext\n\n</div>` comes back as `<div>\ntext\n</div>`. The parse is
+  identical either way.
+- A `<pre>` whose content contains a blank line is exempt only for its *first*
+  paragraph; the rest is parsed as markdown. Pre-existing — the extent has
+  always been the paragraph — but it has a visible consequence now that the
+  interior of everything else is parsed. Noted in `dev-docs/syntax-notes.md`.
+
+## Second review, and the removal of the tight rule (2026-09-04)
+
+A second review found the writer's tightness rule unsound. Three defects, all
+reproduced through the binary:
+
+- **A `Plain` was pulled tight against a following raw-text element from a
+  *different* paragraph.** `<script>` then no longer *began* a paragraph, so
+  the exemption did not fire and its JavaScript was parsed as markdown —
+  `` const t = `hi`; `` became `const t = <code>hi</code>;` after one cycle.
+- **A comment containing `>`** defeated `line_is_only_tags`, which forced a
+  fence, which restored a blank line, which let `</div>` collapse back into a
+  paragraph — the `<p><div>` shape PR #646 exists to prevent.
+- **Filter-produced blocks were merged.** `[Plain, RawBlock, Plain, RawBlock]`
+  written and re-read came back as a single `Paragraph` holding both tags as
+  inlines.
+
+### Why it was unsound, not merely incomplete
+
+Pandoc's tight rule is safe because *pandoc's* `Plain` in this position means
+"content inside an HTML block that is still open" — its reader guarantees it.
+Ours does not: we emit `Plain` for every split interior, and a filter can emit
+one anywhere. So the writer, seeing `Plain` next to a `RawBlock`, cannot tell
+whether they came from one paragraph or two, and that question has no answer in
+the AST. We had borrowed pandoc's writer rule without the reader invariant that
+makes it sound.
+
+That is a design fault rather than a missing clause, and the earlier plan text
+claiming the rule was "measured, not guessed" was measuring the wrong thing: the
+5×5 matrix recorded *what pandoc does*, not *why it may*.
+
+### What replaced it
+
+`needs_blank_line_between` and `writes_bare_html` are gone; every container loop
+is back to separating blocks unconditionally. The fence-versus-bare decision
+stays — it is what stops an authored ```` ```{=html} ```` block being stripped
+and its contents parsed — and `line_is_only_tags` now scans a comment to `-->`
+rather than to the first `>`.
+
+**The cost, stated plainly:** a split interior comes back as a `Paragraph`
+rather than a `Plain`, gaining a `<p>`. For `<div>` that matches Quarto 1. For a
+phrasing-only element like `<summary>` it is invalid HTML — but only after a
+write/read cycle, never on first render. Filed as bd-8md6k9dv.
+
+Three alternatives were measured and rejected:
+
+- **Keep the fence instead of writing bare** — identical `Paragraph` outcome,
+  uglier source. Strictly worse.
+- **Emit `Paragraph` from the reader instead of `Plain`** — round-trip becomes
+  perfectly stable and `<div>` matches Q1 byte-for-byte, but every `<summary>`
+  gets an invalid `<p>` on *first render*, which is worse than getting one only
+  after an edit.
+- **Recover provenance from source spans** — fragile for filter-produced and
+  transformed blocks.
+
+### Source reflows, in full
+
+Writing the AST back out is parse-stable but not byte-stable. The reflows, so
+the next reader is not surprised:
+
+- a split interior returns as a `Paragraph`, gaining a `<p>` (see above);
+- several block tags on one line are re-emitted one per line —
+  `<div><section>` becomes two lines, from the `join("\n")` in `flush_raw`;
+- text sharing a line with a tag moves to its own line — `<div>text` becomes
+  `<div>` then `text`;
+- leading indentation is dropped — `  <div>` becomes `<div>`;
+- a blank line between a `Plain` and a following bare `RawBlock` is preserved
+  now that nothing is written tight, so the earlier note about it being dropped
+  no longer applies;
+- a `<pre>` whose content spans a blank line is exempt only for its first
+  paragraph — pre-existing, since the extent has always been the paragraph.
diff --git a/claude-notes/research/2026-09-03-block-html-adjacent-markdown-unparsed.md b/claude-notes/research/2026-09-03-block-html-adjacent-markdown-unparsed.md
new file mode 100644
index 000000000..1858afb7d
--- /dev/null
+++ b/claude-notes/research/2026-09-03-block-html-adjacent-markdown-unparsed.md
@@ -0,0 +1,233 @@
+# bd-block-html-adjacent-markdown-unparsed-0qnjuwuy — exploration and recommendation
+
+Investigation only. No fix implemented; the spikes described below were
+measured and reverted.
+
+## Summary
+
+The strand's diagnosis is **correct**, and its suggested fix direction is
+**sound but understated**. The reader-side change is small and I verified it
+fixes the regression while keeping PR #646's guard green. Two costs the
+strand did not identify make the total job medium, not small:
+
+1. A **qmd-writer companion change** is mandatory, not optional. Without it
+   the split destabilises round-tripping (`Plain` comes back as `Paragraph`)
+   and breaks the incremental writer used by the hub editing path.
+2. **Exact pandoc parity on the `Plain`/`Para` distinction is not reachable**
+   with a local rule. It needs open-element tracking — the thing
+   `dev-docs/syntax-notes.md` rejects. The recommendation is to *not* chase it.
+
+Plus one measured exception class the strand did not have: `<pre>`,
+`<script>`, `<style>`, `<textarea>` must keep the current verbatim
+behaviour.
+
+## 1. The diagnosis holds — verified, not taken on faith
+
+Reproduced at HEAD (`914f20697`), not just at the 0.29.0 release build.
+
+The strand's central measurement is exactly reproducible:
+
+| input `-f …` | `<p>` wrapper | inline markdown |
+| --- | --- | --- |
+| `markdown` | yes | parsed |
+| `markdown-native_divs` | no | parsed |
+| `markdown-native_divs-markdown_in_html_blocks` | no | **literal** |
+| q2 HEAD | no | **literal** |
+
+q2's HTML is byte-identical to row 3. The conflation claim is confirmed.
+
+I also confirmed it **at the AST level**, which the strand did not do and
+which is the stronger evidence:
+
+```
+pandoc -f markdown-native_divs                          -> RawBlock, Plain, RawBlock
+pandoc -f markdown-native_divs-markdown_in_html_blocks  -> RawBlock (one, verbatim)
+q2 HEAD                                                 -> RawBlock (one, verbatim)
+```
+
+A fourth data point sharpens *why* the two extensions were easy to conflate:
+`-f markdown-markdown_in_html_blocks` (dropping only that extension, keeping
+`native_divs`) still parses the markdown and still emits `<p>`. The two
+extensions interact — `markdown_in_html_blocks` only has an observable effect
+once `native_divs` is off, which is precisely the configuration PR #646 put
+q2 into. Dropping `native_divs` alone was safe; dropping it *and* lifting
+verbatim was not.
+
+`syntax-notes.md`'s objection is specifically to *parsing HTML into AST
+structure* via backtracking parser combinators — i.e. `native_divs`. It does
+not speak to `markdown_in_html_blocks`. The strand is right that the
+constraint does not block this fix.
+
+## 2. What it takes — spiked and measured
+
+**Reader side (small).** The inline content is *already parsed* when the lift
+happens: `process_paragraph` builds a full `Vec<Inline>` and then throws it
+away in favour of re-reading the source bytes. The fix is to partition that
+existing vector into runs — block-level-HTML `RawInline`s become `RawBlock`s,
+everything else becomes `Plain` — and return
+`IntermediateSection(Vec<Block>)`, which every block container already
+splices (`treesitter.rs:340`, `document.rs`, `section.rs`, `block_quote.rs`,
+`fenced_div_block.rs`, `note_definition_fenced_block.rs`).
+
+This needs **no tag matching**: the predicate is per-inline and already
+exists (`starts_block_html`). The paragraph boundary already fixes the
+extent. Confirmed: the spike produced an AST identical to
+`pandoc -f markdown-native_divs` for the tight `<div>` case.
+
+Two reader-side details the spike surfaced:
+
+- `RawInline.text` for a *non-first* inline carries **leading whitespace**
+  (`" <!-- second -->"`), so `starts_block_html` must be applied to
+  `text.trim_start()`. Without this, `<!-- a --> <!-- b --> <!-- c -->` on
+  one line splits wrongly. The existing `paragraph_starts_block_html` never
+  hit this because it only inspects the first inline.
+- Each split block needs its **own** `SourceInfo` derived from the child
+  nodes. Cloning the paragraph's `SourceInfo` onto every part (what the spike
+  did) gives sibling blocks identical overlapping ranges and confuses the
+  incremental writer.
+
+**Writer side (the real cost, and mandatory).** `write_rawblock` emits a
+non-markdown `RawBlock` as a ```` ```{=html} ```` fence, and every block
+container unconditionally emits a blank line between blocks. So a split trio
+round-trips to:
+
+````
+```{=html}
+<div class="case-b">
+```
+
+Case B text with a `code span` and *emphasis*.
+
+```{=html}
+</div>
+```
+````
+
+which re-parses as `RawBlock, **Para**, RawBlock` — a `Plain`→`Para` drift.
+That is exactly the `incremental_writer_tests::roundtrip_comment_in_blockquote`
+failure. Today's merged behaviour round-trips *structurally stable* (one
+`RawBlock` → one fence → same `RawBlock`), so the split makes round-tripping
+strictly worse unless the writer is changed with it.
+
+Pandoc round-trips the same AST **byte-identically**. Its rule is entirely
+AST-derivable: write an html `RawBlock` verbatim, and write `Plain` with no
+blank line after it — which is what `Plain` *means*. I spiked both changes
+and the q2 round-trip closed completely: byte-identical source, identical
+reparse.
+
+The cost is that the blank-line suppression must be applied at **every** block
+container, not just `write_impl`. My spike patched only the top level, which
+is why the blockquote test still failed.
+
+**Conflict to decide.** The writer change contradicts a deliberate PR #646
+choice: `test_html_block_lift::naked_block_round_trips_as_an_explicit_raw_fence`
+asserts that naked HTML normalises to the documented ```` ```{=html} ````
+spelling. Writing it verbatim reverses that. These can be reconciled — a
+`RawBlock` adjacent to a `Plain` in a tight run writes bare, an isolated one
+stays fenced, and that is decidable from the AST — but it is a design call,
+not a mechanical edit.
+
+## 3. Where exact parity stops being reachable
+
+This is the part that changes the shape of the fix, and it argues *against*
+the strand's implied ambition.
+
+Pandoc's choice between `Plain` and `Para` for the interior is **not**
+expressible as a local rule. Measured:
+
+| input | pandoc blocks |
+| --- | --- |
+| `<div>\ntext\n</div>` | RawBlock, **Plain**, RawBlock |
+| `<div>\nunclosed text` | RawBlock, **Para** |
+| `<div class="x"> text after` | RawBlock, **Para** |
+| `<div>\ntext\n</div>\nmore` | RawBlock, Plain, RawBlock, **Para** |
+| `<div>\ntext\n</div>\nmore\n<div>\nagain\n</div>` | RawBlock, Plain, RawBlock, **Plain**, RawBlock, Plain, RawBlock |
+
+The same text `more` is `Para` in one and `Plain` in the other, decided by
+what follows it. And `<div>\ntext\n</div>\nmore` ends the block at the
+balanced `</div>` — under plain CommonMark type-6 semantics it would run to
+the blank line. Pandoc is tracking open elements.
+
+So: **the strand's claim that the fix needs no balanced tag matching is right
+for the split itself, but wrong if the goal is exact pandoc parity.** Chasing
+the `Plain`/`Para` distinction means reimplementing pandoc's HTML block
+parser, which is what `syntax-notes.md` rejects.
+
+**This does not matter for the reported bug.** The bug is literal backticks;
+`Plain` vs `Para` only decides a `<p>` wrapper. Against **Quarto 1** — the
+actual porting baseline — the spike matches on *every* markdown-parsing
+question:
+
+```
+                        Quarto 1                       q2 spike
+<div class="s1">   inside <code>code</code>       inside <code>code</code>
+<div class="s2">   text ... <code>code</code>     text ... <code>code</code>
+<details>/<summary> Sum <code>code</code>          Sum <code>code</code>
+nested divs        nested <code>code</code>       nested <code>code</code>
+<pre>              raw `code` *em*  (literal)      raw `code` *em*  (literal)
+```
+
+Every residual difference is a `<p>` wrapper, i.e. the already-accepted
+`native_divs` gap. **Recommendation: emit `Plain` unconditionally for split
+interiors and document the divergence.** Do not track open elements.
+
+## 4. Blast radius
+
+**The `<pre>` exception is real and the strand did not have it.** Measured
+across the whitelist: `pre`, `script`, `style`, `textarea` — CommonMark's
+HTML block type 1 raw-text set — keep their content **verbatim** in pandoc.
+All four are in q2's `BLOCK_TAGS`. A blanket split would newly break them by
+parsing markdown inside a `<script>`. Every other tag probed (`title`,
+`iframe`, `noscript`, `svg`, `canvas`, `object`, `section`, `table`/`tr`/`td`,
+`div`, `details`) splits. So the ~60-tag whitelist partitions cleanly 4 / 56,
+and the guard is a first-inline check — no state needed.
+
+**Test blast radius, whole workspace, both spikes applied:**
+
+```
+baseline (branch HEAD, clean)  13676 tests run: 13676 passed, 0 failed, 199 skipped
+with both spikes applied       13676 tests run: 13669 passed, 7 failed, 199 skipped
+```
+
+The run count is identical, so the spike added no tests and every failure is
+an existing test changing behaviour — a clean delta of exactly 7.
+
+All 7 in `pampa`; nothing downstream (`quarto-core`, hub, WASM untouched):
+
+| test | nature |
+| --- | --- |
+| `test::unit_test_snapshots_json` | 1 snapshot, `html-comment-17` |
+| `test_html_block_lift::details_summary_becomes_one_raw_block_verbatim` | asserts merged behaviour |
+| `test_html_block_lift::details_renders_without_paragraph_wrappers` | asserts merged behaviour |
+| `test_html_block_lift::container_prefixes_are_stripped_from_a_multi_line_block` | asserts merged behaviour |
+| `test_html_block_lift::naked_block_round_trips_as_an_explicit_raw_fence` | **design conflict** (§2) |
+| `test_warnings::test_block_level_html_elements` | Q-2-9 quotes `<div>` not `<div>content</div>` |
+| `incremental_writer_tests::roundtrip_comment_in_blockquote` | **real breakage** — writer, per-container |
+
+Only one snapshot moves, far less churn than PR #646's 27.
+
+Note `test_warnings`: Q-2-9's diagnostic currently quotes the whole lifted
+block. After a split it quotes just the tag. Worth deciding deliberately —
+the tag alone is arguably the better diagnostic.
+
+## 5. Recommendation
+
+Do it, in this order, TDD per repo rules:
+
+1. Reader: partition the already-parsed inlines into `RawBlock`/`Plain` runs;
+   return `IntermediateSection`. Trim leading whitespace before
+   `starts_block_html`. Give each part its own `SourceInfo`.
+2. Guard the type-1 raw-text set (`pre`/`script`/`style`/`textarea`) with a
+   first-inline check; those keep today's verbatim path.
+3. Writer: make `Plain` tight and lifted block-html `RawBlock`s verbatim, at
+   **every** block container. Resolve the fence-normalisation conflict by
+   keeping the fence for an isolated `RawBlock` and writing bare only within
+   a tight run.
+4. Accept `Plain`-always for interiors; document the `Plain`/`Para` and
+   `native_divs` divergences alongside the existing "no naked HTML" notes.
+5. Regression tests from both repro fixtures; both must stay green together.
+
+**Open design question for Gordon** (§2): should naked HTML still normalise
+to a ```` ```{=html} ```` fence on round-trip, as PR #646 deliberately chose?
+Preserving it needs the adjacency rule in step 3; dropping it is simpler and
+matches pandoc, but reverses an intentional decision.
diff --git a/crates/pampa/README.md b/crates/pampa/README.md
index 4bc445c57..74cda6c5d 100644
--- a/crates/pampa/README.md
+++ b/crates/pampa/README.md
@@ -76,7 +76,10 @@ A robust parser for QMD documents will enable more robust treatment in editors,
 These are non-exhaustive and will only list intentional differences.
 We will, aspirationally, treat unintentional differences as bugs.
 
-- no naked HTML support: use `{=html}` raw blocks an inlines
+- no naked HTML support: use `{=html}` raw blocks an inlines. It is accepted
+  with a `Q-2-9` warning; markdown inside it is parsed, but `<div>`/`<span>`
+  are not promoted to `Div`/`Span` nodes, so their contents are not wrapped
+  in `<p>`. See dev-docs/syntax-notes.md "No naked HTML support".
 - no grid tables: use `{<markdown}`, [list tables](https://github.com/pandoc-ext/list-table), or Quarto's [HTML-as-table-AST mode](https://quarto.org/docs/authoring/tables.html#html-tables)
 
 ## Syntax escape hatches
diff --git a/crates/pampa/snapshots/json/html-comment-17-comment-at-line-start.snap b/crates/pampa/snapshots/json/html-comment-17-comment-at-line-start.snap
index c9d6f1d40..f63d95938 100644
--- a/crates/pampa/snapshots/json/html-comment-17-comment-at-line-start.snap
+++ b/crates/pampa/snapshots/json/html-comment-17-comment-at-line-start.snap
@@ -3,4 +3,4 @@ source: crates/pampa/tests/integration/test.rs
 assertion_line: 550
 expression: output
 ---
-{"blocks":[{"a":{"classes":[],"id":null,"kvs":[]},"c":[1,["test-17-comment-at-start-of-line",[],[]],[{"c":"Test","s":1,"t":"Str"},{"s":2,"t":"Space"},{"c":"17:","s":5,"t":"Str"},{"s":6,"t":"Space"},{"c":"Comment","s":7,"t":"Str"},{"s":8,"t":"Space"},{"c":"at","s":9,"t":"Str"},{"s":10,"t":"Space"},{"c":"start","s":11,"t":"Str"},{"s":12,"t":"Space"},{"c":"of","s":13,"t":"Str"},{"s":14,"t":"Space"},{"c":"line","s":15,"t":"Str"}]],"s":0,"t":"Header"},{"c":["html","<!-- Comment at line start --> followed by text"],"s":16,"t":"RawBlock"}],"meta":{},"pandoc-api-version":[1,23,1],"astContext":{"files":[{"line_breaks":[35,36,84],"name":"tests/snapshots/json/html-comment-17-comment-at-line-start.qmd","total_length":85}],"p":[{"d":0,"r":[0,36],"t":0},{"d":0,"r":[2,6],"t":0},{"d":0,"r":[6,7],"t":0},{"d":0,"r":[7,9],"t":0},{"d":0,"r":[9,10],"t":0},{"d":[[3,0,2],[4,2,1]],"r":[0,3],"t":2},{"d":0,"r":[10,11],"t":0},{"d":0,"r":[11,18],"t":0},{"d":0,"r":[18,19],"t":0},{"d":0,"r":[19,21],"t":0},{"d":0,"r":[21,22],"t":0},{"d":0,"r":[22,27],"t":0},{"d":0,"r":[27,28],"t":0},{"d":0,"r":[28,30],"t":0},{"d":0,"r":[30,31],"t":0},{"d":0,"r":[31,35],"t":0},{"d":0,"r":[37,85],"t":0}]}}
+{"blocks":[{"a":{"classes":[],"id":null,"kvs":[]},"c":[1,["test-17-comment-at-start-of-line",[],[]],[{"c":"Test","s":1,"t":"Str"},{"s":2,"t":"Space"},{"c":"17:","s":5,"t":"Str"},{"s":6,"t":"Space"},{"c":"Comment","s":7,"t":"Str"},{"s":8,"t":"Space"},{"c":"at","s":9,"t":"Str"},{"s":10,"t":"Space"},{"c":"start","s":11,"t":"Str"},{"s":12,"t":"Space"},{"c":"of","s":13,"t":"Str"},{"s":14,"t":"Space"},{"c":"line","s":15,"t":"Str"}]],"s":0,"t":"Header"},{"c":["html","<!-- Comment at line start -->"],"s":16,"t":"RawBlock"},{"c":[{"c":"followed","s":18,"t":"Str"},{"s":19,"t":"Space"},{"c":"by","s":20,"t":"Str"},{"s":21,"t":"Space"},{"c":"text","s":22,"t":"Str"}],"s":17,"t":"Plain"}],"meta":{},"pandoc-api-version":[1,23,1],"astContext":{"files":[{"line_breaks":[35,36,84],"name":"tests/snapshots/json/html-comment-17-comment-at-line-start.qmd","total_length":85}],"p":[{"d":0,"r":[0,36],"t":0},{"d":0,"r":[2,6],"t":0},{"d":0,"r":[6,7],"t":0},{"d":0,"r":[7,9],"t":0},{"d":0,"r":[9,10],"t":0},{"d":[[3,0,2],[4,2,1]],"r":[0,3],"t":2},{"d":0,"r":[10,11],"t":0},{"d":0,"r":[11,18],"t":0},{"d":0,"r":[18,19],"t":0},{"d":0,"r":[19,21],"t":0},{"d":0,"r":[21,22],"t":0},{"d":0,"r":[22,27],"t":0},{"d":0,"r":[27,28],"t":0},{"d":0,"r":[28,30],"t":0},{"d":0,"r":[30,31],"t":0},{"d":0,"r":[31,35],"t":0},{"d":0,"r":[37,67],"t":0},{"d":0,"r":[68,84],"t":0},{"d":0,"r":[68,76],"t":0},{"d":0,"r":[76,77],"t":0},{"d":0,"r":[77,79],"t":0},{"d":0,"r":[79,80],"t":0},{"d":0,"r":[80,84],"t":0}]}}
diff --git a/crates/pampa/snapshots/json/html-comment-44-comment-starts-at-block-boundary.snap b/crates/pampa/snapshots/json/html-comment-44-comment-starts-at-block-boundary.snap
index ca4ebfb13..94da80b4c 100644
--- a/crates/pampa/snapshots/json/html-comment-44-comment-starts-at-block-boundary.snap
+++ b/crates/pampa/snapshots/json/html-comment-44-comment-starts-at-block-boundary.snap
@@ -3,4 +3,4 @@ source: crates/pampa/tests/integration/test.rs
 assertion_line: 550
 expression: output
 ---
-{"blocks":[{"a":{"classes":[],"id":null,"kvs":[]},"c":[1,["test-44-comment-starts-at-block-boundary-start-of-paragraph",[],[]],[{"c":"Test","s":1,"t":"Str"},{"s":2,"t":"Space"},{"c":"44:","s":5,"t":"Str"},{"s":6,"t":"Space"},{"c":"Comment","s":7,"t":"Str"},{"s":8,"t":"Space"},{"c":"starts","s":9,"t":"Str"},{"s":10,"t":"Space"},{"c":"at","s":11,"t":"Str"},{"s":12,"t":"Space"},{"c":"block","s":13,"t":"Str"},{"s":14,"t":"Space"},{"c":"boundary","s":15,"t":"Str"},{"s":16,"t":"Space"},{"c":"(start","s":19,"t":"Str"},{"s":20,"t":"Space"},{"c":"of","s":21,"t":"Str"},{"s":22,"t":"Space"},{"c":"paragraph)","s":25,"t":"Str"}]],"s":0,"t":"Header"},{"c":["html","<!-- Comment starts at beginning of what would be a paragraph\n\n* List is commented\n* Still commented\n\n--> Continues after comment."],"s":26,"t":"RawBlock"}],"meta":{},"pandoc-api-version":[1,23,1],"astContext":{"files":[{"line_breaks":[64,65,127,128,148,166,167,196],"name":"tests/snapshots/json/html-comment-44-comment-starts-at-block-boundary.qmd","total_length":197}],"p":[{"d":0,"r":[0,65],"t":0},{"d":0,"r":[2,6],"t":0},{"d":0,"r":[6,7],"t":0},{"d":0,"r":[7,9],"t":0},{"d":0,"r":[9,10],"t":0},{"d":[[3,0,2],[4,2,1]],"r":[0,3],"t":2},{"d":0,"r":[10,11],"t":0},{"d":0,"r":[11,18],"t":0},{"d":0,"r":[18,19],"t":0},{"d":0,"r":[19,25],"t":0},{"d":0,"r":[25,26],"t":0},{"d":0,"r":[26,28],"t":0},{"d":0,"r":[28,29],"t":0},{"d":0,"r":[29,34],"t":0},{"d":0,"r":[34,35],"t":0},{"d":0,"r":[35,43],"t":0},{"d":0,"r":[43,44],"t":0},{"d":0,"r":[44,45],"t":0},{"d":0,"r":[45,50],"t":0},{"d":[[17,0,1],[18,1,5]],"r":[0,6],"t":2},{"d":0,"r":[50,51],"t":0},{"d":0,"r":[51,53],"t":0},{"d":0,"r":[53,54],"t":0},{"d":0,"r":[54,63],"t":0},{"d":0,"r":[63,64],"t":0},{"d":[[23,0,9],[24,9,1]],"r":[0,10],"t":2},{"d":0,"r":[66,197],"t":0}]}}
+{"blocks":[{"a":{"classes":[],"id":null,"kvs":[]},"c":[1,["test-44-comment-starts-at-block-boundary-start-of-paragraph",[],[]],[{"c":"Test","s":1,"t":"Str"},{"s":2,"t":"Space"},{"c":"44:","s":5,"t":"Str"},{"s":6,"t":"Space"},{"c":"Comment","s":7,"t":"Str"},{"s":8,"t":"Space"},{"c":"starts","s":9,"t":"Str"},{"s":10,"t":"Space"},{"c":"at","s":11,"t":"Str"},{"s":12,"t":"Space"},{"c":"block","s":13,"t":"Str"},{"s":14,"t":"Space"},{"c":"boundary","s":15,"t":"Str"},{"s":16,"t":"Space"},{"c":"(start","s":19,"t":"Str"},{"s":20,"t":"Space"},{"c":"of","s":21,"t":"Str"},{"s":22,"t":"Space"},{"c":"paragraph)","s":25,"t":"Str"}]],"s":0,"t":"Header"},{"c":["html","<!-- Comment starts at beginning of what would be a paragraph\n\n* List is commented\n* Still commented\n\n-->"],"s":26,"t":"RawBlock"},{"c":[{"c":"Continues","s":28,"t":"Str"},{"s":29,"t":"Space"},{"c":"after","s":30,"t":"Str"},{"s":31,"t":"Space"},{"c":"comment.","s":32,"t":"Str"}],"s":27,"t":"Plain"}],"meta":{},"pandoc-api-version":[1,23,1],"astContext":{"files":[{"line_breaks":[64,65,127,128,148,166,167,196],"name":"tests/snapshots/json/html-comment-44-comment-starts-at-block-boundary.qmd","total_length":197}],"p":[{"d":0,"r":[0,65],"t":0},{"d":0,"r":[2,6],"t":0},{"d":0,"r":[6,7],"t":0},{"d":0,"r":[7,9],"t":0},{"d":0,"r":[9,10],"t":0},{"d":[[3,0,2],[4,2,1]],"r":[0,3],"t":2},{"d":0,"r":[10,11],"t":0},{"d":0,"r":[11,18],"t":0},{"d":0,"r":[18,19],"t":0},{"d":0,"r":[19,25],"t":0},{"d":0,"r":[25,26],"t":0},{"d":0,"r":[26,28],"t":0},{"d":0,"r":[28,29],"t":0},{"d":0,"r":[29,34],"t":0},{"d":0,"r":[34,35],"t":0},{"d":0,"r":[35,43],"t":0},{"d":0,"r":[43,44],"t":0},{"d":0,"r":[44,45],"t":0},{"d":0,"r":[45,50],"t":0},{"d":[[17,0,1],[18,1,5]],"r":[0,6],"t":2},{"d":0,"r":[50,51],"t":0},{"d":0,"r":[51,53],"t":0},{"d":0,"r":[53,54],"t":0},{"d":0,"r":[54,63],"t":0},{"d":0,"r":[63,64],"t":0},{"d":[[23,0,9],[24,9,1]],"r":[0,10],"t":2},{"d":0,"r":[66,171],"t":0},{"d":0,"r":[172,196],"t":0},{"d":0,"r":[172,181],"t":0},{"d":0,"r":[181,182],"t":0},{"d":0,"r":[182,187],"t":0},{"d":0,"r":[187,188],"t":0},{"d":0,"r":[188,196],"t":0}]}}
diff --git a/crates/pampa/src/pandoc/treesitter_utils/html_block.rs b/crates/pampa/src/pandoc/treesitter_utils/html_block.rs
index a86ad88d6..6da71e2be 100644
--- a/crates/pampa/src/pandoc/treesitter_utils/html_block.rs
+++ b/crates/pampa/src/pandoc/treesitter_utils/html_block.rs
@@ -122,9 +122,8 @@ const BLOCK_TAGS: &[&str] = &[
 /// instructions — which pandoc's `isBlockTag` also treats as block-level and
 /// which CommonMark covers with HTML block types 2 through 5.
 pub fn starts_block_html(text: &str) -> bool {
-    let rest = match text.strip_prefix('<') {
-        Some(rest) => rest,
-        None => return false,
+    let Some(rest) = text.strip_prefix('<') else {
+        return false;
     };
 
     // `<!--comment-->`, `<!DOCTYPE …>`, `<![CDATA[…]]>`, `<?php …?>`
@@ -132,25 +131,59 @@ pub fn starts_block_html(text: &str) -> bool {
         return true;
     }
 
-    let rest = rest.strip_prefix('/').unwrap_or(rest);
+    matches!(tag_name(text), Some((_, name)) if BLOCK_TAGS.binary_search(&name.as_str()).is_ok())
+}
+
+/// Tag names whose content is *raw text*: markdown is not parsed inside them.
+///
+/// CommonMark's HTML block type 1, and pandoc agrees — `pandoc -f markdown`
+/// leaves a code span inside `<pre>` or `<script>` as literal backticks while
+/// parsing one inside `<div>` or `<section>`. All four are in [`BLOCK_TAGS`],
+/// so the interior split in `paragraph.rs` has to exempt them explicitly or it
+/// would start parsing markdown inside a `<script>`.
+const RAW_TEXT_TAGS: &[&str] = &["pre", "script", "style", "textarea"];
+
+/// Does `text` open a raw-text element ([`RAW_TEXT_TAGS`])?
+///
+/// Only the *opening* tag counts: CommonMark's type-1 start condition is
+/// `<pre`, `<script`, `<style`, `<textarea` — a closing tag does not begin a
+/// raw-text block, so `</pre>` is false.
+pub fn starts_raw_text_element(text: &str) -> bool {
+    matches!(tag_name(text), Some((false, name)) if RAW_TEXT_TAGS.contains(&name.as_str()))
+}
+
+/// The tag name at the head of `text`, lowercased, with a flag for whether it
+/// is a closing tag.
+///
+/// `None` when `text` does not begin a well-formed tag, including the `<!…`
+/// and `<?…` forms, which have no name. The name must end at a delimiter, so
+/// `<divider>` does not read as `<div>`.
+///
+/// Shared by [`starts_block_html`] and [`starts_raw_text_element`] so the two
+/// cannot disagree about what a tag name is.
+fn tag_name(text: &str) -> Option<(bool, String)> {
+    let rest = text.strip_prefix('<')?;
+    if rest.starts_with('!') || rest.starts_with('?') {
+        return None;
+    }
+    let (closing, rest) = match rest.strip_prefix('/') {
+        Some(rest) => (true, rest),
+        None => (false, rest),
+    };
     let name_len = rest
         .find(|c: char| !c.is_ascii_alphanumeric())
         .unwrap_or(rest.len());
     if name_len == 0 {
-        return false;
+        return None;
     }
     let (name, after) = rest.split_at(name_len);
-
     // The tag name must actually end here: `<divider>` is not a `<div>`.
-    if !after.is_empty() {
-        let next = after.as_bytes()[0];
-        if !matches!(next, b' ' | b'\t' | b'\r' | b'\n' | b'>' | b'/') {
-            return false;
-        }
+    if let Some(&next) = after.as_bytes().first()
+        && !matches!(next, b' ' | b'\t' | b'\r' | b'\n' | b'>' | b'/')
+    {
+        return None;
     }
-
-    let name = name.to_ascii_lowercase();
-    BLOCK_TAGS.binary_search(&name.as_str()).is_ok()
+    Some((closing, name.to_ascii_lowercase()))
 }
 
 /// Is the byte at `offset` the first non-prefix content on its line?
diff --git a/crates/pampa/src/pandoc/treesitter_utils/paragraph.rs b/crates/pampa/src/pandoc/treesitter_utils/paragraph.rs
index 7aa580fa1..f95e221a7 100644
--- a/crates/pampa/src/pandoc/treesitter_utils/paragraph.rs
+++ b/crates/pampa/src/pandoc/treesitter_utils/paragraph.rs
@@ -4,11 +4,12 @@
  */
 
 use crate::pandoc::ast_context::ASTContext;
-use crate::pandoc::block::{Block, Paragraph, RawBlock};
+use crate::pandoc::block::{Block, Paragraph, Plain, RawBlock};
 use crate::pandoc::inline::{Inline, InlineAttr};
 use crate::pandoc::location::node_source_info_with_context;
-use crate::pandoc::treesitter_utils::html_block::starts_block_html;
+use crate::pandoc::treesitter_utils::html_block::{starts_block_html, starts_raw_text_element};
 use crate::pandoc::treesitter_utils::pandocnativeintermediate::PandocNativeIntermediate;
+use quarto_source_map::{FileId, SourceInfo};
 
 /// Process a paragraph node, collecting inlines and filtering out block continuations
 pub fn process_paragraph(
@@ -43,10 +44,23 @@ pub fn process_paragraph(
         // bd-block-html-wrapped-in-p-w8qebxig.
         let text = verbatim_text(node, input_bytes);
         if !text.is_empty() {
+            let source_info = node_source_info_with_context(node, context);
+
+            // Runs of tags stay raw; the text between them goes back through
+            // the inline parser. This is pandoc's `markdown_in_html_blocks`.
+            // Raw-text elements (`<pre>`, `<script>`, …) are exempt: their
+            // content is not markdown in the first place.
+            if !paragraph_starts_raw_text_element(&inlines) {
+                let parts = split_html_block_runs(&inlines, &source_info);
+                if parts.len() > 1 {
+                    return PandocNativeIntermediate::IntermediateSection(parts);
+                }
+            }
+
             return PandocNativeIntermediate::IntermediateBlock(Block::RawBlock(RawBlock {
                 format: "html".to_string(),
                 text,
-                source_info: node_source_info_with_context(node, context),
+                source_info,
             }));
         }
     }
@@ -59,6 +73,12 @@ pub fn process_paragraph(
 
 /// Does this paragraph open with raw HTML that belongs in a block position?
 ///
+/// The text is trimmed before the test, as in [`is_block_html`] and
+/// [`paragraph_starts_raw_text_element`]: the grammar happens to emit leading
+/// whitespace as its own `Space` inline, so it makes no difference here today,
+/// but three predicates asking the same question should not answer it three
+/// different ways.
+///
 /// Leading whitespace is skipped: the grammar admits `_inline_whitespace`
 /// before the first element, and CommonMark allows an HTML block to be
 /// indented. Anything else before the tag — ordinary text, a link, an
@@ -69,7 +89,7 @@ fn paragraph_starts_block_html(inlines: &[Inline]) -> bool {
         match inline {
             Inline::Space(_) | Inline::SoftBreak(_) => continue,
             Inline::RawInline(raw) => {
-                return raw.format == "html" && starts_block_html(&raw.text);
+                return raw.format == "html" && starts_block_html(raw.text.trim_start());
             }
             _ => return false,
         }
@@ -122,3 +142,173 @@ fn verbatim_text(node: &tree_sitter::Node, input_bytes: &[u8]) -> String {
 
     out.trim().to_string()
 }
+
+/// Does this paragraph open a raw-text element (`<pre>`, `<script>`, …)?
+///
+/// Their content is not markdown, so the whole paragraph stays one verbatim
+/// `RawBlock` rather than being split. Mirrors the leading-whitespace skipping
+/// in [`paragraph_starts_block_html`].
+fn paragraph_starts_raw_text_element(inlines: &[Inline]) -> bool {
+    for inline in inlines {
+        match inline {
+            Inline::Space(_) | Inline::SoftBreak(_) => continue,
+            Inline::RawInline(raw) => {
+                return raw.format == "html" && starts_raw_text_element(raw.text.trim_start());
+            }
+            _ => return false,
+        }
+    }
+    false
+}
+
+/// Is this inline a block-level raw HTML tag?
+///
+/// The text is trimmed first: only the *first* inline of a paragraph starts at
+/// a token boundary. tree-sitter folds the whitespace preceding a later inline
+/// into that inline's text, so `<!-- a --> <!-- b -->` yields a second
+/// `RawInline` whose text is `" <!-- b -->"` — which `starts_block_html`
+/// rejects, since it tests for a leading `<`.
+fn is_block_html(inline: &Inline) -> bool {
+    matches!(inline, Inline::RawInline(raw)
+        if raw.format == "html" && starts_block_html(raw.text.trim_start()))
+}
+
+/// The span covering `inlines`, in the offset space of `fallback`.
+///
+/// Each part of a split needs its own range: handing every part the whole
+/// paragraph's `SourceInfo` gives sibling blocks identical overlapping spans,
+/// which misleads the incremental writer about what text each block owns.
+fn span_of<'a>(infos: impl Iterator<Item = &'a SourceInfo>, fallback: &SourceInfo) -> SourceInfo {
+    let mut first: Option<&SourceInfo> = None;
+    let mut bounds: Option<(FileId, usize, usize)> = None;
+    let mut all_original = true;
+
+    for info in infos {
+        if first.is_none() {
+            first = Some(info);
+        }
+        match info {
+            SourceInfo::Original {
+                file_id,
+                start_offset,
+                end_offset,
+            } => {
+                bounds = Some(match bounds {
+                    None => (*file_id, *start_offset, *end_offset),
+                    Some((f, s, e)) if f == *file_id => {
+                        (f, s.min(*start_offset), e.max(*end_offset))
+                    }
+                    // Offsets from two files would union into nonsense.
+                    Some(prev) => {
+                        all_original = false;
+                        prev
+                    }
+                });
+            }
+            _ => all_original = false,
+        }
+    }
+
+    match (all_original, bounds) {
+        // The common case: every inline came from the document, so union them
+        // into one tight range.
+        (true, Some((file_id, start_offset, end_offset))) => SourceInfo::Original {
+            file_id,
+            start_offset,
+            end_offset,
+        },
+        // Not everything here carries a file offset. Metadata block scalars
+        // reach this arm: `include-in-header: - text: |` is parsed as markdown,
+        // and its inlines carry the YAML value's provenance rather than a range
+        // in the document. Take the run's *first* span rather than the whole
+        // paragraph's — it is distinct per run, so sibling blocks do not all
+        // collide on one range the way the paragraph's would.
+        _ => first.cloned().unwrap_or_else(|| fallback.clone()),
+    }
+}
+
+/// Split a lifted paragraph into raw-HTML runs and parsed content.
+///
+/// Consecutive block-level raw HTML tags coalesce into one `RawBlock`, joined
+/// by newlines so the original line structure survives; everything else
+/// becomes a `Plain`. Both decisions are local — each inline is classified on
+/// its own, with no tag matching and no lookahead — so this stays inside the
+/// no-backtracking constraint in `dev-docs/syntax-notes.md`.
+///
+/// The interiors are always `Plain`, never `Paragraph`. Pandoc picks between
+/// the two by tracking which element is still open, which needs the balanced
+/// matching we do not do; the difference is only whether a `<p>` wrapper
+/// appears, which is the `native_divs` gap qmd already accepts. See
+/// `claude-notes/research/2026-09-03-block-html-adjacent-markdown-unparsed.md`.
+fn split_html_block_runs(inlines: &[Inline], paragraph_si: &SourceInfo) -> Vec<Block> {
+    let mut blocks: Vec<Block> = Vec::new();
+    let mut raw_run: Vec<&Inline> = Vec::new();
+    let mut content_run: Vec<Inline> = Vec::new();
+
+    fn flush_raw(run: &mut Vec<&Inline>, out: &mut Vec<Block>, fallback: &SourceInfo) {
+        if run.is_empty() {
+            return;
+        }
+        let text = run
+            .iter()
+            .filter_map(|i| match i {
+                Inline::RawInline(raw) => Some(raw.text.trim()),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        let source_info = span_of(run.iter().map(|i| i.source_info()), fallback);
+        out.push(Block::RawBlock(RawBlock {
+            format: "html".to_string(),
+            text,
+            source_info,
+        }));
+        run.clear();
+    }
+
+    fn flush_content(run: &mut Vec<Inline>, out: &mut Vec<Block>, fallback: &SourceInfo) {
+        while matches!(
+            run.last(),
+            Some(Inline::Space(_) | Inline::SoftBreak(_) | Inline::LineBreak(_))
+        ) {
+            run.pop();
+        }
+        if run.is_empty() {
+            return;
+        }
+        let source_info = span_of(run.iter().map(|i| i.source_info()), fallback);
+        out.push(Block::Plain(Plain {
+            content: std::mem::take(run),
+            source_info,
+        }));
+    }
+
+    for inline in inlines {
+        if is_block_html(inline) {
+            flush_content(&mut content_run, &mut blocks, paragraph_si);
+            raw_run.push(inline);
+        } else if matches!(
+            inline,
+            Inline::Space(_) | Inline::SoftBreak(_) | Inline::LineBreak(_)
+        ) {
+            // A separator between two raw tags is the line break the join
+            // above re-creates, so it only matters inside a content run.
+            //
+            // `LineBreak` belongs here as much as `SoftBreak` does: trailing
+            // spaces on a tag line are invisible in the source but make the
+            // reader emit a hard break, and treating that as content rendered
+            // a spurious `<br />` before the text — or, with nothing between
+            // the tags, a `Plain` holding the break alone.
+            if !content_run.is_empty() {
+                content_run.push(inline.clone());
+            }
+        } else {
+            flush_raw(&mut raw_run, &mut blocks, paragraph_si);
+            content_run.push(inline.clone());
+        }
+    }
+    flush_content(&mut content_run, &mut blocks, paragraph_si);
+    flush_raw(&mut raw_run, &mut blocks, paragraph_si);
+
+    blocks
+}
diff --git a/crates/pampa/src/writers/qmd.rs b/crates/pampa/src/writers/qmd.rs
index be925431e..0a48efbeb 100644
--- a/crates/pampa/src/writers/qmd.rs
+++ b/crates/pampa/src/writers/qmd.rs
@@ -8,6 +8,7 @@ use crate::pandoc::block::MetaBlock;
 use crate::pandoc::inline::Inline;
 use crate::pandoc::list::{ListNumberDelim, ListNumberStyle};
 use crate::pandoc::table::{Alignment, Cell, ColWidth, Row, Table};
+use crate::pandoc::treesitter_utils::html_block::{starts_block_html, starts_raw_text_element};
 use crate::pandoc::{
     Block, BlockQuote, BulletList, CodeBlock, DefinitionList, Figure, Header, HorizontalRule,
     LineBlock, OrderedList, Pandoc, Paragraph, Plain, RawBlock, Str,
@@ -548,6 +549,96 @@ fn write_blockquote(
     Ok(())
 }
 
+/// Is this line made up solely of complete HTML tags?
+///
+/// Quoted attribute values are skipped, so `<div data-x="a>b">` is one tag.
+fn line_is_only_tags(line: &str) -> bool {
+    let mut rest = line.trim();
+    let mut saw_tag = false;
+    while !rest.is_empty() {
+        if !rest.starts_with('<') {
+            return false;
+        }
+        // A comment ends at `-->`, not at the first `>`: `<!-- a -> b -->`
+        // is one unit, and scanning to `>` would strand `b -->` as non-tag
+        // text and fence a run that did not need it.
+        if let Some(body) = rest.strip_prefix("<!--") {
+            let Some(end) = body.find("-->") else {
+                return false;
+            };
+            rest = body[end + 3..].trim_start();
+            saw_tag = true;
+            continue;
+        }
+        let bytes = rest.as_bytes();
+        let mut i = 1;
+        let mut quote: Option<u8> = None;
+        let mut closed = false;
+        while i < bytes.len() {
+            let c = bytes[i];
+            match quote {
+                Some(q) if c == q => quote = None,
+                Some(_) => {}
+                None if c == b'"' || c == b'\'' => quote = Some(c),
+                None if c == b'>' => {
+                    closed = true;
+                    i += 1;
+                    break;
+                }
+                None => {}
+            }
+            i += 1;
+        }
+        if !closed {
+            return false;
+        }
+        rest = rest[i..].trim_start();
+        saw_tag = true;
+    }
+    saw_tag
+}
+
+/// Would writing `text` bare — with no ```` ```{=html} ```` fence — read back
+/// as exactly one `RawBlock` holding this same text?
+///
+/// Only two shapes qualify, and they are exactly the two the lift in
+/// `paragraph.rs` produces:
+///
+///   * a pure run of block-level tags, which the lift re-forms on the next
+///     read, and
+///   * a raw-text element (`<pre>`, `<script>`, …), whose interior the reader
+///     deliberately leaves unparsed.
+///
+/// Anything else has to keep its fence. An author-written ```` ```{=html} ````
+/// block may hold arbitrary text, and bare it would be *parsed* on the next
+/// read — a backtick becoming `Code`, a `#` line after a blank line becoming a
+/// real `Header`. That is content corruption through any AST -> qmd -> read
+/// cycle, so the test is on the text, not merely on its first tag.
+fn round_trips_bare_html(text: &str) -> bool {
+    // A blank line ends the HTML block, so the rest would come back separately.
+    if text.lines().any(|line| line.trim().is_empty()) {
+        return false;
+    }
+    if !starts_block_html(text) {
+        return false;
+    }
+    starts_raw_text_element(text) || text.lines().all(line_is_only_tags)
+}
+
+/// Does [`write_rawblock`] emit this raw HTML bare?
+///
+/// The single source of truth for both the writer and the blank-line rule
+/// below, so the two cannot drift apart.
+fn html_writes_bare(text: &str) -> bool {
+    // The comment arm predates the block-tag one (bd-1066) and deliberately
+    // skips `round_trips_bare_html`'s blank-line guard: the grammar keeps a
+    // whole `<!-- … -->` as one `html_element`, blank lines and all, so a
+    // comment the *reader* produced always re-reads as itself. A comment
+    // `RawBlock` synthesised by a filter with markdown after a blank line
+    // inside it would not, but no reader path produces that.
+    is_html_comment(text) || round_trips_bare_html(text)
+}
+
 fn write_div(
     div: &crate::pandoc::Div,
     writer: &mut dyn std::io::Write,
@@ -558,7 +649,7 @@ fn write_div(
     writeln!(writer)?;
 
     for block in div.content.iter() {
-        // Add a blank line between blocks in the blockquote
+        // A blank line opens the div body and separates its blocks.
         writeln!(writer)?;
         write_block(block, writer, ctx)?;
     }
@@ -850,12 +941,28 @@ fn write_rawblock(rawblock: &RawBlock, buf: &mut dyn std::io::Write) -> std::io:
     // Only output raw content if it's for markdown format
     if rawblock.format == "markdown" {
         write!(buf, "{}", rawblock.text)?;
-    } else if rawblock.format == "html" && is_html_comment(&rawblock.text) {
-        // HTML comments are emitted in native syntax, matching write_rawinline
-        // (bd-1066). A comment on its own line is now lifted to a RawBlock
-        // rather than a Paragraph of RawInlines, so the block writer needs the
-        // same case or the comment round-trips as a ```{=html} fence.
-        writeln!(buf, "{}", rawblock.text)?;
+    } else if rawblock.format == "html" && html_writes_bare(&rawblock.text) {
+        // Block-level raw HTML is emitted as written, not wrapped in a
+        // ```{=html} fence. Comments came first (bd-1066); the rest followed
+        // when the lift started splitting a tight `<div>` into
+        // RawBlock/Plain/RawBlock, because a fence around each tag would
+        // separate it from the `Plain` and break the round-trip.
+        //
+        // The rule is self-consistent: exactly the texts written bare here are
+        // the ones `paragraph.rs` lifts back to a `RawBlock` on the next read.
+        // Raw HTML that is *not* block-level keeps its fence, since bare it
+        // would come back as an inline.
+        //
+        // This reverses the normalisation to the documented ```{=html}
+        // spelling the lift originally shipped with — deliberately, in favour
+        // of round-trip stability and pandoc parity
+        // (bd-block-html-adjacent-markdown-unparsed-0qnjuwuy).
+        // `trim_end` because the text may already end in a newline — a filter
+        // or JSON AST can carry `"<div>\n"` — and `writeln!` would then emit a
+        // second one. Harmless to the parse (blocks are blank-line separated
+        // either way) but it makes the first write idempotent rather than the
+        // second.
+        writeln!(buf, "{}", rawblock.text.trim_end())?;
     } else {
         // For other formats, use fenced raw block notation with `=` prefix
         writeln!(buf, "```{{={}}}", rawblock.format)?;
diff --git a/crates/pampa/tests/integration/incremental_writer_tests.rs b/crates/pampa/tests/integration/incremental_writer_tests.rs
index 2890ec647..14ec37f7f 100644
--- a/crates/pampa/tests/integration/incremental_writer_tests.rs
+++ b/crates/pampa/tests/integration/incremental_writer_tests.rs
@@ -1431,12 +1431,105 @@ fn roundtrip_inline_comment() {
 }
 
 /// Standard writer round-trip: comment in blockquote.
+///
+/// This one cannot use [`assert_roundtrip`], which demands the rewritten text
+/// re-parse *structurally equal* to the new AST. A comment followed by prose on
+/// the next line is one paragraph, and the reader splits it into a `RawBlock`
+/// plus a `Plain` (bd-block-html-adjacent-markdown-unparsed-0qnjuwuy). The
+/// writer separates blocks with a blank line, so the `Plain` re-reads as a
+/// `Paragraph` — a canonicalization, in the same family as the table and
+/// definition-list rewrites documented in `writers/qmd.rs`.
+///
+/// Preserving the `Plain` would mean writing the two blocks tight, which
+/// requires knowing they came from one paragraph. The AST does not record that,
+/// and the rule that guessed it merged blocks that were never one paragraph —
+/// it pulled a following `<script>` into the preceding text and its contents
+/// were then parsed as markdown. So this asserts what actually holds: the
+/// comment stays in block position, the prose stays parsed, and the shape is
+/// stable from the first rewrite onward.
 #[test]
 fn roundtrip_comment_in_blockquote() {
-    assert_roundtrip(
-        "> <!-- comment -->\n> Some text.\n",
-        "> <!-- comment -->\n> Changed text.\n",
+    use pampa::pandoc::Block;
+
+    let original_qmd = "> <!-- comment -->\n> Some text.\n";
+    let new_qmd = "> <!-- comment -->\n> Changed text.\n";
+
+    let original_ast = parse_qmd(original_qmd);
+    let new_ast = parse_qmd(new_qmd);
+    let plan = compute_reconciliation(&original_ast, &new_ast);
+    let result =
+        writers::incremental::incremental_write(original_qmd, &original_ast, &new_ast, &plan)
+            .expect("incremental_write failed");
+
+    let quoted = match &parse_qmd(&result).blocks[0] {
+        Block::BlockQuote(q) => q.content.clone(),
+        other => panic!("expected a BlockQuote, got {:?}", other),
+    };
+    match &quoted[0] {
+        Block::RawBlock(r) => assert_eq!(r.text, "<!-- comment -->"),
+        other => panic!("the comment must stay in block position, got {:?}", other),
+    }
+    let text = match &quoted[1] {
+        Block::Plain(p) => &p.content,
+        Block::Paragraph(p) => &p.content,
+        other => panic!("expected the prose as its own block, got {:?}", other),
+    };
+    assert!(
+        format!("{:?}", text).contains("Changed"),
+        "the edit should be present: {:?}",
+        text
     );
+
+    // A second pass over the rewritten text must not move again.
+    let stable_ast = parse_qmd(&result);
+    let stable_plan = compute_reconciliation(&stable_ast, &stable_ast);
+    let stable =
+        writers::incremental::incremental_write(&result, &stable_ast, &stable_ast, &stable_plan)
+            .expect("incremental_write failed");
+    assert_eq!(stable, result, "the rewrite should reach a fixed point");
+}
+
+/// Incremental round-trip of a split at the *top level*.
+///
+/// `roundtrip_comment_in_blockquote` covers a split inside a container; this is
+/// the bare case. Same contract: the tags stay in block position, the interior
+/// stays parsed, and the shape is stable once rewritten.
+#[test]
+fn roundtrip_tight_div_at_top_level() {
+    use pampa::pandoc::Block;
+
+    let original_qmd = "<div class=\"note\">\ntext with `code`\n</div>\n";
+    let new_qmd = "<div class=\"note\">\nchanged with `code`\n</div>\n";
+
+    let original_ast = parse_qmd(original_qmd);
+    let new_ast = parse_qmd(new_qmd);
+    let plan = compute_reconciliation(&original_ast, &new_ast);
+    let result =
+        writers::incremental::incremental_write(original_qmd, &original_ast, &new_ast, &plan)
+            .expect("incremental_write failed");
+
+    let blocks = parse_qmd(&result).blocks;
+    match &blocks[0] {
+        Block::RawBlock(r) => assert_eq!(r.text, "<div class=\"note\">"),
+        other => panic!("the open tag must stay in block position, got {:?}", other),
+    }
+    match blocks.last() {
+        Some(Block::RawBlock(r)) => assert_eq!(r.text, "</div>"),
+        other => panic!("the close tag must stay in block position, got {:?}", other),
+    }
+    let interior = format!("{:?}", &blocks[1]);
+    assert!(
+        interior.contains("Code") && interior.contains("changed"),
+        "the edited interior should still be parsed markdown: {}",
+        interior
+    );
+
+    let stable_ast = parse_qmd(&result);
+    let stable_plan = compute_reconciliation(&stable_ast, &stable_ast);
+    let stable =
+        writers::incremental::incremental_write(&result, &stable_ast, &stable_ast, &stable_plan)
+            .expect("incremental_write failed");
+    assert_eq!(stable, result, "the rewrite should reach a fixed point");
 }
 
 // --- Phase 4: Edge case tests ---
diff --git a/crates/pampa/tests/integration/test_html_block_lift.rs b/crates/pampa/tests/integration/test_html_block_lift.rs
index 63f2d12e9..2688b082e 100644
--- a/crates/pampa/tests/integration/test_html_block_lift.rs
+++ b/crates/pampa/tests/integration/test_html_block_lift.rs
@@ -98,24 +98,31 @@ fn bare_div_becomes_raw_block() {
 }
 
 #[test]
-fn details_summary_becomes_one_raw_block_verbatim() {
-    // The shape that hit the Positron docs' download.qmd. The whole paragraph —
-    // both source lines — becomes one RawBlock, which is also what CommonMark's
-    // HTML block type 6 produces (it runs to the next blank line, exactly as a
-    // paragraph does).
+fn details_summary_splits_into_raw_tags_and_parsed_text() {
+    // The shape that hit the Positron docs' download.qmd. The two tag lines are
+    // one paragraph, and the lift keeps that extent — but the summary's text is
+    // content, so it lifts out between the tags. Matches
+    // `pandoc -f markdown-native_divs`, which gives the same four blocks.
     let blocks = blocks(
         "<details class=\"checksums-section\">\n<summary>SHA-256 checksums</summary>\n\nText inside the details.\n\n</details>\n",
     );
 
+    // The opening tags are consecutive raw inlines, so they coalesce into one
+    // RawBlock that keeps their original line break.
     match &blocks[0] {
         Block::RawBlock(r) => {
             assert_eq!(r.format, "html");
-            assert_eq!(
-                r.text,
-                "<details class=\"checksums-section\">\n<summary>SHA-256 checksums</summary>"
-            );
+            assert_eq!(r.text, "<details class=\"checksums-section\">\n<summary>");
         }
-        other => panic!("expected a RawBlock spanning both lines, got {:?}", other),
+        other => panic!(
+            "expected a RawBlock spanning both tag lines, got {:?}",
+            other
+        ),
+    }
+    assert_eq!(inline_shape_text(&blocks[1]), "SHA-256 checksums");
+    match &blocks[2] {
+        Block::RawBlock(r) => assert_eq!(r.text, "</summary>"),
+        other => panic!("expected the closing summary tag, got {:?}", other),
     }
 }
 
@@ -152,15 +159,24 @@ fn container_prefixes_are_stripped_from_a_multi_line_block() {
     // a bare newline for each break rather than copying its source text.
     let blocks = blocks("> <div class=\"a\">\n> <span>x</span>\n");
     let flat = format!("{:#?}", blocks);
-    match &blocks[0] {
-        Block::BlockQuote(q) => match &q.content[0] {
-            Block::RawBlock(r) => {
-                assert_eq!(r.text, "<div class=\"a\">\n<span>x</span>");
-            }
-            other => panic!("expected RawBlock inside the quote, got {:?}", other),
-        },
-        other => panic!("expected BlockQuote, got {:?}\n{}", other, flat),
+    let Block::BlockQuote(q) = &blocks[0] else {
+        panic!("expected BlockQuote, got {:?}\n{}", blocks[0], flat);
+    };
+
+    // `<span>` is not block-level, so it is not part of the raw run: the quote
+    // splits into the `<div>` tag and the span as content. Pandoc splits here
+    // too (`RawBlock "<div class=\"a\">"`, then the span as a block).
+    match &q.content[0] {
+        Block::RawBlock(r) => assert_eq!(r.text, "<div class=\"a\">"),
+        other => panic!("expected RawBlock inside the quote, got {:?}", other),
     }
+
+    // The point of the test: no `> ` gutter anywhere in what the quote holds.
+    assert!(
+        !flat.contains("> <"),
+        "the block-quote gutter leaked into the quoted content:\n{}",
+        flat
+    );
 }
 
 #[test]
@@ -268,9 +284,12 @@ fn details_renders_without_paragraph_wrappers() {
         "closing details must not be wrapped in a paragraph:\n{}",
         html
     );
+    // The summary's tags stay raw and its text is parsed, so it renders across
+    // three lines. Quarto 1 and pandoc do the same; the whitespace is
+    // insignificant inside `<summary>`, which is phrasing content.
     assert!(
-        html.contains("<summary>SHA-256 checksums</summary>"),
-        "summary should be emitted verbatim:\n{}",
+        html.contains("<summary>\nSHA-256 checksums\n</summary>"),
+        "summary tags should be raw with parsed text between them:\n{}",
         html
     );
 }
@@ -367,19 +386,583 @@ fn standalone_comment_round_trips_in_native_syntax() {
 }
 
 #[test]
-fn naked_block_round_trips_as_an_explicit_raw_fence() {
+fn naked_block_round_trips_as_written() {
     // Naked HTML never round-tripped as written — before the lift it came back
-    // as an inline `` `<div …>`{=html} `` span. It now comes back as a block
-    // fence, which is the documented spelling for block-level raw HTML.
-    let out = roundtrip("<div class=\"a\">\n\nbody\n\n</div>\n");
+    // as an inline `` `<div …>`{=html} `` span, and the lift first normalised
+    // it to a ```{=html} fence, the documented spelling.
+    //
+    // It now comes back verbatim, matching pandoc. The normalisation was
+    // reversed deliberately: a fence around each tag separates it from the
+    // `Plain` in a split `<div>`/text/`</div>`, so the text would come back as
+    // a `Paragraph` and the round-trip would not be stable. Writing the tag
+    // bare is also self-consistent — exactly the texts written bare here are
+    // the ones the reader lifts back to a `RawBlock`.
+    //
+    // bd-block-html-adjacent-markdown-unparsed-0qnjuwuy
+    let src = "<div class=\"a\">\n\nbody\n\n</div>\n";
+    let out = roundtrip(src);
+    assert_eq!(out, src, "naked block HTML should round-trip as written");
+
+    // The blank lines are load-bearing: they keep `body` a Paragraph, so it
+    // must not be pulled tight against the tags the way a `Plain` would be.
+    let reparsed = blocks(&out);
+    assert!(
+        matches!(reparsed[1], Block::Paragraph(_)),
+        "a blank-line-separated body stays a Paragraph, got {:?}",
+        reparsed[1]
+    );
+}
+
+// =============================================================================
+// Split: markdown adjacent to a raw HTML block line still reaches the inline
+// parser (pandoc's `markdown_in_html_blocks`)
+//
+// The lift above reproduces the HTML block's *extent* correctly, but it
+// originally emitted the paragraph verbatim, which also switched off inline
+// parsing inside it. Dropping `native_divs` costs the `<p>` wrapper and the
+// `Div` node — intended. Dropping `markdown_in_html_blocks` costs inline
+// markdown parsing — not intended, and a parity break against Quarto 1.
+//
+// Target shape, matching `pandoc -f markdown-native_divs`: runs of block-level
+// raw HTML stay `RawBlock`, the text between them becomes `Plain`.
+//
+// bd-block-html-adjacent-markdown-unparsed-0qnjuwuy
+// =============================================================================
+
+/// The `Code` and `Emph` inlines in `block`, as a terse shape string.
+fn inline_shape(block: &Block) -> String {
+    let content = match block {
+        Block::Plain(p) => &p.content,
+        Block::Paragraph(p) => &p.content,
+        other => panic!("expected Plain or Paragraph, got {:?}", other),
+    };
+    content
+        .iter()
+        .filter_map(|i| match i {
+            pampa::pandoc::Inline::Code(c) => Some(format!("Code({})", c.text)),
+            pampa::pandoc::Inline::Emph(_) => Some("Emph".to_string()),
+            _ => None,
+        })
+        .collect::<Vec<_>>()
+        .join(",")
+}
+
+#[test]
+fn tight_div_splits_and_parses_its_interior() {
+    let blocks =
+        blocks("<div class=\"case-b\">\nText with a `code span` and *emphasis*.\n</div>\n");
+
+    assert_eq!(
+        blocks.len(),
+        3,
+        "expected RawBlock/Plain/RawBlock: {:#?}",
+        blocks
+    );
+    match &blocks[0] {
+        Block::RawBlock(r) => assert_eq!(r.text, "<div class=\"case-b\">"),
+        other => panic!("expected RawBlock open tag, got {:?}", other),
+    }
+    assert!(
+        matches!(blocks[1], Block::Plain(_)),
+        "interior should be Plain, got {:?}",
+        blocks[1]
+    );
+    assert_eq!(inline_shape(&blocks[1]), "Code(code span),Emph");
+    match &blocks[2] {
+        Block::RawBlock(r) => assert_eq!(r.text, "</div>"),
+        other => panic!("expected RawBlock close tag, got {:?}", other),
+    }
+}
+
+#[test]
+fn details_summary_interior_is_parsed() {
+    // The shape from the real bug report: Positron docs
+    // assistant-chat-instructions.qmd:61-63 rendered literal backticks.
+    let html = render_html(
+        "<details>\n<summary>Example custom instructions</summary>\nThis uses a `quarto.instructions.md` file.\n</details>\n",
+    );
+    assert!(
+        html.contains("<code>quarto.instructions.md</code>"),
+        "the code span should be parsed, got:\n{}",
+        html
+    );
+    assert!(
+        !html.contains("`quarto.instructions.md`"),
+        "no literal backticks should survive, got:\n{}",
+        html
+    );
+}
+
+#[test]
+fn consecutive_tags_on_one_line_stay_one_raw_run() {
+    // A non-first `RawInline` carries its leading whitespace in `text`, so the
+    // block-tag test has to be applied to the trimmed text or the second and
+    // third comments here read as ordinary content.
+    let blocks = blocks("<!-- first --> <!-- second --> <!-- third -->\n");
+
+    assert_eq!(blocks.len(), 1, "expected one RawBlock: {:#?}", blocks);
+    assert!(
+        matches!(&blocks[0], Block::RawBlock(_)),
+        "expected RawBlock, got {:?}",
+        blocks[0]
+    );
+}
+
+#[test]
+fn raw_text_elements_keep_their_content_verbatim() {
+    // CommonMark's HTML block type 1: `pre`, `script`, `style` and `textarea`
+    // are raw-text elements. Pandoc does not parse markdown inside them, so
+    // neither do we — even though all four are in BLOCK_TAGS.
+    for tag in ["pre", "script", "style", "textarea"] {
+        let qmd = format!("<{tag}>\ntext with a `code span` and *emphasis*.\n</{tag}>\n");
+        let blocks = blocks(&qmd);
+        assert_eq!(
+            blocks.len(),
+            1,
+            "<{tag}> should stay one verbatim RawBlock: {:#?}",
+            blocks
+        );
+        let raw = only_raw_block(&blocks);
+        assert!(
+            raw.text.contains("`code span`"),
+            "<{tag}> content should stay verbatim, got: {:?}",
+            raw.text
+        );
+    }
+}
+
+#[test]
+fn tag_only_paragraph_still_emits_a_single_raw_block() {
+    // PR #646's shape, unchanged by the split: with nothing but tags in the
+    // paragraph there is no interior to lift out.
+    let blocks = blocks(
+        "<details class=\"checksums-section\">\n<summary>SHA-256 checksums</summary>\n\nBody.\n\n</details>\n",
+    );
+
+    match &blocks[0] {
+        Block::RawBlock(r) => assert!(
+            r.text.starts_with("<details class=\"checksums-section\">"),
+            "expected the details open tag, got {:?}",
+            r.text
+        ),
+        other => panic!("expected RawBlock, got {:?}", other),
+    }
+}
+
+#[test]
+fn split_parts_carry_their_own_source_info() {
+    // Cloning the paragraph's SourceInfo onto every part gives sibling blocks
+    // identical overlapping ranges, which misleads the incremental writer.
+    let blocks = blocks("<div>\nText inside.\n</div>\n");
+    assert_eq!(blocks.len(), 3, "expected three blocks: {:#?}", blocks);
+
+    let spans: Vec<(usize, usize)> = blocks
+        .iter()
+        .map(|b| {
+            let si = match b {
+                Block::RawBlock(r) => &r.source_info,
+                Block::Plain(p) => &p.source_info,
+                other => panic!("unexpected block {:?}", other),
+            };
+            match si {
+                quarto_source_map::SourceInfo::Original {
+                    start_offset,
+                    end_offset,
+                    ..
+                } => (*start_offset, *end_offset),
+                other => panic!("expected an Original source info, got {:?}", other),
+            }
+        })
+        .collect();
+
+    for (i, w) in spans.windows(2).enumerate() {
+        assert!(
+            w[0].1 <= w[1].0,
+            "part {} [{}..{}] overlaps part {} [{}..{}]: {:?}",
+            i,
+            w[0].0,
+            w[0].1,
+            i + 1,
+            w[1].0,
+            w[1].1,
+            spans
+        );
+    }
+}
+
+#[test]
+fn tight_div_round_trips_to_a_stable_shape() {
+    // A block-level html RawBlock writes verbatim rather than as a ```{=html}
+    // fence, so the tags survive as written. What does *not* survive is the
+    // tightness: the writer separates blocks, so the interior comes back as a
+    // `Paragraph` rather than the `Plain` the reader produced.
+    //
+    // That is unavoidable without recording which blocks shared a paragraph,
+    // which the AST does not do — and the tight rule that faked it merged
+    // blocks that were never one paragraph. See the round-trip note in the
+    // plan. The shape reaches a fixed point immediately, and the tags stay in
+    // block position, which is what the lift exists to guarantee.
+    let src = "<div class=\"case-b\">\nText with a `code span` and *emphasis*.\n</div>\n";
+    let once = roundtrip(src);
+    let twice = roundtrip(&once);
+    assert_eq!(
+        once, twice,
+        "the round-trip should reach a fixed point:\n{}",
+        once
+    );
+
+    let reparsed = blocks(&once);
+    assert_eq!(
+        reparsed.len(),
+        3,
+        "the tags must stay their own blocks: {:#?}",
+        reparsed
+    );
+    assert!(matches!(reparsed[0], Block::RawBlock(_)));
+    assert!(
+        matches!(reparsed[1], Block::Paragraph(_)),
+        "the interior canonicalizes to a Paragraph, got {:?}",
+        reparsed[1]
+    );
+    assert!(matches!(reparsed[2], Block::RawBlock(_)));
+    assert_eq!(inline_shape(&reparsed[1]), "Code(code span),Emph");
+}
+
+#[test]
+fn split_round_trips_inside_a_block_quote() {
+    // A container must keep the comment in block position and the text parsed.
+    // As at the top level, the interior canonicalizes to a `Paragraph`.
+    let out = roundtrip("> <!-- comment -->\n> Text after.\n");
+    let reparsed = blocks(&out);
+
+    let quoted = match &reparsed[0] {
+        Block::BlockQuote(q) => &q.content,
+        other => panic!("expected a BlockQuote, got {:?}", other),
+    };
+    assert!(
+        matches!(quoted[0], Block::RawBlock(_)),
+        "the comment should stay a RawBlock, got {:?}",
+        quoted[0]
+    );
+    assert!(
+        matches!(quoted[1], Block::Paragraph(_)),
+        "the text should be its own parsed block, got {:?}",
+        quoted[1]
+    );
+}
+
+/// The plain-text content of a `Plain`/`Paragraph`, for terse assertions.
+fn inline_shape_text(block: &Block) -> String {
+    let content = match block {
+        Block::Plain(p) => &p.content,
+        Block::Paragraph(p) => &p.content,
+        other => panic!("expected Plain or Paragraph, got {:?}", other),
+    };
+    content
+        .iter()
+        .map(|i| match i {
+            pampa::pandoc::Inline::Str(s) => s.text.clone(),
+            pampa::pandoc::Inline::Space(_) => " ".to_string(),
+            _ => String::new(),
+        })
+        .collect()
+}
+
+// =============================================================================
+// Regressions found in review of the split
+// =============================================================================
+
+#[test]
+fn a_hard_line_break_after_the_tag_is_not_content() {
+    // Trailing spaces on the tag line make the reader emit `Inline::LineBreak`
+    // rather than `SoftBreak`. It is a separator like any other, so it must not
+    // fall into the content run — doing so rendered a spurious `<br />` before
+    // the text. The spaces are invisible in the source, so this looks to an
+    // author like the engine inventing markup.
+    let html = render_html("<div class=\"x\">  \ntext with a `code span`\n</div>\n");
+    assert!(
+        !html.contains("<br"),
+        "a hard break at the tag boundary must not survive:\n{}",
+        html
+    );
+    assert!(
+        html.contains("<code>code span</code>"),
+        "the interior should still be parsed:\n{}",
+        html
+    );
+}
+
+#[test]
+fn a_hard_line_break_between_tags_invents_no_content() {
+    // The same break with nothing between the tags must leave the pair a single
+    // raw run, not a `Plain` holding the break alone — which rendered a stray
+    // backslash. Pandoc emits `<div>\n</div>` and nothing else.
+    let blocks = blocks("<div>   \n</div>\n");
+    assert_eq!(
+        blocks.len(),
+        1,
+        "an empty div should stay one raw run: {:#?}",
+        blocks
+    );
+    let raw = only_raw_block(&blocks);
+    assert_eq!(raw.text, "<div>\n</div>");
+}
+
+#[test]
+fn an_authored_raw_fence_keeps_its_fence() {
+    // Writing block-level raw HTML bare is only sound for the shapes the *lift*
+    // produces — a pure run of tags, or a raw-text element. An author-written
+    // ```{=html} fence can hold anything, and stripping its fence means the
+    // next read parses its contents: a backtick becomes `Code`, and a `#` line
+    // after a blank line becomes a real `Header`. That is content corruption
+    // through any AST -> qmd -> read cycle.
+    let src =
+        "```{=html}\n<div class=\"authored\">\nstill `raw` inside\n\n# not a header\n</div>\n```\n";
+    let out = roundtrip(src);
     assert!(
         out.contains("```{=html}"),
-        "expected an explicit raw block, got:\n{}",
+        "an authored fence with interior content must keep its fence:\n{}",
         out
     );
+
+    let reparsed = blocks(&out);
+    assert_eq!(
+        reparsed.len(),
+        1,
+        "it must come back as one RawBlock, not parsed apart: {:#?}",
+        reparsed
+    );
+    let raw = only_raw_block(&reparsed);
+    assert!(
+        raw.text.contains("still `raw` inside"),
+        "the backticks must survive verbatim, got: {:?}",
+        raw.text
+    );
+    assert!(
+        raw.text.contains("# not a header"),
+        "the hash line must survive verbatim, got: {:?}",
+        raw.text
+    );
+}
+
+#[test]
+fn a_raw_text_element_still_round_trips_bare() {
+    // The counterpart: `<pre>` and friends keep their interior verbatim on the
+    // next read, so they are safe to write bare and should stay that way.
+    let src = "<pre>\ntext with a `code span`\n</pre>\n";
+    let out = roundtrip(src);
+    assert_eq!(out, src, "a raw-text element should round-trip as written");
+}
+
+#[test]
+fn split_round_trips_inside_an_ordered_list_item() {
+    // An ordered item has its own block loop in the writer, separate from a
+    // bullet item's; both must keep a split's tags in block position and its
+    // interior parsed.
+    let out = roundtrip("1. item\n\n   <div>\n   text `code`\n   </div>\n");
+    let reparsed = blocks(&out);
+
+    let items = match &reparsed[0] {
+        Block::OrderedList(l) => &l.content,
+        other => panic!("expected an OrderedList, got {:?}", other),
+    };
+    let split = &items[0];
+    assert!(
+        split.iter().any(|b| matches!(b, Block::RawBlock(_))),
+        "the div's tags should stay in block position: {:#?}",
+        split
+    );
+    assert!(
+        split.iter().any(|b| matches!(
+            b,
+            Block::Paragraph(p)
+                if p.content.iter().any(|i| matches!(i, pampa::pandoc::Inline::Code(_)))
+        )),
+        "the interior should still be parsed markdown: {:#?}",
+        split
+    );
+}
+
+#[test]
+fn raw_text_elements_are_exempt_inside_a_container_too() {
+    // The exemption is a property of the paragraph, not of the top level, so
+    // it has to hold wherever a lift can happen. A block quote is the awkward
+    // one — its `> ` gutter is stripped on the way in.
+    let blocks = blocks("> <pre>\n> raw `code` *em*\n> </pre>\n");
+    let Block::BlockQuote(q) = &blocks[0] else {
+        panic!("expected a BlockQuote, got {:?}", blocks[0]);
+    };
+    assert_eq!(
+        q.content.len(),
+        1,
+        "a <pre> inside a quote should stay one verbatim RawBlock: {:#?}",
+        q.content
+    );
+    match &q.content[0] {
+        Block::RawBlock(r) => assert!(
+            r.text.contains("raw `code` *em*"),
+            "the interior should stay verbatim, got: {:?}",
+            r.text
+        ),
+        other => panic!("expected RawBlock, got {:?}", other),
+    }
+}
+
+#[test]
+fn a_closing_raw_text_tag_does_not_start_an_exemption() {
+    // CommonMark's type-1 start condition is the *opening* tag. A paragraph
+    // opening with `</pre>` is an ordinary tag run, so its interior is parsed.
+    let blocks = blocks("</pre>\ntext with a `code span`\n");
+    assert!(
+        blocks.len() > 1,
+        "a closing tag should not exempt the paragraph: {:#?}",
+        blocks
+    );
+    assert_eq!(inline_shape(&blocks[1]), "Code(code span)");
+}
+
+#[test]
+fn a_metadata_block_scalar_splits_without_a_document_span() {
+    // Not every inline the split sees carries a file offset. A metadata block
+    // scalar — `include-in-header: - text: |` — is parsed as markdown, and its
+    // inlines carry the YAML value's provenance instead. `span_of` has to cope
+    // rather than assume `SourceInfo::Original`; assuming it panicked the whole
+    // render (quarto-core's `text_block_markdown_reaches_head_via_full_pipeline`).
+    let qmd = "---\ninclude-in-header:\n  - text: |\n      <meta name=\"a\" content=\"1\">\n\n      <meta name=\"b\" content=\"2\">\n---\n\nBody.\n";
+    let (pandoc, _context, _warnings) = readers::qmd::read(
+        qmd.as_bytes(),
+        false,
+        "test.md",
+        &mut std::io::sink(),
+        true,
+        None,
+    )
+    .expect("a metadata block scalar holding raw HTML should parse");
+
+    assert!(
+        pandoc.meta.get("include-in-header").is_some(),
+        "the metadata key should survive: {:?}",
+        pandoc.meta
+    );
+}
+
+// =============================================================================
+// The writer keeps blocks apart
+//
+// A split trio cannot be written *tight* to preserve its `Plain`s. Tightness
+// needs to know that two blocks came from one paragraph, and the AST does not
+// record that — a `Plain` next to a `RawBlock` may be a split interior or two
+// unrelated blocks, and a filter can produce either. Writing them tight merged
+// blocks that were never one paragraph, which is how a `<script>`'s contents
+// came to be parsed as markdown.
+//
+// So the writer always separates blocks, and a split interior comes back as a
+// `Paragraph`. See the round-trip note in the plan.
+// =============================================================================
+
+#[test]
+fn a_following_raw_text_element_keeps_its_own_paragraph() {
+    // The regression that killed the exemption: pulling a `Plain` tight against
+    // the next paragraph's `<script>` merged them, so `<script>` no longer
+    // *began* a paragraph and its contents were parsed. JavaScript is not
+    // markdown; a backtick in it must not become a code span.
+    let src = "<div class=\"note\">\nSee below.\n\n<script>\nconst t = `hi`;\n</script>\n";
+    let out = roundtrip(src);
+    let reparsed = blocks(&out);
+
+    let script = reparsed
+        .iter()
+        .find_map(|b| match b {
+            Block::RawBlock(r) if r.text.contains("script") => Some(r),
+            _ => None,
+        })
+        .unwrap_or_else(|| {
+            panic!(
+                "expected a <script> RawBlock after a round-trip: {:#?}",
+                reparsed
+            )
+        });
+    assert!(
+        script.text.contains("const t = `hi`;"),
+        "the script body must survive verbatim, got: {:?}",
+        script.text
+    );
+}
+
+#[test]
+fn a_round_trip_does_not_reopen_the_paragraph_wrapper_bug() {
+    // Tightness let a closing tag fall back into a paragraph, restoring the
+    // `<p><div>` shape bd-block-html-wrapped-in-p-w8qebxig fixed. Any raw HTML
+    // in the source, however awkward, must still land in block position after a
+    // write/read cycle. The `>` inside the comment is the awkward part.
+    let out = roundtrip("<div>\n<!-- fix: a -> b -->\ntext\n</div>\n");
+    let html = {
+        let mut buf = Vec::new();
+        write_blocks_to(&blocks(&out), &mut buf).unwrap();
+        String::from_utf8(buf).unwrap()
+    };
+    assert!(
+        !html.contains("<p><div") && !html.contains("</div></p>"),
+        "a round-trip must not put block HTML inside a paragraph:\n{}",
+        html
+    );
+}
+
+#[test]
+fn unrelated_blocks_are_not_merged_by_the_writer() {
+    // A `Plain` adjacent to a `RawBlock` need not have come from one paragraph —
+    // a filter can emit any sequence, and this one is built directly rather than
+    // parsed so that it really is `Plain`. Writing them tight collapsed all four
+    // blocks into a single `Paragraph` holding both tags as inlines.
+    use pampa::pandoc::block::{Plain, RawBlock};
+    use pampa::pandoc::inline::Str;
+    use quarto_source_map::{FileId, SourceInfo};
+
+    let span = || SourceInfo::original(FileId(0), 0, 0);
+    let plain = |text: &str| {
+        Block::Plain(Plain {
+            content: vec![pampa::pandoc::Inline::Str(Str {
+                text: text.to_string(),
+                source_info: span(),
+            })],
+            source_info: span(),
+        })
+    };
+    let raw = |text: &str| {
+        Block::RawBlock(RawBlock {
+            format: "html".to_string(),
+            text: text.to_string(),
+            source_info: span(),
+        })
+    };
+
+    let pandoc = pampa::pandoc::Pandoc {
+        meta: Default::default(),
+        blocks: vec![plain("alpha"), raw("<div>"), plain("beta"), raw("</div>")],
+    };
+    let mut out = Vec::new();
+    pampa::writers::qmd::write(&pandoc, &mut out).expect("should write");
+    let out = String::from_utf8(out).unwrap();
+
+    let reparsed = blocks(&out);
+    assert_eq!(
+        reparsed.len(),
+        4,
+        "the four blocks must stay four after a round-trip, got:\n{}\n{:#?}",
+        out,
+        reparsed
+    );
+}
+
+#[test]
+fn a_comment_containing_an_angle_bracket_still_writes_bare() {
+    // `line_is_only_tags` scanned to the first `>`, so the `>` in `a -> b` ended
+    // the "tag" early and the run was fenced unnecessarily. Harmless to the
+    // rendered HTML, but it churns the source for no reason.
+    let out = roundtrip("<div>\n<!-- fix: a -> b -->\n\ntext\n\n</div>\n");
     assert!(
-        out.contains("<div class=\"a\">"),
-        "the tag text should survive, got:\n{}",
+        !out.contains("```{=html}"),
+        "a pure tag run should stay bare even when a comment holds a `>`:\n{}",
         out
     );
 }
diff --git a/crates/pampa/tests/integration/test_warnings.rs b/crates/pampa/tests/integration/test_warnings.rs
index 18fd44d6e..90c9c0594 100644
--- a/crates/pampa/tests/integration/test_warnings.rs
+++ b/crates/pampa/tests/integration/test_warnings.rs
@@ -243,13 +243,20 @@ fn test_block_level_html_elements() {
     );
 
     use pampa::pandoc::Block;
+    // The tags stay raw and `content` is parsed between them, so the first
+    // block quotes just the opening tag rather than the whole element
+    // (bd-block-html-adjacent-markdown-unparsed-0qnjuwuy).
     match &pandoc.blocks[0] {
         Block::RawBlock(r) => {
             assert_eq!(r.format, "html");
-            assert_eq!(r.text, "<div>content</div>");
+            assert_eq!(r.text, "<div>");
         }
         other => panic!("Expected a RawBlock, got {:?}", other),
     }
+    match &pandoc.blocks[2] {
+        Block::RawBlock(r) => assert_eq!(r.text, "</div>"),
+        other => panic!("Expected the closing tag as a RawBlock, got {:?}", other),
+    }
 }
 
 #[test]
diff --git a/dev-docs/syntax-notes.md b/dev-docs/syntax-notes.md
index 478ef3eaa..bd8603a06 100644
--- a/dev-docs/syntax-notes.md
+++ b/dev-docs/syntax-notes.md
@@ -238,4 +238,50 @@ In Pandoc, you can intersperse HTML and Markdown, and Pandoc will (attempt to) p
 its AST format. This is brittle and inefficient because it relies heavily on backtracking through
 parser combinators. In `quarto-markdown`, use the raw block and inline syntax directly.
 
+Naked HTML is nonetheless *accepted*, with a `Q-2-9` warning, and the reader
+tries to give it the same shape Pandoc would. Two deliberate gaps remain.
+
+**No `native_divs` / `native_spans`.** Pandoc promotes a balanced
+`<div>…</div>` to a `Div` node, which wraps its contents in `<p>`. Finding the
+matching close tag is the backtracking this section rejects, so we do not do
+it: the tags stay `RawBlock`s and the contents are not wrapped. The visible
+difference is a missing `<p>`.
+
+**`Plain` where Pandoc sometimes writes `Para`.** Markdown *is* parsed inside a
+naked HTML block — Pandoc's `markdown_in_html_blocks`, which is a separate
+extension from `native_divs` and which we do implement. Pandoc chooses between
+`Plain` and `Para` for that content by tracking which element is still open;
+lacking that, we always emit `Plain`. The visible difference is again only a
+`<p>`, and only for text that trails a raw tag rather than sitting between a
+pair. Analysis:
+`claude-notes/research/2026-09-03-block-html-adjacent-markdown-unparsed.md`.
+
+Content inside `<pre>`, `<script>`, `<style>` and `<textarea>` is *not* parsed
+as markdown — they are CommonMark's raw-text elements, and Pandoc agrees. The
+exemption covers one paragraph, because that is the extent of the lift: if such
+an element's content contains a blank line, only the part before it is kept
+verbatim and the rest is read as markdown.
+
+**Writing the AST back out does not reproduce the `Plain`.** The writer always
+separates blocks with a blank line, so a lifted interior read back as `Plain`
+comes out as a `Paragraph` on the next read — gaining a `<p>`. This is
+canonicalization, like the table and definition-list rewrites, not a lossy
+step: the tags stay in block position and the markdown stays parsed, and the
+shape is stable from the first cycle onward.
+
+Preserving the `Plain` would mean writing it *tight* against the neighbouring
+tag, which requires knowing the two blocks came from one paragraph. The AST
+does not record that, and a rule that inferred it from block types alone was
+wrong in both directions: it merged a `Plain` with a following *unrelated*
+`<script>`, so the script's contents were parsed as markdown, and it let a
+closing tag fall back inside a paragraph — the `<p><div>` shape the lift
+exists to prevent. The information needed is provenance the AST cannot carry,
+so the writer does not guess.
+
+One consequence is worth knowing: for an element whose content model is
+phrasing — `<summary>`, `<td>` — the added `<p>` is not valid there. The first
+render is correct; only a write/read cycle introduces it. Naked HTML is an
+unsupported authoring form that already warns (`Q-2-9`) and points at
+`::: {.class}` or a `{=html}` fence, which have neither problem.
+