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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5a56937c4116a0f55e5e0d8885c311b1f1b1ed2176808f161a67625fc21b71f
-  data.tar.gz: 9ea9e72c0b8b813d6a6754d2bf5198f3478ebc9f47df570ac53eb3c79b864ce6
+  metadata.gz: 5b203c0ffb03e49f10b8e30afd6b070d36fd054867b7b3fd0e1376778b9e4b94
+  data.tar.gz: 3a26a99a690546bcc5367fab22645b8c47bd65dec58df75df5a7a93950de3386
 SHA512:
-  metadata.gz: 9fb9f54c36318f05e2d8970c1342d1ade6b36d9fc85045df4296a352e2d759a29b11428443b61232be9d7fcf88b20d7bd2e12503927584444f8cd5373701818c
-  data.tar.gz: 0cadc6458fc773c334d892ff764e6bc41c837808693b86183d0c819d9bc496ba7ffc78bd7a50adce5de77a5a687d63bfb6f8aa12c1ce09b6b791a060e94ded03
+  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,34 +1,311 @@
 # 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
+
+* `XPathContext.new` now registers namespace bindings passed via
+  `prefix: uri` (previously ignored).
+* `#css`, `#at_css`, and `#matches?` accept `(selector, namespaces = nil)`
+  on HTML documents for consistency with XML.
+* Standardized error message format for rejected CSS selectors across XML
+  and HTML: `"<reason>: <selector>"`.
+* Unified argument handling for `#xpath` and `#at_xpath` between HTML and XML.
+  * HTML supports per-query namespace bindings and keyword prefixes
+    (e.g., `s: uri`).
+  * XML supports custom-function handlers.
+* XML nodes now support HTML-style node readers and aliases
+  (`#first_element_child`, `#next_element`, `#tag_name`, `#attr`,
+  `#node_name`, etc.).
+
+### Changed
+
+* Updated vendored Lexbor to `v3.0.0-66`.
+* Parsed `<?php ... ?>` tags in HTML input as `ProcessingInstruction` nodes
+  instead of comments, adhering to the HTML Standard.
+* Vendored Lexbor updated from `v3.0.0-25` to `v3.0.0-66` (`05b5d37`), for an
+  out-of-bounds write in `lxb_dom_character_data_replace` reachable through
+  `#content=`, UTF-16 surrogate rejection, exact `meta` charset matching and
+  buffer-capacity fixes. (v3.0.1 is not usable: it lacks the two CSS-selector
+  fixes Makiri upstreamed.)
+* `<?php ... ?>` in HTML input is now a `ProcessingInstruction` node rather
+  than a Comment, serializes as `<?target data?>`, and `<?` at end of input is
+  ignored - the HTML Standard's processing-instruction tokens, which Lexbor now
+  implements. `Nokogiri::HTML5` still answers with a comment.
+* `Makiri::XML#matches?` tests the node locally via tree walking instead of
+  performing a full-document search.
+* `Makiri::XML::Namespace` is now an immutable `Data` object defined in Ruby.
+* `XML::Node#value` returns its text content (or attribute value for
+  attributes), aligning with HTML node behavior.
+* XPath over HTML now handles element/attribute names case-insensitively
+  and properly handles `xmlns` attributes according to browser specs.
+* `Makiri::XML` checks the internal DTD subset for well-formedness and
+  raises `Makiri::XML::SyntaxError` if unsupported constructs (e.g., attribute
+  defaults, entity references) would alter the document tree.
+* Documents with `version="1.x"` are now accepted and parsed as XML 1.0.
+* Processing instruction (PI) targets containing colons (e.g., `<?a:b?>`)
+  are now rejected per Namespaces in XML specs.
+
+### Fixed
+
+* `Makiri::XML::DocumentType#prefix` now returns `nil` instead of
+  the PUBLIC ID.
+* `Makiri::XML#last_element_child` now correctly returns an `Element`
+  instead of arbitrary child nodes (like comments or text).
+* `Element#local_name` and `local-name()` in XPath preserve camelCase
+  for SVG/MathML elements (e.g., `foreignObject`).
+* `inner_html=` and `outer_html=` are now atomic operations to prevent
+  leaving the DOM in a corrupted state on failure.
+* XPath over HTML assigns empty/correct namespaces to attributes instead of
+  inheriting from their parent element.
+* Corrected `lang()` evaluation to check the nearest language attribute
+  hierarchically.
+* Fixed `namespace_matching: :lax` on XML to be strict, aligning with
+  `Nokogiri::XML` / `libxml2` behavior.
+* Moving an HTML node to another document now correctly removes it
+  from the source document's indexes.
+* Prevented XPath custom handlers from creating new nodes on the document
+  being evaluated.
+* Fixed CSS universal selectors (`p|*`, `|*`) on XML to respect namespace
+  boundaries.
+* CSS column combinator (`a || b`) on XML now raises
+  `Makiri::CSS::SyntaxError` instead of being misparsed as descendant selector.
+
 ## [0.10.0.rc1] - 2026-09-19
 
 ### Changed
 
