makiri 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: baaa765e2bd6208137962299994628a55a36ab68e29f9de9921e686679c69bf2
-  data.tar.gz: cd74ab123b1f8384d7aa14c448f1f12ee78371335061b60728c06424ccc5973b
+  metadata.gz: 383a2feea9ae25aca8e66985862eb3dfbbb64682771fc4578d9f0f6c11100d43
+  data.tar.gz: 774f2089e9b581b757cf0e142e937f892a87ccd71bb7c60f74666d9007bcac5c
 SHA512:
-  metadata.gz: 9ce8aa721e0e6848e2f7015f924f510599064f309c590181abef990e9b81121a1675aade8917515fdc35577bb65bb5edcf0d72ce4582df686eb0156d461d5e7b
-  data.tar.gz: 692a2a400e1be9ecc12fcd67cf317f5d7e51eef38c2846f25ab3bc23dd6626acdf02d860309e4444bf1b2b646461e8a32934804ebc8d1cc3f9a8593d729a79d8
+  metadata.gz: 575cdf673cf1c0f2f76bc641c978a5c946e99a19ebc9bd92d761aa23ac9e7d9a72d980120c22b7bc344a95d0236bcfff6887fc09e28836f64739ca87a18c7e8d
+  data.tar.gz: 8b5f74af6c317ce0928c2b700d4061828621c4115685b80c3b49c47bf65f521f46431e4cf22ce064eadf0c30dc2f68611f84b3e4e4ead2b162ef5369c5544b7a

data/.github/workflows/ci.yml

@@ -5,6 +5,13 @@ on:
     branches: [main, master]
   pull_request:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   test:
     name: Ruby ${{ matrix.ruby }} on ${{ matrix.os }}

data/.github/workflows/conformance.yml

@@ -15,6 +15,13 @@ on:
     - cron: "37 5 * * *" # nightly, offset from the other workflows
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # PR + push: HTML5 parsing conformance, plus the XPath and CSS differentials
   # over the curated corpus and a moderate batch of generated XPath expressions.

data/.github/workflows/css-match.yml

@@ -37,6 +37,13 @@ on:
     - cron: "41 4 * * *"
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 env:
   # Short on a push or PR, long on the nightly schedule.
   LONG: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
@@ -139,8 +146,12 @@ jobs:
       # also starts from the other's corpus (read-only: new units go to the
       # first directory). The cache prefix is libfuzzer.yml's, so the corpus
       # accumulated there carries over.
+      # Restored here, saved after the minimization below - and not on a pull
+      # request: a cache a PR saves is scoped to that PR's ref, so main and the
+      # nightly never read it, and minimizing it (~5 min) only bought a cache
+      # nobody restores.
       - name: Restore the corpus
-        uses: actions/cache@v6
+        uses: actions/cache/restore@v6
         with:
           path: ext/makiri/rust/fuzz/corpus/${{ matrix.target }}
           key: cargo-fuzz-corpus-${{ matrix.target }}-${{ github.run_id }}
@@ -171,6 +182,32 @@ jobs:
             -dict=css.dict \
             -print_final_stats=1
 
+      # The corpus is saved after every main/nightly run, so without this it
+      # only grows: every nightly hour adds units and nothing ever drops one.
+      # It reached ~58k files (with the sibling, ~107k units replayed before
+      # the first mutation) of which libFuzzer kept ~2.8k, and a short run
+      # spent its whole 180 s replaying - 0 new units, no fuzzing at all.
+      # Minimizing before the save keeps only what adds coverage. The first
+      # run after a long gap pays one replay of the backlog; later ones a
+      # few thousand units.
+      - name: Minimize the corpus before it is cached
+        if: github.event_name != 'pull_request'
+        working-directory: ext/makiri/rust/fuzz
+        run: |
+          before=$(ls corpus/${{ matrix.target }} | wc -l)
+          cargo fuzz cmin ${{ matrix.target }} corpus/${{ matrix.target }} -- \
+            -max_len=4096 \
+            -timeout=30
+          after=$(ls corpus/${{ matrix.target }} | wc -l)
+          echo "corpus/${{ matrix.target }}: $before -> $after files"
+
+      - name: Save the corpus
+        if: github.event_name != 'pull_request'
+        uses: actions/cache/save@v6
+        with:
+          path: ext/makiri/rust/fuzz/corpus/${{ matrix.target }}
+          key: cargo-fuzz-corpus-${{ matrix.target }}-${{ github.run_id }}
+
       - name: Upload reproducers
         if: failure()
         uses: actions/upload-artifact@v4

