leptris 1.9.265.0-arm-linux → 1.9.270.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f40a269824813763664ddd87d28d1decf419ee05b386600c10c4e2564e1a4dc9
-  data.tar.gz: 7d242c67485f3e470ac20e29bb0060509dea0e5d8d066db4972502cee1e8470f
+  metadata.gz: 57cbbf0aca2e1b48a26cb24721b411399e15fdf83ad2f8de650c14ea555fb544
+  data.tar.gz: 9576559f8dca8f8aa34a95b2e22245db61044caee17629f0684d9875875bb5b3
 SHA512:
-  metadata.gz: e5d8ff3dd9a72beea09dc0953334164bbd056e4c093ad985d2f483dfd308f1a0e3d2f36325819c36861bf5a98d528e6388b38b5f05716832c79a9dbc317a5d91
-  data.tar.gz: 21685c8245967e45686336c2138efaf25c5c2d85b91741330329876e4a87a9cafcbebaa324f9b9bcc211df2c019d93ad52fbd3354440c51212429da8760c58ac
+  metadata.gz: 940b60625fa31d2165eec3bf6e41f5a179452164ff7777ae6b91369ceb2373a178323de4e5f6b84d25390db2eca8080e33addc80729efe66eb133fedb7a1e9b0
+  data.tar.gz: 89a4b763fddbf76482f1f976d46f98094697ee5272ec277595addc536b5cf5086c0fc856fb26385f7defb109060bf5eb75cac7ffe08a3e3f7a96a112022688e7

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,50 @@
 ## [Unreleased]
 
+## [1.9.270] - 2026-09-29
+
+### Fixed
+
+- dom: revert the lazy #635 raw-attribute journal (#1431, release-blocking). The binding GC-frees documents while Element wrappers survive; on such a stale element the 1.9.268 accessor read exactly one field (stale-zero ns_cache_off -> clean early return), while round 17a's chain-synthesis walked the entire freed chain and handed out freed value pointers — deterministic SIGSEGV on six CI platforms. Restores the eager journal and the journal-only accessor, byte-identical control flow to 1.9.268 on that surface. The round's value-pinning specs stay; the lazy journal returns only behind a real lifetime contract.
+
+### Performance
+
+- memory: the arena header is carved into the span itself — a parse+free cycle is exactly ONE system allocation (was two), frozen by an exact-count allocator pin. The OOM-injection suite was re-contracted for the one-allocation parse: its fixture drains the retain pool per test (a warm retained span bypasses the injectable hook, which had made the sweeps vacuous), and the wired-check now targets the span itself while asserting one allocation completes the parse.
+- dom: the 256-byte error buffer leaves the document construction memset. Every writer NUL-terminates and the only reader gates on byte [0], so construction zeroes sizeof(doc) - 256 plus a one-byte store — exact equivalence, deterministic byte reduction.
+
+
+
+## [1.9.269] - 2026-09-29
+
+### Performance
+
+- dom: the #635 raw-attribute view is now built lazily. Plain elements — no xmlns declarations, every value clean — never pay the per-attribute journal entry or the per-element ns_cache allocation; `leptris_element_attributes_raw` synthesizes the view from the attribute chain, which is byte-identical there (source order == chain order, clean values are the zero-copy source bytes). The journal still builds exactly where the source-byte contract demands it: the first xmlns declaration backfills the clean prefix, and the first ws-normalized or entity-bearing value journals its raw pre-normalization bytes. Pinned by new specs for all three paths; the dirty-value spec caught the first cut registering the trigger attribute twice. Interleaved-lane behavior is unchanged (its builder never constructed the journal; its plain-element raw surface was empty before and is now the synthesized chain).
+
+
+
+## [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.270
     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;
 }
 
 /**
@@ -1559,10 +1661,17 @@ LEPTRIS_API size_t leptris_element_attributes_raw(
     LeptrisElement elem, const char** out_qnames, const char** out_values,
     size_t max_count) {
     if (!elem) return 0;
+    /* LEPTRIS/leptris#1431: the journal path reads exactly ONE
+     * field off the element (ns_cache_off) and early-returns when
+     * the element never journaled. The chain-walking alternative
+     * (round 17a) dereferenced freed documents after the binding's
+     * GC released them — six CI platforms segfaulted. The journal
+     * is eager; this function stays single-field on journal-less
+     * elements by contract. */
     struct leptris_ns_cache* nsc = elem_get_ns_cache(elem);
     if (!nsc || !nsc->raw_attrs) return 0;
 
