leptris 1.9.209.1 → 1.9.210.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f9ee6f6fa740c91bbb444f605bd68fcae043d8184f220774e89b749eb521fc
-  data.tar.gz: b22ed76f401235b0731cbeeeec011655a07ffd189e02a25dd675659fd076798f
+  metadata.gz: 6a8b73b57e537bd42a2f62759cd8b36fb842ed36c5046894453ae4b6c1540ca0
+  data.tar.gz: b089afc26fe2c7d8e8396a25a88c00baaa947c732896cf3aa70097c3b88b4302
 SHA512:
-  metadata.gz: a9bd90a1a9d941ad5814a13dd659213de9ab86e21e38a8064b681d6d127fe91c935ba5635a2b2e4938699769aca76953e8bcb4db42fee893eef5ab6f55166cb3
-  data.tar.gz: f261d4206b02aefa6bfbc57866da62f82c627059fba9fdbab640178e3e7ab6cf19272b6590f20587e50efe170872368930ce5f117d604f1c9c225746643d3cf9
+  metadata.gz: 1661a5db0ca010813f02bb90a24537fd92c5849cb797775ec7bb98c5217144bbdf95b8eca4ae3ec0a42a18f7cbebc57fd13b33500b1e402c69f903de4be85bff
+  data.tar.gz: 6724e22c525398f6ecead93260b6716188242a5f3722bc29fc6810bb00d89f66e8fc2a512729a7915b3be001b0a7c9b3dbbc2250623a22b528a819cc3f7faa49

data/CHANGELOG.md

