leptris 1.9.380.2-arm-linux → 1.9.382.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db3ec4fdfeddcf213dff77dd14341bffd1dad711ea60877e08cdd0adad3fb05c
-  data.tar.gz: cfff61372aebafdcb8911bfc554107cc5816a03beca575fc50c3c5640a08f5d0
+  metadata.gz: eeb080a56ba2f644ba7219077f866627006b2d5e8ea80405a86a17cff5853737
+  data.tar.gz: 8498da423561b35ddfabe900ae828df3ee9f9963c1498ac90cbb543f73c4c58e
 SHA512:
-  metadata.gz: 0d11c5af4528032ee1b067bd7433dad8ad7b4f4cce9e986794ecf8f5075ab1f7307e349c8cc1e0b76b1d325f4792ba56fd75d0f043c8032f1a55572ab010e7f1
-  data.tar.gz: 807a7f8407a86c141810f4ec074ef473ef8bdf846d3441e752239ccfaac27d0712de57c4fa628504e86bdcd63e19fef1ecc38d5650888e4e82531e09b2c916fa
+  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
@@ -17,6 +43,14 @@
   parameters and marks all-native results; 1.9.380.1 shipped before
   the PR merged, so the face rides in 1.9.380.2.
 
+## [1.9.381.0] - 2026-10-22
+
+Ride: libleptris 1.9.381 — the XSLT identity/copy-of quadratic fix
+(#1839): identity transforms 13.0 s -> 57 ms on a 20k-book catalog;
+every CLI row now beats xsltproc end-to-end. The Rakefile pin moves
+1.9.380 -> 1.9.381 in the same commit so the platform gems vendor
+this core.
+
 ## [1.9.379.3] - 2026-10-22
 
 ### Fixed

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.380"
+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

@@ -2999,18 +2999,41 @@ static void *create_elem_core(void *doc_ptr, void *parent,
     return elem;
 }
 
+/* leptris-ruby#539: the ATTACHED construction faces are
+ * wrapper-visible mutations — they splice a built child under a
+ * parent — so they run the same freed/readonly gates and version
+ * bump as every other write face (bump before the call: a failed
+ * mutation merely discards memos). The raw-address face keeps the
+ * legacy Integer-document contract (moxml's pre-#340 callers pass
+ * doc.c_address): a bare engine address cannot reach the Document
+ * object, so the gate runs only when the caller names it. */
 static VALUE nf_create_element_with_attrs(VALUE self, VALUE document,
                                           VALUE parent_addr, VALUE name,
                                           VALUE attrs)
 {
-    void *doc_ptr = NIL_P(document)
-                        ? NULL
-                        : (void *)(uintptr_t)NUM2ULL(document);
-    void *parent = NIL_P(parent_addr)
-                       ? NULL
-                       : (void *)(uintptr_t)NUM2ULL(parent_addr);
-    void *elem = create_elem_core(doc_ptr, parent,
-                                  StringValueCStr(name), attrs);
+    void *doc_ptr;
+    void *parent;
+    void *elem;
+
+    parent = NIL_P(parent_addr)
+                 ? NULL
+                 : (void *)(uintptr_t)NUM2ULL(parent_addr);
+    if (!NIL_P(document) && !RB_INTEGER_TYPE_P(document)) {
+        if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+            rb_raise(c_use_after_free_error,
+                     "owning document has been freed");
+        /* The bump rides the ATTACH: a free-floating create mutates
+         * no tree (detached-create discipline, no bump). */
+        if (parent)
+            document_advance_version(document);
+        doc_ptr = doc_ptr_of(document);
+    } else {
+        doc_ptr = NIL_P(document)
+                      ? NULL
+                      : (void *)(uintptr_t)NUM2ULL(document);
+    }
+    elem = create_elem_core(doc_ptr, parent,
+                            StringValueCStr(name), attrs);
     return elem ? ULL2NUM((uintptr_t)elem) : Qnil;
 }
 
@@ -3025,15 +3048,29 @@ static VALUE nf_create_element_with_attrs_wrapped(
     VALUE self, VALUE document, VALUE parent_addr, VALUE name,
     VALUE attrs)
 {
-    void *doc_ptr = doc_ptr_of(document);
-    void *parent = NIL_P(parent_addr)
-                       ? NULL
-                       : (void *)(uintptr_t)NUM2ULL(parent_addr);
-    void *elem = create_elem_core(doc_ptr, parent,
-                                  StringValueCStr(name), attrs);
+    void *doc_ptr;
+    void *parent;
+    void *elem;
     VALUE ck, key, node, cache;
 
     (void)self;
+    parent = NIL_P(parent_addr)
+                 ? NULL
+                 : (void *)(uintptr_t)NUM2ULL(parent_addr);
+    if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    /* #539: attached construction bumps the version — the same
+     * discipline as append_binding_child (bump before the call; a
+     * failed mutation merely discards memos) — so version-stamped
+     * memos (C content, walk-reads) retire across the splice.
+     * Free-floating creates (parent_addr 0) mutate no tree and
+     * stay bump-free, like the detached create faces. */
+    if (parent)
+        document_advance_version(document);
+    doc_ptr = doc_ptr_of(document);
+    elem = create_elem_core(doc_ptr, parent,
+                            StringValueCStr(name), attrs);
     if (!elem) return Qnil;
     resolve_binding_classes();
     ck = doc_klass_for_kind(document, 0 /* element */);
@@ -3057,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;
@@ -3502,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;
@@ -3928,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
@@ -3944,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.380.2"
+  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.380
+- libleptris v1.9.382
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,75 @@
 ## [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
+workload users actually run. The identity transform
+(`match="@*|node()"` + `xsl:copy`) was quadratic: 13.0 s where
+xsltproc takes 65 ms on a 20k-book catalog. Three independent causes
+went in PR #1839, and every measured CLI row now beats xsltproc
+end-to-end:
+
+| stylesheet (20k-book catalog) | xsltproc 1.1.35 | 1.9.380 | 1.9.381 |
+| --- | --- | --- | --- |
+| identity `@*|node()` | 64.5 ms | 13,002 ms | **56.9 ms** |
+| `copy-of //book` | 37.2 ms | 58.8 ms | **25.3 ms** |
+| dispatch (apply-templates) | 63.8 ms | 23.5 ms | **23.6 ms** |
+| 1,000-template sheet | 293.8 ms | 18.7 ms | **17.6 ms** |
+
+### Fixed
+
+- apply xsi:type at every depth in whole-instance validation: an
+  instance document may pin a derived type on any element via
+  `xsi:type`; validation previously honored it only at the root, so
+  deeper particles validated against the declared type (#1838)
+
+### Performance
+
+- **xslt: identity transforms and copy-of were quadratic (#1839).**
+  Three fixes: (1) the pattern fast path never compiled node-type
+  tests — `node(`/`text(`/`processing-instruction(` parsed as NCName
+  and failed on the paren, sending every match through the quadratic
+  ancestor ladder (and `processing-instruction(` compared 21 of its
+  23 prefix characters); (2) the document-order rank table hashed
+  pointers by low bits, which degenerates on fixed-stride pool
+  allocations (872 ms to build for a 500k-node transform); (3) the
+  append-tail pair pointed at the deepest node a body built, so wide
+  parents re-walked their whole child chain on every append after an
+  interleaved child. Full suite 2103/2103, libxslt-205 output parity
+  included.
+- dom: lane-18 append/create micro-levers from a fresh profile
+  (#1836)
+
+
+
 ## [1.9.380] - 2026-10-22
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/TODO.SOTA.md

@@ -106,7 +106,11 @@ Harness `wt/460-harness/build_bench.rb`; A/B pairs alternate within
 ONE window (drift ±20%). Rejected within noise: fast_attach,
 native-cache deletion, doc_klass memo, identity-probe deletion,
 add_child alias. Residual: wrapper allocation (owner-level node
-layout).
+layout). **Allocation census 2026-10-22: AT FLOOR** — moxml
+0.06 minor GC/build vs nokogiri 0.39 (6.5x fewer), 3420 objects vs
+9907; every named suspect eliminated by the levers; the non-floor
+remainder is 17 objects/build (~0.1% CPU). No lever remains — the
+gap is the wrapper-count/identity-contract decision.
 - [ ] per-element object budget: one Ruby object per created node
       (drop the shell entirely post-create-priming; the mint cache
       insert policy; the context registration)
@@ -138,7 +142,19 @@ three interleaved-median runs (`wt/460-harness/pipeline_bench.rb`,
       build, serialize medians, fail on >5% regression)
 
 ### B5 remaining red rows
-- [ ] pugixml lane-18 append/attr-parse (2.0x/5.9x; hash prefilter)
+- [x] pugixml lane-18 append/attr-parse — **re-dated 2026-10-22: the
+      2.0x/5.9x rows no longer exist.** The named levers shipped in
+      the prior 22-round campaign (dup-check hash PR #1413, FNV-fused
+      lookup PR #1425, append parity PR #1533). Attr-lookup
+      ~parity (0.99x; caveat: in-process rigs let leptris's teardown
+      depress the adjacent pugixml row — self-warmed rigs are the
+      honest numbers). Append: **1.44x on self-warmed rigs; 1.37x
+      after PR leptris#1836** (4 behavior-identical levers: childless-
+      proof ancestor-walk skip, fused type chains, bounded name scan,
+      create_pooled double-copy fix; −3.6%, 9/10 pairs). Residual
+      ~1.37x parse gap = conformance features pugixml doesn't do
+      (dup detection, error positions, NUL writes) — the measured
+      floor; owner decision in #1436.
 - [ ] zero-copy text lever (#1218) — adopt if it wins any row
 
 ## Gate C — Safety: trust is auditable

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).