leptris 1.9.207.0 → 1.9.209.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b10f689b2142684316157264cfd935433d6d0d22db8cf90b4a27e9c4ba79bd88
-  data.tar.gz: f3e625c375d995087bec8cd6c058a7a9c900791125f1422f6da8b2436e90047b
+  metadata.gz: 700c8b243ae83bca888161a3db72b2e3c6304023c2d6876716d63cbc77046469
+  data.tar.gz: 3f5e149db82b4dd010e7a485650321bc752d74ee198e06b5711736781eca3281
 SHA512:
-  metadata.gz: ddf28875bb34e2eb14074c51834614f5cb5acddf0a33c58f55a50d9e6970a065eb70cb6f3da51c1114cad3a8c062a6dec98d6ce271ff27a81a77033f92e774ea
-  data.tar.gz: b1c7bc0629b2840a7a23d71bd27b08303426ab7b013d8a272d9a1fedc82b8f40ba8fdd6805724f878fbf4374752912658ea5922e79548f16a53a859cf4de3164
+  metadata.gz: 87f6bfc69bcabf29bef4721bddc2947311ba021146912be96f34d043123611f0bc5230fc027855d897d42b7979ff7bed97d0b6df749bcaaf9f7b62cc642c6d26
+  data.tar.gz: 022fa14f46227d54e5966be7f0b90da028a2ff4bed14e4c2f2f4e26343a4a684c43770637077ab31657efb6c7a63af357285558cc4d25550156c55742c39f83a

data/CHANGELOG.md

