leptris 1.9.265.0 → 1.9.268.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5549f821f7f1ba7a4d5c161680e4535d439938b0d0d5220417e636b684805719
-  data.tar.gz: d7cb676a13bbce365e0f704e8cee85d006318071867040b3a6f87b29f90379ba
+  metadata.gz: cba1727210a6adce592d6f84970bfcf2abb6b0cd6bba396bfc5714e0b6a2c00e
+  data.tar.gz: f8669f950703f4a01fbabc3feef084911a22ef169ec8c6debfe14f057579b591
 SHA512:
-  metadata.gz: 88f706c894390f015bb8501e711a3063d5ae0d1588d5319e2606cdfa79fe1a657da37dda758a85b79833d172ccdc075fe1f61f5a300b42652f51d71b088516d1
-  data.tar.gz: a99096295f37ed317e9201400f273c76f94f29d78602cec42f8eba9bc4d4808d7cfa99a646cb11e7392ed4defbc7ea2e4f5be8e690c339ac73ddb257bc4c7ab8
+  metadata.gz: c3441867d08747f3ed67559e68c29e1c9b1a33b0df9ab29d919580d149a696ff422e20a339611ce52ea2e768c7dfe6ecc9881f5cd20e4575f8bcf7b59adb2fcb
+  data.tar.gz: 8421fd0b02bdd2a321bc998e75bddbf07aec3597740618fa38008b811b61e7726357323ae91c893d1b714ce233290b1055a2c8239dc1d0d0dc53bcdc412bae5d

data/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.268.0] - 2026-09-29
+
+### Performance — engine sync (1.9.266-1.9.268)
+
+- Vendored libleptris 1.9.268: three DOM access rounds.
+  - The child-iteration cache: indexed child access resumes from a
+    per-element generation-validated slot instead of re-walking —
+    CI Child Access 0.34x -> 2.42x vs pugixml, Tree Walking 5.81x;
+    the cache now materializes lazily for attribute-free parents
+    too (the plain wide-catalog case was an O(N^2) re-walk per
+    call: 148s -> 0.77s on the 96 KB fixture).
+  - Bare-name attribute lookup skips prefixed attributes via the
+    TODO 173 ns-cache invariant — 14.5 -> 8.8 ns/query, 1.15x
+    pugixml.
+
 ## [1.9.265.0] - 2026-09-28
 
 ### 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.265"
+LIBLEPTRIS_VERSION = "1.9.268"
 # 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/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.265.0"
+  VERSION = "1.9.268.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.265
+- libleptris v1.9.268
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## [Unreleased]
 
+## [1.9.268] - 2026-09-28
+
+### Performance
+
+- dom: the child-iteration cache is now materialized lazily for attribute-free parents. The round-13 resume slot only engaged for elements carrying namespace state, so indexed child access on a plain wide parent (`<catalog>` with a thousand `<product>` children) was still an O(N^2) full re-walk per call — dom_benchmark_v2's Child Access row measured 148 SECONDS on the 96 KB catalog fixture (CI's 1 KB fixture hid it entirely). `child()` now carves the cache from the element's pool on first indexed access; the mutation-invalidation contract is unchanged and pinned by a new spec plus a tightened (18x -> 6x) perf guard watched failing first. Same fixture after: 0.77 s (~190x). CI artifacts now show all three access rows AHEAD of pugixml on ubuntu: Child 2.42x, Attribute 1.45x, Tree Walking 5.81x.
+
+
+
+## [1.9.267] - 2026-09-28
+
+### Performance
+
+- dom: bare-name attribute lookup rebuilt on the TODO 173 invariant — an attribute carries a side ns cache only when its name contains a colon, so the query walk skips prefixed attributes with a single int32 load and the per-attribute colon-probe loop is gone entirely. The finder is always-inline and the needle is hashed in the same pass as its length+colon scan (`attr_hash15_finish` split out as the shared finalizer). Attr-only arm64 harness: 14.5 -> 8.8 ns/query vs pugixml 7.4 (1.94x -> 1.15x).
+
+
+
+## [1.9.266] - 2026-09-28
+
+### Performance
+
+- dom: child-iteration cache for indexed child access. `leptris_element_child(parent, i)` no longer re-walks from the first child on every call — it resumes from a per-element slot (generation-validated; every child-list mutator invalidates) so sequential indexed access is O(1) per step, and sibling hops skip the generic node type-switch via the shared edge tables. CI dom_benchmark_v2 Child Access: 0.34x -> 2.02x vs pugixml (ubuntu leg); Tree Walking 4.94x.
+
+
+
 ## [1.9.265] - 2026-09-28
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -219,12 +219,7 @@ static inline void leptris_attr_set_next(struct leptris_attribute* a,
  * low bits sit under the multiply's carry chain; the upper half
  * mixes better). Returns nonzero: 0 maps to 1 so the "uncomputed"
  * sentinel stays unambiguous. */