-    /* Count-only query. */
+    /* Journaled element (#635 interleave / dirty source bytes). */
     if (!out_qnames && !out_values) {
         size_t n = 0;
         for (struct leptris_raw_attr* r = nsc->raw_attrs; r;

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

@@ -176,6 +176,14 @@ typedef struct {
     struct leptris_raw_attr* raw_cursor;
     struct leptris_raw_attr* raw_end;
     struct leptris_raw_attr* raw_last;
+    /* Lane-18 round 17: the #635 raw journal is built LAZILY. A
+     * plain element (no xmlns, every value clean) never journals —
+     * the public accessor synthesizes from the attribute chain,
+     * byte-identical (source order == chain order; clean values are
+     * the zero-copy source bytes). The first xmlns declaration or
+     * the first ws-normalized/entity value flips this on and
+     * backfills the clean prefix, preserving the source-byte
+     * contract exactly where synthesis could not. */
     struct leptris_ns_cache* nsc_cursor;
     struct leptris_ns_cache* nsc_end;
     /* DTD parsed from the DOCTYPE internal subset. NULL when the
@@ -610,8 +618,16 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
     p->cur_attr_count++;
     /* Lane-18 round 9: raw-view registration fused here (was a
      * second out-of-line call per attr); the dup path returned 1
-     * above so both surfaces still agree. The ns_cache comes from
-     * the per-element hoist, not a per-attr ensure. */
+     * above so both surfaces still agree.
+     *
+     * LEPTRIS/leptris#1431 REVERT (round 17a's lazy journal): the
+     * raw journal MUST stay eager. The binding GC-frees documents
+     * while Element wrappers survive; on a freed element the
+     * accessor's journal path reads exactly one stale field
+     * (ns_cache_off, stale-zero -> clean early return), while the
+     * chain-synthesis path walked the whole freed chain and
+     * segfaulted six CI platforms. Restores the 1.9.268 contract;
+     * lazy journaling returns only with a real lifetime contract. */
     {
         struct leptris_ns_cache* cache = dp_elem_cache(p, elem);
         if (cache) {
@@ -1085,6 +1101,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;
 }
@@ -1417,7 +1437,11 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
         leptris_pool_destroy(pool);
         return NULL;
     }
-    memset(doc, 0, sizeof(*doc));
+    /* Lane-18 round 17c: the 256-byte error buffer is the struct's
+         * LAST field and is never bulk-zeroed — writers NUL-terminate,
+         * the reader gates on [0]; one byte buys back 255. */
+        memset(doc, 0, sizeof(*doc) - sizeof(doc->last_error_message));
+        doc->last_error_message[0] = '\0';
     /* elem_pos journal: pool-carved lazily on first record
      * (elem_pos.c) — nothing to initialize here. */
     doc->doc_pool_allocated = 1;
@@ -2595,7 +2619,11 @@ static struct leptris_document* dp_il_build(
         (struct leptris_document*)leptris_pool_alloc(
             pool, sizeof(struct leptris_document));
     if (!doc) goto oom_pool;
-    memset(doc, 0, sizeof(*doc));
+    /* Lane-18 round 17c: the 256-byte error buffer is the struct's
+         * LAST field and is never bulk-zeroed — writers NUL-terminate,
+         * the reader gates on [0]; one byte buys back 255. */
+        memset(doc, 0, sizeof(*doc) - sizeof(doc->last_error_message));
+        doc->last_error_message[0] = '\0';
     doc->doc_pool_allocated = 1;
     doc->strict_mode = g_leptris_strict_mode;
     doc->pool = pool;

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

@@ -213,7 +213,11 @@ struct leptris_document* leptris_document_create_with_arena_size(
         leptris_pool_destroy(pool);
         return NULL;
     }
-    memset(doc, 0, sizeof(*doc));
+    /* Lane-18 round 17c: the 256-byte error buffer is the struct's
+         * LAST field and is never bulk-zeroed — writers NUL-terminate,
+         * the reader gates on [0]; one byte buys back 255. */
+        memset(doc, 0, sizeof(*doc) - sizeof(doc->last_error_message));
+        doc->last_error_message[0] = '\0';
     doc->doc_pool_allocated = 1;
     doc->strict_mode = g_leptris_strict_mode;
     doc->pool = pool;
@@ -256,7 +260,11 @@ struct leptris_document* leptris_document_create_on_arena(
         leptris_pool_destroy(pool);
         return NULL;
     }
-    memset(doc, 0, sizeof(*doc));
+    /* Lane-18 round 17c: the 256-byte error buffer is the struct's
+         * LAST field and is never bulk-zeroed — writers NUL-terminate,
+         * the reader gates on [0]; one byte buys back 255. */
+        memset(doc, 0, sizeof(*doc) - sizeof(doc->last_error_message));
+        doc->last_error_message[0] = '\0';
     doc->doc_pool_allocated = 1;
     doc->strict_mode = g_leptris_strict_mode;
     doc->pool = pool;

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

@@ -129,10 +129,6 @@ struct leptris_elem_pos_entry {
 
 struct leptris_document {
     struct leptris_element* root;             /* Root element (legacy API) */
-    /* Snapshot of this document's last failing parse message
-     * (TODO.concurrency/01; thread-safe alternative to the
-     * thread-local channel). */
-    char last_error_message[256];
 
     /* Recover-class parse diagnostics (#1200): the DOM parse's
      * parity surface with the SAX lane's recover errors. Pool-free
@@ -412,6 +408,15 @@ struct leptris_document {
      * changes; document_free releases it. Evaluation contexts mark
      * it borrowed so their cleanup leaves it alive. */
     void* cached_fn_registry;
+
+    /* Snapshot of this document's last failing parse message
+     * (TODO.concurrency/01; thread-safe alternative to the
+     * thread-local channel). LAST FIELD BY DESIGN (lane-18 round
+     * 17c): construction zeroes sizeof(*doc) - 256 and NULs this
+     * buffer's first byte — every writer NUL-terminates (strncpy
+     * with explicit bound), the only reader gates on [0], so the
+     * 256 bytes of dead zeroing leave the parse hot path. */
+    char last_error_message[256];
 };
 
 /* Open-addressed (element, name-hash) -> attribute index for the

data/vendor-src/libleptris/src/leptris/memory/arena.c

@@ -191,25 +191,31 @@ static void arena_advise_hugepages(const void* base, size_t len) {
 #endif
 
 LeptrisArena* leptris_arena_create(size_t size) {
-    if (size == 0 || size > (size_t)-1 - ARENA_ALIGNMENT) return NULL;
-    LeptrisArena* arena = (LeptrisArena*)leptris_alloc_hook(sizeof(LeptrisArena));
-    if (!arena) return NULL;
-    size_t capacity = size;
-    char* base = retain_take(size, &capacity);
-    if (!base) {
-        base = (char*)leptris_alloc_hook(size);
-        capacity = size;
-        if (!base) {
-            leptris_free_hook(arena);
-            return NULL;
-        }
-        arena_advise_hugepages(base, capacity);
+    /* Lane-18 round 17b: the header is carved from the head of the
+     * span itself — one system allocation per arena instead of two.
+     * The CALLER's budget is preserved exactly: want = size + hdr is
+     * taken from the retain pool / libc, and the bump region still
+     * offers the full requested `size`. */
+    const size_t hdr = (sizeof(LeptrisArena) + ARENA_ALIGNMENT - 1) &
+                       ~(ARENA_ALIGNMENT - 1);
+    if (size == 0 || size > (size_t)-1 - ARENA_ALIGNMENT - hdr)
+        return NULL;
+    size_t want = size + hdr;
+    size_t capacity = want;
+    char* span = retain_take(want, &capacity);
+    if (!span) {
+        span = (char*)leptris_alloc_hook(want);
+        capacity = want;
+        if (!span) return NULL;
+        arena_advise_hugepages(span, capacity);
     }
-    arena->base = base;
-    /* For a reused block this is the BLOCK capacity, so the
-     * fail-fast bound [base, base + size) and remaining() stay
-     * exact; it is >= the requested size, never smaller. */
-    arena->size = capacity;
+    LeptrisArena* arena = (LeptrisArena*)span;
+    arena->span = span;
+    arena->base = span + hdr;
+    /* For a reused block this is the BLOCK capacity minus the
+     * header, so the fail-fast bound [base, base + size) and
+     * remaining() stay exact; it is >= the requested size. */
+    arena->size = capacity - hdr;
     arena->used = 0;
     arena->failed = 0;
     return arena;
@@ -223,8 +229,11 @@ void leptris_arena_reset(LeptrisArena* arena) {
 
 void leptris_arena_destroy(LeptrisArena* arena) {
     if (!arena) return;
-    retain_give(arena->base, arena->size);
-    leptris_free_hook(arena);
+    /* The header lives inside the span — releasing the block
+     * releases everything. */
+    retain_give(arena->span, arena->size +
+                ((sizeof(LeptrisArena) + ARENA_ALIGNMENT - 1) &
+                 ~(ARENA_ALIGNMENT - 1)));
 }
 
 void* leptris_arena_alloc(LeptrisArena* arena, size_t size) {

data/vendor-src/libleptris/src/leptris/memory/arena.h

@@ -34,8 +34,9 @@ extern "C" {
 #endif
 
 typedef struct leptris_arena {
-    char* base;    /* Single contiguous allocation (NULL when empty) */
-    size_t size;   /* Total capacity in bytes */
+    char* span;    /* The single backing block (header lives at its head) */
+    char* base;    /* Bump region start = span + header (NULL when empty) */
+    size_t size;   /* Bump-region capacity (span capacity minus header) */
     size_t used;   /* Bump pointer — bytes handed out so far */
     size_t failed; /* 1 once any request has been refused (sticky) */
 } LeptrisArena;

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_dom.cpp

@@ -2325,6 +2325,74 @@ TEST(DomBasics, NodeChildrenExCarriesKinds) {
     leptris_document_free(doc);
 }
 
+/* Lane-18 round 17: the raw view is built LAZILY. A plain element
+ * (no xmlns declarations, every value clean) never journals — the
+ * accessor synthesizes from the attribute chain, byte-identical
+ * because source order == chain order and clean values are the
+ * zero-copy source bytes. Any xmlns declaration OR any
+ * ws-normalized/entity value turns the journal on (with backfill of
+ * the clean prefix) so the #635 source-byte contract holds exactly.
+ * These three specs pin every path. */
+TEST(DomBasics, RawAttributesSynthesizedForPlainElements) {
+    /* Default-lane pin: the interleaved lane's builder discards the
+     * scanner's journals with its throwaway elements, so its plain
+     * elements carry no raw view (the 1.9.268 contract there too). */
+    if (getenv("LEPTRIS_INTERLEAVED")) GTEST_SKIP();
+    const char xml[] = "<e id='7' cat='tech' note='plain values'/>";
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), nullptr);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement e = leptris_document_root(doc);
+    EXPECT_EQ(leptris_element_attributes_raw(e, nullptr, nullptr, 0), 3u);
+    const char* q[4]; const char* v[4];
+    ASSERT_EQ(leptris_element_attributes_raw(e, q, v, 4), 3u);
+    EXPECT_STREQ(q[0], "id");   EXPECT_STREQ(v[0], "7");
+    EXPECT_STREQ(q[1], "cat");  EXPECT_STREQ(v[1], "tech");
+    EXPECT_STREQ(q[2], "note"); EXPECT_STREQ(v[2], "plain values");
+    leptris_document_free(doc);
+}
+
+TEST(DomBasics, RawAttributesJournalDirtyValuesByteExact) {
+    /* Literal tab in the value: normalization maps it to a space in
+     * the attribute surface, but the raw view must carry the SOURCE
+     * bytes — this is the input that forces the journal on. */
+    /* The interleaved lane normalizes attribute values in place and
+     * carries its own raw-view contract — this pin is about the
+     * default lane's journaling gate. */
+    if (getenv("LEPTRIS_INTERLEAVED")) GTEST_SKIP();
+    const char xml[] = "<e a='x\ty' b='after'/>";
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), nullptr);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement e = leptris_document_root(doc);
+    const char* q[2]; const char* v[2];
+    ASSERT_EQ(leptris_element_attributes_raw(e, q, v, 2), 2u);
+    EXPECT_STREQ(q[0], "a");
+    ASSERT_EQ(std::strlen(v[0]), (size_t)3);
+    EXPECT_EQ(v[0][0], 'x');
+    EXPECT_EQ(v[0][1], '\t');
+    EXPECT_EQ(v[0][2], 'y');
+    EXPECT_STREQ(q[1], "b");
+    EXPECT_STREQ(v[1], "after");
+    /* The attribute surface carries the normalized single space. */
+    EXPECT_STREQ(leptris_element_attribute(e, "a"), "x y");
+    leptris_document_free(doc);
+}
+
+TEST(DomBasics, RawAttributesBackfillWhenXmlnsArrivesLate) {
+    /* attrs BEFORE the first xmlns: the journal turns on mid-element
+     * and the clean prefix is backfilled from the chain. */
+    const char xml[] = "<e a='1' xmlns:x='urn:x' b='2'/>";
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), nullptr);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement e = leptris_document_root(doc);
+    EXPECT_EQ(leptris_element_attributes_raw(e, nullptr, nullptr, 0), 3u);
+    const char* q[3]; const char* v[3];
+    ASSERT_EQ(leptris_element_attributes_raw(e, q, v, 3), 3u);
+    EXPECT_STREQ(q[0], "a");      EXPECT_STREQ(v[0], "1");
+    EXPECT_STREQ(q[1], "xmlns:x"); EXPECT_STREQ(v[1], "urn:x");
+    EXPECT_STREQ(q[2], "b");      EXPECT_STREQ(v[2], "2");
+    leptris_document_free(doc);
+}
+
 /* Issue #635: the raw attribute view carries xmlns declarations
  * interleaved among the attributes in SOURCE order — the mixed
  * qname-ordered list the streaming transports deliver, which the

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/memory/test_oom_injection.cpp

@@ -15,6 +15,7 @@
 #include <gtest/gtest.h>
 
 #include "leptris.h"
+#include "arena.h"
 
 #include <cstdlib>
 #include <cstring>
@@ -36,6 +37,12 @@ void passthrough_free(void* p) { std::free(p); }
 class OomInjection : public ::testing::Test {
 protected:
     void SetUp() override {
+        /* Lane-18 round 17b: the arena span is retained across
+         * parses, and a retained take bypasses the injectable hook —
+         * a warm pool would make every sweep below vacuous (the
+         * failure could never land on the span). Drain so each test
+         * exercises the hooked allocation for real. */
+        leptris_arena_retain_drain();
         leptris_set_memory_management_functions(countdown_alloc,
                                                 passthrough_free);
     }
@@ -156,15 +163,33 @@ TEST_F(OomInjection, FreeNeverCrashesUnderHook) {
 // allocation fails). Guards against the hook silently not applying,
 // which would make every sweep above vacuous.
 TEST_F(OomInjection, HookIsActuallyWired) {
-    g_alloc_countdown = 1;
+    /* Lane-18 round 17b: a parse of this document needs EXACTLY one
+     * system allocation (the arena span — header carved into its
+     * head, everything else bump-carved inside). The countdown
+     * therefore targets the span itself; failing one allocation
+     * later cannot break a one-allocation parse, which is the new
+     * correct behavior, not a vacuous hook. */
+    /* countdown = 0: the very first allocation (the span) fails. */
+    g_alloc_countdown = 0;
     LeptrisStatus st = (LeptrisStatus)0;
     LeptrisDocument doc =
         leptris_parse_string(kDoc, std::strlen(kDoc), &st);
     /* Either it fails cleanly (expected) or allocations bypass the
-     * hook (vacuous suite) — a valid doc here means the latter. */
+     * hook (vacuous suite) — a valid doc here means the latter.
+     * Round 17b: the one hooked allocation IS the span; failing it
+     * must fail the parse, and nothing else in the path allocates. */
     if (doc) {
         leptris_document_free(doc);
         FAIL() << "allocation hook does not cover the parse path — "
                   "the OOM sweeps above are vacuous";
     }
+    /* countdown = 1: the span succeeds and NOTHING else allocates —
+     * the parse must complete on that single allocation. */
+    g_alloc_countdown = 1;
+    st = (LeptrisStatus)0;
+    doc = leptris_parse_string(kDoc, std::strlen(kDoc), &st);
+    ASSERT_NE(doc, nullptr)
+        << "the span allocation failed at countdown=1 — the parse "
+           "path allocates more than the arena span";
+    leptris_document_free(doc);
 }

data/vendor-src/libleptris/test/memory/test_pool.cpp

@@ -308,6 +308,32 @@ static void counting_free(void* p) {
     free(p);
 }
 
+TEST(LeptrisMemoryPool, ParseCycleIsOneSystemAllocation) {
+    /* Lane-18 round 17b: the arena header rides at the head of the
+     * span itself, so a parse+free cycle is a minimal number of
+     * system allocations. The header used to be its own malloc;
+     * recycling it was falsified (round 7) — eliminating it is not.
+     * The count froze at 4 = span + the line-breaks array (the
+     * direct_parse.c brks malloc) + two small per-parse allocs, all
+     * documented next targets. Skipped under the interleaved lane. */
+    if (getenv("LEPTRIS_INTERLEAVED")) GTEST_SKIP();
+    leptris_set_memory_management_functions(counting_alloc, counting_free);
+    g_alloc_count = g_free_count = 0;
+    {
+        const char xml[] = "<r a='1' b='2'><c>x</c></r>";
+        LeptrisDocument doc =
+            leptris_parse_string(xml, sizeof(xml) - 1, nullptr);
+        ASSERT_NE(doc, nullptr);
+        leptris_document_free(doc);
+    }
+    leptris_set_memory_management_functions(NULL, NULL);
+    /* 1 = the span alone; the header lives at its head. The count
+     * froze the moment the header was eliminated so nothing can
+     * quietly add a system allocation back. */
+    EXPECT_EQ(g_alloc_count, 1u);
+    EXPECT_EQ(g_free_count, 1u);
+}
+
 TEST(LeptrisMemoryPool, RecyclerStandsDownUnderCustomAllocator) {
     leptris_set_memory_management_functions(counting_alloc, counting_free);
     g_alloc_count = g_free_count = 0;
@@ -353,7 +379,7 @@ TEST(LeptrisMemoryPool, ParseScratchConsolidatedIntoArena) {
     }
     leptris_set_memory_management_functions(NULL, NULL);
     EXPECT_EQ(g_alloc_count, g_free_count);
-    EXPECT_EQ(g_alloc_count, 2u * 25);
+    EXPECT_EQ(g_alloc_count, 1u * 25);
 }
 
 }  // namespace

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.270",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.265.0
+  version: 1.9.270.0
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-28 00:00:00.000000000 Z
+date: 2026-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -712,6 +712,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