leptris 1.9.380.2 → 1.9.381.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 213b5096ca73813ee05e8816632f5f3f0e0cbae5744b477b5cecb7acae15ad2b
-  data.tar.gz: 23ea9d5f3ddb5f067e5bc90b29599e47df1418336bff8caa1b3fb139202079fe
+  metadata.gz: 600a02350159ac29319d4e4df445bade18bc26489ea6ad3f28dfe118948b366e
+  data.tar.gz: dd081df19fbe1a3ae8b1af6dad80395e2ddbd93aa2ecd488cbee6b059324e910
 SHA512:
-  metadata.gz: ca38fd56c66cf502830190aed494c9371571477c2d4609d93dcc942ff98b7c34503ffe34f61dda5148aa63306f1386b4b99c022d587be5cb6b19e79e103ef8f2
-  data.tar.gz: 07ff974cc3fee133d576d76cbf205422235d6cc7656ade52f0d50453c8cc0232f6d648969e6aa2d3778f15e3417f1a30b75b07e93e8124054b75b47a0c876f62
+  metadata.gz: b5c65806365acbe0bc0aebe358c5267519c71e3e922acecc1ca13fa44a826965f9feba45258286fb10885cb1ad13d77f2f97bead9d027f92ad0f60569086d02a
+  data.tar.gz: a3bdb6971f8e5a16db92ba01cf6d4d55f580e923250b616b9b8b02d3d755485717bc11f8a36b852e4c1526d40002d4117f025325e8672be3a91097ed66b5ec28

data/CHANGELOG.md

@@ -17,6 +17,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.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

@@ -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 */);

data/lib/leptris/version.rb

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

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.2
+  version: 1.9.381.0
 platform: ruby
 authors:
 - Ribose Inc.