@@ -5,6 +5,87 @@ 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.209.0] - 2026-09-20
+
+### Performance — engine sync (1.9.209)
+
+- Vendored libleptris 1.9.209: WHATWG HTML parse round 2
+  (#1218) — the per-close-tag implied-end/open-side name-list
+  scans (40 + 33 names, ~7% of parse self-time on table-heavy
+  pages) became membership bits on the first-char-bucketed tag
+  classifier; bench_html_parse 24.1 → 25.1-26.7 MB/s. No
+  binding-facing surface changes; audit holds.
+
+### Added — `Diff#summary` / `Diff#to_json` (the 1.9.200 output modes, #1184)
+
+- The `leptris diff --summary` / `--json` CLI modes' library face:
+  per-kind op counts (`{update_attr: 1, insert: 1}`, `{}` when
+  identical) and the op list as JSON — pure Ruby over the existing
+  `#ops` face, no new engine symbols. Salvaged from #269's unique
+  half (its DTD half was superseded by the 1.9.204 wiring).
+
+## [1.9.208.0] - 2026-09-20
+
+### Fixed — engine sync: the #1242 TLS-memo corruption (1.9.208)
+
+- Vendored libleptris 1.9.208: the TLS `(root, doc)` last-hit memo
+  in `leptris_element_get_document` trusted the root address and
+  was cleared only by document identity — an element-level
+  unregistration left `(freed_address, doc)` behind, and a
+  recycled address resolved the WRONG document, poisoning
+  attribute ownership (whole-run all-NULL
+  `leptris_element_attribute` reads; set_root's cross-document
+  check tripping EINVAL). The memo is now cleared whenever the
+  outgoing root address matches. `leptris_document_set_root` also
+  sets a fresh thread-local error on every rejection (no more
+  stale XPath messages), and `LEPTRIS_DEBUG_ATTR_MISS=1` dumps
+  attribute-chain state on lookup misses.
+- **First IBM Z gem: `s390x-linux-musl`** ships from this release —
+  the 14th variant (qemu-built, in-container smoked). The release
+  build-musl containers needed `linux-headers` (the ffi gem's
+  bundled libffi includes `linux/limits.h` under musl; #283 fixed
+  the wrong apk line, #284 the one s390x runs). With #1197 fixed
+  (1.9.206) and strict s390x CI legs green since 1.9.207, the
+  big-endian platform is fully shippable.
+- **CI un-quarantine where the evidence holds**: the s390x/ppc64le
+  qemu test legs are strict again, and so are the armv7/ppc64le/
+  s390x-musl release-build cells (#1174's ILP32 port shipped; arm
+  gems publish from every release since). The ubuntu-latest Ruby
+  3.4 leg stays non-blocking: strikes 7-10 on 1.9.208 show the
+  engine's memo clear was incomplete — in-spec forensics captured
+  a direct `leptris_element_attribute` call returning NULL with an
+  EMPTY chain on a live yielded element, and windows-4.0 produced
+  the fresh `set_root: element belongs to a different document`
+  for a same-document element. One mechanism: the TLS memo
+  resolving elements to a wrong document under address-recycling
+  interleavings. Tracked as leptris-ruby#279 / leptris/leptris#1242
+  with the dump env + forensics armed on the leg until the
+  residual engine fix lands.
+- ffi.rb dedupe: the 1.9.206-surface block re-attached ten
+  symbols the 1.9.204 wiring had already attached (audit counted
+  345 attachments against 335 exports). The typed 1.9.206 block
+  is kept; audit 335/335.
+
+## [1.9.207.0] - 2026-09-19
+
+### Fixed — engine sync: big-endian close-tag parse (#1197 upstream)
+
+- Vendored libleptris 1.9.207: the close-tag fast-path compare
+  masked the wrong end of its 8-byte name load on big-endian hosts,
+  rejecting ordinary paired-tag documents with "malformed input"
+  (434/727 binding-suite failures under qemu s390x). The mask now
+  follows memory order per byte dialect; the s390x-linux-musl
+  platform gem becomes viable with this release.
+
+### Added — FFI mirror adopts the 1.9.202–1.9.207 engine surface
+
+- audit:symbols lockstep attachments: recover diagnostics
+  (leptris_document_parse_diag[_count]), the standalone DTD family
+  (leptris_dtd_*), declaration/doctype removal, engine-heap buffer
+  allocation, and one-shot SAX. leptris_set_error stays internal —
+  the engine now hides it on ELF too (leptris#1243), so the export
+  surface agrees across Linux/macOS/Windows.
+
 ## [1.9.204.0] - 2026-09-19
 
 ### Added — document-level mutation completed: #1229 (the 1.9.204 surface)
@@ -51,29 +132,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ppc64le qemu leg (ffi_spec:223) once the audit fix let the suite
   run; the spec now asserts JVM ≡ host tier.
 
-### Not fixed despite upstream closes
+### Resolved upstream threads (final state)
 
+- **#1220 (HTML mutations lost on serialization) — fixed in
+  1.9.204** (engine commit 737fe977 / #1228). Verified from the
+  binding on 1.9.208: the original reopen repro serializes the
+  mutation on both the whatwg and html4 lanes.
 - **Iterparse attribute reads: all-nil runs on ubuntu-latest Ruby
-## [1.9.207.0] - 2026-09-19
-
-### Fixed — engine sync: big-endian close-tag parse (#1197 upstream)
-
-- Vendored libleptris 1.9.207: the close-tag fast-path compare
-  masked the wrong end of its 8-byte name load on big-endian hosts,
-  rejecting ordinary paired-tag documents with "malformed input"
-  (434/727 binding-suite failures under qemu s390x). The mask now
-  follows memory order per byte dialect; the s390x-linux-musl
-  platform gem becomes viable with this release.
-
-### Added — FFI mirror adopts the 1.9.202–1.9.207 engine surface
-
-- audit:symbols lockstep attachments: recover diagnostics
-  (leptris_document_parse_diag[_count]), the standalone DTD family
-  (leptris_dtd_*), declaration/doctype removal, engine-heap buffer
-  allocation, and one-shot SAX. leptris_set_error stays internal —
-  the engine now hides it on ELF too (leptris#1243), so the export
-  surface agrees across Linux/macOS/Windows.
-
+  3.4 legs** — filed upstream as leptris/leptris#1242
+  (leptris-ruby#279 tracks the investigation). Originally
+  suspected binding-side, finally root-caused engine-side by
+  in-spec forensics (see the 1.9.208.0 entry); the engine's
+  1.9.208 fix is incomplete and the flake persists. The leg is
+  gated with diagnostics armed until the residual engine fix.
 ## [1.9.201.3] - 2026-09-19
 
 ### Added — the HTML facade (Nokogiri-shaped entry points)

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.207"
+LIBLEPTRIS_VERSION = "1.9.209"
 # 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
@@ -77,13 +77,14 @@ task :compile do
   fetch_tarball.call(
     "https://api.github.com/repos/leptris/leptris/tarball/v#{version}", build)
 
-  # NOTE: 32-bit ARM (armv7) is an ENGINE port task — the round-19
+  # NOTE: 32-bit ARM (armv7) WAS an engine port task — the round-19
   # ABI asserts pin layouts to 8-byte-pointer sizes and correctly
-  # abort the build on 32-bit. Filed upstream as leptris/leptris
-  # #1174; the release legs stay experimental (continue-on-error)
-  # and flip green automatically when the port ships. We patch
-  # nothing here — the emulated-leg smoke validates whatever the
-  # engine provides.
+  # aborted the build on 32-bit. Upstream shipped the ILP32 port
+  # (leptris/leptris#1174, closed; per-wordsize layout pins +
+  # inline-value gate landed in 1.9.199) and arm-linux /
+  # arm-linux-musl gems publish from every release since — the
+  # emulated release legs are strict again. We patch nothing here;
+  # the emulated-leg smoke validates whatever the engine provides.
 
   # utf8proc: shared build only, @rpath install name, local prefix.
   u8_dir = File.expand_path("tmp/utf8proc-#{UTF8PROC_VERSION}", __dir__)

data/lib/leptris/version.rb

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

data/lib/leptris/xml/diff.rb

@@ -71,4 +71,18 @@ class Leptris::XML::Diff
     str_ptr = Leptris::XML::FFI.leptris_diff_serialize(@handle)
     Leptris::XML::FFI.read_owned_string(str_ptr)
   end
+
+  # Per-kind op counts (#1184): {update_attr: 1, insert: 1, ...} —
+  # {} when identical.
+  def summary
+    ops.each_with_object(Hash.new(0)) { |op, h| h[op[:type]] += 1 }
+  end
+
+  # The op list as JSON (#1184) — the same shape #ops yields, with
+  # stringified ops. Requires the json standard library lazily.
+  def to_json(*args)
+    require "json"
+    ops.map { |op| op.transform_values { |v| v.nil? ? nil : v.to_s } }
+      .to_json(*args)
+  end
 end

data/lib/leptris/xml/ffi.rb

@@ -386,12 +386,6 @@ attach_function :leptris_parse_string,
         [:leptris_document, :int], :leptris_status
       attach_function :leptris_document_set_doctype,
         [:leptris_document, :string, :string, :string], :leptris_doctype
-      # The #1229 remove-half (libleptris 1.9.204): un-set the
-      # declaration; un-set the DOCTYPE (NOT_FOUND when none set).
-      attach_function :leptris_document_clear_declaration,
-        [:leptris_document], :leptris_status
-      attach_function :leptris_document_remove_doctype,
-        [:leptris_document], :leptris_status
       attach_function :leptris_document_append_pi,
         [:leptris_document, :string, :string], :leptris_node_ref
       attach_function :leptris_document_remove_child,
@@ -860,14 +854,6 @@ attach_function :leptris_parse_string,
         [:leptris_sax_parser], :void
       attach_function :leptris_sax_parser_set_streaming,
         [:leptris_sax_parser, :int], :int
-      # One-shot input hint (libleptris 1.9.204): whole document in
-      # a single feed(), alive for the parser's lifetime — enables
-      # in-place scans. The binding's one-shot entry
-      # (leptris_sax_parse) is one-shot by construction; the engine
-      # sets this itself for pull's memory source. Attach-only
-      # until a chunked-feed face wants to opt in.
-      attach_function :leptris_sax_parser_set_one_shot,
-        [:leptris_sax_parser, :int], :void
 
       # Pull parsing (v1.6.0): StAX-style cursor over a document.
       attach_function :leptris_pull_new,
@@ -1053,19 +1039,6 @@ attach_function :leptris_parse_string,
                :line, :int,
                :column, :int
       end
-      attach_function :leptris_dtd_parse,
-        [:string, :size_t], :pointer
-      # leptris_document_get_dtd attached above with the readers
-      attach_function :leptris_dtd_parse_external_subset,
-        [:pointer, :string, :size_t], :int
-      attach_function :leptris_dtd_set_pe_loader,
-        [:pointer, :pointer, :pointer], :void
-      attach_function :leptris_dtd_validate,
-        [:leptris_document, :pointer, :pointer], :int
-      attach_function :leptris_dtd_free,
-        [:pointer], :void
-      attach_function :leptris_dtd_error_free,
-        [:pointer], :void
 
       attach_function :leptris_rng_parse,
         [:string, :size_t, :pointer], :leptris_relaxng
@@ -1143,11 +1116,6 @@ attach_function :leptris_parse_string,
         [:leptris_doctype], :string
 
       attach_function :leptris_free_string, [:pointer], :void
-      # Engine-heap allocation (libleptris 1.9.204): buffers handed
-      # to engine callbacks (the DTD PE loader) so the engine frees
-      # through its matching deallocation path. Release with
-      # leptris_free_string when NOT consumed by the engine.
-      attach_function :leptris_alloc_buffer, [:size_t], :pointer
       attach_function :leptris_explicit_cleanup, [], :void
       attach_function :leptris_set_memory_management_functions,
         [:pointer, :pointer], :void

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,43 @@
 ## [Unreleased]
 
+## [1.9.209] - 2026-09-20
+
+### Performance
+
+- WHATWG HTML parse, #1218 round 2: the per-close-tag name-list
+  scans (a 40-name implied-end set and a 33-name open-side set,
+  ~7% of parse self-time on table-heavy pages) are now membership
+  bits on the first-char-bucketed tag classifier — both lookups
+  are one bucket walk, sets preserved bit-for-bit.
+  bench_html_parse plain fixture: 24.1 → 25.1-26.7 MB/s.
+
+
+
+## [1.9.208] - 2026-09-19
+
+### Fixed
+
+- Per-machine process-global corruption (#1242): the TLS (root, doc)
+  last-hit memo in `leptris_element_get_document` trusted the root
+  ADDRESS and was cleared only by document identity — an element-level
+  unregistration left `(freed_address, doc)` behind, and a
+  recycled address resolved the WRONG document (poisoning attribute
+  ownership: whole-run all-NULL `leptris_element_attribute` reads;
+  and tripping set_root's cross-document check). The memo is now
+  cleared whenever the outgoing root address matches, in both the
+  element-level unregister and the document sweep — closing the
+  same recycled-address class #1038 fixed for the root-doc map.
+- `leptris_document_set_root` now sets a fresh thread-local error on
+  every rejection (NULL_ARG + both EINVAL paths) — previously the
+  previous operation's message leaked through (the reported "EINVAL
+  with a stale XPath parse error").
+- New diagnostic: `LEPTRIS_DEBUG_ATTR_MISS=1` dumps attribute-chain
+  state on lookup misses (chain length, per-attr name bytes/hash15)
+  — the discriminator for any residual binding-side corruption
+  report.
+
+
+
 ## [1.9.207] - 2026-09-19
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/TODO.max-perf/00-INDEX.md

@@ -5,12 +5,12 @@ RED bench first where perf claims are made.
 
 | # | Lever | Type | Effort | Status |
 |---|-------|------|--------|--------|
-| 3 | iterparse fixed-cost (6.9µs) + error channel (#563) | perf | bench landed #1195; remaining = zero-copy one-shot emission (design with lever 2) | half done |
+| 3 | iterparse fixed-cost (6.9µs) + error channel (#563) | perf | bench #1195; zero-copy emission landed #1236 (295->52us full-doc); remaining = iterparse per-event DOM construction (0.45->0.15us/event stretch) | mostly done |
 | 1 | SIMD/memchr HTML tokenizer scans | perf | memchr ×2 (#1176/#1190) + LUT (#1199, +30%/+51%) | DONE v1.9.199 |
 | 7 | leptris validate CLI + bindings | feature | engine half merged #1198 (--dtd + DTD engine fixes); bindings remain | half done |
-| 8 | native XML diff consumer surface | feature | small | next |
-| 4 | compact-node micro-opts (non-layout) | perf | audited: TODOs 172/195/Lane18-P3 already in; residual = node-creation cost (node-layout fork, owner call) | parked on fork |
-| 2 | compiled-dispatch tokenizer | perf | medium; design together with lever 3's zero-copy emission | queued |
+| 8 | native XML diff consumer surface | feature | CLI diff text/JSON/--summary + engine API shipped | DONE (#1184 closed) |
+| 4 | compact-node micro-opts (non-layout) | perf | residual = node-creation cost; SUPERSEDED by the node-layout fork (TODO.max-perf/node-layout-fork.md, owner green-lit 2026-09-20) | folded into fork |
+| 2 | compiled-dispatch tokenizer | perf | slices 1+3 landed #1236; slice 2's class LUT + dense switch pre-existed; residual = iterparse consumer (row 3) | mostly done |
 | 5 | XSLT 2x per-bench profile rounds (#682) | perf | medium, ongoing | in progress |
 | 6 | language tails (QT3/dates/fn-items/lane 15) | correctness | medium-large | queued |
 | 9 | prebuilt-gem 12-platform matrix | release | small, BLOCKED on owner go | blocked |
@@ -20,3 +20,7 @@ Portability wave 2026-09-18 (v1.9.199): ILP32 layout port #1193 —
 per-wordsize pins, SSE2 gate, xsl:number 64-bit chain, ILP32 +
 native-arm64 + Intel-macOS CI legs, concurrency groups everywhere.
 Next portability gate: s390x big-endian (#1194, PR #1202).
+
+The node-layout fork (row 4 successor, owner green-lit 2026-09-20):
+TODO.max-perf/node-layout-fork.md — 5 slices, addresses #1222 +
+#1179 residual + #1238 parse side.

data/vendor-src/libleptris/TODO.max-perf/2-3-oneshot-tokenizer-design.md

@@ -1,6 +1,12 @@
 # Levers 2+3 — compiled-dispatch + zero-copy one-shot emission (design)
 
-Status: DESIGNED (2026-09-19). Implementation slices below.
+Status: LANDED (2026-09-19, PR #1236). Slices 1+3 implemented;
+slice 2's class LUT (`sxs_chartype`) + dense state switch already
+existed. Measured: bench_iterparse full-doc 295->52-63us wall,
+15.9->74-91 MB/s, 2.54->0.45-0.55us/event. Residual to the 0.15
+stretch = iterparse per-event DOM construction (element create +
+namespace resolution through the public element API), a consumer
+lever, not string copies.
 Owners: engine repo. Bench: `benchmarks/sax/bench_iterparse.c` (#1195).
 
 ## Problem

data/vendor-src/libleptris/TODO.max-perf/node-layout-fork.md

@@ -0,0 +1,70 @@
+# The node-layout fork — pugixml-class allocation for the DOM
+
+Status: DESIGN (2026-09-20). Owner green-light received. This is
+the durable fix for #1222 (2-5.9x vs pugixml large docs), #1179's
+residual node-creation cost, and the parse-side constant factor of
+#1238. Measured basis: scaling is LINEAR on serialbench fixtures
+(352-467 MB/s across 1.5-13MB) — the gap is a per-node constant
+cost, not complexity.
+
+## Why the gap exists (measured)
+
+Every element today costs: pool_alloc (block chain + freelist
+recycler bookkeeping) + compact-edge encoding (cp16 + overflow
+table on out-of-range pairs) + root-doc registration for detached
+nodes + name materialization through the namebp/inline paths.
+pugixml pays: one bump-pointer increment inside ONE document-sized
+block, with node "pointers" as intra-block offsets and names
+interned into a shared char arena. Constant-factor difference per
+node, multiplied by millions of nodes.
+
+## Target layout (pugixml-class, adapted)
+
+- ONE primary allocation per document (grown geometrically,
+  never per-node): node array with intra-block integer offsets for
+  parent/first-child/next-sibling/first-attr edges. No cp16
+  overflow table (offsets are block-relative and always
+  representable), no root-doc map for parse-created nodes (block
+  base implies the document).
+- String arena beside the node array: element/attr names
+  interned by (ptr,len) hash into the block; parse buffers stay
+  immutable (#1125) and zero-copy views remain the primary
+  representation — interning only replaces the per-node copies.
+- MUTATION-CREATED nodes keep today's paths initially (mut blocks
+  + root-doc map) behind the same public API; the internal
+  get_document walk resolves by block base first. Migration of
+  mutation paths is a later slice, gated by the same benches.
+- ABI unchanged: every public handle is already opaque; the
+  compact-pointer exports and element-size check (VALIDATION.md)
+  get new expected values.
+
+## Slices (one PR each, RED bench first)
+
+1. **Document block allocator**: the growable block + offset-edge
+   node struct, PARALLEL to the pool (parse path only, behind a
+   flag). Gate: no test changes; element-size check documents both.
+2. **Parser wiring**: flat/direct_parse + html_parse build into
+   block storage. Gate: full ctest + html5lib corpus 1169 floor;
+   RED bench: serialbench shapes to >=350 MB/s at 13MB (close the
+   libxml2 gap, halve the pugixml gap).
+3. **Name interning**: shared arena replaces per-node name copies.
+   Gate: attr/name read benches (many-attrs, first-access) no
+   regression; memory RSS down on name-heavy docs.
+4. **Compact-edge retirement for parse trees**: drop overflow-table
+   traffic on the block path; mutation keeps the old encode until
+   slice 5.
+5. **Mutation unification** (optional, last): programmatic
+   create/append onto the block. Gate: append <= pugixml (the
+   lane-18 P1 row).
+
+## Non-goals / invariants
+
+- No public API or ABI change (opaque handles).
+- Digest (#869), diff, c14n correctness rides the same node
+  accessors — all read through the inline edge helpers, which
+  become offset arithmetic.
+- The address-keyed TLS caches (root-doc map/memo) survive for
+  MUTATION nodes only; their invalidation contracts (#1242/#1038)
+  must be re-gated, not assumed.
+
+Effort: medium-large. Every slice independently shippable.

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

@@ -178,7 +178,49 @@ LEPTRIS_API const char* leptris_element_attribute(LeptrisElement elem, const cha
         if (!uri) return NULL;                             /* (4) */
         attr = find_attr_expanded(elem, uri, colon + 1);   /* (2) */
     }
-    if (!attr) return NULL;
+    if (!attr) {
+        /* #1242 diagnostic: LEPTRIS_DEBUG_ATTR_MISS=1 dumps the
+         * element's attribute-chain state for the first 5 misses in
+         * the process — distinguishes construction loss
+         * (chain_len=0) from storage corruption (garbage name
+         * bytes) from hash-discipline drift (correct bytes,
+         * mismatching hash15). Off by default; fprintf only on
+         * miss. */
+        static int dumped = 0;
+        if (dumped < 5 && getenv("LEPTRIS_DEBUG_ATTR_MISS")) {
+            dumped++;
+            size_t chain = 0;
+            for (struct leptris_attribute* a =
+                     leptris_element_get_first_attribute(elem);
+                 a; a = leptris_attr_next(a))
+                chain++;
+            fprintf(stderr,
+                    "[leptris-attr-miss] elem=%p needle='%s' "
+                    "chain_len=%zu\n",
+                    (void*)elem, name, chain);
+            size_t i = 0;
+            for (struct leptris_attribute* a =
+                     leptris_element_get_first_attribute(elem);
+                 a && i < 8; a = leptris_attr_next(a), i++) {
+                char nb[17];
+                size_t nl = a->name_view.length < 16
+                                ? a->name_view.length : 16;
+                for (size_t k = 0; k < nl; k++) {
+                    unsigned char c = (unsigned char)a->name_view.data[k];
+                    nb[k] = (c >= 32 && c < 127) ? (char)c : '.';
+                }
+                nb[nl] = '\0';
+                fprintf(stderr,
+                        "  attr[%zu] addr=%p name_ptr=%p len=%zu "
+                        "bytes='%s' hash15=%u entities=%d\n",
+                        i, (void*)a, (void*)a->name_view.data,
+                        a->name_view.length, nb,
+                        (unsigned)(a->name_hash & 0x7FFFu),
+                        (int)((a->name_hash & 0x8000u) != 0));
+            }
+        }
+        return NULL;
+    }
 
     /* Single representation (round 4): entity values expand lazily
      * INTO the view (owned copy); no-entity views are already

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

@@ -102,6 +102,15 @@ static size_t bucket_index(LeptrisElement root) {
     return (size_t)(v & (ROOT_DOC_BUCKETS - 1));
 }
 
+/* #682 2x lever (sound): last-hit (root, doc) memo. The climb to
+ * the root is unavoidable without a per-element field, but the TLS
+ * bucket-array walk is not — consecutive queries in a transform
+ * hit the same root, so one pointer compare replaces the hash
+ * bucket chain. One TLS access total (the memo pair), and the
+ * 1M-loop sentinel becomes a plain NULL check. */
+static LEPTRIS_THREAD_LOCAL LeptrisElement g_memo_root;
+static LEPTRIS_THREAD_LOCAL struct leptris_document* g_memo_doc;
+
 void leptris_root_doc_register(LeptrisElement root, struct leptris_document* doc) {
     if (!root || !doc) return;
     size_t idx = bucket_index(root);
@@ -160,6 +169,17 @@ void leptris_root_doc_drain_thread_caches(void) {
 void leptris_root_doc_unregister(LeptrisElement root) {
     if (!root) return;
     if (!rootmap_marked(root)) return;  /* never registered: O(1) out */
+    /* #1242: the (root, doc) memo trusts the root ADDRESS. An
+     * element-level unregister frees that address while the doc
+     * lives — the doc-keyed invalidation never fires, and the
+     * allocator recycling the address into another element's climb
+     * target made get_document return the WRONG document. Same
+     * exposure class #1038 closed for the map; the memo needs it
+     * at element granularity. */
+    if (g_memo_root == root) {
+        g_memo_root = NULL;
+        g_memo_doc = NULL;
+    }
     size_t idx = bucket_index(root);
     RootDocEntry** pp = &g_root_doc_buckets[idx];
     while (*pp) {
@@ -202,6 +222,13 @@ size_t leptris_root_doc_unregister_doc(struct leptris_document* doc) {
     doc->map_entries = NULL;
     while (e) {
         RootDocEntry* next = e->doc_next;
+        /* #1242: a swept root address must not survive in the memo
+         * even when the memo's doc differs (a previously poisoned
+         * pair). */
+        if (g_memo_root == e->root) {
+            g_memo_root = NULL;
+            g_memo_doc = NULL;
+        }
         size_t idx = bucket_index(e->root);
         RootDocEntry** pp = &g_root_doc_buckets[idx];
         while (*pp) {
@@ -234,15 +261,6 @@ struct leptris_document* leptris_root_doc_lookup(LeptrisElement root) {
  * are skipped entirely (get_document was 3.5% of the light bench).
  * Hint is thread-local-scoped by construction (one transform per
  * thread), validated by the root-walk fallback when it misses. */
-/* #682 2x lever (sound): last-hit (root, doc) memo. The climb to
- * the root is unavoidable without a per-element field, but the TLS
- * bucket-array walk is not — consecutive queries in a transform
- * hit the same root, so one pointer compare replaces the hash
- * bucket chain. One TLS access total (the memo pair), and the
- * 1M-loop sentinel becomes a plain NULL check. */
-static LEPTRIS_THREAD_LOCAL LeptrisElement g_memo_root;
-static LEPTRIS_THREAD_LOCAL struct leptris_document* g_memo_doc;
-
 /* #904: prime the TLS last-root memo from a driver that already
  * knows the (root, doc) pair — the iterparse yield path hands out
  * a subtree that is released before the next, so the memo misses
@@ -263,6 +281,10 @@ void leptris_root_doc_memo_invalidate(const struct leptris_document* doc) {
     }
 }
 
+LeptrisElement leptris_root_doc_memo_root_for_tests(void) {
+    return g_memo_root;
+}
+
 struct leptris_document* leptris_element_get_document(LeptrisElement elem) {
     if (!elem) return NULL;
     LeptrisElement cur = elem;

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

@@ -15,6 +15,8 @@ void leptris_root_doc_register(LeptrisElement root, struct leptris_document* doc
 void leptris_root_doc_unregister(LeptrisElement root);
 struct leptris_document* leptris_root_doc_lookup(LeptrisElement root);
 void leptris_root_doc_memo_invalidate(const struct leptris_document* doc);
+/* Test hook (#1242): the memo's current root, or NULL. */
+LeptrisElement leptris_root_doc_memo_root_for_tests(void);
 /* #904: prime the TLS (root, doc) memo from a driver that knows
  * the pair (iterparse yields). Root must be registered. */
 void leptris_root_doc_memo_prime(LeptrisElement root,

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

@@ -2189,40 +2189,36 @@ static int h_closes_ww(const char* open, const char* start) {
 /* WHATWG: starts that close an open p in button scope
  * (13.2.6.4.7 "in body" block set + h/pre/form/li/dd/dt/plaintext/
  * hr/xmp). */
+typedef struct {
+    char name[12];
+    uint8_t len;
+    uint8_t special;   /* WHATWG 13.2.4 special set */
+    uint8_t no_fmt;    /* never reconstructed (formatting) */
+    uint8_t closes;    /* bit0: h_p_closes implied-end set; bit1:
+                        * k_p_closers — replaced the per-close-tag
+                        * strcmp scans (#1218 profile). */
+} HTagInfo;
+
+static const HTagInfo* h_tag_lookup(const char* n);
+
+static const HTagInfo* h_tag_lookup(const char* n);
+
 static int h_p_closes(const char* start) {
-    static const char* const k[] = {
-        "address", "article", "aside",  "blockquote", "center",
-        "details", "dialog", "dir",     "div",        "dl",
-        "fieldset", "figcaption", "figure", "footer", "header",
-        "hgroup",  "main",    "menu",   "nav",        "ol",
-        "p",       "search",  "section", "summary",   "ul",
-        "h1",      "h2",      "h3",     "h4",         "h5",
-        "h6",      "pre",     "listing", "form",      "li",
-        "dd",      "dt",      "plaintext", "hr",     "xmp",
-        NULL};
-    for (int i = 0; k[i]; i++)
-        if (strcmp(start, k[i]) == 0) return 1;
-    return 0;
+    /* Classifier hit (round: #1218 profile — the 40-name strcmp
+     * scan was the top WHATWG self-time on table-heavy pages).
+     * Sets preserved bit-for-bit from the old k[] list. */
+    const HTagInfo* t = h_tag_lookup(start);
+    return t && (t->closes & 1);
 }
 
 /* Implied-end sets: a start tag in `closes` closes any open
  * element named `name` (HTML4 §7.5.4 / table model). */
-static const char* const k_p_closers[] = {
-    "address", "article", "aside", "blockquote", "details", "dialog",
-    "dir", "div", "dl", "fieldset", "figcaption", "figure", "footer",
-    "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup",
-    "hr", "li", "main", "menu", "nav", "ol", "p", "pre", "section",
-    "table", "ul", NULL,
-};
-static int h_in_list(const char* const* list, const char* name) {
-    for (int i = 0; list[i]; i++)
-        if (strcmp(list[i], name) == 0) return 1;
-    return 0;
-}
 /* Does starting `start` close an open element named `open`? */
 static int h_closes(const char* open, const char* start) {
-    if (strcmp(open, "p") == 0 && h_in_list(k_p_closers, start))
-        return 1;
+    if (strcmp(open, "p") == 0) {
+        const HTagInfo* t = h_tag_lookup(start);
+        if (t && (t->closes & 2)) return 1;
+    }
     if (strcmp(open, "li") == 0 && strcmp(start, "li") == 0)
         return 1;
     if ((strcmp(open, "dt") == 0 || strcmp(open, "dd") == 0) &&
@@ -3066,98 +3062,92 @@ static int h_is_formatting(const char* n) {
  * sampler pinned at ~21% of WHATWG parse (h_is_special_ww +
  * h_reconstructs). Keep in sync with the WHATWG special and
  * no-formatting sets. */
-typedef struct {
-    char name[12];
-    uint8_t len;
-    uint8_t special;   /* WHATWG 13.2.4 special set */
-    uint8_t no_fmt;    /* never reconstructed (formatting) */
-} HTagInfo;
 
 static const HTagInfo h_tag_infos[] = {
-    {"address", 7, 1, 1},
-    {"applet", 6, 1, 0},
-    {"area", 4, 1, 0},
-    {"article", 7, 1, 1},
-    {"aside", 5, 1, 1},
-    {"base", 4, 1, 1},
-    {"basefont", 8, 1, 1},
-    {"bgsound", 7, 1, 1},
-    {"blockquote", 10, 1, 1},
-    {"body", 4, 1, 1},
-    {"br", 2, 1, 0},
-    {"button", 6, 1, 0},
-    {"caption", 7, 1, 1},
-    {"center", 6, 1, 1},
-    {"col", 3, 1, 1},
-    {"colgroup", 8, 1, 1},
-    {"dd", 2, 1, 1},
-    {"details", 7, 1, 1},
-    {"dialog", 6, 1, 1},
-    {"dir", 3, 1, 1},
-    {"div", 3, 1, 1},
-    {"dl", 2, 1, 1},
-    {"dt", 2, 1, 1},
-    {"embed", 5, 1, 0},
-    {"fieldset", 8, 1, 1},
-    {"figcaption", 10, 1, 1},
-    {"figure", 6, 1, 1},
-    {"footer", 6, 1, 1},
-    {"form", 4, 1, 1},
-    {"frame", 5, 1, 1},
-    {"frameset", 8, 1, 1},
-    {"h1", 2, 1, 1},
-    {"h2", 2, 1, 1},
-    {"h3", 2, 1, 1},
-    {"h4", 2, 1, 1},
-    {"h5", 2, 1, 1},
-    {"h6", 2, 1, 1},
-    {"head", 4, 1, 1},
-    {"header", 6, 1, 1},
-    {"hgroup", 6, 1, 1},
-    {"hr", 2, 1, 1},
-    {"html", 4, 1, 1},
-    {"iframe", 6, 1, 0},
-    {"img", 3, 1, 0},
-    {"input", 5, 1, 0},
-    {"keygen", 6, 1, 0},
-    {"li", 2, 1, 1},
-    {"link", 4, 1, 1},
-    {"listing", 7, 1, 1},
-    {"main", 4, 1, 1},
-    {"marquee", 7, 1, 0},
-    {"menu", 4, 1, 1},
-    {"meta", 4, 1, 1},
-    {"nav", 3, 1, 1},
-    {"noembed", 7, 1, 0},
-    {"noframes", 8, 1, 1},
-    {"noscript", 8, 1, 0},
-    {"object", 6, 1, 0},
-    {"ol", 2, 1, 1},
-    {"p", 1, 1, 1},
-    {"param", 5, 1, 0},
-    {"plaintext", 9, 1, 1},
-    {"pre", 3, 1, 1},
-    {"script", 6, 1, 1},
-    {"search", 6, 1, 1},
-    {"section", 7, 1, 1},
-    {"select", 6, 1, 0},
-    {"source", 6, 1, 0},
-    {"style", 5, 1, 1},
-    {"summary", 7, 1, 1},
-    {"table", 5, 1, 1},
-    {"tbody", 5, 1, 1},
-    {"td", 2, 1, 1},
-    {"template", 8, 1, 1},
-    {"textarea", 8, 1, 1},
-    {"tfoot", 5, 1, 1},
-    {"th", 2, 1, 1},
-    {"thead", 5, 1, 1},
-    {"title", 5, 1, 1},
-    {"tr", 2, 1, 1},
-    {"track", 5, 1, 0},
-    {"ul", 2, 1, 1},
-    {"wbr", 3, 1, 0},
-    {"xmp", 3, 1, 0},
+    {"address", 7, 1, 1, 3},
+    {"applet", 6, 1, 0, 0},
+    {"area", 4, 1, 0, 0},
+    {"article", 7, 1, 1, 3},
+    {"aside", 5, 1, 1, 3},
+    {"base", 4, 1, 1, 0},
+    {"basefont", 8, 1, 1, 0},
+    {"bgsound", 7, 1, 1, 0},
+    {"blockquote", 10, 1, 1, 3},
+    {"body", 4, 1, 1, 0},
+    {"br", 2, 1, 0, 0},
+    {"button", 6, 1, 0, 0},
+    {"caption", 7, 1, 1, 0},
+    {"center", 6, 1, 1, 1},
+    {"col", 3, 1, 1, 0},
+    {"colgroup", 8, 1, 1, 0},
+    {"dd", 2, 1, 1, 1},
+    {"details", 7, 1, 1, 3},
+    {"dialog", 6, 1, 1, 3},
+    {"dir", 3, 1, 1, 3},
+    {"div", 3, 1, 1, 3},
+    {"dl", 2, 1, 1, 3},
+    {"dt", 2, 1, 1, 1},
+    {"embed", 5, 1, 0, 0},
+    {"fieldset", 8, 1, 1, 3},
+    {"figcaption", 10, 1, 1, 3},
+    {"figure", 6, 1, 1, 3},
+    {"footer", 6, 1, 1, 3},
+    {"form", 4, 1, 1, 3},
+    {"frame", 5, 1, 1, 0},
+    {"frameset", 8, 1, 1, 0},
+    {"h1", 2, 1, 1, 3},
+    {"h2", 2, 1, 1, 3},
+    {"h3", 2, 1, 1, 3},
+    {"h4", 2, 1, 1, 3},
+    {"h5", 2, 1, 1, 3},
+    {"h6", 2, 1, 1, 3},
+    {"head", 4, 1, 1, 0},
+    {"header", 6, 1, 1, 3},
+    {"hgroup", 6, 1, 1, 3},
+    {"hr", 2, 1, 1, 3},
+    {"html", 4, 1, 1, 0},
+    {"iframe", 6, 1, 0, 0},
+    {"img", 3, 1, 0, 0},
+    {"input", 5, 1, 0, 0},
+    {"keygen", 6, 1, 0, 0},
+    {"li", 2, 1, 1, 3},
+    {"link", 4, 1, 1, 0},
+    {"listing", 7, 1, 1, 1},
+    {"main", 4, 1, 1, 3},
+    {"marquee", 7, 1, 0, 0},
+    {"menu", 4, 1, 1, 3},
+    {"meta", 4, 1, 1, 0},
+    {"nav", 3, 1, 1, 3},
+    {"noembed", 7, 1, 0, 0},
+    {"noframes", 8, 1, 1, 0},
+    {"noscript", 8, 1, 0, 0},
+    {"object", 6, 1, 0, 0},
+    {"ol", 2, 1, 1, 3},
+    {"p", 1, 1, 1, 3},
+    {"param", 5, 1, 0, 0},
+    {"plaintext", 9, 1, 1, 1},
+    {"pre", 3, 1, 1, 3},
+    {"script", 6, 1, 1, 0},
+    {"search", 6, 1, 1, 1},
+    {"section", 7, 1, 1, 3},
+    {"select", 6, 1, 0, 0},
+    {"source", 6, 1, 0, 0},
+    {"style", 5, 1, 1, 0},
+    {"summary", 7, 1, 1, 1},
+    {"table", 5, 1, 1, 2},
+    {"tbody", 5, 1, 1, 0},
+    {"td", 2, 1, 1, 0},
+    {"template", 8, 1, 1, 0},
+    {"textarea", 8, 1, 1, 0},
+    {"tfoot", 5, 1, 1, 0},
+    {"th", 2, 1, 1, 0},
+    {"thead", 5, 1, 1, 0},
+    {"title", 5, 1, 1, 0},
+    {"tr", 2, 1, 1, 0},
+    {"track", 5, 1, 0, 0},
+    {"ul", 2, 1, 1, 3},
+    {"wbr", 3, 1, 0, 0},
+    {"xmp", 3, 1, 0, 1},
 };
 
 /* bucket[first_char] = start index; bucket[first_char+1] = end */

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

@@ -253,12 +253,19 @@ struct leptris_document* leptris_document_create_on_arena(
  */
 LEPTRIS_API LeptrisStatus leptris_document_set_root(LeptrisDocument doc,
                                                     LeptrisElement root) {
-    if (!doc || !root) return LEPTRIS_ERROR_NULL_ARG;
+    if (!doc || !root) {
+        leptris_set_error(LEPTRIS_ERROR_NULL_ARG,
+                          "set_root: NULL document or element");
+        return LEPTRIS_ERROR_NULL_ARG;
+    }
 
     /* Already attached under a parent? (parent_off == 0 encodes NULL;
      * leptris_elem_parent is the static inline accessor from dom/element.h) */
-    if (leptris_elem_parent(root))
+    if (leptris_elem_parent(root)) {
+        leptris_set_error(LEPTRIS_ERROR_INVALID_ARG,
+                          "set_root: element is attached to a parent");
         return LEPTRIS_ERROR_INVALID_ARG;
+    }
 
     /* Cross-document attach would dangle the source pool on free.
      * Lane 18 P1: resolve via get_document (map + namebp fallback)
@@ -266,8 +273,11 @@ LEPTRIS_API LeptrisStatus leptris_document_set_root(LeptrisDocument doc,
      * lookup rejected every one of them. */
     extern struct leptris_document* leptris_element_get_document(
         LeptrisElement elem);
-    if (leptris_element_get_document(root) != doc)
+    if (leptris_element_get_document(root) != doc) {
+        leptris_set_error(LEPTRIS_ERROR_INVALID_ARG,
+                          "set_root: element belongs to a different document");
         return LEPTRIS_ERROR_INVALID_ARG;
+    }
 
     doc->root = root;
     doc->new_dom_root = root;

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

@@ -3,8 +3,17 @@
 #include <gtest/gtest.h>
 
 #include "leptris.h"
+#include "leptris/error.h"
 /* #1125 pristine-buffer gate: reach doc->xml_buffer directly. */
 #include "../leptris/leptris_internal.h"
+/* Internal root-doc-map surface (#1242 spec); C linkage. */
+extern "C" {
+LeptrisElement leptris_root_doc_memo_root_for_tests(void);
+void leptris_root_doc_register(LeptrisElement root,
+                               struct leptris_document* doc);
+void leptris_root_doc_unregister(LeptrisElement root);
+struct leptris_document* leptris_element_get_document(LeptrisElement elem);
+}
 #include "../leptris/memory/pool.h"
 
 #include <cstring>
@@ -92,6 +101,30 @@ TEST(DomBasics, DocumentSetRootRejectsNullInputs) {
     leptris_document_free(doc);
 }
 
+// #1242 symptom 2: a failed set_root must set a FRESH thread-local
+// error — the binding's exception message was stitched from whatever
+// the previous operation left behind (a stale XPath parse error).
+TEST(DomBasics, DocumentSetRootFailureSetsFreshError) {
+    LeptrisDocument doc_a = leptris_document_create();
+    LeptrisDocument doc_b = leptris_document_create();
+    ASSERT_NE(doc_a, nullptr);
+    ASSERT_NE(doc_b, nullptr);
+    /* Poison the thread-local slot with an unrelated message. */
+    ASSERT_EQ(leptris_parse_string("<a><b></a>", 10, nullptr), nullptr);
+
+    LeptrisElement foreign = leptris_element_create(doc_b, "b");
+    ASSERT_NE(foreign, nullptr);
+    EXPECT_EQ(leptris_document_set_root(doc_a, foreign),
+              LEPTRIS_ERROR_INVALID_ARG);
+    const char* msg = leptris_last_error();
+    ASSERT_NE(msg, nullptr);
+    EXPECT_EQ(strstr(msg, "set_root"), msg)
+        << "expected a fresh set_root message, got: " << msg;
+
+    leptris_document_free(doc_a);
+    leptris_document_free(doc_b);
+}
+
 TEST(DomBasics, DocumentSetRootRejectsForeignElement) {
     LeptrisDocument doc_a = leptris_document_create();
     LeptrisDocument doc_b = leptris_document_create();
@@ -117,6 +150,69 @@ TEST(DomBasics, DocumentSetRootRejectsParentedElement) {
     leptris_document_free(doc);
 }
 
+/* #1242: the TLS (root, doc) memo trusts the root address. An
+ * element-level unregister frees that address while the document
+ * lives; a recycled address later made get_document resolve the
+ * WRONG document (per-machine corruption signature). Unregistering
+ * a root must drop the memo. */
+TEST(DomBasics, RootDocMemoClearedWhenRootUnregisters) {
+    LeptrisDocument doc = leptris_document_create();
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement e = leptris_element_create(doc, "r");
+    ASSERT_NE(e, nullptr);
+    leptris_root_doc_register(e, doc);
+    /* Prime the memo through a resolution. */
+    ASSERT_EQ(leptris_element_get_document(e), doc);
+    ASSERT_EQ(leptris_root_doc_memo_root_for_tests(), e);
+    /* Element-level lifecycle: the root goes away, the doc stays. */
+    leptris_root_doc_unregister(e);
+    EXPECT_EQ(leptris_root_doc_memo_root_for_tests(), nullptr)
+        << "stale (root, doc) memo survived root unregistration";
+    leptris_document_free(doc);
+}
+
+/* #1242: every status-returning rejection must refresh the
+ * thread-local error channel — a stale message from an earlier
+ * operation leaking through an EINVAL is the reported signature. */
+TEST(DomBasics, DocumentSetRootRejectionSetsFreshError) {
+    const char xml[] = "<a><b/></a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), &st);
+    ASSERT_NE(doc, nullptr);
+    /* Poison the channel with an XPath syntax error and snapshot it. */
+    LeptrisXPathResult bad = leptris_xpath_eval(doc, nullptr, "<<");
+    if (bad) leptris_xpath_result_free(bad);
+    std::string poisoned = leptris_last_error() ? leptris_last_error() : "";
+    ASSERT_FALSE(poisoned.empty());
+
+    LeptrisElement b = (LeptrisElement)leptris_node_first_child(
+        leptris_element_as_node(leptris_document_root(doc)));
+    ASSERT_NE(b, nullptr);
+    EXPECT_EQ(leptris_document_set_root(doc, b), LEPTRIS_ERROR_INVALID_ARG);
+    /* The channel must now describe THIS failure, not the XPath one. */
+    const char* err = leptris_last_error();
+    ASSERT_TRUE(err != nullptr && err[0] != '\0');
+    EXPECT_STRNE(err, poisoned.c_str())
+        << "stale XPath error leaked through set_root EINVAL: " << err;
+    EXPECT_TRUE(strstr(err, "root") != nullptr)
+        << "expected a set_root-specific message, got: " << err;
+
+    /* Cross-document rejection refreshes the channel too. */
+    LeptrisDocument other = leptris_document_create();
+    ASSERT_NE(other, nullptr);
+    LeptrisElement foreign = leptris_element_create(other, "f");
+    ASSERT_NE(foreign, nullptr);
+    EXPECT_EQ(leptris_document_set_root(doc, foreign),
+              LEPTRIS_ERROR_INVALID_ARG);
+    err = leptris_last_error();
+    ASSERT_TRUE(err != nullptr && err[0] != '\0');
+    EXPECT_STRNE(err, poisoned.c_str());
+    EXPECT_TRUE(strstr(err, "document") != nullptr)
+        << "expected a cross-document message, got: " << err;
+    leptris_document_free(other);
+    leptris_document_free(doc);
+}
+
 TEST(DomBasics, AttributeLookupByName) {
     const char xml[] = "<r a='1' b='2' c='3'/>";
     LeptrisStatus st = LEPTRIS_OK;

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.207",
+  "version": "1.9.209",
   "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.207.0
+  version: 1.9.209.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -154,6 +154,8 @@ files:
 - lib/leptris/vendor/arm64-darwin/libutf8proc.3.dylib
 - lib/leptris/vendor/ppc64le-linux/libleptris.so
 - lib/leptris/vendor/ppc64le-linux/libutf8proc.so.3
+- lib/leptris/vendor/s390x-linux-musl/libleptris.so
+- lib/leptris/vendor/s390x-linux-musl/libutf8proc.so.3
 - lib/leptris/vendor/x86_64-darwin/libleptris.dylib
 - lib/leptris/vendor/x86_64-darwin/libutf8proc.3.dylib
 - lib/leptris/vendor/x86_64-linux-musl/libleptris.so
@@ -246,6 +248,7 @@ files:
 - vendor-src/libleptris/TODO.max-perf/7-validate-bindings.md
 - vendor-src/libleptris/TODO.max-perf/8-native-xml-diff-consumer.md
 - vendor-src/libleptris/TODO.max-perf/9-prebuilt-gem-matrix.md
+- vendor-src/libleptris/TODO.max-perf/node-layout-fork.md
 - vendor-src/libleptris/TODO.md
 - vendor-src/libleptris/TODO.transform/README.md
 - vendor-src/libleptris/TODO.validate/README.md