leptris 1.9.228.0 → 1.9.231.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa53c1b21f30aa89e5992390c40deb360eb8d94d0000ca5346e381b35b086f87
-  data.tar.gz: e667ca695bb8b10ecd251ad03d77521adacf6829cdd5bac7ec9c4f9bcb5b42a0
+  metadata.gz: 7788b24a1aa6763d4bc2d101f7a9c50b30f0067e6ca7f84cf9c7335187b2b55a
+  data.tar.gz: 8eef3d332d6a5c31e9d9b15d1c453f68485930f026240b8087e662888738ee2a
 SHA512:
-  metadata.gz: 2927fc583597d9c607816ad16cb293a73c9ab7647a57b77429b8efbf8124b6e7ff52b871c25825b826d3a70501dbd51d4cc4b628c4992ea916825bd3f42845fa
-  data.tar.gz: a4a6371fa8e9e461db91e4705308b6ab9bc1920d08a76cee7d32f964f75bf9c5e9d16751359e6159b39fe8c0d3a57f0a6ffe5560806114f5d36b142385cd9204
+  metadata.gz: 3a4046fa5c520c295926bdc8857e19255a0e7cc739528a0df26fec89a7a05b014d07b930acca2f0bccdf695c6ce5056c3048d99877cb7b0a54afda9f1e689b23
+  data.tar.gz: d9efd5c7e9ee80a638e5210d8aa4e449d052c4e6b967ce3d3f85426b2acb56227e9444d344093ee90d4f6f02917364264abd174e0eb42ef1457b0e5661163974

data/CHANGELOG.md

@@ -5,6 +5,39 @@ 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.231.0] - 2026-09-23
+
+### Fixed
+
+- Vendored libleptris 1.9.231: the root-doc map is process-global
+  now — a document freed on a thread other than the one that
+  registered its roots (binding GC finalizers run on arbitrary
+  threads) no longer leaves a stale `{root -> doc}` entry in the
+  owner thread's map. Pre-fix, address-matched walks dereferenced
+  (and rewired) the freed document: the
+  `leptris_root_doc_unregister+0x6c` segfault under heavy parse
+  churn on macOS Ruby 3.3 (#321), plus silent freed-document
+  resolution through lookups and the per-thread memo. The memo
+  stays lock-free, validated by a global atomic generation.
+- Also riding 1.9.230's string-length fix (continuation-count
+  table, ac6f9738): the old lead-byte table over-advanced past
+  the NUL, and the NFD spec expectation enshrined the phantom
+  byte (4.0). Re-pinned to the correct contracts — verbatim
+  one-argument passthrough (2 codepoints) and two-argument NFD
+  (splits the precomposed é, 3 codepoints).
+
+## [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.231"
 # 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.231.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.231
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,77 @@
 ## [Unreleased]
 
+## [1.9.231] - 2026-09-23
+
+### Fixed
+
+- root-doc map is process-global — cross-thread document death poisoned owner-thread state (dom)
+
+
+
+## [1.9.230] - 2026-09-23
+
+### Added
+
+- **xquery: QT3 stage-2 corpus slice — 228 newly gated conformance
+  cases across six core families** (translate, normalize-space,
+  substring-before, substring-after, boolean, string-length),
+  vendored from the W3C qt3tests suite with the driver's exact
+  `agree == run == pinned` gate. fn:number is deliberately not
+  adopted: its string assertions want canonical E-notation doubles,
+  which the number formatter deliberately does not print
+  (libxml2 xmlXPathFormatNumber parity is load-bearing for the
+  libxslt suite).
+
+### Fixed
+
+- **xpath: `fn:translate` is now codepoint-correct.** The old
+  implementation built a 256-entry byte-level table, so every
+  multi-byte UTF-8 character matched byte-by-byte and astral
+  codepoints could not be addressed at all. The rewrite decodes
+  `from`/`to` into codepoints (first occurrence governs, per
+  F&O), supports cross-width replacements, and emits into a
+  growable buffer.
+- **xpath: `fn:string-length` counts codepoints, not bytes** —
+  `string-length("𐀂")` returned 4; the walk now steps by
+  lead-byte length.
+- **xpath: `substring-before`/`substring-after` accept the 3-arg
+  collation overload.** The codepoint-collation URI (under which
+  the collation is the default byte comparison) and the empty URI
+  are accepted; any other URI raises the unsupported-collation
+  error.
+- **bench: the CI benchmark legs' fixture/result paths unified
+  under one convention** (harnesses read `fixtures/` and write
+  `results/` relative to their working directory; CI stages both
+  once). SAX and XPath benchmark results that were silently
+  skipped or failing to write now produce real data, and 21 stale
+  committed result files (including a nine-month-old comparison
+  report) are gone from the tree.
+
+
+
+## [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.231
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/benchmarks/serialization/bench_leptris_serialize.c

@@ -35,7 +35,7 @@ static char* load_file(const char* path, size_t* size) {
 // Benchmark: Serialize small document
 static void bench_serialize_small(void) {
     size_t size;
-    char* xml = load_file("benchmarks/fixtures/small.xml", &size);
+    char* xml = load_file("fixtures/small.xml", &size);
     if (!xml) {
         printf("ERROR: Could not load small.xml\n");
         return;
@@ -68,7 +68,7 @@ static void bench_serialize_small(void) {
 // Benchmark: Serialize medium document
 static void bench_serialize_medium(void) {
     size_t size;
-    char* xml = load_file("benchmarks/fixtures/medium.xml", &size);
+    char* xml = load_file("fixtures/medium.xml", &size);
     if (!xml) {
         printf("ERROR: Could not load medium.xml\n");
         return;
@@ -101,7 +101,7 @@ static void bench_serialize_medium(void) {
 // Benchmark: Serialize large document
 static void bench_serialize_large(void) {
     size_t size;
-    char* xml = load_file("benchmarks/fixtures/large.xml", &size);
+    char* xml = load_file("fixtures/large.xml", &size);
     if (!xml) {
         printf("ERROR: Could not load large.xml\n");
         return;
@@ -134,7 +134,7 @@ static void bench_serialize_large(void) {
 // Benchmark: Pretty-print vs compact
 static void bench_format_comparison(void) {
     size_t size;
-    char* xml = load_file("benchmarks/fixtures/small.xml", &size);
+    char* xml = load_file("fixtures/small.xml", &size);
     if (!xml) {
         printf("ERROR: Could not load small.xml\n");
         return;

data/vendor-src/libleptris/benchmarks/workflows/bench_end_to_end.c

@@ -513,7 +513,7 @@ int main(int argc, char** argv) {
     snprintf(size_medium, sizeof(size_medium), "%.1fKB", medium_len / 1024.0);
     snprintf(size_large, sizeof(size_large), "%.1fKB", large_len / 1024.0);
 
-    write_json_results("benchmarks/results/phase17.5_session1.json",
+    write_json_results("results/phase17.5_session1.json",
                        size_small, size_medium, size_large,
                        &small_results, &medium_results, &large_results,
                        iterations);

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;
 }