makiri 0.11.0.rc2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5c68dc8b6bb133010a1ec3aada51eea868a0b645d1e02832b36b929f7ef5f2e
-  data.tar.gz: 66c4ff9d957074f37c4d1e9d1c1570b328ca86f1acdabc49c8d8d1435e24330d
+  metadata.gz: 19309bc1e3663b299aa192c879718ffb75926783690cd1213338c472d7d439fe
+  data.tar.gz: 0a7498c693ec14f659ea75dcd85c02af153fe5c19b172f62ffcaaf3d2c549ab0
 SHA512:
-  metadata.gz: d66a4deb197ac04e51b9234425d740dec346cf5e4de4e2a29aedd6ad50e299ee4f6f3229a698cab3bf54e1756472fe5771fb7266df1180d87d2769ba39d757d9
-  data.tar.gz: ceb2392bddf7d1a4683f72239e13fc4785522cadc5ebf33a18b2ca67b3b1f1f97a49ecb4e72e12218463aafe7dc3aecc75efe8c540e36c56ff74b5d30f7bff9f
+  metadata.gz: 2465968a7f276bf2c93b4d0e37928a3d292f05212e37d0148a29b529494a3ef52e51ae2679c478c4b11994ad229fac5e6869f7d169c4293bab68ae791e654a5b
+  data.tar.gz: 1ffe5dd03e3d00914ecf4c6753000a6a82dfc160deb7b0d4b3fa6da93d27dbd082c6e073f63f6d35c2b6ad2ae7f508edb9f011da7cfb50ba70235bd96eea4c50

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## [0.12.0] - 2026-10-01
+
+Most changes accept what the DOM allows where 0.11.0 raised. The XML
+serializers (`to_xml`, `canonicalize`) raise instead when the tree holds
+something XML cannot write.
+
+### Changed
+
+HTML:
+
+* `to_html` / `inner_html` write a `<template>`'s contents, not its own
+  children (added with `add_child`), as browsers do.
+* `create_element_ns` in the HTML namespace accepts an upper-case name
+  (`BR`, `DIV`), as the DOM does. It makes an unknown element: not void, and
+  not matched by type selectors. Importing such an XHTML element from XML
+  behaves the same way.
+
+XML:
+
+* Text, attribute values and comments accept the characters the DOM allows:
+  `"\f"`, U+0001, NUL, and `--` in a comment.
+* `set_attribute_ns` accepts names XML cannot write, such as `p:a}b`.
+* `to_xml` and `canonicalize` raise while any of the above is in the tree.
+* `create_cdata` with `]]>` and `create_processing_instruction` with `?>`
+  now raise `ArgumentError`.
+* `canonicalize` adds the namespace declarations a name needs instead of
+  raising. It still raises where it would have to invent a prefix.
+
+HTML to XML (`import_node`):
+
+* The copy is in its namespace at once. Before, it was in none until
+  inserted.
+* The copy gets no `xmlns` attribute.
+* An attribute XML cannot write (`x-on:click`, `@click`) is copied as it is
+  instead of raising.
+* A `<template>` keeps its own children, after its contents.
+
+Other:
+
+* `Node#path` round-trips when a sibling with a different prefix or case
+  would also match the same XPath step.
+
+## [0.11.0] - 2026-09-30
+
+No code changes since 0.11.0.rc2. Coming from 0.10.x, read the rc2 and rc1
+notes below as well.
+
 ## [0.11.0.rc2] - 2026-09-30
 
 ### Added

data/NOKOGIRI_DIFFERENCES.md

@@ -184,11 +184,11 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     that does not fit the name (`set_attribute_ns`, `create_element_ns`)
     raises `Makiri::Error`. Invalid UTF-8 raises `Makiri::Error` for every
     argument, names included.
-  * `create_element_ns` refuses an HTML-namespace name in upper case that
-    lower-cases to an element Lexbor knows (`BR`, `DIV`), where the DOM makes
-    an unknown element: Lexbor would make that element (`BR` void, its
-    children never written). Other names keep their case (`MY-EL`). Nokogiri
-    has no `create_element_ns`.
+  * `create_element_ns` keeps the case of an HTML-namespace name, as the DOM
+    does: `create_element_ns(XHTML, "BR")` is an unknown element named `BR`,
+    not a void `br`, and type selectors do not match it (XPath name tests do,
+    folding case on HTML elements as browsers do). Nokogiri has no
+    `create_element_ns`.
 * An HTML `<template>` follows the WHATWG content model, which Nokogiri does
   not: its parsed contents live in the separate fragment `Element#content_fragment`
   returns, `template.children` is empty, and `inner_html` / `inner_html=`
