leptris 1.9.268.0 → 1.9.270.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cba1727210a6adce592d6f84970bfcf2abb6b0cd6bba396bfc5714e0b6a2c00e
-  data.tar.gz: f8669f950703f4a01fbabc3feef084911a22ef169ec8c6debfe14f057579b591
+  metadata.gz: cb2a0e979362ca73a36edb1e16e47d1e69db7e3ce0f4dc1efc3fe012eeadfd53
+  data.tar.gz: ba0d63880b1060c14dda81a33b835c88c37a294dd093dd0bf9801d9ebea8070c
 SHA512:
-  metadata.gz: c3441867d08747f3ed67559e68c29e1c9b1a33b0df9ab29d919580d149a696ff422e20a339611ce52ea2e768c7dfe6ecc9881f5cd20e4575f8bcf7b59adb2fcb
-  data.tar.gz: 8421fd0b02bdd2a321bc998e75bddbf07aec3597740618fa38008b811b61e7726357323ae91c893d1b714ce233290b1055a2c8239dc1d0d0dc53bcdc412bae5d
+  metadata.gz: f1ec1c35f4d191afdaee7e5b5e4c799532d1ea58f4ad388f63b4ebfc3b7fbce759022f1a6be01b341d167c6998b6adfe72619e7e90ba2c261a3f26ca6f5b577f
+  data.tar.gz: 9c0d192018890d531cd645df8866164093baa9dbd9974fd0500b4bdc32ed566906fcb8d2bf3d7c748c223fb54df88124c6476f373d04fa21350b3739598ac7c4

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.268"
+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.268.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.268
+- libleptris v1.9.270
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [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

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.268
+    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_query.c

@@ -1661,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) {
@@ -1421,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;
@@ -2599,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/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/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/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.268",
+  "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.268.0
+  version: 1.9.270.0
 platform: ruby
 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