data/.github/workflows/security.yml

@@ -8,6 +8,13 @@ on:
     - cron: "17 19 * * *"
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # A "C safety lint" job stood here (`rake security:clint`, over
   # script/check_c_safety.rb). It enforced rules about C that no longer exists -

data/.github/workflows/valgrind.yml

@@ -23,6 +23,13 @@ on:
     - cron: "0 2 * * *"
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # Valgrind memcheck on the full spec suite.  Complements ASan by catching
   # layout-independent errors ASan misses: use of uninitialised values, and
@@ -111,8 +118,8 @@ jobs:
   # (parse/drop cycles) scale their iteration count down under stress
   # (`gc_churn_iters` / `GC_COMPACT_ITERS`) because each stressed iteration is
   # orders of magnitude heavier; `GC_COMPACT_ITERS` below tunes the total runtime
-  # (~6-9 min on CI at 200).  An earlier version forced GC.stress onto the
-  # *entire* suite (~800 examples): it ran 1h40m+ and never finished, while
+  # (~14.5 min on CI at 200 in one job, hence the three shards below).  An
+  # earlier version forced GC.stress onto the *entire* suite (~800 examples): it ran 1h40m+ and never finished, while
   # testing borrowed-pointer discipline on hundreds of examples that have none.
   # The rest of the suite still runs in ci.yml.
   #
@@ -123,7 +130,7 @@ jobs:
     # Pull requests, nightly and on demand - not on push (the valgrind job is the
     # post-merge gate). See the note under `on:` for why pull requests.
     if: github.event_name != 'push'
-    name: GC.auto_compact + GC.stress (Ruby ${{ matrix.ruby }})
+    name: GC.auto_compact + GC.stress (Ruby ${{ matrix.ruby }}, ${{ matrix.shard.name }})
     runs-on: ubuntu-latest
     timeout-minutes: 30
     env:
@@ -137,6 +144,17 @@ jobs:
       fail-fast: false
       matrix:
         ruby: ["3.4"]
+        # Split by spec file into three ~equal parts (measured per file: the
+        # handler spec alone is a third, attribute + source_location another).
+        # The last shard is everything ELSE, so a newly tagged file lands
+        # there rather than in no shard; rebalance if it grows past the others.
+        shard:
+          - name: xpath_handler
+            args: spec/xpath_handler_spec.rb
+          - name: attribute
+            args: spec/attribute_spec.rb spec/source_location_spec.rb
+          - name: rest
+            args: --exclude-pattern "spec/{xpath_handler,attribute,source_location}_spec.rb" spec
 
     steps:
       - name: Checkout (with vendored Lexbor submodule)
@@ -166,4 +184,4 @@ jobs:
       # auto_compact globally and wrap each example in GC.stress; --tag gc_compact
       # limits the run to the borrowed-pointer examples.
       - name: Run GC-sensitive examples under GC.auto_compact + GC.stress
-        run: bundle exec rspec --tag gc_compact spec
+        run: bundle exec rspec --tag gc_compact ${{ matrix.shard.args }}

data/.github/workflows/verify.yml

@@ -1,11 +1,37 @@
 name: Verify
 
 on:
+  # Ten minutes of proofs, over the Ruby-free engine only - so they run when
+  # that engine (or how it is built) changes, not on every push.
   push:
     branches: [main, master]