@@ -198,6 +198,11 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   ordinary element, with the parsed nodes as its children, so
   `template.inner_html` and `template.children` answer the other way round and
   there is no `content_fragment`.
+  * `Makiri::XML` has no template contents: an XHTML `<template>`'s children
+    are its children. Crossing into HTML they become its contents, and back
+    they become children - what a browser's XML parser, which puts them in the
+    contents, and its importNode give for the same document. An XML
+    `<template>` whose children should stay children has no way to say so.
 * An HTML document has one root element and no text child, as the DOM requires;
   `doc << element` beside an existing root raises.
 * An insertion the DOM refuses - a child under a text, comment, PI, doctype
@@ -205,13 +210,20 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   `Makiri::Error` in both representations. Nokogiri refuses the same ones with
   `ArgumentError` (or `RuntimeError` for a second XML root).
 * Moving HTML into an XML document (`xml_doc.import_node(html_node)`, or
-  inserting one) keeps every name's namespace, and refuses what XML cannot
-  write that way. An attribute in no namespace whose name has a prefix other
-  than `xml` - `v-on:click`, `fb:like`, an `xlink:href` on an HTML (not SVG)
-  element - raises `Makiri::Error`: as XML it would be a prefix bound to
-  nothing. Nokogiri copies it and writes `v-on:click="..."` into output that is
-  not namespace-well-formed. An element named with a colon (`<fb:like>`)
-  crosses as a DOM-loose name, which `to_xml` refuses.
+  inserting one) copies it as the DOM's clone does: every element in its
+  namespace from the start (an imported `<p>` is XHTML before it is
+  inserted), every attribute named as it is, and no `xmlns` attribute added -
+  `to_xml` and `canonicalize` write the declarations the output needs.
+  Nokogiri's copy of an HTML5 `<div>` is in no namespace, and libxml2
+  declares `xmlns:svg` on it for an SVG child (in `namespace_definitions`),
+  writing the child as `<svg:svg>`. One XML cannot write that way -
+  in no namespace with a colon or no XML name, `v-on:click`, `:href`,
+  `@click`, `fb:like` - crosses DOM-loose, and `to_xml` refuses the tree
+  while it is there; so does an element named with a colon (`<fb:like>`).
+  Nokogiri copies them and writes output that is not namespace-well-formed.
+  * One exception to the DOM: an HTML attribute named `xml:lang` (in no
+    namespace) becomes the XML namespace's `xml:lang`, as the XML reader reads
+    that name, so XHTML-style HTML still writes as XML.
 * A known gap, in Lexbor's tag table: an HTML document that already holds a
   parsed element named with a colon (`<x:y>`, one local name) and then
   receives, by `import_node` from another document, a prefixed element
@@ -284,7 +296,7 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   case-sensitivity rule, as browsers do: lower-cased for an HTML element (`LI`
   matches `<li>`), as written for any other (`feGaussianBlur` matches the SVG
   element, `fegaussianblur` does not). An HTML element named in upper case
-  (`create_element_ns(XHTML, "MY-EL")`, which keeps its name as the DOM does)
+  (`create_element_ns(XHTML, "DIV")`, which keeps its name as the DOM does)
   therefore matches no type selector.
   * `Nokogiri::HTML5` is case-sensitive on HTML elements too, so `LI` does not
     match `<li>` there. `Makiri::XML`'s `#css` is case-sensitive, as XML names
@@ -321,5 +333,12 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   `Makiri::Error`.
   * On re-parse, the HTML tokenizer replaces a U+0000 in text/attributes with
     U+FFFD (WHATWG), so a serialized-then-reparsed round-trip is not byte-identical.
