From 88eb1d7fdc9dd302a49011074e89c6fd5d5c93c8 Mon Sep 17 00:00:00 2001
From: Matt Farmer <matt@frmr.me>
Date: Wed, 25 Feb 2026 22:06:08 -0500
Subject: [PATCH 1/6] test: add characterization tests for HTML parsing
 pipeline

Adds comprehensive characterization tests for Html5Parser, Html5Writer,
PCDataXmlParser, AltXML, and MarkdownParser to lock in current behavior
before refactoring the scala-xml internal API dependencies.

New test coverage includes: AutoInsertedBody unwrapping, void/non-void tag
rendering, CDATA round-trips as Lift PCData nodes, HTML entity resolution,
namespace prefix handling, script/style verbatim content, unicode, malformed
input failure cases, and full parse+serialize round-trips for both parser paths.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../net/liftweb/util/Html5ParserSpec.scala    |  89 ++++++++++-
 .../net/liftweb/util/HtmlRoundTripSpec.scala  | 151 ++++++++++++++++++
 .../net/liftweb/util/MarkdownParserSpec.scala |  84 ++++++++++
 .../liftweb/util/PCDataXmlParserSpec.scala    | 111 ++++++++++---
 .../net/liftweb/util/XmlParserSpec.scala      |  46 +++++-
 .../net/liftweb/util/Html5ParserSpec.scala    |  88 +++++++++-
 .../net/liftweb/util/HtmlRoundTripSpec.scala  | 151 ++++++++++++++++++
 .../net/liftweb/util/MarkdownParserSpec.scala |  84 ++++++++++
 .../liftweb/util/PCDataXmlParserSpec.scala    | 111 ++++++++++---
 .../net/liftweb/util/XmlParserSpec.scala      |  46 +++++-
 10 files changed, 912 insertions(+), 49 deletions(-)
 create mode 100644 core/util/src/test/scala-2.13/net/liftweb/util/HtmlRoundTripSpec.scala
 create mode 100644 core/util/src/test/scala-2.13/net/liftweb/util/MarkdownParserSpec.scala
 create mode 100644 core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala
 create mode 100644 core/util/src/test/scala-3/net/liftweb/util/MarkdownParserSpec.scala

diff --git a/core/util/src/test/scala-2.13/net/liftweb/util/Html5ParserSpec.scala b/core/util/src/test/scala-2.13/net/liftweb/util/Html5ParserSpec.scala
index a0a479f5f..54533654c 100644
--- a/core/util/src/test/scala-2.13/net/liftweb/util/Html5ParserSpec.scala
+++ b/core/util/src/test/scala-2.13/net/liftweb/util/Html5ParserSpec.scala
@@ -17,7 +17,7 @@
 package net.liftweb
 package util
 
-import scala.xml.Elem
+import scala.xml.{ Comment, Elem }
 
 import org.specs2.mutable.Specification
 import org.specs2.execute.PendingUntilFixed
@@ -32,7 +32,7 @@ import Helpers._
 class Html5ParserSpec extends Specification with PendingUntilFixed with Html5Parser with Html5Writer {
   "Html5Parser Specification".title
 
-  "Htm5 Writer" should {
+  "Html5 Writer" should {
     "Write &" in {
       toString(<foo baz="&amp;dog"/>) must_== """<foo baz="&dog"></foo>"""
     }
@@ -40,6 +40,39 @@ class Html5ParserSpec extends Specification with PendingUntilFixed with Html5Par
     "ignore attributes that are null" in {
       toString(<foo id={None}/>) must_== """<foo></foo>"""
     }
+
+    "render void tags without a closing tag" in {
+      toString(<br/>) must_== "<br>"
+    }
+
+    "render void tags with attributes" in {
+      toString(<img src="x" alt="y"/>) must_== """<img src="x" alt="y">"""
+    }
+
+    "render non-void empty tags with a closing tag" in {
+      toString(<div/>) must_== "<div></div>"
+    }
+
+    "not escape content inside script tags" in {
+      toString(<script>{"var x = 1 < 2 && true;"}</script>) must_== "<script>var x = 1 < 2 && true;</script>"
+    }
+
+    "not escape content inside style tags" in {
+      toString(<style>{"p > span { color: red; }"}</style>) must_== "<style>p > span { color: red; }</style>"
+    }
+
+    "write PCData as CDATA section" in {
+      toString(<div>{PCData("x < y & z")}</div>) must_== "<div><![CDATA[x < y & z]]></div>"
+    }
+
+    "write Comment nodes" in {
+      toString(<div>{Comment("a comment")}</div>) must_== "<div><!--a comment--></div>"
+    }
+
+    "preserve namespace prefix on elements" in {
+      toString(<lift:surround with="default" at="content"><div/></lift:surround>) must_==
+        """<lift:surround with="default" at="content"><div></div></lift:surround>"""
+    }
   }
 
   "Html5 Parser" should {
@@ -94,7 +127,57 @@ class Html5ParserSpec extends Specification with PendingUntilFixed with Html5Par
       e.label must_== "div"
       (parsed.openOrThrowException("Test") \ "@with").text must_== "dog"
     }
+
+    "unwrap a single fragment element via AutoInsertedBody" in {
+      val result = parse("<div>hello</div>").openOrThrowException("Test")
+      result.label must_== "div"
+      result.text must_== "hello"
+    }
+
+    "not unwrap a full html document" in {
+      val result = parse("<html><head><title>T</title></head><body><p>X</p></body></html>")
+        .openOrThrowException("Test")
+      result.label must_== "html"
+    }
+
+    "unwrap a single self-closing fragment element" in {
+      val result = parse("<span/>").openOrThrowException("Test")
+      result.label must_== "span"
+    }
+
+    "resolve standard HTML entities to their character values" in {
+      val result = parse("<p>&nbsp;</p>").openOrThrowException("Test")
+      result.text must_== "\u00A0"
+    }
+
+    "preserve script tag content verbatim (in head)" in {
+      // nu.validator places bare <script> in <head>; AutoInsertedBody does not unwrap since head is non-empty
+      val result = parse("<script>var x = 1 < 2 && true;</script>").openOrThrowException("Test")
+      result.label must_== "html"
+      (result \\ "script").text must_== "var x = 1 < 2 && true;"
+    }
+
+    "preserve style tag content verbatim (in head)" in {
+      // nu.validator places bare <style> in <head>; AutoInsertedBody does not unwrap since head is non-empty
+      val result = parse("<style>p > span { color: red; }</style>").openOrThrowException("Test")
+      result.label must_== "html"
+      (result \\ "style").text must_== "p > span { color: red; }"
+    }
+
+    "preserve data-* attributes" in {
+      val result = parse("""<div data-foo="bar" data-baz="qux">x</div>""").openOrThrowException("Test")
+      (result \ "@data-foo").text must_== "bar"
+      (result \ "@data-baz").text must_== "qux"
+    }
+
+    "preserve Unicode content" in {
+      val result = parse("<p>café naïve 日本語</p>").openOrThrowException("Test")
+      result.text must_== "café naïve 日本語"
+    }
+
+    "return a Full result for empty string input" in {
+      parse("") must beAnInstanceOf[Full[Elem]]
+    }
   }
 
 }
