leptris 1.9.210.0-aarch64-linux → 1.9.213.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a2c84b82a16659bc64132d8dc4c58993c0948a0cc6503efb7bda2026c66e8a4
-  data.tar.gz: ceba8e6bfffdc72ee31c0003a880c5fcb3a875e28551778a014a3cca880ab625
+  metadata.gz: b840899442b8d26da4e97f213ea68ddbe4158ec52d9ddcbd423172231b8eda25
+  data.tar.gz: 0c2a4b6fe6b2d9b8fb2fe0114d4a9d1ab6c11d25d34a463a929f48bda71fb330
 SHA512:
-  metadata.gz: 3ef7b23ea04034b76107d02dc1672374c140d6fb84f4012c7799352325242ae50c4acf6c74b2686f201125c0e98aa1211bf70a6f1700a45b6d07a33c76ab1d09
-  data.tar.gz: c75201acc9602bb257baa9f4cc85971f3551e4edf1267b651c5bb399512b2c603cc5596a734693792a6128f79b9e8270aebb4cfaedd02acab3e448e432451828
+  metadata.gz: 4252440c757a98e2dae8483f959e8df94c047cffc8d43699e741ad3206e49ecacdb0ac2cb8b18d329e8faac43811a557dca864664f92a7c415743e9e68032c8f
+  data.tar.gz: 18f7d22d36e6a16ec1ff654d625c4a33efb7161a8d7ccac5c701183091c4ac38d3c2139a93b923f8cd8148f899ef00bf0f63403005103d6eb695141b2d8f4125

data/CHANGELOG.md

@@ -5,6 +5,46 @@ 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.213.0] - 2026-09-21
+
+### Engine sync — 1.9.211–1.9.213 (perf + the QT3 date/time family)
+
+- 1.9.211: the **interleaved parse lane** landed behind
+  `LEPTRIS_INTERLEAVED=1` (engine-side opt-in; sentinel-discipline
+  scans, fused 48-byte SIMD probes, names as zero-copy views —
+  1633/1633 parity). The XSLT append-tail memo (single-slot
+  validated last-child hint) also rides.
+- 1.9.212/1.9.213: the **QT3 date/time function family** for
+  XPath/XSLT (extractors, timezone + `fn:parse-ietf-date`,
+  `op:date` arithmetic, the yearMonthDuration family — 17 test
+  sets, 782/782 engine-side) plus int64/`long long` portability
+  fixes for MSVC/ILP32.
+- No binding-facing surface changes: audit holds at 335/335,
+  suite 760/0.
+
+## [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)

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.210"
+LIBLEPTRIS_VERSION = "1.9.213"
 # 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/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.210.0"
+  VERSION = "1.9.213.0"
 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/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.210
+- libleptris v1.9.213
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,62 @@
 ## [Unreleased]
 