-  * `Makiri::XML` rejects NUL everywhere: XML 1.0 has no legal U+0000 character,
-    so admitting it would produce non-well-formed XML.
+  * `Makiri::XML` holds the character data the DOM holds, NUL included:
+    text or an attribute value with a character XML has no `Char` for (`\f`,
+    U+0001, U+0000), a comment with `--`. Nokogiri takes the same, but NUL
+    (`ArgumentError`, a Ruby C-string limit). Where they part is the output. `to_xml` / `canonicalize` raise for such a tree; Nokogiri writes
+    `\f` in text as U+FFFD (the data changes) and a comment's `--` or an
+    attribute value's `\f` as it stands (the output does not parse).
+    `create_cdata` refuses `]]>` and `create_processing_instruction` `?>`,
+    raising `ArgumentError` as the DOM's factories do; Nokogiri takes the PI
+    and writes `<?t a?>b?>`, which re-reads as another tree.

data/ext/makiri/rust/build.rs

@@ -262,6 +262,14 @@ fn main() {
         .allowlist_function("lxb_dom_attr_set_name")
         .allowlist_function("lxb_dom_document_create_element")
         .allowlist_function("lxb_dom_element_create")
+        // An HTML element named as written (`DIV`, not `div`): its case-kept
+        // tag is Lexbor's `lxb_tag_append` (UNDECLARED_EXPORTS), and the rest
+        // is `lxb_dom_element_create`'s own steps with that tag.
+        .allowlist_function("lxb_dom_document_create_interface_noi")
+        .allowlist_function("lxb_dom_document_destroy_interface_noi")
+        .allowlist_function("lxb_ns_prefix_append")
+        .allowlist_type("lxb_tag_data_t")
+        .allowlist_type("lxb_ns_prefix_data_t")
         .allowlist_function("lxb_dom_document_create_text_node")
         .allowlist_function("lxb_dom_document_create_comment")
         .allowlist_function("lxb_dom_document_create_processing_instruction")
@@ -281,6 +289,10 @@ fn main() {
         .allowlist_function("lxb_css_selector_serialize_chain")
         // The HTML serializers `lexbor::serialize` drives through its sink.
         .allowlist_function("lxb_html_serialize_tree_cb")
+        // One node's own markup: Makiri drives the walk
+        // itself (`adapter::html::serialize`), so a <template> writes its
+        // contents and not its own children, as the HTML Standard says.
+        .allowlist_function("lxb_html_serialize_cb")
         .allowlist_function("lxb_html_serialize_deep_cb")
         .allowlist_function("lxb_html_serialize_pretty_tree_cb")
         .allowlist_function("lxb_html_serialize_pretty_deep_cb")
@@ -382,6 +394,12 @@ const UNDECLARED_EXPORTS: &[(&str, &str, &str, &str)] = &[
         "lxb_dom_attr_qualified_name_append",
         "lexbor_hash_t *hash, const lxb_char_t *name, size_t length",
     ),
+    (
+        "lexbor/tag/tag.c",
+        "LXB_API const lxb_tag_data_t *",
+        "lxb_tag_append",
+        "lexbor_hash_t *hash, lxb_tag_id_t tag_id, const lxb_char_t *name, size_t length",
+    ),
     (
         "lexbor/dom/interfaces/element.c",
         "LXB_API lxb_status_t",

data/ext/makiri/rust/src/bridge/doc.rs

@@ -163,6 +163,12 @@ pub fn import_node(rb_self: Value, node_v: Value, deep: bool) -> Result<Value, E
         // SAFETY: `doc` is the receiver's live document.
         unsafe { import_copy(doc, src, deep, "import node") }
     })??;
+    /* The copy carries whatever its source held. */
+    if crate::bridge::wrapper::may_hold_template_children(
+        crate::bridge::wrapper::keepalive_document(node_v)?,
+    ) {
+        crate::bridge::wrapper::note_template_children(rb_self);
+    }
     wrap_html_node(imp, rb_self)
 }
 

data/ext/makiri/rust/src/bridge/html.rs

