leptris 1.9.380.1 → 1.9.381.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 691f29770b6ab11fe0b36b1de8d4119839aea55e77fa7aa484df208e7f2242a3
-  data.tar.gz: 9cab3c91a664ca30ab2252db2c7a3c4e6846461b767391ebdf4fb9a695bf65b7
+  metadata.gz: 600a02350159ac29319d4e4df445bade18bc26489ea6ad3f28dfe118948b366e
+  data.tar.gz: dd081df19fbe1a3ae8b1af6dad80395e2ddbd93aa2ecd488cbee6b059324e910
 SHA512:
-  metadata.gz: 6b6abc7e9b311595fc66e17422fcfceb6cf58ac50dafadfa92c6cd3cfead022c8beb7c1875f9cb2e3a0db39696b6160e8d51abaf2fad671ad7a5cef60ef670c6
-  data.tar.gz: 723cdf249ab1fec0f6f8c0e52549e37366ac605c131fb7b23b6e430db995699297b01445c34e2b6ab08c1ab8d538c180526aa508410339dfb67cbbba05278c83
+  metadata.gz: b5c65806365acbe0bc0aebe358c5267519c71e3e922acecc1ca13fa44a826965f9feba45258286fb10885cb1ad13d77f2f97bead9d027f92ad0f60569086d02a
+  data.tar.gz: a3bdb6971f8e5a16db92ba01cf6d4d55f580e923250b616b9b8b02d3d755485717bc11f8a36b852e4c1526d40002d4117f025325e8672be3a91097ed66b5ec28

data/CHANGELOG.md

@@ -10,6 +10,21 @@
   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.
 
+### Fixed — engine ride (1.9.380.2)
+
+- **Bulk XPath priming face rides (leptris/leptris-ruby#537)**:
+  `xpath_result_rows_bulk` gains the mx_context/mx_adapter birth-prime
+  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.381"
 # 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

data/ext/leptris/native/native.c

@@ -203,6 +203,10 @@ static VALUE binding_klass_for(int kind);
 static VALUE c_iteration_scope;
 static VALUE c_leptris_error;
 static VALUE c_b_document, c_b_freed, c_ffi_pointer;
+/* BulkIdentityRows resolves lazily like the binding classes: the
+ * module lives in native_layer.rb, which optional consumers load. */
+static VALUE c_bulk_rows_mark = Qundef;
+static ID id_bulk_rows_mark;
 static ID id_ptr_new, id_freed_new, id_alive;
 static ID id_iv_c_address, id_iv_document, id_iv_parent;
 static ID id_iv_mx_context, id_iv_mx_adapter, id_iv_mx_native;
@@ -221,8 +225,23 @@ struct native_node {
      * Slot beats the hash memo on repeat reads of one name. */
     VALUE attr_key, attr_val, attr_ver;
     VALUE content_val, content_ver;
+    /* Walk-read memos (leptris-ruby#530): the element name and the
+     * children list, the two reads a tree walk pays per node. The
+     * children memo is what the subtree prime (#527 machinery)
+     * fills; the version stamp retires both on any mutation. The
+     * children list is SHARED with callers until the version moves
+     * (the mutation that would invalidate it also retires the
+     * memo) — treat it as read-only, like an interned String. */
+    VALUE name_val, name_ver;
+    VALUE children_val, children_ver;
 };
 
+static VALUE columnar_node_for(VALUE document, VALUE owner_klass,
+                               void *ptr, int kind);
+static VALUE doc_klass_for_kind(VALUE document, int kind);
+static VALUE nn_prime_children_of(VALUE document, VALUE owner_klass,
+                                  void *node, VALUE ver);
+
 static void nn_mark(void *p)
 {
     struct native_node *n = p;
@@ -234,6 +253,10 @@ static void nn_mark(void *p)
         rb_gc_mark(n->attr_val);
     if (n->content_val != Qnil)
         rb_gc_mark(n->content_val);
+    if (n->name_val != Qnil)
+        rb_gc_mark(n->name_val);
+    if (n->children_val != Qnil)
+        rb_gc_mark(n->children_val);
 }
 
 static size_t nn_size(const void *p) { (void)p; return sizeof(struct native_node); }
@@ -367,7 +390,19 @@ static VALUE nn_name(VALUE self)
 {
     struct native_node *n;
     const char *s;
+    VALUE doc, ver;
+
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    /* Walk-memo hit (leptris-ruby#530): a repeat name read is two
+     * struct reads and a Fixnum compare — the subtree prime fills
+     * this slot ahead of the walk, so walked names never recompute
+     * (or re-intern) until the next mutation. */
+    doc = n->document;
+    if (doc != Qnil) {
+        ver = rb_ivar_get(doc, id_iv_version);
+        if (n->name_ver == ver)
+            return n->name_val;
+    }
     s = f_elem_name(n->ptr);
     /* Interned (shared, frozen) fstring: element names repeat
      * massively across a document — one RString per distinct name
@@ -375,7 +410,13 @@ static VALUE nn_name(VALUE self)
      * ~18% of consumer materialize allocations were fresh name
      * strings). Names are identifiers; nothing downstream mutates
      * them in place (renames mint new strings). */
-    return s ? rb_enc_interned_str(s, strlen(s), rb_utf8_encoding()) : Qnil;
+    VALUE name = s ? rb_enc_interned_str(s, strlen(s), rb_utf8_encoding())
+                   : Qnil;
+    if (doc != Qnil) {
+        n->name_val = name;
+        n->name_ver = ver;
+    }
+    return name;
 }
 
 static VALUE nn_content(VALUE self)
@@ -563,14 +604,43 @@ static VALUE nn_children(VALUE self)
     void **buf;
     int *kinds;
     int count, i;
-    VALUE cache, out, owner_klass;
+    VALUE cache, out, owner_klass, doc, ver;
 
     TypedData_Get_Struct(self, struct native_node, &nn_type, n);
+    /* Walk-memo hit (leptris-ruby#530): the subtree prime (or an
+     * earlier read) filled this node's list against the current
+     * mutation version — serve it, engine walk skipped. */
+    doc = n->document;
+    if (doc != Qnil) {
+        ver = rb_ivar_get(doc, id_iv_version);
+        if (n->children_ver == ver)
+            return n->children_val;
+        /* Registered-consumer documents (#340 doc-klass map = the
+         * moxml mint registration) walk whole subtrees top-down:
+         * the FIRST cold children_read trades itself for ONE
+         * subtree crossing that fills every node's name + children
+         * memo (walk_columnar machinery, native-cache identity —
+         * the primed wrappers ARE the answers later reads give).
+         * Unregistered documents keep the per-node fetch; both
+         * paths memo-store below. */
+        if (!NIL_P(doc_klass_for_kind(doc, NT_ELEMENT))) {
+            out = nn_prime_children_of(doc, rb_obj_class(self), n->ptr,
+                                       ver);
+            n->children_val = out;
+            n->children_ver = ver;
+            return out;
+        }
+    }
     count = fetch_children_two_call(n->ptr, &buf, &kinds);
     if (count <= 0) {
         ruby_xfree(buf);
         ruby_xfree(kinds);
-        return rb_ary_new2(0);
+        out = rb_ary_new2(0);
+        if (doc != Qnil) {
+            n->children_val = out;
+            n->children_ver = ver;
+        }
+        return out;
     }
 
     cache = native_cache_of(n->document);
@@ -592,6 +662,10 @@ static VALUE nn_children(VALUE self)
     }
     ruby_xfree(buf);
     ruby_xfree(kinds);