+    paths: &kani-paths
+      # The proofs build `--no-default-features`, so the Ruby/Lexbor layers
+      # below are compiled out of them; a change confined to those cannot
+      # change a proof's outcome. Everything else under src/ stays in, since
+      # the harnesses reach the engine's shared modules (limits, text, ...).
+      - "ext/makiri/rust/src/**"
+      - "!ext/makiri/rust/src/bridge/**"
+      - "!ext/makiri/rust/src/glue/**"
+      - "!ext/makiri/rust/src/lexbor/**"
+      - "!ext/makiri/rust/src/css/**"
+      - "!ext/makiri/rust/src/init.rs"
+      - "ext/makiri/rust/build.rs"
+      - "ext/makiri/rust/Cargo.toml"
+      - "ext/makiri/rust/Cargo.lock"
+      - "Rakefile"
+      - ".github/workflows/verify.yml"
   pull_request:
+    paths: *kani-paths
   workflow_dispatch:
 
+# A new push to a pull request supersedes the run on its previous head. The
+# event is in the group so a push to main never queues behind (or replaces) a
+# nightly run of the same workflow.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   # A CBMC job stood here and proved ext/makiri/{core,xml,xpath}/*.c. Those
   # files are gone, and `rake verify` with them: every one of its fifteen

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [0.15.0] - 2026-10-09
+
+### Added
+
+* `Makiri::HTML::Document#create_loose_dom_element(qualified_name, prefix,
+  local_name, namespace_uri)`, like the XML Document's: the local name is
+  taken as given (`"Foo:Bar"` keeps its colon and case). Names the DOM
+  refuses raise `ArgumentError`.
+* `Makiri::XML::Document#quirks_mode?` (always `false`) and `#compat_mode`
+  (always `"CSS1Compat"`), as on the HTML Document.
+
+### Changed
+
+* `:lexbor-contains()` is no longer supported. `#css` / `#at_css` /
+  `#matches?` raise `Makiri::CSS::SyntaxError` for it (HTML and XML), and
+  `parse_stylesheet` reports its rule as `:bad_style`. Use XPath `contains()`
+  instead.
+* HTML `#css` / `#at_css` / `#matches?` raise `Makiri::Error` ("could not be
+  run") for `:current(S)` instead of matching nothing.
+
+### Fixed
+
+* `parse_stylesheet` keeps escapes in a selector's `:text`: `.md\:block` came
+  back as `.md:block`. `:current(S)` keeps its argument, and a rule
+  with `[|a]` is no longer reported as `:bad_style`.
+* `parse_stylesheet` trims only CSS whitespace and never an escaped one:
+  `screen\ ` came back as `screen\`. A `:bad_style`'s `selector_text` no
+  longer keeps the whitespace before its `{`.
+* HTML `:has()` with a descendant combinator is no longer slow on deep
+  documents: `:has(* * x)` exceeded the work budget at 200 levels.
+
 ## [0.14.0] - 2026-10-04
 
 ### Added
@@ -964,14 +995,3 @@ Tooling
   benchmark harness (`rake bench`); conformance harnesses (html5lib-tests, WPT
   domxpath, CSS differential vs `Nokogiri::HTML5`). GitHub Actions CI across
   Ruby 3.2–4.0 × Ubuntu/macOS plus a sanitizer job.
-
-[0.9.0]: https://github.com/takahashim/makiri/compare/v0.8.0...v0.9.0
-[0.8.0]: https://github.com/takahashim/makiri/compare/v0.7.0...v0.8.0
-[0.7.0]: https://github.com/takahashim/makiri/compare/v0.6.0...v0.7.0
-[0.6.0]: https://github.com/takahashim/makiri/compare/v0.5.1...v0.6.0
-[0.5.1]: https://github.com/takahashim/makiri/compare/v0.5.0...v0.5.1
-[0.5.0]: https://github.com/takahashim/makiri/compare/v0.4.0...v0.5.0
-[0.4.0]: https://github.com/takahashim/makiri/compare/v0.3.0...v0.4.0
-[0.3.0]: https://github.com/takahashim/makiri/compare/v0.2.0...v0.3.0
-[0.2.0]: https://github.com/takahashim/makiri/compare/v0.1.0...v0.2.0
-[0.1.0]: https://github.com/takahashim/makiri/releases/tag/v0.1.0

data/NOKOGIRI_DIFFERENCES.md

@@ -245,18 +245,12 @@ 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")` - 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).
+  * There is no text-containment pseudo-class. Nokogiri's `:contains()` is
+    not supported, and neither is Lexbor's `:lexbor-contains()`: it raises
+    `Makiri::CSS::SyntaxError` on HTML and XML alike, like any unknown
+    pseudo-class (Lexbor's parser for it had memory-safety bugs, so Makiri
+    never lets it run). Use XPath instead:
+    `xpath('//p[contains(., "text")]')`.
 * 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.

data/Rakefile

@@ -94,10 +94,12 @@ end
 # the report down to errors whose stack touches our extension, so we no longer
 # have to fetch ruby.supp from ruby/ruby (that path was removed upstream).
 #
-# We keep this job's historical contract: catch *use of uninitialised values*
-# and *invalid reads/writes* (incl. intra-arena overflows) - NOT leaks (leak
-# detection stays with `rake leaks`). So we override ruby_memcheck's defaults,
-# which disable undef-value errors and turn on full leak-check.
+# The job catches *use of uninitialised values* and *invalid reads/writes*
+# (incl. intra-arena overflows), and also any "definitely lost" block whose
+# stack touches our extension - the one leak gate with no frequency threshold
+# (`rake leaks`, macOS, flags only stacks repeated >= 30x). It once meant to
+# leave leaks out and could not: see `--leak-check` below. ruby_memcheck's
+# defaults disable undef-value errors, so we override them.
 #
 # `filter_all_errors: true` is essential: by default ruby_memcheck only applies
 # its "stack must touch the makiri binary" filter to *leak*-kind errors
@@ -146,7 +148,19 @@ begin
       # post-merge push gate turns it off (VALGRIND_TRACK_ORIGINS=no) to run in
       # ~half the time, while the nightly / manual runs keep it on for the backtrace.
       "--track-origins=#{ENV.fetch('VALGRIND_TRACK_ORIGINS', 'yes')}",
-      "--leak-check=no",        # leaks are `rake leaks`' job, not this one
+      # Leaks ARE checked here, whatever this says: ruby_memcheck always runs
+      # valgrind with --xml=yes, and in XML mode memcheck writes its leak
+      # records even under --leak-check=no (a "definitely lost" in a spec's
+      # child process failed run 37864917248 that way). So say what happens,
+      # and keep ruby_memcheck's own leak kinds - these options REPLACE its
+      # defaults rather than adding to them, and without the line below
+      # valgrind's default (definite,possible) fails the job on a "possibly
+      # lost" too. A spec that runs Ruby in a child must leave
+      # RUBY_FREE_AT_EXIT set there (it is inherited): without it the child's
+      # live strings at exit are reported as definitely lost through our
+      # frames (PR #55).
+      "--leak-check=full",
+      "--show-leak-kinds=definite",
     ],
   )
 

