makiri 0.10.0.rc2-aarch64-linux → 0.11.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75d5f9396671a66a5faede037375c56ae2e7920a424c5f857707ac583d09fe6b
-  data.tar.gz: 5fd67d814657a6a47449d0ee523ae000e0f77b49e5875e69df99fdfcc9c9438f
+  metadata.gz: 5b203c0ffb03e49f10b8e30afd6b070d36fd054867b7b3fd0e1376778b9e4b94
+  data.tar.gz: 3a26a99a690546bcc5367fab22645b8c47bd65dec58df75df5a7a93950de3386
 SHA512:
-  metadata.gz: ffd0bc4de1aa2ab659e536ee69ed43b033cdcbcb01be60ff60e49d59302f3abc428073bf53a62db97f885f23d5b6a61520f8740c5d67a2a4709bb2c303ff1213
-  data.tar.gz: 3211a8681f03c39bf6f3cfe6369b7bac2cb23ac7a60e6a7e6a1bfe3a2f851843af3a8924bdc2c09d51c79e6a37aae15b4cd027c968f188911b9be2ddbe9ba202
+  metadata.gz: 5397148284ec99562ffe74e4f633f903405c420cc7593c996b600d13c65e9f94a48bf69a477a45063cd6e2a369b87f4d55f324bce1bcc0087b7f37cc6d73f5d4
+  data.tar.gz: 232787e75468ce0da009f1755538c062cabab7bdadd0a3a0eeb8b9e5f388f59eb0f4159e9f2b8152761f7c7c9e6619a3aa5568955358435d26f8a130e31a472e

data/.github/workflows/libfuzzer.yml

@@ -25,7 +25,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        target: [xml, xpath, xml_xpath, css, html, html_xpath]
+        target: [xml, xpath, xml_xpath, css, html, html_xpath, html_css]
 
     steps:
       - name: Checkout (with vendored Lexbor submodule)

data/.github/workflows/release.yml

@@ -86,9 +86,18 @@ jobs:
           # names the GNU triple; this installs the std that goes with it.
           # Empty elsewhere, so the other runners are unaffected.
           targets: ${{ runner.os == 'Windows' && 'x86_64-pc-windows-gnu' || '' }}
-      - name: Install libclang (bindgen, via rb-sys)
+      # clang/lld/llvm are for the vendored Lexbor's LTO, not for bindgen: on
+      # Linux the whole chain has to be LLVM or extconf turns LTO off (gcc
+      # emits GIMPLE, which rust-lld cannot read - see the note in
+      # extconf.rb). It DETECTS them, so a runner without them still builds,
+      # just without LTO - which is what this job used to ship, silently,
+      # to every user who installs the precompiled gem (see the measured win
+      # in CLAUDE.md's "Vendored Lexbor is built with LTO" section: this is
+      # the job that produces those gems, and `ci.yml` installing the chain
+      # only exercises the fast path in CI, it does not ship it).
+      - name: Install libclang (bindgen) and the LLVM chain (Lexbor LTO)
         if: runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y libclang-dev
+        run: sudo apt-get update && sudo apt-get install -y libclang-dev clang lld llvm
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}

data/.github/workflows/security.yml

@@ -55,7 +55,7 @@ jobs:
           bundler-cache: true
 
       - name: Run short fuzz under sanitizers
-        run: bundle exec rake fuzz:sanitize FUZZ_ARGS="--time 30"
+        run: FUZZ_TIME=30 bundle exec rake fuzz:sanitize
 
   # macOS-only malloc-leak gate: ASan everywhere runs with detect_leaks=0 (Ruby
   # and Lexbor are uninstrumented), so this is the ONLY automated leak check. It
@@ -98,9 +98,9 @@ jobs:
         run: bundle exec rake leaks
 
   # OOM-injection sweep: rebuilds with MAKIRI_ALLOC_INJECT=1 and fails each core
-  # C allocation site in turn, gating that every OOM branch fails closed - a
-  # clean exception or a baseline-identical result, never truncated output
-  # (see script/check_alloc_failures.rb).
+  # Rust allocation site in turn, gating that every OOM branch fails closed - a
+  # clean exception or a baseline-identical result, with stateful objects reusable
+  # after the failure (see script/check_alloc_failures.rb).
   security-alloc-inject:
     name: OOM-injection sweep
     runs-on: ubuntu-latest