-
diff --git a/core/util/src/test/scala-2.13/net/liftweb/util/HtmlRoundTripSpec.scala b/core/util/src/test/scala-2.13/net/liftweb/util/HtmlRoundTripSpec.scala
new file mode 100644
index 000000000..64b40791e
--- /dev/null
+++ b/core/util/src/test/scala-2.13/net/liftweb/util/HtmlRoundTripSpec.scala
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2026 Lift Committers and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.liftweb
+package util
+
+import scala.xml.Elem
+
+import org.specs2.mutable.Specification
+
+
+/**
+ * Round-trip tests for HTML parsing and serialization pipelines.
+ * These lock in the observable behavior of both parser paths so that
+ * implementation changes can be validated against them.
+ */
+class HtmlRoundTripSpec extends Specification with Html5Parser with Html5Writer {
+  "Html5 round-trip" should {
+    "preserve element label and text content" in {
+      val result = parse("<div>hello world</div>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("<div>")
+      output must contain("hello world")
+      output must contain("</div>")
+    }
+
+    "preserve attribute values" in {
+      val result = parse("""<a href="http://example.com" class="nav">link</a>""")
+        .openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("http://example.com")
+      output must contain("nav")
+      output must contain("link")
+    }
+
+    "preserve nested structure" in {
+      val input = "<div><ul><li><a href=\"x\">text</a></li></ul></div>"
+      val result = parse(input).openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("<ul>")
+      output must contain("<li>")
+      output must contain("<a ")
+      output must contain("text")
+    }
+
+    "preserve lift: namespace prefix" in {
+      val result = parse("""<lift:surround with="default" at="content"><div/></lift:surround>""")
+        .openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("lift:surround")
+      output must contain("""with="default"""")
+    }
+
+    "preserve unicode content" in {
+      val result = parse("<p>café 日本語</p>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("café")
+      output must contain("日本語")
+    }
+
+    "represent nbsp as a non-breaking space character (not entity name)" in {
+      // Html5 parser resolves &nbsp; to the U+00A0 character.
+      // Html5Writer (with convertAmp=true, the toString default) does not convert it back.
+      val result = parse("<p>&nbsp;</p>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("\u00A0")
+    }
+
+    "write void tags without closing tag" in {
+      val result = parse("<div><br/><img src=\"x\"/></div>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("<br>")
+      output must contain("<img ")
+      output must not contain "</br>"
+      output must not contain "</img>"
+    }
+  }
+
+  "PCDataXmlParser + AltXML round-trip" should {
+    "preserve element label and text content" in {
+      val result = PCDataXmlParser("<div>hello world</div>").openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("<div>")
+      output must contain("hello world")
+      output must contain("</div>")
+    }
+
+    "preserve attribute values" in {
+      val result = PCDataXmlParser("""<a href="http://example.com">link</a>""")
+        .openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("http://example.com")
+      output must contain("link")
+    }
+
+    "preserve nested structure" in {
+      val input = "<div><ul><li><a href=\"x\">text</a></li></ul></div>"
+      val result = PCDataXmlParser(input).openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("<ul>")
+      output must contain("<li>")
+      output must contain("text")
+    }
+
+    "preserve CDATA content as CDATA" in {
+      val result = PCDataXmlParser("<div><![CDATA[x < y & z]]></div>")
+        .openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("<![CDATA[")
+      output must contain("x < y & z")
+      output must contain("]]>")
+    }
+
+    "preserve HTML entities as characters with convertAmp=true" in {
+      // With convertAmp=true, the U+00A0 char produced by parsing &nbsp;
+      // is emitted as the character (not converted back to entity name)
+      val result = PCDataXmlParser("<p>&nbsp;</p>").openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("\u00A0")
+    }
+
+    "convert high-codepoint chars back to entity names with convertAmp=false" in {
+      // With convertAmp=false, U+00A0 is reversed to &nbsp; via revMap
+      val result = PCDataXmlParser("<p>&nbsp;</p>").openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, false)
+      output must contain("&nbsp;")
+    }
+
+    "preserve lift: namespace prefix through both parsers" in {
+      val result = PCDataXmlParser("""<lift:surround with="default" at="content"><div/></lift:surround>""")
+        .openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("lift:surround")
+      output must contain("""with="default"""")
+    }
+  }
+
+}
diff --git a/core/util/src/test/scala-2.13/net/liftweb/util/MarkdownParserSpec.scala b/core/util/src/test/scala-2.13/net/liftweb/util/MarkdownParserSpec.scala
new file mode 100644
index 000000000..1313bfdff
--- /dev/null
+++ b/core/util/src/test/scala-2.13/net/liftweb/util/MarkdownParserSpec.scala
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2026 Lift Committers and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.liftweb
+package util
+
+import scala.xml.{ Elem, NodeSeq }
+
+import org.specs2.mutable.Specification
+
+import net.liftweb.common.Full
+
+
+/**
+ * Basic characterization tests for MarkdownParser.
+ * MarkdownParser delegates to Html5.parse so these also exercise that pipeline.
+ */
+class MarkdownParserSpec extends Specification {
+  "MarkdownParser" should {
+    "return Full for basic paragraph markdown" in {
+      MarkdownParser.parse("hello world") must beAnInstanceOf[Full[NodeSeq]]
+    }
+
+    "render a paragraph as a <p> element" in {
+      val result = MarkdownParser.parse("hello world").openOrThrowException("Test")
+      val paras = result.filter(n => n.isInstanceOf[Elem] && n.asInstanceOf[Elem].label == "p")
+      paras must not(beEmpty)
+    }
+
+    "render bold markdown as <strong>" in {
+      val result = MarkdownParser.parse("**bold text**").openOrThrowException("Test")
+      val strong = result \\ "strong"
+      strong must not(beEmpty)
+      strong.text must contain("bold text")
+    }
+
+    "render italic markdown as <em>" in {
+      val result = MarkdownParser.parse("*italic text*").openOrThrowException("Test")
+      val em = result \\ "em"
+      em must not(beEmpty)
+      em.text must contain("italic text")
+    }
+
+    "render a markdown link as <a>" in {
+      val result = MarkdownParser.parse("[link text](http://example.com)").openOrThrowException("Test")
+      val anchors = result \\ "a"
+      anchors must not(beEmpty)
+      anchors.text must contain("link text")
+    }
+
+    "render a code block as <pre><code>" in {
+      val result = MarkdownParser.parse("    code line").openOrThrowException("Test")
+      val pre = result \\ "pre"
+      pre must not(beEmpty)
+    }
+
+    "childrenOfBody extracts children from a body element" in {
+      val input = <html><body><p>x</p><p>y</p></body></html>
+      val result = MarkdownParser.childrenOfBody(input)
+      result.length must be >= 2
+      (result \\ "p").text must contain("x")
+    }
+
+    "childrenOfBody returns input unchanged when no body element" in {
+      val input = <div><p>x</p></div>
+      val result = MarkdownParser.childrenOfBody(input)
+      result must_== input
+    }
+  }
+
+}
diff --git a/core/util/src/test/scala-2.13/net/liftweb/util/PCDataXmlParserSpec.scala b/core/util/src/test/scala-2.13/net/liftweb/util/PCDataXmlParserSpec.scala
index fedd000ca..cd21fabbe 100644
--- a/core/util/src/test/scala-2.13/net/liftweb/util/PCDataXmlParserSpec.scala
+++ b/core/util/src/test/scala-2.13/net/liftweb/util/PCDataXmlParserSpec.scala
@@ -17,16 +17,23 @@
 package net.liftweb
 package util
 
+import java.io.ByteArrayInputStream
+
+import scala.xml.Elem
+
 import org.specs2.matcher.XmlMatchers
 import org.specs2.mutable.Specification
 
+import net.liftweb.common.{ Failure, Full }
+
 
 /**
  * Systems under specification for PCDataXmlParser.
  */
 class PCDataXmlParserSpec extends Specification with XmlMatchers {
   "PCDataXmlParser Specification".title
-val data1 = """
+
+  val data1 = """
 
 
 <html>dude</html>
@@ -34,7 +41,8 @@ val data1 = """
 
 """
 
-val data2 = """
+  val data2 = """
+
 
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html>dude</html>
@@ -42,7 +50,7 @@ val data2 = """
 
 """
 
-val data3 = """<?xml version="1.0" encoding="UTF-8"?>
+  val data3 = """<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
@@ -63,21 +71,86 @@ val data3 = """<?xml version="1.0" encoding="UTF-8"?>
 </body>
 </html>"""
 
-
-   "PCDataMarkupParser" should {
-     "Parse a document with whitespace" in {
-       PCDataXmlParser(data1).openOrThrowException("Test") must ==/ (<html>dude</html>)
-     }
-
-     "Parse a document with doctype" in {
-       PCDataXmlParser(data2).openOrThrowException("Test") must ==/ (<html>dude</html>)
-     }
-
-     "Parse a document with xml and doctype" in {
-       PCDataXmlParser(data3).openOrThrowException("Test").apply(0).label must_== "html"
-     }
-
-   }
+  "PCDataMarkupParser" should {
+    "Parse a document with whitespace" in {
+      PCDataXmlParser(data1).openOrThrowException("Test") must ==/ (<html>dude</html>)
+    }
+
+    "Parse a document with doctype" in {
+      PCDataXmlParser(data2).openOrThrowException("Test") must ==/ (<html>dude</html>)
+    }
+
+    "Parse a document with xml and doctype" in {
+      PCDataXmlParser(data3).openOrThrowException("Test").apply(0).label must_== "html"
+    }
+
+    "resolve named HTML entities to their character values" in {
+      val result = PCDataXmlParser("<p>&nbsp;&copy;&euro;</p>").openOrThrowException("Test")
+      val text = result.apply(0).text
+      text must contain("\u00A0")   // nbsp
+      text must contain("\u00A9")   // copy
+      text must contain("\u20AC")   // euro
+    }
+
+    "parse numeric character references" in {
+      val result = PCDataXmlParser("<p>&#160;&#x20AC;</p>").openOrThrowException("Test")
+      val text = result.apply(0).text
+      text must contain("\u00A0")   // &#160; = nbsp
+      text must contain("\u20AC")   // &#x20AC; = euro
+    }
+
+    "parse CDATA sections as Lift PCData nodes" in {
+      val result = PCDataXmlParser("<div><![CDATA[x < y & z]]></div>").openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.child must haveSize(1)
+      val child = elem.child.head
+      child must beAnInstanceOf[PCData]
+      child.asInstanceOf[PCData].data must_== "x < y & z"
+    }
+
+    "parse namespace-prefixed elements" in {
+      val result = PCDataXmlParser("""<lift:surround with="default"><div/></lift:surround>""")
+        .openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.prefix must_== "lift"
+      elem.label must_== "surround"
+      (result.apply(0) \ "@with").text must_== "default"
+    }
+
+    "parse xmlns declarations and produce namespace bindings" in {
+      val result = PCDataXmlParser("""<html xmlns="http://www.w3.org/1999/xhtml"><body/></html>""")
+        .openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.label must_== "html"
+      elem.scope.uri must_== "http://www.w3.org/1999/xhtml"
+    }
+
+    "return Failure for malformed XML" in {
+      PCDataXmlParser("<div><span></div>") must beAnInstanceOf[Failure]
+    }
+
+    "return Failure for empty string" in {
+      PCDataXmlParser("") must beAnInstanceOf[Failure]
+    }
+
+    "parse self-closing tags as elements with empty children" in {
+      val result = PCDataXmlParser("<br/>").openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.label must_== "br"
+      elem.child must beEmpty
+    }
+
+    "parse attributes containing encoded ampersands" in {
+      val result = PCDataXmlParser("""<a href="foo&amp;bar">x</a>""").openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      (elem \ "@href").text must_== "foo&bar"
+    }
+
+    "parse via InputStream" in {
+      val bytes = "<p>hello</p>".getBytes("UTF-8")
+      val result = PCDataXmlParser(new ByteArrayInputStream(bytes)).openOrThrowException("Test")
+      result.apply(0).label must_== "p"
+    }
+  }
 
 }
-
diff --git a/core/util/src/test/scala-2.13/net/liftweb/util/XmlParserSpec.scala b/core/util/src/test/scala-2.13/net/liftweb/util/XmlParserSpec.scala
index 070fc92a2..8f7d21865 100644
--- a/core/util/src/test/scala-2.13/net/liftweb/util/XmlParserSpec.scala
+++ b/core/util/src/test/scala-2.13/net/liftweb/util/XmlParserSpec.scala
@@ -19,7 +19,7 @@ package util
 
 import java.io.ByteArrayInputStream
 
-import scala.xml.{Text, Unparsed}
+import scala.xml.{ EntityRef, Text, Unparsed }
 
 import org.specs2.matcher.XmlMatchers
 import org.specs2.mutable.Specification
@@ -71,7 +71,7 @@ class XmlParserSpec extends Specification with XmlMatchers {
   }
 
   "XML cannot contain Control characters" in {
-     val data = 
+     val data =
      <foo>
       {
         '\u0085'
@@ -99,5 +99,45 @@ class XmlParserSpec extends Specification with XmlMatchers {
     str.toList.foldLeft(0)((a, b) => a + cntIllegal(b)) must_== 0
   }
 
-}
+  "AltXML" should {
+    "render empty elements with self-close syntax" in {
+      AltXML.toXML(<br/>, false, true) must contain("/>")
+    }
+
+    "render non-empty elements with open and close tags" in {
+      val result = AltXML.toXML(<div>x</div>, false, true)
+      result must contain("<div>")
+      result must contain("</div>")
+    }
+
+    "preserve EntityRef nodes when convertAmp is false" in {
+      val data = <p>{EntityRef("nbsp")}</p>
+      val result = AltXML.toXML(data, false, false)
+      result must contain("&nbsp;")
+    }
+
+    "convert high-codepoint EntityRef to character when convertAmp is true" in {
+      // nbsp = 160, which is >= 128, so it converts to the actual char
+      val data = <p>{EntityRef("nbsp")}</p>
+      val result = AltXML.toXML(data, false, true)
+      result must contain("\u00A0")
+    }
+
+    "preserve low-codepoint EntityRef as entity when convertAmp is true" in {
+      // amp = 38, which is < 128, so it stays as &amp;
+      val data = <p>{EntityRef("amp")}</p>
+      val result = AltXML.toXML(data, false, true)
+      result must contain("&amp;")
+    }
 
+    "apply legacy IE compatibility mode to br tags" in {
+      // legacy mode: br gets />, no space
+      val withLegacy = AltXML.toXML(<br/>, false, true, legacyIeCompatibilityMode = true)
+      withLegacy must contain("/>")
+      // without legacy mode: br is in inlineTags, gets " />"
+      val withoutLegacy = AltXML.toXML(<br/>, false, true, legacyIeCompatibilityMode = false)
+      withoutLegacy must contain(" />")
+    }
+  }
+
+}
diff --git a/core/util/src/test/scala-3/net/liftweb/util/Html5ParserSpec.scala b/core/util/src/test/scala-3/net/liftweb/util/Html5ParserSpec.scala
index 2d48015eb..fa85d3d27 100644
--- a/core/util/src/test/scala-3/net/liftweb/util/Html5ParserSpec.scala
+++ b/core/util/src/test/scala-3/net/liftweb/util/Html5ParserSpec.scala
@@ -17,7 +17,7 @@
 package net.liftweb
 package util
 
-import scala.xml.Elem
+import scala.xml.{ Comment, Elem }
 
 import org.specs2.mutable.Specification
 import org.specs2.execute.PendingUntilFixed
@@ -32,7 +32,7 @@ import Helpers._
 class Html5ParserSpec extends Specification with PendingUntilFixed with Html5Parser with Html5Writer {
   "Html5Parser Specification".title
 
-  "Htm5 Writer" should {
+  "Html5 Writer" should {
     "Write &" in {
       toString(<foo baz="&amp;dog"/>) === """<foo baz="&dog"></foo>"""
     }
@@ -40,6 +40,39 @@ class Html5ParserSpec extends Specification with PendingUntilFixed with Html5Par
     "ignore attributes that are null" in {
       toString(<foo id={None}/>) === """<foo></foo>"""
     }
+
+    "render void tags without a closing tag" in {
+      toString(<br/>) === "<br>"
+    }
+
+    "render void tags with attributes" in {
+      toString(<img src="x" alt="y"/>) === """<img src="x" alt="y">"""
+    }
+
+    "render non-void empty tags with a closing tag" in {
+      toString(<div/>) === "<div></div>"
+    }
+
+    "not escape content inside script tags" in {
+      toString(<script>{"var x = 1 < 2 && true;"}</script>) === "<script>var x = 1 < 2 && true;</script>"
+    }
+
+    "not escape content inside style tags" in {
+      toString(<style>{"p > span { color: red; }"}</style>) === "<style>p > span { color: red; }</style>"
+    }
+
+    "write PCData as CDATA section" in {
+      toString(<div>{PCData("x < y & z")}</div>) === "<div><![CDATA[x < y & z]]></div>"
+    }
+
+    "write Comment nodes" in {
+      toString(<div>{Comment("a comment")}</div>) === "<div><!--a comment--></div>"
+    }
+
+    "preserve namespace prefix on elements" in {
+      toString(<lift:surround with="default" at="content"><div/></lift:surround>) ===
+        """<lift:surround with="default" at="content"><div></div></lift:surround>"""
+    }
   }
 
   "Html5 Parser" should {
@@ -94,6 +127,57 @@ class Html5ParserSpec extends Specification with PendingUntilFixed with Html5Par
       e.label === "div"
       (parsed.openOrThrowException("Test") \ "@with").text === "dog"
     }
+
+    "unwrap a single fragment element via AutoInsertedBody" in {
+      val result = parse("<div>hello</div>").openOrThrowException("Test")
+      result.label === "div"
+      result.text === "hello"
+    }
+
+    "not unwrap a full html document" in {
+      val result = parse("<html><head><title>T</title></head><body><p>X</p></body></html>")
+        .openOrThrowException("Test")
+      result.label === "html"
+    }
+
+    "unwrap a single self-closing fragment element" in {
+      val result = parse("<span/>").openOrThrowException("Test")
+      result.label === "span"
+    }
+
+    "resolve standard HTML entities to their character values" in {
+      val result = parse("<p>&nbsp;</p>").openOrThrowException("Test")
+      result.text === "\u00A0"
+    }
+
+    "preserve script tag content verbatim (in head)" in {
+      // nu.validator places bare <script> in <head>; AutoInsertedBody does not unwrap since head is non-empty
+      val result = parse("<script>var x = 1 < 2 && true;</script>").openOrThrowException("Test")
+      result.label === "html"
+      (result \\ "script").text === "var x = 1 < 2 && true;"
+    }
+
+    "preserve style tag content verbatim (in head)" in {
+      // nu.validator places bare <style> in <head>; AutoInsertedBody does not unwrap since head is non-empty
+      val result = parse("<style>p > span { color: red; }</style>").openOrThrowException("Test")
+      result.label === "html"
+      (result \\ "style").text === "p > span { color: red; }"
+    }
+
+    "preserve data-* attributes" in {
+      val result = parse("""<div data-foo="bar" data-baz="qux">x</div>""").openOrThrowException("Test")
+      (result \ "@data-foo").text === "bar"
+      (result \ "@data-baz").text === "qux"
+    }
+
+    "preserve Unicode content" in {
+      val result = parse("<p>café naïve 日本語</p>").openOrThrowException("Test")
+      result.text === "café naïve 日本語"
+    }
+
+    "return a Full result for empty string input" in {
+      parse("") must beAnInstanceOf[Full[Elem]]
+    }
   }
 
 }
diff --git a/core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala b/core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala
new file mode 100644
index 000000000..64b40791e
--- /dev/null
+++ b/core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2026 Lift Committers and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.liftweb
+package util
+
+import scala.xml.Elem
+
+import org.specs2.mutable.Specification
+
+
+/**
+ * Round-trip tests for HTML parsing and serialization pipelines.
+ * These lock in the observable behavior of both parser paths so that
+ * implementation changes can be validated against them.
+ */
+class HtmlRoundTripSpec extends Specification with Html5Parser with Html5Writer {
+  "Html5 round-trip" should {
+    "preserve element label and text content" in {
+      val result = parse("<div>hello world</div>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("<div>")
+      output must contain("hello world")
+      output must contain("</div>")
+    }
+
+    "preserve attribute values" in {
+      val result = parse("""<a href="http://example.com" class="nav">link</a>""")
+        .openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("http://example.com")
+      output must contain("nav")
+      output must contain("link")
+    }
+
+    "preserve nested structure" in {
+      val input = "<div><ul><li><a href=\"x\">text</a></li></ul></div>"
+      val result = parse(input).openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("<ul>")
+      output must contain("<li>")
+      output must contain("<a ")
+      output must contain("text")
+    }
+
+    "preserve lift: namespace prefix" in {
+      val result = parse("""<lift:surround with="default" at="content"><div/></lift:surround>""")
+        .openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("lift:surround")
+      output must contain("""with="default"""")
+    }
+
+    "preserve unicode content" in {
+      val result = parse("<p>café 日本語</p>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("café")
+      output must contain("日本語")
+    }
+
+    "represent nbsp as a non-breaking space character (not entity name)" in {
+      // Html5 parser resolves &nbsp; to the U+00A0 character.
+      // Html5Writer (with convertAmp=true, the toString default) does not convert it back.
+      val result = parse("<p>&nbsp;</p>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("\u00A0")
+    }
+
+    "write void tags without closing tag" in {
+      val result = parse("<div><br/><img src=\"x\"/></div>").openOrThrowException("Test")
+      val output = toString(result)
+      output must contain("<br>")
+      output must contain("<img ")
+      output must not contain "</br>"
+      output must not contain "</img>"
+    }
+  }
+
+  "PCDataXmlParser + AltXML round-trip" should {
+    "preserve element label and text content" in {
+      val result = PCDataXmlParser("<div>hello world</div>").openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("<div>")
+      output must contain("hello world")
+      output must contain("</div>")
+    }
+
+    "preserve attribute values" in {
+      val result = PCDataXmlParser("""<a href="http://example.com">link</a>""")
+        .openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("http://example.com")
+      output must contain("link")
+    }
+
+    "preserve nested structure" in {
+      val input = "<div><ul><li><a href=\"x\">text</a></li></ul></div>"
+      val result = PCDataXmlParser(input).openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("<ul>")
+      output must contain("<li>")
+      output must contain("text")
+    }
+
+    "preserve CDATA content as CDATA" in {
+      val result = PCDataXmlParser("<div><![CDATA[x < y & z]]></div>")
+        .openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("<![CDATA[")
+      output must contain("x < y & z")
+      output must contain("]]>")
+    }
+
+    "preserve HTML entities as characters with convertAmp=true" in {
+      // With convertAmp=true, the U+00A0 char produced by parsing &nbsp;
+      // is emitted as the character (not converted back to entity name)
+      val result = PCDataXmlParser("<p>&nbsp;</p>").openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("\u00A0")
+    }
+
+    "convert high-codepoint chars back to entity names with convertAmp=false" in {
+      // With convertAmp=false, U+00A0 is reversed to &nbsp; via revMap
+      val result = PCDataXmlParser("<p>&nbsp;</p>").openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, false)
+      output must contain("&nbsp;")
+    }
+
+    "preserve lift: namespace prefix through both parsers" in {
+      val result = PCDataXmlParser("""<lift:surround with="default" at="content"><div/></lift:surround>""")
+        .openOrThrowException("Test")
+      val output = AltXML.toXML(result.head, false, true)
+      output must contain("lift:surround")
+      output must contain("""with="default"""")
+    }
+  }
+
+}
diff --git a/core/util/src/test/scala-3/net/liftweb/util/MarkdownParserSpec.scala b/core/util/src/test/scala-3/net/liftweb/util/MarkdownParserSpec.scala
new file mode 100644
index 000000000..0af21bc54
--- /dev/null
+++ b/core/util/src/test/scala-3/net/liftweb/util/MarkdownParserSpec.scala
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2026 Lift Committers and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.liftweb
+package util
+
+import scala.xml.{ Elem, NodeSeq }
+
+import org.specs2.mutable.Specification
+
+import net.liftweb.common.Full
+
+
+/**
+ * Basic characterization tests for MarkdownParser.
+ * MarkdownParser delegates to Html5.parse so these also exercise that pipeline.
+ */
+class MarkdownParserSpec extends Specification {
+  "MarkdownParser" should {
+    "return Full for basic paragraph markdown" in {
+      MarkdownParser.parse("hello world") must beAnInstanceOf[Full[NodeSeq]]
+    }
+
+    "render a paragraph as a <p> element" in {
+      val result = MarkdownParser.parse("hello world").openOrThrowException("Test")
+      val paras = result.filter(n => n.isInstanceOf[Elem] && n.asInstanceOf[Elem].label == "p")
+      paras must not(beEmpty)
+    }
+
+    "render bold markdown as <strong>" in {
+      val result = MarkdownParser.parse("**bold text**").openOrThrowException("Test")
+      val strong = result \\ "strong"
+      strong must not(beEmpty)
+      strong.text must contain("bold text")
+    }
+
+    "render italic markdown as <em>" in {
+      val result = MarkdownParser.parse("*italic text*").openOrThrowException("Test")
+      val em = result \\ "em"
+      em must not(beEmpty)
+      em.text must contain("italic text")
+    }
+
+    "render a markdown link as <a>" in {
+      val result = MarkdownParser.parse("[link text](http://example.com)").openOrThrowException("Test")
+      val anchors = result \\ "a"
+      anchors must not(beEmpty)
+      anchors.text must contain("link text")
+    }
+
+    "render a code block as <pre><code>" in {
+      val result = MarkdownParser.parse("    code line").openOrThrowException("Test")
+      val pre = result \\ "pre"
+      pre must not(beEmpty)
+    }
+
+    "childrenOfBody extracts children from a body element" in {
+      val input = <html><body><p>x</p><p>y</p></body></html>
+      val result = MarkdownParser.childrenOfBody(input)
+      result.length must beGreaterThanOrEqualTo(2)
+      (result \\ "p").text must contain("x")
+    }
+
+    "childrenOfBody returns input unchanged when no body element" in {
+      val input = <div><p>x</p></div>
+      val result = MarkdownParser.childrenOfBody(input)
+      result === input
+    }
+  }
+
+}
diff --git a/core/util/src/test/scala-3/net/liftweb/util/PCDataXmlParserSpec.scala b/core/util/src/test/scala-3/net/liftweb/util/PCDataXmlParserSpec.scala
index dcdb07ef8..de70063db 100644
--- a/core/util/src/test/scala-3/net/liftweb/util/PCDataXmlParserSpec.scala
+++ b/core/util/src/test/scala-3/net/liftweb/util/PCDataXmlParserSpec.scala
@@ -17,16 +17,23 @@
 package net.liftweb
 package util
 
+import java.io.ByteArrayInputStream
+
+import scala.xml.Elem
+
 import org.specs2.matcher.XmlMatchers
 import org.specs2.mutable.Specification
 
+import net.liftweb.common.{ Failure, Full }
+
 
 /**
  * Systems under specification for PCDataXmlParser.
  */
 class PCDataXmlParserSpec extends Specification with XmlMatchers {
   "PCDataXmlParser Specification".title
-val data1 = """
+
+  val data1 = """
 
 
 <html>dude</html>
@@ -34,7 +41,8 @@ val data1 = """
 
 """
 
-val data2 = """
+  val data2 = """
+
 
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html>dude</html>
@@ -42,7 +50,7 @@ val data2 = """
 
 """
 
-val data3 = """<?xml version="1.0" encoding="UTF-8"?>
+  val data3 = """<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
@@ -63,21 +71,86 @@ val data3 = """<?xml version="1.0" encoding="UTF-8"?>
 </body>
 </html>"""
 
-
-   "PCDataMarkupParser" should {
-     "Parse a document with whitespace" in {
-       PCDataXmlParser(data1).openOrThrowException("Test") must ==/ (<html>dude</html>)
-     }
-
-     "Parse a document with doctype" in {
-       PCDataXmlParser(data2).openOrThrowException("Test") must ==/ (<html>dude</html>)
-     }
-
-     "Parse a document with xml and doctype" in {
-       PCDataXmlParser(data3).openOrThrowException("Test").apply(0).label === "html"
-     }
-
-   }
+  "PCDataMarkupParser" should {
+    "Parse a document with whitespace" in {
+      PCDataXmlParser(data1).openOrThrowException("Test") must ==/ (<html>dude</html>)
+    }
+
+    "Parse a document with doctype" in {
+      PCDataXmlParser(data2).openOrThrowException("Test") must ==/ (<html>dude</html>)
+    }
+
+    "Parse a document with xml and doctype" in {
+      PCDataXmlParser(data3).openOrThrowException("Test").apply(0).label === "html"
+    }
+
+    "resolve named HTML entities to their character values" in {
+      val result = PCDataXmlParser("<p>&nbsp;&copy;&euro;</p>").openOrThrowException("Test")
+      val text = result.apply(0).text
+      text must contain("\u00A0")   // nbsp
+      text must contain("\u00A9")   // copy
+      text must contain("\u20AC")   // euro
+    }
+
+    "parse numeric character references" in {
+      val result = PCDataXmlParser("<p>&#160;&#x20AC;</p>").openOrThrowException("Test")
+      val text = result.apply(0).text
+      text must contain("\u00A0")   // &#160; = nbsp
+      text must contain("\u20AC")   // &#x20AC; = euro
+    }
+
+    "parse CDATA sections as Lift PCData nodes" in {
+      val result = PCDataXmlParser("<div><![CDATA[x < y & z]]></div>").openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.child must haveSize(1)
+      val child = elem.child.head
+      child must beAnInstanceOf[PCData]
+      child.asInstanceOf[PCData].data === "x < y & z"
+    }
+
+    "parse namespace-prefixed elements" in {
+      val result = PCDataXmlParser("""<lift:surround with="default"><div/></lift:surround>""")
+        .openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.prefix === "lift"
+      elem.label === "surround"
+      (result.apply(0) \ "@with").text === "default"
+    }
+
+    "parse xmlns declarations and produce namespace bindings" in {
+      val result = PCDataXmlParser("""<html xmlns="http://www.w3.org/1999/xhtml"><body/></html>""")
+        .openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.label === "html"
+      elem.scope.uri === "http://www.w3.org/1999/xhtml"
+    }
+
+    "return Failure for malformed XML" in {
+      PCDataXmlParser("<div><span></div>") must beAnInstanceOf[Failure]
+    }
+
+    "return Failure for empty string" in {
+      PCDataXmlParser("") must beAnInstanceOf[Failure]
+    }
+
+    "parse self-closing tags as elements with empty children" in {
+      val result = PCDataXmlParser("<br/>").openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      elem.label === "br"
+      elem.child must beEmpty
+    }
+
+    "parse attributes containing encoded ampersands" in {
+      val result = PCDataXmlParser("""<a href="foo&amp;bar">x</a>""").openOrThrowException("Test")
+      val elem = result.apply(0).asInstanceOf[Elem]
+      (elem \ "@href").text === "foo&bar"
+    }
+
+    "parse via InputStream" in {
+      val bytes = "<p>hello</p>".getBytes("UTF-8")
+      val result = PCDataXmlParser(new ByteArrayInputStream(bytes)).openOrThrowException("Test")
+      result.apply(0).label === "p"
+    }
+  }
 
 }
-
diff --git a/core/util/src/test/scala-3/net/liftweb/util/XmlParserSpec.scala b/core/util/src/test/scala-3/net/liftweb/util/XmlParserSpec.scala
index b091007c5..bd13189d9 100644
--- a/core/util/src/test/scala-3/net/liftweb/util/XmlParserSpec.scala
+++ b/core/util/src/test/scala-3/net/liftweb/util/XmlParserSpec.scala
@@ -19,7 +19,7 @@ package util
 
 import java.io.ByteArrayInputStream
 
-import scala.xml.{Text, Unparsed}
+import scala.xml.{ EntityRef, Text, Unparsed }
 
 import org.specs2.matcher.XmlMatchers
 import org.specs2.mutable.Specification
@@ -71,7 +71,7 @@ class XmlParserSpec extends Specification with XmlMatchers {
   }
 
   "XML cannot contain Control characters" in {
-     val data = 
+     val data =
      <foo>
       {
         '\u0085'
@@ -99,5 +99,45 @@ class XmlParserSpec extends Specification with XmlMatchers {
     str.toList.foldLeft(0)((a, b) => a + cntIllegal(b)) === 0
   }
 
-}
+  "AltXML" should {
+    "render empty elements with self-close syntax" in {
+      AltXML.toXML(<br/>, false, true) must contain("/>")
+    }
+
+    "render non-empty elements with open and close tags" in {
+      val result = AltXML.toXML(<div>x</div>, false, true)
+      result must contain("<div>")
+      result must contain("</div>")
+    }
+
+    "preserve EntityRef nodes when convertAmp is false" in {
+      val data = <p>{EntityRef("nbsp")}</p>
+      val result = AltXML.toXML(data, false, false)
+      result must contain("&nbsp;")
+    }
+
+    "convert high-codepoint EntityRef to character when convertAmp is true" in {
+      // nbsp = 160, which is >= 128, so it converts to the actual char
+      val data = <p>{EntityRef("nbsp")}</p>
+      val result = AltXML.toXML(data, false, true)
+      result must contain("\u00A0")
+    }
+
+    "preserve low-codepoint EntityRef as entity when convertAmp is true" in {
+      // amp = 38, which is < 128, so it stays as &amp;
+      val data = <p>{EntityRef("amp")}</p>
+      val result = AltXML.toXML(data, false, true)
+      result must contain("&amp;")
+    }
 
+    "apply legacy IE compatibility mode to br tags" in {
+      // legacy mode: br gets />, no space
+      val withLegacy = AltXML.toXML(<br/>, false, true, legacyIeCompatibilityMode = true)
+      withLegacy must contain("/>")
+      // without legacy mode: br is in inlineTags, gets " />"
+      val withoutLegacy = AltXML.toXML(<br/>, false, true, legacyIeCompatibilityMode = false)
+      withoutLegacy must contain(" />")
+    }
+  }
+
+}

From 63672b6d82ac628a8f652f97c15e1283f498541b Mon Sep 17 00:00:00 2001
From: Matt Farmer <matt@frmr.me>
Date: Wed, 25 Feb 2026 22:09:12 -0500
Subject: [PATCH 2/6] refactor: replace NoBindingFactoryAdapter with
 XML.withXMLReader in Html5Parser

Use the public scala-xml API (XML.withXMLReader) instead of the unsupported
NoBindingFactoryAdapter internal class. The nu.validator HtmlParser already
implements XMLReader, so it integrates directly with XMLLoader.load().

Removes all scala.xml.parsing._ imports and internal field access from
HtmlParser.scala. AutoInsertedBody stripping logic is unchanged.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../scala/net/liftweb/util/HtmlParser.scala   | 49 ++-----------------
 1 file changed, 4 insertions(+), 45 deletions(-)

diff --git a/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala b/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala
index 6aa696594..61e9b2b3e 100644
--- a/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala
+++ b/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala
@@ -19,7 +19,6 @@ package util
 
 import net.liftweb.common._
 import scala.xml._
-import parsing._
 import java.io._
 
 import nu.validator.htmlparser._
@@ -344,53 +343,13 @@ trait Html5Parser {
       hp.setContentNonXmlCharPolicy(common.XmlViolationPolicy.ALLOW)
       hp.setContentSpacePolicy(common.XmlViolationPolicy.FATAL)
       hp.setNamePolicy(common.XmlViolationPolicy.ALLOW)
-      val saxer = new NoBindingFactoryAdapter {
-        /*
-        override def createNode (pre: String, label: String, attrs: MetaData, scope: NamespaceBinding, children: List[Node]) : Elem = {
-          if (pre == "lift" && label == "head") {
-            super.createNode(null, label, attrs, scope, children)
-          } else {
-            super.createNode(pre, label, attrs, scope, children)
-          }
-        }*/
-
-        override def captureText(): Unit = {
-          if (capture) {
-            val text = buffer.toString()
-            if (text.length() > 0) {
-              hStack = hStack.prepended(createText(text))
-            }
-          }
-          buffer.setLength(0)
-        }
-
-        // Override endDocument to handle empty hStack case in Scala 3
-        // Scala 3's List.last throws "None.get" error on empty lists
-        override def endDocument(): Unit = {
-          if (hStack.nonEmpty) {
-            epilogue = hStack.init.reverse
-            hStack = hStack.last :: Nil
-          }
-        }
-      }
-
-      saxer.scopeStack = saxer.scopeStack.prepended(TopScope)
-      hp.setContentHandler(saxer)
       val is = new InputSource(in)
       is.setEncoding("UTF-8")
-      hp.parse(is)
-
-      saxer.scopeStack = saxer.scopeStack.drop(1)
-
+      val elem = scala.xml.XML.withXMLReader(hp).load(is)
       in.close()
-      saxer.rootElem match {
-        case null => Empty
-        case e: Elem =>
-          AutoInsertedBody.unapply(e) match {
-            case Some(x) => Full(x)
-            case _ => Full(e)
-          }
-        case _ => Empty
+      AutoInsertedBody.unapply(elem) match {
+        case Some(x) => Full(x)
+        case _ => Full(elem)
       }
     }.flatMap(a => a)
   }

From e1be438b3cba6d05694f3c1d3134c5a40ab5366e Mon Sep 17 00:00:00 2001
From: Matt Farmer <matt@frmr.me>
Date: Wed, 25 Feb 2026 22:19:38 -0500
Subject: [PATCH 3/6] refactor: replace MarkupParser-based PCDataXmlParser with
 SAX-based implementation

Replace the PCDataMarkupParser trait and PCDataXmlParser class (which extended
ConstructingHandler, MarkupParser, and ExternalSources from scala.xml.parsing)
with a SAX-based LiftSaxTreeBuilder that uses javax.xml.parsers.SAXParserFactory.

Key design decisions:
- namespace-aware=false to allow undeclared namespace prefixes (e.g. lift:)
  and surface xmlns:* as regular attributes for manual NamespaceBinding construction
- LexicalHandler integration detects CDATA sections and produces Lift PCData nodes
- Named HTML entities (e.g. &nbsp;) preprocessed to numeric char refs before
  SAX parsing since a standard XML parser has no DTD with entity declarations
- CDATA sections skipped during entity preprocessing to preserve their content
- Public API (PCDataXmlParser.apply(String/InputStream) -> Box[NodeSeq]) unchanged
- Preamble stripping logic (XML declaration + DOCTYPE) unchanged

Removes all scala.xml.parsing.* imports from this file.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../net/liftweb/util/PCDataMarkupParser.scala | 300 ++++++++++--------
 1 file changed, 169 insertions(+), 131 deletions(-)

diff --git a/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala b/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala
index 9297923c9..48886f566 100644
--- a/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala
+++ b/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala
@@ -19,11 +19,13 @@ package util
 
 import common._
 
-import scala.xml.parsing.{ MarkupParser, MarkupHandler, FatalError, ConstructingHandler, ExternalSources }
 import scala.xml.dtd._
 import scala.xml._
-import java.io.InputStream
-import scala.io.{ Codec, Source }
+import java.io.{ InputStream, StringReader }
+import javax.xml.parsers.SAXParserFactory
+import org.xml.sax.{ Attributes, InputSource, SAXParseException }
+import org.xml.sax.ext.LexicalHandler
+import org.xml.sax.helpers.DefaultHandler
 
 /**
  * Utilities for simplifying use of named HTML symbols.
@@ -69,161 +71,198 @@ object HtmlEntities {
   def apply() = entities
 }
 
-/**
- * Extends the Markup Parser to do the right thing (tm) with PCData blocks
- */
-trait PCDataMarkupParser[PCM <: MarkupParser with MarkupHandler] extends MarkupParser { self: PCM =>
-  /** '&lt;! CharData ::= [CDATA[ ( {char} - {char}"]]&gt;"{char} ) ']]&gt;'
-   *
-   * see [15]
-   */
-  override def xCharData: NodeSeq = {
-    xToken("[CDATA[")
-    val pos1 = pos
-    val sb: StringBuilder = new StringBuilder()
-    while (true) {
-      if (ch==']'  &&
-          { sb.append(ch); nextch(); ch == ']' } &&
-          { sb.append(ch); nextch(); ch == '>' } ) {
-        sb.setLength(sb.length - 2);
-        nextch();
-        return PCData(sb.toString)
-      } else sb.append( ch );
-      nextch();
-    }
-    throw FatalError("this cannot happen");
-  }
-}
+object PCDataXmlParser {
+  import Helpers._
 
-class PCDataXmlParser(val input: Source) extends ConstructingHandler with PCDataMarkupParser[PCDataXmlParser] with ExternalSources  {
-  val preserveWS = true
-  ent ++= HtmlEntities()
-  import scala.xml._
+  def apply(in: InputStream): Box[NodeSeq] =
+    for {
+      ba  <- tryo(Helpers.readWholeStream(in))
+      ret <- apply(new String(ba, "UTF-8"))
+    } yield ret
 
-  /** Public accessor for curInput.hasNext to work around Scala 3 protected access restrictions */
-  def hasMoreInput: Boolean = curInput.hasNext
-  /** parse attribute and create namespace scope, metadata
-   *  [41] Attributes    ::= { S Name Eq AttValue }
-   */
-  override def xAttributes(pscope:NamespaceBinding): (MetaData,NamespaceBinding) = {
-    var scope: NamespaceBinding = pscope
-    var aMap: MetaData = Null
-    while (isNameStart(ch)) {
-      val pos = this.pos
-
-      val qname = xName
-      val _     = xEQ()
-      val value = xAttributeValue()
-
-      Utility.prefix(qname) match {
-        case Some("xmlns") =>
-          val prefix = qname.substring(6 /* xmlns: */ , qname.length);
-          scope = new NamespaceBinding(prefix, value, scope);
-
-        case Some(prefix)       =>
-          val key = qname.substring(prefix.length+1, qname.length);
-          aMap = new PrefixedAttribute(prefix, key, Text(value), aMap);
-
-        case _             =>
-          if( qname == "xmlns" )
-          scope = new NamespaceBinding(null, value, scope);
-          else
-          aMap = new UnprefixedAttribute(qname, Text(value), aMap);
-      }
+  def apply(in: String): Box[NodeSeq] = {
+    var pos = 0
+    val len = in.length
+    def moveToLT(): Unit =
+      while (pos < len && in.charAt(pos) != '<') pos += 1
 
-      if ((ch != '/') && (ch != '>') && ('?' != ch))
-      xSpace();
-    }
+    moveToLT()
 
-    def findIt(base: MetaData, what: MetaData): MetaData = (base, what) match {
-      case (_, Null) => Null
-      case (upb: UnprefixedAttribute, upn: UnprefixedAttribute) if upb.key == upn.key => upn
-      case (pb: PrefixedAttribute, pn: PrefixedAttribute) if pb.key == pn.key && pb.pre == pn.key => pn
-      case _ => findIt(base, what.next)
+    // scan past <? ... ?>
+    if (pos + 1 < len && in.charAt(pos + 1) == '?') {
+      pos += 1
+      moveToLT()
     }
 
-    if(!aMap.wellformed(scope)) {
-      if (findIt(aMap, aMap.next) != Null) {
-        reportSyntaxError( "double attribute")
-      }
+    // scan past <!DOCTYPE ....>
+    if (pos + 1 < len && in.charAt(pos + 1) == '!') {
+      pos += 1
+      moveToLT()
     }
 
-    (aMap,scope)
+    parseXml(preprocessEntities(in.substring(pos)))
   }
 
+  private def parseXml(content: String): Box[NodeSeq] =
+    tryo {
+      // namespace-aware=false: undeclared prefixes (e.g. lift:) are allowed; xmlns
+      // attributes are surfaced as regular attributes so we can build NamespaceBinding
+      // manually, matching the behaviour of the previous MarkupParser-based impl.
+      val spf = SAXParserFactory.newInstance()
+      spf.setNamespaceAware(false)
+      val saxParser = spf.newSAXParser()
+      val xmlReader = saxParser.getXMLReader
+      val builder   = new LiftSaxTreeBuilder
+      xmlReader.setContentHandler(builder)
+      xmlReader.setErrorHandler(builder)
+      xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", builder)
+      xmlReader.parse(new InputSource(new StringReader(content)))
+      NodeSeq.fromSeq(Seq(builder.result))
+    }
+
   /**
-   * report a syntax error
+   * Replace named HTML entity references with numeric character references so
+   * that standard XML parsers can handle them without a DTD.  CDATA sections
+   * are passed through verbatim since `&` inside them is not an entity ref.
    */
-  override def reportSyntaxError(pos: Int, msg: String): Unit =  {
-
-    //error("MarkupParser::synerr") // DEBUG
-    import scala.io._
-
-
-    val line = ScalaPosition.line(pos)
-    val col = ScalaPosition.column(pos)
-    val report = curInput.descr + ":" + line + ":" + col + ": " + msg
-    System.err.println(report)
-    try {
-      System.err.println(curInput.getLines().toIndexedSeq(line))
-    } catch {
-      case e: Exception => // ignore
-    }
-    var i = 1
-    while (i < col) {
-      System.err.print(' ')
-      i += 1
+  private def preprocessEntities(s: String): String = {
+    val sb  = new java.lang.StringBuilder(s.length)
+    var i   = 0
+    val len = s.length
+    while (i < len) {
+      val c = s.charAt(i)
+      if (c == '<' && i + 8 < len &&
+          s.charAt(i+1) == '!' && s.charAt(i+2) == '[' &&
+          s.charAt(i+3) == 'C' && s.charAt(i+4) == 'D' &&
+          s.charAt(i+5) == 'A' && s.charAt(i+6) == 'T' &&
+          s.charAt(i+7) == 'A' && s.charAt(i+8) == '[') {
+        // copy CDATA section verbatim
+        val end = s.indexOf("]]>", i + 9)
+        if (end >= 0) { sb.append(s, i, end + 3); i = end + 3 }
+        else          { sb.append(c); i += 1 }
+      } else if (c == '&' && i + 1 < len && s.charAt(i + 1) != '#') {
+        val semi = s.indexOf(';', i + 1)
+        if (semi > i && semi - i <= 12) {
+          val name = s.substring(i + 1, semi)
+          if (name.nonEmpty && name.forall(c => c.isLetter || c.isDigit)) {
+            HtmlEntities.entMap.get(name) match {
+              case Some(chr) =>
+                sb.append("&#"); sb.append(chr.toInt); sb.append(';')
+                i = semi + 1
+              case None =>
+                sb.append(c); i += 1
+            }
+          } else { sb.append(c); i += 1 }
+        } else { sb.append(c); i += 1 }
+      } else { sb.append(c); i += 1 }
     }
-    System.err.println('^')
-    throw new ValidationException(report)
+    sb.toString
   }
 
-}
+  /**
+   * SAX ContentHandler + LexicalHandler that builds a scala-xml node tree.
+   * CDATA sections become Lift [[PCData]] nodes instead of text nodes.
+   *
+   * Requires namespace-aware=false on the factory so that undeclared namespace
+   * prefixes (e.g. `lift:`) are accepted and `xmlns:*` attributes are surfaced
+   * in the attribute list for manual NamespaceBinding construction.
+   */
+  private class LiftSaxTreeBuilder extends DefaultHandler with LexicalHandler {
+    // (prefix, label, attributes, scope, children-accumulated-in-reverse)
+    private var stack: List[(String, String, MetaData, NamespaceBinding, List[Node])] = Nil
+    private val textBuf  = new java.lang.StringBuilder
+    private var inCDATA  = false
+    private val cdataBuf = new java.lang.StringBuilder
+
+    var result: Node = _
+
+    private def flushText(): Unit =
+      if (textBuf.length > 0) {
+        val t = Text(textBuf.toString)
+        textBuf.setLength(0)
+        pushChild(t)
+      }
 
-object PCDataXmlParser {
-  import Helpers._
+    private def pushChild(n: Node): Unit =
+      stack match {
+        case (pre, lbl, attrs, scope, children) :: rest =>
+          stack = (pre, lbl, attrs, scope, n :: children) :: rest
+        case Nil =>
+      }
 
-  def apply(in: InputStream): Box[NodeSeq] = {
-    for {
-      ba <- tryo(Helpers.readWholeStream(in))
-      ret <- apply(new String(ba, "UTF-8"))
-    } yield ret
-  }
+    override def startElement(uri: String, localName: String, qName: String,
+                              attrs: Attributes): Unit = {
+      flushText()
+
+      // Start from the parent's scope and extend with this element's xmlns declarations.
+      var scope: NamespaceBinding = stack.headOption.map(_._4).getOrElse(TopScope)
+      var metadata: MetaData      = Null
+
+      for (i <- (attrs.getLength - 1) to 0 by -1) {
+        val aqn = attrs.getQName(i)
+        val v   = attrs.getValue(i)
+        if (aqn == "xmlns") {
+          scope = new NamespaceBinding(null, v, scope)
+        } else if (aqn.startsWith("xmlns:")) {
+          scope = new NamespaceBinding(aqn.substring(6), v, scope)
+        } else {
+          val ai = aqn.indexOf(':')
+          metadata =
+            if (ai > 0)
+              new PrefixedAttribute(aqn.substring(0, ai), aqn.substring(ai + 1), Text(v), metadata)
+            else
+              new UnprefixedAttribute(aqn, Text(v), metadata)
+        }
+      }
 
-  private def apply(source: Source): Box[NodeSeq] = {
-    for {
-      p <- tryo{new PCDataXmlParser(source)}
-      _ = while (p.ch != '<' && p.hasMoreInput) p.nextch() // side effects, baby
-      bd <- tryo(p.document())
-      doc <- Box !! bd
-    } yield (doc.children: NodeSeq)
+      val ci = qName.indexOf(':')
+      val (pre, label) =
+        if (ci > 0) (qName.substring(0, ci), qName.substring(ci + 1))
+        else        (null, qName)
 
-  }
+      stack = (pre, label, metadata, scope, Nil) :: stack
+    }
 
-  def apply(in: String): Box[NodeSeq] = {
-    var pos = 0
-    val len = in.length
-    def moveToLT(): Unit =  {
-      while (pos < len && in.charAt(pos) != '<') {
-        pos += 1
+    override def endElement(uri: String, localName: String, qName: String): Unit = {
+      flushText()
+      stack match {
+        case (pre, label, metadata, scope, children) :: rest =>
+          stack = rest
+          val elem = Elem(pre, label, metadata, scope, minimizeEmpty = true, children.reverse: _*)
+          rest match {
+            case Nil =>
+              result = elem
+            case (pp, pl, pm, ps, pc) :: rr =>
+              stack = (pp, pl, pm, ps, elem :: pc) :: rr
+          }
+        case Nil =>
       }
     }
 
-    moveToLT()
+    override def characters(ch: Array[Char], start: Int, length: Int): Unit =
+      if (inCDATA) cdataBuf.append(ch, start, length)
+      else         textBuf.append(ch, start, length)
 
-    // scan past <? ... ?>
-    if (pos + 1 < len && in.charAt(pos + 1) == '?') {
-      pos += 1
-      moveToLT()
+    override def startCDATA(): Unit = {
+      flushText()
+      inCDATA = true
+      cdataBuf.setLength(0)
     }
 
-    // scan past <!DOCTYPE ....>
-    if (pos + 1 < len && in.charAt(pos + 1) == '!') {
-      pos += 1
-      moveToLT()
+    override def endCDATA(): Unit = {
+      inCDATA = false
+      pushChild(PCData(cdataBuf.toString))
+      cdataBuf.setLength(0)
     }
 
-    apply(Source.fromString(in.substring(pos)))
+    override def fatalError(e: SAXParseException): Unit = throw e
+
+    // LexicalHandler no-ops
+    override def startDTD(name: String, publicId: String, systemId: String): Unit = {}
+    override def endDTD(): Unit = {}
+    override def startEntity(name: String): Unit = {}
+    override def endEntity(name: String): Unit = {}
+    override def comment(ch: Array[Char], start: Int, length: Int): Unit = {}
   }
 }
 
@@ -462,4 +501,3 @@ object AltXML {
   }
 
 }
-

From 3428402a3ee336ef1de6098863450b27442fc315 Mon Sep 17 00:00:00 2001
From: Matt Farmer <matt@frmr.me>
Date: Wed, 25 Feb 2026 22:20:47 -0500
Subject: [PATCH 4/6] chore: remove scala-xml.parsing and dtd internal API
 remnants

- Remove unused import scala.xml.parsing.XhtmlParser from BlockParsers.scala
- Remove HtmlEntities.entities and apply() which used ParsedEntityDecl/IntDef
  from scala.xml.dtd (these were only used by the now-removed PCDataXmlParser class)
- Remove import scala.xml.dtd._ from PCDataMarkupParser.scala

Completes the removal of all scala.xml internal API usage from lift-util.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../src/main/scala/net/liftweb/markdown/BlockParsers.scala    | 1 -
 .../src/main/scala/net/liftweb/util/PCDataMarkupParser.scala  | 4 ----
 2 files changed, 5 deletions(-)

diff --git a/core/markdown/src/main/scala/net/liftweb/markdown/BlockParsers.scala b/core/markdown/src/main/scala/net/liftweb/markdown/BlockParsers.scala
index d6d33a2e5..c0ec5d797 100644
--- a/core/markdown/src/main/scala/net/liftweb/markdown/BlockParsers.scala
+++ b/core/markdown/src/main/scala/net/liftweb/markdown/BlockParsers.scala
@@ -24,7 +24,6 @@ import scala.language.postfixOps
 import collection.immutable.StringOps
 import collection.mutable.ListBuffer
 import scala.xml.{Group, Node, Text, NodeSeq, Elem => XmlElem, TopScope, XML}
-import scala.xml.parsing.XhtmlParser
 import util.parsing.combinator.{Parsers, RegexParsers}
 
 /**
diff --git a/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala b/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala
index 48886f566..98adc066e 100644
--- a/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala
+++ b/core/util/src/main/scala/net/liftweb/util/PCDataMarkupParser.scala
@@ -19,7 +19,6 @@ package util
 
 import common._
 
-import scala.xml.dtd._
 import scala.xml._
 import java.io.{ InputStream, StringReader }
 import javax.xml.parsers.SAXParserFactory
@@ -66,9 +65,6 @@ object HtmlEntities {
 
   val revMap: Map[Char, String] = Map(entList.map{ case (name, value) => (value.toChar, name)} :_*)
 
-  val entities = entList.map{case (name, value) => (name, new ParsedEntityDecl(name, new IntDef(value.toChar.toString)))}
-
-  def apply() = entities
 }
 
 object PCDataXmlParser {

From 213b9297deb805a855ca88070ce574ac6da5041b Mon Sep 17 00:00:00 2001
From: Matt Farmer <matt@frmr.me>
Date: Sat, 28 Feb 2026 13:19:07 -0500
Subject: [PATCH 5/6] fix: add specs2-xml dependency for Scala 3 to fix CI
 compilation failures

In specs2 5.x (used for Scala 3), XmlMatchers moved from specs2-matcher-extra
to a separate specs2-xml artifact. Eight test files in scala-3/ imported
org.specs2.matcher.XmlMatchers, causing compilation failures for all Scala 3.3.7
CI jobs.

Also fix a type inference issue in HtmlRoundTripSpec where `must not contain`
was ambiguous under Scala 3 + specs2 5.x; replaced with `must not(contain(...))`.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 build.sbt                                                 | 1 +
 .../test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala | 4 ++--
 project/Dependencies.scala                                | 8 ++++++++
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/build.sbt b/build.sbt
index 7a8d36497..20013048b 100644
--- a/build.sbt
+++ b/build.sbt
@@ -21,6 +21,7 @@ ThisBuild / libraryDependencies ++= Seq(
   scalactic,
   scalatest
 )
+ThisBuild / libraryDependencies ++= specs2XmlDeps(scalaVersion.value)
 
 ThisBuild / scalacOptions       ++= Seq("-deprecation")
 
diff --git a/core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala b/core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala
index 64b40791e..bf8a7e3aa 100644
--- a/core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala
+++ b/core/util/src/test/scala-3/net/liftweb/util/HtmlRoundTripSpec.scala
@@ -84,8 +84,8 @@ class HtmlRoundTripSpec extends Specification with Html5Parser with Html5Writer
       val output = toString(result)
       output must contain("<br>")
       output must contain("<img ")
-      output must not contain "</br>"
-      output must not contain "</img>"
+      output must not(contain("</br>"))
+      output must not(contain("</img>"))
     }
   }
 
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 9b71363c1..5e9c272d7 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -93,6 +93,14 @@ object Dependencies {
   lazy val specs2Prov: ModuleMap = (version: String) => "org.specs2" %% "specs2-core" % specs2Version(version) % Provided
   lazy val specs2Matchers: ModuleMap = (version: String) => "org.specs2" %% "specs2-matcher-extra" % specs2Version(version) % Test
   lazy val specs2MatchersProv: ModuleMap = (version: String) => "org.specs2" %% "specs2-matcher-extra" % specs2Version(version) % Provided
+  def specs2XmlDeps(version: String): Seq[ModuleID] =
+    CrossVersion.partialVersion(version) match {
+      case Some((3, _)) =>
+        Seq("org.specs2" %% "specs2-xml" % specs2Version(version) % Test)
+      case _ =>
+        Seq.empty
+    }
+
   lazy val specs2Mock: ModuleMap = (version: String) => {
     CrossVersion.partialVersion(version) match {
       case Some((2, 13)) => "org.specs2" %% "specs2-mock" % specs2Version(version) % Test

From 77e23d1a5d597a1549b45e00a2e778ec329fdff2 Mon Sep 17 00:00:00 2001
From: Matt Farmer <matt@frmr.me>
Date: Sat, 14 Mar 2026 23:42:47 -0400
Subject: [PATCH 6/6] fix: close InputStream in Html5Parser.parse on failure

Wrap parsing in try/finally so the InputStream is always closed,
including when XML.withXMLReader(...).load() throws an exception.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../main/scala/net/liftweb/util/HtmlParser.scala    | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala b/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala
index 61e9b2b3e..4c8d2d1b5 100644
--- a/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala
+++ b/core/util/src/main/scala/net/liftweb/util/HtmlParser.scala
@@ -345,11 +345,14 @@ trait Html5Parser {
       hp.setNamePolicy(common.XmlViolationPolicy.ALLOW)
       val is = new InputSource(in)
       is.setEncoding("UTF-8")
-      val elem = scala.xml.XML.withXMLReader(hp).load(is)
-      in.close()
-      AutoInsertedBody.unapply(elem) match {
-        case Some(x) => Full(x)
-        case _ => Full(elem)
+      try {
+        val elem = scala.xml.XML.withXMLReader(hp).load(is)
+        AutoInsertedBody.unapply(elem) match {
+          case Some(x) => Full(x)
+          case _ => Full(elem)
+        }
+      } finally {
+        in.close()
       }
     }.flatMap(a => a)
   }