makiri 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27ac120b94ab835caee9bbb50a1cee71b19e339dde2384496db9608e58b3269b
-  data.tar.gz: 27b8ea683abe8854e6c68269413d4858e0f2fedfdd04f04d8fa91130b9b05ac1
+  metadata.gz: ad4966a3bf44b4cbc01822bab034227c3c5a5c18347135bfc5cfbc13963a42eb
+  data.tar.gz: 4669d45c028deb66343788e8adb27c72819fb78c71a3f6efa14f8c5acc07efc4
 SHA512:
-  metadata.gz: 84754fb994af236692bdbc281cb0cba89a8cd6d7c75e2caa4e16ebe9b1efa6c4cbd270409be2957e461db4909bbabc32296ed44e185ccaa8985a0c285f25846c
-  data.tar.gz: c3fba2792720ad30d1bee90343e4ae7877bd9871195620ce667281fffeb36e994b3e715a5f456327aaa4e8de1e80e3c24c7e6a898739c660f4d1c8d5ffa51c60
+  metadata.gz: a076b9c0c2f8e790d6bf433912f8f27cf1c9439de66dbcd403a010736ee26e3716531c975969ea03274bb0fdac34e4c46ab25dbc6777eb50ec753e41a0c95e90
+  data.tar.gz: ad0d15f5fc4b6de3bf8850b21f69b0e66848c0dfe9f19b1304e9f0acde2754979506ca618a2af0449c9191052491fddc3b9ace9f226beed4b94349c48b4c09cc

data/.github/workflows/libfuzzer.yml

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

data/.github/workflows/verify.yml

@@ -0,0 +1,37 @@
+name: Verify
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  cbmc:
+    name: CBMC proofs
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout (with vendored Lexbor submodule)
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - name: Install CBMC
+        env:
+          CBMC_VERSION: "6.9.0"
+        run: |
+          curl -fsSLO "https://github.com/diffblue/cbmc/releases/download/cbmc-${CBMC_VERSION}/ubuntu-24.04-cbmc-${CBMC_VERSION}-Linux.deb"
+          sudo apt-get update
+          sudo apt-get install -y "./ubuntu-24.04-cbmc-${CBMC_VERSION}-Linux.deb"
+          cbmc --version
+
+      - name: Run verification suite
+        run: bundle exec rake verify

data/CHANGELOG.md

@@ -1,9 +1,23 @@
 # Changelog
 
-All notable changes to this project will be documented in this file.
+## [0.6.0] - 2026-07-05
 
-The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+### Changed
+
+* Text and comment node content (`create_text_node`, `create_comment`,
+  `content=`) and attribute values (`[]=`, `set_attribute_ns`) now accept an
+  embedded NUL (U+0000) and store it verbatim, matching the WHATWG DOM and
+  browsers, instead of raising. Names, tag names, namespaces, CSS selectors, and
+  XPath expressions stay NUL-strict, and invalid UTF-8 is still rejected. XML
+  documents (`Makiri::XML`) are unchanged and still reject NUL everywhere, since
+  XML 1.0 has no legal U+0000 character.
+
+## [0.5.1] - 2026-06-22
+
+### Changed
+
+* Faster CSS queries that reuse the same selector: compiled selectors are now
+  cached and reused across queries instead of being re-parsed each time.
 
 ## [0.5.0] - 2026-06-14
 
@@ -362,7 +376,8 @@ libxml2 / libxslt dependency at any layer**.
   domxpath, CSS differential vs `Nokogiri::HTML5`). GitHub Actions CI across
   Ruby 3.2–4.0 × Ubuntu/macOS plus a sanitizer job.
 