@@ -137,9 +137,8 @@ jobs:
       - name: Run the OOM-injection sweep
         run: bundle exec rake oom
 
-  # Nightly: fuzz EVERY target (the 30s PR fuzz covers only the default xpath
-  # target; the CSS engine reuse and the XML parser/mutator are each their own
-  # documented memory-safety risk, so each gets a full 300s run).
+  # Nightly: fuzz EVERY target for a longer run. The PR job already exercises
+  # every surface for 30s; nightly gives each target a full 300s run.
   security-fuzz-nightly:
     name: Nightly sanitized fuzz (${{ matrix.target }})
     runs-on: ubuntu-latest
@@ -178,7 +177,7 @@ jobs:
           bundler-cache: true
 
       - name: Run nightly fuzz under sanitizers
-        run: bundle exec rake fuzz:sanitize FUZZ_ARGS="--target ${{ matrix.target }} --time 300"
+        run: FUZZ_ARGS="--target ${{ matrix.target }} --time 300" bundle exec rake fuzz:sanitize
 
   # Nightly: the whole spec suite with Lexbor ITSELF built under ASan (mraw
   # poisoning on), catching intra-arena overflows that a plain ASan build cannot

data/CHANGELOG.md

@@ -1,5 +1,211 @@
 # Changelog
 