+    if (doc != Qnil) {
+        n->children_val = out;
+        n->children_ver = ver;
+    }
     return out;
 }
 
@@ -1940,18 +2014,28 @@ static VALUE nf_at_xpath_first(VALUE self, VALUE document,
  * Nodesets free the handle here (TODO.perf/22 eager discipline);
  * non-nodeset results return Qnil UNFREED — the caller keeps the
  * scalar path, whose wrap owns the free. */
-static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
-                                       VALUE result_addr)
+static VALUE nf_xpath_result_rows_bulk(int argc, VALUE *argv, VALUE self)
 {
-    void *result = (void *)(uintptr_t)NUM2ULL(result_addr);
+    VALUE document, result_addr, mx_context, mx_adapter;
+    void *result;
     void **buf;
     int *kinds;
     size_t scount;
     long i, n;
     VALUE cache, out;
+    int all_native;
 
     (void)self;
     resolve_binding_classes();
+    /* Optional (context, adapter): when the consumer passes its
+     * contract state, every registered-klass row is born primed
+     * (@native is the node itself, @context/@adapter written here)
+     * and an all-native result extends with BulkIdentityRows —
+     * the consumer's per-row wrap prime disappears from the
+     * iterate-every-result lane (same triple as nn_create_element). */
+    rb_scan_args(argc, argv, "22", &document, &result_addr,
+                 &mx_context, &mx_adapter);
+    result = (void *)(uintptr_t)NUM2ULL(result_addr);
     if (f_xp_type(result) != 0) /* XPATH_NODESET only */
         return Qnil;
 
@@ -1969,6 +2053,7 @@ static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
     n = (long)scount;
     out = rb_ary_new_capa(n);
     cache = binding_cache_of(document);
+    all_native = !NIL_P(mx_context);
     for (i = 0; i < n; i++) {
         void *ptr = buf[i];
         int tag;
@@ -1988,10 +2073,17 @@ static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
                 node = rb_hash_aref(native_cache_of(document), key);
                 if (NIL_P(node))
                     node = mint_consumer_node(mk, document, ptr);
+                if (all_native &&
+                    !rb_ivar_defined(node, id_iv_mx_context)) {
+                    rb_ivar_set(node, id_iv_mx_native, node);
+                    rb_ivar_set(node, id_iv_mx_context, mx_context);
+                    rb_ivar_set(node, id_iv_mx_adapter, mx_adapter);
+                }
                 rb_ary_push(out, node);
                 continue;
             }
         }
+        all_native = 0;
         node = materialize_xp_entry(document, cache, result, ptr,
                                     kinds[i], (int)i);
         if (node == m_native_sentinel) {
@@ -2005,6 +2097,22 @@ static VALUE nf_xpath_result_rows_bulk(VALUE self, VALUE document,
     ruby_xfree(buf);
     ruby_xfree(kinds);
     f_xp_free(result);
+    if (all_native) {
+        /* Certificate for the consumer's fast row loop: every row
+         * is a born-primed, registered-klass identity native. The
+         * module lives in the Ruby layer (native_layer.rb) and may
+         * not be loaded on faces used without it — an unresolved
+         * mark degrades to the unmarked Array, never an error. */
+        if (c_bulk_rows_mark == Qundef) {
+            VALUE m_xml = rb_path2class("Leptris::XML");
+            c_bulk_rows_mark =
+                rb_const_defined_at(m_xml, id_bulk_rows_mark)
+                    ? rb_const_get_at(m_xml, id_bulk_rows_mark)
+                    : Qnil;
+        }
+        if (c_bulk_rows_mark != Qnil)
+            rb_extend_object(out, c_bulk_rows_mark);
+    }
     return out;
 }
 
@@ -2599,6 +2707,58 @@ static void walk_columnar_impl(VALUE document, VALUE owner_klass,
     }
 }
 