-[Unreleased]: https://github.com/takahashim/makiri/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/takahashim/makiri/compare/v0.5.1...HEAD
+[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

data/README.md

@@ -267,6 +267,22 @@ Detailed, test-backed notes live in `spec/conformance/README.md`.
 * Type selectors are ASCII case-insensitive (CSS-correct for HTML; `LI` matches `<li>`)
   * `Nokogiri::HTML5` is case-sensitive there.
 
+### Text input (mutation APIs)
+
+* Programmatic string arguments must be **valid UTF-8** (invalid bytes raise
+  `Makiri::Error`, never silently repaired - unlike HTML *parsing*, which decodes
+  leniently to U+FFFD).
+* An embedded **NUL (U+0000)** is **accepted in HTML data-family content** -
+  text/comment node content (`create_text_node`, `create_comment`, `content=`)
+  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).
+  * On re-parse, the HTML tokenizer replaces a U+0000 in text/attributes with
+    U+FFFD (WHATWG), so a serialized-then-reparsed round-trip is not byte-identical.
+  * `Makiri::XML` rejects NUL everywhere: XML 1.0 has no legal U+0000 character,
+    so admitting it would produce non-well-formed XML.
+
 ## Conformance
 
 The XPath engine and XML parser are original code, so their correctness is held by

data/Rakefile

@@ -287,6 +287,12 @@ task :oom do
   puts "(injection build left in place; run `rake clean compile` to restore a normal build)"
 end
 
+desc "CBMC proofs over the Ruby/Lexbor-free carve-out (core + XML + XPath front; " \
+     "needs cbmc; see docs/formal_verification.ja.md and verify/Makefile)"
+task :verify do
+  sh "make -C verify smoke selftest cbmc"
+end
+
 desc "Run the performance benchmark (Makiri vs Nokogiri reference)"
 task bench: :compile do
   # Run outside the bundle so the bench-only gems (nokogiri, benchmark-ips)
@@ -303,6 +309,13 @@ task "bench:xml" => :compile do
   end
 end
 
+desc "Run the CSS selector-query benchmark on a note.com-style SPA page (set BENCH_CARDS)"
+task "bench:css" => :compile do
+  Bundler.with_unbundled_env do
+    sh "#{FileUtils::RUBY} -Ilib bench/bench_css_query.rb"
+  end
+end
+
 namespace :conformance do
   desc "WHATWG HTML5 parsing conformance: run html5lib-tests through Makiri"
   task html5: :compile do

data/ext/makiri/bridge/bridge.h

@@ -24,6 +24,22 @@ typedef struct {
     size_t      len;
 } mkr_ruby_borrowed_text_t;
 
+/* A validated, borrowed view of a Ruby String argument for a DATA-FAMILY
+ * mutation (text/comment/CDATA node content, attribute value). Contract: valid
+ * UTF-8, interior NUL ALLOWED, NUL-terminated at ptr[len] but - unlike
+ * mkr_ruby_borrowed_text_t - NOT usable as a C string, because an interior NUL
+ * may truncate it. Every consumer MUST pass (ptr, len) explicitly. `value`
+ * keeps `ptr` alive while the view stays on the C stack. This type is
+ * deliberately distinct from mkr_ruby_borrowed_text_t so the compiler forbids a
+ * NUL-bearing value from reaching a name or engine API that requires the
+ * NUL-free contract (DOM createTextNode/setAttribute must accept U+0000; names
+ * and engine strings still must not). */
+typedef struct {
+    VALUE       value;
+    const char *ptr;
+    size_t      len;
+} mkr_ruby_borrowed_data_t;
+
 /* A borrowed raw byte view of a Ruby String. This deliberately does NOT enforce
  * Makiri's strict text contract; HTML parsing consumes raw bytes and decodes
  * invalid UTF-8 leniently. */
