leptris 1.9.209.1-arm-linux → 1.9.210.1-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ce1d65e6aeb91514ba27063f13dd3d31113fcdf298fac6bf8010536032c5836
-  data.tar.gz: dc150276080b58313d34a05e78e3457d5ae675585b824fdd187608b4e786ca25
+  metadata.gz: d1ea51f9fab577cb642f3d97041e358f9cd7bb24683f00efeda95d030d23f271
+  data.tar.gz: e5daf20fd58e184304892ae0524609a1f75421fcbd1b281c7b8b1b14b1434d14
 SHA512:
-  metadata.gz: 20baf0ac1501f9c6b057d95993329c33b1fa126dd7024e6291d453f6cd1efd66b363886693f65d98b291e0df5a41214e20cadc08e20ec684171f3fd471003ea6
-  data.tar.gz: fee9695415f16f8666748e3e108fcd9c2204aab15dcbdffd4521813b459453bea0f6247cf9295161d84dc95a01ff2f416c9a387ade147b5064a43c02d17042aa
+  metadata.gz: 748f76cccbf61b98d4c8c59f9a9c334496945e148a54421cdcbacbc0fd0e065a6d8174ffb535bd2f698aea595ce401dbef3dff5ba1ad183689665d6ffa101230
+  data.tar.gz: a95bccff70898f0ebe1879d9d3d6a25216e4e64eeec499671cf5fb87ba8a7e00852bbd926ed7e01b26eab0c268f19e43a46f01569f9124ef4ebfdb660f6753b0

data/CHANGELOG.md

@@ -5,6 +5,50 @@ 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).
 