+/* ---- Subtree memo priming (leptris-ruby#530) ---------------------
+ * Registered-consumer documents (the #340 doc-klass map — moxml's
+ * mint registration) walk whole subtrees top-down, so the FIRST
+ * cold children_read fills every ELEMENT's name + children read
+ * memos in ONE crossing, reusing the walk_columnar machinery and
+ * minting through columnar_node_for (native-cache identity — the
+ * primed wrappers ARE the answers later reads hand back). Memos
+ * are version-stamped like the content memo: any mutation bumps
+ * @version and retires them subtree-wide.
+ *
+ * Conservative by construction: only ELEMENT descendants get their
+ * memos filled here (the one kind whose f_first_child chain IS its
+ * children list, the #527 contract); leaf and shell kinds keep the
+ * per-node fetch, which memo-stores the same way. The receiver's
+ * own name memo is left to nn_name (one node, once). */
+static VALUE nn_prime_children_of(VALUE document, VALUE owner_klass,
+                                  void *node, VALUE ver)
+{
+    VALUE out = rb_ary_new();
+    void *c;
+
+    for (c = f_first_child(node); c; c = f_next_sibling(c)) {
+        int kind = f_node_type(c);
+        VALUE wrapper = columnar_node_for(document, owner_klass, c, kind);
+        struct native_node *nn;
+
+        TypedData_Get_Struct(wrapper, struct native_node, &nn_type, nn);
+        if (kind == WS_NODE_ELEMENT) {
+            const char *name = f_elem_name(c);
+            nn->name_val = name ? rb_enc_interned_str(name, strlen(name),
+                                                      rb_utf8_encoding())
+                                : Qnil;
+            nn->name_ver = ver;
+            nn->children_val = nn_prime_children_of(document, owner_klass,
+                                                    c, ver);
+            nn->children_ver = ver;
+        } else if (kind != WS_NODE_DOCTYPE && kind != 9 /* DOCUMENT */) {
+            /* leaf kinds: memo the name exactly as nn_name computes
+             * it (f_elem_name answers "" for nameless kinds); their
+             * (empty) children keep the fetch path, which
+             * memo-stores the same way. */
+            const char *name = f_elem_name(c);
+            nn->name_val = name ? rb_enc_interned_str(name, strlen(name),
+                                                      rb_utf8_encoding())
+                                : Qnil;
+            nn->name_ver = ver;
+        }
+        rb_ary_push(out, wrapper);
+    }
+    return out;
+}
+
 static VALUE nf_walk_columnar(VALUE self, VALUE root)
 {
     struct native_node *n;
@@ -2839,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;
 }
 
@@ -2865,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 */);
@@ -3715,6 +3912,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     id_iv_mx_context = rb_intern("@context");
     id_iv_mx_native = rb_intern("@native");
     id_iv_mx_adapter = rb_intern("@adapter");
+    id_bulk_rows_mark = rb_intern("BulkIdentityRows");
     id_iv_parent = rb_intern("@parent");
     id_iv_structure_memoizable = rb_intern("@structure_memoizable");
     id_iv_native_fast = rb_intern("@native_fast");
@@ -3823,7 +4021,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_module_function(m_native, "materialize_xpath",
                               nf_materialize_xpath, 2);
     rb_define_module_function(m_native, "xpath_result_rows_bulk",
-                              nf_xpath_result_rows_bulk, 2);
+                              nf_xpath_result_rows_bulk, -1);
     rb_define_module_function(m_native, "set_binding_name",
                               nf_set_binding_name, 3);
     rb_define_module_function(m_native, "set_binding_text",

data/lib/leptris/version.rb

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

data/lib/leptris/xml/native_layer.rb

@@ -59,6 +59,19 @@ rescue LoadError => e
   MSG
 end
 
+# Certificate module for the bulk XPath rows face: an Array extended
+# with this carries ONLY born-primed registered-klass identity natives
+# (xpath_result_rows_bulk answered with a consumer context+adapter, so
+# @native is the node itself and @context/@adapter are already set).
+# Consumers with a per-row wrap in their result loop can key a fast
+# path on it (moxml's NodeSet#each); one object per native address
+# remains the binding's native-cache contract (#529) either way.
+module Leptris::XML::BulkIdentityRows
+  def bulk_identity_rows?
+    true
+  end
+end
+
 module Leptris::XML::Native
   # FFI.libleptris_candidates is the single source of truth — the
   # native layer MUST dlsym the exact image the FFI layer loaded,
@@ -118,10 +131,15 @@ class Leptris::XML::Document
   # (nodesets free the handle in C); a non-nodeset result answers
   # nil and leaves the pointer with the caller — route it through
   # Searchable.wrap_xpath_result for the scalar faces.
-  def xpath_result_rows_bulk(result_ptr)
+  # Optional (context, adapter): when the consumer passes its
+  # contract state, every registered-klass row is born primed and an
+  # all-native result extends with BulkIdentityRows — the consumer's
+  # per-row wrap prime disappears from the iterate-every-result lane.
+  def xpath_result_rows_bulk(result_ptr, mx_context = nil, mx_adapter = nil)
     Leptris::XML::Native.xpath_result_rows_bulk(
       self, result_ptr.respond_to?(:address) ? result_ptr.address
-                                             : result_ptr)
+                                             : result_ptr,
+      mx_context, mx_adapter)
   end
 
   # Builder factories that return NativeNodes (#149): one C call

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.381
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,47 @@
 ## [Unreleased]
 
+## [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.381
     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/docs/MISSION-PLAN.md

@@ -58,7 +58,7 @@ from stale build dirs, so the harness protocol is part of the gate.
 | attr listing | ≥ all | 99x — ahead |
 | build | ≥ all | 0.87x — ahead |
 | walk+read (moxml) | ≥ 0.95x nokogiri | **done 2026-10-19** — ~195ns name / ~193ns content, 0.90–0.95x |
