leptris 1.9.381.0-arm-linux → 1.9.382.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a14d1d324ee4925bbeb41aed36f0efaf3ccaed6ce6a89c1c643460eccfbd56a1
-  data.tar.gz: 359ee93d64dca7b0f6de0d9e6028da147fa19aef034c9009663f23260fbcc34e
+  metadata.gz: eeb080a56ba2f644ba7219077f866627006b2d5e8ea80405a86a17cff5853737
+  data.tar.gz: 8498da423561b35ddfabe900ae828df3ee9f9963c1498ac90cbb543f73c4c58e
 SHA512:
-  metadata.gz: b65285e8a95fd881703df532d3c5196043c56d20c6f7576cb481ab2097a3014b79429b484f30f3ce46846237f34d22dbf59838414b2c36c0e7367991d6385469
-  data.tar.gz: 3b866259b7b0e2e5c82196bbdf89dc8d3dffa43e603d32f96f55e24c71614deb7637af0c7463d7ed8ff2b94665ac0674fc937b56b4cbe4e0fdb57dcf729d5b51
+  metadata.gz: 750842a780c631c64e41614fa9f6b1a812bec0cffe9965fa868967a0b0375b16d9b1466279a07b990a90bbb0f14ee307c3868e9f4dd1702c1436f1af54d3d3f7
+  data.tar.gz: 16cfef2895a0d2b8ccfb5324492183111dacf30e4db0261f310418a3f2f97dbd6c68b24828858573ecd5062ba2ec9e3fa0f83c5904e8b769234dde45f9b7e86b

data/CHANGELOG.md

@@ -1,7 +1,33 @@
 ## [Unreleased]
 