+## [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
+
+* `Makiri::HTML::Document#create_element_ns(namespace_uri, qualified_name)`
+  (DOM `createElementNS`). An SVG or MathML element made this way keeps its
+  name's case and behaves like a parsed one. An upper-case name in the HTML
+  namespace that names a known element (`BR`, `DIV`) raises `Makiri::Error`.
+* `Makiri::XML::Element#set_loose_dom_attribute(qualified_name, value)` (DOM
+  `setAttribute`): the attribute is in no namespace and keeps the name as
+  given (`xmlns`, `xlink:href`, `v-on:click`). `to_xml` raises while the
+  document holds one XML cannot write.
+
+### Changed
+
+* A NUL in an element, attribute, doctype or PI target name raises
+  `ArgumentError`, like any other invalid name. A namespace that does not fit
+  the name still raises `Makiri::Error`.
+* HTML type selectors are case-sensitive on SVG and MathML elements, as in
+  browsers: `fegaussianblur` no longer matches `feGaussianBlur`.
+* `set_attribute_ns` accepts the XML namespace with any prefix or none again
+  (rc1 raised); `to_xml` writes such an attribute as `xml:name`.
+* XML `set_attribute_ns` accepts a namespace declaration XML forbids, such as
+  `xmlns:foo=""`. It binds nothing, and `to_xml` raises while it is present.
+* XML `create_document_type` accepts any public and system id, and any name
+  without whitespace, NUL or `>`. `to_xml` raises if the doctype cannot be
+  written as XML.
+
+### Fixed
+
+* `import_node` from XML to HTML keeps an upper-case XHTML element name
+  (`Foo`) instead of lower-casing it, and raises for one that names a known
+  element (`BR`).
+
+## [0.11.0.rc1] - 2026-09-29
+
+### Changed
+
+* HTML `#css` / `#at_css` / `#matches?` now match with Makiri's own Rust
+  implementation instead of Lexbor's `lxb_selectors` (selectors are still
+  parsed by Lexbor). Where the answers differ:
+  * `:nth-child(An+B of S)` / `:nth-last-child(... of S)` count by the CSS
+    definition; Lexbor miscounted when `S` was a comma list, held a
+    combinator, or carried pseudo-classes such as `:enabled`.
+  * `:disabled`, `:enabled` and `:checked` follow the HTML Standard: a
+    control inside a `<fieldset disabled>` (outside its first `<legend>`) is
+    disabled, `<option>` / `<optgroup>` count, and `:enabled` matches only
+    form elements.
+  * Attribute selector names are matched by qualified name, and
+    case-sensitively on SVG/MathML elements: `[href]` no longer finds
+    `xlink:href`, nor `[viewbox]` an SVG `viewBox`.
+  * `#id` / `.class` match only the no-namespace `id` / `class` attribute.
+  * A selector chain is capped at 64 compounds (as `Makiri::XML` already
+    was), and a query at 50M steps of work (XPath's limit); past either,
+    `Makiri::Error`.
+  * The column combinator `||` raises `Makiri::Error` instead of matching
+    nothing.
+
+### Removed
+
+* `:lexbor-contains()` in HTML `#css` / `#at_css` / `#matches?`: it still
+  parses, but raises `Makiri::Error`. `Makiri::XML`'s `#css` keeps it. See
+  NOKOGIRI_DIFFERENCES.md.
+* `Node#name=` / `#node_name=`. The DOM cannot rename an element, and renaming
+  a Lexbor element in place could crash (`div` to `template`). Create a new
+  element and `replace` the old one.
+
+### Security
+
+* Hardening: every heap block the vendored Lexbor allocates carries 16 bytes
+  of slack past its end, so a small overrun cannot reach neighbouring memory
+  (not in sanitizer builds).
+* Adding an `id` or `class` attribute beside an existing one
+  (`set_attribute_ns(nil, "ID", v)`, a namespaced `id`) no longer frees the
+  existing one under a held `Attr`. HTML attribute reads and writes follow the
+  DOM: `#[]`, `#key?`, `#[]=` and `#delete` match the qualified name
+  (`svg_a["href"]` no longer returns `xlink:href`), copies and imports keep
+  every attribute, and a no-namespace name keeps its case.
+* `content=` on an HTML element and `delete(name)` detach the nodes they
+  remove instead of freeing them under a live wrapper.
+* `el[name] = value` on an existing attribute no longer leaves a destroyed
+  attribute linked when storing the value runs out of memory.
+* A checked argument String is locked while its bytes are in use, so a later
+  argument's `#to_s` cannot rewrite it (it raises instead); a receiver frozen
+  by an argument's `#to_s` is not edited; and a mutator's argument can no
+  longer rebuild the document's indexes in the middle of the edit.
+* HTML element and attribute names follow the DOM's rules:
+  `create_element("img src=x onerror=alert(1)")` raises `ArgumentError`
+  instead of writing that markup. See NOKOGIRI_DIFFERENCES.md.
+* HTML parsing bounds the tree depth (`max_tree_depth:`, default 400) and the
+  `<option>`s one `<select>` receives (10,000), raising `Makiri::Error` past
+  either; both made the parse quadratic.
+* `Makiri::Lexbor::CSS.parse_stylesheet` no longer crashes on a
+  `:lexbor-contains()` after a string ended by CR, FF or a newline.
+* A CSS query that runs out of memory raises instead of answering with what it
+  had collected; a selector-parse OOM is reported as OOM, not
+  `CSS::SyntaxError`.
+* Inputs whose cost grew faster than their size are linear or budgeted: many
+  namespace bindings, the `preceding` axis and reverse-axis steps, XML
+  duplicate-attribute checks, `contains` / `substring-*` / `translate` on long
+  strings, XML CSS `:nth-*`, CDATA full of `]]>`, and stylesheets with
+  rejected `:lexbor-contains()`.
+* A panic in any Ruby method Makiri defines raises `Makiri::InternalError`
+  (rescuable), not `fatal`.
+
+### Fixed
+
+* A document that grows by editing (appended nodes, `inner_html=`) reports
+  its new size to the GC, so memory pressure from it triggers collections; it
+  was reported once, at parse time.
+* A node wrapped while memory runs out raises `Makiri::Error` instead of
+  coming back as a second Ruby object for the same node, without the first
+  one's `freeze`, instance variables or singleton methods.
+* Insertion follows the DOM's pre-insertion rules in HTML and XML alike: no
+  cycles through a template's contents (which hung `dup`), no children on
+  Text/Comment/PI/DocumentType/Attr, no Text directly under an XML Document,
+  and an XML `DocumentFragment` takes children.
+* `inner_html` / `inner_html=` on a `<template>` target its contents, agreeing
+  with `#to_html` and `content_fragment`.
+* HTML `#keys` / `#values` raise on out-of-memory instead of returning a
+  truncated Array.
+* `dup`, `clone_node` and `import_node` keep an element's name as written
+  (`linearGradient`, `q:Bar`), and a copied XML doctype keeps its PUBLIC id.
+* Namespaces across HTML <-> XML `import_node`: attributes keep their own
+  namespace, a prefixed element keeps its prefix and case, names XML cannot
+  write are refused where they would be written, and copied `xmlns`
+  attributes no longer move elements between namespaces.
+* XML namespaces: `set_attribute_ns` on a detached element survives insertion;
+  `[]=` on an existing attribute changes only its value; the mutators refuse
+  what the parser refuses (forbidden declarations, duplicate expanded names,
+  bad doctype names and PUBLIC ids); `canonicalize` raises instead of writing a
+  wrong namespace; and a refused declaration says which rule it broke.
+* `to_xml` output re-parses: CDATA holding `]]>`, a SYSTEM id holding `"`, and
+  attributes with a namespace but no prefix.
+* XPath: `string()` of a number follows libxml2 (as Nokogiri does);
+  `substring()` rounds per spec; node-set vs boolean comparisons follow §3.4;
+  the `xml` prefix is always bound; a comparison no longer raises
+  `LimitExceeded` because its values added up past 64 MB.
+* `Node#path` round-trips through `#at_xpath` for CDATA, PIs, and namespaced
+  nodes (SVG/MathML, XML namespaces, `xlink:href`, Vue/Word-style names); an
+  unreachable node answers `"?"` as in Nokogiri.
+* CSS over XML agrees with the HTML matcher on `.x\ y`, `:root`, empty and
+  whitespace attribute values, `$=` with non-ASCII, `:empty` beside a comment,
+  and `[|a]`; the `s` modifier is accepted.
+* An HTML document refuses a second root element or a text child; an
+  attribute's parent is always its owner element.
+* `Node#line` of a node copied from another document is nil.
+* `Makiri::XML` nodes compare with `<=>` in document order (an attribute with
+  itself too), and `XML::Document#dup` / `#clone` return a copy.
+* `clone_node` on a Document raises instead of returning the document.
+* `NodeSet#css` / `#xpath` / `#at_css` / `#at_xpath` pass their extra
+  arguments through; `#xpath` of a non-node-set expression raises
+  `ArgumentError`, as in Nokogiri.
+* `XML::Builder` no longer answers `respond_to?` for `to_ary` and similar.
+* Namespace Hashes and `register_namespace` arguments are read as a Hash and
+  with `String()`, with one length cap and one error message.
+* A rejected stylesheet rule's `selector_text` is sliced by Lexbor's offsets.
+
+### Performance
+
+* `NodeSet#at_css` / `#at_xpath` stop at the first node with a match.
+* `XML::Node#canonicalize` looks namespaces up by prefix in the scope it keeps:
+  a 1000-deep document of declarations went from 0.7 s to 0.02 s.
+
+## [0.10.0] - 2026-09-22
+
+### Fixed
+
+* A frozen node now raises `FrozenError` when it is the ARGUMENT of a tree
+  mutation, not only the receiver: `b.add_child(a)` relinks `a` exactly as
+  `a.remove` does. Both `Makiri::XML` and `Makiri::HTML`. A fragment argument
+  splices its children, which have no wrapper of their own to check.
+* A `Makiri::XML` mutation that exceeds the document's own `max_bytes` /
+  `max_nodes` now raises `Makiri::XML::LimitExceeded` instead of reporting the
+  refusal as out of memory.
+* Inserting a `DocumentFragment` is all or nothing on `add_child`, `before` and
+  `after`, as it already was on `replace`: a child the rules refuse no longer
+  leaves the earlier ones linked in a document the caller was told had not
+  changed.
+* A rejected `Makiri::XML::Document#fragment` no longer charges the document for
+  the nodes it discarded. 100k rejected fragments grew a `<r/>` document to
+  77 MB; it is now 516 bytes.
+* A failed `Makiri::XML` parse reports the FIRST failure for all four kinds
+  (`syntax` was sticky while `limit` and `unsupported` overwrote each other).
+* `Makiri::XML#to_xml`'s serializer allocates fallibly again, so running out of
+  memory raises instead of aborting the process.
+* `:lexbor-contains()` now rejects an argument the bundled CSS parser does not
+  take, the way any unknown pseudo-class is rejected: `Makiri::CSS::SyntaxError`
+  from `#css` / `#at_css` / `#matches?`, and a `:bad_style` rule from
+  `Makiri::Lexbor::CSS.parse_stylesheet`. Well-formed uses are unchanged.
+
+### Performance
+
+* `Makiri::XML#to_xml` plans namespaces from a binding stack instead of
+  re-walking each ancestor's attribute list, which cost O(depth^2 x attributes).
+  403 KB of nested prefixed attributes took 4.88s and now takes 0.001s. A
+  crafted document fails closed with `Makiri::Error` ("namespace planning
+  exceeded its step budget") rather than running on.
+* Setting an attribute on a `Makiri::XML` element walks the attribute list once
+  instead of twice (4096 attributes: 47ms -> 27ms).
+
 ## [0.10.0.rc2] - 2026-09-20
 
 ### Added

data/NOKOGIRI_DIFFERENCES.md

@@ -26,11 +26,34 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     exactly (`//*[@refX]`, not `@refx`). Only ASCII folds: `Ø` still differs from `ø`.
     This holds in `namespace_matching: :lax` too.
   * `Nokogiri::HTML5` is case-sensitive there.
+* `Node#path` names a node by expanded name where a bare name would not reach it
+  * An SVG, MathML or namespaced-XML node, and an HTML name that is no plain
+    XPath name (`<o:p>`, `xml:lang`, Vue's `@click`), give
+    `*[local-name()='path' and namespace-uri()='http://www.w3.org/2000/svg']`,
+    which `#at_xpath` evaluates with no prefix registered. Nokogiri writes
+    `svg:svg` or `/*/*[2]` for the first kinds; the paths are equivalent, the
+    strings are not.
+  * A node not attached to its document answers `"?"`, as a doctype does.
+    Nokogiri answers `"/div/p"` for a detached `<div><p>`, which is the path of
+    the document's own `/div/p` when it has one.
 * A foreign element's namespace declarations are not attributes
   * `<svg xmlns="...">` has no `@xmlns` for `//*[@xmlns]` or `@*`, as in browsers
     and in XPath's data model. An `xmlns` on an HTML element is an ordinary
     attribute and stays visible.
 
+* A `StandardError` raised by a custom-function handler becomes `Makiri::Error`
+  ("handler raised: <message>"), with the handler's exception as its `#cause`
+  * Nokogiri re-raises the handler's exception itself. Anything that is not a
+    `StandardError` (`Interrupt`, `SystemExit`, Timeout's exception) and a
+    `throw` reach the caller unchanged in both.
+
+* A number literal is read as the nearest double; libxml2's own reader is not
+  correctly rounded for a literal with more digits than a double holds, so
+  `string(0.72609133372266155)` is `0.726091333722662` in Makiri and
+  `0.726091333722661` in Nokogiri (the digits differ in the last place). The
+  number is then written by libxml2's rule in both (`string(1234567890.5)` is
+  `1.2345678905e+09`); only the value read differs.
+
 ## XML
 
 * `Makiri::XML` is XML 1.0 (Fifth Edition) only and non-validating.
@@ -61,6 +84,13 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   * `create_processing_instruction("a:b", ...)` succeeds, as DOM
     `createProcessingInstruction` does, but `#to_xml` / `#canonicalize` then raise,
     as DOM Parsing's well-formed serializer does. Nokogiri writes `<?a:b ...?>`.
+* `#freeze` on a node is ENFORCED: a frozen node's mutators raise `FrozenError`,
+  and so does passing a frozen node as the argument of an insertion, which
+  relinks it. Nokogiri reports `frozen?` but every mutator still mutates. The
+  check reaches the nodes the caller named; a fragment argument splices its
+  children, and those cannot be checked, because frozen-ness is a property of a
+  Ruby object and the arena keeps no map from a node back to its wrapper.
+
 * A node's namespace URI is its identity, not something re-derived from the
   declarations around it - the WHATWG DOM model, measured against Chrome 152
   (`DOMParser` + `XMLSerializer`).
@@ -77,6 +107,19 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     invents one (`ns1`, `ns2`, ...) rather than shadow the other, as browsers do.
   * An element in no namespace stays that way under a default namespace,
     serialized as `xmlns=""`.
+  * `create_document_type` takes what the DOM's `createDocumentType` takes -
+    any id, and a name without whitespace, NUL or `>` - and `to_xml` refuses a
+    doctype XML cannot write (`create_document_type("q", "abcde", %(x"'y))`).
+    Nokogiri writes that system id as `"x&quot;'y"`, which parses but reads
+    back as the id `x&quot;'y` - a literal expands no references.
+  * `set_attribute_ns(XMLNS_NS, "xmlns:foo", "")` - a declaration Namespaces in
+    XML forbids, which the DOM's `setAttributeNS` accepts - is kept as an
+    attribute that binds nothing, and `to_xml` refuses the tree while it is
+    there. `root["xmlns:foo"] = ""` still raises.
+  * An attribute in the XML namespace is written as `xml:local`, whatever
+    prefix it was given (`set_attribute_ns(XML_NS, "a:bb")`, as the DOM
+    allows): Namespaces in XML binds that namespace to `xml` alone. It re-reads
+    to the same namespace and local name. `canonicalize` writes it so too.
   * Nodes from the factories (`create_element` and friends) still take their
     namespace from the context they are first inserted into, so a subtree can be
     built detached and attached afterwards. Only later moves carry.
@@ -93,6 +136,14 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   the property-based differential), including namespaces, prolog/epilog comments
   and PIs, and adjacent-CDATA coalescing.
 
+* `to_xml` keeps an element's namespace when an `xmlns` attribute on it says
+  otherwise
+  * `root["xmlns"] = "urn:x"` on an element in no namespace is not written: the
+    element stays in no namespace when the output is re-read, as the DOM Parsing
+    and Serialization spec asks. Nokogiri writes `<r xmlns="urn:x">`, which moves
+    the element into `urn:x` on re-parse. Create the element in the namespace
+    instead (`create_element("r", "xmlns" => "urn:x")`, or parse it so).
+
 ## HTML parsing
 
 * `<?php ... ?>` in HTML input is a **ProcessingInstruction** node; `#to_html`
@@ -102,6 +153,79 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     still produces the older bogus comment (`<!--?php ... ?-->`), and
     `Nokogiri::HTML` (libxml2) its own comment.
 
+* A tree deeper than `max_tree_depth` raises **`Makiri::Error`**, where
+  `Nokogiri::HTML5` raises `ArgumentError`; the default (400) and boundary are
+  Nokogiri's. `inner_html=`, `outer_html=` and `Node#parse` take no keyword.
+  `Nokogiri::HTML` (libxml2) instead stops at depth 256 and returns the
+  truncated document.
+* More than 10,000 `<option>`s in one `<select>` raise `Makiri::Error`;
+  Nokogiri has no such limit.
+
+## HTML mutation
+
+* There is no `Node#name=` / `#node_name=` (on HTML or XML nodes). Nokogiri
+  renames a node in place and keeps its identity; the DOM has no rename, and
+  Lexbor keeps elements such as `<template>`, `<option>` and `<style>` in
+  structs of their own, so a node cannot change its tag safely. Create an
+  element of the new name, move the attributes and children, and `replace`
+  the old one (see CHANGELOG.md).
+* Element and attribute names follow the WHATWG DOM's rules
+  * `create_element`, `[]=` and `set_attribute_ns` raise `ArgumentError` for a
+    name the DOM refuses - one holding whitespace, `/`, `>` (or `=` for an
+    attribute) - where `Nokogiri::HTML5` accepts it and writes it into the
+    markup as it stands: `create_element("img src=x onerror=alert(1)")`
+    serializes as that tag.
+    The names HTML actually uses (`data-*`, `aria-*`, `@click`, `:href`,
+    `v-on:x`, custom elements) are accepted.
+  * `set_attribute_ns(nil, "x:y")` raises, as the DOM's `setAttributeNS` does:
+    a prefix needs a namespace. `[]=` (HTML) and `set_loose_dom_attribute`
+    (XML) are the DOM's `setAttribute`, which makes such an attribute.
+  * A refused name raises `ArgumentError` - a NUL in it too - and a namespace
+    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`.
+* 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=`
+  special-case the contents (the WHATWG DOM special-cases `innerHTML` alone;
+  `append_child`, `content=`, and `children` act on the element's own empty
+  children, as the specification says). Nokogiri treats `<template>` as an
+  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`.
+* 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
+  or attribute node, text under an XML Document, a second root - raises
+  `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.
+* 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
+  written the same way (`x:y` from XML: prefix `x`, local name `y`) re-points
+  the table's entry for that spelling - the parsed element then no longer
+  matches CSS `x\:y`. Copies within one document do not touch the table.
+* An XML element with a prefix, imported into HTML, keeps it (`h:div` in
+  XHTML has the local name `div`). Two readers then disagree, as they do in
+  browsers: CSS's `div` matches it (Lexbor matches the local name), XPath's
+  `//div` does not (an HTML element's name test reads its qualified name). And
+  Lexbor's HTML serializer writes the prefix (`<h:div>`), where the HTML
+  standard writes the local name, so the HTML does not re-parse to the same
+  element.
+
 ## CSS
 
 * Most jQuery/Nokogiri CSS extensions are not supported (`:gt`, `:lt`, `:eq`, `:first`, ...)
@@ -109,13 +233,18 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     text-containment extension. Use XPath (`xpath("//p[contains(., 'x')]")`) or
     Enumerable (`css('li')[1]`) for the rest.
     Standard Level-4 selectors (`:is` / `:where` / `:has`) are supported; some of which Nokogiri rejects.
-  * `:lexbor-contains("text")` is supported (on both HTML and XML) - Lexbor's
-    spelling of the jQuery `:contains()` substring filter, matching an element
-    whose text contains the string; append ` i` (`:lexbor-contains("text" i)`)
-    for an ASCII case-insensitive match. (Nokogiri's name `:contains` is not an
-    alias.) Like Lexbor's matcher, it tests the element's immediate child text
-    nodes (not the deep string-value), so HTML and XML agree; on XML it lowers
-    to XPath `child::text()[contains(., "text")]`.
+  * `:lexbor-contains("text")` - Lexbor's spelling of the jQuery `:contains()`
+    substring filter, matching an element whose text contains the string;
+    append ` i` (`:lexbor-contains("text" i)`) for an ASCII case-insensitive
+    match. (Nokogiri's name `:contains` is not an alias.) **XML only**: it
+    lowers to XPath `child::text()[contains(., "text")]`, testing the
+    element's immediate child text nodes, not the deep string-value. HTML no
+    longer supports it - `lexbor::css_match`, the safe-Rust port that
+    replaced Lexbor's own matcher for HTML, deliberately does not reimplement
+    it, so a well-formed `:lexbor-contains()` now raises `Makiri::Error`
+    ("could not be run") on HTML rather than ever matching (it still PARSES,
+    and an actually malformed one still raises `Makiri::CSS::SyntaxError`, as
+    before).
 * Untyped `:*-of-type` (`:first-of-type`, `:nth-of-type(an+b)`, ... with no type
   selector) is supported and correct on both HTML and XML - the "type" is the
   element's own expanded name.
@@ -131,12 +260,35 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     prefix IS resolved against the bindings, when the namespace matters.
   * `Makiri::XML` resolves CSS prefixes properly - it lowers the selector to the
     XPath engine, which registers the bindings.
+  * The same holds for attribute selectors: HTML `[|href]` (no namespace) and
+    plain `[href]` also find an SVG `xlink:href`, which `Nokogiri::HTML5`
+    does not.
+    `Makiri::XML` reads `[|a]` as the no-namespace attribute.
+* A selector under a node matches the way `Element#querySelectorAll` does in a
+  browser, not scoped to that node, on HTML: `at_css("#c").css("div p")` finds a
+  `p` inside `#c` when `#c` is itself a `div`, since the selector is matched
+  against the whole document and only the results are kept to descendants.
+  `Nokogiri::HTML5` and `Nokogiri::XML` scope the selector to the node (`#c`
+  cannot be the `div`), and so does `Makiri::XML`, which lowers the selector to
+  an XPath from the node. Lexbor has no `:scope`; for a scoped match on HTML,
+  use XPath from the node (`xpath(".//div//p")`).
+* The attribute case modifiers (`[a="x" i]`, `[a="x" s]`): HTML supports both,
+  through Lexbor's matcher. `Makiri::XML` accepts `s` (case-sensitive, which XML
+  values are anyway) and refuses `i` with `Makiri::CSS::SyntaxError`. Nokogiri
+  refuses both on either representation.
 * `#matches?` answers for a DETACHED node (`document.create_element("p")
   .matches?("p")` is true, on both representations). Nokogiri raises
   `NoMethodError` there - it implements `#matches?` as a search from
   `ancestors.last`, which a detached node does not have.
-* * Type selectors are ASCII case-insensitive (CSS-correct for HTML; `LI` matches `<li>`)
-  * `Nokogiri::HTML5` is case-sensitive there.
+* Type selectors in an HTML document follow the HTML Standard's
+  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)
+  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
+    are.
 
 ## Serialization
 
@@ -163,7 +315,10 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   and attribute values (`[]=`, `set_attribute_ns`) - and stored/read back
   verbatim, matching the WHATWG DOM / browsers (`document.createTextNode("\0")`).
   It is still rejected in names, tag names, namespaces, PI target/data, CSS
-  selectors, and XPath expressions/variable names (a NUL there raises).
+  selectors, and XPath expressions/variable names. A NUL in a name given to a
+  factory or setter (element, attribute, doctype and PI target names) raises
+  `ArgumentError`, as any other refused name does; anywhere else it raises
+  `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,

data/README.md

@@ -23,11 +23,13 @@ XPath 1.0 evaluation in its own native engine, with no libxml2 dependency.
 * Native XML 1.0 parser
   * A strict, non-validating, fail-closed parser with its own node arena (not
     Lexbor's HTML DOM), queried through the same native XPath engine, with
-    in-place tree edits (attributes, content, rename, remove).
+    in-place tree edits (attributes, content, remove).
   * Conformance is held by the W3C XML Conformance Test Suite, an XPath
     differential, and property-based testing vs Nokogiri (see below).
 * Bounded, fail-closed execution
   * XPath evaluation is bounded by per-evaluation limits on work, memory, and recursion.
+  * HTML parsing bounds the tree depth (`max_tree_depth:`, default 400) and the
+    `<option>`s per `<select>` (10,000).
   * Ownership and borrowing are kept explicit across layers, with owned/borrowed
     string types and verified text at engine boundaries.
   * Programmatic invalid input, limit violations, allocation failures, and unsupported constructs
@@ -65,6 +67,10 @@ link.parent.name                        # => "div"
 # Source location (reconstructed from the tokenizer, no Lexbor patches)
 doc.at_css("p").line                    # => 3
 
+# Nesting deeper than 400 elements raises Makiri::Error (Nokogiri's default);
+# max_tree_depth: raises the limit, and a negative value disables it
+Makiri::HTML(deep_html, max_tree_depth: 2000)
+
 # Serialization
 doc.at_css("#main").to_html             # => "<div id=\"main\" ...>...</div>"
 doc.at_css("#main").inner_html          # => "\n    <p class=\"lead\">Hello</p>\n..."
@@ -132,11 +138,10 @@ e   = doc.at_xpath("//entry")
 e["id"]   = "9"            # add or replace an attribute (value escaped on output)
 e["dc:k"] = "v"           # a prefixed name resolves against the in-scope xmlns
 e.content = "Bye"         # replace an element's children with text
-e.name    = "post"        # rename in place (identity + namespace re-resolved)
 e.delete("id")            # remove an attribute
 doc.at_xpath("//draft").remove
 
-doc.root.to_xml           # => "<feed xmlns:dc=\"urn:dc\"><post dc:k=\"v\">Bye</post></feed>"
+doc.root.to_xml           # => "<feed xmlns:dc=\"urn:dc\"><entry dc:k=\"v\">Bye</entry></feed>"
 ```
 
 XML subtrees can be built using `Document#create_element` and other node factory methods,