-| append / attr-parse (pugixml lane 18) | ≥ parity | **RED 2.0x / 5.9x** — hash-prefilter lever named |
+| append / attr-parse (pugixml lane 18) | ≥ parity | lookup ~parity (rig-bias caveat); **append 1.37x after PR leptris#1836** (was 1.44x self-warmed) — residual = conformance floor (#1436) |
 | DOM mutation rows | ≥ parity | RED — node-layout redesign, owner decision pending |
 | zero-copy text (#1218 lever) | adopt if it wins any row | lever named, unmeasured |
 

data/vendor-src/libleptris/src/leptris/dom/element.c

@@ -59,6 +59,7 @@ LeptrisElement leptris_element_create_with_view(
     memset(elem, 0, sizeof(struct leptris_element));
     elem->base.type = LEPTRIS_NODE_TYPE_ELEMENT;
     char* nm = leptris_sv_to_cstr_pooled(&name_view, pool);
+    if (!nm) return NULL; /* pool OOM — do not store a NULL name */
     elem_set_name(elem, nm);
     elem->name_hash = leptris_name_hash_compute(nm);
     elem->name_len = (name_view.length > 254)
@@ -107,13 +108,16 @@ LeptrisElement leptris_element_create_zero_copy(LeptrisMemoryPool* pool) {
 LeptrisElement leptris_element_create_pooled(const char* name, LeptrisMemoryPool* pool) {
     if (!name || !pool) return NULL;
 
-    /* Pool-owned copy; lives for the document's lifetime. */
-    char* name_copy = leptris_pool_strdup(pool, name);
-    if (!name_copy) return NULL;
-
-    /* Hand ownership to create_with_view via the inplace path so the
-     * name_view points into pool-owned storage, not the caller's buffer. */
-    return leptris_element_create_pooled_inplace(name_copy, pool);
+    /* Lane 18: ONE strlen + ONE pooled copy. The old route strdup'ed
+     * the name into the pool and then handed that copy to the inplace
+     * path, whose with_view call copies the SAME bytes into the pool
+     * again via sv_to_cstr_pooled — the strdup result was orphaned
+     * (never stored on the element), so every fallback-path create
+     * paid a dead strlen + pool alloc + memcpy. Building the view
+     * over the caller's buffer lands on the identical final name
+     * pointer (same pooled copy, same interning behavior). */
+    return leptris_element_create_with_view(leptris_sv_from_cstr(name),
+                                            pool);
 }
 
 /* Free element - pool allocated, so this is a no-op */
@@ -771,22 +775,16 @@ void leptris_element_append_child_hint_doc(LeptrisElement elem,
                                            LeptrisNode* hint) {
     if (!elem || !child) return;
 
-    /* SAFETY: Verify node type field is valid before accessing it
-     * Small values like 0x4 or 0x1 in the type field suggest the pointer is corrupted */
-    if (child->type < LEPTRIS_NODE_TYPE_ELEMENT ||
-        (child->type > LEPTRIS_NODE_TYPE_DOCTYPE &&
-         child->type != LEPTRIS_NODE_TYPE_ENTITY_REF)) {
-        /* Invalid node type - corrupted pointer */
-        return;
-    }
-
-    if (child->type != LEPTRIS_NODE_TYPE_ELEMENT &&
-        child->type != LEPTRIS_NODE_TYPE_TEXT &&
-        child->type != LEPTRIS_NODE_TYPE_CDATA &&
-        child->type != LEPTRIS_NODE_TYPE_COMMENT &&
-        child->type != LEPTRIS_NODE_TYPE_PI &&
-        child->type != LEPTRIS_NODE_TYPE_ENTITY_REF) {
-        return;  /* Only allow these node types as children */
+    /* Type gate, fused (lane 18): the appendable set is
+     * {ELEMENT..PI} ∪ {ENTITY_REF}; the old two-chain form (a range
+     * guard followed by a six-way membership walk) admitted exactly
+     * the same set in ~8 compare/branch pairs. One load + two
+     * compares decide it. */
+    {
+        unsigned t = (unsigned)child->type;
+        if (!(t <= (unsigned)LEPTRIS_NODE_TYPE_PI ||
+              t == (unsigned)LEPTRIS_NODE_TYPE_ENTITY_REF))
+            return; /* corrupted or non-appendable node type */
     }
 
     /* Issue #217: if child is already attached to a parent, unlink
@@ -909,22 +907,16 @@ void leptris_element_append_child_hint_doc(LeptrisElement elem,
 void leptris_element_prepend_child_internal(LeptrisElement elem, LeptrisNode* child) {
     if (!elem || !child) return;
 
-    /* SAFETY: Verify node type field is valid before accessing it
-     * Small values like 0x4 or 0x1 in the type field suggest the pointer is corrupted */
-    if (child->type < LEPTRIS_NODE_TYPE_ELEMENT ||
-        (child->type > LEPTRIS_NODE_TYPE_DOCTYPE &&
-         child->type != LEPTRIS_NODE_TYPE_ENTITY_REF)) {
-        /* Invalid node type - corrupted pointer */
-        return;
-    }
-
-    if (child->type != LEPTRIS_NODE_TYPE_ELEMENT &&
-        child->type != LEPTRIS_NODE_TYPE_TEXT &&
-        child->type != LEPTRIS_NODE_TYPE_CDATA &&
-        child->type != LEPTRIS_NODE_TYPE_COMMENT &&
-        child->type != LEPTRIS_NODE_TYPE_PI &&
-        child->type != LEPTRIS_NODE_TYPE_ENTITY_REF) {
-        return;  /* Only allow these node types as children */
+    /* Type gate, fused (lane 18): the appendable set is
+     * {ELEMENT..PI} ∪ {ENTITY_REF}; the old two-chain form (a range
+     * guard followed by a six-way membership walk) admitted exactly
+     * the same set in ~8 compare/branch pairs. One load + two
+     * compares decide it. */
+    {
+        unsigned t = (unsigned)child->type;
+        if (!(t <= (unsigned)LEPTRIS_NODE_TYPE_PI ||
+              t == (unsigned)LEPTRIS_NODE_TYPE_ENTITY_REF))
+            return; /* corrupted or non-appendable node type */
     }
 
     /* Issue #217: if child is already attached to a parent, unlink

data/vendor-src/libleptris/src/leptris/dom/element_modify.c

@@ -183,7 +183,12 @@ LeptrisElement leptris_element_create(LeptrisDocument doc, const char* name) {
          * Same init contract as leptris_element_create_with_view
          * (memset-zero + type/name/name_hash/name_len). Falls back
          * to the plain pool path when a block can't be allocated. */
-        size_t name_len = strlen(name);
+        /* Lane 18: element names are almost always tiny — a bounded
+         * byte scan resolves the length without the strlen call;
+         * anything 8+ bytes pays the same strlen as before. */
+        size_t name_len = 0;
+        while (name_len < 8 && name[name_len]) name_len++;
+        if (name_len == 8 && name[8]) name_len = strlen(name);
         elem = mut_elem_carve(doc);
         if (elem) {
             char* name_copy = mut_name_carve(doc, name, name_len);
@@ -469,6 +474,11 @@ LeptrisStatus leptris_element_add_child_addr_installed(
 LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement child) {
     if (!parent || !child) return LEPTRIS_ERROR_NULL_ARG;
 
+    /* Single document resolution per mutation (TODO 195c): the
+     * root walk + map lookup was paid three times per append
+     * (twice here, once inside the internal for the tail cache). */
+    struct leptris_document* doc = leptris_element_get_document(parent);
+
     /* #1636: appending a node into its own descendant subtree
      * builds a parent cycle — every tree walker (serializer
      * first) then recurses without bound and the process dies
@@ -477,9 +487,24 @@ LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement
      * ancestor edge: walk child's parent chain for parent. The
      * same-document fast path below never sees foreign copies as
      * ancestors, so the walk runs on the caller's node — O(depth),
-     * depth bounded by the parse cap. */
-    {
-        if (parent == child) return LEPTRIS_ERROR_INVALID_ARG;
+     * depth bounded by the parse cap.
+     *
+     * Lane 18: the freshness probe below runs FIRST. A child is
+     * provably childless — and therefore cannot be an ancestor of
+     * parent (nor equal any node that has descendants) — only when
+     * BOTH hold: it was carved from the current mut block (recent
+     * create) AND its child list is still empty. The extent alone is
+     * NOT enough: a block-extent element may have been given
+     * children since its create, and appending an ancestor under its
+     * own descendant must keep rejecting. parent == child stays
+     * unconditional and the walk still sees the ORIGINAL child
+     * before any #1528 adoption, so accept/reject decisions are
+     * identical to the unconditioned guard. */
+    int child_fresh = node_in_current_mut_block(doc, child) &&
+                      (leptris_elem_first_child(child) == NULL);
+
+    if (parent == child) return LEPTRIS_ERROR_INVALID_ARG;
+    if (!child_fresh) {
         LeptrisElement p = leptris_element_parent(parent);
         int guard = 0;
         while (p && guard++ < 8192) {
@@ -488,11 +513,6 @@ LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement
         }
     }
 
-    /* Single document resolution per mutation (TODO 195c): the
-     * root walk + map lookup was paid three times per append
-     * (twice here, once inside the internal for the tail cache). */
-    struct leptris_document* doc = leptris_element_get_document(parent);
-
     /* #1528: a foreign document's node is adopted by copy, never
      * spliced raw. The freshly-created-then-appended shape proves
      * same-doc in two hot loads: a child inside the CURRENT mut
@@ -500,7 +520,7 @@ LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement
      * THIS document's block by the create call just executed — no
      * foreign allocation can live inside it. Everything else takes
      * the full check (Lane 18 append bar). */
-    if (!(node_in_current_mut_block(doc, child))) {
+    if (!child_fresh) {
         child = (LeptrisElement)adopt_for_splice((LeptrisNode*)child,
                                                  doc);
         if (!child) return LEPTRIS_ERROR_MEMORY;

data/vendor-src/libleptris/src/leptris/xpath/evaluator_path.c

@@ -508,6 +508,21 @@ static void doc_rank_table_free(DocOrderRankTable* t) {
     free(t->ranks);
 }
 
+/* Mix the pointer before masking. Pool nodes are allocated at a
+ * fixed stride, so the old (ptr >> 4) & mask sent every key to the
+ * same residue class: with a power-of-two capacity and 64/96-byte
+ * strides, only a fraction of the slots were ever reachable and
+ * linear probing degenerated. A 500k-node identity transform spent
+ * 872 ms in the rank build; mixing makes the same build O(1) per
+ * insert. */
+static size_t doc_rank_slot(const void* key, size_t mask) {
+    uint64_t x = (uint64_t)(uintptr_t)key;
+    x ^= x >> 33;
+    x *= 0xff51afd7ed558ccdULL;
+    x ^= x >> 33;
+    return (size_t)x & mask;
+}
+
 /* Grow at 70% load so probe chains stay short. */
 static int doc_rank_table_grow(DocOrderRankTable* t) {
     size_t new_cap = (t->mask + 1) << 1;
@@ -521,7 +536,7 @@ static int doc_rank_table_grow(DocOrderRankTable* t) {
     size_t new_mask = new_cap - 1;
     for (size_t i = 0; i <= t->mask; i++) {
         if (!t->keys[i]) continue;
-        size_t j = (size_t)(((uintptr_t)t->keys[i] >> 4) & new_mask);
+        size_t j = doc_rank_slot(t->keys[i], new_mask);
         while (new_keys[j]) j = (j + 1) & new_mask;
         new_keys[j] = t->keys[i];
         new_ranks[j] = t->ranks[i];
@@ -538,7 +553,7 @@ static int doc_rank_table_put(DocOrderRankTable* t, void* key, int64_t rank) {
     if ((t->count + 1) * 10 >= (t->mask + 1) * 7) {
         if (!doc_rank_table_grow(t)) return 0;
     }
-    size_t i = (size_t)(((uintptr_t)key >> 4) & t->mask);
+    size_t i = doc_rank_slot(key, t->mask);
     while (t->keys[i]) {
         if (t->keys[i] == key) return 1;  /* first visit wins */
         i = (i + 1) & t->mask;
@@ -550,7 +565,7 @@ static int doc_rank_table_put(DocOrderRankTable* t, void* key, int64_t rank) {
 }
 
 static int64_t doc_rank_table_get(const DocOrderRankTable* t, void* key) {
-    size_t i = (size_t)(((uintptr_t)key >> 4) & t->mask);
+    size_t i = doc_rank_slot(key, t->mask);
     while (t->keys[i]) {
         if (t->keys[i] == key) return t->ranks[i];
         i = (i + 1) & t->mask;

data/vendor-src/libleptris/src/leptris/xsd/validate.c

@@ -423,8 +423,25 @@ static void validate_children(struct xsd_validator* v,
                 }
             }
         }
-        if (ptype)
+        /* leptris-ruby#535 (XSD 1.0 2.6.2): xsi:type applies at every
+         * assessed depth -- a child typed by the parent particle is
+         * substituted exactly like a globally declared one (which
+         * validate_element above already handles). */
+        const char* cxsi = leptris_element_attribute_ns(
+            ce, "http://www.w3.org/2001/XMLSchema-instance", "type");
+        if (cxsi && cxsi[0] && ptype) {
+            char xuri[512], xlocal[256];
+            xsd_resolve_qname_inst(ce, cxsi, xuri, sizeof(xuri),
+                                   xlocal, sizeof(xlocal));
+            if (!xlocal[0]) {
+                verrf_at(v, ce, "element", cl,
+                         "xsi:type prefix is not bound in the instance");
+            } else {
+                validate_local_uri(v, s, ce, cl, xlocal, xuri, cxsi);
+            }
+        } else if (ptype) {
             validate_local(v, s, ce, cl, ptype);
+        }
     }
 }
 

data/vendor-src/libleptris/src/leptris/xslt/xslt_exec.c

@@ -1011,6 +1011,15 @@ static int op_result_elem(XsltExec* ex, const XsltInstr* in,
         }
     }
     ex->pending_parent = parent;
+    /* The content ran only inside e (append-only, strictly nested),
+     * so e is `parent`'s newest child — hand it back as the next
+     * append's tail hint (the single-entry pair otherwise points at
+     * the deepest node the body built, and each append to a wide
+     * parent then walks its whole child chain, #682). */
+    if (parent) {
+        ex->last_append_parent = parent;
+        ex->last_append_child = (LeptrisNodeRef)e;
+    }
     return rc;
 }
 
@@ -2691,6 +2700,16 @@ static int op_copy(XsltExec* ex, const XsltInstr* in, LeptrisElement node) {
     ex->pending_parent = e;
     int rc = xslt_exec_instrs(ex, in->child, node);
     ex->pending_parent = saved;
+    /* Result-tree construction is append-only and strictly nested,
+     * so `e` is `saved`'s newest child when the body returns — hand
+     * it back as the next append's tail hint. The single-entry pair
+     * otherwise points at the deepest node the body built, and each
+     * append to a wide parent then walks that parent's whole child
+     * chain (quadratic identity transforms, #682). */
+    if (saved) {
+        ex->last_append_parent = saved;
+        ex->last_append_child = (LeptrisNodeRef)e;
+    }
     return rc;
 }
 
@@ -2763,21 +2782,27 @@ static int copy_node_deep(XsltExec* ex, LeptrisElement node,
             LeptrisNodeRef cc = (LeptrisNodeRef)leptris_cdata_create(
                 t, t ? strlen(t) : 0,
                 ((struct leptris_document*)ex->result)->pool);
-            if (cc) leptris_element_append_child_internal(e, (LeptrisNode*)cc);
+            if (cc) out_append_child(ex, e, (void*)cc);
         } else if (ty == LEPTRIS_NODE_TYPE_COMMENT) {
             LeptrisNodeRef cm = leptris_comment_node_create(
                 ex->result, leptris_comment_node_get_content(c));
-            if (cm) leptris_element_append_child_internal(e, (LeptrisNode*)cm);
+            if (cm) out_append_child(ex, e, (void*)cm);
         } else if (ty == LEPTRIS_NODE_TYPE_PI) {
             LeptrisNodeRef pi = leptris_pi_node_create(
                 ex->result, leptris_pi_node_get_target(c),
                 leptris_pi_node_get_data(c));
-            if (pi) leptris_element_append_child_internal(e, (LeptrisNode*)pi);
+            if (pi) out_append_child(ex, e, (void*)pi);
         } else if (ty == LEPTRIS_NODE_TYPE_TEXT) {
             const char* t = leptris_text_get_content((LeptrisTextNode*)c);
             if (t && t[0]) out_append_text(ex, e, t);
         }
     }
+    /* The caller's newest child is e — hand it back as the tail
+     * hint so sibling copies append O(1) (see op_copy). */
+    if (parent) {
+        ex->last_append_parent = parent;
+        ex->last_append_child = (LeptrisNodeRef)e;
+    }
     return 0;
 }
 
@@ -3515,6 +3540,10 @@ static int builtin_no_match(XsltExec* ex, const char* mode,
         &(XsltInstr){ .kind = XSLT_INSTR_APPLY_TEMPLATES, .name = mode },
         node);
     ex->pending_parent = saved_parent;
+    if (saved_parent && e) {
+        ex->last_append_parent = saved_parent;
+        ex->last_append_child = (LeptrisNodeRef)e;
+    }
     return rc;
 }
 
@@ -3876,6 +3905,16 @@ static int op_element(XsltExec* ex, const XsltInstr* in,
     ex->pending_parent = e;
     int rc = xslt_exec_instrs(ex, in->child, node);
     ex->pending_parent = saved;
+    /* Result-tree construction is append-only and strictly nested,
+     * so `e` is `saved`'s newest child when the body returns — hand
+     * it back as the next append's tail hint. The single-entry pair
+     * otherwise points at the deepest node the body built, and each
+     * append to a wide parent then walks that parent's whole child
+     * chain (quadratic identity transforms, #682). */
+    if (saved) {
+        ex->last_append_parent = saved;
+        ex->last_append_child = (LeptrisNodeRef)e;
+    }
     return rc;
 }
 

data/vendor-src/libleptris/src/leptris/xslt/xslt_pattern.c

@@ -59,6 +59,22 @@ static int parse_pat_step(const char** pp, const char* end,
     if (*p == '@') { s->is_attr = 1; p++; }
     if (p < end && *p == '*') {
         p++;
+    /* Node-type tests FIRST: "node(" also starts with an NCName, so
+     * the name branch below would swallow the keyword and then fail
+     * on its '(' — leaving steps_valid=0 and sending every match of
+     * node()/text()/comment()/processing-instruction() into the
+     * ancestor ladder (O(width) per node: the identity transform's
+     * @*|node() went quadratic). The bare names "node"/"text" still
+     * parse as name tests: the keyword check requires the '('. */
+    } else if (p + 5 <= end && strncmp(p, "node(", 5) == 0) {
+        s->kind = 1; p += 5;
+    } else if (p + 5 <= end && strncmp(p, "text(", 5) == 0) {
+        s->kind = 2; p += 5;
+    } else if (p + 8 <= end && strncmp(p, "comment(", 8) == 0) {
+        s->kind = 3; p += 8;
+    } else if (p + 23 <= end &&
+               strncmp(p, "processing-instruction(", 23) == 0) {
+        s->kind = 4; p += 23;
     } else if (p < end && ncname_char(*p) && *p != '-') {
         const char* st = p;
         while (p < end && ncname_char(*p)) p++;
@@ -72,15 +88,6 @@ static int parse_pat_step(const char** pp, const char* end,
         if (!s->name) return 0;
         memcpy(s->name, st, n);
         s->name[n] = 0;
-    } else if (p + 5 <= end && strncmp(p, "node(", 5) == 0) {
-        s->kind = 1; p += 5;
-    } else if (p + 5 <= end && strncmp(p, "text(", 5) == 0) {
-        s->kind = 2; p += 5;
-    } else if (p + 8 <= end && strncmp(p, "comment(", 8) == 0) {
-        s->kind = 3; p += 8;
-    } else if (p + 21 <= end &&
-               strncmp(p, "processing-instruction(", 23 - 2) == 0) {
-        s->kind = 4; p += 21;
     } else {
         return 0;
     }

data/vendor-src/libleptris/test/dom/test_dom.cpp

@@ -2966,6 +2966,48 @@ TEST(DomCycleGuard, AncestorAppendRejected) {
     leptris_document_free(d);
 }
 
+/* Lane 18: the append path skips the #1636 ancestor walk when the
+ * child is provably childless (fresh mut-block carve AND empty
+ * child list). An element still sitting inside the mut-block
+ * extent is NOT automatically childless — it may have been given
+ * children since its create — so the walk must still run for it.
+ * Regression pin for the first cut, which keyed the skip on the
+ * extent alone and ACCEPTED root-under-b for mutation-built
+ * trees (parse-built trees never enter the mut block, which is
+ * why the parse-only specs above could not see it). */
+TEST(DomCycleGuard, AncestorAppendRejectedInMutBlockExtent) {
+    LeptrisDocument d = leptris_document_create();
+    ASSERT_NE(d, nullptr);
+    LeptrisElement root = leptris_element_create(d, "root");
+    ASSERT_NE(root, nullptr);
+    ASSERT_EQ(leptris_document_set_root(d, root), LEPTRIS_OK);
+    LeptrisElement a = leptris_element_create(d, "a");
+    LeptrisElement b = leptris_element_create(d, "b");
+    ASSERT_NE(a, nullptr);
+    ASSERT_NE(b, nullptr);
+    ASSERT_EQ(leptris_element_append_child(root, a), LEPTRIS_OK);
+    ASSERT_EQ(leptris_element_append_child(a, b), LEPTRIS_OK);
+
+    /* all three still sit in the current mut-block extent here —
+     * the guard must not trust the extent as childlessness */
+    EXPECT_EQ(leptris_element_append_child(b, root),
+              LEPTRIS_ERROR_INVALID_ARG);
+    EXPECT_EQ(leptris_element_append_child(a, a),
+              LEPTRIS_ERROR_INVALID_ARG);
+    EXPECT_EQ(leptris_element_prepend_child(b, root),
+              LEPTRIS_ERROR_INVALID_ARG);
+
+    /* fresh create->append (the fast-path shape) still links */
+    LeptrisElement c = leptris_element_create(d, "c");
+    ASSERT_NE(c, nullptr);
+    EXPECT_EQ(leptris_element_append_child(b, c), LEPTRIS_OK);
+    char* out = leptris_document_serialize(d, nullptr);
+    ASSERT_NE(out, nullptr);
+    EXPECT_NE(strstr(out, "<b><c/></b>"), nullptr);
+    leptris_free_string(out);
+    leptris_document_free(d);
+}
+
 TEST(DomCycleGuard, InsertIntoOwnSubtreeRejected) {
     LeptrisStatus st = LEPTRIS_OK;
     LeptrisDocument d =

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -2855,4 +2855,94 @@ TEST(XsdConformanceClauses, XsiTypeUnknownTypeIsLoud) {
     leptris_xsd_free(s);
 }
 
+TEST(XsdConformanceClauses, XsiTypeAtDepthGlobalChild) {
+  const char schema[] =
+      "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+      " targetNamespace=\"urn:t\" xmlns=\"urn:t\""
+      " elementFormDefault=\"qualified\">"
+      " <xs:complexType name=\"Base\">"
+      "  <xs:sequence><xs:element name=\"a\" type=\"xs:string\"/></xs:sequence>"
+      " </xs:complexType>"
+      " <xs:complexType name=\"Derived\">"
+      "  <xs:complexContent>"
+      "   <xs:extension base=\"Base\">"
+      "    <xs:sequence><xs:element name=\"b\" type=\"xs:string\"/></xs:sequence>"
+      "   </xs:extension>"
+      "  </xs:complexContent>"
+      " </xs:complexType>"
+      " <xs:element name=\"doc\" type=\"Base\"/>"
+      " <xs:element name=\"wrap\">"
+      "  <xs:complexType>"
+      "   <xs:sequence><xs:element ref=\"doc\"/></xs:sequence>"
+      "  </xs:complexType>"
+      " </xs:element>"
+      "</xs:schema>";
+  LeptrisXsdSchema s = compile_string(schema);
+  ASSERT_NE(s, (LeptrisXsdSchema)0);
+  /* leptris-ruby#535 depth case, global-declaration child: the
+   * child walk re-enters validate_element, which reads xsi:type.
+   * The prefix resolves through the ROOT's declaration -- in
+   * scope, not just the bearing element's own. */
+  EXPECT_EQ(validate_compiled(
+                s,
+                "<wrap xmlns=\"urn:t\" xmlns:i=\"urn:t\""
+                " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
+                "<doc xsi:type=\"i:Derived\"><a>x</a><b>y</b></doc></wrap>"),
+            1)
+      << "xsi:type must be honored on a global child below the root";
+  /* the declared type governs without xsi:type: b is out of Base. */
+  EXPECT_EQ(validate_compiled(
+                s, "<wrap xmlns=\"urn:t\"><doc><a>x</a><b>y</b></doc></wrap>"),
+            0);
+  leptris_xsd_free(s);
+}
+
+TEST(XsdConformanceClauses, XsiTypeAtDepthParticleTypedChild) {
+  const char schema[] =
+      "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+      " targetNamespace=\"urn:t\" xmlns=\"urn:t\""
+      " elementFormDefault=\"qualified\">"
+      " <xs:complexType name=\"Base\">"
+      "  <xs:sequence><xs:element name=\"a\" type=\"xs:string\"/></xs:sequence>"
+      " </xs:complexType>"
+      " <xs:complexType name=\"Derived\">"
+      "  <xs:complexContent>"
+      "   <xs:extension base=\"Base\">"
+      "    <xs:sequence><xs:element name=\"b\" type=\"xs:string\"/></xs:sequence>"
+      "   </xs:extension>"
+      "  </xs:complexContent>"
+      " </xs:complexType>"
+      " <xs:element name=\"wrap\">"
+      "  <xs:complexType>"
+      "   <xs:sequence><xs:element name=\"doc\" type=\"Base\"/></xs:sequence>"
+      "  </xs:complexType>"
+      " </xs:element>"
+      "</xs:schema>";
+  LeptrisXsdSchema s = compile_string(schema);
+  ASSERT_NE(s, (LeptrisXsdSchema)0);
+  /* leptris-ruby#535 depth case, local particle: no global `doc`
+   * exists, so the child is typed by wrap's particle -- xsi:type
+   * must still substitute Derived's model at that depth. */
+  EXPECT_EQ(validate_compiled(
+                s,
+                "<wrap xmlns=\"urn:t\" xmlns:i=\"urn:t\""
+                " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
+                "<doc xsi:type=\"i:Derived\"><a>x</a><b>y</b></doc></wrap>"),
+            1)
+      << "xsi:type must substitute on a particle-typed child too";
+  /* the named type's own constraint applies: Derived needs b. */
+  EXPECT_EQ(validate_compiled(
+                s,
+                "<wrap xmlns=\"urn:t\" xmlns:i=\"urn:t\""
+                " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
+                "<doc xsi:type=\"i:Derived\"><a>x</a></doc></wrap>"),
+            0);
+  /* without xsi:type the declared particle type governs: b is out
+   * of Base's model. */
+  EXPECT_EQ(validate_compiled(
+                s, "<wrap xmlns=\"urn:t\"><doc><a>x</a><b>y</b></doc></wrap>"),
+            0);
+  leptris_xsd_free(s);
+}
+
 }  // namespace

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.380",
+  "version": "1.9.381",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.380.1
+  version: 1.9.381.0
 platform: ruby
 authors:
 - Ribose Inc.