-* **The native extension is rewritten in Rust.** The C glue, the XPath engine,
+* The native extension is rewritten in Rust. The C glue, the XPath engine,
   the XML reader and the CSS lowering are now one Rust crate; the only C left is
   the vendored Lexbor, still unpatched. The Ruby API is unchanged, and answers
   were checked against the C build's recorded output as well as the existing
   differential suites against Nokogiri.
 
-  * **Installing from source needs a Rust toolchain.** `cargo` (stable) and
+  * Installing from source needs a Rust toolchain. `cargo` (stable) and
     libclang are required alongside CMake, and `rb_sys` becomes a runtime
     dependency of the source gem, because its `extconf.rb` runs at install time.
     The precompiled platform gems need none of this and do not depend on
     `rb_sys`.
-  * **Faster.** Makiri now beats both Nokogiri and nokolexbor on every
+  * Faster. Makiri now beats both Nokogiri and nokolexbor on every
     `rake bench` row, parse included - previously ~1.25x slower than nokolexbor.
     Source locations are stamped on the first `#line` or mutation rather than
     during every parse, and the vendored Lexbor is built with link-time
     optimization where the linker supports it (macOS; Linux with clang,
     llvm-ar and lld; not Windows).
-  * **An internal failure is an exception, not a crash.** It used to end the
+  * An internal failure is an exception, not a crash. It used to end the
     host process with SIGABRT. Now it unwinds on the thread that ran the call:
     `ensure` blocks run and the process keeps working. On entry points that
     handle input (parse, XPath, CSS, serialization, text) it is the new
-    **`Makiri::InternalError`**, which descends from `Exception`, not
+    `Makiri::InternalError`, which descends from `Exception`, not
     `StandardError`, so a bare `rescue => e` does not swallow it; elsewhere it
     is Ruby's `fatal`.
-  * **An XPath handler may not modify the document being evaluated.** Every
+  * An XPath handler may not modify the document being evaluated. Every
     mutator on that document raises `Makiri::Error` while an evaluation with a
     handler runs, because the evaluator holds names and values from it for the
     whole walk.
@@ -46,14 +323,14 @@
 
 * `Node#attribute_by_qualified_name(name)` and
   `Node#attribute_value_by_qualified_name(name)`: the attribute whose
-  **qualified** name is exactly `name` — its node, and its value — or nil.
+  qualified name is exactly `name` — its node, and its value — or nil.
   `#[]` cannot answer this: it also finds a prefixed attribute by its local
   name (`svg_a["href"]` returns `xlink:href`), and it lower-cases what it looks
   up (`el["DATA-X"]` finds `data-x`). The new match is byte-exact.
 
 ### Changed
 
-* **`Makiri::XML` follows the DOM namespace model.** A node's namespace URI is
+* `Makiri::XML` follows the DOM namespace model. A node's namespace URI is
   decided once — by the parser, or by the context it is first inserted into —
   and does not change afterwards; the serializer emits whatever xmlns
   declarations the output needs:
@@ -71,24 +348,24 @@
   Nodes from the factories (`create_element` and friends) still take their
   namespace from the context they are first inserted into.
 
