leptris 1.9.229.0-x86_64-linux → 1.9.231.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94655f5964d22d85d415d8e8f8b48c7a8fc0772c6dec1bde5a3e539a1d569820
-  data.tar.gz: 8771d75bff1b08340b07b0db2c8996d4dcc9b65097d8766b62aeada7fd1e93a8
+  metadata.gz: 012e5580dc974f792458c6943f8059a5d7e3aa467a9805c7eae937f1039e5a83
+  data.tar.gz: f0c40fc816995d4f545988578dd70f66b62844bb4ff4fd6dcb43182efb023c1f
 SHA512:
-  metadata.gz: 205f207da94cc4e8378554692b658bb3bf4e99e5b21755f5933a59691c044304dbb28a92af2307a728409e9fce18b0a7658f0d8cec438168a72a962ccc9f77ba
-  data.tar.gz: 31528505abde42209dc834e1385b1f7c4693000f5f048a91ee8cc1f9c62ec47fd38e6b1b9781787afec368566909722f2b44e5735ee6adac14432e4e641488cf
+  metadata.gz: 44c3ed7dced5f3bc3700458535e214366ca35be93ea4a8312801660598ade70c64254ad9ddf9b57c7647a3d23d28209b2ef6e61dd2e7d632d92c073c116964c8
+  data.tar.gz: b10d3216646b6974c356e2a55384ab33985badde6e36499050427d1802730bf282c050237603bbfde6b64a72fb0df4832e9b8e37115b7d2922c7cb4e8d846442

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.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)

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

data/vendor-src/libleptris/CHANGELOG.md

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

data/vendor-src/libleptris/CMakeLists.txt

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

@@ -1,9 +1,21 @@
-/* dom/root_doc_map.c — Thread-local root-element → document mapping.
+/* dom/root_doc_map.c — root-element → document mapping.
  *
  * TODO 155 Phase A: the `document` field was removed from struct
  * leptris_element to fit it in one 64-byte cache line. Non-root
  * elements reach their document by walking parent_off to the root,
- * then looking up the root in this thread-local hash table.
+ * then looking up the root in this hash table.
+ *
+ * leptris-ruby#321: the map (buckets, entries, generation) was
+ * THREAD-LOCAL, but document death is not — binding finalizers free
+ * documents on arbitrary threads. A cross-thread free could not
+ * reach the owner thread's buckets, leaving a stale {root -> freed
+ * doc} entry and a memo the owner's TLS generation still trusted:
+ * the next owner-thread walk that address-matched the stale entry
+ * dereferenced (and rewired) the freed document, and lookups handed
+ * the freed document to callers. The map state is process-global
+ * now, guarded by one mutex; the per-thread (root, doc) memo stays
+ * lock-free, validated against a GLOBAL atomic generation that any
+ * thread's mutation bumps.
  *
  * TODO 157 (perf): uses a free-list to avoid per-parse malloc/free.
  * After warmup, register and unregister are O(1) with zero heap ops. */
@@ -39,7 +51,12 @@ typedef struct root_doc_entry {
     struct root_doc_entry* doc_next;   /* owning doc's chain */
 } RootDocEntry;
 
-static LEPTRIS_THREAD_LOCAL RootDocEntry* g_root_doc_buckets[ROOT_DOC_BUCKETS];
+static RootDocEntry* g_root_doc_buckets[ROOT_DOC_BUCKETS];
+
+/* One lock guards buckets, entry chunks/free-list, and doc chains.
+ * Uncontended acquisition is the whole per-op cost single-threaded
+ * callers pay; the memo fast path below needs no lock at all. */
+static leptris_mutex_t g_root_doc_lock = LEPTRIS_MUTEX_INIT;
 
 /* Doc-entry chain helpers: every register pushes the entry onto its
  * document's list (doc->map_entries), so unregister_doc walks exactly
@@ -62,7 +79,7 @@ static void doc_chain_unlink(struct leptris_document* doc, RootDocEntry* e) {
 
 /* Free-list: recycled entries from unregistered roots. Eliminates
  * malloc/free churn on the parse→free cycle. */