@@ -5,6 +5,27 @@ 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.210.0] - 2026-09-20
+
+### Performance — engine sync (1.9.210)
+
+- Vendored libleptris 1.9.210: the node-layout fork's document
+  block (slice 1, #1253) — two contiguous geometrically-grown
+  regions per document (dense node array + string arena) with
+  region-relative byte-offset edges, so growth never invalidates
+  an offset; and the parse-arena retain ceiling raised 32 → 96MB
+  with a thread-cleanup drain (#1222/#1238 lane): repeated large
+  parses stop freeing/re-mallocing tens of MB per cycle. Measured
+  engine-side: 13MB attr shape 341 → 472 MB/s (+38%); the text
+  shape's size-decline eliminated (~605-627 flat across
+  1.5-13MB). No binding-facing surface changes; audit holds.
+- Note: #1242 was closed upstream before our strikes 7-10
+  forensics landed; reopened with the post-fix evidence (the
+  1.9.208 memo clear is incomplete — direct-call NULL + empty
+  chain on a live element; set_root cross-document false
+  positive on windows-4.0). The ubuntu-3.4 gate and armed
+  forensics stay until the engine ships the residual fix.
+
 ## [1.9.209.0] - 2026-09-20
 
 ### Performance — engine sync (1.9.209)

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.209"
+LIBLEPTRIS_VERSION = "1.9.210"
 # 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
@@ -117,6 +117,35 @@ task :compile do
     rm_rf([File.join(dest, "build"), File.join(dest, "prefix")])
   end
 
+  # Rebuild notes ride every gem beside the sources (packaging
+  # doctrine): the exact pins and the commands to reproduce the
+  # vendored libraries. The ruby variant's extconf runs these
+  # trees automatically at install time.
+  File.write(File.join(vsrc, "README.md"), <<~README)
+    Sources vendored in this gem (recompile rights; the ruby
+    variant builds them at install via extconf.rb):
+
+    - libleptris v#{LIBLEPTRIS_VERSION}
+    - utf8proc v#{UTF8PROC_VERSION}
+
+    Rebuild by hand:
+
+        cmake -B vendor-src/utf8proc/build -S vendor-src/utf8proc \
+          -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON \
+          -DUTF8PROC_ENABLE_TESTING=OFF
+        cmake --build vendor-src/utf8proc/build --config Release
+        cmake --install vendor-src/utf8proc/build --prefix <prefix>
+
+        cmake -B vendor-src/libleptris/build -S vendor-src/libleptris \
+          -DCMAKE_BUILD_TYPE=Release \
+          -DLEPTRIS_BUILD_SHARED=ON -DLEPTRIS_BUILD_STATIC=OFF \
+          -DBUILD_TESTING=OFF -DLEPTRIS_BUILD_CLI=OFF \
+          -DLEPTRIS_BUILD_BENCHMARKS=OFF -DLEPTRIS_BUILD_MAN_PAGES=OFF \
+          -DLEPTRIS_ENABLE_UTF8PROC=ON \
+          -DCMAKE_PREFIX_PATH=<utf8proc-prefix>
+        cmake --build vendor-src/libleptris/build --config Release
+  README
+
   # libleptris 1.9.18's xslt_functions.c:270 assigns LeptrisElement
   # to LeptrisNodeRef — GCC 14 (Alpine/musl) makes incompatible
   # pointer types an error by default and the musl platform gems
@@ -357,6 +386,46 @@ namespace :audit do
     end
   end
 
+  # Packaging doctrine (#271): every BUILT gem carries the engine
+  # source (vendor-src/libleptris build inputs) and the ext sources;
+  # platform gems additionally carry the prebuilt libraries and must
+  # NOT carry extensions; the pure ruby gem compiles at install
+  # (extensions present). Run over pkg/*.gem before publishing —
+  # the gate is what keeps the doctrine from regressing silently.
+  desc "Audit built gems for the packaging doctrine (source + binaries + extension policy)"
+  task :doctrine do
+    gems = Dir.glob("pkg/*.gem")
+    abort "audit:doctrine: no gems in pkg/ — build first (rake gem:native:...)" if gems.empty?
+
+    gems.each do |path|
+      spec = Gem::Package.new(path).spec
+      files = spec.files.map { |f| f.gsub("\\", "/") }
+
+      missing = []
+      missing << "vendor-src/libleptris/CMakeLists.txt" unless
+        files.include?("vendor-src/libleptris/CMakeLists.txt")
+      missing << "vendor-src/README.md" unless files.include?("vendor-src/README.md")
+      missing << "ext/leptris/native/extconf.rb" unless
+        files.include?("ext/leptris/native/extconf.rb")
+
+      if spec.platform.to_s == "ruby"
+        missing << "extensions (compile-at-install)" if spec.extensions.empty?
+      else
+        binary = files.any? { |f| f =~ %r{\Alib/libleptris\.(so|dylib|dll)\z} } ||
+                 files.any? { |f| f.start_with?("lib/leptris/vendor/") }
+        missing << "prebuilt engine binary" unless binary
+        missing << "extensions (platform gems never rebuild)" unless spec.extensions.empty?
+      end
+
+      if missing.empty?
+        puts "audit:doctrine: #{File.basename(path)} OK " \
+             "(#{spec.platform}, #{files.length} files)"
+      else
+        abort "audit:doctrine: #{File.basename(path)} MISSING: #{missing.join(', ')}"
+      end
+    end
+  end
+
   # @api private
   def nm_available?
     system("nm", "--version", out: File::NULL, err: File::NULL)

data/lib/leptris/version.rb

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

data/lib/leptris.rb

@@ -29,10 +29,13 @@ begin
 rescue LoadError => e
   raise LoadError, <<~MSG
     Leptris could not load the native libleptris library.
-    The ruby-platform gem is a fallback variant and ships no
-    binary; install the platform-specific variant for your system
-    (e.g. `gem install leptris --platform=arm64-darwin`), or set
-    LEPTRIS_LIB_PATH to a libleptris.{so,dylib,dll} file.
+    The ruby-platform gem carries the engine sources under
+    vendor-src/ and builds them at install time — a failed build
+    here usually means cmake or a C toolchain is missing (check
+    the gem install output). Alternatively install the
+    platform-specific variant for your system (e.g. `gem install
+    leptris --platform=arm64-darwin`), or set LEPTRIS_LIB_PATH to
+    a libleptris.{so,dylib,dll} file.
     (Underlying error: #{e.message})
   MSG
 end

data/vendor-src/README.md

@@ -0,0 +1,14 @@
+Sources vendored in this gem (recompile rights; the ruby
+variant builds them at install via extconf.rb):
+
+- libleptris v1.9.210
+- utf8proc v2.11.0
+
+Rebuild by hand:
+
+    cmake -B vendor-src/utf8proc/build -S vendor-src/utf8proc       -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON       -DUTF8PROC_ENABLE_TESTING=OFF
+    cmake --build vendor-src/utf8proc/build --config Release
+    cmake --install vendor-src/utf8proc/build --prefix <prefix>
+
+    cmake -B vendor-src/libleptris/build -S vendor-src/libleptris       -DCMAKE_BUILD_TYPE=Release       -DLEPTRIS_BUILD_SHARED=ON -DLEPTRIS_BUILD_STATIC=OFF       -DBUILD_TESTING=OFF -DLEPTRIS_BUILD_CLI=OFF       -DLEPTRIS_BUILD_BENCHMARKS=OFF -DLEPTRIS_BUILD_MAN_PAGES=OFF       -DLEPTRIS_ENABLE_UTF8PROC=ON       -DCMAKE_PREFIX_PATH=<utf8proc-prefix>
+    cmake --build vendor-src/libleptris/build --config Release

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
 
+## [1.9.210] - 2026-09-20
+
+### Added
+
+- The node-layout fork's document block (slice 1, #1253): two
+  contiguous geometrically-grown regions per document (dense node
+  array + string arena) with region-relative byte-offset edges —
+  growth never invalidates an offset. Foundation for the pugixml-
+  class parse layout (TODO.max-perf/node-layout-fork.md).
+
+### Performance
+
+- Large-document parse (#1222/#1238 lane, #1255): the parse arena
+  (~4x input) exceeded the arena retain cache's 32MB ceiling, so
+  every repeated-parse cycle freed and re-malloc'd tens of MB.
+  Ceiling raised to 96MB (one document's worth of parking) with a
+  thread-cleanup drain and ASAN free-for-real. Measured: 13MB
+  attr shape 341 -> 472 MB/s (+38%); the text shape's size-decline
+  eliminated (465 -> 163 MB/s falling across 1.5-13MB, now
+  ~605-627 flat).
+
+
+
 ## [1.9.209] - 2026-09-20
 
 ### Performance

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -47,6 +47,7 @@ set(LEPTRIS_SOURCES
 
     # Memory management
     leptris/memory/pool.c
+    leptris/memory/doc_block.c
     leptris/memory/arena.c
     leptris/dom/compact.c
     leptris/dom/root_doc_map.c

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

@@ -74,9 +74,11 @@ LEPTRIS_API void leptris_thread_cleanup(void) {
     extern void leptris_xpath_drain_thread_caches(void);
     extern void leptris_root_doc_drain_thread_caches(void);
     extern void leptris_pool_drain_recycler(void);
+    extern void leptris_arena_retain_drain(void);
     leptris_xpath_drain_thread_caches();
     leptris_root_doc_drain_thread_caches();
     leptris_pool_drain_recycler();
+    leptris_arena_retain_drain();
 }
 
 /* ---- Memory management API ---- */

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

@@ -51,7 +51,20 @@ static inline size_t align_up(size_t n) {
  * twice per document lifetime, so contention is irrelevant. */
 #define ARENA_RETAIN_MIN (256u * 1024u)
 #define ARENA_RETAIN_MAX_BLOCKS 4u
-#define ARENA_RETAIN_MAX_BYTES (32u * 1024u * 1024u)
+/* 96MB: a large-document parse arena (~4x input with the
+ * pre-sized estimate) must survive the free to be reused by the
+ * next parse — at the old 32MB ceiling, every big-doc cycle
+ * freed and re-malloc'd tens of MB (libc madvise showed ~2% of
+ * repeated-parse wall time). One document's worth of parking. */
+#define ARENA_RETAIN_MAX_BYTES (96u * 1024u * 1024u)
+
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+#define ARENA_RETAIN_ASAN 1
+#endif
+#elif defined(__SANITIZE_ADDRESS__)
+#define ARENA_RETAIN_ASAN 1
+#endif
 
 static struct {
     char* base[ARENA_RETAIN_MAX_BLOCKS];
@@ -106,6 +119,14 @@ static char* retain_take(size_t request, size_t* capacity) {
 }
 
 static void retain_give(char* base, size_t size) {
+#ifdef ARENA_RETAIN_ASAN
+    /* ASAN: retained blocks have no TLS destructor and read as
+     * LSan leaks — free for real (the recycle win is measurable
+     * only in repeated-parse loops, which ASAN runs don't gate). */
+    (void)size;
+    leptris_free_hook(base);
+    return;
+#endif
     if (size < ARENA_RETAIN_MIN) {
         leptris_free_hook(base);
         return;
@@ -124,6 +145,18 @@ static void retain_give(char* base, size_t size) {
     retain_unlock();
 }
 
+/* Host-invoked drain (leptris_thread_cleanup): the retained
+ * blocks are process-lifetime parking by design; release them so
+ * embedded hosts and leak checkers see a clean exit. */
+void leptris_arena_retain_drain(void) {
+    retain_lock();
+    for (size_t i = 0; i < g_retain.count; i++)
+        leptris_free_hook(g_retain.base[i]);
+    g_retain.count = 0;
+    g_retain.bytes = 0;
+    retain_unlock();
+}
+
 char* leptris_arena_buffer_alloc(size_t size) {
     size_t capacity = size;
     char* base = retain_take(size, &capacity);

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

@@ -55,6 +55,9 @@ void leptris_arena_reset(LeptrisArena* arena);
  * All pointers handed out by the arena become invalid. */
 void leptris_arena_destroy(LeptrisArena* arena);
 
+/* Release retained arena blocks (leptris_thread_cleanup drain). */
+void leptris_arena_retain_drain(void);
+
 /* Bump-allocate `size` bytes, 8-byte aligned. NOT zeroed.
  * Returns NULL when the request does not fit in remaining space —
  * no fallback allocation, ever (see the contract above). */

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

@@ -0,0 +1,108 @@
+/* doc_block.c — the node-layout fork's document block (slice 1).
+ * See doc_block.h for the design contract. */
+
+#include "doc_block.h"
+#include <stdlib.h>
+#include <string.h>
+
+#define DOC_BLOCK_MIN_CAP ((size_t)4096)
+#define DOC_BLOCK_ALIGN   ((size_t)8)
+
+struct LeptrisDocBlock {
+    char*  nodes;        /* node region base (8-aligned) */
+    size_t nodes_cap;
+    size_t nodes_used;
+    char*  strs;         /* string region base */
+    size_t strs_cap;
+    size_t strs_used;
+};
+
+static char* region_grow(char* p, size_t* cap, size_t need) {
+    size_t want = *cap ? *cap : DOC_BLOCK_MIN_CAP;
+    while (want < need) want *= 2;
+    char* grown = (char*)realloc(p, want);
+    if (grown) *cap = want;
+    return grown;
+}
+
+LeptrisDocBlock* leptris_doc_block_create(size_t initial_capacity) {
+    LeptrisDocBlock* b =
+        (LeptrisDocBlock*)calloc(1, sizeof(*b));
+    if (!b) return NULL;
+    if (initial_capacity && initial_capacity < DOC_BLOCK_MIN_CAP)
+        initial_capacity = DOC_BLOCK_MIN_CAP;
+    if (initial_capacity) {
+        b->nodes = (char*)malloc(initial_capacity);
+        b->strs = (char*)malloc(initial_capacity);
+        if (!b->nodes || !b->strs) {
+            free(b->nodes);
+            free(b->strs);
+            free(b);
+            return NULL;
+        }
+        b->nodes_cap = b->strs_cap = initial_capacity;
+    }
+    return b;
+}
+
+void leptris_doc_block_free(LeptrisDocBlock* b) {
+    if (!b) return;
+    free(b->nodes);
+    free(b->strs);
+    free(b);
+}
+
+size_t leptris_doc_block_node_alloc(LeptrisDocBlock* b, size_t sz) {
+    if (!b || sz == 0 || sz > (size_t)-1 / 2) return (size_t)-1;
+    size_t off = (b->nodes_used + DOC_BLOCK_ALIGN - 1) &
+                 ~(DOC_BLOCK_ALIGN - 1);
+    size_t need = off + sz;
+    if (need > b->nodes_cap) {
+        char* grown = region_grow(b->nodes, &b->nodes_cap, need);
+        if (!grown) return (size_t)-1;
+        b->nodes = grown;
+    }
+    b->nodes_used = need;
+    return off;
+}
+
+size_t leptris_doc_block_str(LeptrisDocBlock* b, const char* s,
+                             size_t len) {
+    if (!b || (!s && len)) return (size_t)-1;
+    size_t need = b->strs_used + len + 1;
+    if (need > b->strs_cap) {
+        char* grown = region_grow(b->strs, &b->strs_cap, need);
+        if (!grown) return (size_t)-1;
+        b->strs = grown;
+    }
+    size_t off = b->strs_used;
+    if (len) memcpy(b->strs + off, s, len);
+    b->strs[off + len] = '\0';
+    b->strs_used = need;
+    return off;
+}
+
+void* leptris_doc_block_node(const LeptrisDocBlock* b, size_t off) {
+    return (b && off < b->nodes_used) ? b->nodes + off : NULL;
+}
+
+void* leptris_doc_block_nodes_base(const LeptrisDocBlock* b) {
+    return b ? b->nodes : NULL;
+}
+
+size_t leptris_doc_block_nodes_used(const LeptrisDocBlock* b) {
+    return b ? b->nodes_used : 0;
+}
+
+const char* leptris_doc_block_str_at(const LeptrisDocBlock* b,
+                                     size_t off) {
+    return (b && off < b->strs_used) ? b->strs + off : NULL;
+}
+
+size_t leptris_doc_block_bytes_used(const LeptrisDocBlock* b) {
+    return b ? b->nodes_used + b->strs_used : 0;
+}
+
+size_t leptris_doc_block_capacity(const LeptrisDocBlock* b) {
+    return b ? b->nodes_cap + b->strs_cap : 0;
+}

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

@@ -0,0 +1,61 @@
+/* lib/src/memory/doc_block.h — the node-layout fork's document
+ * block (TODO.max-perf/node-layout-fork, slice 1).
+ *
+ * Two contiguous, geometrically-grown regions per document — a
+ * dense node array and a string arena. Every reference to either
+ * is a byte OFFSET within its region, so growth (realloc) never
+ * invalidates an edge: callers hold offsets, not pointers, and
+ * refetch region bases after any allocation.
+ *
+ * Differences vs memory/pool.c (which stays for mutation paths):
+ * the pool chains fixed 32KB pages, scattering one tree across
+ * pages; each parse node pays compact-edge encoding and detached
+ * nodes pay root-doc registration. Here the tree is contiguous
+ * (walk locality), edges are plain offsets (no cp16 overflow
+ * table), and the owning document is implied by the region base.
+ */
+#ifndef LEPTRIS_MEMORY_DOC_BLOCK_H
+#define LEPTRIS_MEMORY_DOC_BLOCK_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct LeptrisDocBlock LeptrisDocBlock;
+
+/* Create with an initial byte capacity per region (grown
+ * geometrically on demand; 0 = lazy). NULL on failure. */
+LeptrisDocBlock* leptris_doc_block_create(size_t initial_capacity);
+
+void leptris_doc_block_free(LeptrisDocBlock* b);
+
+/* Node region: bump-allocate sz bytes, 8-byte aligned. Returns
+ * the node's offset in the region (stable across growth) — never
+ * a pointer; resolve via leptris_doc_block_node. (size_t)-1 on
+ * failure. Growth may realloc: refetch any held pointers. */
+size_t leptris_doc_block_node_alloc(LeptrisDocBlock* b, size_t sz);
+
+/* String region: append len bytes plus a NUL. Returns the
+ * string's offset in ITS region (stable across growth) or
+ * (size_t)-1 on failure. */
+size_t leptris_doc_block_str(LeptrisDocBlock* b, const char* s,
+                             size_t len);
+
+/* Resolve an offset (region base + off, one add). */
+void* leptris_doc_block_node(const LeptrisDocBlock* b, size_t off);
+
+void* leptris_doc_block_nodes_base(const LeptrisDocBlock* b);
+size_t leptris_doc_block_nodes_used(const LeptrisDocBlock* b);
+const char* leptris_doc_block_str_at(const LeptrisDocBlock* b,
+                                     size_t off);
+size_t leptris_doc_block_bytes_used(const LeptrisDocBlock* b);
+size_t leptris_doc_block_capacity(const LeptrisDocBlock* b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LEPTRIS_MEMORY_DOC_BLOCK_H */

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

@@ -116,6 +116,7 @@ leptris_add_test(test_simd_spans common/test_simd_spans.cpp)
 leptris_add_test(test_pool       memory/test_pool.cpp)
 leptris_add_test(test_oom        memory/test_oom_injection.cpp)
 leptris_add_test(test_arena      memory/test_arena.cpp)
+leptris_add_test(test_doc_block memory/test_doc_block.cpp)
 leptris_add_test(test_pool_arena memory/test_pool_arena.cpp)
 leptris_add_test(test_xpath      xpath/test_xpath.cpp)
 leptris_add_test(test_exslt       xpath/test_exslt.cpp)

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

@@ -192,11 +192,25 @@ TEST(Arena, AllPointersWithinSpanForCompactEncoding) {
 
 /* ---- Retained-block free list (parse fault fix) ---------------------- */
 
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+#define ARENA_TESTS_ASAN 1
+#endif
+#elif defined(__SANITIZE_ADDRESS__)
+#define ARENA_TESTS_ASAN 1
+#endif
+
 TEST(LeptrisArena, RetainsAndReusesLargeBlocks) {
     /* Blocks >= 256 KB must round-trip through the free list: the
      * next same-size create gets the SAME mapping back (no munmap,
      * no page faults). Machine-independent by construction: it
      * asserts pointer identity, not timing. */
+    /* Under ASAN the retain cache frees for real (no TLS
+     * destructor; parked blocks read as LSan leaks) — the reuse
+     * contract is deliberately disabled there. */
+#if defined(ARENA_TESTS_ASAN)
+    GTEST_SKIP() << "retain cache disabled under ASAN";
+#endif
     const size_t big = 512u * 1024u;
     LeptrisArena* a1 = leptris_arena_create(big);
     ASSERT_NE(a1, nullptr);
@@ -239,6 +253,13 @@ TEST(LeptrisArena, SmallBlocksStillMallocSemantics) {
 }
 
 TEST(LeptrisArena, BufferRoundTripReusesMapping) {
+/* Under ASAN the retain cache frees for real (no TLS
+     * destructor; parked blocks read as LSan leaks) — the reuse
+     * contract is deliberately disabled there. */
+#if defined(ARENA_TESTS_ASAN)
+    GTEST_SKIP() << "retain cache disabled under ASAN";
+#endif
+
     char* b1 = leptris_arena_buffer_alloc(512u * 1024u);
     ASSERT_NE(b1, nullptr);
     memset(b1, 1, 512u * 1024u);

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

@@ -0,0 +1,94 @@
+// test/memory/test_doc_block.cpp - the node-layout fork's document
+// block (slice 1). Falsifiable contract: offsets stay valid across
+// geometric growth, regions stay dense/aligned, boundary inputs
+// are refused.
+
+#include <gtest/gtest.h>
+#include <cstring>
+#include <cstdio>
+#include <vector>
+#include "../../src/leptris/memory/doc_block.h"
+
+typedef struct {
+    uint32_t first_child;
+    uint32_t next;
+    uint32_t name_off;
+} TNode;
+
+TEST(DocBlock, OffsetsSurviveGrowth) {
+    LeptrisDocBlock* b = leptris_doc_block_create(0);
+    ASSERT_NE(b, nullptr);
+    std::vector<uint32_t> offs;
+    const int N = 20000;
+    for (int i = 0; i < N; i++) {
+        size_t off = leptris_doc_block_node_alloc(b, sizeof(TNode));
+        ASSERT_NE(off, (size_t)-1);
+        ASSERT_EQ(off % 8u, 0u);
+        TNode* n = (TNode*)leptris_doc_block_node(b, off);
+        ASSERT_NE(n, nullptr);
+        n->first_child = 0;
+        n->next = i > 0 ? offs[i - 1] : 0;
+        n->name_off = 0;
+        offs.push_back((uint32_t)off);
+        if (i % 1000 == 0) {
+            for (size_t k = 1; k < offs.size(); k++) {
+                const TNode* p =
+                    (const TNode*)leptris_doc_block_node(b, offs[k]);
+                ASSERT_NE(p, nullptr);
+                ASSERT_EQ(p->next, offs[k - 1]);
+            }
+        }
+    }
+    EXPECT_GT(leptris_doc_block_capacity(b), (size_t)0);
+    leptris_doc_block_free(b);
+}
+
+TEST(DocBlock, StringRegionStableAcrossGrowth) {
+    LeptrisDocBlock* b = leptris_doc_block_create(64);
+    ASSERT_NE(b, nullptr);
+    std::vector<size_t> offs;
+    char buf[32];
+    for (int i = 0; i < 5000; i++) {
+        int n = snprintf(buf, sizeof(buf), "name-%05d", i);
+        size_t off = leptris_doc_block_str(b, buf, (size_t)n);
+        ASSERT_NE(off, (size_t)-1);
+        offs.push_back(off);
+    }
+    for (int i = 0; i < 5000; i += 500) {
+        int n = snprintf(buf, sizeof(buf), "name-%05d", i);
+        const char* s = leptris_doc_block_str_at(b, offs[i]);
+        ASSERT_NE(s, nullptr);
+        EXPECT_EQ(std::memcmp(s, buf, (size_t)n), 0);
+        EXPECT_EQ(s[n], '\0');
+    }
+    leptris_doc_block_free(b);
+}
+
+TEST(DocBlock, BoundaryInputsRefused) {
+    LeptrisDocBlock* b = leptris_doc_block_create(0);
+    ASSERT_NE(b, nullptr);
+    EXPECT_EQ(leptris_doc_block_node_alloc(b, 0), (size_t)-1);
+    EXPECT_EQ(leptris_doc_block_node_alloc(nullptr, 8), (size_t)-1);
+    EXPECT_EQ(leptris_doc_block_str(b, nullptr, 3), (size_t)-1);
+    size_t off = leptris_doc_block_str(b, "", 0);
+    EXPECT_NE(off, (size_t)-1);
+    EXPECT_STREQ(leptris_doc_block_str_at(b, off), "");
+    EXPECT_EQ(leptris_doc_block_node(b, 1 << 20), nullptr);
+    leptris_doc_block_free(b);
+    leptris_doc_block_free(nullptr);
+}
+
+TEST(DocBlock, NodesAndStringsIndependent) {
+    LeptrisDocBlock* b = leptris_doc_block_create(0);
+    ASSERT_NE(b, nullptr);
+    size_t n1 = leptris_doc_block_node_alloc(b, 16);
+    size_t s1 = leptris_doc_block_str(b, "abc", 3);
+    size_t n2 = leptris_doc_block_node_alloc(b, 16);
+    size_t s2 = leptris_doc_block_str(b, "defg", 4);
+    EXPECT_NE(n1, n2);
+    EXPECT_NE(s1, s2);
+    EXPECT_STREQ(leptris_doc_block_str_at(b, s1), "abc");
+    EXPECT_STREQ(leptris_doc_block_str_at(b, s2), "defg");
+    EXPECT_EQ(leptris_doc_block_nodes_used(b), 32u);
+    leptris_doc_block_free(b);
+}

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.209",
+  "version": "1.9.210",
   "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.209.1
+  version: 1.9.210.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -205,6 +205,7 @@ files:
 - lib/leptris/xml/xquery.rb
 - lib/leptris/xml/xslt.rb
 - scripts/gem_smoke.rb
+- vendor-src/README.md
 - vendor-src/libleptris/CHANGELOG.md
 - vendor-src/libleptris/CLAUDE.md
 - vendor-src/libleptris/CMakeLists.txt
@@ -662,6 +663,8 @@ files:
 - vendor-src/libleptris/src/leptris/leptris_parse.h
 - vendor-src/libleptris/src/leptris/memory/arena.c
 - vendor-src/libleptris/src/leptris/memory/arena.h
+- vendor-src/libleptris/src/leptris/memory/doc_block.c
+- vendor-src/libleptris/src/leptris/memory/doc_block.h
 - vendor-src/libleptris/src/leptris/memory/pool.c
 - vendor-src/libleptris/src/leptris/memory/pool.h
 - vendor-src/libleptris/src/leptris/rng/parse.c
@@ -816,6 +819,7 @@ files:
 - vendor-src/libleptris/test/html/test_html.cpp
 - vendor-src/libleptris/test/html/test_html5lib.cpp
 - vendor-src/libleptris/test/memory/test_arena.cpp
+- vendor-src/libleptris/test/memory/test_doc_block.cpp
 - vendor-src/libleptris/test/memory/test_oom_injection.cpp
 - vendor-src/libleptris/test/memory/test_pool.cpp
 - vendor-src/libleptris/test/memory/test_pool_arena.cpp