data/ext/makiri/rust/build.rs

@@ -292,7 +292,6 @@ fn main() {
         .allowlist_function("lxb_css_stylesheet_destroy")
         .allowlist_function("lxb_css_property_serialize")
         .allowlist_function("lxb_css_property_serialize_name")
-        .allowlist_function("lxb_css_selector_serialize_chain")
         // One node's own markup, plain and pretty: Makiri drives the walk
         // itself (`adapter::html::serialize`), so a <template> writes its
         // contents and not its own children, as the HTML Standard says, and

data/ext/makiri/rust/fuzz/fuzz_targets/html_css_diff.rs

@@ -22,7 +22,9 @@
 //! (`:checked` / `:disabled` / `:enabled`, and `:read-only` / `:read-write`,
 //! which ask the same `is_disabled`), `of S`, `An+B` past 2^53, a
 //! compound that starts with a list pseudo-class where it has several
-//! candidates (Lexbor tries only the first - found by this target), and,
+//! candidates (Lexbor tries only the first - found by this target), a
+//! compound holding one after `+` in a `:has()` argument (Lexbor stops after
+//! the first pair it fails), and,
 //! on a document with foreign elements, the HTML Standard's case-sensitivity
 //! and qualified-name rules for type and attribute selectors. A selector either engine refuses is not compared either.
 //!
@@ -173,6 +175,8 @@ impl Shape {
                 // Whether the compound being walked starts with a list
                 // pseudo-class (`:is()`, `:where()`, `:not()`, `:has()`).
                 let mut leads_with_list = false;
+                // How the compound being walked attaches to the one before.
+                let mut attached = Combinator::Descendant;
                 let mut first = true;
                 let mut sel: Option<Selector<'_>> = list.first();
                 while let Some(s) = sel {
@@ -182,6 +186,7 @@ impl Shape {
                     }
                     let combinator = s.combinator();
                     if first || combinator != Combinator::Close {
+                        attached = combinator;
                         // The compound before this one is searched over every
                         // ancestor / preceding sibling when this one attaches
                         // by a descendant or `~` combinator.
@@ -199,6 +204,18 @@ impl Shape {
                             shape.departs = true;
                         }
                     }
+                    // In a `:has()` argument, a compound attached by `+` that
+                    // holds `:is()` / `:not()` / `:where()` / `:has()`: Lexbor
+                    // stops after the first pair that fails it.
+                    if in_has
+                        && attached == Combinator::NextSibling
+                        && matches!(
+                            s.simple(),
+                            Simple::PseudoClassFunction(FunctionArg::Selectors { .. })
+                        )
+                    {
+                        shape.departs = true;
+                    }
                     first = false;
                     shape.simple(s, in_has, &mut work);
                     sel = s.next();
@@ -211,7 +228,7 @@ impl Shape {
     fn simple<'p>(&mut self, s: Selector<'p>, in_has: bool, work: &mut Vec<(Lists<'p>, bool)>) {
         match s.combinator() {
             Combinator::Descendant | Combinator::SubsequentSibling => self.backtracks += 1,
-            Combinator::Other => self.departs = true,
+            Combinator::Column | Combinator::Other => self.departs = true,
             _ => {}
         }
         let upper = s.name().iter().any(u8::is_ascii_uppercase);
@@ -245,7 +262,8 @@ impl Shape {
                     }
                     work.push((lists, in_has || has));
                 }
-                FunctionArg::Contains(_) => self.departs = true,
+                // Both raised by the port and matched by Lexbor.
+                FunctionArg::Contains | FunctionArg::Current(_) => self.departs = true,
                 FunctionArg::Other => {}
             },
             _ => {}

data/ext/makiri/rust/src/css/lower.rs

@@ -31,9 +31,7 @@ use crate::xpath::ast::{Axis, Expr, NodeTest, Op, Step};
 
 /// The internal of-type position functions, whose names carry a leading \x01 so
 /// no user expression can name them.
-use crate::xpath::funcs::{
-    FN_CHILD_POS, FN_CHILD_POS_LAST, FN_IS_TEXT, FN_OF_TYPE_POS, FN_OF_TYPE_POS_LAST,
-};
+use crate::xpath::funcs::{FN_CHILD_POS, FN_CHILD_POS_LAST, FN_OF_TYPE_POS, FN_OF_TYPE_POS_LAST};
 
 /* ------------------------------------------------------------------ *
  * simple selectors                                                   *
@@ -353,8 +351,7 @@ fn lower_pseudo_simple(b: &Build, pc: PseudoClass) -> Built {
          *
          * `NodeTest::Text` matches a CDATA section as well, and that is wanted
          * HERE: Lexbor's `:empty` ignores comments alone, so any other child -
-         * a CDATA section included - makes the element non-empty. The
-         * CDATA-excluding rule is `:lexbor-contains`'s, not this one. */
+         * a CDATA section included - makes the element non-empty. */
         PseudoClass::Empty => build::fold(
             b,
             Op::And,
@@ -398,29 +395,8 @@ pub(crate) fn selector_list_selftest(b: &Build, lists: Lists<'_>) -> Built {
     )
 }
 
-/// `child::text()[is-text()][pred]` - the element's direct child TEXT nodes
-/// satisfying `pred`, which is consumed.
-///
-/// In predicate position a non-empty node-set is truthy, so this reads "some
-/// direct child text node matches" - exactly how Lexbor's `:lexbor-contains`
-/// matcher scans, which looks at immediate child TEXT nodes only and not at the
-/// deep string value. Matching that is what keeps the XML path's answer equal to
-/// the HTML one.
-///
-/// The `is-text()` filter drops CDATA sections, which XPath's `text()` matches
-/// but Lexbor's matcher does not: it scans `LXB_DOM_NODE_TYPE_TEXT` alone, so an
-/// XML `:lexbor-contains` must not see a CDATA section either.
-fn child_text_pred(b: &Build, pred: Built) -> Built {
-    let pred = pred?;
-    let mut step = Step::new(Axis::Child, NodeTest::Text);
-    let is_text = build::call0(b, FN_IS_TEXT);
-    build::push(b, &mut step.predicates, is_text?)?;
-    build::push(b, &mut step.predicates, pred)?;
-    build::single_step_path(b, step)
-}
-
 /// The functional pseudo-classes: `:nth-*(an+b)`, `:not()`, `:is()`/`:where()`,
-/// `:has()`, `:lexbor-contains()`.
+/// `:has()`.
 fn lower_pseudo_func(b: &Build, arg: FunctionArg<'_>) -> Built {
     match arg {
         FunctionArg::Nth {
@@ -460,43 +436,7 @@ fn lower_pseudo_func(b: &Build, arg: FunctionArg<'_>) -> Built {
             ),
         },
 
-        FunctionArg::Contains(c) => {
-            let Some(c) = c else {
-                return Err(b.fail(ErrorKind::Syntax, "malformed :lexbor-contains()"));
-            };
-            let needle = c.needle;
-
-            if !c.insensitive {
-                let dot = build::step_path(b, Axis::SelfAxis, NodeTest::Node); /* "." */
-                return child_text_pred(
-                    b,
-                    build::call2(b, b"contains", || dot, || build::literal(b, needle)),
-                );
-            }
-
-            /* ASCII case-insensitive: fold both sides with translate(). The
-             * flag is ASCII-only, which is what Lexbor's matcher does. */
-            const UPPER: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-            const LOWER: &[u8] = b"abcdefghijklmnopqrstuvwxyz";
-            let Some(mut low) = crate::falloc::try_vec_with_capacity::<u8>(needle.len()) else {
-                return Err(b.oom());
-            };
-            low.extend(needle.iter().map(|&ch| ch.to_ascii_lowercase()));
-
-            let folded = build::call3(
-                b,
-                b"translate",
-                || build::step_path(b, Axis::SelfAxis, NodeTest::Node),
-                || build::literal(b, UPPER),
-                || build::literal(b, LOWER),
-            );
-            child_text_pred(
-                b,
-                build::call2(b, b"contains", || folded, || build::literal(b, &low)),
-            )
-        }
-
-        FunctionArg::Other => {
+        FunctionArg::Contains | FunctionArg::Current(_) | FunctionArg::Other => {
             Err(b.fail(ErrorKind::Syntax, "unsupported functional CSS pseudo-class"))
         }
     }
@@ -563,7 +503,7 @@ fn combinator_axis(b: &Build, c: Combinator, reverse: bool) -> Result<Axis, Repo
         (Combinator::Child, true) => Axis::Parent,
         (Combinator::SubsequentSibling, false) => Axis::FollowingSibling,
         (Combinator::SubsequentSibling, true) => Axis::PrecedingSibling,
-        (Combinator::NextSibling | Combinator::Other, _) => {
+        (Combinator::NextSibling | Combinator::Column | Combinator::Other, _) => {
             return Err(b.fail(ErrorKind::Syntax, "unsupported CSS combinator"));
         }
     })

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

@@ -53,7 +53,7 @@ fn query_error(err: QueryFailure) -> Error {
 /// one node each, never a `Vec`) and so only ever fail the other way.
 ///
 /// The message for `Unsupported` (the column combinator `||`, or
-/// `:lexbor-contains()`) matches the OLD engine's own wording for the same
+/// `:current()`) matches the OLD engine's own wording for the same
 /// case (`SelectError::Traversal`'s "CSS selector could not be run") on
 /// purpose: it is the same fact - this engine could not run the selector
 /// either - not a new one.

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

@@ -178,6 +178,10 @@ fn init_mutate() -> Result<(), Error> {
 
     doc.define_method("create_element", method!(mutate::create_element, 1))?;
     doc.define_method("create_element_ns", method!(mutate::create_element_ns, 2))?;
+    doc.define_method(
+        "create_loose_dom_element",
+        method!(mutate::create_loose_dom_element, 4),
+    )?;
     doc.define_method(
         "create_document_type",
         method!(mutate::create_document_type, -1),

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

@@ -340,6 +340,50 @@ pub fn create_element_ns(
     })
 }
 
+/// `create_loose_dom_element(qualified_name, prefix, local_name, namespace_uri)`
+/// -> Element.
+///
+/// The XML Document's factory of the same name: the name is not parsed, the
+/// caller gives its split, so a local name keeps its colons (`"foo:"`) and its
+/// case. Neither [`create_element`] (lower-cased, in the HTML namespace) nor
+/// [`create_element_ns`] (split at the first colon) can make that. The names
+/// are held to the DOM's rule (`ArgumentError`); the namespace is not checked
+/// against the prefix, as on XML.
+pub fn create_loose_dom_element(
+    ruby: &Ruby,
+    rb_self: Value,
+    rb_qname: Value,
+    rb_prefix: Value,
+    rb_local: Value,
+    rb_ns: Value,
+) -> Result<Value, Error> {
+    crate::bridge::ruby::entry(|| {
+        let doc = owning_doc(&rb_self)?;
+        let qv = ruby_verified_name(rb_qname, "qualified name")?;
+        let lv = ruby_verified_name(rb_local, "local name")?;
+        let pv = if rb_prefix.is_nil() {
+            None
+        } else {
+            Some(ruby_verified_name(rb_prefix, "prefix")?)
+        };
+        let nv = namespace_arg(rb_ns, "namespace URI")?;
+        let prefix = pv.as_ref().map(|p| p.as_bytes());
+        dom_name::split_loose_dom_name(qv.as_bytes(), prefix, lv.as_bytes())
+            .map_err(|e| Error::new(ruby.exception_arg_error(), e.message()))?;
+        let ns = nv.as_ref().map_or(&b""[..], |n| n.as_bytes());
+        created(
+            crate::bridge::html::create_element_ns(
+                doc,
+                lv.as_bytes(),
+                ns,
+                prefix.unwrap_or_default(),
+            ),
+            rb_self,
+            "element",
+        )
+    })
+}
+
 /// `Document#create_text_node(content)` -> Text.
 pub fn create_text_node(_ruby: &Ruby, rb_self: Value, rb_text: Value) -> Result<Value, Error> {
     crate::bridge::ruby::entry(|| {

data/ext/makiri/rust/src/lexbor/adapter/html/mod.rs

@@ -939,6 +939,13 @@ impl<'doc> HtmlNode<'doc> {
         if let Some(c) = self.first_child() {
             return Some(c);
         }
+        self.preorder_next_past(root)
+    }
+
+    /// The node after this one's whole subtree in a pre-order walk of
+    /// `root`'s subtree: [`preorder_next`](Self::preorder_next) without going
+    /// down into this node's children. None past the last.
+    pub fn preorder_next_past(self, root: Self) -> Option<Self> {
         let mut n = self;
         loop {
             if n == root {