-static LEPTRIS_THREAD_LOCAL RootDocEntry* g_free_list;
+static RootDocEntry* g_free_list;
 
 /* Entry chunks (lane 18 P0): one TLS bump chunk serves fresh
  * entries so a create-heavy document pays no malloc per element —
@@ -74,9 +91,9 @@ typedef struct root_doc_chunk {
     struct root_doc_chunk* next;
     RootDocEntry entries[ROOTMAP_CHUNK];
 } RootDocChunk;
-static LEPTRIS_THREAD_LOCAL RootDocChunk* g_entry_chunks;
-static LEPTRIS_THREAD_LOCAL RootDocEntry* g_entry_cursor;
-static LEPTRIS_THREAD_LOCAL RootDocEntry* g_entry_end;
+static RootDocChunk* g_entry_chunks;
+static RootDocEntry* g_entry_cursor;
+static RootDocEntry* g_entry_end;
 
 static RootDocEntry* entry_take(void) {
     if (g_free_list) {
@@ -128,13 +145,33 @@ static LEPTRIS_THREAD_LOCAL struct leptris_document* g_memo_doc;
  * lookups only, so the memo keeps hitting there; any churn —
  * precisely the strike interleaving — kills it deterministically
  * instead of by allocator luck. */
-static LEPTRIS_THREAD_LOCAL uint64_t g_rootmap_generation;
+/* Global: a mutation on ANY thread must invalidate EVERY thread's
+ * memo snapshot (the TLS counter let a foreign document death go
+ * unseen — leptris-ruby#321). Portability per arena.c's lock
+ * precedent: __atomic on GCC/Clang, _Interlocked on MSVC. */
+static uint64_t g_rootmap_generation;
 static LEPTRIS_THREAD_LOCAL uint64_t g_memo_generation;
 
-static void rootmap_generation_bump(void) { g_rootmap_generation++; }
+#if defined(_MSC_VER)
+#include <intrin.h>
+static uint64_t rootmap_generation_load(void) {
+    return _InterlockedCompareExchange64(&g_rootmap_generation, 0, 0);
+}
+static uint64_t rootmap_generation_bump(void) {
+    return _InterlockedIncrement64(&g_rootmap_generation) - 1;
+}
+#else
+static uint64_t rootmap_generation_load(void) {
+    return __atomic_load_n(&g_rootmap_generation, __ATOMIC_ACQUIRE);
+}
+static uint64_t rootmap_generation_bump(void) {
+    return __atomic_add_fetch(&g_rootmap_generation, 1, __ATOMIC_ACQ_REL);
+}
+#endif
 
 void leptris_root_doc_register(LeptrisElement root, struct leptris_document* doc) {
     if (!root || !doc) return;
+    LEPTRIS_MUTEX_LOCK(&g_root_doc_lock);
     rootmap_generation_bump();
     size_t idx = bucket_index(root);
     if (rootmap_marked(root)) {
@@ -149,48 +186,55 @@ void leptris_root_doc_register(LeptrisElement root, struct leptris_document* doc
                     e->doc = doc;
                     doc_chain_push(doc, e);
                 }
+                LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
                 return;
             }
         }
     } else {
         /* Never registered: prepend directly, no duplicate walk. */
         RootDocEntry* e = entry_take();
-        if (!e) return;
+        if (!e) {
+            LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
+            return;
+        }
         e->root = root; e->doc = doc;
         e->next = g_root_doc_buckets[idx];
         g_root_doc_buckets[idx] = e;
         doc_chain_push(doc, e);
         rootmap_set(root, 1);
+        LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
         return;
     }
     /* Pop from free-list, or the bump chunk. */
     RootDocEntry* e = entry_take();