@@ -37,6 +53,12 @@ typedef struct {
  * Makiri::Error (naming +what+) on a NUL byte or invalid UTF-8. */
 mkr_ruby_borrowed_text_t mkr_ruby_verified_text(VALUE in, const char *what);
 
+/* Constructor for mkr_ruby_borrowed_data_t (see its contract above): coerce +in+
+ * to a String, requiring valid UTF-8 but permitting an interior NUL. Raises
+ * Makiri::Error (naming +what+) on invalid UTF-8 only. For data-family values;
+ * names and engine strings use mkr_ruby_verified_text. */
+mkr_ruby_borrowed_data_t mkr_ruby_verified_data(VALUE in, const char *what);
+
 /* Coerce +in+ to a String and return its raw bytes. No UTF-8 / NUL validation.
  * The returned `ptr` borrows the bytes of `value`; use mkr_ruby_copy_bytes when
  * the buffer must outlive the source String. */
@@ -84,10 +106,12 @@ const char *mkr_ruby_try_verified_text(VALUE sv, size_t max_bytes,
  * escape. Embedded NULs are intentionally truncated by %s formatting. */
 void mkr_ruby_exception_message(VALUE exc, char *buf, size_t len);
 
-/* The sole constructor of mkr_verified_text_t. Turns an already-validated view
- * (from mkr_ruby_verified_text or mkr_ruby_try_verified_text) into the token the
- * XPath engine accepts. The returned token borrows v.ptr; the caller must keep
- * v.value alive for the duration of the engine call. */
+/* The Ruby-bound constructor of mkr_verified_text_t. Turns an already-validated
+ * view (from mkr_ruby_verified_text or mkr_ruby_try_verified_text) into the token
+ * the XPath engine accepts. The returned token borrows v.ptr; the caller must
+ * keep v.value alive for the duration of the engine call. The sole Ruby-free
+ * constructor is mkr_verified_text_lit (core/mkr_text.h), for compile-time
+ * literals. */
 mkr_verified_text_t mkr_verified_text_from_view(mkr_ruby_borrowed_text_t v);
 
 /* Assemble a UTF-8 Ruby String of exactly +total+ bytes by concatenating +n+

data/ext/makiri/bridge/ruby_string.c

@@ -115,6 +115,31 @@ mkr_ruby_verified_text(VALUE in, const char *what)
     return v;
 }
 
+mkr_ruby_borrowed_data_t
+mkr_ruby_verified_data(VALUE in, const char *what)
+{
+    VALUE       s   = rb_String(in);
+    const char *ptr = RSTRING_PTR(s);
+    size_t      len = (size_t)RSTRING_LEN(s);
+
+    /* Data-family (text/comment/CDATA content, attribute value): only invalid
+     * UTF-8 is fatal; an interior NUL is permitted so DOM data can hold U+0000.
+     * mkr_verify_text is not reused because it raises on NUL. mkr_text_check is
+     * allocation-free, so the borrow above is not held across a GC point. */
+    switch (mkr_text_check(s, ptr, len)) {
+        case MKR_TEXT_INVALID_UTF8:
+            rb_raise(mkr_eError, "%s must be valid UTF-8", what);
+        case MKR_TEXT_HAS_NUL: /* permitted for data-family */
+        case MKR_TEXT_OK:
+            break;
+    }
+    mkr_ruby_borrowed_data_t v;
+    v.value = s;
+    v.ptr   = ptr;
+    v.len   = len;
+    return v;
+}
+
 mkr_ruby_borrowed_bytes_t
 mkr_ruby_bytes_view(VALUE in)
 {

data/ext/makiri/core/mkr_alloc.c

@@ -39,6 +39,12 @@ mkr_reallocarray(void *ptr, size_t count, size_t elem)
         free(ptr);
         return NULL;
     }
+    if (elem == 0) {
+        /* Fail closed like mkr_callocarray rather than fall through to a
+         * realloc(ptr, 0) whose free-or-not is implementation-defined; the
+         * caller keeps ownership of ptr. */
+        return NULL;
+    }
     size_t bytes;
     if (!mkr_size_mul(count, elem, &bytes)) {
         return NULL; /* overflow: leave ptr unchanged */

data/ext/makiri/core/mkr_alloc.h

@@ -48,8 +48,10 @@ mkr_size_mul(size_t a, size_t b, size_t *out)
 }
 
 /* Compute a new capacity (in elements) that is >= need and grows geometrically
- * from cap, with cap*elem guaranteed to fit in size_t. Returns false on
- * overflow. */
+ * from cap, with new_cap*elem guaranteed to fit in size_t. Succeeds EXACTLY
+ * when need*elem fits: if the geometric target overshoots what elem allows, it
+ * falls back to `need` rather than failing, so the only failure is `need`
+ * itself being too large. (cbmc-alloc proves success <=> need*elem fits.) */
 static inline bool
 mkr_grow_capacity(size_t cap, size_t need, size_t elem, size_t *new_cap)
 {
@@ -59,14 +61,21 @@ mkr_grow_capacity(size_t cap, size_t need, size_t elem, size_t *new_cap)
         nc *= 2;
     }
     size_t bytes;
-    if (!mkr_size_mul(nc, elem, &bytes)) return false;
+    if (!mkr_size_mul(nc, elem, &bytes)) {
+        /* Geometric overshoot doesn't fit; retry at exactly `need` so a
+         * representable need never fails from the *2 headroom alone. */
+        nc = need;
+        if (!mkr_size_mul(nc, elem, &bytes)) return false;
+    }
     *new_cap = nc;
     return true;
 }
 
 /* realloc(ptr, count * elem) with the multiply overflow-checked. Returns NULL
  * on overflow or OOM; the original ptr is then unchanged (caller still owns
- * it). count == 0 frees and returns NULL. */
+ * it). count == 0 frees ptr and returns NULL; elem == 0 (with count > 0)
+ * returns NULL and leaves ptr unchanged (no implementation-defined
+ * realloc(ptr, 0)). */
 void *mkr_reallocarray(void *ptr, size_t count, size_t elem);
 
 /* calloc(count, elem) with the multiply overflow-checked, result zeroed.

data/ext/makiri/core/mkr_buf.h

@@ -143,6 +143,7 @@ static inline void
 mkr_spanbuf_write(mkr_spanbuf_t *b, const void *src, size_t n)
 {
     if (!b->ok || n == 0) return;
+    if (src == NULL) { b->ok = false; return; } /* fail closed, never memcpy(,NULL,n) */
     if (b->pos > b->cap || n > b->cap - b->pos) { b->ok = false; return; }
     memcpy(b->buf + b->pos, src, n);
     b->pos += n;