-* **Inserting a node from another document adopts it.** `add_child` / `before` /
+* Inserting a node from another document adopts it. `add_child` / `before` /
   `after` / `replace` bring the node over and remove it from the document it
   came from, instead of copying it (`Makiri::XML`) or raising (`Makiri::HTML`).
   A spliced fragment is left empty; a rejected insert leaves the source
   document untouched.
 
-  The node handed back is a **different object** than the one passed in, so use
+  The node handed back is a different object than the one passed in, so use
   the return value afterwards rather than the argument. `Document#import_node`
   is unchanged: it copies and leaves the source alone.
 
-* **XML serialization is capped at the nesting depth the parser accepts.**
+* XML serialization is capped at the nesting depth the parser accepts.
   `#to_xml` and `#canonicalize` raise `Makiri::Error` past it, rather than
   emitting XML that Makiri could not read back. A deeper tree is still fine to
   hold, walk and query.
 
 ### Fixed
 
-* XPath axes from an **attribute** context node on the XML backend now follow
+* XPath axes from an attribute context node on the XML backend now follow
   XPath 1.0 §2.2: `following-sibling` and `preceding-sibling` are empty, and
   `following` / `preceding` exclude attribute nodes. They used to return the
   element's later attributes.
@@ -294,7 +571,7 @@
 
 ### Added
 
-* **Native XML 1.0 reader + in-place editor** - `Makiri::XML::Document.parse(source)`
+* Native XML 1.0 reader + in-place editor - `Makiri::XML::Document.parse(source)`
   / `Makiri::XML(source)`. No libxml2: a strict, fail-closed parser builds its own
   node arena (case- and namespace-preserving), queried by the native XPath engine.
   * Strict & secure: fail-closed decode (bad UTF-8 / NUL -> `XML::SyntaxError`),
@@ -304,9 +581,9 @@
     encoding is a fatal error, not a silent mis-decode.
   * DoS-bounded by a single arena byte ceiling (default 256 MiB; raise per parse
     with `max_bytes:`).
-  * `<!DOCTYPE>` recognized but **not processed** (`#internal_subset` ->
-    `XML::DocumentType`); zero entity/DTD I/O, so **XXE and billion-laughs are
-    structurally impossible**. Kept off the tree, as in libxml2.
+  * `<!DOCTYPE>` recognized but not processed (`#internal_subset` ->
+    `XML::DocumentType`); zero entity/DTD I/O, so XXE and billion-laughs are
+    structurally impossible. Kept off the tree, as in libxml2.
   * Read API mirrors Nokogiri: `#xpath` / `#at_xpath` (`{prefix => uri}`),
     name/namespace readers, `#text`, `#[]`, traversal, and namespace introspection
     (`Makiri::XML::Namespace`); `XPathContext` works over XML nodes too.
@@ -334,7 +611,7 @@
 * `NodeSet#[]` accepts a `Range` or `start, length` (like `Array#[]`).
 * `Node` / `NodeSet` / `Document` `#dup` / `#clone` now return real independent
   copies (`#dup(0)` shallow; `#clone(freeze:)` honoured).
-* A **frozen node is genuinely immutable** - every mutator raises `FrozenError`.
+* A frozen node is genuinely immutable - every mutator raises `FrozenError`.
 
 ### Changed
 
@@ -346,7 +623,7 @@
   added `Node#cdata?`.
 * Text-index range table uses `uint32` bounds (24 -> 16 B/entry; ~27% less retained
   index, byte-identical text).
-* Parsing **honours the input String's encoding** - Shift_JIS / EUC-JP / ... are now
+* Parsing honours the input String's encoding - Shift_JIS / EUC-JP / ... are now
   transcoded to UTF-8 instead of mangled.
 * Parsing skips its UTF-8 validation scan when the String's coderange already proves
   it valid.
@@ -355,7 +632,7 @@
 
 ### Fixed
 
-* **Hardened the HTML/XML representation boundary.** HTML (Lexbor) and XML (arena)
+* Hardened the HTML/XML representation boundary. HTML (Lexbor) and XML (arena)
   nodes are now distinct TypedData types, so the wrong representation raises
   `TypeError` instead of corrupting memory:
   * `Node#==` / `XPathContext#node=` with an XML `Document` no longer aborts the