+## [1.9.213] - 2026-09-21
+
+### Added — the op:date and yearMonth families (#1182, lever 6)
+
+- **op-date arithmetic (#1265)**: date/time/dateTime +/- dayTimeDuration — 6 QT3 sets, 128/128. Shared lexical shifter (`leptris_dt_shift`), time arithmetic wrapping the day, ISO date-shaped string comparisons. Fixed two corpus-caught bugs: zoned times misclassified as dateTimes, and dateTime results printing the input's seconds instead of the shifted instant's.
+- **yearMonthDuration family (#1266)**: 11 QT3 sets, 264/264 — months arithmetic (PnYnM canonical, llrint tie rule), month-end clamping for date/dateTime shifts (leap-aware), negative-year printing. The lt/gt sets rode the existing months comparison hook untouched.
+
+Both batches survived the 32-bit-long portability classes (MSVC/ILP32): int64-range instant math and every %lld argument now use long long — the CI legs caught three occurrences of the width/specifier mismatch family.
+
+## [1.9.212] - 2026-09-21
+
+### Added — the QT3 date/time family (lever 6 stage-2, #1182)
+
+Three corpus-driven batches land the date/time surface with the
+W3C QT3 suite as the gate:
+
+- **Extractors (#1261)**: 12 vendored test-sets (300/300) —
+  year/month/day-from-date{,Time}, hours/minutes/seconds-from-
+  {time,dateTime} — plus five language fixes: function-call
+  operands for eq/ne/lt/le/gt/ge (unprefixed and fn:-prefixed),
+  the `idiv` operator, unary `+`, the timezone scan in date
+  parsing (zoned values were treated as naive), and the
+  empty-sequence/fractional-seconds extractor contracts.
+- **Timezone + RFC 5322 (#1262)**: 5 sets (90/90) —
+  timezone-from-* accessors and fn:parse-ietf-date (both lexical
+  orders, obsolete US zones, verbatim fractions). The QT3 harness
+  grew inline param environments and external-declaration
+  prepending.
+- **op:dayTimeDuration value model (#1263)**: 8 sets (287/287) —
+  duration arithmetic (+, -, *, div), comparisons, min/max over
+  duration sequences, canonical formatting, FODT0002 range errors
+  (including a fixed fortified-runtime abort on giant values), and
+  adjust-* attaching the implicit timezone to naive values.
+
+## [1.9.211] - 2026-09-20
+
+### Performance
+
+- **Interleaved parse lane, slices 1-3a (#1258).** The first
+  pugixml-style interleaved rewrite landed behind
+  `LEPTRIS_INTERLEAVED=1` (opt-in; every input outside the covered
+  surface bails to the classic parser before any state). The lane
+  streams `IlRec`/`IlAttr` records with buffer-relative views, then
+  replays the classic public stores in one linear post-pass:
+  sentinel-discipline scans (no per-byte bounds tests; fused 48-byte
+  quote/'&'/whitespace probes with SIMD tails), upfront stream
+  capacity from the input size, and element/attribute names as
+  NUL'd views into the parse scratch (no per-name copies). Parity is
+  gated by a dedicated spec plus running the FULL test suite with
+  the lane forced on: 1633/1633 identical. `LEPTRIS_IL_STATS=1`
+  prints an engagement canary for diagnosing whether the lane ran.
+- **XSLT append-tail memo (#1259).** `out_append_child` keeps a
+  validated single-slot (parent, last-child) hint and feeds
+  `leptris_element_append_child_tail` — result-tree placement no
+  longer re-walks sibling chains (the hottest dispatch-heavy
+  profile leaf, ~17% of samples).
+
 ## [1.9.210] - 2026-09-20
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -24,3 +24,7 @@ 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.
+
+The interleaved-parse rewrite (owner-directed 2026-09-20):
+TODO.max-perf/interleaved-parse.md — the #1222 step-change; slices 0-4,
+each CI-benchmark-gated.

data/vendor-src/libleptris/TODO.max-perf/interleaved-parse.md

@@ -0,0 +1,67 @@
+# The interleaved-parse rewrite (the pugixml-class lane)
+
+Status: PLAN (2026-09-20, owner directive). Supersedes the fork's
+remaining slices for the XML parse path. Target: close the #1222
+large-document gap (pugixml 2-5.9x ahead on CI) at the SOURCE.
+
+## Why the current lane can't get there
+
+The no-LTO dissection (2026-09-20) shows direct_parse is at its
+representation optimum: fused 48B probe + SIMD value scan, packed
+attr tail, O(1) wiring, offset edges, root-only registration. The
+remaining per-item cost is the representation itself: per-attr
+40B struct stores inline in the parse loop, the scratch
+NUL-terminate/restore dance, per-element ns/line bookkeeping, and
+the O(K) dup-detection walk.
+
+## The pugixml model (what we're adopting)
+
+One immutable input (already ours, #1125) + ONE node region + ONE
+stream region. The parse loop ONLY appends to streams; nothing is
+finalized inline:
+
+1. **SOA attr streams** — per element, attrs land in parallel
+   arrays: name_off[4B] / value_off[4B] / len8[len pairs] into the
+   string stream. ~12-16B per attr, sequential stores, no structs
+   built during parse.
+2. **Length-based views everywhere** — names and values are
+   (offset, len) into the pristine buffer. NO NUL-termination, NO
+   scratch mutation, NO restore pass (the current lane's biggest
+   hidden cost).
+3. **Element records as pure data** — a 32-48B record per element
+   (name view, first_attr index, parent/first/next indices, line)
+   bump-carved from the node region (doc_block, slice 1 landed).
+4. **Deferred passes** — dup detection, ns stamping, hash
+   sentinel: all become ONE linear post-pass sweep over the
+   streams (cache-sequential), building the public
+   leptris_attribute structs. The public API, DOM semantics, and
+   every consumer see IDENTICAL trees.
+
+## Slices (one PR each, CI-benchmark-gated)
+
+0. **A/B harness**: bench_parse_ab in benchmarks/ — the attr/text
+   shapes at 1.5/5/13MB, leptris vs pugixml vs libxml2, run by the
+   CI Benchmark legs on QUIET runners (the local Mac under load
+   343 produced 46-85 MB/s phantom numbers — measurements gate on
+   CI only). PR with this plan.
+1. **The dp_il lane skeleton** (flag off): streams + records +
+   post-pass building the public tree for well-formed, DTD-free
+   input. Gate: parity specs byte-identical to the current lane;
+   CI A/B numbers recorded.
+2. **Tokenizer port**: the SIMD scan helpers onto the stream
+   appends. Gate: attr shape ≤1.5x pugixml, text ≤1.25x on CI.
+3. **Feature coverage**: DTD/entity/namespace/CDATA/PI routes
+   through the lane (fall back to the classic lane per-feature,
+   never wrong). Gate: full ctest + html5lib-style parity for the
+   XML suite (W3C + libxml2 corpus green).
+4. **Default flip**: LEPTRIS_PARSE_INTERLEAVED=1 default, classic
+   lane behind an env escape hatch. Gate: all 24 CI legs + a
+   release cut with the CI A/B table in the notes.
+
+## Invariants (non-negotiable)
+
+- Public API/ABI unchanged; every existing spec passes unmodified.
+- The classic lane stays until slice 4 ships AND one full release
+  runs clean.
+- Zero-copy views remain primary; the pristine buffer is never
+  mutated by the interleaved lane.

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

@@ -232,6 +232,19 @@ leptris_add_benchmark(bench_xslt_subtree_copy xslt/bench_subtree_copy.c utils.c)
 # ----------------------------------------------------------------------------
 leptris_add_benchmark(bench_iterparse   sax/bench_iterparse.c)
 
+# Interleaved-parse gate (#1222): leptris vs pugixml on identical
+# fixtures, run by the CI Benchmark legs (quiet runners).
+if(PUGIXML_AVAILABLE)
+    leptris_add_benchmark(bench_parse_ab CXX parse/bench_parse_ab.cpp)
+    target_compile_definitions(bench_parse_ab PRIVATE HAVE_PUGIXML=1)
+    if(PUGIXML_TARGET)
+        target_link_libraries(bench_parse_ab PRIVATE ${PUGIXML_TARGET})
+    else()
+        target_include_directories(bench_parse_ab PRIVATE ${PUGIXML_INCLUDE_DIR})
+        target_link_libraries(bench_parse_ab PRIVATE ${PUGIXML_LIBRARY})
+    endif()
+endif()
+
 # ----------------------------------------------------------------------------
 # SAX benchmarks (leptris vs libxml2).  TODO 101.
 # ----------------------------------------------------------------------------

data/vendor-src/libleptris/benchmarks/parse/bench_parse_ab.cpp

@@ -0,0 +1,83 @@
+/* bench_parse_ab.cpp — the interleaved-parse lane's gate (#1222).
+ *
+ * Same fixtures, sizes, and shapes for leptris and pugixml,
+ * best-of-5 each. The CI Benchmark legs run this on quiet
+ * runners; the interleaved lane's slices are gated on THESE
+ * numbers, never a loaded dev machine (2026-09-20: a Mac at load
+ * 340 measured a 472 MB/s build at 46-85).
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "leptris.h"
+#ifdef HAVE_PUGIXML
+#include "pugixml.hpp"
+using namespace pugi;
+#endif
+
+static double now_us(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return ts.tv_sec * 1e6 + ts.tv_nsec / 1e3;
+}
+
+static size_t gen(char* out, size_t target, int text_shape) {
+    size_t len = 0;
+    len += (size_t)sprintf(out + len, "<root>");
+    int i = 0;
+    if (text_shape) {
+        while (len < target)
+            len += (size_t)sprintf(out + len,
+                "<p>The quick brown fox jumps over the lazy dog %d.</p>", i++);
+    } else {
+        while (len < target)
+            len += (size_t)sprintf(out + len,
+                "<item id=\"%d\" class=\"c%d\" state=\"on\" ref=\"%d\">v %d</item>",
+                i, i % 7, i * 3, i++);
+    }
+    len += (size_t)sprintf(out + len, "</root>");
+    return len;
+}
+
+int main(void) {
+    const size_t sizes[3] = {1500 * 1024, 5000 * 1024, 13000 * 1024};
+    const char* names[2] = {"attr", "text"};
+    printf("%-6s %9s %12s %12s\n", "shape", "bytes", "leptris", "pugixml");
+    for (int s = 0; s < 2; s++) {
+        for (size_t si = 0; si < 3; si++) {
+            char* doc = (char*)malloc(sizes[si] + 2048);
+            if (!doc) return 1;
+            size_t len = gen(doc, sizes[si], s);
+            double best = 1e18;
+            for (int r = 0; r < 5; r++) {
+                double a = now_us();
+                LeptrisStatus st = LEPTRIS_OK;
+                LeptrisDocument d = leptris_parse_string(doc, len, &st);
+                double b = now_us();
+                if (!d) { printf("PARSE FAILED\n"); return 1; }
+                leptris_document_free(d);
+                if (b - a < best) best = b - a;
+            }
+            double mbps = len / 1048576.0 / (best / 1e6);
+#ifdef HAVE_PUGIXML
+            double pbest = 1e18;
+            for (int r = 0; r < 5; r++) {
+                double a = now_us();
+                xml_document xdoc;
+                xml_parse_result res = xdoc.load_buffer(doc, len);
+                double b = now_us();
+                if (!res) { printf("PUGIXML FAILED: %s\n", res.description()); return 1; }
+                if (b - a < pbest) pbest = b - a;
+            }
+            double pmbps = len / 1048576.0 / (pbest / 1e6);
+            printf("%-6s %9zu %10.1f %10.1f  MB/s  (pugixml %.2fx)\n",
+                   names[s], len, mbps, pmbps, pmbps / mbps);
+#else
+            printf("%-6s %9zu %10.1f %10s\n", names[s], len, mbps, "-");
+#endif
+            free(doc);
+        }
+    }
+    return 0;
+}