data/ext/makiri/core/mkr_text.h

@@ -22,17 +22,28 @@ extern "C" {
 /* A borrowed byte slice whose contents are guaranteed to satisfy Makiri's
  * engine text contract: valid UTF-8, no interior NUL, and NUL-terminated at
  * ptr[len]. The XPath engine's public string entry points accept ONLY this
- * type, so a raw `const char *` cannot be passed without a compile error. The
- * sole constructor is mkr_verified_text_from_view() at the Ruby boundary (bridge),
- * which can only be fed a view that mkr_ruby_verified_text() already validated;
- * there is deliberately no Ruby-free constructor, so unvalidated bytes have no
- * path into the engine. (ptr is non-owning: the caller keeps it alive for the
- * duration of the engine call.) */
+ * type, so a raw `const char *` cannot be passed without a compile error.
+ * Constructors:
+ *   - mkr_verified_text_from_view() at the Ruby boundary (bridge), fed a view
+ *     that mkr_ruby_verified_text() already validated;
+ *   - mkr_verified_text_lit() below, for compile-time string literals (which
+ *     meet the contract by construction).
+ * There is deliberately no Ruby-free constructor over runtime bytes, so
+ * unvalidated bytes have no path into the engine. (ptr is non-owning: the
+ * caller keeps it alive for the duration of the engine call.) */
 typedef struct {
     const char *ptr;
     size_t      len;
 } mkr_verified_text_t;
 
+/* Wrap a compile-time string literal as a verified-text token. The literal is
+ * NUL-terminated, NUL-free, and valid UTF-8 by construction, so it meets the
+ * engine text contract without validation - the sole Ruby-free mint, for
+ * selftest / fuzz harness literals that the bridge cannot reach. Do not pass a
+ * char* variable: sizeof(pointer) would not be the byte length. */
+#define mkr_verified_text_lit(lit) \
+    ((mkr_verified_text_t){ (lit), sizeof(lit) - 1 })
+
 /* ---------------------------------------------------------------- */
 /* string-type lattice                                              */
 /* ---------------------------------------------------------------- */
@@ -59,10 +70,18 @@ typedef struct {
  *   raw slice today. When something does, name it mkr_borrowed_bytes_t per the
  *   convention above; do not resurrect a placeholder before there is a user.
  *
+ *   One bridge-only variant sits BETWEEN bytes and text on the contract axis:
+ *   mkr_ruby_borrowed_data_t (bridge.h) is "valid UTF-8 but interior NUL
+ *   PERMITTED" - a strict superset of text - for DOM data-family mutations
+ *   (text/comment/CDATA content, attribute value), where U+0000 is legal data.
+ *   It never enters the engine (the engine still requires NUL-free text), so it
+ *   is deliberately absent from this engine lattice.
+ *
  *   (*) mkr_verified_text_t (defined above) is the one deliberate naming exception:
- *   it is a borrowed valid text AND a capability token. Its sole constructor is
- *   mkr_verified_text_from_view() at the Ruby boundary, so an unvalidated const char*
- *   cannot reach the engine's public API. Internally the engine carries the
+ *   it is a borrowed valid text AND a capability token. Its constructors are
+ *   mkr_verified_text_from_view() at the Ruby boundary and mkr_verified_text_lit()
+ *   for compile-time literals, so an unvalidated runtime const char* cannot
+ *   reach the engine's public API. Internally the engine carries the
  *   freely-constructible mkr_borrowed_text_t instead.
  *
  * Conversions - the only sanctioned edges. The points that actually VALIDATE

data/ext/makiri/core/mkr_utf8.h

@@ -32,6 +32,10 @@
 extern "C" {
 #endif
 
+/* src must be non-NULL when len > 0 (it is dereferenced through [0, len)); src
+ * may be NULL only when len == 0 (trivially valid). len > 0 with src == NULL is
+ * a caller-contract violation, not a fail-closed case - this is a hot path
+ * guarded at the call site, not here. */
 bool mkr_utf8_valid(const unsigned char *src, size_t len);
 
 /* mkr_utf8_decode1 - decode ONE code point from [p, p+len), strictly: rejects
@@ -53,7 +57,10 @@ mkr_utf8_decode1_span(const mkr_span_t *s, uint32_t *cp)
 /* mkr_utf8_count_chars - count Unicode code points in [ptr, ptr+len): every
  * byte that is NOT a 0x80..0xBF continuation byte starts a new code point.
  * Length-bounded (does not rely on a NUL terminator); ptr may be NULL when
- * len == 0. Used where XPath measures string length / offsets in characters. */
+ * len == 0. Used where XPath measures string length / offsets in characters.
+ * Semantics: on VALID UTF-8 this equals the code-point count (proved in
+ * cbmc-utf8-chain); on invalid bytes it is only a lead-byte-class scan (no
+ * decoding), so the strong count/boundary guarantees hold for valid text. */
 static inline size_t
 mkr_utf8_count_chars(const char *ptr, size_t len)
 {

data/ext/makiri/fuzz/Makefile

@@ -1,9 +1,10 @@
 # ext/makiri/fuzz/Makefile - libFuzzer harness build
 #
 # Usage:
-#   make xml_fuzz      # build the XML parser harness
-#   make xpath_fuzz    # build the XPath compile+eval harness
-#   make clean         # remove build artifacts
+#   make xml_fuzz       # build the XML parser harness
+#   make xpath_fuzz     # build the XPath compile+eval harness (fixed document)
+#   make xml_xpath_fuzz # build the combined harness (fuzzer-controlled document + expression)
+#   make clean          # remove build artifacts
 #
 # Requires: clang with libFuzzer support (usually part of the clang distribution)
 #   and the vendored Lexbor static library already built (via `rake compile`).
@@ -64,9 +65,9 @@ CORE_OBJS  = $(patsubst $(EXT_DIR)/%.c,$(BUILD_DIR)/%.o,$(CORE_SRCS))
 XML_OBJS   = $(patsubst $(EXT_DIR)/%.c,$(BUILD_DIR)/%.o,$(XML_SRCS))
 XPATH_OBJS = $(patsubst $(EXT_DIR)/%.c,$(BUILD_DIR)/%.o,$(XPATH_SRCS))
 
-.PHONY: all clean check-libfuzzer xml_fuzz xpath_fuzz
+.PHONY: all clean check-libfuzzer xml_fuzz xpath_fuzz xml_xpath_fuzz
 
-all: check-libfuzzer xml_fuzz xpath_fuzz
+all: check-libfuzzer xml_fuzz xpath_fuzz xml_xpath_fuzz
 
 check-libfuzzer:
 	@mkdir -p $(BUILD_DIR)
@@ -79,6 +80,9 @@ xml_fuzz: $(BUILD_DIR)/xml_fuzz.o $(CORE_OBJS) $(XML_OBJS)
 xpath_fuzz: $(BUILD_DIR)/xpath_fuzz.o $(CORE_OBJS) $(XML_OBJS) $(XPATH_OBJS)
 	$(CXX) $(LDFLAGS) -o $@ $^ $(LEXBOR_DST)/lib/liblexbor_static.a
 
+xml_xpath_fuzz: $(BUILD_DIR)/xml_xpath_fuzz.o $(CORE_OBJS) $(XML_OBJS) $(XPATH_OBJS)
+	$(CXX) $(LDFLAGS) -o $@ $^ $(LEXBOR_DST)/lib/liblexbor_static.a
+
 $(BUILD_DIR)/%.o: $(EXT_DIR)/%.c
 	@mkdir -p $(dir $@)
 	$(CLANG) $(CFLAGS) -c -o $@ $<
@@ -91,5 +95,9 @@ $(BUILD_DIR)/xpath_fuzz.o: xpath_fuzz.c
 	@mkdir -p $(dir $@)
 	$(CLANG) $(CFLAGS) -c -o $@ $<
 
+$(BUILD_DIR)/xml_xpath_fuzz.o: xml_xpath_fuzz.c
+	@mkdir -p $(dir $@)
+	$(CLANG) $(CFLAGS) -c -o $@ $<
+
 clean:
-	rm -rf $(BUILD_DIR) xml_fuzz xpath_fuzz
+	rm -rf $(BUILD_DIR) xml_fuzz xpath_fuzz xml_xpath_fuzz

data/ext/makiri/fuzz/xml_xpath_fuzz.c

@@ -0,0 +1,87 @@
+/* xml_xpath_fuzz.c - libFuzzer harness where the fuzzer controls BOTH the
+ * document and the expression.
+ *
+ * Complements the other two targets: xml_fuzz covers the parser alone, and
+ * xpath_fuzz covers the engine over one fixed document shape - so evaluator
+ * paths that depend on document structure (namespace scopes, index buckets,
+ * axis edge cases) only ever see that shape. Here the input's bytes up to the
+ * first NUL are the XML document and the rest is the expression (both engine
+ * contracts forbid embedded NUL, so the separator costs no coverage).
+ *
+ * Contract violations (invalid UTF-8, non-XML chars) are filtered the same
+ * way the Ruby bridge does, so the harness only exercises in-contract inputs;
+ * the validators themselves run on every input and are fuzzed for free.
+ * Ruby-free; the XML arena self-poisons under ASan, so intra-arena overruns
+ * are caught. */
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "core/mkr_core.h"
+#include "xml/mkr_xml.h"
+#include "xpath/mkr_xpath.h"
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    const uint8_t *sep = memchr(data, 0, size);
+    if (sep == NULL) return 0;
+
+    const char *xml  = (const char *)data;
+    size_t xml_len   = (size_t)(sep - data);
+    const char *expr = (const char *)sep + 1;
+    size_t expr_len  = size - xml_len - 1;
+
+    /* In-contract filter, mirroring the bridge's strict gate. */
+    if (!mkr_utf8_valid((const unsigned char *)xml, xml_len)) return 0;
+    if (mkr_xml_validate_chars(xml, (uint32_t)xml_len) != 0) return 0;
+    if (!mkr_utf8_valid((const unsigned char *)expr, expr_len)) return 0;
+
+    mkr_xml_status_t st = MKR_XML_OK;
+    mkr_xml_doc_t *doc = mkr_xml_parse(xml, xml_len, &st);
+    if (doc == NULL) return 0;
+
+    mkr_xpath_context_t *ctx = mkr_xpath_context_new(doc->doc_node, doc->doc_node);
+    if (ctx != NULL) {
+        mkr_xpath_set_engine_kind(ctx, 1); /* XML monomorphization */
+
+        /* Shrink the per-evaluate budgets so a single hostile input can't
+         * stall the fuzzer; overruns fail closed, which is the point. */
+        mkr_xpath_limits_t *L = mkr_ctx_limits(ctx);
+        L->max_eval_ops     = 20000;
+        L->max_nodeset_size = 1024;
+        L->max_string_bytes = 4096;
+
+        mkr_xpath_register_ns(ctx, mkr_verified_text_lit("d"), mkr_verified_text_lit("urn:d"));
+
+        /* The expression is the bytes after the separator NUL. libFuzzer
+         * gives exactly `size` bytes with no trailing terminator, so copy
+         * into an owned, NUL-terminated heap buffer and mint over that
+         * (mirroring xpath_fuzz.c): this supplies the NUL at ptr[len] the
+         * lexer's strtod / "%.10s" error path rely on. UTF-8 validity was
+         * checked above; the copy preserves it. */
+        char *expr_copy = mkr_strndup(expr, expr_len);
+        if (expr_copy == NULL) {
+            mkr_xpath_context_free(ctx);
+            mkr_xml_doc_destroy(doc);
+            return 0;
+        }
+
+        mkr_xpath_error_t err = {0};
+        mkr_verified_text_t e = { expr_copy, expr_len };
+        mkr_node_t *ast = mkr_parse(e, L, &err);
+        if (ast != NULL) {
+            mkr_xpath_value_t v = {0};
+            (void)mkr_xpath_eval_compiled(ctx, ast, &v, &err);
+            mkr_xpath_value_clear(&v);
+            mkr_node_free(ast);
+        }
+        mkr_xpath_error_clear(&err);
+        free(expr_copy);
+        mkr_xpath_context_free(ctx);
+    }
+    mkr_xml_doc_destroy(doc);
+    return 0;
+}

data/ext/makiri/glue/ruby_html_css.c

@@ -33,6 +33,34 @@ static lxb_css_selectors_t *g_css_sel;
 static lxb_selectors_t     *g_selectors;
 static int                  g_css_ready;
 
+/* Compiled-selector cache: a Ruby Hash mapping a selector String to the parsed
+ * lxb_css_selector_list_t (stored as an Integer pointer). Parsing a selector is
+ * the dominant cost when the same selectors are queried over and over (a
+ * querySelector-heavy SPA fires tens of thousands of identical queries), so the
+ * compiled list is reused instead of re-parsed. The parsed lists live in the
+ * shared g_css_mem arena, which is therefore NOT cleaned per call (the original
+ * code reset it after every query); to bound growth, when the cache fills we drop
+ * every compiled list at once (clean the arena + clear the Hash) and start over. */
+static VALUE                g_css_cache;
+#define MKR_CSS_CACHE_CAP   256
+
+/* Adaptive caching. Holding many distinct compiled lists in the shared arena
+ * makes each new parse slower (a bigger arena = more allocator work), so a flood
+ * of one-off selectors -- e.g. getElementById on unique React `useId` ids, which
+ * are never requeried -- turned the cache into a net loss vs the original
+ * parse+clean (measured ~22% slower per call). Track the cache hit rate over a
+ * window and, when it is low, BYPASS the cache: parse + clean per call, exactly
+ * as before, so the arena stays small and the worst case is merely "as fast as no
+ * cache". Periodically drop back into caching to re-test, so a workload that
+ * starts repeating selectors regains the cache. */
+static size_t               g_css_win;        /* lookups in the current window */
+static size_t               g_css_win_hits;   /* cache hits in the current window */
+static int                  g_css_bypass;     /* 1 = parse+clean, no caching */
+static size_t               g_css_bypass_runs; /* consecutive bypass windows */
+#define MKR_CSS_WIN          1024  /* re-evaluate the hit rate every N lookups */
+#define MKR_CSS_MIN_HIT_PCT  15    /* below this hit rate, bypass the cache */
+#define MKR_CSS_RETEST_GAP   32    /* re-test caching every N bypass windows */
+
 /* Build the shared engine on first use; raises Makiri::Error on init failure
  * (leaving the globals unset, so a later call retries). */
 static void
@@ -179,22 +207,83 @@ mkr_with_compiled_selector(VALUE rb_selector, lxb_dom_node_t *node,
 
     mkr_css_engine_init(); /* raises on init failure */
 
-    lxb_css_selector_list_t *list =
-        lxb_css_selectors_parse(g_css_parser, (const lxb_char_t *)sv.ptr, sv.len);
+    if (g_css_cache == 0) {
+        g_css_cache = rb_hash_new();
+        rb_gc_register_address(&g_css_cache);
+    }
+
+    /* Adaptive window: every MKR_CSS_WIN lookups, decide whether caching is
+     * paying off. A low hit rate (mostly one-off selectors) means the cache is
+     * only growing the arena and slowing parses, so bypass it; periodically
+     * re-test so a workload that becomes selector-repetitive regains the cache. */
+    if (++g_css_win > MKR_CSS_WIN) {
+        if (!g_css_bypass) {
+            if (g_css_win_hits * 100 < (size_t)MKR_CSS_WIN * MKR_CSS_MIN_HIT_PCT) {
+                g_css_bypass = 1;
+                g_css_bypass_runs = 0;
+                lxb_css_memory_clean(g_css_mem); /* drop the cached lists' arena */
+                rb_hash_clear(g_css_cache);
+            }
+        } else if (++g_css_bypass_runs >= MKR_CSS_RETEST_GAP) {
+            g_css_bypass = 0; /* re-test caching over the next window */
+        }
+        g_css_win = 1;
+        g_css_win_hits = 0;
+    }
+
+    if (!g_css_bypass) {
+        /* Reuse the compiled selector when we have already parsed this string. */
+        VALUE cached = rb_hash_lookup(g_css_cache, sv.value);
+        if (!NIL_P(cached)) {
+            lxb_css_selector_list_t *list =
+                (lxb_css_selector_list_t *)(intptr_t)NUM2LL(cached);
+            g_css_win_hits++;
+            (void)run(g_selectors, node, list, u);
+            /* The traversal engine self-cleans; the cached list + arena persist. */
+            RB_GC_GUARD(sv.value);
+            return;
+        }
+
+        /* Cache miss. Bound the cache before parsing: when full, drop every
+         * compiled list at once by cleaning the shared arena, then start fresh —
+         * so the new list is parsed into the now-empty arena (cleaning AFTER
+         * parsing would invalidate it). */
+        if (RHASH_SIZE(g_css_cache) >= MKR_CSS_CACHE_CAP) {
+            lxb_css_memory_clean(g_css_mem);
+            rb_hash_clear(g_css_cache);
+        }
+
+        lxb_css_selector_list_t *list =
+            lxb_css_selectors_parse(g_css_parser, (const lxb_char_t *)sv.ptr, sv.len);
+        int syntax_error = (list == NULL || g_css_parser->status != LXB_STATUS_OK);
+
+        /* Return the parser to its CLEAN stage; do NOT clean the memory arena —
+         * the freshly parsed list lives there and we keep it. */
+        lxb_css_parser_clean(g_css_parser);
+
+        if (syntax_error) {
+            rb_raise(mkr_eCSSSyntaxError, "invalid CSS selector: %" PRIsVALUE, sv.value);
+        }
 
-    int syntax_error = (list == NULL || g_css_parser->status != LXB_STATUS_OK);
-    if (!syntax_error) {
+        /* Cache the compiled list (the Hash dups + freezes the String key), then
+         * run. Store the pointer as a Ruby Integer; the list outlives the call. */
+        rb_hash_aset(g_css_cache, sv.value, LL2NUM((long long)(intptr_t)list));
         (void)run(g_selectors, node, list, u);
+        RB_GC_GUARD(sv.value);
+        return;
     }
 
-    /* Reset the shared engine for the next query: drop the parsed list's arena
-     * allocations and return the parser to its CLEAN stage. Both preserve the
-     * memory/selectors objects we set once; the traversal engine self-cleans
-     * after find/match. */
+    /* Bypass mode: parse + clean per call (the original behavior), so the arena
+     * stays small and a one-off-selector flood is no slower than no cache. */
+    lxb_css_selector_list_t *l0 =
+        lxb_css_selectors_parse(g_css_parser, (const lxb_char_t *)sv.ptr, sv.len);
+    int err0 = (l0 == NULL || g_css_parser->status != LXB_STATUS_OK);
+    if (!err0) {
+        (void)run(g_selectors, node, l0, u);
+    }
     lxb_css_memory_clean(g_css_mem);
     lxb_css_parser_clean(g_css_parser);
-
-    if (syntax_error) {
+    if (err0) {
         rb_raise(mkr_eCSSSyntaxError, "invalid CSS selector: %" PRIsVALUE, sv.value);
     }
     RB_GC_GUARD(sv.value);