+### Added — 1.9.382.0 (rides libleptris 1.9.382)
+
+- **Schema#version** (moxml#460 item 2): the effective schema
+  version — "1.1" when the root declares `@version="1.1"` (1.1
+  semantics apply: `xs:alternative` CTA, `xs:assert`), else
+  "1.0". Engine face leptris_xsd_version (leptris/leptris#1849).
+- **Native.name_equals** (leptris/leptris#1855 ask 2): engine-side
+  name comparison — no String materialization for name-comparing
+  consumers. Soft-gated; Qnil for non-element addresses.
+- **Soft-attached faces** (leptris-ruby#548): version-gated symbols
+  no longer break the load on older engines; the symbol audit
+  exempts them until the pin reaches their release.
+
 ### Fixed — engine ride
 
+- **Ride libleptris 1.9.382**: XSD structured error rows
+  (leptris/leptris#1843), negative wildcards (#1850), block +
+  category escapes in the pattern regex (#1853/#1856/#1857), the
+  parse-perf campaign work (#1844/#1847/#1848/#1851), and the
+  CAS-only retain spinlock.
+- **Ride libleptris 1.9.380**: the xsi:type conformance fix
+  (leptris/leptris#1832, lutaml/moxml#433) — an element carrying
+  `xsi:type` is assessed against the NAMED type (XSD 1.0
+  §2.6.2/§3.3.4), so valid xsi:type-derived instances validate
+  instead of being rejected against the declared type's content
+  model. Released 1.9.380.0 with the pin still at 1.9.379 (the
+  vendored dylib missed the fix); this pin bump is the real ride.
+
 - **Ride libleptris 1.9.380**: the xsi:type conformance fix
   (leptris/leptris#1832, lutaml/moxml#433) — an element carrying
   `xsi:type` is assessed against the NAMED type (XSD 1.0

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.381"
+LIBLEPTRIS_VERSION = "1.9.382"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the
@@ -401,8 +401,15 @@ namespace :audit do
       .map { |n| n.sub(/\Aleptris_/, "") }.sort
     attached = File.read("lib/leptris/xml/ffi.rb")
       .scan(/attach_function :leptris_([a-z_0-9]+)/).flatten.sort
+    # Version-gated faces: soft-attached because engines BEFORE the
+    # named release lack the symbol (the load must survive them).
+    # They join the audit only when the engine pin reaches that
+    # release (the lockstep ride). TODO.concurrency/08-era law:
+    # never let one forward symbol poison the load.
+    version_gated = []
+    version_gated << "xsd_version" if Gem::Version.new(LIBLEPTRIS_VERSION) < Gem::Version.new("1.9.382")
     unattached = exported - attached
-    unexported = attached - exported
+    unexported = attached - exported - version_gated
     unless unattached.empty?
       puts "exported but NOT attached (upstream surface drift):"
       unattached.each { |s| puts "  leptris_#{s}" }

data/ext/leptris/native/native.c

@@ -3094,6 +3094,80 @@ static VALUE nf_create_element_with_attrs_wrapped(
     return node;
 }
 
+/* TODO.sota/04 (moxml build row): ONE construction crossing for the
+ * consumer build shape — create + attrs + attach + optional text +
+ * version bump + consumer mint, all in C off the PARENT WRAPPER's
+ * struct (the document comes from the struct: no FFI twin, no
+ * bridge, no per-element document climb on the Ruby side). Nokogiri's
+ * equivalent shape is five separate crossings (Node.new, []= x2,
+ * content=, add_child) + five wrapper allocs; this face is one
+ * crossing + one wrapper. attrs arrives FLATTENED (name, value, ...)
+ * like create_element_with_attrs_wrapped; text may be nil. */
+static VALUE nn_add_element_full(VALUE self, VALUE name, VALUE attrs,
+                                 VALUE text)
+{
+    struct native_node *pn;
+    VALUE doc, ck, node;
+    void *doc_ptr, *elem;
+    int st;
+
+    resolve_binding_classes();
+    TypedData_Get_Struct(self, struct native_node, &nn_type, pn);
+    doc = pn->document;
+    if (NIL_P(doc) || NIL_P(rb_ivar_get(doc, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    if (rb_ivar_get(doc, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — mutation attempted");
+    /* Bump before the call: a failed construction merely discards
+     * memos (the #539 discipline). */
+    rb_ivar_set(doc, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(doc, id_iv_version)) + 1));
+    doc_ptr = doc_ptr_of(doc);
+    elem = create_elem_core(doc_ptr, pn->ptr,
+                            StringValueCStr(name), attrs);
+    if (!elem) return Qnil;
+    if (!NIL_P(text)) {
+        st = f_elem_set_text(elem, StringValueCStr(text));
+        check_status_c(st);
+    }
+    ck = doc_klass_for_kind(doc, 0 /* element */);
+    if (!NIL_P(ck)) {
+        node = mint_consumer_node(ck, doc, elem);
+        /* The #508 identity contract, born-primed from the parent
+         * wrapper: @native is the node itself and the contract state
+         * (@context/@adapter) copies off self, so the consumer's
+         * per-child wrap prime disappears from the build row. */
+        rb_ivar_set(node, id_iv_mx_native, node);
+        if (NIL_P(rb_ivar_get(node, id_iv_mx_context))) {
+            VALUE cx = rb_ivar_get(self, id_iv_mx_context);
+            if (!NIL_P(cx)) {
+                VALUE ad = rb_ivar_get(self, id_iv_mx_adapter);
+                rb_ivar_set(node, id_iv_mx_context, cx);
+                if (!NIL_P(ad)) rb_ivar_set(node, id_iv_mx_adapter, ad);
+            }
+        }
+        return node;
+    }
+
+    node = rb_hash_aref(native_cache_of(doc),
+                        ULL2NUM((uint64_t)(uintptr_t)elem));
+    if (!NIL_P(node)) return node;
+    node = rb_obj_alloc(c_b_element);
+    rb_iv_set(node, "@c_address", ULL2NUM((uint64_t)(uintptr_t)elem));
+    rb_iv_set(node, "@document", doc);
+    rb_iv_set(node, "@parent", Qnil);
+    rb_iv_set(node, "@structure_memoizable", Qtrue);
+    rb_iv_set(node, "@native_fast", Qtrue);
+    rb_iv_set(node, "@pub_document", doc);
+    rb_iv_set(node, "@addr_reads_fast", Qtrue);
+    rb_iv_set(node, "@node_type", INT2FIX(0));
+    rb_hash_aset(native_cache_of(doc),
+                 ULL2NUM((uint64_t)(uintptr_t)elem), node);
+    return node;
+}
+
 static VALUE nf_attribute_rows(VALUE self, VALUE document, VALUE addr)
 {
     (void)self;
@@ -3539,6 +3613,18 @@ static VALUE nf_name(VALUE self, VALUE addr)
     return s ? rb_utf8_str_new_cstr(s) : Qnil;
 }
 
+/* moxml#460/#1855 ask 2: engine-side name comparison — no String
+ * materialization for name-comparing consumers. Qtrue/Qfalse;
+ * Qnil when the address is not an element (mirrors nf_name). */
+static VALUE nf_name_equals(VALUE self, VALUE addr, VALUE name)
+{
+    const char *s;
+    (void)self;
+    s = f_elem_name((void *)(uintptr_t)NUM2ULL(addr));
+    if (!s) return Qnil;
+    return strcmp(s, StringValueCStr(name)) == 0 ? Qtrue : Qfalse;
+}
+
 static VALUE nf_element_text(VALUE self, VALUE addr)
 {
     const char *s;
@@ -3965,6 +4051,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_alias(c_native_node, "text_read", "content");
     rb_define_alias(c_native_node, "name_read", "name");
     rb_define_method(c_native_node, "children", nn_children, 0);
+    rb_define_method(c_native_node, "add_element_full",
+                     nn_add_element_full, 3);
     rb_define_alias(c_native_node, "children_read", "children");
     /* Unshadowed write face (the add_child_native pattern): the
      * registered Identity klasses shadow content= with the
@@ -3981,6 +4069,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     m_native = rb_define_module_under(m_xml, "Native");
     m_native_sentinel = m_native;
     rb_define_module_function(m_native, "fast_name", nf_name, 1);
+    rb_define_module_function(m_native, "name_equals", nf_name_equals, 2);
     id_sax_start_document = rb_intern("start_document");
     id_sax_end_document = rb_intern("end_document");
     id_sax_start_element = rb_intern("start_element");

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.381.0"
+  VERSION = "1.9.382.0"
 end

data/lib/leptris/xml/element.rb

@@ -548,11 +548,17 @@ class Leptris::XML::Element < Leptris::XML::Node
     # Cross-document and docless (#376): full path first (lift +
     # engine copy), then the source original is removed; returns
     # the installed copy (self's new next sibling).
+    # #543: the raw-FFI lanes are wrapper-visible mutations too —
+    # they must advance the document version like the C-bound face,
+    # or every #530 walk-read memo warmed before the insert serves
+    # stale children afterwards (bump before the splice: a failed
+    # mutation merely discards memos).
     if Leptris::XML::Element.foreign_to?(node, @document)
       ensure_writable!
       unless Leptris::XML::Element.skip_adoption_lift?(node)
         Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces_for_sibling)
       end
+      @document&.advance_version
       Leptris::XML::FFI.check_status(
         Leptris::XML::FFI.leptris_element_insert_after(c_ptr, node.c_ptr))
       Leptris::XML::Node.invalidate_cross_document!(node, @document)
@@ -569,6 +575,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     unless Leptris::XML::Element.skip_adoption_lift?(node)
       Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces_for_sibling)
     end
+    @document&.advance_version
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_after(c_ptr, node.c_ptr))
     node
@@ -580,12 +587,14 @@ class Leptris::XML::Element < Leptris::XML::Node
     # the namespace lift — the full path below handles it.
     # Cross-document and docless (#376): full path first (lift +
     # engine copy), then the source original is removed; returns
-    # the installed copy (self's new previous sibling).
+    # the installed copy (self's new previous sibling). #543: the
+    # raw-FFI lanes advance the version like the C-bound face.
     if Leptris::XML::Element.foreign_to?(node, @document)
       ensure_writable!
       unless Leptris::XML::Element.skip_adoption_lift?(node)
         Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces_for_sibling)
       end
+      @document&.advance_version
       Leptris::XML::FFI.check_status(
         Leptris::XML::FFI.leptris_element_insert_before(c_ptr, node.c_ptr))
       Leptris::XML::Node.invalidate_cross_document!(node, @document)
@@ -602,6 +611,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     unless Leptris::XML::Element.skip_adoption_lift?(node)
       Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces_for_sibling)
     end
+    @document&.advance_version
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_before(c_ptr, node.c_ptr))
     node

data/lib/leptris/xml/ffi.rb

@@ -1397,6 +1397,24 @@ attach_function :leptris_parse_string,
         [:leptris_xsd_schema], :size_t
       attach_function :leptris_xsd_error,
         [:leptris_xsd_schema], UTF8_STRING
+      # libleptris 1.9.382 (moxml#460/#1841): the structured report —
+      # rows of {kind, component, line, column, message}; schema-
+      # owned memory, valid until the next validate. out receives
+      # the record array pointer; the return is the row count.
+      attach_function :leptris_xsd_error_report,
+        [:leptris_xsd_schema, :pointer], :size_t
+      # libleptris 1.9.382 (moxml#460 item 2): the schema's
+      # effective version — "1.1" when the root declares
+      # @version="1.1" (1.1 semantics apply), else "1.0". SOFT
+      # attach: engines before 1.9.382 lack the symbol, and a hard
+      # attach would break every face at load for the whole gem —
+      # callers gate on FFI.respond_to?(:leptris_xsd_version).
+      begin
+        attach_function :leptris_xsd_version,
+          [:leptris_xsd_schema], UTF8_STRING
+      rescue ::FFI::NotFoundError
+        nil
+      end
       # Slice 2 (libleptris 1.9.319, #1075): lexical validation.
       # Built-ins take the "xs:NAME" reference spelling; -1 = not
       # in the tier-1 table. simple_valid resolves a user

data/lib/leptris/xml/xsd.rb

@@ -108,6 +108,20 @@ module Leptris::XML::XSD
       Leptris::XML::FFI.leptris_xsd_declaration_count(@handle)
     end
 
+    # The schema's effective version (libleptris 1.9.382, moxml#460
+    # item 2): "1.1" when the root carries @version="1.1" — the
+    # engine then applies 1.1 semantics (xs:alternative CTA,
+    # xs:assert) — else "1.0". Consumers scope 1.0-only checks
+    # against it.
+    def version
+      check_released!
+      unless Leptris::XML::FFI.respond_to?(:leptris_xsd_version)
+        raise Leptris::XML::Error,
+              'Schema#version requires libleptris 1.9.382+ '               '(the leptris_xsd_version face)'
+      end
+      Leptris::XML::FFI.leptris_xsd_version(@handle) || '1.0'
+    end
+
     # The engine's schema-level error message, or nil when the
     # schema compiled cleanly.
     def error
@@ -150,6 +164,46 @@ module Leptris::XML::XSD
       end
     end
 
+    # The structured report (libleptris 1.9.382, moxml#460/#1841):
+    # one hash per finding — kind (element-decl / attribute-use /
+    # content-model / simpleType-facet / type-resolution /
+    # assertion / identity-constraint), component (declaring
+    # schema component), line, column, message (the same text
+    # validate_errors carries). Requires the 1.9.382 engine.
+    StructuredError = Struct.new(:kind, :component, :line, :column,
+                                 :message)
+
+    def structured_errors(document)
+      check_released!
+      valid?(document)
+      unless Leptris::XML::FFI.respond_to?(:leptris_xsd_error_report)
+        raise Leptris::XML::Error,
+              'structured_errors requires libleptris 1.9.382+ ' \
+              '(the leptris_xsd_error_report face)'
+      end
+      out = ::FFI::MemoryPointer.new(:pointer)
+      n = Leptris::XML::FFI.leptris_xsd_error_report(@handle, out)
+      rows = out.get_pointer(0)
+      return [] if n.zero? || rows.null?
+
+      # C layout: kind* / component* / uint line / uint column /
+      # message* — 32 bytes per record with tail padding.
+      (0...n).map do |i|
+        ptr = rows + (i * 32)
+        kind = ptr.get_pointer(0)
+        component = ptr.get_pointer(8)
+        line = ptr.get_uint32(16)
+        column = ptr.get_uint32(20)
+        message = ptr.get_pointer(24)
+        StructuredError.new(
+          kind.nil? ? nil : kind.read_string,
+          component.nil? ? nil : component.read_string,
+          line, column,
+          message.nil? ? nil : message.read_string
+        )
+      end
+    end
+
     # Slice 3 direct face: a child SEQUENCE against a top-level
     # element declaration's compiled content model (occurrence
     # bounds, xs:any wildcards). +children+ are child Nodes (name

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.381
+- libleptris v1.9.382
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,33 @@
 ## [Unreleased]
 
+## [1.9.382] - 2026-10-26
+
+### Added
+
+- category escapes — \p{L}, \p{Nd}, families (moxml#464) (xsd)
+- codepoint-wide \p{Is...} blocks — the full F.1 table (moxml#464) (xsd)
+- \p{Is...} block escapes in the pattern-facet regex (moxml#464) (xsd)
+- XSD 1.1 negative wildcards — notQName on xs:any and xs:anyAttribute (moxml#460) (xsd)
+- leptris_xsd_version — effective version reporting (moxml#460) (xsd)
+- structured error rows — {kind, component, line, column, message} (xsd)
+
+### Fixed
+
+- gate the category table on LEPTRIS_HAS_UTF8PROC (simd)
+- CAS-only retain spinlock — the plain spin read raced the atomics (memory)
+- dispatch_init fully initializes the count3_high slot on every arch (simd)
+- declared non-UTF-8 encodings are EXEMPT from the fused gate (parse)
+
+### Performance
+
+- parse_string adopts the conversion buffer — the copy-in chain and the pristine carve drop out (#1846)
+- raise the element-index build threshold to 8 axis queries (xpath)
+- fuse the UTF-8 fast gate into the count3 sizing pass (parse)
+- rank unmutated documents by parse-time byte offset (xpath)
+- pre-size the element-position journal from the count3 estimate (parse)
+
+
+
 ## [1.9.381] - 2026-10-22
 
 The XSLT transform engine is no longer slower than libxslt on the

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.381
+    VERSION 1.9.382
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/TODO.max-perf/00-INDEX.md

@@ -28,3 +28,7 @@ TODO.max-perf/node-layout-fork.md — 5 slices, addresses #1222 +
 The interleaved-parse rewrite (owner-directed 2026-09-20):
 TODO.max-perf/interleaved-parse.md — the #1222 step-change; slices 0-4,
 each CI-benchmark-gated.
+
+The C-face vs pugixml campaign (serialbench fair-flags wave, 2026-10-24):
+TODO.max-perf/15-c-face-vs-pugixml.md — parse 2.81x / generation 2.23x /
+xpath 3.48x; three tracks, CI-bench-gated. Track A1 shipped (PR #1844).

data/vendor-src/libleptris/TODO.max-perf/15-c-face-vs-pugixml.md

@@ -0,0 +1,87 @@
+# 15 — C-face vs pugixml: close the fair-flags gap (#1842)
+
+Serialbench's fair-flags wave (pugixml `parse_ws_pcdata`, run
+40066278528, posted to #1842): the gap is real — **parse 2.81x**,
+**generation 2.23x**, **xpath 3.48x** median across 13 CI legs —
+and mingw is outright parity (772 vs 770 ips), so the compiler/arch
+dimension matters as much as the library. macos-26-intel is our
+weakest runner every wave and exaggerates every ratio.
+
+Leads on XSLT (341 vs libxslt 287 ips) — not part of this campaign.
+
+## Track A — parse (2.81x)
+
+Profiled (8s sample, no-LTO build, text-shape fixture; see the
+#1842 comment): scanner loop 68% | memchr 8% | dp_wire_child 6.4% |
+whole-buffer copies ~5% | count3 sizing pass 4.4% | SWAR utf8
+validation 2.8% | elem_pos journal ~2.5%.
+
+- [x] **A1** journal pre-size from the count3 estimate — PR #1844.
+- [ ] **A2** fold the UTF-8 validation into the count3 pass
+      (`count3_high`: ASCII => valid; high bytes => the existing
+      DFA). Saves one full memory pass (~2.8%).
+- [ ] **A3** lazy pristine copy. `doc->xml_buffer` is load-bearing
+      for lazy LINE resolution; the pristine copy exists because
+      `dp_nul` may overwrite a `\n` token terminator. Audit which
+      terminators can be `\n`; either protect those or build the
+      line table from the scratch. Saves ~2.5%.
+- [ ] **A4** (sprint 2, the actual gap) scanner-loop surgery in
+      `direct_parse_internal`: per-tag branch layout, edge-encode
+      elimination on the hot path, NUL-write discipline audit.
+      pugixml-class work; the loop is 68% of text-shape parse.
+
+## Track B — generation (2.23x)
+
+- [ ] **B1** profile `leptris_document_serialize` on the serialbench
+      fixture (same method: no-LTO sample, MB/s A/B vs pugixml's
+      `xml_document::save` to buffer).
+- [ ] **B2** levers from B1: expected candidates — escape-table
+      scans (the common no-escape fast path), buffer growth
+      strategy, per-node virtual dispatch on the writer.
+
+## Track C — xpath (3.48x — the widest)
+
+**C0 (measured, 2026-10-24):** the serialbench xpath ROW re-parses
+inside the timed loop (bench.c: `leptris_parse_string` + 3 evals per
+iteration) — the row inherits the parse gap. On the exact ops
+(306KB canonical medium.xml), the dominant NON-parse cost is the
+document-order rank-table build per fresh document:
+`doc_rank_table_put` 337 + `index_walk` 78 + zeroing 29 of ~900
+non-parse samples — every query on every fresh doc re-walks the
+whole tree to assign ranks (#485 table).
+
+- [x] **C1** exact-ops profile (scratch_sb_repro vs serialbench-c
+      bench.c BENCH bodies; fixture = serialbench/fixtures
+      medium.xml).
+- [ ] **C2** offset fast path (DESIGNED, NOT LANDED — see below):
+      unmutated parse-created documents (mutation_version == 0)
+      rank by parse-time byte offset `(base.line << 2 | kind_bias)`
+      — byte offsets ARE XPath document order (attrs sit inside the
+      start tag; ns/attr/xpath-text biases 1/2/3 on the owner's
+      offset). No walk, no hash. A first implementation reproduced
+      EXACTLY (doc node must rank to the outside-the-tree tail like
+      the table path) but 8 XPathResults/SubtreeIndex/Ledger tests
+      still failed: the eval ITSELF produced different node sets
+      when the sort skipped the table build — some step-dedup or
+      ordering consumer depends on the table's side effect
+      (doc_order_index population), not just the ranks. The
+      reproduce-in-one-file probe: parse kSubtree (test_xpath.cpp),
+      eval //item then //section//item — fast mode duplicates the
+      nested item 5x. NEXT SESSION: find the consumer (candidates:
+      the vm's descendant chain dedup assumptions, or a hidden
+      doc_order_index reader behind a macro), or gate the fast path
+      to the FINAL result sort only.
+- [ ] **C3** mingw/Windows parity investigation: we are AT parity
+      there — diff the codegen assumptions (branch-heavy loops?
+      LTO behavior on gcc-win vs clang-mac?) and port whatever
+      wins back to the other legs.
+
+## Laws
+
+- CI benchmark legs (quiet runners) gate every number; local A/B
+  under a loaded machine is noise.
+- Profile with a separate `-DLEPTRIS_ENABLE_LTO=OFF` build dir; LTO
+  flattens samples into one frame.
+- #1218: arena estimates only ever grow.
+
+Refs #1842, serialbench-c#8.

data/vendor-src/libleptris/src/include/leptris.h

@@ -952,9 +952,50 @@ LEPTRIS_API int leptris_xsd_content_valid(
  * the schema). */
 LEPTRIS_API int leptris_xsd_validate(LeptrisXsdSchema schema,
                                      LeptrisDocument doc);
+/**
+ * Effective XSD version of a compiled schema ("1.1" or "1.0").
+ *
+ * "1.1" when the schema root carries @version="1.1" — the engine
+ * then applies 1.1 semantics (xs:alternative conditional type
+ * assignment, xs:assert evaluation). Any other root version, or no
+ * version attribute, is "1.0". The returned string is static and
+ * schema-independent; NULL for a NULL schema (moxml#460).
+ */
+LEPTRIS_API const char* leptris_xsd_version(LeptrisXsdSchema schema);
 LEPTRIS_API size_t leptris_xsd_error_count(LeptrisXsdSchema schema);
 LEPTRIS_API const char* leptris_xsd_error_at(LeptrisXsdSchema schema,
                                              size_t i);
+
+/**
+ * One XSD validation finding, in the structured report shape
+ * (#1841 — mirrors LeptrisRngErrorRecord). Returned as a
+ * whole-list report via leptris_xsd_error_report(); no
+ * per-index stitching. All strings are schema-owned and live
+ * until the next validate call or leptris_xsd_free.
+ */
+typedef struct {
+    const char* kind;     /* failure class, stable name:
+                           * "element-decl", "attribute-use",
+                           * "content-model", "simpleType-facet",
+                           * "type-resolution", "assertion",
+                           * "identity-constraint" */
+    const char* component; /* declaring schema component's name
+                            * (qualified where namespaced), or NULL */
+    unsigned line;        /* instance source line, 0 when unknown */
+    unsigned column;      /* instance source column, 0 when unknown */
+    const char* message;  /* unchanged leptris_xsd_error_at text */
+} LeptrisXsdErrorRecord;
+
+/**
+ * Get the full XSD validation report in one call (#1841).
+ *
+ * @param schema  schema handle after a leptris_xsd_validate call
+ * @param out     receives the schema-owned record array (NULL when
+ *                the count is 0; left untouched on a NULL schema)
+ * @return        record count; 0 for a valid document
+ */
+LEPTRIS_API size_t leptris_xsd_error_report(
+    LeptrisXsdSchema schema, const LeptrisXsdErrorRecord** out);
 /* Validate an instance document against the parsed schema
  * (phase-2 core subset: element/attribute/text/data/value/
  * choice/group/interleave/repeats/ref). Returns 1 valid; on 0,

data/vendor-src/libleptris/src/leptris/common/simd_text.c

@@ -58,6 +58,9 @@ static ptrdiff_t (*g_find3_fn)(const char*, size_t, char, char, char) = NULL;
 static size_t (*g_count_fn)(const char*, size_t, char) = NULL;
 static void (*g_count3_fn)(const char*, size_t, char, char, char,
                            size_t*, size_t*, size_t*) = NULL;
+static void (*g_count3_high_fn)(const char*, size_t, char, char, char,
+                                size_t*, size_t*, size_t*,
+                                int*) = NULL;
 static void (*g_copy3_fn)(char*, const char*, size_t, char, char, char,
                           size_t*, size_t*, size_t*) = NULL;
 
@@ -79,6 +82,10 @@ static size_t count_scalar(const char* s, size_t len, char c) {
  * dispatch_init()" pattern raced when two threads hit the same
  * entry point on first call. */
 static void dispatch_init(void);
+static void count3_high_scalar(const char* s, size_t len,
+                               char c0, char c1, char c2,
+                               size_t* n0, size_t* n1, size_t* n2,
+                               int* saw_high);
 
 #if defined(_MSC_VER)
 #  pragma section(".CRT$XCU", read)
@@ -100,6 +107,7 @@ static void dispatch_init(void) {
         g_contains_fn = leptris_text_contains_avx2;
         g_find3_fn = leptris_text_find3_avx2;
         g_count_fn = leptris_text_count_char_avx2;
+        g_count3_high_fn = count3_high_scalar;
         return;
     }
 #endif
@@ -109,6 +117,7 @@ static void dispatch_init(void) {
         g_find3_fn = leptris_text_find3_neon;
         g_count_fn = leptris_text_count_char_neon;
         g_count3_fn = leptris_text_count3_neon;
+        g_count3_high_fn = leptris_text_count3_high_neon;
         g_copy3_fn = leptris_copy_count3_neon;
         return;
     }
@@ -117,6 +126,41 @@ static void dispatch_init(void) {
     g_contains_fn = contains_scalar;
     g_find3_fn = find3_scalar;
     g_count_fn = count_scalar;
+    g_count3_high_fn = count3_high_scalar;
+}
+
+/* Scalar kernel: one byte loop counts all three chars and detects
+ * high bytes (host shapes without a count3 SIMD kernel — x86/AVX2
+ * builds have none today). Assigned by dispatch_init so the
+ * constructor fully initializes the slot on every arch: the lazy
+ * if-NULL re-dispatch raced under TSan when two threads hit the
+ * same entry on first call (TODO.concurrency/08 discipline). */
+static void count3_high_scalar(const char* s, size_t len,
+                               char c0, char c1, char c2,
+                               size_t* n0, size_t* n1, size_t* n2,
+                               int* saw_high) {
+    size_t a = 0, b = 0, c = 0;
+    int h = 0;
+    for (size_t i = 0; i < len; i++) {
+        unsigned char ch = (unsigned char)s[i];
+        if (ch == (unsigned char)c0) a++;
+        if (ch == (unsigned char)c1) b++;
+        if (ch == (unsigned char)c2) c++;
+        if (ch & 0x80) h = 1;
+    }
+    *n0 = a;
+    *n1 = b;
+    *n2 = c;
+    *saw_high = h;
+}
+
+void leptris_text_count3_high(const char* s, size_t len,
+                              char c0, char c1, char c2,
+                              size_t* n0, size_t* n1, size_t* n2,
+                              int* saw_high) {
+    if (!g_count3_high_fn) dispatch_init();
+    if (!g_count3_high_fn) g_count3_high_fn = count3_high_scalar;
+    g_count3_high_fn(s, len, c0, c1, c2, n0, n1, n2, saw_high);
 }
 
 int leptris_text_contains(const char* s, size_t len, char c) {

data/vendor-src/libleptris/src/leptris/common/simd_text.h

@@ -48,6 +48,15 @@ void leptris_text_count3(const char* s, size_t len,
                         char c0, char c1, char c2,
                         size_t* n0, size_t* n1, size_t* n2);
 
+/* count3 + "any byte >= 0x80" in one pass (#1842): the parser's
+ * sizing pre-scan doubles as the UTF-8 fast gate — pure-ASCII input
+ * is valid UTF-8 by construction. Falls back to the scalar loop
+ * where no SIMD path is compiled. */
+void leptris_text_count3_high(const char* s, size_t len,
+                              char c0, char c1, char c2,
+                              size_t* n0, size_t* n1, size_t* n2,
+                              int* saw_high);
+
 /* Copy [src, src+len) to dst while counting c0/c1/c2 occurrences —
  * one fused memory pass (falls back to memcpy + count3 where no
  * SIMD path is compiled). The parser's owns-copy path gets its
@@ -103,6 +112,10 @@ size_t leptris_text_count_char_neon(const char* s, size_t len, char c);
 void leptris_text_count3_neon(const char* s, size_t len,
                               char a, char b, char c,
                               size_t* ca, size_t* cb, size_t* cc);
+void leptris_text_count3_high_neon(const char* s, size_t len,
+                                   char a, char b, char c,
+                                   size_t* ca, size_t* cb, size_t* cc,
+                                   int* saw_high);
 void leptris_copy_count3_neon(char* dst, const char* src, size_t len,
                               char a, char b, char c,
                               size_t* ca, size_t* cb, size_t* cc);