+## [Unreleased]
+
+### Added — Descriptor typed scalars + the fused materialize entry (#230's consumer contract)
+
+- **Typed scalars**: attribute and child plan rows accept
+  `type: :string | :integer | :float | :boolean`. The tag travels
+  through the plan ABI (host-defined, echoed verbatim) and
+  `PlanValue#to_ruby` returns the cast value — Integer / Float /
+  true / false — on element scalars AND collected attributes, so
+  per-value cast probes disappear from the consumer's loop
+  (lutaml-model's `cast_element_present`/`apply_value_map` class
+  of cost). Lenient on unparseable input (raw String wins);
+  `#string_value` stays the raw escape hatch regardless of tag.
+- **`Descriptor#materialize(source)`** — the fused loop, pointed
+  at the parse: source bytes → typed rows in ONE call (parse,
+  plan walk, document free; the standalone PlanValue tree is all
+  that surfaces). Byte-parity with parse + `#walk(root)`.
+- Mirrors the yeptris schema-ABI shape (leptris/yeptris#238:
+  SCALAR + type_tag STR|INT|FLOAT|BOOL, whole-document results)
+  so a framework compiles one descriptor vocabulary and runs it
+  on every engine. Native in-pass int/float parsing (no string
+  round-trip) is the recorded engine-side headroom.
+
+## [1.9.210.0] - 2026-09-20
+
+### Performance — engine sync (1.9.210)
+
+- Vendored libleptris 1.9.210: the node-layout fork's document
+  block (slice 1, #1253) — two contiguous geometrically-grown
+  regions per document (dense node array + string arena) with
+  region-relative byte-offset edges, so growth never invalidates
+  an offset; and the parse-arena retain ceiling raised 32 → 96MB
+  with a thread-cleanup drain (#1222/#1238 lane): repeated large
+  parses stop freeing/re-mallocing tens of MB per cycle. Measured
+  engine-side: 13MB attr shape 341 → 472 MB/s (+38%); the text
+  shape's size-decline eliminated (~605-627 flat across
+  1.5-13MB). No binding-facing surface changes; audit holds.
+- Note: #1242 was closed upstream before our strikes 7-10
+  forensics landed; reopened with the post-fix evidence (the
+  1.9.208 memo clear is incomplete — direct-call NULL + empty
+  chain on a live element; set_root cross-document false
+  positive on windows-4.0). The ubuntu-3.4 gate and armed
+  forensics stay until the engine ships the residual fix.
+
 ## [1.9.209.0] - 2026-09-20
 
 ### Performance — engine sync (1.9.209)

data/README.adoc

@@ -67,8 +67,11 @@ vendors precompiled `libleptris` + `libutf8proc` binaries for the
 common engine platforms under `lib/leptris/vendor/`:
 
 - `arm64-darwin`, `x86_64-darwin`
-- `x86_64-linux`, `aarch64-linux` (glibc; the musl variants are
-  tried as fallback for Alpine hosts)
+- `x86_64-linux`, `aarch64-linux` (glibc) and `x86_64-linux-musl`,
+  `aarch64-linux-musl` (tried as fallback for Alpine hosts)
+- `arm-linux`, `arm-linux-musl` (32-bit ARM EABI5)
+- `ppc64le-linux`, `s390x-linux`, `s390x-linux-musl` (POWER8+ LE
+  and IBM Z, qemu-built)
 
 `gem install leptris` just works on both engines — the FFI layer
 selects the matching vendored binary at require time (the binding
@@ -127,7 +130,10 @@ Leptris::XML::FFI.leptris_last_error    # => "..."
 `Leptris::XML.parse_html(html)` parses tolerant HTML4/5 into a
 standard Document — the same nodes, pool, serializer, and
 XPath/XSLT/XQuery machinery as XML (libleptris 1.9.75, the last
-Nokogiri capability gap):
+Nokogiri capability gap). The `Leptris::HTML`, `Leptris::HTML4`,
+and `Leptris::HTML5` module facades provide the
+Nokogiri-shaped entry points over the same engine
+(`Leptris::HTML5.parse(html)`, `Leptris::HTML(html)`):
 
 [source,ruby]
 ----
@@ -345,18 +351,45 @@ puts doc.to_xml
 `Element#replace(node)` / `#swap(node)` :: replace in parent.
 `Element#wrap(node_or_markup)` :: wrap this element in a new one.
 `Node#unlink` :: detach from the tree.
+`Element#attribute_pairs` :: bulk read-only attribute listing — `[[name, value], ...]` in document order, duplicates included; one C crossing on the native layer (libleptris 1.9.210 era).
+
+Document diffing (`Leptris::XML.diff(a, b)`) yields an op list with
+`#ops`, per-kind counts via `#summary`
+(`{update_attr: 1, insert: 1}`, `{}` when identical), and `#to_json`
+for the op list — the `leptris diff --summary/--json` CLI modes'
+library face.
 
 === Building from scratch (no parse)
 
+`Document.create` starts an empty document; build up from there
+(document-level prolog parts included — PIs, comments, the XML
+declaration, and the DOCTYPE are all first-class):
+
 [source,ruby]
 ----
-# Create an empty Document by parsing a sentinel and replacing the root,
-# or build incrementally on a one-element seed.
-doc = Leptris::XML.parse("<root/>")
-doc.root.name = "catalog"
-# ... then create_element / add_child as above.
+doc   = Leptris::XML::Document.create
+book  = doc.create_element("book")
+book[:id] = "b3"
+book << doc.create_element("title")
+doc.root = doc.create_element("catalog")
+doc.root << book
+doc.add_comment("built programmatically")   # epilog comment
+doc.set_doctype("catalog", system_id: "catalog.dtd")
+
+puts doc.to_xml
 ----
 
+[horizontal]
+`Document.create` :: empty document (no root yet).
+`Document#root=` :: attach the root element (bottom-up construction).
+`Document#set_doctype(name, public_id:, system_id:)` :: programmatic DOCTYPE.
+`Document#doctype` (alias `#internal_subset`) :: the `DocType` reader (name/root_name/public_id/system_id/internal_subset).
+`Document#clear_declaration` :: un-set the XML declaration (serialize as if the input had none; idempotent).
+`Document#remove_doctype` :: un-set the DOCTYPE (true when removed; the DocType stays readable until `#free`).
+`Document#add_pi(target, data)` / `#remove_pi(target_or_index)` :: document-level processing instructions.
+`Document#add_comment(str)` :: epilog comment.
+`Document#create_entity_reference(name)` :: `&name;` node, serializes verbatim once attached.
+
 == Namespaces
 
 [horizontal]
@@ -711,11 +744,16 @@ Notable differences:
   past Document disposal will see the error; silence-replace-UAF patterns
   from Nokogiri do not apply.
 * No `Nokogiri::CSS` parser. HTML parsing is supported
-  (`Leptris::XML.parse_html`, libleptris 1.9.75); Nokogiri's
+  (`Leptris::HTML` / `Leptris::HTML4` / `Leptris::HTML5` facades
+  over `Leptris::XML.parse_html`, libleptris 1.9.75); Nokogiri's
   HTML-specific node subclasses have no equivalent.
-* No RelaxNG / DTD validation, no schema caching (XSLT 1.0–3.0
+* RelaxNG and DTD validation ARE supported (`Leptris::XML::RelaxNG`,
+  `Leptris::XML::DTD` — parse once, validate many, structured
+  errors). No W3C XML Schema and no schema caching (XSLT 1.0–3.0
   and an XQuery 1.0 core are supported — see above).
-* No built-in JRuby / TruffleRuby support — only CRuby via `ffi`.
+* TruffleRuby and JRuby ARE supported out of the box (#160): the
+  `ruby`-platform variant vendors precompiled binaries and the
+  binding is FFI-based (no MRI C extension required to load).
 
 == Performance
 

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.209"
+LIBLEPTRIS_VERSION = "1.9.210"
 # 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
@@ -117,6 +117,35 @@ task :compile do
     rm_rf([File.join(dest, "build"), File.join(dest, "prefix")])
   end
 
+  # Rebuild notes ride every gem beside the sources (packaging
+  # doctrine): the exact pins and the commands to reproduce the
+  # vendored libraries. The ruby variant's extconf runs these
+  # trees automatically at install time.
+  File.write(File.join(vsrc, "README.md"), <<~README)
+    Sources vendored in this gem (recompile rights; the ruby
+    variant builds them at install via extconf.rb):
+
+    - libleptris v#{LIBLEPTRIS_VERSION}
+    - utf8proc v#{UTF8PROC_VERSION}
+
+    Rebuild by hand:
+
+        cmake -B vendor-src/utf8proc/build -S vendor-src/utf8proc \
+          -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON \
+          -DUTF8PROC_ENABLE_TESTING=OFF
+        cmake --build vendor-src/utf8proc/build --config Release
+        cmake --install vendor-src/utf8proc/build --prefix <prefix>
+
+        cmake -B vendor-src/libleptris/build -S vendor-src/libleptris \
+          -DCMAKE_BUILD_TYPE=Release \
+          -DLEPTRIS_BUILD_SHARED=ON -DLEPTRIS_BUILD_STATIC=OFF \
+          -DBUILD_TESTING=OFF -DLEPTRIS_BUILD_CLI=OFF \
+          -DLEPTRIS_BUILD_BENCHMARKS=OFF -DLEPTRIS_BUILD_MAN_PAGES=OFF \
+          -DLEPTRIS_ENABLE_UTF8PROC=ON \
+          -DCMAKE_PREFIX_PATH=<utf8proc-prefix>
+        cmake --build vendor-src/libleptris/build --config Release
+  README
+
   # libleptris 1.9.18's xslt_functions.c:270 assigns LeptrisElement
   # to LeptrisNodeRef — GCC 14 (Alpine/musl) makes incompatible
   # pointer types an error by default and the musl platform gems
@@ -357,6 +386,46 @@ namespace :audit do
     end
   end
 
+  # Packaging doctrine (#271): every BUILT gem carries the engine
+  # source (vendor-src/libleptris build inputs) and the ext sources;
+  # platform gems additionally carry the prebuilt libraries and must
+  # NOT carry extensions; the pure ruby gem compiles at install
+  # (extensions present). Run over pkg/*.gem before publishing —
+  # the gate is what keeps the doctrine from regressing silently.
+  desc "Audit built gems for the packaging doctrine (source + binaries + extension policy)"
+  task :doctrine do
+    gems = Dir.glob("pkg/*.gem")
+    abort "audit:doctrine: no gems in pkg/ — build first (rake gem:native:...)" if gems.empty?
+
+    gems.each do |path|
+      spec = Gem::Package.new(path).spec
+      files = spec.files.map { |f| f.gsub("\\", "/") }
+
+      missing = []
+      missing << "vendor-src/libleptris/CMakeLists.txt" unless
+        files.include?("vendor-src/libleptris/CMakeLists.txt")
+      missing << "vendor-src/README.md" unless files.include?("vendor-src/README.md")
+      missing << "ext/leptris/native/extconf.rb" unless
+        files.include?("ext/leptris/native/extconf.rb")
+
+      if spec.platform.to_s == "ruby"
+        missing << "extensions (compile-at-install)" if spec.extensions.empty?
+      else
+        binary = files.any? { |f| f =~ %r{\Alib/libleptris\.(so|dylib|dll)\z} } ||
+                 files.any? { |f| f.start_with?("lib/leptris/vendor/") }
+        missing << "prebuilt engine binary" unless binary
+        missing << "extensions (platform gems never rebuild)" unless spec.extensions.empty?
+      end
+
+      if missing.empty?
+        puts "audit:doctrine: #{File.basename(path)} OK " \
+             "(#{spec.platform}, #{files.length} files)"
+      else
+        abort "audit:doctrine: #{File.basename(path)} MISSING: #{missing.join(', ')}"
+      end
+    end
+  end
+
   # @api private
   def nm_available?
     system("nm", "--version", out: File::NULL, err: File::NULL)

data/TODO.restructure/17-perf-drift-record.md

@@ -10,3 +10,18 @@ Status: DONE
       parse 10–12×, serialize 2.9–3.2×, inner_html 4–5×, attr reads
       6–9×, text 9–11×, element_children walks at parity. Will
       re-record on the next clean window (load < 15).
+
+## Re-recorded 2026-09-21 — clean window (load ~12, 1.9.210.0, 84k-element/1.3MB catalog, interleaved best-of-5, nokogiri 1.19.4)
+
+- [x] Standing harness (MEDIUM fixture): parse medium **11.1x** /
+      small 1.88x; xpath 2.4-20x (predicate 15-20x, complex
+      11-14x); traverse 1.5-1.7x; serialize 2.25-3.13x
+- [x] Warm `children` walks **2.06-2.08x** (was 1.86x at 1.9.152)
+- [x] Cold parse+first-touch walks **0.58-0.74x (avg ~0.66x)** —
+      the loss nearly HALVED from 0.34x; the engine's
+      document-block/arena work (1.9.210) shows here
+- [x] Attr cold row (fresh wrappers) 1.18x
+- [ ] **Open front: cold TEXT row 0.66x** — fresh text-node
+      materialization (`element_children.each(&:content)` cold)
+      loses where warm text aggregation was 6.18x. Next perf
+      round's target.

data/lib/leptris/version.rb

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

data/lib/leptris/xml/descriptor.rb

@@ -28,7 +28,33 @@ require "ffi"
 # Namespace binding per plan: +ns:+ is :none (default), :any, or
 # { exact: "urn:..." }; +flags: [:mixed_content, :ordered, :cdata,
 # :ns_lenient].
+#
+# == Typed scalars (#230's fused-consumer contract, mirroring the
+# yeptris schema ABI)
+#
+# Attribute and child rows accept +type: :string (default),
+# :integer, :float, or :boolean+. The tag travels through the plan
+# ABI (host-defined, echoed verbatim) and PlanValue#to_ruby returns
+# the cast value — Integer / Float / true / false — so per-value
+# cast probes disappear from the consumer. Unparseable values fall
+# back to the raw String (lenient, first-wins house style);
+# #string_value always returns the raw String regardless of tag.
+#
+#     descriptor = Leptris::XML::Descriptor.build(
+#       name: "catalog",
+#       children: [
+#         { name: "price", kind: :scalar, type: :float },
+#         { name: "in_stock", kind: :scalar, type: :boolean },
+#       ])
+#     descriptor.materialize(xml_source).to_ruby  # typed, one call
 class Leptris::XML::Descriptor
+  TYPE_TAGS = {
+    string: 0,
+    integer: 1,
+    float: 2,
+    boolean: 3,
+  }.freeze
+  private_constant :TYPE_TAGS
   class Handle < ::FFI::AutoPointer
     def self.release(ptr)
       Leptris::XML::FFI.leptris_plan_free(ptr)
@@ -136,7 +162,7 @@ class Leptris::XML::Descriptor
         ap = Leptris::XML::FFI::AttrPlan.new(attr_memory[j])
         ap[:wire_name] = anchor_string(anchors, row.fetch(:name))
         ap[:kind] = kind_code(row[:kind] || :scalar)
-        ap[:type_tag] = row[:type_tag] || 0
+        ap[:type_tag] = type_tag_code(row)
       end
       ep[:attribute_count] = attrs.size
       ep[:attribute_plans] = attr_memory
@@ -148,7 +174,7 @@ class Leptris::XML::Descriptor
         cp = Leptris::XML::FFI::ChildPlan.new(child_memory[j])
         cp[:wire_name] = anchor_string(anchors, row.fetch(:name))
         cp[:kind] = kind_code(row[:kind] || :scalar)
-        cp[:type_tag] = row[:type_tag] || 0
+        cp[:type_tag] = type_tag_code(row)
         cp[:child_plan_index] = row[:child_plan_index] || -1
         # Rule-level ns form (libleptris 1.9.178, #1115): siblings
         # under one parent can require different URIs when set;
@@ -189,6 +215,20 @@ class Leptris::XML::Descriptor
   end
   private_class_method :kind_code
 
+  # +type: :string/:integer/:float/:boolean+ (or a raw numeric
+  # type_tag passthrough for hosts with their own vocabulary).
+  # Public: PlanValue's attribute casts share the vocabulary.
+  def self.type_tag_code(row)
+    if row.key?(:type)
+      TYPE_TAGS.fetch(row[:type]) do
+        raise ArgumentError,
+          "type must be one of #{TYPE_TAGS.keys.inspect}, got #{row[:type].inspect}"
+      end
+    else
+      row[:type_tag] || 0
+    end
+  end
+
   def initialize(handle, plans, root_index)
     @handle = handle
     @plans = plans
@@ -211,4 +251,21 @@ class Leptris::XML::Descriptor
     Leptris::XML::PlanValue.new(ResultHandle.new(raw),
                                 owner: true, plans: @plans, plan: @plans[0])
   end
+
+  # The fused loop (#230, pointed at the parse): source bytes →
+  # typed rows in ONE call — parse, walk the compiled plan, free
+  # the document; the returned PlanValue tree is standalone and
+  # the Document never surfaces. Byte-for-byte parity with
+  # #walk on the same source's root element.
+  def materialize(source)
+    document = Leptris::XML::Document.parse(source)
+    begin
+      root = document.root
+      raise Leptris::XML::Error,
+        "materialize: document has no root element" if root.nil?
+      walk(root)
+    ensure
+      document.free
+    end
+  end
 end

data/lib/leptris/xml/plan_value.rb

@@ -94,12 +94,40 @@ class Leptris::XML::PlanValue
     when :callback
       { value: string_value, position: position, type_tag: type_tag }
     else
-      string_value
+      typed_string_value
     end
   end
 
   private
 
+  # SCALAR honoring the plan row's type tag (#230's typed-scalars
+  # contract): 1=Integer, 2=Float, 3=boolean. Lenient on
+  # unparseable input — the raw String wins (first-wins house
+  # style; strict validation belongs to the consumer's callback
+  # rows). #string_value stays the raw escape.
+  def typed_string_value
+    case type_tag
+    when 1
+      s = string_value
+      Integer(s, 10) rescue s
+    when 2
+      s = string_value
+      begin
+        Float(s)
+      rescue ArgumentError, TypeError
+        s
+      end
+    when 3
+      case string_value
+      when "true", "1" then true
+      when "false", "0" then false
+      else string_value
+      end
+    else
+      string_value
+    end
+  end
+
   # The element plan that a child row with this wire_name recurses
   # into (nil for non-nested rows — their values carry no plan).
   def child_row_plan(child_wire_name)
@@ -114,8 +142,31 @@ class Leptris::XML::PlanValue
     result = {}
     ((@plan && @plan[:attributes]) || []).each do |row|
       v = attribute(row[:name])
-      result[row[:name]] = v unless v.nil?
+      result[row[:name]] = cast_attribute(v, row) unless v.nil?
     end
     result
   end
+
+  # Attribute values come back as plain Strings from the walk;
+  # apply the row's type tag with the same lenient semantics as
+  # typed_string_value.
+  def cast_attribute(value, row)
+    tag = Leptris::XML::Descriptor.type_tag_code(row)
+    case tag
+    when 1 then Integer(value, 10) rescue value
+    when 2
+      begin
+        Float(value)
+      rescue ArgumentError, TypeError
+        value
+      end
+    when 3
+      case value
+      when "true", "1" then true
+      when "false", "0" then false
+      else value
+      end
+    else value
+    end
+  end
 end

data/lib/leptris.rb

@@ -29,10 +29,13 @@ begin
 rescue LoadError => e
   raise LoadError, <<~MSG
     Leptris could not load the native libleptris library.
-    The ruby-platform gem is a fallback variant and ships no
-    binary; install the platform-specific variant for your system
-    (e.g. `gem install leptris --platform=arm64-darwin`), or set
-    LEPTRIS_LIB_PATH to a libleptris.{so,dylib,dll} file.
+    The ruby-platform gem carries the engine sources under
+    vendor-src/ and builds them at install time — a failed build
+    here usually means cmake or a C toolchain is missing (check
+    the gem install output). Alternatively install the
+    platform-specific variant for your system (e.g. `gem install
+    leptris --platform=arm64-darwin`), or set LEPTRIS_LIB_PATH to
+    a libleptris.{so,dylib,dll} file.
     (Underlying error: #{e.message})
   MSG
 end

data/vendor-src/README.md

@@ -0,0 +1,14 @@
+Sources vendored in this gem (recompile rights; the ruby
+variant builds them at install via extconf.rb):
+
+- libleptris v1.9.210
+- utf8proc v2.11.0
+
+Rebuild by hand:
+
+    cmake -B vendor-src/utf8proc/build -S vendor-src/utf8proc       -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON       -DUTF8PROC_ENABLE_TESTING=OFF
+    cmake --build vendor-src/utf8proc/build --config Release
+    cmake --install vendor-src/utf8proc/build --prefix <prefix>
+
+    cmake -B vendor-src/libleptris/build -S vendor-src/libleptris       -DCMAKE_BUILD_TYPE=Release       -DLEPTRIS_BUILD_SHARED=ON -DLEPTRIS_BUILD_STATIC=OFF       -DBUILD_TESTING=OFF -DLEPTRIS_BUILD_CLI=OFF       -DLEPTRIS_BUILD_BENCHMARKS=OFF -DLEPTRIS_BUILD_MAN_PAGES=OFF       -DLEPTRIS_ENABLE_UTF8PROC=ON       -DCMAKE_PREFIX_PATH=<utf8proc-prefix>
+    cmake --build vendor-src/libleptris/build --config Release

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
 
+## [1.9.210] - 2026-09-20
+
+### Added
+
+- The node-layout fork's document block (slice 1, #1253): two
+  contiguous geometrically-grown regions per document (dense node
+  array + string arena) with region-relative byte-offset edges —
+  growth never invalidates an offset. Foundation for the pugixml-
+  class parse layout (TODO.max-perf/node-layout-fork.md).
+
+### Performance
+
+- Large-document parse (#1222/#1238 lane, #1255): the parse arena
+  (~4x input) exceeded the arena retain cache's 32MB ceiling, so
+  every repeated-parse cycle freed and re-malloc'd tens of MB.
+  Ceiling raised to 96MB (one document's worth of parking) with a
+  thread-cleanup drain and ASAN free-for-real. Measured: 13MB
+  attr shape 341 -> 472 MB/s (+38%); the text shape's size-decline
+  eliminated (465 -> 163 MB/s falling across 1.5-13MB, now
+  ~605-627 flat).
+
+
+
 ## [1.9.209] - 2026-09-20
 
 ### Performance

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/CMakeLists.txt

@@ -47,6 +47,7 @@ set(LEPTRIS_SOURCES
 
     # Memory management
     leptris/memory/pool.c
+    leptris/memory/doc_block.c
     leptris/memory/arena.c
     leptris/dom/compact.c
     leptris/dom/root_doc_map.c

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

@@ -74,9 +74,11 @@ LEPTRIS_API void leptris_thread_cleanup(void) {
     extern void leptris_xpath_drain_thread_caches(void);
     extern void leptris_root_doc_drain_thread_caches(void);
     extern void leptris_pool_drain_recycler(void);
+    extern void leptris_arena_retain_drain(void);
     leptris_xpath_drain_thread_caches();
     leptris_root_doc_drain_thread_caches();
     leptris_pool_drain_recycler();
+    leptris_arena_retain_drain();
 }
 
 /* ---- Memory management API ---- */

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

@@ -51,7 +51,20 @@ static inline size_t align_up(size_t n) {
  * twice per document lifetime, so contention is irrelevant. */
 #define ARENA_RETAIN_MIN (256u * 1024u)
 #define ARENA_RETAIN_MAX_BLOCKS 4u
-#define ARENA_RETAIN_MAX_BYTES (32u * 1024u * 1024u)
+/* 96MB: a large-document parse arena (~4x input with the
+ * pre-sized estimate) must survive the free to be reused by the
+ * next parse — at the old 32MB ceiling, every big-doc cycle
+ * freed and re-malloc'd tens of MB (libc madvise showed ~2% of
+ * repeated-parse wall time). One document's worth of parking. */
+#define ARENA_RETAIN_MAX_BYTES (96u * 1024u * 1024u)
+
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+#define ARENA_RETAIN_ASAN 1
+#endif
+#elif defined(__SANITIZE_ADDRESS__)
+#define ARENA_RETAIN_ASAN 1
+#endif
 
 static struct {
     char* base[ARENA_RETAIN_MAX_BLOCKS];
@@ -106,6 +119,14 @@ static char* retain_take(size_t request, size_t* capacity) {
 }
 
 static void retain_give(char* base, size_t size) {
+#ifdef ARENA_RETAIN_ASAN
+    /* ASAN: retained blocks have no TLS destructor and read as
+     * LSan leaks — free for real (the recycle win is measurable
+     * only in repeated-parse loops, which ASAN runs don't gate). */
+    (void)size;
+    leptris_free_hook(base);
+    return;
+#endif
     if (size < ARENA_RETAIN_MIN) {
         leptris_free_hook(base);
         return;
@@ -124,6 +145,18 @@ static void retain_give(char* base, size_t size) {
     retain_unlock();
 }
 
+/* Host-invoked drain (leptris_thread_cleanup): the retained
+ * blocks are process-lifetime parking by design; release them so
+ * embedded hosts and leak checkers see a clean exit. */
+void leptris_arena_retain_drain(void) {
+    retain_lock();
+    for (size_t i = 0; i < g_retain.count; i++)
+        leptris_free_hook(g_retain.base[i]);
+    g_retain.count = 0;
+    g_retain.bytes = 0;
+    retain_unlock();
+}
+
 char* leptris_arena_buffer_alloc(size_t size) {
     size_t capacity = size;
     char* base = retain_take(size, &capacity);

data/vendor-src/libleptris/src/leptris/memory/arena.h

@@ -55,6 +55,9 @@ void leptris_arena_reset(LeptrisArena* arena);
  * All pointers handed out by the arena become invalid. */
 void leptris_arena_destroy(LeptrisArena* arena);
 
+/* Release retained arena blocks (leptris_thread_cleanup drain). */
+void leptris_arena_retain_drain(void);
+
 /* Bump-allocate `size` bytes, 8-byte aligned. NOT zeroed.
  * Returns NULL when the request does not fit in remaining space —
  * no fallback allocation, ever (see the contract above). */

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

@@ -0,0 +1,108 @@
+/* doc_block.c — the node-layout fork's document block (slice 1).
+ * See doc_block.h for the design contract. */
+
+#include "doc_block.h"
+#include <stdlib.h>
+#include <string.h>
+
+#define DOC_BLOCK_MIN_CAP ((size_t)4096)
+#define DOC_BLOCK_ALIGN   ((size_t)8)
+
+struct LeptrisDocBlock {
+    char*  nodes;        /* node region base (8-aligned) */
+    size_t nodes_cap;
+    size_t nodes_used;
+    char*  strs;         /* string region base */
+    size_t strs_cap;
+    size_t strs_used;
+};
+
+static char* region_grow(char* p, size_t* cap, size_t need) {
+    size_t want = *cap ? *cap : DOC_BLOCK_MIN_CAP;
+    while (want < need) want *= 2;
+    char* grown = (char*)realloc(p, want);
+    if (grown) *cap = want;
+    return grown;
+}
+
+LeptrisDocBlock* leptris_doc_block_create(size_t initial_capacity) {
+    LeptrisDocBlock* b =
+        (LeptrisDocBlock*)calloc(1, sizeof(*b));
+    if (!b) return NULL;
+    if (initial_capacity && initial_capacity < DOC_BLOCK_MIN_CAP)
+        initial_capacity = DOC_BLOCK_MIN_CAP;
+    if (initial_capacity) {
+        b->nodes = (char*)malloc(initial_capacity);
+        b->strs = (char*)malloc(initial_capacity);
+        if (!b->nodes || !b->strs) {
+            free(b->nodes);
+            free(b->strs);
+            free(b);
+            return NULL;
+        }
+        b->nodes_cap = b->strs_cap = initial_capacity;
+    }
+    return b;
+}
+
+void leptris_doc_block_free(LeptrisDocBlock* b) {
+    if (!b) return;
+    free(b->nodes);
+    free(b->strs);
+    free(b);
+}
+
+size_t leptris_doc_block_node_alloc(LeptrisDocBlock* b, size_t sz) {
+    if (!b || sz == 0 || sz > (size_t)-1 / 2) return (size_t)-1;
+    size_t off = (b->nodes_used + DOC_BLOCK_ALIGN - 1) &
+                 ~(DOC_BLOCK_ALIGN - 1);
+    size_t need = off + sz;
+    if (need > b->nodes_cap) {
+        char* grown = region_grow(b->nodes, &b->nodes_cap, need);
+        if (!grown) return (size_t)-1;
+        b->nodes = grown;
+    }
+    b->nodes_used = need;
+    return off;
+}
+
+size_t leptris_doc_block_str(LeptrisDocBlock* b, const char* s,
+                             size_t len) {
+    if (!b || (!s && len)) return (size_t)-1;
+    size_t need = b->strs_used + len + 1;
+    if (need > b->strs_cap) {
+        char* grown = region_grow(b->strs, &b->strs_cap, need);
+        if (!grown) return (size_t)-1;
+        b->strs = grown;
+    }
+    size_t off = b->strs_used;
+    if (len) memcpy(b->strs + off, s, len);
+    b->strs[off + len] = '\0';
+    b->strs_used = need;
+    return off;
+}
+
+void* leptris_doc_block_node(const LeptrisDocBlock* b, size_t off) {
+    return (b && off < b->nodes_used) ? b->nodes + off : NULL;
+}
+
+void* leptris_doc_block_nodes_base(const LeptrisDocBlock* b) {
+    return b ? b->nodes : NULL;
+}
+
+size_t leptris_doc_block_nodes_used(const LeptrisDocBlock* b) {
+    return b ? b->nodes_used : 0;
+}
+
+const char* leptris_doc_block_str_at(const LeptrisDocBlock* b,
+                                     size_t off) {
+    return (b && off < b->strs_used) ? b->strs + off : NULL;
+}
+
+size_t leptris_doc_block_bytes_used(const LeptrisDocBlock* b) {
+    return b ? b->nodes_used + b->strs_used : 0;
+}
+
+size_t leptris_doc_block_capacity(const LeptrisDocBlock* b) {
+    return b ? b->nodes_cap + b->strs_cap : 0;
+}

data/vendor-src/libleptris/src/leptris/memory/doc_block.h

@@ -0,0 +1,61 @@
+/* lib/src/memory/doc_block.h — the node-layout fork's document
+ * block (TODO.max-perf/node-layout-fork, slice 1).
+ *
+ * Two contiguous, geometrically-grown regions per document — a
+ * dense node array and a string arena. Every reference to either
+ * is a byte OFFSET within its region, so growth (realloc) never
+ * invalidates an edge: callers hold offsets, not pointers, and
+ * refetch region bases after any allocation.
+ *
+ * Differences vs memory/pool.c (which stays for mutation paths):
+ * the pool chains fixed 32KB pages, scattering one tree across
+ * pages; each parse node pays compact-edge encoding and detached
+ * nodes pay root-doc registration. Here the tree is contiguous
+ * (walk locality), edges are plain offsets (no cp16 overflow
+ * table), and the owning document is implied by the region base.
+ */
+#ifndef LEPTRIS_MEMORY_DOC_BLOCK_H
+#define LEPTRIS_MEMORY_DOC_BLOCK_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct LeptrisDocBlock LeptrisDocBlock;
+
+/* Create with an initial byte capacity per region (grown
+ * geometrically on demand; 0 = lazy). NULL on failure. */
+LeptrisDocBlock* leptris_doc_block_create(size_t initial_capacity);
+
+void leptris_doc_block_free(LeptrisDocBlock* b);
+
+/* Node region: bump-allocate sz bytes, 8-byte aligned. Returns
+ * the node's offset in the region (stable across growth) — never
+ * a pointer; resolve via leptris_doc_block_node. (size_t)-1 on
+ * failure. Growth may realloc: refetch any held pointers. */
+size_t leptris_doc_block_node_alloc(LeptrisDocBlock* b, size_t sz);
+
+/* String region: append len bytes plus a NUL. Returns the
+ * string's offset in ITS region (stable across growth) or
+ * (size_t)-1 on failure. */
+size_t leptris_doc_block_str(LeptrisDocBlock* b, const char* s,
+                             size_t len);
+
+/* Resolve an offset (region base + off, one add). */
+void* leptris_doc_block_node(const LeptrisDocBlock* b, size_t off);
+
+void* leptris_doc_block_nodes_base(const LeptrisDocBlock* b);
+size_t leptris_doc_block_nodes_used(const LeptrisDocBlock* b);
+const char* leptris_doc_block_str_at(const LeptrisDocBlock* b,
+                                     size_t off);
+size_t leptris_doc_block_bytes_used(const LeptrisDocBlock* b);
+size_t leptris_doc_block_capacity(const LeptrisDocBlock* b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LEPTRIS_MEMORY_DOC_BLOCK_H */

data/vendor-src/libleptris/test/CMakeLists.txt

@@ -116,6 +116,7 @@ leptris_add_test(test_simd_spans common/test_simd_spans.cpp)
 leptris_add_test(test_pool       memory/test_pool.cpp)
 leptris_add_test(test_oom        memory/test_oom_injection.cpp)
 leptris_add_test(test_arena      memory/test_arena.cpp)
+leptris_add_test(test_doc_block memory/test_doc_block.cpp)
 leptris_add_test(test_pool_arena memory/test_pool_arena.cpp)
 leptris_add_test(test_xpath      xpath/test_xpath.cpp)
 leptris_add_test(test_exslt       xpath/test_exslt.cpp)

data/vendor-src/libleptris/test/memory/test_arena.cpp

@@ -192,11 +192,25 @@ TEST(Arena, AllPointersWithinSpanForCompactEncoding) {
 
 /* ---- Retained-block free list (parse fault fix) ---------------------- */
 
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+#define ARENA_TESTS_ASAN 1
+#endif
+#elif defined(__SANITIZE_ADDRESS__)
+#define ARENA_TESTS_ASAN 1
+#endif
+
 TEST(LeptrisArena, RetainsAndReusesLargeBlocks) {
     /* Blocks >= 256 KB must round-trip through the free list: the
      * next same-size create gets the SAME mapping back (no munmap,
      * no page faults). Machine-independent by construction: it
      * asserts pointer identity, not timing. */
+    /* Under ASAN the retain cache frees for real (no TLS
+     * destructor; parked blocks read as LSan leaks) — the reuse
+     * contract is deliberately disabled there. */
+#if defined(ARENA_TESTS_ASAN)
+    GTEST_SKIP() << "retain cache disabled under ASAN";
+#endif
     const size_t big = 512u * 1024u;
     LeptrisArena* a1 = leptris_arena_create(big);
     ASSERT_NE(a1, nullptr);
@@ -239,6 +253,13 @@ TEST(LeptrisArena, SmallBlocksStillMallocSemantics) {
 }
 
 TEST(LeptrisArena, BufferRoundTripReusesMapping) {
+/* Under ASAN the retain cache frees for real (no TLS
+     * destructor; parked blocks read as LSan leaks) — the reuse
+     * contract is deliberately disabled there. */
+#if defined(ARENA_TESTS_ASAN)
+    GTEST_SKIP() << "retain cache disabled under ASAN";
+#endif
+
     char* b1 = leptris_arena_buffer_alloc(512u * 1024u);
     ASSERT_NE(b1, nullptr);
     memset(b1, 1, 512u * 1024u);

data/vendor-src/libleptris/test/memory/test_doc_block.cpp

@@ -0,0 +1,94 @@
+// test/memory/test_doc_block.cpp - the node-layout fork's document
+// block (slice 1). Falsifiable contract: offsets stay valid across
+// geometric growth, regions stay dense/aligned, boundary inputs
+// are refused.
+
+#include <gtest/gtest.h>
+#include <cstring>
+#include <cstdio>
+#include <vector>
+#include "../../src/leptris/memory/doc_block.h"
+
+typedef struct {
+    uint32_t first_child;
+    uint32_t next;
+    uint32_t name_off;
+} TNode;
+
+TEST(DocBlock, OffsetsSurviveGrowth) {
+    LeptrisDocBlock* b = leptris_doc_block_create(0);
+    ASSERT_NE(b, nullptr);
+    std::vector<uint32_t> offs;
+    const int N = 20000;
+    for (int i = 0; i < N; i++) {
+        size_t off = leptris_doc_block_node_alloc(b, sizeof(TNode));
+        ASSERT_NE(off, (size_t)-1);
+        ASSERT_EQ(off % 8u, 0u);
+        TNode* n = (TNode*)leptris_doc_block_node(b, off);
+        ASSERT_NE(n, nullptr);
+        n->first_child = 0;
+        n->next = i > 0 ? offs[i - 1] : 0;
+        n->name_off = 0;
+        offs.push_back((uint32_t)off);
+        if (i % 1000 == 0) {
+            for (size_t k = 1; k < offs.size(); k++) {
+                const TNode* p =
+                    (const TNode*)leptris_doc_block_node(b, offs[k]);
+                ASSERT_NE(p, nullptr);
+                ASSERT_EQ(p->next, offs[k - 1]);
+            }
+        }
+    }
+    EXPECT_GT(leptris_doc_block_capacity(b), (size_t)0);
+    leptris_doc_block_free(b);
+}
+
+TEST(DocBlock, StringRegionStableAcrossGrowth) {
+    LeptrisDocBlock* b = leptris_doc_block_create(64);
+    ASSERT_NE(b, nullptr);
+    std::vector<size_t> offs;
+    char buf[32];
+    for (int i = 0; i < 5000; i++) {
+        int n = snprintf(buf, sizeof(buf), "name-%05d", i);
+        size_t off = leptris_doc_block_str(b, buf, (size_t)n);
+        ASSERT_NE(off, (size_t)-1);
+        offs.push_back(off);
+    }
+    for (int i = 0; i < 5000; i += 500) {
+        int n = snprintf(buf, sizeof(buf), "name-%05d", i);
+        const char* s = leptris_doc_block_str_at(b, offs[i]);
+        ASSERT_NE(s, nullptr);
+        EXPECT_EQ(std::memcmp(s, buf, (size_t)n), 0);
+        EXPECT_EQ(s[n], '\0');
+    }
+    leptris_doc_block_free(b);
+}
+
+TEST(DocBlock, BoundaryInputsRefused) {
+    LeptrisDocBlock* b = leptris_doc_block_create(0);
+    ASSERT_NE(b, nullptr);
+    EXPECT_EQ(leptris_doc_block_node_alloc(b, 0), (size_t)-1);
+    EXPECT_EQ(leptris_doc_block_node_alloc(nullptr, 8), (size_t)-1);
+    EXPECT_EQ(leptris_doc_block_str(b, nullptr, 3), (size_t)-1);
+    size_t off = leptris_doc_block_str(b, "", 0);
+    EXPECT_NE(off, (size_t)-1);
+    EXPECT_STREQ(leptris_doc_block_str_at(b, off), "");
+    EXPECT_EQ(leptris_doc_block_node(b, 1 << 20), nullptr);
+    leptris_doc_block_free(b);
+    leptris_doc_block_free(nullptr);
+}
+
+TEST(DocBlock, NodesAndStringsIndependent) {
+    LeptrisDocBlock* b = leptris_doc_block_create(0);
+    ASSERT_NE(b, nullptr);
+    size_t n1 = leptris_doc_block_node_alloc(b, 16);
+    size_t s1 = leptris_doc_block_str(b, "abc", 3);
+    size_t n2 = leptris_doc_block_node_alloc(b, 16);
+    size_t s2 = leptris_doc_block_str(b, "defg", 4);
+    EXPECT_NE(n1, n2);
+    EXPECT_NE(s1, s2);
+    EXPECT_STREQ(leptris_doc_block_str_at(b, s1), "abc");
+    EXPECT_STREQ(leptris_doc_block_str_at(b, s2), "defg");
+    EXPECT_EQ(leptris_doc_block_nodes_used(b), 32u);
+    leptris_doc_block_free(b);
+}

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.209",
+  "version": "1.9.210",
   "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.209.1
+  version: 1.9.210.1
 platform: arm-linux
 authors:
 - Ribose Inc.
@@ -187,6 +187,7 @@ files:
 - lib/libleptris.so
 - lib/libutf8proc.so.3
 - scripts/gem_smoke.rb
+- vendor-src/README.md
 - vendor-src/libleptris/CHANGELOG.md
 - vendor-src/libleptris/CLAUDE.md
 - vendor-src/libleptris/CMakeLists.txt
@@ -644,6 +645,8 @@ files:
 - vendor-src/libleptris/src/leptris/leptris_parse.h
 - vendor-src/libleptris/src/leptris/memory/arena.c
 - vendor-src/libleptris/src/leptris/memory/arena.h
+- vendor-src/libleptris/src/leptris/memory/doc_block.c
+- vendor-src/libleptris/src/leptris/memory/doc_block.h
 - vendor-src/libleptris/src/leptris/memory/pool.c
 - vendor-src/libleptris/src/leptris/memory/pool.h
 - vendor-src/libleptris/src/leptris/rng/parse.c
@@ -798,6 +801,7 @@ files:
 - vendor-src/libleptris/test/html/test_html.cpp
 - vendor-src/libleptris/test/html/test_html5lib.cpp
 - vendor-src/libleptris/test/memory/test_arena.cpp
+- vendor-src/libleptris/test/memory/test_doc_block.cpp
 - vendor-src/libleptris/test/memory/test_oom_injection.cpp
 - vendor-src/libleptris/test/memory/test_pool.cpp
 - vendor-src/libleptris/test/memory/test_pool_arena.cpp