-    if (!e) return;
+    if (!e) {
+        LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
+        return;
+    }
     e->root = root; e->doc = doc;
     e->next = g_root_doc_buckets[idx];
     g_root_doc_buckets[idx] = e;
     doc_chain_push(doc, e);
+    LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
 }
 
-/* TODO.concurrency/08: TLS free-list entries outlive their thread
- * (no portable C99 TLS destructor). leptris_thread_cleanup() drains
- * them from each worker thread before exit. */
+/* TODO.concurrency/08, adjusted for #321: entry chunks are
+ * process-global and reused for the life of the process (they were
+ * per-thread and never torn down either). A dying thread now has
+ * only its memo to drop. */
 void leptris_root_doc_drain_thread_caches(void) {
-    while (g_free_list) {
-        RootDocEntry* next = g_free_list->next;
-        g_free_list = next; /* chunk-owned; freed with the chunks */
-    }
-    while (g_entry_chunks) {
-        RootDocChunk* next = g_entry_chunks->next;
-        free(g_entry_chunks);
-        g_entry_chunks = next;
-    }
-    g_entry_cursor = NULL;
-    g_entry_end = NULL;
+    g_memo_root = NULL;
+    g_memo_doc = NULL;
+    g_memo_generation = rootmap_generation_load();
 }
 
 void leptris_root_doc_unregister(LeptrisElement root) {
     if (!root) return;
+    /* The flag read touches element storage; elements die only with
+     * their document, and a cross-thread document death cannot run
+     * concurrently with THIS thread's unregister for the same tree
+     * (the binding never touches a freed document), so the probe is
+     * safe outside the lock. */
     if (!rootmap_marked(root)) return;  /* never registered: O(1) out */
     /* #1242: any map mutation kills the memo (generation bump).
      * The address-match clear below stays as the immediate drop;
@@ -201,6 +245,7 @@ void leptris_root_doc_unregister(LeptrisElement root) {
         g_memo_root = NULL;
         g_memo_doc = NULL;
     }
+    LEPTRIS_MUTEX_LOCK(&g_root_doc_lock);
     size_t idx = bucket_index(root);
     RootDocEntry** pp = &g_root_doc_buckets[idx];
     while (*pp) {
@@ -214,10 +259,12 @@ void leptris_root_doc_unregister(LeptrisElement root) {
             freed->next = g_free_list;
             g_free_list = freed;
             rootmap_set(root, 0);
+            LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
             return;
         }
         pp = &(*pp)->next;
     }
+    LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
 }
 
 /* #1038: root-doc map entries must die with their document. The
@@ -238,6 +285,7 @@ void leptris_root_doc_unregister(LeptrisElement root) {
  * preserving the adopted-pool rule above. */
 size_t leptris_root_doc_unregister_doc(struct leptris_document* doc) {
     if (!doc) return 0;
+    LEPTRIS_MUTEX_LOCK(&g_root_doc_lock);
     size_t removed = 0;
     /* #1242: doc sweep mutates the map — kill the memo. */
     rootmap_generation_bump();
@@ -266,16 +314,20 @@ size_t leptris_root_doc_unregister_doc(struct leptris_document* doc) {
         removed++;
         e = next;
     }
+    LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
     return removed;
 }
 
 struct leptris_document* leptris_root_doc_lookup(LeptrisElement root) {
     if (!root) return NULL;
+    LEPTRIS_MUTEX_LOCK(&g_root_doc_lock);
     size_t idx = bucket_index(root);
+    struct leptris_document* found = NULL;
     for (RootDocEntry* e = g_root_doc_buckets[idx]; e; e = e->next) {
-        if (e->root == root) return e->doc;
+        if (e->root == root) { found = e->doc; break; }
     }
-    return NULL;
+    LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
+    return found;
 }
 
 /* #682 2x lever: an ambient document hint set by the transform
@@ -293,9 +345,24 @@ struct leptris_document* leptris_root_doc_lookup(LeptrisElement root) {
 void leptris_root_doc_memo_prime(LeptrisElement root,
                                  struct leptris_document* doc) {
     if (!root || !doc) return;
+    LEPTRIS_MUTEX_LOCK(&g_root_doc_lock);
+    /* Verify the pair is still live under the lock: a document that
+     * died on another thread between the caller's registration
+     * guarantee and this prime must not seed a trusted memo. */
+    size_t idx = bucket_index(root);
+    struct leptris_document* live = NULL;
+    for (RootDocEntry* e = g_root_doc_buckets[idx]; e; e = e->next) {
+        if (e->root == root) { live = e->doc; break; }
+    }
+    if (live != doc) {
+        LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
+        return;
+    }
+    uint64_t gen = rootmap_generation_load();
+    LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
     g_memo_root = root;
     g_memo_doc = doc;
-    g_memo_generation = g_rootmap_generation;
+    g_memo_generation = gen;
 }
 
 void leptris_root_doc_memo_invalidate(const struct leptris_document* doc) {
@@ -310,7 +377,7 @@ void leptris_root_doc_memo_invalidate(const struct leptris_document* doc) {
  * when the memo is generation-stale (primed before a map
  * mutation), even if the pair fields still hold values. */
 LeptrisElement leptris_root_doc_memo_root_for_tests(void) {
-    if (g_memo_generation != g_rootmap_generation) return NULL;
+    if (g_memo_generation != rootmap_generation_load()) return NULL;
     return g_memo_root;
 }
 
@@ -334,7 +401,8 @@ struct leptris_document* leptris_element_get_document(LeptrisElement elem) {
          * address memo. A freed root's address recycled by the
          * allocator made the memo hit with a stale document
          * before the authoritative namebp was consulted. */
-        if (cur == memo_root && memo_generation == g_rootmap_generation &&
+        if (cur == memo_root &&
+            memo_generation == rootmap_generation_load() &&
             !leptris_elem_has_namebp(cur))
             return g_memo_doc;
         LeptrisElement parent = leptris_elem_parent(cur);
@@ -346,12 +414,28 @@ struct leptris_document* leptris_element_get_document(LeptrisElement elem) {
         if (!parent) break;
         cur = parent;
     }
-    struct leptris_document* d = leptris_root_doc_lookup(cur);
-    if (d) {
-        g_memo_root = cur;
-        g_memo_doc = d;
-        g_memo_generation = g_rootmap_generation;
-        return d;
+    /* Locked bucket walk with an UNDER-THE-LOCK generation
+     * snapshot: a death that acquires the lock after we release
+     * bumps the global generation past our snapshot, so the primed
+     * pair is untrusted on the next read. Priming from outside the
+     * lock (the old shape) could snapshot the NEW generation for a
+     * pair whose document was freed in between (#321). */
+    {
+        struct leptris_document* d = NULL;
+        uint64_t now;
+        LEPTRIS_MUTEX_LOCK(&g_root_doc_lock);
+        size_t ridx = bucket_index(cur);
+        for (RootDocEntry* e = g_root_doc_buckets[ridx]; e; e = e->next) {
+            if (e->root == cur) { d = e->doc; break; }
+        }
+        now = rootmap_generation_load();
+        LEPTRIS_MUTEX_UNLOCK(&g_root_doc_lock);
+        if (d) {
+            g_memo_root = cur;
+            g_memo_doc = d;
+            g_memo_generation = now;
+            return d;
+        }
     }
     /* Round 21: unattached mutation elements carry their doc in the
      * name slot backpointer — a stateless fallback that replaced the

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

@@ -1,4 +1,6 @@
-/* dom/root_doc_map.h — Thread-local root-element → document mapping. */
+/* dom/root_doc_map.h — root-element → document mapping (process-global
+ * state behind one mutex; per-thread memo validated by a global
+ * generation — see leptris-ruby#321). */
 #ifndef LEPTRIS_DOM_ROOT_DOC_MAP_H
 #define LEPTRIS_DOM_ROOT_DOC_MAP_H