@@ -434,12 +711,12 @@
 ## [0.1.0] - 2026-06-02
 
 First public release. An HTML5 parser, a native XPath 1.0 query engine, and CSS
-selectors for Ruby - built on vendored [Lexbor](https://lexbor.com/) with **no
-libxml2 / libxslt dependency at any layer**.
+selectors for Ruby - built on vendored [Lexbor](https://lexbor.com/) with no
+libxml2 / libxslt dependency at any layer.
 
 ### Added
 
-**Parsing & DOM**
+Parsing & DOM
 
 * `Makiri::HTML` / `Makiri.parse` - HTML5 parsing via vendored, unpatched Lexbor,
   with browser-compatible UTF-8 decoding (invalid bytes → U+FFFD; parsing never
@@ -454,7 +731,7 @@ libxml2 / libxslt dependency at any layer**.
   quirks_mode,internal_subset,errors}` and `Makiri::DocumentType#{public_id,
   system_id,external_id}`.
 
-**XPath**
+XPath
 
 * Native XPath 1.0 query engine (no libxml2/libxslt): `Node#{xpath,at_xpath}`
   and `Makiri::XPathContext` (`evaluate`, namespace/variable binding, custom
@@ -462,7 +739,7 @@ libxml2 / libxslt dependency at any layer**.
   built-in functions with spec-faithful semantics (XML NCNames including
   non-ASCII, node-set vs node-set comparisons per §3.4, document order per §5.1,
   Unicode-aware `translate`/`substring`).
-* Namespace matching is **strict by default** (HTML5/WHATWG-faithful, like
+* Namespace matching is strict by default (HTML5/WHATWG-faithful, like
   browsers' `document.evaluate` and `Nokogiri::HTML5`); pass
   `namespace_matching: :lax` for the namespace-agnostic, `Nokogiri::HTML`-style
   match.
@@ -470,12 +747,12 @@ libxml2 / libxslt dependency at any layer**.
   (operation / recursion-depth / node-set / string-byte caps) that raise
   `Makiri::XPath::LimitExceeded` on overrun.
 
-**CSS**
+CSS
 
 * `Node#{css,at_css,matches?}` via Lexbor's selector engine (descendant-only,
   document order). Malformed selectors raise `Makiri::CSS::SyntaxError`.
 
-**Mutation & serialization**
+Mutation & serialization
 
 * DOM mutation: `add_child`/`<<`, `add_previous_sibling`/`before`,
   `add_next_sibling`/`after`, `remove`/`unlink`, `replace`; attribute `[]=` and
@@ -494,7 +771,7 @@ libxml2 / libxslt dependency at any layer**.
   `NodeSet#{|,+,&,-,css,xpath,search,at,last,remove}`, and `Element.new` /
   `Text.new`.
 
-**Safety & concurrency**
+Safety & concurrency
 
 * UTF-8 text-input contract: HTML and fragment parsing are lenient (invalid
   bytes → U+FFFD, never reject), while strings passed to the XPath / CSS /
@@ -505,7 +782,7 @@ libxml2 / libxslt dependency at any layer**.
   context across threads cannot corrupt memory. Fail-closed string caps and
   iterative (non-recursive) tree walks resist stack-exhaustion DoS.
 
-**Performance** (`rake bench`, vs Nokogiri/libxml2)
+Performance (`rake bench`, vs Nokogiri/libxml2)
 
 * Meets or beats Nokogiri on every benchmarked operation: parse ~3×, css ~12×,
   at_css ~1000×, serialize ~4×, `//tag` ~3.4×, `[@attr='v']` predicate ~1.5×,
@@ -513,7 +790,7 @@ libxml2 / libxslt dependency at any layer**.
   a document element index (for `//tag`), a direct-attribute predicate fast
   path, and a hashed per-evaluate string-value cache.
 
-**Tooling**
+Tooling
 
 * Vendored Lexbor as a git submodule (pinned v3.0.0, applied without patches).
   Build hardening flags; AddressSanitizer+UBSan build (`rake sanitize`);