leptris 1.9.228.0-x86_64-linux → 1.9.229.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de81e97aa3ab8a52850dbb21c9b9fbfdd47707458ebc1132817cffd36bd7dcdf
-  data.tar.gz: b11e49c626fd6995a0b6c60fe0730dbec6543c88dac1951ea87345c0054de15f
+  metadata.gz: 94655f5964d22d85d415d8e8f8b48c7a8fc0772c6dec1bde5a3e539a1d569820
+  data.tar.gz: 8771d75bff1b08340b07b0db2c8996d4dcc9b65097d8766b62aeada7fd1e93a8
 SHA512:
-  metadata.gz: c6d7f0bff8c2b63decad14b04c787e7243521163ff505daa7e1e760b4d4cbf3a6c2d13e5f8b6306eaec2dd721f3508efca5f515bc333d6181232fefd0f2a7527
-  data.tar.gz: cc50b867785d0a8ee19b1185ac681fffc8e46677d8d3bc0e4897f60888741a155d56cde58d43ea7a72d7fca20fafd6bdf4230e23942052588489bcf6dfdbce65
+  metadata.gz: 205f207da94cc4e8378554692b658bb3bf4e99e5b21755f5933a59691c044304dbb28a92af2307a728409e9fce18b0a7658f0d8cec438168a72a962ccc9f77ba
+  data.tar.gz: 31528505abde42209dc834e1385b1f7c4693000f5f048a91ee8cc1f9c62ec47fd38e6b1b9781787afec368566909722f2b44e5735ee6adac14432e4e641488cf

data/CHANGELOG.md

