leptris 1.9.371.0-ppc64le-linux → 1.9.373.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce241a477870b3f87f210b42e00558040d8d08562df7064749e27120d8070b09
-  data.tar.gz: 72b0e8e891cb0539cbe8679293e694912c019e3d28a408492b88295f1240ce8a
+  metadata.gz: 3cfa4759d2078d8a80e6e45c27067fec2d01c9bfde679b5d379411d5d6b23d28
+  data.tar.gz: 01752c4ee4c9897dbb5765d7913a36397d251d1d75a02bd48115a3b2accdacdd
 SHA512:
-  metadata.gz: 2ae877b4e3b0037d3e3bd03e606ada3f75a4e6ef3e93f0796d9aa2b15ff682ff810c7d46eca0f6157746bfb91755d2655c98c69ca142056ccc036f95c135ebbd
-  data.tar.gz: a68ccf07157ce2cb5a20a5d9a71874f7fcf8863b616653c32c386dce532acb08fde7891e94e11e5daed74d1fa27c6832be29dd39386cdbc15ed833f068fcd9a4
+  metadata.gz: 268a5bd3746f3b30fb183cbe4acb076bb2b8670e8fd2577c47f780f0b973fa624a9efb7461e261484beef014dc86456d045f3af26d1ae576c4b7d41eab9ca28c
+  data.tar.gz: c7bba592a9065340448326f3d51550ed1ff5802d0801d5127c6726470815fb1a2d3d7b6fe2ae672f40b05ee8ff029b97d7eda88182b5d64850c4df310f1f6080

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.371"
+LIBLEPTRIS_VERSION = "1.9.373"
 # 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/ext/leptris/native/native.c