-static inline uint16_t attr_hash15(const char* s, size_t len) {
-    uint32_t h = 2166136261u;
-    for (size_t i = 0; i < len; i++) {
-        h ^= (unsigned char)s[i];
-        h *= 16777619u;
-    }
+static inline uint16_t attr_hash15_finish(uint32_t h) {
     /* Finalizer (round 20): raw FNV truncation (h>>16) mapped
      * names differing in their last digit to hashes exactly 256
      * apart — arithmetic progressions that collide onto one open-
@@ -237,6 +232,15 @@ static inline uint16_t attr_hash15(const char* s, size_t len) {
     return h15 ? h15 : 1;
 }
 
+static inline uint16_t attr_hash15(const char* s, size_t len) {
+    uint32_t h = 2166136261u;
+    for (size_t i = 0; i < len; i++) {
+        h ^= (unsigned char)s[i];
+        h *= 16777619u;
+    }
+    return attr_hash15_finish(h);
+}
+
 /* Entity flag (round 19): name_hash bit 15. */
 static inline int attr_has_entities(const struct leptris_attribute* a) {
     return (a->name_hash & 0x8000u) != 0;
@@ -370,6 +374,16 @@ struct leptris_ns_cache {
     struct leptris_ns_cache* doc_next;
     unsigned char prefix_heap;
     unsigned char uri_heap;
+    /* Lane-18 round 13: child-iteration cache. child_gen is bumped by
+     * every child-list mutator (prepend/insert/remove); child() stores
+     * (child_cached_gen, child_idx, child_node) after a walk and
+     * resumes from it while the generations agree — sequential indexed
+     * access becomes O(1) per step. append_child needs no bump: it
+     * preserves existing indices. */
+    uint32_t child_gen;
+    uint32_t child_cached_gen;
+    uint32_t child_idx;
+    LeptrisNode* child_node;
 };
 
 struct leptris_element {
@@ -927,7 +941,15 @@ void leptris_element_set_next_sibling(LeptrisElement elem, LeptrisElement siblin
  * future compact-storage cache (e.g. pugixml-style compact pointer
  * table) can plug in without touching every mutation call site. */
 static inline void leptris_element_invalidate_child_cache(LeptrisElement elem) {
-    (void)elem;
+    /* Lane-18 round 13: the hook now drives the ns_cache child-
+     * iteration cache (child_idx/child_node below). Bumping child_gen
+     * AND nulling child_node means a stale cache can never serve a
+     * node even across a 2^32 generation wrap. */
+    struct leptris_ns_cache* c = elem_get_ns_cache(elem);
+    if (c) {
+        c->child_gen++;
+        c->child_node = NULL;
+    }
 }
 
 /* ============================================================================

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

@@ -24,6 +24,8 @@ struct leptris_namespace* leptris_namespace_new_pooled(const char* prefix,
 #include "cdata.h"
 #include "comment.h"
 #include "pi.h"
+#include "entity_ref.h"
+#include "edges.h"
 #include "../common/string_view.h"
 #include "../common/entities.h"
 #include "../common/port.h"
@@ -35,6 +37,11 @@ struct leptris_namespace* leptris_namespace_new_pooled(const char* prefix,
  * resolver are defined in the attribute section below. */
 static struct leptris_attribute* find_attr_expanded_len(
     LeptrisElement elem, const char* uri, const char* local, size_t ll);
+static struct leptris_attribute* find_attr_bare(
+    LeptrisElement elem, const char* local, size_t ll);
+static struct leptris_attribute* find_attr_bare_h(LeptrisElement elem,
+                                                  const char* local,
+                                                  size_t ll, uint16_t lh);
 static const char* elem_resolve_attr_prefix(LeptrisElement elem,
                                             const char* prefix);
 #include <math.h>
@@ -170,14 +177,23 @@ LEPTRIS_API const char* leptris_element_attribute(LeptrisElement elem, const cha
      * strcmp ran for EVERY bare-name query. */
     const char* colon = NULL;
     size_t name_len = 0;
+    /* The FNV rides this same pass (attr_hash15's byte loop fused
+     * into the len+colon scan — a second pass over the needle cost
+     * ~1ns/query). Discarded when a colon ends the scan: the bare
+     * path that consumes the hash is not taken then. */
+    uint32_t nh = 2166136261u;
     for (; name[name_len]; name_len++) {
-        if (name[name_len] == ':') { colon = &name[name_len]; break; }
+        unsigned char c9 = (unsigned char)name[name_len];
+        if (c9 == ':') { colon = &name[name_len]; break; }
+        nh ^= c9;
+        nh *= 16777619u;
     }
     struct leptris_attribute* attr;
     if (!colon) {
         if (name_len == 5 && name[0] == 'x' &&
             leptris_memeq_short(name, "xmlns", 5)) return NULL;  /* (5) */
-        attr = find_attr_expanded_len(elem, NULL, name, name_len); /* (1) */
+        attr = find_attr_bare_h(elem, name, name_len,
+                                attr_hash15_finish(nh));     /* (1) */
     } else {
         size_t pl = (size_t)(colon - name);
         if (pl == 5 && memcmp(name, "xmlns", 5) == 0) return NULL;  /* (5) */
@@ -327,6 +343,41 @@ static int uri_is_none(const char* uri) {
     return !uri || !uri[0];
 }
 
+/* Bare-name lookup (needle provably colon-free). The TODO 173
+ * invariant: an attribute carries a side ns cache ONLY when its name
+ * contains a colon — all three attr_set_ns_cache sites are
+ * colon-gated — so `ns_cache_off == 0` is an exact colon-free test,
+ * and a prefixed attr can never match a bare needle (#542 rule 1).
+ * That removes the per-attr colon probe entirely: a skipped hop is
+ * one int32 load, and the confirmed hop needs no probe either. */
+/* Always-inline: an out-of-line call per query costs more than the
+ * whole walk body (LTO otherwise emits this as a shared subroutine
+ * for the expanded-name delegation — the call was ~65% of query
+ * time at 2-attr chain lengths). Takes the caller's needle hash:
+ * attribute() computes it inside its len+colon scan, so the needle
+ * is hashed in one pass, not two. */
+LEPTRIS_ALWAYS_INLINE
+static struct leptris_attribute* find_attr_bare_h(LeptrisElement elem,
+                                                  const char* local,
+                                                  size_t ll, uint16_t lh) {
+    struct leptris_attribute* attr = leptris_element_get_first_attribute(elem);
+    while (attr) {
+        if (attr->ns_cache_off == 0 &&
+            attr->name_view.length == ll &&
+            attr_name_hash(attr) == lh &&
+            leptris_memeq_short(attr->name_view.data, local, ll))
+            return attr;
+        attr = leptris_attr_next(attr);
+    }
+    return NULL;
+}
+
+static struct leptris_attribute* find_attr_bare(LeptrisElement elem,
+                                                const char* local,
+                                                size_t ll) {
+    return find_attr_bare_h(elem, local, ll, attr_hash15(local, ll));
+}
+
 /* Find an attribute by EXPANDED name. uri NULL/"" matches only
  * no-namespace attributes; otherwise the URI must match what the
  * attribute's prefix resolves to (prefix-agnostic). Local names
@@ -334,34 +385,24 @@ static int uri_is_none(const char* uri) {
 static struct leptris_attribute* find_attr_expanded_len(
         LeptrisElement elem, const char* uri, const char* local,
         size_t ll) {
+    if (uri_is_none(uri)) return find_attr_bare(elem, local, ll);
     struct leptris_attribute* attr = leptris_element_get_first_attribute(elem);
-    /* No-namespace search: the 15-bit name-hash prefilter (TODO 172
-     * / S9, as in leptris_dom_attr_find). A hash+length+memcmp hit
-     * against a colon-free needle implies the attr name carries no
-     * colon, so the per-attr memchr is gone from the common path —
-     * value-of @name and attribute axes ride this (#682). */
-    uint16_t lh = uri_is_none(uri) ? attr_hash15(local, ll) : 0;
     while (attr) {
         const char* n = attr->name_view.data;
         size_t nl = attr->name_view.length;
-        if (nl < ll) goto next;
         /* Round 11: inline colon probe for the short names that
-     * dominate attr traffic — memchr's call setup costs more than
-     * the 1-3 iterations (the TODO 174 law). */
-    const char* colon = NULL;
-    if (nl <= 16) {
-        for (const char* c9 = n; c9 < n + nl; c9++) {
-            if (*c9 == ':') { colon = c9; break; }
-        }
-    } else {
-        colon = (const char*)memchr(n, ':', nl);
-    }
-        if (uri_is_none(uri)) {
-            if (colon) goto next;                    /* namespaced */
-            if (attr_name_hash(attr) == lh &&
-                leptris_memeq_short(n, local, ll)) return attr;
+         * dominate attr traffic — memchr's call setup costs more
+         * than the 1-3 iterations (the TODO 174 law). */
+        const char* colon = NULL;
+        if (nl <= 16) {
+            for (const char* c9 = n; c9 < n + nl; c9++) {
+                if (*c9 == ':') { colon = c9; break; }
+            }
         } else {
-            if (!colon) goto next;                   /* no namespace */
+            colon = (const char*)memchr(n, ':', nl);
+        }
+        if (!colon) goto next;                       /* no namespace */
+        {
             size_t pl = (size_t)(colon - n);
             if (nl - pl - 1 != ll || memcmp(colon + 1, local, ll) != 0)
                 goto next;
@@ -621,11 +662,72 @@ LEPTRIS_API LeptrisElement leptris_element_child(LeptrisElement elem, size_t ind
     if (!elem) return NULL;
     if (index >= elem->child_count) return NULL;
 
-    LeptrisElement child = leptris_element_get_first_child(elem);
-    for (size_t i = 0; i < index && child != NULL; i++) {
-        child = leptris_element_get_next_sibling(child);
+    /* Lane-18 round 13: resume from the ns_cache child-iteration
+     * slot when the generations agree — sequential indexed access
+     * (the loop pattern) becomes O(1) per step instead of re-walking
+     * from the first child through every interleaved text node.
+     * leptris_element_invalidate_child_cache bumps the generation on
+     * every child-list mutation. */
+    struct leptris_ns_cache* cc = elem_get_ns_cache(elem);
+    if (!cc && elem->child_count > 1) {
+        /* Lane-18 round 15: attr-free parents carry no parse-time
+         * ns_cache (it exists only where the parse stamped
+         * xmlns/prefix state), so the round-13 resume slot never
+         * engaged for them and every indexed read re-walked from
+         * the first child — O(children) per call (a 96 KB catalog
+         * root measured 148 s per 100k indexed reads). Materialize
+         * the cache from the element's pool on first indexed
+         * access: the string fields stay NULL (nothing heap-owned,
+         * so no doc-chain registration), and the mutation
+         * invalidation hook keys off elem_get_ns_cache, so a cache
+         * created here is invalidated exactly like a parse-time
+         * one. Detached elements have no pool — they keep the
+         * walk. */
+        LeptrisMemoryPool* pool = leptris_element_get_pool(elem);
+        if (pool) {
+            struct leptris_ns_cache* nc = (struct leptris_ns_cache*)
+                leptris_pool_alloc(pool, sizeof(*nc));
+            if (nc) {
+                memset(nc, 0, sizeof(*nc));
+                elem_set_ns_cache((struct leptris_element*)elem, nc);
+                cc = nc;
+            }
+        }
     }
-    return child;
+    LeptrisNode* cur;
+    size_t i;
+    if (cc && cc->child_cached_gen == cc->child_gen && cc->child_node &&
+        index >= cc->child_idx) {
+        cur = cc->child_node;
+        i = cc->child_idx;
+    } else {
+        cur = (LeptrisNode*)leptris_element_get_first_child(elem);
+        i = 0;
+    }
+    while (cur) {
+        if (cur->type == LEPTRIS_NODE_TYPE_ELEMENT) {
+            if (i == index) {
+                if (cc) {
+                    cc->child_cached_gen = cc->child_gen;
+                    cc->child_idx = index;
+                    cc->child_node = cur;
+                }
+                return (LeptrisElement)cur;
+            }
+            i++;
+        }
+        /* Type-dispatched raw hop (edges.h tables, #450): text nodes
+         * interleave with elements and carry next_sibling_off at a
+         * different struct offset — a single-offset cast here reads
+         * garbage (the segfault this comment replaced). */
+        size_t ti = leptris_edge_idx((unsigned)cur->type);
+        if (ti >= 6) { cur = NULL; continue; }
+        const int32_t* f =
+            (const int32_t*)((char*)cur + leptris_edge_sib_off[ti]);
+        cur = (LeptrisNode*)leptris_compact_int32_decode_inline(
+            (void*)cur, *f, f);
+    }
+    return NULL;
 }
 
 /**

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -1085,6 +1085,10 @@ static struct leptris_ns_cache* dp_ensure_cache(DParser* p,
     c->doc_next = NULL;
     c->prefix_heap = 0;
     c->uri_heap = 0;
+    c->child_gen = 0;
+    c->child_cached_gen = 0;
+    c->child_idx = 0;
+    c->child_node = NULL;
     elem_set_ns_cache(elem, c);
     return c;
 }

data/vendor-src/libleptris/test/CMakeLists.txt

@@ -93,6 +93,7 @@ leptris_add_test(test_parser     parser/test_parser.cpp)
 leptris_add_test(test_large_docs parser/test_large_documents.cpp)
 leptris_add_test(test_encoding   parser/test_encoding.cpp)
 leptris_add_test(test_dom        dom/test_dom.cpp)
+leptris_add_test(test_element_children dom/test_element_children.cpp)
 leptris_add_test(test_map_lifecycle dom/test_map_lifecycle.cpp)
 leptris_add_test(test_simd_count parser/test_simd_count.cpp)
 leptris_add_test(test_descriptor abi/test_descriptor.cpp)

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

@@ -0,0 +1,102 @@
+// test/dom/test_element_children.cpp — indexed child access specs,
+// including the lane-18 round-13 iteration-cache invalidation guards.
+#include <gtest/gtest.h>
+#include <string>
+#include "leptris.h"
+
+
+TEST(ElementChildCache, MutationInvalidatesIterationSlot) {
+    /* Lane-18 round 13: the ns_cache child-iteration slot must never
+     * serve a node across a child-list mutation. */
+    LeptrisStatus st;
+    LeptrisDocument doc = leptris_parse_string(
+        "<r><a/><b/><c/></r>", 19, &st);
+    ASSERT_NE(doc, nullptr);
+
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+    LeptrisElement b = leptris_element_child(root, 1);
+    ASSERT_NE(b, nullptr);
+    EXPECT_EQ(std::string(leptris_element_name(b)), "b");
+
+    /* Mutate before the cached position: indices shift. */
+    LeptrisDocument fresh = leptris_document_create();
+    LeptrisElement z = leptris_element_create(fresh, "z");
+    ASSERT_NE(z, nullptr);
+    ASSERT_EQ(leptris_element_prepend_child(root, z), LEPTRIS_OK);
+
+    const char* names[] = {"z", "a", "b", "c"};
+    for (int i = 0; i < 4; i++) {
+        LeptrisElement c = leptris_element_child(root, (size_t)i);
+        ASSERT_NE(c, nullptr) << "i=" << i;
+        EXPECT_EQ(std::string(leptris_element_name(c)), names[i]) << "i=" << i;
+    }
+    leptris_document_free(fresh);
+    leptris_document_free(doc);
+}
+
+TEST(ElementChildCache, RemoveChildInvalidatesIterationSlot) {
+    LeptrisStatus st;
+    LeptrisDocument doc = leptris_parse_string(
+        "<r><a/><b/><c/></r>", 19, &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+    LeptrisElement c = leptris_element_child(root, 2);
+    ASSERT_NE(c, nullptr);
+
+    LeptrisElement b = leptris_element_child(root, 1);
+    ASSERT_NE(b, nullptr);
+    ASSERT_EQ(leptris_element_remove_child(root, b), LEPTRIS_OK);
+
+    LeptrisElement c2 = leptris_element_child(root, 1);
+    ASSERT_NE(c2, nullptr);
+    EXPECT_EQ(std::string(leptris_element_name(c2)), "c");
+    EXPECT_EQ(leptris_element_child(root, 2), nullptr);
+    leptris_document_free(doc);
+}
+
+TEST(ElementChildCache, AttrFreeParentLazyCacheStaysMutationSafe) {
+    /* Lane-18 round 15: attribute-free elements carry no ns_cache
+     * from the parser (the cache exists only when the parse stamped
+     * xmlns/prefix state), so the round-13 resume slot never engaged
+     * for them and every indexed read re-walked from the first
+     * child. child() now materializes the cache lazily. The mutation
+     * contract must hold for that lazily-created cache exactly as it
+     * does for parse-created ones. */
+    LeptrisStatus st;
+    LeptrisDocument doc = leptris_parse_string(
+        "<r><a/><b/><c/></r>", 19, &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+    EXPECT_EQ(leptris_element_attribute(root, "id"), nullptr);
+
+    /* Warm the iteration slot through the lazy path. */
+    for (int i = 0; i < 3; i++) {
+        LeptrisElement c = leptris_element_child(root, (size_t)i);
+        ASSERT_NE(c, nullptr) << "i=" << i;
+    }
+
+    LeptrisDocument fresh = leptris_document_create();
+    LeptrisElement z = leptris_element_create(fresh, "z");
+    ASSERT_NE(z, nullptr);
+    ASSERT_EQ(leptris_element_prepend_child(root, z), LEPTRIS_OK);
+
+    const char* names[] = {"z", "a", "b", "c"};
+    for (int i = 0; i < 4; i++) {
+        LeptrisElement c = leptris_element_child(root, (size_t)i);
+        ASSERT_NE(c, nullptr) << "i=" << i;
+        EXPECT_EQ(std::string(leptris_element_name(c)), names[i]) << "i=" << i;
+    }
+
+    LeptrisElement b = leptris_element_child(root, 2);
+    ASSERT_NE(b, nullptr);
+    ASSERT_EQ(leptris_element_remove_child(root, b), LEPTRIS_OK);
+    LeptrisElement c = leptris_element_child(root, 2);
+    ASSERT_NE(c, nullptr);
+    EXPECT_EQ(std::string(leptris_element_name(c)), "c");
+    EXPECT_EQ(leptris_element_child(root, 3), nullptr);
+    leptris_document_free(fresh);
+    leptris_document_free(doc);
+}

data/vendor-src/libleptris/test/perf/test_perf.cpp

@@ -313,12 +313,16 @@ TEST(PerfRegression, IndexedChildAccessDoesNotRegress) {
         if (s < small) small = s;
         if (l < large) large = l;
     }
-    /* 3x size: O(N^2) sweep => large/small ~ 9x; an O(N^3)
-     * regression reaches ~27x. Budget 18x separates both with
-     * margin on loaded runners and under ASAN. */
-    EXPECT_LT(large, 18.0 * small)
-        << "Indexed child access complexity regression: 75-child sweep "
-        << large << " us vs 25-child sweep " << small << " us";
+    /* 3x size: a LINEAR sweep (the round-13 resume slot makes a
+     * sequential indexed read O(1) per step; round 15 extends it to
+     * attr-free parents, whose cache child() materializes lazily)
+     * measures large/small ~ 3x. The old quadratic walk measures
+     * ~9x; an O(N^3) regression reaches ~27x. Budget 6x separates
+     * linear from quadratic with margin on loaded runners. */
+    EXPECT_LT(large, 6.0 * small)
+        << "Indexed child access lost the O(1)-per-step resume "
+        << "(quadratic walk back?): 75-child sweep " << large
+        << " us vs 25-child sweep " << small << " us";
 }
 
 /* Template dispatch must scale with the CANDIDATE'S subtree, not

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.265",
+  "version": "1.9.268",
   "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.265.0
+  version: 1.9.268.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -730,6 +730,7 @@ files:
 - vendor-src/libleptris/test/dom/test_digest.cpp
 - vendor-src/libleptris/test/dom/test_document_children.cpp
 - vendor-src/libleptris/test/dom/test_dom.cpp
+- vendor-src/libleptris/test/dom/test_element_children.cpp
 - vendor-src/libleptris/test/dom/test_map_lifecycle.cpp
 - vendor-src/libleptris/test/dom/test_node_surface_parity.cpp
 - vendor-src/libleptris/test/dom/test_text_borrowed.cpp