@@ -396,6 +396,15 @@ fn release_from_tree(node: HtmlNodeMut<'_>) {
 pub fn insert(this: &HtmlSelf, rb_incoming: Value, place: Place) -> Result<Value, Error> {
     let target = edit(this)?.node()?;
     let (key, incoming_doc) = html_node_key(rb_incoming)?;
+    /* A child placed under a template is one of its own, not its contents
+     * (see `HtmlParsed::note_template_children`). */
+    let parent_after = match place {
+        Place::Child => Some(target.node()),
+        Place::Before | Place::After | Place::Replace => target.node().parent(),
+    };
+    if parent_after.is_some_and(HtmlNode::is_html_template) {
+        crate::bridge::wrapper::note_template_children(this.document);
+    }
     /* The argument is relinked too - `place` changes its parent and siblings, and
      * an adoption removes it from its own document - so a frozen argument is a
      * frozen node being modified. The receiver check alone let it through, which
@@ -419,6 +428,10 @@ pub fn insert(this: &HtmlSelf, rb_incoming: Value, place: Place) -> Result<Value
     if !adopted {
         return Ok(rb_incoming);
     }
+    /* The copy carries whatever its source held. */
+    if crate::bridge::wrapper::may_hold_template_children(incoming_doc) {
+        crate::bridge::wrapper::note_template_children(this.document);
+    }
     adopt_release(rb_incoming)?;
     wrap_html_node(placed, this.document)
 }
@@ -563,12 +576,6 @@ pub fn create_element<'d>(doc: HtmlDoc<'d>, name: &RubyText) -> Option<RawNode>
     doc.create_element(name.as_bytes()).map(RawNode::from)
 }
 
-/// The refusal of an HTML-namespace name Lexbor would make as another element
-/// (`HtmlDoc::misreads_html_name`), from `create_element_ns` and the
-/// XML-to-HTML import alike.
-pub const HTML_NAME_CASE: &str = "cannot make an HTML element whose upper-case name \
-lower-cases to a known element (BR, SCRIPT, ...): it would be made as that element";
-
 /// A new element named `local` in namespace `ns` ("" = none), with `prefix`
 /// ("" = none) - the DOM's createElementNS, once the caller has validated and
 /// split the name.

data/ext/makiri/rust/src/bridge/wrapper.rs