@@ -1414,20 +1414,30 @@ static VALUE nf_insert_binding_child(VALUE self, VALUE document,
 static VALUE nn_create_element(VALUE klass, VALUE document, VALUE name)
 {
     void *ptr;
+    VALUE mk = doc_klass_for_kind(document, 0);
     (void)klass;
     ptr = f_elem_create(doc_ptr_of(document), StringValueCStr(name));
     if (!ptr)
         rb_raise(c_runtime_error, "leptris_element_create failed");
+    /* #340: registered documents mint their element klass here too —
+     * the unattached create factories are the build path (moxml's
+     * create_element per record); plain NativeNode here forced the
+     * consumer into wrapper-mode bridging for the whole document. */
+    if (!NIL_P(mk))
+        return mint_consumer_node(mk, document, ptr);
     return wrap_new(document, ptr);
 }
 
 static VALUE nn_create_text(VALUE klass, VALUE document, VALUE content)
 {
     void *ptr;
+    VALUE mk = doc_klass_for_kind(document, 1);
     (void)klass;
     ptr = f_text_create(doc_ptr_of(document), StringValueCStr(content));
     if (!ptr)
         rb_raise(c_runtime_error, "leptris_text_node_create failed");
+    if (!NIL_P(mk))
+        return mint_consumer_node(mk, document, ptr);
     return wrap_new(document, ptr);
 }
 
@@ -3548,6 +3558,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_method(c_native_node, "create_child", nn_create_child, 1);
     rb_define_method(c_native_node, "append_child", nn_append_child, 1);
     rb_define_method(c_native_node, "add_child", nn_append_child, 1);
+    rb_define_alias(c_native_node, "add_child_native", "add_child");
     rb_define_method(c_native_node, "address", nn_address, 0);
     rb_define_method(c_native_node, "document", nn_document, 0);
     rb_define_method(c_native_node, "attributes", nn_attributes, 0);
@@ -3564,7 +3575,9 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
      * method-cache cost instead of UnboundMethod#bind_call. */
     rb_define_alias(c_native_node, "attr_read", "attribute");
     rb_define_alias(c_native_node, "text_read", "content");
+    rb_define_alias(c_native_node, "name_read", "name");
     rb_define_method(c_native_node, "children", nn_children, 0);
+    rb_define_alias(c_native_node, "children_read", "children");
     rb_define_method(c_native_node, "element_children", nn_element_children, 0);
     rb_define_method(c_native_node, "next_sibling", nn_next_sibling, 0);
     rb_define_method(c_native_node, "parent", nn_parent, 0);

data/lib/leptris/version.rb

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

data/lib/leptris/xml/document_fragment.rb

@@ -27,6 +27,15 @@ class Leptris::XML::DocumentFragment
   end
 
   def self.parse(xml, document)
+    # leptris#1781: the second argument is the HOST document (the
+    # fragment borrows its lifetime). A nil or wrong-typed argument
+    # used to surface from the native face as "document has been
+    # freed" — misread as a GC/lifecycle bug. Name the contract.
+    unless document.is_a?(Leptris::XML::Document)
+      raise ArgumentError,
+        "second argument must be the host Leptris::XML::Document " \
+        "(got #{document.inspect})"
+    end
     # TODO.perf/34: the C face answers the fragment address with
     # no status MemoryPointer and no Pointer mint; failures fall
     # back to the FFI pair for the exact error.
@@ -60,4 +69,33 @@ class Leptris::XML::DocumentFragment
   def name
     "#document-fragment"
   end
+
+  # The serialization face (leptris#1781): a fragment serializes as
+  # its children, concatenated — the synthetic "#document-fragment"
+  # wrapper never emits (Nokogiri's contract). One C pass over the
+  # child chain — the same pass Element#inner_html uses; the FFI
+  # fallback walks the children per node.
+  def to_html
+    ensure_host_alive!
+    return Leptris::XML::Native.fast_inner_xml(@c_address) if
+      defined?(Leptris::XML::NATIVE_FAST)
+    children.map(&:to_html).join
+  end
+
+  def to_xml(*, **)
+    to_html
+  end
+
+  def to_s
+    to_html
+  end
+
+  private
+
+  def ensure_host_alive!
+    # the document's own convention (UseAfterFreeError) — the
+    # fragment borrows the host's lifetime
+    raise Leptris::XML::UseAfterFreeError, "document has been freed" if
+      @document.freed?
+  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.371
+- libleptris v1.9.373
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,42 @@
 ## [Unreleased]
 
+## [1.9.373] - 2026-10-19
+
+### Added
+
+- **html: the #1771 verdict-parity gate (PRs #1778, #1779, #1780,
+  #1782, #1783).** The HTML5 corpus lane now gates on the §13.2.5
+  parse-error stream, not just tree shape: html5lib's own #errors
+  verdict vs `LEPTRIS_PARSE_COLLECT_HTML_ERRORS` per case. New
+  emission sites — the doctype-less initial insertion-mode family
+  (chars/start-tag/end-tag/EOF), EOF with open elements, the
+  raw-text EOF variants (named vs generic per the corpus's own
+  mapping), frameset-after-body-content, and the fenced
+  any-other-end-tag walk. Verdict parity 190 → 1394 of 1555 (floor
+  pinned); code-set overlap 975/1231, 417 exact; trees
+  byte-identical throughout (1555/1555).
+
+### Changed
+
+- **docs: the mission and the mission plan (#1776, #1777).** The
+  two-sided bar — conformance suites as the gate, benchmark
+  supremacy as the goal — now lives in CLAUDE.md, the README, and
+  `docs/MISSION-PLAN.md` (four falsifiable gates, phase
+  sequencing, invariants).
+
+
+## [1.9.372] - 2026-10-19
+
+### Changed
+
+- **test: document-context XPath parity pin (leptris-ruby#502).**
+  Test-only release: pins the `document()`/context-node parity
+  contract with a side-by-side Nokogiri regression spec in
+  `test/xpath/test_xpath.cpp` — expressions evaluated with a NULL
+  context resolve against the document node, matching Nokogiri.
+  No library-code changes; runtime rides re-pin to this engine.
+
+
 ## [1.9.371] - 2026-10-19
 
 ### Added

data/vendor-src/libleptris/CLAUDE.md

@@ -6,6 +6,13 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 **libleptris** — pure C99 XML 1.0 parser, XPath 1.0 engine (W3C-conformant), and SAX parser. Ships as a static/shared library plus a `leptris` CLI. Zero required runtime deps; `utf8proc` (Unicode) and `iconv` (encoding conversion) are optional.
 
+**Mission.** Replace the libxml2 era with a clean-room, dependency-free XML stack that is simultaneously more conformant and faster than the incumbents, delivered natively to every language it reaches. The bar is two-sided:
+
+- **Conformance suites are the gate.** W3C XPath (438/438), libxslt (205/205), QT3, the WHATWG/html5lib corpus — a feature isn't done until the suite says so.
+- **Benchmark supremacy is the goal.** No published scoreboard row — parse, serialize, XPath, walk+read, build — may trail nokogiri, libxml2, or pugixml.
+
+One engine, four runtime bindings — leptris-ruby (Nokogiri-compatible), leptris-py, leptris-ts (WebAssembly), leptris-rs — same engine, same numbers everywhere.
+
 ## Build & Test
 
 CMake-based (CMake ≥ 3.20). The default build is a static lib + CLI + tests:

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/README.adoc

@@ -17,6 +17,28 @@ canonicalization (C14N).  It is designed for low-latency,
 memory-efficient workloads where predictable performance and safe
 memory handling matter.
 
+== Mission
+
+Replace the libxml2 era with a clean-room, dependency-free XML stack
+that is simultaneously more conformant and faster than the incumbents,
+delivered natively to every language it reaches.
+
+The bar is two-sided:
+
+* **Conformance suites are the gate.** W3C XPath (438/438), libxslt
+  (205/205), QT3, the WHATWG/html5lib corpus — a feature isn't done
+  until the suite says so.
+* **Benchmark supremacy is the goal.** No published scoreboard row —
+  parse, serialize, XPath, walk+read, build — may trail nokogiri,
+  libxml2, or pugixml.
+
+One engine, four runtime bindings —
+https://github.com/leptris/leptris-ruby[leptris-ruby]
+(Nokogiri-compatible), https://github.com/leptris/leptris-py[leptris-py],
+https://github.com/leptris/leptris-ts[leptris-ts] (WebAssembly), and
+https://github.com/leptris/leptris-rs[leptris-rs] — same engine, same
+numbers everywhere.
+
 == Highlights
 
 * **XML 1.0 parsing** with UTF-8 validation and optional encoding

data/vendor-src/libleptris/docs/MISSION-PLAN.md

@@ -0,0 +1,163 @@
+# The Mission Plan
+
+How the mission — *replace the libxml2 era with a clean-room,
+dependency-free XML stack that is simultaneously more conformant and
+faster than the incumbents, delivered natively to every language it
+reaches* — is fully achieved.
+
+"Fully achieved" is not a feeling. The mission decomposes into four
+falsifiable gates. Each gate has a measurement command whose output is
+the verdict. Every number below is **last-known (date)** — Phase 0
+re-baselines everything before any work is sequenced against it.
+
+---
+
+## Gate A — Conformance: no suite red anywhere
+
+A feature isn't done until the suite says so. Conformance is the
+moat: it is the one axis where "clean-room" must prove it gave up
+nothing to libxml2.
+
+| # | Suite | Exit | Last known |
+|---|---|---|---|
+| A1 | W3C XPath 1.0 | 438/438 pinned in CI | **done** — 438/438 |
+| A2 | libxslt (XSLT 1.0) | 205/205 pinned (Linux-authoritative; macOS skips bug-169 iconv-encoding) | **done** — 205/205 (v1.9.19) |
+| A3 | XsltFull | 27/27 + full suite green; XSLT gate (v1.10.0) stays met | **done** — gate MET (#1761) |
+| A4 | QT3 / XQuery 3.1 | 0 unexplained pins; every pin has a recorded disposition | pins ~41–99 by slice (2026-09/10) — **re-pin fresh** |
+| A5 | WHATWG/html5lib (#659) | 0 reds on the tree gate; verdict parity climbing on the #1771 error-verdict gate | **tree lane CLOSED** — 1555/1555, redlist retired (found during Phase 0); verdict gate flipped 2026-10-19: 1312/1555, floor pinned |
+| A6 | XSD conformance lane | suite-complete per the lane's own queue | 769→795 (2026-10-14, queue #1691) |
+| A7 | DTD phase 8 (TODO 91) | ENTITY/ENTITIES attribute resolution, parameter entities, choice-model backtracking | open |
+| A8 | XInclude parse="xml" + xpointer (TODO 92) | spec-complete | open (parse="text" + fallback ship) |
+| A9 | RelaxNG / C14N / SAX | parity maintained, no reds | green |
+
+**Working rule (proven across A1–A3):** suite-driven fixes only —
+read the failing case, name the root cause, red-first spec, fix,
+re-run the whole suite. The recurring root causes are already
+documented (RTF binding, foreign-doc patterns, §3.4 ordering,
+xmlXPathFormatNumber, define-body sibling lists, carrier-by-pointer).
+Every engine fix lands with its regression spec before the next case
+is opened.
+
+**Exit:** `scripts/validate.sh` green + each suite's command in
+`VALIDATION.md` green + zero pins without a disposition file.
+
+---
+
+## Gate B — Performance: no published row trails
+
+The scoreboard is published pairs — CPU-time medians, 31
+interleaved reps, fresh build dirs, identical `CMAKE_BUILD_TYPE`
+on both sides. The discipline *is* the result; phantom wins come
+from stale build dirs, so the harness protocol is part of the gate.
+
+| Row | Bar | Last known |
+|---|---|---|
+| parse | ≥ nokogiri/libxml2/pugixml | 2.6x — ahead |
+| serialize | ≥ all | 2.6x — ahead |
+| XPath | ≥ all | 18x — ahead |
+| attr listing | ≥ all | 99x — ahead |
+| build | ≥ all | 0.87x — ahead |
+| walk+read (moxml) | ≥ 0.95x nokogiri | **done 2026-10-19** — ~195ns name / ~193ns content, 0.90–0.95x |
+| append / attr-parse (pugixml lane 18) | ≥ parity | **RED 2.0x / 5.9x** — hash-prefilter lever named |
+| DOM mutation rows | ≥ parity | RED — node-layout redesign, owner decision pending |
+| zero-copy text (#1218 lever) | adopt if it wins any row | lever named, unmeasured |
+
+**Working rules:** algorithms before struct bytes (the attr-parse and
+append rounds proved it); measure deltas, not absolutes (spill and
+extension-block effects are invisible in means — count events);
+one local build dir at -j4, CI is the gate; macro-benchmarks claim
+nothing without interleaved A/B medians.
+
+**Exit:** every published row ≥ 1.00x median-of-runs on the published
+harnesses + chokepoint regression gates in CI (the write-path and
+attr-path chokepoints get the same treatment conformance got).
+
+---
+
+## Gate C — Delivery: the engine reaches every language, natively
+
+The engine is nothing until a consumer can install it. Lockstep law:
+runtime versions are `{engine-semver}.{binding-patch}`; every engine
+release gets its runtime ride; ride branches push only after the tag
+lands (TAG-RACE).
+
+| # | Surface | Exit | Last known |
+|---|---|---|---|
+| C1 | leptris-ruby / -py / -ts rides | automated, proven (1.9.372 train: rubygems full matrix, PyPI, npm+provenance) | **done**, keep green |
+| C2 | leptris-rs descriptor crate | `leptris-descriptor` published; safe-wrapper crate rides lockstep | feat/294 in flight, not published |
+| C3 | moxml gem | cut (owner-dispatched) carries the walk+read adoption | merged on main, release pending owner |
+| C4 | Prebuilt binaries everywhere consumers lack compilers | rubygems platform matrix ✓, PyPI wheels ✓, npm WASM ✓ | **done**, keep green |
+| C5 | System packaging | vcpkg ✓; add homebrew / conan / deb formulas so "install libleptris" is one command per platform | open |
+| C6 | Cargo publish lane | OIDC-free trusted publishing (crates-io-auth-action@v1) wired into the rust-release workflow; CARGO_REGISTRY_TOKEN secret set once | workflow shipped; secret/token state to verify in Phase 0 |
+
+**Exit:** a consumer on any of the four runtimes installs a prebuilt
+binary with one command; the descriptor ABI crate is consumable from
+Rust with no engine checkout.
+
+---
+
+## Gate D — Adoption & durability: the libxml2 era actually ends
+
+Replacing an era is an ecosystem event, not a benchmark. This gate is
+the proof that downstream can and does move.
+
+| # | Proof | Exit |
+|---|---|---|
+| D1 | Downstream corpus compiles end-to-end on leptris — metanorma/lutaml document sets parse, validate, transform, serialize with libxml2 removed from the path | green corpus runs recorded per release |
+| D2 | Migration surface documented — nokogiri-compat face, per-adapter notes in moxml, a libxml2→libleptris migration guide in `docs/guide/` | guide ships |
+| D3 | Security posture — nightly fuzzing ✓, ASAN CI ✓, ASAN Linux-only leak gate ✓; plus a documented advisory/reporting channel and a CVE-response note | security.md ships |
+| D4 | 1.0 — semver freeze, ABI stability policy (export-surface gate stays green), documented platform matrix (ILP32/arm64/Intel legs, s390x gate) | v1.0.0 tagged through the release workflow, never by hand |
+| D5 | Durability gates in CI — conformance suites and perf chokepoints fail the build on regression, so the mission cannot silently erode | gates wired into test.yml/asan.yml/fuzz-nightly.yml siblings |
+
+**Exit:** D1 green + v1.0.0 shipped. That is the day the era ends.
+
+---
+
+## Phase sequencing
+
+**Phase 0 — Re-baseline (first, everything depends on it).**
+Run every Gate A command and every Gate B harness fresh. Produce one
+numbered table dated today. Nothing in this plan is sequenced against
+a stale number. (The #659 and QT3 figures above are already stale.)
+
+**Phase 1 — Conformance closure (A4–A8).** Largest and longest. Order
+by leverage: A5 (corpus tail — user-visible HTML correctness), A4
+(QT3 pins — the XQuery story), A6 (XSD lane), A7/A8 (DTD/XInclude
+completeness). One PR per fix, red-first spec with every fix,
+suite-wide re-run per landing.
+
+**Phase 2 — Performance closure (B reds).** Parallelizable with
+Phase 1's tail: lane-18 hash prefilter first (named lever, biggest
+gap), zero-copy text next, node-layout/mutation rows behind the
+owner decision.
+
+**Phase 3 — Delivery completion (C2/C3/C5/C6).** Descriptor crate
+publish, moxml gem cut, packaging formulas. Small, mechanical, can
+ride any release train.
+
+**Phase 4 — Durability & adoption (D).** Migration guide, security
+note, CI durability gates, then the 1.0 freeze. 1.0 ships **only
+after** Gates A and B report zero reds — it is the seal, not a date.
+
+## Invariants (the operating system)
+
+These laws produced every number above; the plan executes inside
+them, never around them:
+
+- Falsifiability — red-first specs; a test that passes both sides is
+  not a regression test.
+- Lockstep + TAG-RACE — runtime versions ride engine semver; ride
+  branches push only after the tag lands.
+- Release workflow owns versions and tags; humans never tag by hand.
+- Benchmark discipline — fresh build dirs, explicit build types,
+  medians of interleaved reps, or the number does not exist.
+- One PR per work item; branch → tests → ASAN → benchmark →
+  rebase-merge; verify content on main after every merge.
+- Binding repos release only through their own automated flows.
+
+## The scoreboard of record
+
+One table, updated at every release train: gate, command, last run,
+verdict. When every row of Gate A and Gate B reads "green (dated)"
+and Gate D1 is green, the mission is achieved — and v1.0.0 is the
+tag that says so.

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

@@ -3139,6 +3139,8 @@ static uint8_t h_id_p, h_id_li, h_id_dd, h_id_dt, h_id_ol, h_id_ul,
     h_id_frameset, h_id_button, h_id_applet, h_id_caption,
     h_id_colgroup, h_id_marquee, h_id_object, h_id_html, h_id_rb,
     h_id_rt, h_id_rp, h_id_rtc, h_id_listing, h_id_plaintext;
+static uint8_t h_id_textarea, h_id_title, h_id_xmp, h_id_iframe,
+    h_id_noembed, h_id_noframes;
 static uint8_t h_heading_lut[256], h_ruby_lut[256], h_p_fence_lut[256],
     h_li_fence_lut[256], h_dd_fence_lut[256];
 /* #1218 slice 6: the per-name strcmp chains the sampler pinned at
@@ -3186,6 +3188,12 @@ static void h_id_luts_init(void) {
     h_id_rtc = h_tag_id("rtc");
     h_id_listing = h_tag_id("listing");
     h_id_plaintext = h_tag_id("plaintext");
+    h_id_textarea = h_tag_id("textarea");
+    h_id_title = h_tag_id("title");
+    h_id_xmp = h_tag_id("xmp");
+    h_id_iframe = h_tag_id("iframe");
+    h_id_noembed = h_tag_id("noembed");
+    h_id_noframes = h_tag_id("noframes");
     h_id_head = h_tag_id("head");
     h_id_body = h_tag_id("body");
     h_id_noscript = h_tag_id("noscript");
@@ -5584,6 +5592,22 @@ static void h_diag(HBuilder* b, const char* code, size_t off,
                            code, line, col, "%s", detail);
 }
 
+/* #1771 verdict slice: a non-whitespace character run while the
+ * doctype-less initial insertion mode is still open is the spec's
+ * expected-doctype-but-got-chars (13.2.6.4.1). Judged once per run
+ * here — ahead of the per-path flush/drop decisions, so dropped or
+ * re-parented text still reports. */
+static void h_initial_chars_diag(HBuilder* b, const char* from,
+                                 const char* to) {
+    for (const char* c = from; c < to; c++)
+        if (*c && !h_is_ws(*c)) {
+            h_diag(b, "expected-doctype-but-got-chars",
+                   (size_t)(from - b->input_base),
+                   "characters in the initial insertion mode");
+            return;
+        }
+}
+
 static LeptrisDocument html_parse_shared(
     const char* buf, size_t len, LeptrisStatus* status, int whatwg,
     LeptrisParseFlags flags) {
@@ -5653,6 +5677,12 @@ static LeptrisDocument html_parse_shared(
         if (p + 1 >= end) { p++; continue; }
         char k1 = p[1];
 
+        /* #1771: judge a pending character run against the
+         * doctype-less initial mode before any branch flushes or
+         * drops it (expected-doctype-but-got-chars). */
+        if (b.whatwg && !b.left_initial && !doc->doctype && text < p)
+            h_initial_chars_diag(&b, text, p);
+
         if (k1 == '!') {
             /* Flush pending text first. */
             if (text < p) {
@@ -6033,6 +6063,10 @@ static LeptrisDocument html_parse_shared(
                 continue;
             }
             /* End tag: ends the initial insertion mode too. */
+            if (b.whatwg && !b.left_initial && !doc->doctype)
+                h_diag(&b, "expected-doctype-but-got-end-tag",
+                       (size_t)(p - b.input_base),
+                       "end tag in the initial insertion mode");
             if (b.whatwg && !b.left_initial && text < p) {
                 int ws_only = 1;
                 for (const char* c = text; c < p; c++)
@@ -6559,7 +6593,21 @@ static LeptrisDocument html_parse_shared(
                                            (h_ieq_raw(on, "ul") ||
                                             h_ieq_raw(on, "ol")));
                             }
-                            if (fenced) break;
+                            if (fenced) {
+                                /* #1771: html5lib's walk reports
+                                 * unexpected-end-tag when a special
+                                 * element stops the search before
+                                 * the target is found (endTagOther);
+                                 * the list-scope fences map to its
+                                 * endTagListItem not-in-scope
+                                 * error. */
+                                h_diag(&b, "unexpected-end-tag",
+                                       (size_t)(p - b.input_base),
+                                       "</%s> ignored: a special "
+                                       "element fences the target",
+                                       lname);
+                                break;
+                            }
                         }
                         if (on && tag_match) {
                             /* Scope guard (WHATWG): a foreign
@@ -6816,6 +6864,13 @@ static LeptrisDocument html_parse_shared(
                 if (*c != 0 && !h_is_ws(*c)) { ws_only = 0; break; }
             if (ws_only) text = p;
         }
+        /* #1771: a start tag in the doctype-less initial insertion
+         * mode is expected-doctype-but-got-start-tag (13.2.6.4.1) —
+         * even when the tag itself is a dropped structural one. */
+        if (b.whatwg && !b.left_initial && !doc->doctype)
+            h_diag(&b, "expected-doctype-but-got-start-tag",
+                   (size_t)(p - b.input_base),
+                   "start tag in the initial insertion mode");
         b.left_initial = 1;
         /* 13.2.5.4.4: non-whitespace body text (NUL ignored — an
          * ignored token cannot clear the flag) clears frameset-ok;
@@ -7022,6 +7077,18 @@ static LeptrisDocument html_parse_shared(
             /* frameset is NOT in the 13.2.6.5 breakout list: inside
              * foreign content it is a plain foreign element
              * (plain-text-unsafe:16-23). */
+            /* #1771: html5lib's verdict — a <frameset> token that
+             * reaches the body phase after body content is
+             * unexpected-start-tag whether it then converts or is
+             * ignored (webkit01:51); head-phase converters and
+             * in-template framesets stay clean. body_seen is not
+             * set by the frameset token itself (it is in the
+             * head-only list), so it reads PRIOR content only. */
+            if (b.body_seen && !b.frameset &&
+                h_template_idx(&b) < 0)
+                h_diag(&b, "unexpected-start-tag",
+                       (size_t)(p - b.input_base),
+                       "frameset after body content");
             /* depth<=1: at most the (explicit or synthesized) html
              * element is open; frameset-ok is the spec gate and the
              * body is removed wholesale when it converts. */
@@ -8121,6 +8188,27 @@ static LeptrisDocument html_parse_shared(
                 cq++;
             }
             p = (cq < end) ? cq + 1 : end;
+            /* #1771: the element never closed at EOF — either the
+             * raw scan consumed to EOF without a close tag, or the
+             * close tag itself is unterminated (</script foo= —
+             * tests16:11-60). html5lib's named variant for the
+             * strict containers, the generic one for the RCDATA
+             * pair (mapping mined from the corpus: script/style/
+             * xmp/noframes/noembed/iframe -> named; textarea/
+             * title -> generic; plaintext has no close form and
+             * never reports). Judged here, before the pop. */
+            if (b.whatwg && cq >= end &&
+                strcmp(name, "plaintext") != 0) {
+                int named = strcmp(name, "textarea") != 0 &&
+                            strcmp(name, "title") != 0;
+                h_diag(&b,
+                       named ? "expected-named-closing-tag-but-got-eof"
+                             : "expected-closing-tag-but-got-eof",
+                       (size_t)(end - b.input_base),
+                       "raw-text element <%s> left open at end of "
+                       "input",
+                       name);
+            }
             b.depth--;   /* the raw element is complete */
             text = p;
             continue;
@@ -8201,6 +8289,11 @@ static LeptrisDocument html_parse_shared(
     }
 
     /* Trailing text. */
+    /* #1771: a trailing character run in the doctype-less initial
+     * insertion mode is expected-doctype-but-got-chars too — the
+     * loop-internal judge only runs at markup boundaries. */
+    if (b.whatwg && !b.left_initial && !doc->doctype && text < end)
+        h_initial_chars_diag(&b, text, end);
     if (text < end) {
         LeptrisTextNode* t = h_text_node(&b, text, end);
         if (t) {
@@ -8230,6 +8323,30 @@ done:
     /* Nothing appended (empty input, stray end tags only, doctype
      * only) is NOT an error in lenient HTML mode: the wrapper
      * synthesis below yields the empty Nokogiri shape. */
+    /* #1771: elements still open at EOF are
+     * expected-closing-tag-but-got-eof (html5lib's verdict; the
+     * implied html shell does not count). Judged BEFORE the
+     * wrapper synthesis, which tears the open stack down. Our
+     * stack carries no implied html/body, so the html5lib
+     * top-of-stack rule maps to: any real element open, gated on
+     * </body>/</html> never having been seen — after-body EOF is
+     * clean whatever remains (tests1:34). A raw-text container
+     * got its own variant at the raw branch already (that branch
+     * pops the element, so the top here is whatever wraps it). */
+    if (b.whatwg && b.depth > 0) {
+        uint8_t top = b.open_id[b.depth - 1];
+        if (top != h_id_html && top != h_id_head &&
+            top != h_id_body)
+            h_diag(&b,
+                   (top == h_id_script || top == h_id_style ||
+                    top == h_id_listing || top == h_id_plaintext ||
+                    top == h_id_textarea || top == h_id_title ||
+                    top == h_id_xmp || top == h_id_iframe ||
+                    top == h_id_noembed || top == h_id_noframes)
+                       ? "expected-named-closing-tag-but-got-eof"
+                       : "expected-closing-tag-but-got-eof",
+                   b.input_len, "elements left open at end of input");
+    }
     /* Nokogiri document shape (#659): with no explicit <html>,
      * synthesize <html><head></head><body>content</body></html> —
      * the document model is single-rooted, and libxml2's
@@ -8361,6 +8478,12 @@ done:
                               b.body_attr_n);
         }
     }
+    /* #1771: EOF in the doctype-less initial insertion mode is
+     * expected-doctype-but-got-eof (13.2.6.4.1) — empty and
+     * whitespace-only documents included. */
+    if (b.whatwg && !b.left_initial && !doc->doctype)
+        h_diag(&b, "expected-doctype-but-got-eof", b.input_len,
+               "document ended without a DOCTYPE");
     doc->new_dom_root = b.root;
     leptris_root_doc_register(b.root, doc);
     if (b.prolog_head) {

data/vendor-src/libleptris/test/html/test_html5lib.cpp

@@ -21,6 +21,8 @@
 #include <gtest/gtest.h>
 extern "C" {
 #include "leptris.h"
+#include "leptris/html.h"
+#include "leptris/error.h"
 /* Internal (non-exported) accessor needed for the ns comparison;
  * the public surface exposes attribute/namespace-node URIs only. */
 const char* leptris_element_get_namespace_uri(LeptrisElement elem);
@@ -50,6 +52,10 @@ struct XCase {
     bool skip = false;     /* fragment pairs / script-on */
     std::string skip_why;
     XNode doc;             /* synthesized document level */
+    /* the #errors section, verbatim "(line,col): code" entries —
+     * the html5lib suite's own parse-error verdict (leptris#1771
+     * verdict-parity gate) */
+    std::vector<std::string> errors;
     XCase() { doc.kind = XNode::DOC; }
 };
 
@@ -327,7 +333,11 @@ std::vector<XCase> ScanFile(const std::string& path, const std::string& fname,
                 } else if (l.compare(0, 7, "#errors") == 0) {
                     i++;
                     while (i < lines.size() &&
-                           !(lines[i].size() && lines[i][0] == '#')) i++;
+                           !(lines[i].size() && lines[i][0] == '#')) {
+                        if (!lines[i].empty())
+                            c.errors.push_back(lines[i]);
+                        i++;
+                    }
                 } else if (l.compare(0, 18, "#document-fragment") == 0) {
                     c.skip = true;
                     c.skip_why = "fragment mode";
@@ -829,3 +839,147 @@ TEST(Html5LibCorpus, TreeConstruction) {
         EXPECT_GE(ppassed, (size_t)784);
     }
 }
+
+/* ---- #1771 VERDICT PARITY (leptris#1771) ----
+ *
+ * The tree gate proves WHAT we build; this gate proves we JUDGE the
+ * same inputs the same way. The corpus's #errors section is
+ * html5lib's own parse-error verdict for every case; ours is the
+ * §13.2.5 token stream recorded through
+ * LEPTRIS_PARSE_COLLECT_HTML_ERRORS (leptris_parse_html_string_flags).
+ * The gate is VERDICT parity — did we error where they errored —
+ * per case; the code sets are compared too and dumped to the
+ * red-list for the tail. Positions are not compared (offset
+ * conventions differ legitimately). */
+TEST(Html5LibCorpus, ErrorVerdictParity) {
+    const char* srcdir = getenv("HTML5LIB_SRC");
+    std::string dir = srcdir && *srcdir
+        ? srcdir
+        : LEPTRIS_HTML5LIB_DIR;
+    std::vector<std::string> files(kHtml5libDatFiles,
+                                   kHtml5libDatFiles +
+                                       sizeof(kHtml5libDatFiles) /
+                                           sizeof(kHtml5libDatFiles[0]));
+    size_t total = 0, parity = 0, skipped = 0, vfail = 0;
+    size_t code_both = 0, code_overlap = 0, code_equal = 0;
+    std::vector<std::string> failures;
+    std::string err;
+    for (const std::string& fn : files) {
+        std::vector<XCase> cs = ScanFile(dir + "/" + fn, fn, &err, 0, 1);
+        if (!err.empty() && cs.empty()) {
+            ADD_FAILURE() << fn << ": " << err;
+            continue;
+        }
+        for (auto& c : cs) {
+            total++;
+            if (c.skip) { skipped++; continue; }
+            LeptrisStatus st = LEPTRIS_OK;
+            LeptrisDocument d = leptris_parse_html_string_flags(
+                c.data.c_str(), c.data.size(),
+                LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
+            if (!d) {
+                vfail++;
+                failures.push_back(c.id + ": parse failed");
+                continue;
+            }
+            size_t n = leptris_document_parse_diag_count(d);
+            bool ours_err = n > 0;
+            bool want_err = !c.errors.empty();
+            std::string ours_codes, want_codes;
+            size_t shown = 0;
+            for (size_t i = 0; i < n && shown < 6; i++) {
+                char code[64] = {0};
+                if (leptris_document_parse_diag_code(d, i, code,
+                                                     sizeof(code),
+                                                     nullptr, nullptr) &&
+                    code[0]) {
+                    if (shown++) ours_codes += ",";
+                    ours_codes += code;
+                }
+            }
+            for (size_t i = 0; i < c.errors.size(); i++) {
+                const std::string& e = c.errors[i];
+                /* corpus formats: "(l,c): code", "(l,c) code",
+                 * "(l:c) code" — strip the "(...)" position. */
+                std::string code = e;
+                if (e.size() > 1 && e[0] == '(') {
+                    size_t close = e.find(')');
+                    if (close != std::string::npos) {
+                        size_t cs = close + 1;
+                        while (cs < e.size() &&
+                               (e[cs] == ':' || e[cs] == ' '))
+                            cs++;
+                        code = e.substr(cs);
+                    }
+                }
+                if (!want_codes.empty()) want_codes += ",";
+                want_codes += code;
+            }
+            leptris_document_free(d);
+
+            if (ours_err == want_err) {
+                parity++;
+                if (ours_err) {
+                    /* secondary: code-set comparison (reported,
+                     * not gated — the verdict is the flip) */
+                    code_both++;
+                    bool overlap = false, equal = false;
+                    /* both sides are small comma lists; exact-set
+                     * comparison on the shown prefixes */
+                    equal = ours_codes == want_codes;
+                    for (size_t a = 0, b = a; !overlap &&
+                             a < ours_codes.size(); ) {
+                        size_t ca = ours_codes.find(',', a);
+                        std::string oc = ours_codes.substr(
+                            a, ca == std::string::npos
+                                   ? std::string::npos : ca - a);
+                        for (b = 0; b < want_codes.size(); ) {
+                            size_t cb = want_codes.find(',', b);
+                            std::string wc = want_codes.substr(
+                                b, cb == std::string::npos
+                                       ? std::string::npos : cb - b);
+                            if (oc == wc) { overlap = true; break; }
+                            if (cb == std::string::npos) break;
+                            b = cb + 1;
+                        }
+                        if (ca == std::string::npos) break;
+                        a = ca + 1;
+                    }
+                    if (overlap) code_overlap++;
+                    if (equal) code_equal++;
+                    if (!overlap)
+                        failures.push_back(c.id + ": code-set divergence want["
+                                           + want_codes + "] ours["
+                                           + ours_codes + "]");
+                }
+            } else {
+                vfail++;
+                failures.push_back(
+                    c.id + ": verdict mismatch want"
+                    + (want_err ? "=errors[" + want_codes + "]"
+                                : "=clean")
+                    + " ours"
+                    + (ours_err ? "=errors[" + ours_codes + "]"
+                                : "=clean"));
+            }
+        }
+    }
+    FILE* rl = fopen("html5lib-verdict-redlist.txt", "w");
+    if (rl) {
+        for (auto& f : failures) fprintf(rl, "%s\n", f.c_str());
+        fclose(rl);
+    }
+    printf("[verdict-parity] total=%zu parity=%zu verdict-fail=%zu "
+           "skip=%zu | both-error=%zu code-overlap=%zu code-equal=%zu "
+           "(red-list: html5lib-verdict-redlist.txt)\n",
+           total, parity, vfail, skipped,
+           code_both, code_overlap, code_equal);
+    for (size_t i = 0; i < failures.size() && i < 20; i++)
+        printf("  VERDICT %s\n", failures[i].c_str());
+    EXPECT_GT(total, (size_t)1500);
+    /* Verdict-parity floor — set at the slice-2 baseline
+     * (1394/1555; was 190 before the #1771 emission slices —
+     * the doctype-less initial-mode family, trailing chars, EOF with
+     * open elements; slice 3 adds the raw-text EOF variants). Only raises. */
+    EXPECT_GE(parity, (size_t)1394);
+}

data/vendor-src/libleptris/test/html/test_html_parse_errors.cpp

@@ -70,10 +70,16 @@ TEST(HtmlParseErrors, EofInTagCarriesSpecCode) {
         xml, strlen(xml), LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
     ASSERT_NE(d, nullptr);
     auto diags = drain(d);
-    ASSERT_GE(diags.size(), 1u);
-    EXPECT_EQ(diags[0].code, "eof-in-tag");
+    /* The doctype-less initial mode fires first (the <a> token),
+     * then the unterminated tag at EOF — html5lib's verdict for
+     * this input is both codes, in token order. */
+    ASSERT_GE(diags.size(), 2u);
+    EXPECT_EQ(diags[0].code, "expected-doctype-but-got-start-tag");
     EXPECT_EQ(diags[0].line, 1);
-    EXPECT_EQ(diags[0].col, 8);
+    EXPECT_EQ(diags[0].col, 1);
+    EXPECT_EQ(diags[1].code, "eof-in-tag");
+    EXPECT_EQ(diags[1].line, 1);
+    EXPECT_EQ(diags[1].col, 8);
     leptris_document_free(d);
 }
 
@@ -84,8 +90,11 @@ TEST(HtmlParseErrors, DoctypeOutsideInitialIgnored) {
         xml, strlen(xml), LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
     ASSERT_NE(d, nullptr);
     auto diags = drain(d);
-    ASSERT_GE(diags.size(), 1u);
-    EXPECT_EQ(diags[0].code, "unexpected-doctype");
+    /* The <div> opens the doctype-less initial mode; the DOCTYPE
+     * token inside the body is unexpected-doctype (13.2.6.4.73). */
+    ASSERT_GE(diags.size(), 2u);
+    EXPECT_EQ(diags[0].code, "expected-doctype-but-got-start-tag");
+    EXPECT_EQ(diags[1].code, "unexpected-doctype");
     leptris_document_free(d);
 }
 
@@ -96,7 +105,15 @@ TEST(HtmlParseErrors, LineColumnTrackRealLines) {
         xml, strlen(xml), LEPTRIS_PARSE_COLLECT_HTML_ERRORS, &st);
     ASSERT_NE(d, nullptr);
     auto diags = drain(d);
-    ASSERT_GE(diags.size(), 1u);
-    EXPECT_EQ(diags[0].line, 3);
+    ASSERT_GE(diags.size(), 2u);
+    EXPECT_EQ(diags[0].code, "expected-doctype-but-got-start-tag");
+    EXPECT_EQ(diags[0].line, 1);
+    bool dup_found = false;
+    for (auto& dd : diags)
+        if (dd.code == "duplicate-attribute") {
+            dup_found = true;
+            EXPECT_EQ(dd.line, 3);
+        }
+    EXPECT_TRUE(dup_found);
     leptris_document_free(d);
 }

data/vendor-src/libleptris/test/xpath/test_xpath.cpp

@@ -22,6 +22,53 @@ LeptrisDocument ParseWith(const char* xml) {
     return doc;
 }
 
+/* leptris-ruby#502 parity pin: a document-context relative path
+ * selects the DOCUMENT's children (XPath 1.0 §2) — libxml2/Nokogiri
+ * measured identical: doc.xpath("bibdata/status/stage") with root
+ * <metanorma> returns [] (bibdata is a child of the ROOT ELEMENT,
+ * one level down); doc.root.xpath(...) finds it. The classic
+ * "root-relative" behavior was the OLD moxml adapter's substitution,
+ * not Nokogiri semantics. */
+TEST(XPathDocContext, RelativePathFromDocumentContext) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xml = "<metanorma><bibdata><status>"
+                      "<stage>published</stage></status></bibdata>"
+                      "</metanorma>";
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+    ASSERT_NE(d, nullptr);
+
+    /* Nokogiri parity: a relative step naming a NON-child of the
+     * document returns empty */
+    LeptrisXPathResult r =
+        leptris_xpath_eval(d, NULL, "bibdata/status/stage");
+    ASSERT_NE(r, nullptr);
+    EXPECT_EQ(leptris_xpath_result_count(r), 0u);
+    leptris_xpath_result_free(r);
+
+    /* the root ELEMENT is a child of the document */
+    LeptrisXPathResult rn =
+        leptris_xpath_eval(d, NULL, "metanorma/bibdata/status/stage");
+    ASSERT_NE(rn, nullptr);
+    ASSERT_EQ(leptris_xpath_result_count(rn), 1u);
+    LeptrisElement e = leptris_xpath_result_get(rn, 0);
+    ASSERT_NE(e, nullptr);
+    EXPECT_STREQ(leptris_element_name(e), "stage");
+    EXPECT_STREQ(leptris_element_text(e), "published");
+    leptris_xpath_result_free(rn);
+
+    /* absolute shapes unchanged */
+    LeptrisXPathResult a = leptris_xpath_eval(d, NULL, "/bibdata");
+    ASSERT_NE(a, nullptr);
+    EXPECT_EQ(leptris_xpath_result_count(a), 0u);
+    leptris_xpath_result_free(a);
+    LeptrisXPathResult am =
+        leptris_xpath_eval(d, NULL, "/metanorma/bibdata/status/stage");
+    ASSERT_NE(am, nullptr);
+    EXPECT_EQ(leptris_xpath_result_count(am), 1u);
+    leptris_xpath_result_free(am);
+    leptris_document_free(d);
+}
+
 TEST(XPathAxes, DescendantOrSelfFindsAll) {
     LeptrisDocument doc = ParseWith(kBasic);
     ASSERT_NE(doc, nullptr);

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.371",
+  "version": "1.9.373",
   "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.371.0
+  version: 1.9.373.0
 platform: ppc64le-linux
 authors:
 - Ribose Inc.
@@ -530,6 +530,7 @@ files:
 - vendor-src/libleptris/docs/ARCHITECTURE_REVIEW.md
 - vendor-src/libleptris/docs/Doxyfile
 - vendor-src/libleptris/docs/FFI.md
+- vendor-src/libleptris/docs/MISSION-PLAN.md
 - vendor-src/libleptris/docs/README.md
 - vendor-src/libleptris/docs/ROADMAP-SAXON-PARITY.md
 - vendor-src/libleptris/docs/guide/building.md