@@ -5,6 +5,18 @@ 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.229.0] - 2026-09-23
+
+### Performance — engine sync (1.9.229)
+
+- Vendored libleptris 1.9.229: the text node struct shrinks
+  40 → 32 bytes on LP64 and ILP32 alike (#1285 slice 4b) — the
+  content pointer became an int32 self-relative offset with
+  doc-tagged overflow stamps (0 = NULL, shared sentinel for the
+  static empty string, byte offset otherwise; >2 GB deltas spill
+  to the overflow table tagged EXPLICIT). No binding-facing
+  surface changes; audit 351/351, suite 781/0.
+
 ## [1.9.228.0] - 2026-09-23
 
 ### Fixed — Text#content= on created-but-unattached text nodes (#318; engine 1.9.227–228)

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.228"
+LIBLEPTRIS_VERSION = "1.9.229"
 # 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.228.0"
+  VERSION = "1.9.229.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.228
+- libleptris v1.9.229
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
 
+## [1.9.229] - 2026-09-23
+
+### Performance
+
+- **dom: text node 40 → 32 bytes — content pointer became an int32
+  self-relative offset, with doc-tagged overflow stamps (#1285
+  slice 4b).** The struct is base + five int32s on both LP64 and
+  ILP32 (content off, uint32 len, int32 next, int32 parent, int32
+  owner doc). Encoding: 0 = NULL, a shared sentinel = the static
+  empty string (xsl:strip-space writes land there instead of one
+  overflow-table entry per stripped node), any other value a byte
+  offset from the node. **Thread safety:** the rare >2 GB delta
+  spills to the overflow table tagged with the EXPLICIT owning
+  document — the direct-parse lane is overflow-table-free by design
+  (it never sets the TLS current-doc), so a TLS-tagged spill leaked
+  the entry past document teardown, which Linux CI ASAN/LSan
+  surfaced as aborting the two concurrency tests. Every content
+  stamp now carries its document; the untagged setter is deleted
+  from the codebase. Local gates: 1683/1683 both parse lanes; the
+  CI ASAN leg that caught the leak is green.
+
+
+
 ## [1.9.228] - 2026-09-23
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -286,7 +286,9 @@ int32_t leptris_compact_int32_encode(void* base, void* target,
                                      const int32_t* field_addr) {
     if (!target) return 0;
     ptrdiff_t d = (char*)target - (char*)base;
-    if (d < INT32_MIN || d > INT32_MAX) {
+    /* INT32_MAX is the EMPTY sentinel (compact.h) — spill exact
+     * deltas there too so raw offsets never collide with it. */
+    if (d < INT32_MIN || d >= INT32_MAX) {
         LeptrisCompactOverflowTable* table = get_overflow_table();
         struct leptris_document* doc = get_current_document();
         if (table && leptris_compact_overflow_set(table, field_addr,

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

@@ -127,6 +127,15 @@ int32_t leptris_compact_int32_encode_doc(void* base, void* target,
  * value is INT32_MIN). */
 #define LEPTRIS_INT32_OVERFLOW_SENTINEL_H ((int32_t)(-2147483647 - 1))
 
+/* int32 sentinel for a non-NULL static "" pointer (#1285 slice 4b).
+ * Text content can be set to the empty string from far-away
+ * read-only storage (xsl:strip-space field writes); encoding that
+ * address would register one overflow-table entry per stripped
+ * node. Decoding returns a shared "" instead. Collision-free: the
+ * encode fast path below spills exact-INT32_MAX deltas to the
+ * overflow table, so no raw offset ever equals this value. */
+#define LEPTRIS_COMPACT_INT32_EMPTY ((int32_t)2147483647)
+
 /* Inline fast paths (lane 18): the shared encode/decode live in
  * compact.c, so every tree-edge store or sibling/parent read paid an
  * out-of-line call — two per node in the parse loop and one per edge
@@ -140,7 +149,10 @@ static inline int32_t leptris_compact_int32_encode_inline(
     void* base, void* target, const int32_t* field_addr) {
     if (!target) return 0;
     ptrdiff_t d = (char*)target - (char*)base;
-    if (d < INT32_MIN || d > INT32_MAX)
+    /* INT32_MAX is the EMPTY sentinel — a real delta of exactly
+     * that size spills to the overflow table (correct, just not
+     * inline). */
+    if (d < INT32_MIN || d >= INT32_MAX)
         return leptris_compact_int32_encode(base, target, field_addr);
     return (int32_t)d;
 }

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

@@ -677,7 +677,8 @@ LeptrisStatus leptris_element_set_text(LeptrisElement elem, const char* text) {
     if (text) {
         /* Create new text node (even if empty to match pugixml behavior) */
         LeptrisMemoryPool* pool = leptris_element_get_pool(elem);
-        LeptrisTextNode* text_node = leptris_text_create(text, strlen(text), pool);
+        LeptrisTextNode* text_node = leptris_text_create(text, strlen(text), pool,
+            leptris_element_get_document(elem));
         if (!text_node) {
             return LEPTRIS_ERROR_MEMORY;
         }
@@ -1341,9 +1342,10 @@ LeptrisElement leptris_element_append_copy(LeptrisElement parent, LeptrisElement
             LeptrisTextNode* text = (LeptrisTextNode*)child;
             /* SAFETY: Verify text pointer is valid before accessing content */
             if ((uintptr_t)text > 0x1000) {
-                LeptrisTextNode* text_copy = leptris_text_create(text->content,
+                LeptrisTextNode* text_copy = leptris_text_create(leptris_textnode_content(text),
                     text->content_len,
-                    leptris_element_get_pool(copy));
+                    leptris_element_get_pool(copy),
+                    leptris_element_get_document(copy));
                 if (text_copy) {
                     leptris_element_append_child_internal(copy, (LeptrisNode*)text_copy);
                 }
@@ -1507,9 +1509,10 @@ LeptrisElement leptris_element_prepend_copy(LeptrisElement parent, LeptrisElemen
             leptris_element_append_copy(copy, child);
         } else if (child_node->type == LEPTRIS_NODE_TYPE_TEXT) {
             LeptrisTextNode* text = (LeptrisTextNode*)child;
-            LeptrisTextNode* text_copy = leptris_text_create(text->content,
+            LeptrisTextNode* text_copy = leptris_text_create(leptris_textnode_content(text),
                 text->content_len,
-                leptris_element_get_pool(copy));
+                leptris_element_get_pool(copy),
+                leptris_element_get_document(copy));
             if (text_copy) {
                 leptris_element_append_child_internal(copy, (LeptrisNode*)text_copy);
             }
@@ -1622,9 +1625,10 @@ LeptrisElement leptris_element_insert_copy_after(LeptrisElement sibling, Leptris
             leptris_element_append_copy(copy, child);
         } else if (child_node->type == LEPTRIS_NODE_TYPE_TEXT) {
             LeptrisTextNode* text = (LeptrisTextNode*)child;
-            LeptrisTextNode* text_copy = leptris_text_create(text->content,
+            LeptrisTextNode* text_copy = leptris_text_create(leptris_textnode_content(text),
                 text->content_len,
-                leptris_element_get_pool(copy));
+                leptris_element_get_pool(copy),
+                leptris_element_get_document(copy));
             if (text_copy) {
                 leptris_element_append_child_internal(copy, (LeptrisNode*)text_copy);
             }
@@ -1737,9 +1741,10 @@ LeptrisElement leptris_element_insert_copy_before(LeptrisElement sibling, Leptri
             leptris_element_append_copy(copy, child);
         } else if (child_node->type == LEPTRIS_NODE_TYPE_TEXT) {
             LeptrisTextNode* text = (LeptrisTextNode*)child;
-            LeptrisTextNode* text_copy = leptris_text_create(text->content,
+            LeptrisTextNode* text_copy = leptris_text_create(leptris_textnode_content(text),
                 text->content_len,
-                leptris_element_get_pool(copy));
+                leptris_element_get_pool(copy),
+                leptris_element_get_document(copy));
             if (text_copy) {
                 leptris_element_append_child_internal(copy, (LeptrisNode*)text_copy);
             }
@@ -1925,9 +1930,10 @@ static LeptrisElement leptris_element_copy_subtree_bulk_internal(
         } else if (child_node->type == LEPTRIS_NODE_TYPE_TEXT) {
             /* Copy text node (not bulk-allocated) */
             LeptrisTextNode* text = (LeptrisTextNode*)child;
-            LeptrisTextNode* text_copy = leptris_text_create(text->content,
+            LeptrisTextNode* text_copy = leptris_text_create(leptris_textnode_content(text),
                 text->content_len,
-                leptris_element_get_pool(copy));
+                leptris_element_get_pool(copy),
+                leptris_element_get_document(copy));
             if (text_copy) {
                 /* Link as child using internal function */
                 leptris_element_append_child_internal(copy, (LeptrisNode*)text_copy);
@@ -2066,8 +2072,8 @@ static LeptrisElement copy_subtree_detached(LeptrisElement source,
                                                        copy, pool, doc);
         } else if (ty == LEPTRIS_NODE_TYPE_TEXT) {
             LeptrisTextNode* t = (LeptrisTextNode*)c;
-            cc = (LeptrisNodeRef)leptris_text_create(t->content,
-                                                     t->content_len, pool);
+            cc = (LeptrisNodeRef)leptris_text_create(leptris_textnode_content(t),
+                                                     t->content_len, pool, doc);
             if (cc) leptris_textnode_set_parent((LeptrisTextNode*)cc, copy);
         } else if (ty == LEPTRIS_NODE_TYPE_CDATA) {
             LeptrisCDATANode* cd = (LeptrisCDATANode*)c;

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

@@ -333,7 +333,7 @@ LEPTRIS_API LeptrisNodeRef leptris_text_node_create(LeptrisDocument doc,
     if (!doc->pool) return NULL;
     if (!content) content = "";
     size_t len = strlen(content);
-    LeptrisTextNode* n = leptris_text_create(content, len, doc->pool);
+    LeptrisTextNode* n = leptris_text_create(content, len, doc->pool, doc);
     if (n) {
         /* #1320: stamp the owner so detached mutations can reach the
          * doc's pool (PI/comment/CDATA do this via owner_doc fields;
@@ -416,7 +416,7 @@ LEPTRIS_API LeptrisStatus leptris_text_node_set_content(LeptrisNodeRef node,
     if (!doc || !doc->pool) return LEPTRIS_ERROR_INVALID_ARG;
     char* copy = node_public_pool_strdup(doc->pool, content, len);
     if (!copy) return LEPTRIS_ERROR_MEMORY;
-    t->content = copy;
+    leptris_textnode_set_content_ptr_doc(t, copy, doc);
     t->content_len = (uint32_t)len;
     return LEPTRIS_OK;
 }

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

@@ -18,7 +18,8 @@
  * CRITICAL: Content is NEVER trimmed — preserved exactly as given. */
 LeptrisTextNode* leptris_text_create(const char* content,
                                     size_t content_len,
-                                    LeptrisMemoryPool* pool) {
+                                    LeptrisMemoryPool* pool,
+                                    struct leptris_document* doc) {
     if (!pool) return NULL;
 
     char* content_storage;
@@ -38,7 +39,10 @@ LeptrisTextNode* leptris_text_create(const char* content,
         memcpy(content_storage, content, content_len);
     }
     content_storage[content_len] = '\0';
-    node->content = content_storage;
+    /* Contiguous with the node in the same pool alloc — the offset
+     * is a small positive delta; doc tags the oversized-content
+     * fallback should it ever leave the inline window. */
+    leptris_textnode_set_content_ptr_doc(node, content_storage, doc);
     node->content_len = (uint32_t)content_len;
 
     return node;
@@ -54,7 +58,8 @@ LeptrisTextNode* leptris_text_create(const char* content,
  * the parser's pool. */
 LeptrisTextNode* leptris_text_create_borrowed(const char* content,
                                              size_t content_len,
-                                             LeptrisMemoryPool* pool) {
+                                             LeptrisMemoryPool* pool,
+                                             struct leptris_document* doc) {
     if (!pool) return NULL;
 
     LeptrisTextNode* node = (LeptrisTextNode*)leptris_pool_alloc(pool, sizeof(LeptrisTextNode));
@@ -67,7 +72,11 @@ LeptrisTextNode* leptris_text_create_borrowed(const char* content,
      * uninitialized raw bit silently flips DOE/cdata behavior by
      * build configuration. */
     node->base.raw = 0;
-    node->content = (char*)content;  /* Non-owning; caller guarantees lifetime + termination. */
+    /* Non-owning view into the doc-owned buffer; caller guarantees
+     * lifetime + termination (#1285 slice 4). The buffer-to-node
+     * distance crosses allocations — the doc-tagged stamp is
+     * MANDATORY here (TLS is unset on parse worker threads). */
+    leptris_textnode_set_content_ptr_doc(node, content, doc);
     node->content_len = (uint32_t)content_len;
     node->parent_off = 0;
     node->next_sibling_off = 0;
@@ -95,5 +104,6 @@ void leptris_text_free(LeptrisTextNode* text) {
  * here. */
 const char* leptris_text_get_content(LeptrisTextNode* text) {
     if (!text) return NULL;
-    return text->content ? text->content : "";
+    const char* c = leptris_textnode_content(text);
+    return c ? c : "";
 }

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

@@ -11,12 +11,12 @@
 #include "node.h"
 #include "compact.h"  /* compact-pointer helpers (TODO 121, TODO 178) */
 
-/* Text node - inherits from LeptrisNode. 48 bytes (#1285 slice 4,
- * was 64 — the pool/borrowed fields are gone because content is
- * ALWAYS NUL-terminated: every producer terminates in place, so
- * leptris_text_get_content is a plain field read).
+/* Text node - inherits from LeptrisNode. 32 bytes (#1285 slice 4b +
+ * #1320, was 40 — the content pointer became an int32 self-relative
+ * byte offset and the detached-owner backref joined it; base 12 +
+ * five int32s on both LP64 and ILP32).
  *
- * #1285 slice 4 invariants:
+ * #1285 slice 4 invariants (unchanged):
  * - `content` is NUL-terminated at content[content_len] in ALL
  *   cases — pooled copies (leptris_text_create) and in-place runs
  *   into the doc-owned input buffer alike (every parse lane
@@ -25,6 +25,17 @@
  *   (dp_text_create rejects beyond that); parse buffers that size
  *   are outside every supported target.
  *
+ * #1285 slice 4b content_off encoding:
+ * - 0 = NULL (zero-init pool memory reads as no content).
+ * - LEPTRIS_COMPACT_INT32_EMPTY = the static "" (xsl:strip-space
+ *   field writes point at a read-only literal far from any node;
+ *   the shared sentinel avoids one overflow-table entry per
+ *   stripped node).
+ * - anything else = byte offset from the node itself; deltas beyond
+ *   int32 range spill to the overflow table (compact.h machinery,
+ *   same as parent/sibling edges — ASLR can place the pool and the
+ *   doc-owned input buffer > 2 GB apart).
+ *
  * Issue #168: parent_off mirrors next_sibling_off so the parent of a
  * text node can be queried in O(1).
  *
@@ -37,7 +48,7 @@
  * LP64 struct keeps its 40 bytes (padding absorbs it). */
 typedef struct leptris_text_node {
     LeptrisNode base;                   /* MUST be first */
-    char* content;                    /* Text content - NEVER trim! NUL-terminated at [content_len] */
+    int32_t content_off;              /* Self-relative offset to NUL-terminated content (0=NULL, EMPTY=static "") */
     uint32_t content_len;             /* Byte length (excl. NUL); 4 GB cap */
     /* (#450) int32 sibling edge — was cp16 (±256 KB). Text nodes
      * link to ELEMENT siblings across the parse-time element↔text
@@ -61,28 +72,37 @@ typedef struct leptris_text_node {
  * have a length-bounded view).  Passing 0 with non-NULL content is
  * treated as an empty string.
  *
+ * `doc` (#1285 slice 4b thread safety): the content offset is
+ * node-relative int32; the rare >2GB delta (oversized-content pool
+ * path under far-apart allocators) spills to the overflow table and
+ * MUST be tagged with the owning document — a NULL/TLS tag leaks the
+ * entry past doc teardown (Linux-ASAN/LSan catches it). Every caller
+ * has the doc.
+ *
  * Ownership: pool-allocated; leptris_document_free releases via pool. */
 LeptrisTextNode* leptris_text_create(const char* content,
                                     size_t content_len,
-                                    LeptrisMemoryPool* pool);
+                                    LeptrisMemoryPool* pool,
+                                    struct leptris_document* doc);
 
 /* Create a text node borrowing the caller's bytes (parse hot path).
  *
  * The node struct is pool-allocated; `content` is stored as a
- * non-owning pointer into the caller's buffer — no memcpy. CALLER
+ * non-owning view into the caller's buffer — no memcpy. CALLER
  * CONTRACT (#1285 slice 4): the run MUST already be NUL-terminated
  * at content[content_len] and must outlive the document (parse
  * lanes terminate the run in the doc-owned input copy before
- * carving the node). */
+ * carving the node). `doc` tags the overflow entry when the
+ * buffer-to-node distance exceeds int32 range (see leptris_text_create). */
 LeptrisTextNode* leptris_text_create_borrowed(const char* content,
                                              size_t content_len,
-                                             LeptrisMemoryPool* pool);
+                                             LeptrisMemoryPool* pool,
+                                             struct leptris_document* doc);
 
 void leptris_text_free(LeptrisTextNode* text);
 
 /* Content access */
 const char* leptris_text_get_content(LeptrisTextNode* text);
-void leptris_text_set_content(LeptrisTextNode* text, const char* content);
 
 /* Casting helpers */
 #define LEPTRIS_NODE_AS_TEXT(node) \
@@ -119,6 +139,41 @@ static inline void leptris_textnode_set_parent(LeptrisTextNode* t, LeptrisElemen
     t->parent_off = leptris_compact_int32_encode_inline(t, parent, &t->parent_off);
 }
 
+/* Compact content accessors (#1285 slice 4b). The content pointer
+ * is a self-relative int32 byte offset — same encoding as the edges
+ * above. Writers that store an empty string land on the shared
+ * EMPTY sentinel; pooled and in-place runs are a small positive
+ * offset from the node (the create paths allocate struct + content
+ * contiguously); far targets (static literals, cross-block buffer
+ * runs) spill to the overflow table. */
+static inline const char* leptris_textnode_content(const LeptrisTextNode* t) {
+    if (!t || t->content_off == 0) return NULL;
+    if (t->content_off == LEPTRIS_COMPACT_INT32_EMPTY) return "";
+    return (const char*)leptris_compact_int32_decode_inline(
+        (void*)t, t->content_off, &t->content_off);
+}
+
+/* Doc-tagged stamp (#1285 slice 4b thread safety). Identical to
+ * set_content_ptr except the >2GB spill registers in the overflow
+ * table tagged with the EXPLICIT document (the TLS current-doc slot
+ * is unset on parse worker threads — dp is overflow-table-free by
+ * design — so a TLS-tagged entry leaks past doc teardown and Linux
+ * CI ASAN/LSan aborts the run). Parse-lane and builder sites MUST
+ * use this form; the pooled-create contiguous path never spills but
+ * takes doc anyway so the oversized-content fallback is covered. */
+static inline void leptris_textnode_set_content_ptr_doc(
+    LeptrisTextNode* t, const char* p, struct leptris_document* doc) {
+    if (!t) return;
+    if (!p) { t->content_off = 0; return; }
+    if (*p == '\0') { t->content_off = LEPTRIS_COMPACT_INT32_EMPTY; return; }
+    ptrdiff_t d = (char*)p - (char*)t;
+    if (d < INT32_MIN || d >= INT32_MAX)
+        t->content_off = leptris_compact_int32_encode_doc(
+            t, (void*)p, &t->content_off, doc);
+    else
+        t->content_off = (int32_t)d;
+}
+
 /* Owning-document access (issue #1320). The stamp is written by
  * leptris_text_node_create with the explicit-doc encoder (an
  * overflow-table entry made outside a parse context must carry the

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

@@ -173,8 +173,10 @@ static int element_has_char_content(LeptrisElement elem) {
         unsigned t = leptris_node_get_type(child);
         if (t == LEPTRIS_NODE_TYPE_TEXT) {
             const LeptrisTextNode* tn = (const LeptrisTextNode*)child;
+            const char* tc = leptris_textnode_content(tn);
+            if (!tc) continue;
             for (size_t i = 0; i < tn->content_len; i++) {
-                if (!isspace((unsigned char)tn->content[i])) return 1;
+                if (!isspace((unsigned char)tc[i])) return 1;
             }
         } else if (t == LEPTRIS_NODE_TYPE_CDATA) {
             const LeptrisCDATANode* cn = (const LeptrisCDATANode*)child;

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

@@ -991,7 +991,7 @@ static inline LeptrisTextNode* dp_text_create(DParser* p,
             p->pool, 128 * sizeof(LeptrisTextNode));
         if (!tn) {
             return leptris_text_create_borrowed(content, content_len,
-                                               p->pool);
+                                               p->pool, p->doc);
         }
         p->text_end = tn + 128;
         /* cursor == tn: carve below */
@@ -1010,7 +1010,7 @@ static inline LeptrisTextNode* dp_text_create(DParser* p,
      * carve (dispatch-entry dp_nul / walker '&' NUL / EOF sentinel)
      * — the terminator write lives with the byte's last reader, not
      * here. */
-    tn->content = (char*)content;
+    leptris_textnode_set_content_ptr_doc(tn, content, p->doc);
     tn->content_len = (uint32_t)content_len;
     tn->parent_off = 0;
     tn->next_sibling_off = 0;
@@ -1443,7 +1443,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                                 leptris_decode_entities_view(&ssv, pool);
                             if (sexp) {
                                 rt = leptris_text_create(
-                                    sexp, strlen(sexp), pool);
+                                    sexp, strlen(sexp), pool, p.doc);
                             }
                         }
                         if (!rt) {
@@ -1482,7 +1482,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                         LeptrisStringView ssv = leptris_sv_from_ptr(seg, slen);
                         char* sexp = leptris_decode_entities_view(&ssv, pool);
                         if (sexp) {
-                            rt = leptris_text_create(sexp, strlen(sexp), pool);
+                            rt = leptris_text_create(sexp, strlen(sexp), pool, p.doc);
                         }
                     }
                     if (!rt) {
@@ -1512,7 +1512,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                           &sv, p.dtd, pool)
                     : leptris_decode_entities_view(&sv, pool);
                 if (expanded) {
-                    tn = leptris_text_create(expanded, strlen(expanded), pool);
+                    tn = leptris_text_create(expanded, strlen(expanded), pool, p.doc);
                 } else {
                     tn = dp_text_create(&p, text_start, tlen);
                 }
@@ -2592,7 +2592,7 @@ static struct leptris_document* dp_il_build(
             tn->base.type = LEPTRIS_NODE_TYPE_TEXT;
             tn->base.frozen = 1;
             tn->base.line = r->line;
-            tn->content = (char*)content;
+            leptris_textnode_set_content_ptr_doc(tn, content, doc);
             tn->content_len = r->len;
             /* (slice 4: pool/borrowed fields gone; the il scratch
              * run is already NUL-terminated at carve) */
@@ -2639,7 +2639,8 @@ oom_early:
 int leptris_il_run(const char* xml, size_t len, int drop_ws,
                    IlCtx* c, char** scratch_out, uint32_t* root_out) {
     *scratch_out = NULL;
-    c->recs = c->attrs = NULL;
+    c->recs = NULL;
+    c->attrs = NULL;
     c->nrec = c->crec = c->nattr = c->cattr = 0;
     c->depth = 0;
     if (!xml || len == 0 || len >= 0x7FFFFFFFu) return 0;

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

@@ -3908,7 +3908,7 @@ static void h_append(HBuilder* b, LeptrisNodeRef n) {
                 w9++;
         if (t9 && w9 && t9[w9]) {
             LeptrisTextNode* tn9 = (LeptrisTextNode*)n;
-            tn9->content = t9 + w9;
+            leptris_textnode_set_content_ptr_doc(tn9, t9 + w9, b->doc);
             tn9->content_len -= w9;
         } else if (t9 && w9 && !t9[w9]) {
             return;   /* pure before-head ws: dropped (tests7:7) */
@@ -3986,7 +3986,7 @@ static void h_append(HBuilder* b, LeptrisNodeRef n) {
         if (ct && ct[cw] && cw > 0) {
             LeptrisTextNode* tail =
                 leptris_text_create(ct + cw, strlen(ct + cw),
-                                    b->pool);
+                                    b->pool, b->doc);
             ((char*)ct)[cw] = '\0';
             ((LeptrisTextNode*)n)->content_len = cw;
             leptris_element_append_child_internal_doc(
@@ -4916,7 +4916,7 @@ head_end =
                         if (w2 > tx && *w2) {
                             LeptrisTextNode* tail =
                                 leptris_text_create(
-                                    w2, strlen(w2), b->pool);
+                                    w2, strlen(w2), b->pool, b->doc);
                             if (tail) {
                                 leptris_node_set_next_sibling(
                                     (LeptrisNodeRef)tail,
@@ -5438,12 +5438,12 @@ static LeptrisTextNode* h_text_node(HBuilder* b, const char* s,
             }
         }
         *(char*)e = '\0';
-        return leptris_text_create_borrowed(s, len, b->pool);
+        return leptris_text_create_borrowed(s, len, b->pool, b->doc);
     }
     size_t dlen = 0;
     char* dec = h_decode_text(b, s, e, &dlen);
     if (!dec || !*dec) return NULL;
-    return leptris_text_create(dec, dlen, b->pool);
+    return leptris_text_create(dec, dlen, b->pool, b->doc);
 }
 
 static LeptrisDocument html_parse_shared(
@@ -5783,13 +5783,13 @@ static LeptrisDocument html_parse_shared(
                                     }
                                 }
                                 LeptrisTextNode* t =
-                                    leptris_text_create(buf, o, b.pool);
+                                    leptris_text_create(buf, o, b.pool, b.doc);
                                 if (t)
                                     h_append(&b, (LeptrisNodeRef)t);
                             }
                         } else {
                             LeptrisTextNode* t = leptris_text_create(
-                                cs, clen, b.pool);
+                                cs, clen, b.pool, b.doc);
                             if (t) h_append(&b, (LeptrisNodeRef)t);
                         }
                     }
@@ -5838,7 +5838,7 @@ static LeptrisDocument html_parse_shared(
                         if (t) h_append(&b, (LeptrisNodeRef)t);
                     }
                     LeptrisTextNode* t =
-                        leptris_text_create("</", 2, b.pool);
+                        leptris_text_create("</", 2, b.pool, b.doc);
                     if (t) h_append(&b, (LeptrisNodeRef)t);
                     p = end;
                     text = p;
@@ -7907,7 +7907,7 @@ static LeptrisDocument html_parse_shared(
                                             b.whatwg, &dlen);
                     if (dec && dlen) {
                         LeptrisTextNode* t = leptris_text_create(
-                        dec, dlen, b.pool);
+                        dec, dlen, b.pool, b.doc);
                         if (t)
                             leptris_element_append_child_internal_doc(
                                 e, (LeptrisNodeRef)t, b.doc);
@@ -7917,14 +7917,14 @@ static LeptrisDocument html_parse_shared(
                         h_nul_fffd_copy(b.pool, cs, clen, eof_fffd);
                     if (mapped && mapped[0]) {
                         LeptrisTextNode* t = leptris_text_create(
-                            mapped, strlen(mapped), b.pool);
+                            mapped, strlen(mapped), b.pool, b.doc);
                         if (t)
                             leptris_element_append_child_internal_doc(
                                 et, (LeptrisNodeRef)t, b.doc);
                     }
                 } else {
                     LeptrisTextNode* t = leptris_text_create(
-                        cs, clen, b.pool);
+                        cs, clen, b.pool, b.doc);
                     if (t)
                         leptris_element_append_child_internal_doc(
                             et, (LeptrisNodeRef)t, b.doc);

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

@@ -937,7 +937,7 @@ static int ser_children_have_text(LeptrisNode* fc) {
              * entity-decoded at parse time — length-bounded read,
              * no serve-mode branch. */
             LeptrisTextNode* tn = (LeptrisTextNode*)c;
-            const char* tc = tn->content;
+            const char* tc = leptris_textnode_content(tn);
             size_t tl = tc ? tn->content_len : 0;
             for (size_t i = 0; i < tl; i++) {
                 if (tc[i] != ' ' && tc[i] != '\t' &&
@@ -1016,7 +1016,7 @@ void serialize_element_internal(LeptrisElement root_elem, SerializeBuffer* buf,
                 cur->type == LEPTRIS_NODE_TYPE_TEXT &&
                 !((sp > 0) && st[sp - 1].mixed)) {
                 LeptrisTextNode* wsn = (LeptrisTextNode*)cur;
-                const char* wsc = wsn->content;
+                const char* wsc = leptris_textnode_content(wsn);
                 size_t wsl = wsc ? wsn->content_len : 0;
                 int ws_only = 1;
                 for (size_t i = 0; i < wsl; i++) {
@@ -1033,7 +1033,7 @@ void serialize_element_internal(LeptrisElement root_elem, SerializeBuffer* buf,
             if (buf->indent_text && buf->indent_spaces > 0 &&
                 cur->type == LEPTRIS_NODE_TYPE_TEXT) {
                 LeptrisTextNode* itn = (LeptrisTextNode*)cur;
-                const char* isc = itn->content;
+                const char* isc = leptris_textnode_content(itn);
                 size_t isl = isc ? itn->content_len : 0;
                 int ws_only = 1;
                 for (size_t k = 0; k < isl; k++) {
@@ -1174,7 +1174,7 @@ void serialize_element_internal(LeptrisElement root_elem, SerializeBuffer* buf,
                  * NUL-terminate, which the escaper doesn't need
                  * (it's length-bounded). Entity-bearing text still
                  * materializes for correct expansion. */
-                const char* tc0 = tn0->content;
+                const char* tc0 = leptris_textnode_content(tn0);
                 size_t tl0 = tc0 ? tn0->content_len : 0;
                 /* Pretty mode fuses newline + indent + open + text +
                  * close into the same single reservation — leaves
@@ -1545,7 +1545,7 @@ void serialize_element_internal(LeptrisElement root_elem, SerializeBuffer* buf,
             }
             if (buf->indent_spaces == 0) {
                 LeptrisTextNode* tn = (LeptrisTextNode*)fc;
-                const char* tc = tn->content;
+                const char* tc = leptris_textnode_content(tn);
                 size_t tlen = tc ? tn->content_len : 0;
                 buffer_ensure_capacity(buf, 2 + epl + nl + 6 * tlen + 2 + 1);
                 char* te = buf->data + buf->size;

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

@@ -121,10 +121,12 @@ static char* load_file_content(const char* path, size_t* out_len) {
  * Returns NULL on allocation failure (partial copies are abandoned
  * along with the pool, which is freed document-scoped). */
 static LeptrisNode* deep_copy_node(const LeptrisNode* src,
-                                   LeptrisMemoryPool* target_pool);
+                                   LeptrisMemoryPool* target_pool,
+                                   struct leptris_document* target_doc);
 
 static LeptrisElement deep_copy_element(const LeptrisElement src,
-                                        LeptrisMemoryPool* target_pool) {
+                                        LeptrisMemoryPool* target_pool,
+                                        struct leptris_document* target_doc) {
     const char* name = leptris_element_get_name(src);
     LeptrisElement dst = leptris_element_create_pooled(name, target_pool);
     if (!dst) return NULL;
@@ -144,7 +146,7 @@ static LeptrisElement deep_copy_element(const LeptrisElement src,
          child;
          child = leptris_node_get_next_sibling(child)) {
 
-        LeptrisNode* child_copy = deep_copy_node(child, target_pool);
+        LeptrisNode* child_copy = deep_copy_node(child, target_pool, target_doc);
         if (!child_copy) return NULL;
 
         if (prev_copy) {
@@ -161,18 +163,21 @@ static LeptrisElement deep_copy_element(const LeptrisElement src,
 }
 
 static LeptrisNode* deep_copy_node(const LeptrisNode* src,
-                                   LeptrisMemoryPool* target_pool) {
+                                   LeptrisMemoryPool* target_pool,
+                                   struct leptris_document* target_doc) {
     if (!src) return NULL;
 
     switch (src->type) {
         case LEPTRIS_NODE_TYPE_ELEMENT:
-            return (LeptrisNode*)deep_copy_element((LeptrisElement)src, target_pool);
+            return (LeptrisNode*)deep_copy_element((LeptrisElement)src, target_pool, target_doc);
 
         case LEPTRIS_NODE_TYPE_TEXT: {
             const LeptrisTextNode* t = (const LeptrisTextNode*)src;
-            /* Source text may be borrowed (non-NUL-terminated) — content_len
-             * is authoritative. TODO 115 Phase B. */
-            return (LeptrisNode*)leptris_text_create(t->content, t->content_len, target_pool);
+            /* #1285 slice 4: runs are always NUL-terminated;
+             * content_len is authoritative. TODO 115 Phase B. */
+            return (LeptrisNode*)leptris_text_create(leptris_textnode_content(t),
+                                                     t->content_len, target_pool,
+                                                     target_doc);
         }
 
         case LEPTRIS_NODE_TYPE_CDATA: {
@@ -725,7 +730,7 @@ static int process_element_xinclude(LeptrisElement elem,
                 content_len = conv_len;
 #endif
             }
-            substitute = (LeptrisNode*)leptris_text_create(content, content_len, doc->pool);
+            substitute = (LeptrisNode*)leptris_text_create(content, content_len, doc->pool, doc);
             /* parse="text" doesn't recurse into another file's body
              * (no risk of A -> B -> A via text), so no push/pop here. */
         }
@@ -744,7 +749,7 @@ fallback:
         if (fb) {
             char* fb_text = leptris_element_get_text_content(fb);
             if (fb_text) {
-                substitute = (LeptrisNode*)leptris_text_create(fb_text, strlen(fb_text), doc->pool);
+                substitute = (LeptrisNode*)leptris_text_create(fb_text, strlen(fb_text), doc->pool, doc);
                 leptris_free(fb_text);
             }
         }

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

@@ -175,8 +175,12 @@ char* get_node_text(void* node) {
                 int ty = leptris_node_get_type(c);
                 if (ty == LEPTRIS_NODE_TYPE_TEXT ||
                     ty == LEPTRIS_NODE_TYPE_CDATA) {
-                    const char* t =
-                        leptris_text_get_content((LeptrisTextNode*)c);
+                    /* #1285 slice 4b: text and CDATA structs no
+                     * longer share `content`'s offset — use the
+                     * matching accessor. */
+                    const char* t = (ty == LEPTRIS_NODE_TYPE_CDATA)
+                        ? leptris_cdata_get_content((LeptrisCDATANode*)c)
+                        : leptris_text_get_content((LeptrisTextNode*)c);
                     if (t && *t) {
                         any_text = 1;
                         size_t tl = strlen(t);

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

@@ -460,7 +460,9 @@ static char* string_value_deep(LeptrisElement e) {
         LeptrisNodeRef n = stack[--sp];
         int ty = leptris_node_get_type(n);
         if (ty == LEPTRIS_NODE_TYPE_TEXT || ty == LEPTRIS_NODE_TYPE_CDATA) {
-            const char* t = leptris_text_get_content((LeptrisTextNode*)n);
+            const char* t = (ty == LEPTRIS_NODE_TYPE_CDATA)
+                ? leptris_cdata_get_content((LeptrisCDATANode*)n)
+                : leptris_text_get_content((LeptrisTextNode*)n);
             if (t) {
                 size_t tl = strlen(t);
                 if (len + tl + 1 > cap) {
@@ -2734,8 +2736,12 @@ static int copy_node_deep(XsltExec* ex, LeptrisElement node,
         if (ty == LEPTRIS_NODE_TYPE_ELEMENT) {
             copy_node_deep(ex, (LeptrisElement)c, e);
         } else if (ty == LEPTRIS_NODE_TYPE_CDATA) {
+            /* #1285 slice 4b: text and CDATA structs no longer
+             * share `content`'s offset — use the CDATA accessor on
+             * CDATA nodes; the cross-cast `text_get_content((TextNode*)c)`
+             * reads garbage here. */
             const char* t =
-                leptris_text_get_content((LeptrisTextNode*)c);
+                leptris_cdata_get_content((LeptrisCDATANode*)c);
             LeptrisNodeRef cc = (LeptrisNodeRef)leptris_cdata_create(
                 t, t ? strlen(t) : 0,
                 ((struct leptris_document*)ex->result)->pool);
@@ -3035,11 +3041,12 @@ static void strip_source_whitespace(XsltExec* ex) {
             if (!ws_only(t)) continue;
             /* Empty in place — never unlink (compact-parse text
              * nodes link via int32 offsets that unlinking can
-             * orphan for following siblings). Direct field write
-             * to a static "" keeps the node readable and the
-             * pointer NUL-terminated (#1285 slice 4 contract). */
+             * orphan for following siblings). Store the shared
+             * EMPTY sentinel: the node stays readable and the
+             * content decodes to a NUL-terminated "" (#1285 slice
+             * 4b — no overflow-table entry per stripped node). */
             LeptrisTextNode* tn = (LeptrisTextNode*)c;
-            tn->content = (char*)"";
+            leptris_textnode_set_content_ptr_doc(tn, "", ex->result);
             tn->content_len = 0;
         }
     }

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

@@ -36,45 +36,47 @@ TEST(TextBorrowed, ParsedTextNodeIsTerminatedInPlace) {
     LeptrisTextNode* text = (LeptrisTextNode*)child;
     EXPECT_EQ(text->content_len, std::strlen("hello world"));
     /* #1285 slice 4: the run is NUL-terminated IN PLACE in the
-     * doc-owned input copy — no pool copy, no serve mode. */
-    ASSERT_NE(text->content, nullptr);
-    EXPECT_EQ(text->content[text->content_len], '\0')
+     * doc-owned input copy — no pool copy, no serve mode. #1285
+     * slice 4b: content is an int32 self-relative offset; decode
+     * twice — the pointer must be stable across calls. */
+    const char* c1 = leptris_textnode_content(text);
+    const char* c2 = leptris_textnode_content(text);
+    ASSERT_NE(c1, nullptr);
+    EXPECT_EQ(c1, c2) << "decode is deterministic";
+    EXPECT_EQ(c1[text->content_len], '\0')
         << "run must be terminated at [content_len]";
-    /* get_content is a plain field read: same pointer, stable. */
-    EXPECT_EQ(leptris_text_get_content(text), text->content);
+    EXPECT_EQ(leptris_text_get_content(text), c1);
     EXPECT_STREQ(leptris_text_get_content(text), "hello world");
 
     leptris_document_free(doc);
 }
 
-TEST(TextBorrowed, NodeStructIsBasePointerAndThreeInt32) {
-    /* #1285 slice 4: pool + borrowed removed, content_len is uint32.
-     * The width-independent invariant: base + ONE content pointer +
-     * FOUR int32s (len, next, parent, owner doc — #1320), rounded to
-     * pointer alignment — nothing else. 40 on LP64 (the owner field
-     * lands in padding; sizeof unchanged); 32 on ILP32. Going lower
-     * needs content as an int32 pool offset (slice 4b). The
-     * parse-time bulk strides (dp text block, il lane table) hardcode
-     * this layout economics — a silent field growth would erode the
-     * #1222 parse win this slice exists for. */
-    /* C++11: no constexpr lambda — inline the round-ups. The
-     * content pointer needs pointer alignment INSIDE the struct:
-     * base rounds up to the pointer's alignment first. */
-    constexpr size_t kA = alignof(void*);
-    constexpr size_t kBaseA =
-        (sizeof(LeptrisNode) + kA - 1) / kA * kA;
-    constexpr size_t kRaw = kBaseA + sizeof(void*) + 4 * sizeof(int32_t);
+TEST(TextBorrowed, NodeStructIsBaseAndFiveInt32) {
+    /* #1285 slice 4b + #1320: the content pointer became an int32
+     * self-relative byte offset, and the detached-owner backref
+     * (#1320) joined it as a fifth int32. Width-independent
+     * invariant: base + FIVE int32s (content off, uint32 len,
+     * int32 next, int32 parent, int32 owner doc), int32-aligned —
+     * nothing else. 40 -> 32 on LP64; 32 on ILP32. Encoding:
+     * content_off 0 = NULL, LEPTRIS_COMPACT_INT32_EMPTY = static ""
+     * (ws-strip sentinel, no overflow-table entry per stripped
+     * node), any other value = self-relative offset with the
+     * overflow-table fallback (same machinery as the tree edges);
+     * owner_doc_off 0 = unstamped (parse-carved nodes attach). The
+     * parse-time bulk strides (dp text block, il lane table)
+     * hardcode this layout economics — a silent field growth would
+     * erode the #1222 parse win. */
+    /* C++11: no constexpr lambda — inline the round-ups. */
+    constexpr size_t kA = alignof(int32_t);
+    constexpr size_t kRaw = sizeof(LeptrisNode) + 5 * sizeof(int32_t);
     constexpr size_t kAligned = (kRaw + kA - 1) / kA * kA;
     static_assert(sizeof(LeptrisTextNode) == kAligned,
-                  "LeptrisTextNode must be base + one content pointer + "
+                  "LeptrisTextNode must be base + int32 content off + "
                   "uint32 len + int32 next + int32 parent + int32 owner "
-                  "(aligned) — no pool/borrowed fields (#1285 slice 4, #1320)");
+                  "(int32-aligned) — no content pointer "
+                  "(#1285 slice 4b, #1320)");
     EXPECT_EQ(sizeof(LeptrisTextNode), kAligned);
-#if defined(__LP64__) || defined(_WIN64)
-    EXPECT_EQ(sizeof(LeptrisTextNode), (size_t)40);
-#else
     EXPECT_EQ(sizeof(LeptrisTextNode), (size_t)32);
-#endif
 }
 
 TEST(TextBorrowed, PublicAccessorsReturnCorrectContent) {
@@ -143,8 +145,9 @@ TEST(TextBorrowed, MaterializationIsStableAcrossCalls) {
 
     LeptrisNodeRef child = leptris_node_first_child(leptris_element_as_node(root));
     LeptrisTextNode* text = (LeptrisTextNode*)child;
-    EXPECT_EQ(leptris_text_get_content(text), text->content)
-        << "get_content is a plain field read (#1285 slice 4)";
+    EXPECT_EQ(leptris_text_get_content(text),
+              leptris_textnode_content(text))
+        << "get_content decodes the same offset (#1285 slice 4b)";
 
     const char* second = leptris_element_text(root);
     EXPECT_EQ(second, first) << "repeated calls return the same pointer";
@@ -183,14 +186,12 @@ TEST(TextBorrowed, ServeContractHoldsInBothParseLanes) {
         LeptrisTextNode* text = (LeptrisTextNode*)child;
         EXPECT_EQ(text->content_len, std::strlen("hello world"));
         /* terminated in place in BOTH lanes (#1285 slice 4) */
-        ASSERT_NE(text->content, nullptr);
-        EXPECT_EQ(text->content[text->content_len], '\0');
-
         const char* a = leptris_text_get_content(text);
         ASSERT_NE(a, nullptr);
+        EXPECT_EQ(a[text->content_len], '\0');
         EXPECT_STREQ(a, "hello world");
-        EXPECT_EQ(a, text->content)
-            << "get_content returns the in-place pointer in both lanes";
+        EXPECT_EQ(a, leptris_textnode_content(text))
+            << "get_content returns the in-place view in both lanes";
         EXPECT_STREQ(leptris_element_text(root), "hello world");
 
         leptris_document_free(doc);

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.228",
+  "version": "1.9.229",
   "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.228.0
+  version: 1.9.229.0
 platform: x86_64-linux
 authors:
 - Ribose Inc.