@@ -895,6 +895,25 @@ pub fn ensure_document_mutable(rb_doc: Value) -> Result<(), Error> {
 
 /// Drop the DOM and text indexes so the next query rebuilds them. An XML
 /// Document keeps none.
+/// Record that `rb_doc` may now hold a `<template>` with children of its own
+/// (`HtmlParsed::note_template_children`): an edit placed one under a
+/// template, or a copy came from a document that may hold one.
+pub fn note_template_children(rb_doc: Value) {
+    if let Content::Html(_) = doc_content_known(rb_doc) {
+        with_html_parsed_known(rb_doc, HtmlParsed::note_template_children);
+    }
+}
+
+/// Whether `rb_doc` may hold a `<template>` with children of its own. True for
+/// anything that is no parsed HTML document, which the template-aware
+/// serializer is right for too.
+pub fn may_hold_template_children(rb_doc: Value) -> bool {
+    match doc_content_known(rb_doc) {
+        Content::Html(_) => with_html_parsed_known(rb_doc, |p| p.may_hold_template_children()),
+        _ => true,
+    }
+}
+
 pub fn invalidate_indexes(rb_doc: Value) {
     if let Content::Html(_) = doc_content_known(rb_doc) {
         with_html_parsed_known(rb_doc, HtmlParsed::invalidate_indexes);

data/ext/makiri/rust/src/bridge/xml.rs

@@ -209,7 +209,7 @@ fn xml_mut_error(st: MutError) -> Error {
             return crate::bridge::ruby::arg_error("not a well-formed XML name");
         }
         MutError::BadDomName(why) => return crate::bridge::ruby::arg_error(why),
-        MutError::BadChars => "value contains a character or sequence not permitted in XML",
+        MutError::InvalidCharacter(why) => return crate::bridge::ruby::arg_error(why),
         MutError::UnboundNs => "namespace prefix is not bound in this scope",
         MutError::Type => "operation unsupported for this node type",
         MutError::Cycle => "cannot insert a node into its own subtree",
@@ -244,7 +244,6 @@ namespace (only xmlns=\"\" undeclares, and only the default)"
             "the namespace does not fit the qualified name (a prefix needs a namespace; \
 xml and xmlns take only their own)"
         }
-        MutError::HtmlNameCase => crate::bridge::html::HTML_NAME_CASE,
         MutError::Internal => "internal error mutating XML (no document)",
         /* The document's own budget, not the machine's memory - so the same
          * exception a parse raises for the same cause. */
@@ -364,7 +363,7 @@ pub fn verified_text(v: Value, what: &str) -> Result<RubyText, Error> {
 }
 
 /// `t`, unless it is too long for an XML node's `u32` span.
-fn fits_xml_node(t: RubyText) -> Result<RubyText, Error> {
+fn fits_xml_node<T: core::ops::Deref<Target = str>>(t: T) -> Result<T, Error> {
     if u32::try_from(t.len()).is_err() {
         return Err(makiri_error("string too long for an XML node (max 4 GiB)"));
     }
@@ -378,6 +377,26 @@ pub fn verified_name(v: Value, what: &str) -> Result<RubyText, Error> {
     fits_xml_node(crate::bridge::string::ruby_verified_name(v, what)?)
 }
 
+/// [`verified_text`] for DATA - text, comment, CDATA and PI content, an
+/// attribute value: valid UTF-8, and NUL allowed, as the DOM allows it there
+/// ([`crate::bridge::string::ruby_verified_data`], what HTML's data takes).
+/// XML cannot write U+0000, so the serializers refuse a tree holding one, as
+/// they refuse any character XML has no `Char` for.
+pub fn verified_data(v: Value, what: &str) -> Result<crate::bridge::string::RubyData, Error> {
+    fits_xml_node(crate::bridge::string::ruby_verified_data(v, what)?)
+}
+
+/// [`verified_data`] for an optional argument: `nil` is `None`.
+pub fn verified_data_opt(
+    v: Value,
+    what: &str,
+) -> Result<Option<crate::bridge::string::RubyData>, Error> {
+    if v.is_nil() {
+        return Ok(None);
+    }
+    verified_data(v, what).map(Some)
+}
+
 /// [`verified_name`] for an optional argument: `nil` is `None`.
 pub fn verified_name_opt(v: Value, what: &str) -> Result<Option<RubyText>, Error> {
     if v.is_nil() {

data/ext/makiri/rust/src/glue/html_node/mutate.rs

@@ -209,6 +209,10 @@ pub fn set_content(_ruby: &Ruby, this: HtmlSelf, rb_text: Value) -> Result<Value
         let edit = edit(&this)?;
         let tv = ruby_verified_data(rb_text, "node content")?;
         let node = edit.node()?;
+        /* A template's text is a child of its own, not its contents. */
+        if node.node().is_html_template() {
+            crate::bridge::wrapper::note_template_children(this.document);
+        }
         crate::bridge::html::set_text_content(node, &tv)
             .map_err(|_| makiri_error("failed to set node content"))?;
         Ok(rb_text)
@@ -284,6 +288,9 @@ pub fn set_outer_html(_ruby: &Ruby, this: HtmlSelf, rb_html: Value) -> Result<Va
                 "outer_html= requires a node with a parent element",
             ));
         };
+        if parent.node().is_html_template() {
+            crate::bridge::wrapper::note_template_children(this.document);
+        }
         let staged = stage_fragment_in(parent, html)?;
         node.place(staged, Place::Replace);
         Ok(rb_html)
@@ -336,9 +343,6 @@ pub fn create_element_ns(
         let ns = nv.as_ref().map_or(&b""[..], |n| n.as_bytes());
         let (prefix, local) =
             extract(ruby, ns, &qv, dom_name::valid_element_local_name, "element")?;
-        if doc.misreads_html_name(local, ns) {
-            return Err(makiri_error(crate::bridge::html::HTML_NAME_CASE));
-        }
         created(
             crate::bridge::html::create_element_ns(doc, local, ns, prefix),
             rb_self,

data/ext/makiri/rust/src/glue/html_node/serialize.rs

@@ -23,9 +23,16 @@ fn pretty_opt(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
 
 /// The receiver's serialization as a UTF-8 String, or `Makiri::Error` on a
 /// Lexbor status failure.
-fn render(ruby: &Ruby, node: RawNode, deep: bool, pretty: bool) -> Result<RString, Error> {
-    let buf =
-        serialize(node, deep, pretty).ok_or_else(|| makiri_error("HTML serialization failed"))?;
+fn render(
+    ruby: &Ruby,
+    document: Value,
+    node: RawNode,
+    deep: bool,
+    pretty: bool,
+) -> Result<RString, Error> {
+    let aware = crate::bridge::wrapper::may_hold_template_children(document);
+    let buf = serialize(node, deep, pretty, aware)
+        .ok_or_else(|| makiri_error("HTML serialization failed"))?;
     /* Lexbor emits UTF-8, so the String is tagged UTF-8 rather than built as
      * binary and re-tagged. */
     Ok(ruby.enc_str_new(buf.as_slice(), ruby.utf8_encoding()))
@@ -39,7 +46,7 @@ fn to_html(ruby: &Ruby, this: HtmlSelf, args: &[Value]) -> Result<RString, Error
          * children: the deep serializer is the right one (the tree serializer
          * rejects a fragment node). */
         let deep = this.node().node_type() == NodeType::DocumentFragment;
-        render(ruby, this.raw(), deep, pretty)
+        render(ruby, this.document, this.raw(), deep, pretty)
     })
 }
 
@@ -56,7 +63,7 @@ fn inner_html(ruby: &Ruby, this: HtmlSelf, args: &[Value]) -> Result<RString, Er
             .node()
             .template_content()
             .map_or(this.raw(), RawNode::from);
-        render(ruby, target, true, pretty)
+        render(ruby, this.document, target, true, pretty)
     })
 }
 

data/ext/makiri/rust/src/glue/xml_node/mutate.rs

@@ -16,9 +16,9 @@ use crate::bridge::ruby::makiri_error;
 use crate::bridge::string::namespace_arg;
 
 use crate::bridge::xml::{
-    begin_edit, import_copy, incoming_node, verified_name, verified_name_opt, verified_text,
-    verified_text_opt, with_arena_for_new_node, wrap_xml_node as wrap, xml_mut_result, Editing,
-    XmlSelf,
+    begin_edit, import_copy, incoming_node, verified_data, verified_data_opt, verified_name,
+    verified_name_opt, verified_text, verified_text_opt, with_arena_for_new_node,
+    wrap_xml_node as wrap, xml_mut_result, Editing, XmlSelf,
 };
 use crate::init::CLASS_XML_DOCUMENT;
 use crate::xml::dom_name::split_loose_dom_name;
@@ -63,7 +63,7 @@ pub fn aset(_ruby: &Ruby, this: XmlSelf, name: Value, val: Value) -> Result<Valu
     crate::bridge::ruby::entry(|| {
         let edit = element_for(this)?;
         let nv = verified_name(name, "attribute name")?;
-        let vv = verified_text(val, "attribute value")?;
+        let vv = verified_data(val, "attribute value")?;
         let (name, value) = (nv.as_bytes(), vv.as_bytes());
         xml_mut_result(edit.with_arena(|d, n| mutate::set_attribute(d, n, name, value))?)?;
         Ok(val)
@@ -81,7 +81,7 @@ pub fn set_attribute_ns(
     crate::bridge::ruby::entry(|| {
         let edit = element_for(this)?;
         let qv = verified_name(qname, "attribute qualified name")?;
-        let vv = verified_text(val, "attribute value")?;
+        let vv = verified_data(val, "attribute value")?;
         let nv = namespace_arg(ns, "namespace")?;
         let (ns, qname, value) = (
             nv.as_ref().map_or(&b""[..], |n| n.as_bytes()),
@@ -107,7 +107,7 @@ pub fn set_loose_dom_attribute(
     crate::bridge::ruby::entry(|| {
         let edit = element_for(this)?;
         let nv = verified_name(name, "attribute name")?;
-        let vv = verified_text(val, "attribute value")?;
+        let vv = verified_data(val, "attribute value")?;
         let (name, value) = (nv.as_bytes(), vv.as_bytes());
         xml_mut_result(
             edit.with_arena(|d, n| mutate::set_loose_dom_attribute(d, n, name, value))?,
@@ -157,7 +157,7 @@ pub fn delete(_ruby: &Ruby, this: XmlSelf, name: Value) -> Result<Value, Error>
 pub fn set_content(_ruby: &Ruby, this: XmlSelf, text: Value) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
         let edit = begin_edit(this)?;
-        let tv = verified_text(text, "node content")?;
+        let tv = verified_data(text, "node content")?;
         let bytes = tv.as_bytes();
         xml_mut_result(edit.with_arena(|d, n| mutate::set_content(d, n, bytes))?)?;
         Ok(text)
@@ -248,7 +248,7 @@ pub fn create_element(ruby: &Ruby, rb_self: Value, args: &[Value]) -> Result<Val
         }
 
         let nv = verified_name(name, "element name")?;
-        let cv = verified_text_opt(content, "element content")?;
+        let cv = verified_data_opt(content, "element content")?;
         let name = nv.as_bytes();
         let el = xml_mut_result(with_arena_for_new_node(rb_self, |d| {
             mutate::new_element(d, name)
@@ -342,7 +342,7 @@ fn create_chardata(
     type_: ArenaKind,
     what: &str,
 ) -> Result<Value, Error> {
-    let tv = verified_text(text, what)?;
+    let tv = verified_data(text, what)?;
     let bytes = tv.as_bytes();
     let n = xml_mut_result(with_arena_for_new_node(rb_self, |d| {
         mutate::new_chardata(d, type_, bytes)
@@ -367,7 +367,7 @@ pub fn create_cdata(_ruby: &Ruby, rb_self: Value, t: Value) -> Result<Value, Err
 pub fn create_pi(_ruby: &Ruby, rb_self: Value, target: Value, data: Value) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {
         let tg = verified_name(target, "PI target")?;
-        let dt = verified_text(data, "PI data")?;
+        let dt = verified_data(data, "PI data")?;
         let (target, data) = (tg.as_bytes(), dt.as_bytes());
         let pi = xml_mut_result(with_arena_for_new_node(rb_self, |d| {
             mutate::new_pi(d, target, data)

data/ext/makiri/rust/src/glue/xml_node/serialize.rs

@@ -40,6 +40,10 @@ fn failure_error(f: Failure, verb: &str) -> Error {
                 "cannot {verb} XML containing a DOM-loose doctype (a name or id XML cannot write)"
             )
         }
+        Failure::UnwritableData => format!(
+            "cannot {verb} XML containing character data XML cannot hold (a character \
+outside XML's, -- in a comment, or ?> in a processing instruction)"
+        ),
         Failure::ForbiddenDeclaration => format!(
             "cannot {verb} XML containing a namespace declaration XML forbids \
 (such as xmlns:p=\"\", held as set_attribute_ns made it)"
@@ -74,9 +78,9 @@ fn failure_error(f: Failure, verb: &str) -> Error {
 or insert the node where it is declared)"
         ),
         Failure::NamespaceMismatch => format!(
-            "cannot {verb} XML whose namespace declarations no longer match its names \
-(a node moved from under its declaration, or one removed); to_xml writes the \
-declarations it needs"
+            "cannot {verb} XML where one prefix would have to mean two namespaces on an \
+element, or an unprefixed attribute has a namespace (canonical form invents no \
+prefix); to_xml writes such a tree"
         ),
     };
     makiri_error(msg)

data/ext/makiri/rust/src/lexbor/abi.rs

@@ -110,7 +110,7 @@ pub type LxbDoc = lxb_dom_document_t;
 /* Every other Lexbor function the crate calls - the `_noi` twins of the
  * `lxb_inline` accessors included - is GENERATED by build.rs from the header
  * that declares it, so its signature is Lexbor's own and a change to it fails
- * the build. These three are the exception: exported by Lexbor but declared
+ * the build. These four are the exception: exported by Lexbor but declared
  * in NO header, so bindgen cannot see them. Lexbor's own sources
  * forward-declare them exactly this way. What stands in for the header is
  * build.rs's `UNDECLARED_EXPORTS`, which reads each C DEFINITION and fails the
@@ -121,7 +121,10 @@ pub type LxbDoc = lxb_dom_document_t;
  * `lxb_dom_attr_qualified_name_append` interns a name CASE-PRESERVING, which is
  * what lets createDocumentType keep its case where Lexbor's own create()
  * lowercases. `lxb_dom_element_qualified_name_set` does the same for an
- * element's name. */
+ * element's name. `lxb_tag_append` interns a TAG name case-preserving, where
+ * every Lexbor create lowercases it first (`lxb_tag_append_lower`): an HTML
+ * element named `DIV` by createElementNS gets a tag of its own rather than
+ * `div`'s, and so is the unknown element the DOM makes rather than a div. */
 extern "C" {
     pub fn lxb_dom_attr_set_name_ns(
         attr: *mut LxbAttr,
@@ -146,6 +149,12 @@ extern "C" {
         lname: *const u8,
         lname_len: usize,
     ) -> u32;
+    pub fn lxb_tag_append(
+        hash: *mut lexbor_hash_t,
+        tag_id: lxb_tag_id_t,
+        name: *const u8,
+        length: usize,
+    ) -> *const lxb_tag_data_t;
 }
 
 /* The C allocator, which `lexbor::memory` wraps for Lexbor. Written here