leptris 1.9.204.0 → 1.9.207.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0facebf2d44046c5a2c7ddaca5fdc8d2b5aea2b92017f6f1de8844122ec0eda4
-  data.tar.gz: f0f09d7786bd551d6f7077e1112e499ad25d6236a379d10607f59aeb2ddef02e
+  metadata.gz: b10f689b2142684316157264cfd935433d6d0d22db8cf90b4a27e9c4ba79bd88
+  data.tar.gz: f3e625c375d995087bec8cd6c058a7a9c900791125f1422f6da8b2436e90047b
 SHA512:
-  metadata.gz: cbb0f3100ba9c705da214daafe066dcdbd973e41abb08d04e4b6db69a18091976b0083e223c9e888829fc46e5b6c4fe49ddf7d3defa380e62631fdc2d3897f7b
-  data.tar.gz: e11a0141773522b79b5ddc5217aa706b1ef01517e8981924842e0f1b7d272499601b3723d6df23c2741dea1e5e5733818a8b743a67af19b63be0f4ce9a554c10
+  metadata.gz: ddf28875bb34e2eb14074c51834614f5cb5acddf0a33c58f55a50d9e6970a065eb70cb6f3da51c1114cad3a8c062a6dec98d6ce271ff27a81a77033f92e774ea
+  data.tar.gz: b1c7bc0629b2840a7a23d71bd27b08303426ab7b013d8a272d9a1fedc82b8f40ba8fdd6805724f878fbf4374752912658ea5922e79548f16a53a859cf4de3164

data/CHANGELOG.md

@@ -54,25 +54,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Not fixed despite upstream closes
 
 - **Iterparse attribute reads: all-nil runs on ubuntu-latest Ruby
-  3.4 CI legs** — filed upstream as leptris/leptris#1242
-  (leptris-ruby#279 tracks the investigation). Six strikes; the
-  last three were consecutive reruns of one job, suggesting
-  per-machine determinism. Unreproducible across ~75k local reads
-  on darwin/arm64 (native + FFI, GC.stress) and x86_64 linux
-  (qemu; native + FFI; threaded and not). The leg sets
-  `LEPTRIS_SKIP_1242=1` to quarantine exactly that one spec on
-  that one leg until the engine ships the fix; every other leg
-  keeps the full guard.
-
-- **#1220 reopened with the 1.9.203 repro**: HTML-document
-  mutations are still lost on serialization (the exact original
-  repro stands; node reads back mutated, serializer sees the old
-  tree). Tracking continues upstream.
-- **#1197 reopened with fresh 1.9.203 evidence**: the s390x qemu
-  leg failed 442/742 with the identical `malformed input`
-  signature at ASCII offsets; the reopen quotes the close
-  comment's own terms. (1.9.204's notes carry no BE fix; the leg
-  stays experimental until the engine ships one.)
+## [1.9.207.0] - 2026-09-19
+
+### Fixed — engine sync: big-endian close-tag parse (#1197 upstream)
+
+- Vendored libleptris 1.9.207: the close-tag fast-path compare
+  masked the wrong end of its 8-byte name load on big-endian hosts,
+  rejecting ordinary paired-tag documents with "malformed input"
+  (434/727 binding-suite failures under qemu s390x). The mask now
+  follows memory order per byte dialect; the s390x-linux-musl
+  platform gem becomes viable with this release.
+
+### Added — FFI mirror adopts the 1.9.202–1.9.207 engine surface
+
+- audit:symbols lockstep attachments: recover diagnostics
+  (leptris_document_parse_diag[_count]), the standalone DTD family
+  (leptris_dtd_*), declaration/doctype removal, engine-heap buffer
+  allocation, and one-shot SAX. leptris_set_error stays internal —
+  the engine now hides it on ELF too (leptris#1243), so the export
+  surface agrees across Linux/macOS/Windows.
 
 ## [1.9.201.3] - 2026-09-19
 

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.204"
+LIBLEPTRIS_VERSION = "1.9.207"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

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

data/lib/leptris/xml/ffi.rb

@@ -137,6 +137,7 @@ module Leptris
       typedef :pointer, :leptris_iterparse
       typedef :pointer, :leptris_xpath_var_set
       typedef :pointer, :leptris_sax_parser
+      typedef :pointer, :leptris_dtd
       typedef :int, :leptris_status
 
       class SAXHandler < ::FFI::Struct
@@ -1156,6 +1157,33 @@ attach_function :leptris_parse_string,
         [:leptris_document, :pointer, :pointer], :leptris_status
       attach_function :leptris_status_string, [:leptris_status], :string
       attach_function :leptris_error_message, [:leptris_status], :string
+      # Engine surface adopted with libleptris 1.9.206 (the FFI
+      # mirror audit keeps attachments and exports in lockstep):
+      # recover diagnostics (#1200), the standalone DTD family
+      # (leptris_dtd_*), declaration/doctype removal (#1094), the
+      # engine-heap buffer (#1219), one-shot SAX (#1178), and the
+      # exported error-recorder entry point.
+      attach_function :leptris_alloc_buffer, [:size_t], :pointer
+      attach_function :leptris_document_clear_declaration,
+        [:leptris_document], :leptris_status
+      attach_function :leptris_document_remove_doctype,
+        [:leptris_document], :leptris_status
+      attach_function :leptris_document_parse_diag_count,
+        [:leptris_document], :size_t
+      attach_function :leptris_document_parse_diag,
+        [:leptris_document, :size_t, :pointer, :pointer, :size_t], :int
+      attach_function :leptris_dtd_parse,
+        [:string, :size_t], :leptris_dtd
+      attach_function :leptris_dtd_free, [:leptris_dtd], :void
+      attach_function :leptris_dtd_parse_external_subset,
+        [:leptris_dtd, :string, :size_t], :int
+      attach_function :leptris_dtd_set_pe_loader,
+        [:leptris_dtd, :pointer, :pointer], :void
+      attach_function :leptris_dtd_validate,
+        [:leptris_document, :leptris_dtd, :pointer], :int
+      attach_function :leptris_dtd_error_free, [:pointer], :void
+      attach_function :leptris_sax_parser_set_one_shot,
+        [:leptris_sax_parser, :int], :void
       # Thread-global last-failure position (error.h): companion to
       # leptris_last_error; populated by recover parses (#547).
       attach_function :leptris_last_error_position,

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,56 @@
 ## [Unreleased]
 
+## [1.9.207] - 2026-09-19
+
+### Fixed
+
+- stop leptris_set_error leaking into the ELF dynamic table (build)
+
+
+
+## [1.9.206] - 2026-09-19
+
+### Fixed
+
+- endian-neutral close-tag name compare (#1197) (parse)
+
+### Performance
+
+- memchr finds the text span end (TODO.max-perf/2-3 slice 3) (sax)
+- zero-copy slice emission for one-shot pulls (#1178 tail) (sax)
+
+
+
+## [1.9.205] - 2026-09-19
+
+### Added
+
+- Parse recover diagnostics (#1200): the DOM parse now records
+  duplicate-attribute events on the document — `LeptrisDiagKind`
+  (with the new `LEPTRIS_DIAG_RECOVER` kind) is public in
+  types.h, and the diag list reads through
+  `leptris_document_parse_diag_count` /
+  `leptris_document_parse_diag` (error.h). First definition wins,
+  matching the SAX lane's libxml2-recover surface; the digest
+  gate no longer needs a SAX probe pass.
+- `LEPTRIS_DIGEST_ATTR_ORDER` (#1200 part 1): opt-in digest flag
+  that makes attribute order identity-bearing instead of sorted
+  away.
+
+### Fixed
+
+- MSVC C2027 in `leptris_internal.h`: the `LeptrisDiag` forward
+  declaration moved to file scope (broke the windows-dll-exports
+  leg).
+
+### Performance
+
+- First-char-bucketed tag classifier for the WHATWG HTML path:
+  the tokenizer's name-list strcmp scans become one-load bucket
+  lookups — parse +31-37% on the #1218 bench shapes.
+
+
+
 ## [1.9.204] - 2026-09-19
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/src/include/leptris/error.h

@@ -96,6 +96,62 @@ LEPTRIS_API void leptris_last_error_position(int* line, int* column);
  */
 LEPTRIS_API const char* leptris_document_last_error(LeptrisDocument doc);
 
+/* ============================================================================
+ * Parse diagnostics (#1200): recover-class events recorded on the
+ * DOM parse (duplicate attributes today) — the SAX lane's recover
+ * error list, unified engine-side so both lanes report the same
+ * surface. Documents stay usable; the diagnostics are advisory.
+ * ============================================================================ */
+
+#ifndef LEPTRIS_API
+#  ifdef _WIN32
+#    ifdef LEPTRIS_BUILD_SHARED
+#      define LEPTRIS_API __declspec(dllexport)
+#    elif defined(LEPTRIS_BUILDING_DLL)
+#      define LEPTRIS_API __declspec(dllexport)
+#    elif defined(LEPTRIS_USE_SHARED)
+#      define LEPTRIS_API __declspec(dllimport)
+#    else
+#      define LEPTRIS_API
+#    endif
+#  else
+#    if defined(__GNUC__) && !defined(__clang__)
+#      define LEPTRIS_API __attribute__((visibility("default"), used, \
+                                            externally_visible))
+#    else
+#      define LEPTRIS_API __attribute__((visibility("default"), used))
+#    endif
+#  endif
+#endif
+
+/**
+ * Number of recover-class diagnostics recorded during the
+ * document's parse.
+ *
+ * @param doc Document handle
+ * @return Diagnostic count (0 for NULL doc or a clean parse)
+ */
+LEPTRIS_API size_t leptris_document_parse_diag_count(LeptrisDocument doc);
+
+/**
+ * Read one parse diagnostic by index.
+ *
+ * @param doc Document handle
+ * @param index Diagnostic index (< leptris_document_parse_diag_count)
+ * @param kind Out: diagnostic kind (may be NULL)
+ * @param message Out: NUL-terminated message buffer (may be NULL)
+ * @param message_cap Capacity of message (ignored when message NULL)
+ * @return 1 on success; 0 for NULL doc or out-of-range index
+ *
+ * Memory: Message is copied into the caller's buffer; diagnostics
+ *         are owned by the document until leptris_document_free.
+ */
+LEPTRIS_API int leptris_document_parse_diag(LeptrisDocument doc,
+                                            size_t index,
+                                            LeptrisDiagKind* kind,
+                                            char* message,
+                                            size_t message_cap);
+
 #ifdef __cplusplus
 }
 #endif

data/vendor-src/libleptris/src/include/leptris/types.h

@@ -246,6 +246,28 @@ typedef enum {
     LEPTRIS_DIFF_IGNORE_WS_TEXT = 1u
 } LeptrisDiffFlags;
 
+/* Unified narration record kinds (#1126). One structured record
+ * per validation/recover event, shared by every validator (RNG
+ * today; XSD/Schematron follow) and the DOM parse's recover
+ * channel (#1200). The kind selects the reporting convention;
+ * append-only. */
+typedef enum {
+    LEPTRIS_DIAG_INVALID = 0,
+    LEPTRIS_DIAG_NOT_ALLOWED_ANYWHERE,   /* name never valid in model */
+    LEPTRIS_DIAG_NOT_ALLOWED_HERE,       /* valid name, wrong position */
+    LEPTRIS_DIAG_NOT_ALLOWED_YET,        /* later; missing required first */
+    LEPTRIS_DIAG_INCOMPLETE,             /* content ends before required */
+    LEPTRIS_DIAG_MISSING_REQUIRED_ATTR,
+    LEPTRIS_DIAG_ATTR_NOT_ALLOWED,
+    LEPTRIS_DIAG_ATTR_VALUE_INVALID,
+    LEPTRIS_DIAG_CHAR_CONTENT_INVALID,   /* data/value/list mismatch */
+    /* Recover-class parse event: the document is usable, the input
+     * was not conformant (duplicate attribute, ...). Not a model
+     * error; SAX-lane "recover" parity (#1200). */
+    LEPTRIS_DIAG_RECOVER,
+    LEPTRIS_DIAG_COUNT_
+} LeptrisDiagKind;
+
 /* Subtree digest flags (issue #869). The digest is content-defined
  * (no pointers/addresses — stable across processes); equality
  * implies subtree equivalence under the flag semantics. */
@@ -253,7 +275,13 @@ typedef enum {
     LEPTRIS_DIGEST_DEFAULT     = 0,
     /* Skip whitespace-only text nodes entirely (comparator's
      * strip-profile default). */
-    LEPTRIS_DIGEST_DROP_WS_TEXT = 1u
+    LEPTRIS_DIGEST_DROP_WS_TEXT = 1u,
+    /* Hash attributes in DOCUMENT order instead of the sorted
+     * canonical order — documents differing only in attribute
+     * order digest DIFFERENT under this flag (canon's verbose
+     * diff gate, #1200). Equality under this flag additionally
+     * implies attribute-order identity. */
+    LEPTRIS_DIGEST_ATTR_ORDER  = 2u
 } LeptrisDigestFlags;
 
 typedef struct {

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

@@ -17,20 +17,9 @@
 extern "C" {
 #endif
 
-typedef enum {
-    LEPTRIS_DIAG_INVALID = 0,
-    LEPTRIS_DIAG_NOT_ALLOWED_ANYWHERE,   /* name never valid in model */
-    LEPTRIS_DIAG_NOT_ALLOWED_HERE,       /* valid name, wrong position */
-    LEPTRIS_DIAG_NOT_ALLOWED_YET,        /* later; missing required first */
-    LEPTRIS_DIAG_INCOMPLETE,             /* content ends before required */
-    LEPTRIS_DIAG_MISSING_REQUIRED_ATTR,
-    LEPTRIS_DIAG_ATTR_NOT_ALLOWED,
-    LEPTRIS_DIAG_ATTR_VALUE_INVALID,
-    LEPTRIS_DIAG_CHAR_CONTENT_INVALID,   /* data/value/list mismatch */
-    LEPTRIS_DIAG_COUNT_
-} LeptrisDiagKind;
+/* LeptrisDiagKind lives in leptris/types.h (public, #1200). */
 
-typedef struct {
+typedef struct LeptrisDiag {
     LeptrisDiagKind kind;
     char* offender_name;          /* captured at emit time (strdup'd);
                                    * NULL when the diag has no offender.

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

@@ -181,7 +181,11 @@ static uint64_t digest_element(LeptrisElement e, LeptrisDigestFlags flags) {
                 attrs[n].value_len = leptris_attr_value_sv(a).length;
                 n++;
             }
-            qsort(attrs, n, sizeof(DigestAttr), digest_attr_cmp);
+            /* ATTR_ORDER (#1200): document order is canonical — the
+             * walk above already collected in document order, so
+             * skip the sort and attribute order feeds the hash. */
+            if (!(flags & LEPTRIS_DIGEST_ATTR_ORDER))
+                qsort(attrs, n, sizeof(DigestAttr), digest_attr_cmp);
         }
         h = digest_mix_u64(h, n);
         for (size_t i = 0; i < n; i++) {

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

@@ -7,6 +7,7 @@
 #include "common/port.h"  /* LEPTRIS_THREAD_LOCAL (TODO.concurrency/01) */
 #include <stdio.h>
 #include <string.h>
+#include "dom/diag.h"   /* LeptrisDiag layout (#1200) */
 
 /* Error state — THREAD-LOCAL since TODO.concurrency/01: concurrent
  * parses (one document per thread) no longer race the channel. The
@@ -131,4 +132,25 @@ LEPTRIS_API const char* leptris_status_string(LeptrisStatus status) {
         case LEPTRIS_ERROR_IO:        return "I/O error";
         default:                     return "Unknown error";
     }
+}
+
+/* ---- #1200: recover-class parse diagnostics ------------------- */
+
+LEPTRIS_API size_t leptris_document_parse_diag_count(LeptrisDocument doc) {
+    return doc ? (size_t)doc->parse_diag_count : 0;
+}
+
+LEPTRIS_API int leptris_document_parse_diag(LeptrisDocument doc,
+                                            size_t index,
+                                            LeptrisDiagKind* kind,
+                                            char* message,
+                                            size_t message_cap) {
+    if (!doc || index >= (size_t)doc->parse_diag_count) return 0;
+    struct LeptrisDiag* d = (struct LeptrisDiag*)doc->parse_diags + index;
+    if (kind) *kind = d->kind;
+    if (message && message_cap) {
+        strncpy(message, d->message, message_cap - 1);
+        message[message_cap - 1] = '\0';
+    }
+    return 1;
 }

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

@@ -437,7 +437,47 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
      * Careful: first_attribute_off == 0 means empty list. We can't decode
      * the pointer and check for NULL — at offset 0 the decoded pointer
      * is `elem` itself, which is non-NULL. Check the offset field. */
+    /* #1200: duplicate-attribute detection. Prefilter on (len,
+     * first byte) — a mismatching pair costs two loads; the memcmp
+     * only runs on genuine candidates. First definition wins
+     * (libxml2 recover semantics, and the digest's first-wins
+     * becomes official); the duplicate never enters the chain, it
+     * costs its already-carved slot. */
     if (elem->first_attribute_off != 0) {
+        int dup = 0;
+        for (struct leptris_attribute* a =
+                 (struct leptris_attribute*)((char*)elem +
+                                             elem->first_attribute_off);
+             a; a = leptris_attr_next(a)) {
+            if (a->name_view.length == attr->name_view.length &&
+                a->name_view.data[0] == attr->name_view.data[0] &&
+                memcmp(a->name_view.data, attr->name_view.data,
+                       attr->name_view.length) == 0) {
+                dup = 1;
+                break;
+            }
+        }
+        if (dup) {
+            if (p->doc) {
+                extern struct LeptrisDiag* leptris_diag_emit(
+                    struct LeptrisDiag**, int*, int*,
+                    LeptrisDiagKind, LeptrisNodeRef,
+                    const char*, ...);
+                char qname[130];
+                size_t ql = attr->name_view.length < 129
+                                ? attr->name_view.length : 129;
+                memcpy(qname, attr->name_view.data, ql);
+                qname[ql] = '\0';
+                leptris_diag_emit(&p->doc->parse_diags,
+                                  &p->doc->parse_diag_count,
+                                  &p->doc->parse_diag_cap,
+                                  LEPTRIS_DIAG_RECOVER, NULL,
+                                  "Attribute %s redefined", qname);
+            }
+            /* 1 = duplicate skipped (keep first): the caller skips
+             * the raw-attr registration so BOTH surfaces agree. */
+            return 1;
+        }
         /* Cache should always be valid mid-parse. Fall back to walk
          * only if cache is NULL (defensive — shouldn't happen). */
         struct leptris_attribute* tail = p->current_elem_last_attr;
@@ -845,13 +885,16 @@ static int dp_parse_attrs(DParser* p, LeptrisElement elem) {
             continue;
         }
 
-        /* Regular attribute — zero-copy name/value, bulk-allocated struct. */
-        if (dp_add_attr_inline(p, elem, name_start, name_len,
-                                val_start, val_len, has_amp, has_ws,
-                                attr_colon) != 0)
+        /* Regular attribute — zero-copy name/value, bulk-allocated
+         * struct. 1 = duplicate skipped: neither surface sees it. */
+        int arc = dp_add_attr_inline(p, elem, name_start, name_len,
+                                     val_start, val_len, has_amp,
+                                     has_ws, attr_colon);
+        if (arc < 0) return -1;
+        if (arc == 0 &&
+            dp_raw_attr(p, elem, name_start, name_len,
+                        val_start, val_len) != 0)
             return -1;
-        if (dp_raw_attr(p, elem, name_start, name_len,
-                        val_start, val_len) != 0) return -1;
     }
     /* for (;;): every exit is a return inside the loop (0 = tag
      * closed, 1 = self-closing, -1 = error) — there is no
@@ -1571,9 +1614,21 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
             if (close_local_len <= 8 &&
                 (p.probe_slack ||
                  close_local + 8 <= p.end + 1)) {
+                /* The mask follows MEMORY order: memcpy fills the low
+                 * bytes on little-endian and the high bytes on
+                 * big-endian, so each dialect must mask the end its
+                 * load populated. The unconditional low-bytes mask
+                 * compared bytes past the name on big-endian and
+                 * failed every close tag (#1197). */
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+                uint64_t mask = (close_local_len == 8)
+                    ? ~(uint64_t)0
+                    : (~(uint64_t)0 << (64 - close_local_len * 8));
+#else
                 uint64_t mask = (close_local_len == 8)
                     ? ~(uint64_t)0
                     : ((1ull << (close_local_len * 8)) - 1);
+#endif
                 uint64_t a, b;
                 memcpy(&a, open_name, 8);
                 memcpy(&b, close_local, 8);

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

@@ -3061,30 +3061,130 @@ static int h_is_formatting(const char* n) {
 
 /* WHATWG "special" category (13.2.4.2) — the adoption agency's
  * furthest-block candidates. */
+/* Generated tag classifier (#1218 hot path): one first-char
+ * bucket walk replaces the ~78-entry strcmp scans that the
+ * sampler pinned at ~21% of WHATWG parse (h_is_special_ww +
+ * h_reconstructs). Keep in sync with the WHATWG special and
+ * no-formatting sets. */
+typedef struct {
+    char name[12];
+    uint8_t len;
+    uint8_t special;   /* WHATWG 13.2.4 special set */
+    uint8_t no_fmt;    /* never reconstructed (formatting) */
+} HTagInfo;
+
+static const HTagInfo h_tag_infos[] = {
+    {"address", 7, 1, 1},
+    {"applet", 6, 1, 0},
+    {"area", 4, 1, 0},
+    {"article", 7, 1, 1},
+    {"aside", 5, 1, 1},
+    {"base", 4, 1, 1},
+    {"basefont", 8, 1, 1},
+    {"bgsound", 7, 1, 1},
+    {"blockquote", 10, 1, 1},
+    {"body", 4, 1, 1},
+    {"br", 2, 1, 0},
+    {"button", 6, 1, 0},
+    {"caption", 7, 1, 1},
+    {"center", 6, 1, 1},
+    {"col", 3, 1, 1},
+    {"colgroup", 8, 1, 1},
+    {"dd", 2, 1, 1},
+    {"details", 7, 1, 1},
+    {"dialog", 6, 1, 1},
+    {"dir", 3, 1, 1},
+    {"div", 3, 1, 1},
+    {"dl", 2, 1, 1},
+    {"dt", 2, 1, 1},
+    {"embed", 5, 1, 0},
+    {"fieldset", 8, 1, 1},
+    {"figcaption", 10, 1, 1},
+    {"figure", 6, 1, 1},
+    {"footer", 6, 1, 1},
+    {"form", 4, 1, 1},
+    {"frame", 5, 1, 1},
+    {"frameset", 8, 1, 1},
+    {"h1", 2, 1, 1},
+    {"h2", 2, 1, 1},
+    {"h3", 2, 1, 1},
+    {"h4", 2, 1, 1},
+    {"h5", 2, 1, 1},
+    {"h6", 2, 1, 1},
+    {"head", 4, 1, 1},
+    {"header", 6, 1, 1},
+    {"hgroup", 6, 1, 1},
+    {"hr", 2, 1, 1},
+    {"html", 4, 1, 1},
+    {"iframe", 6, 1, 0},
+    {"img", 3, 1, 0},
+    {"input", 5, 1, 0},
+    {"keygen", 6, 1, 0},
+    {"li", 2, 1, 1},
+    {"link", 4, 1, 1},
+    {"listing", 7, 1, 1},
+    {"main", 4, 1, 1},
+    {"marquee", 7, 1, 0},
+    {"menu", 4, 1, 1},
+    {"meta", 4, 1, 1},
+    {"nav", 3, 1, 1},
+    {"noembed", 7, 1, 0},
+    {"noframes", 8, 1, 1},
+    {"noscript", 8, 1, 0},
+    {"object", 6, 1, 0},
+    {"ol", 2, 1, 1},
+    {"p", 1, 1, 1},
+    {"param", 5, 1, 0},
+    {"plaintext", 9, 1, 1},
+    {"pre", 3, 1, 1},
+    {"script", 6, 1, 1},
+    {"search", 6, 1, 1},
+    {"section", 7, 1, 1},
+    {"select", 6, 1, 0},
+    {"source", 6, 1, 0},
+    {"style", 5, 1, 1},
+    {"summary", 7, 1, 1},
+    {"table", 5, 1, 1},
+    {"tbody", 5, 1, 1},
+    {"td", 2, 1, 1},
+    {"template", 8, 1, 1},
+    {"textarea", 8, 1, 1},
+    {"tfoot", 5, 1, 1},
+    {"th", 2, 1, 1},
+    {"thead", 5, 1, 1},
+    {"title", 5, 1, 1},
+    {"tr", 2, 1, 1},
+    {"track", 5, 1, 0},
+    {"ul", 2, 1, 1},
+    {"wbr", 3, 1, 0},
+    {"xmp", 3, 1, 0},
+};
+
+/* bucket[first_char] = start index; bucket[first_char+1] = end */
+static const uint8_t h_tag_bucket[27] = {
+    0, 5, 12, 16, 23, 24, 31, 31, 42,
+    45, 45, 46, 49, 53, 57, 59, 63, 63,
+    63, 70, 81, 82, 82, 83, 84, 84, 84,
+};
+
+/* Resolve a (lowercased) tag name's flags; NULL when unknown. */
+static const HTagInfo* h_tag_lookup(const char* n) {
+    if (!n) return NULL;
+    unsigned char c = (unsigned char)n[0];
+    if (c < 'a' || c > 'z') return NULL;
+    for (int i = h_tag_bucket[c - 'a'];
+         i < h_tag_bucket[c - 'a' + 1]; i++) {
+        const HTagInfo* t = &h_tag_infos[i];
+        if ((uint8_t)n[t->len] == 0 && t->name[t->len - 1] == n[t->len - 1] &&
+            memcmp(n, t->name, t->len) == 0)
+            return t;
+    }
+    return NULL;
+}
+
 static int h_is_special_ww(const char* n) {
-    static const char* const k[] = {
-        "address",  "applet",  "area",   "article",  "aside",
-        "base",     "basefont", "bgsound", "blockquote", "body",
-        "br",       "button",  "caption", "center",  "col",
-        "colgroup", "dd",      "details", "dialog",  "dir",
-        "div",
-        "dl",       "dt",      "embed",  "fieldset", "figcaption",
-        "figure",   "footer",  "form",   "frame",    "frameset",
-        "h1",       "h2",      "h3",     "h4",       "h5",
-        "h6",       "head",    "header", "hgroup",   "hr",
-        "html",     "iframe",  "img",    "input",    "keygen",
-        "li",       "link",    "listing", "main",    "marquee",
-        "menu",     "meta",    "nav",    "noembed",  "noframes",
-        "noscript", "object",  "ol",     "p",        "param",
-        "plaintext", "pre",    "script", "search",   "section",
-        "select",   "source",  "style",  "summary",  "table",
-        "tbody",    "td",      "template", "textarea", "tfoot",
-        "th",       "thead",   "title",  "tr",       "track",
-        "ul",       "wbr",     "xmp",    NULL};
-    if (!n) return 0;
-    for (int i = 0; k[i]; i++)
-        if (strcmp(n, k[i]) == 0) return 1;
-    return 0;
+    const HTagInfo* t = h_tag_lookup(n);
+    return t && t->special;
 }
 
 #define H_NS_HTML 0
@@ -3256,22 +3356,8 @@ static int h_input_type_hidden(const char* q, const char* end) {
  * head set, the block-level set (they close p instead), the table
  * family, and raw-text elements. */
 static int h_reconstructs(const char* n) {
-    static const char* const no[] = {
-        "html",  "head",   "body",   "frameset", "base",  "basefont",
-        "bgsound", "link", "meta",   "script",   "style", "template",
-        "title", "noframes", "address", "article", "aside",
-        "blockquote", "center", "details", "dialog", "dir",
-        "div",   "dl",     "fieldset", "figcaption", "figure",
-        "footer", "header", "hgroup", "main",    "menu",  "nav",
-        "ol",    "p",      "search", "section",  "summary", "ul",
-        "h1",    "h2",     "h3",     "h4",       "h5",    "h6",
-        "pre",   "listing", "form",  "li",       "dd",    "dt",
-        "plaintext", "textarea", "table", "hr",  "caption", "col",
-        "colgroup", "frame", "tbody", "tfoot",   "thead", "td",
-        "th",    "tr",     NULL};
-    for (int i = 0; no[i]; i++)
-        if (strcmp(n, no[i]) == 0) return 0;
-    return 1;
+    const HTagInfo* t = h_tag_lookup(n);
+    return !(t && t->no_fmt);
 }
 
 /* ---- #659 foreign content (WHATWG 12.2.6.5) ---- */

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

@@ -836,6 +836,13 @@ LEPTRIS_API void leptris_document_free(struct leptris_document* doc) {
         /* The pool will be destroyed below, freeing all elements */
     }
 
+    /* Parse diagnostics (#1200): the recover-channel list. */
+    {
+        extern void leptris_diag_free(struct LeptrisDiag**, int*, int*);
+        leptris_diag_free(&doc->parse_diags, &doc->parse_diag_count,
+                          &doc->parse_diag_cap);
+    }
+
     /* Free document fields */
     if (doc->encoding) {
         LEPTRIS_FREE(doc->encoding);

data/vendor-src/libleptris/src/leptris/leptris_internal.h

@@ -9,6 +9,19 @@
 #ifndef LEPTRIS_INTERNAL_H
 #define LEPTRIS_INTERNAL_H
 
+/* Internal entry points must not leak into the shared-library ABI.
+ * Windows already hides them (no __declspec(dllexport)) and macOS
+ * build flags hide non-exported globals, but plain ELF keeps
+ * default visibility — leptris_set_error escaped into the Linux
+ * dynamic table while being absent from the PE exports, which no
+ * cross-platform FFI mirror can attach against (#1197 release
+ * cascade). */
+#if defined(_WIN32) || !(defined(__GNUC__) || defined(__clang__))
+#define LEPTRIS_LOCAL
+#else
+#define LEPTRIS_LOCAL __attribute__((visibility("hidden")))
+#endif
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -104,6 +117,8 @@ struct leptris_mut_attr_block {
     char bytes[];
 };
 
+struct LeptrisDiag;
+
 struct leptris_document {
     struct leptris_element* root;             /* Root element (legacy API) */
     /* Snapshot of this document's last failing parse message
@@ -111,6 +126,13 @@ struct leptris_document {
      * thread-local channel). */
     char last_error_message[256];
 
+    /* Recover-class parse diagnostics (#1200): the DOM parse's
+     * parity surface with the SAX lane's recover errors. Pool-free
+     * list (leptris_diag_* owns it); released in document_free. */
+    struct LeptrisDiag* parse_diags;
+    int parse_diag_count;
+    int parse_diag_cap;
+
     /* EXSLT-style extension pack enabled via leptris_exslt_enable
      * (TODO.concurrency/06). */
     int exslt_enabled;
@@ -883,7 +905,7 @@ static inline int leptris_strcmp(const char* s1, const char* s2) {
  * ============================================================================ */
 
 /* Set error with basic message */
-void leptris_set_error(leptris_error_code code, const char* message);
+LEPTRIS_LOCAL void leptris_set_error(leptris_error_code code, const char* message);
 
 /* Set error with line/column position */
 void leptris_set_parse_error_position(int line, int column);

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

@@ -8,6 +8,7 @@
  * by the slice, not the document. All event strings are owned by the
  * puller and remain valid until the NEXT leptris_pull_next call. */
 #include "../../include/leptris/sax/sax.h"
+#include "sax_internal.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -22,6 +23,11 @@ typedef struct pull_event {
     /* START_ELEMENT attributes: owned flat copies [n1,v1,n2,v2...] */
     char** attrs;
     size_t attr_count;
+    /* One-shot buffer pulls (TODO.max-perf/2-3 slice 1): strings
+     * borrow the sax parser's stable storage (input buffer + scratch,
+     * alive until parser free) — queue_reset_event frees only the
+     * attrs array itself. */
+    int borrowed;
 } pull_event;
 
 struct leptris_pull_parser {
@@ -57,9 +63,14 @@ struct leptris_pull_parser {
 };
 
 static void queue_reset_event(pull_event* e) {
-    free(e->name); free(e->text);
+    if (!e->borrowed) {
+        free(e->name);
+        free(e->text);
+    }
     if (e->attrs) {
-        for (size_t i = 0; i < e->attr_count * 2; i++) free(e->attrs[i]);
+        if (!e->borrowed)
+            for (size_t i = 0; i < e->attr_count * 2; i++)
+                free(e->attrs[i]);
         free(e->attrs);
     }
     memset(e, 0, sizeof(*e));
@@ -73,6 +84,18 @@ static char* pull_strdup_n(const char* s, size_t n) {
     return c;
 }
 
+/* Event strings: borrow in one-shot mode (stable until parser free),
+ * strdup otherwise (streaming file mode — the source chunk dies at
+ * the next feed). */
+static char* ev_string(pull_event* e, const struct leptris_pull_parser* p,
+                       const char* s, size_t n) {
+    if (p->sax->one_shot) {
+        e->borrowed = 1;
+        return (char*)(s ? s : "");
+    }
+    return pull_strdup_n(s ? s : "", n);
+}
+
 static pull_event* queue_push(struct leptris_pull_parser* p) {
     size_t used = (p->tail + p->cap - p->head) % p->cap;
     if (used + 1 == p->cap) {   /* full: grow */
@@ -104,16 +127,25 @@ static void cb_start_element(void* ud, const char* name, const char** attrs) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_START_ELEMENT;
-    e->name = pull_strdup_n(name, strlen(name));
+    e->name = ev_string(e, p, name, strlen(name));
     if (attrs) {
         size_t n = 0;
         while (attrs[n]) n += 2;   /* flat [name, value, ..., NULL] */
         e->attr_count = n / 2;
         e->attrs = (char**)calloc(n + 1, sizeof(char*));
         if (e->attrs) {
-            for (size_t i = 0; i < n; i++)
-                e->attrs[i] = pull_strdup_n(attrs[i] ? attrs[i] : "",
-                                            attrs[i] ? strlen(attrs[i]) : 0);
+            if (p->sax->one_shot) {
+                /* Names/values are frame/scratch-owned (parser
+                 * lifetime); the array itself stays queue-owned. */
+                e->borrowed = 1;
+                for (size_t i = 0; i < n; i++)
+                    e->attrs[i] = (char*)(attrs[i] ? attrs[i] : "");
+            } else {
+                for (size_t i = 0; i < n; i++)
+                    e->attrs[i] = pull_strdup_n(
+                        attrs[i] ? attrs[i] : "",
+                        attrs[i] ? strlen(attrs[i]) : 0);
+            }
         }
     }
 }
@@ -123,7 +155,7 @@ static void cb_end_element(void* ud, const char* name) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_END_ELEMENT;
-    e->name = pull_strdup_n(name, strlen(name));
+    e->name = ev_string(e, p, name, strlen(name));
 }
 
 static void cb_characters(void* ud, const char* text, size_t len) {
@@ -131,7 +163,10 @@ static void cb_characters(void* ud, const char* text, size_t len) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_TEXT;
-    e->text = pull_strdup_n(text, len);
+    /* Text spans are raw input-buffer slices — no NUL terminator in
+     * stable storage, so they always copy even in one-shot mode
+     * (the public event contract is NUL-terminated strings). */
+    e->text = pull_strdup_n(text ? text : "", len);
     e->text_len = len;
 }
 
@@ -140,7 +175,7 @@ static void cb_comment(void* ud, const char* comment) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_COMMENT;
-    e->text = pull_strdup_n(comment, strlen(comment));
+    e->text = ev_string(e, p, comment, strlen(comment));
     e->text_len = strlen(comment);
 }
 
@@ -149,7 +184,7 @@ static void cb_cdata(void* ud, const char* cdata) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_CDATA;
-    e->text = pull_strdup_n(cdata, strlen(cdata));
+    e->text = ev_string(e, p, cdata, strlen(cdata));
     e->text_len = strlen(cdata);
 }
 
@@ -158,9 +193,9 @@ static void cb_pi(void* ud, const char* target, const char* data) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_PI;
-    e->name = pull_strdup_n(target, strlen(target));
+    e->name = ev_string(e, p, target, strlen(target));
     if (data) {
-        e->text = pull_strdup_n(data, strlen(data));
+        e->text = ev_string(e, p, data, strlen(data));
         e->text_len = strlen(data);
     }
 }
@@ -177,9 +212,9 @@ static void cb_start_prefix(void* ud, const char* prefix, const char* uri) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_START_PREFIX;
-    e->name = pull_strdup_n(prefix ? prefix : "",
-                            prefix ? strlen(prefix) : 0);
-    e->text = pull_strdup_n(uri ? uri : "", uri ? strlen(uri) : 0);
+    e->name = ev_string(e, p, prefix ? prefix : "",
+                        prefix ? strlen(prefix) : 0);
+    e->text = ev_string(e, p, uri ? uri : "", uri ? strlen(uri) : 0);
     e->text_len = uri ? strlen(uri) : 0;
 }
 
@@ -188,8 +223,8 @@ static void cb_end_prefix(void* ud, const char* prefix) {
     pull_event* e = queue_push(p);
     if (!e) return;
     e->type = LEPTRIS_PULL_END_PREFIX;
-    e->name = pull_strdup_n(prefix ? prefix : "",
-                            prefix ? strlen(prefix) : 0);
+    e->name = ev_string(e, p, prefix ? prefix : "",
+                        prefix ? strlen(prefix) : 0);
 }
 
 static void cb_error(void* ud, const char* message, int line, int column) {

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

@@ -222,6 +222,36 @@ static int sxs_elem_push(LeptrisSAXParser* p, const char* name, size_t name_len)
     return 0;
 }
 
+/* One-shot push: the name lives in the append-only scratch arena
+ * (parser lifetime) instead of the reusable frame slot, so
+ * handler-visible START/END names stay valid for borrowed consumers
+ * (pull.c ev_string) even after the stack slot serves a later
+ * sibling. */
+static int sxs_elem_push_oneshot(LeptrisSAXParser* p, const char* name,
+                                 size_t name_len) {
+    if (p->elem_depth >= LEPTRIS_SAX_MAX_DEPTH) {
+        sxs_set_error(p, "Element nesting too deep");
+        return -1;
+    }
+    const char* nm = sxs_scratch_append(p, name, name_len);
+    if (!nm) {
+        sxs_set_error(p, "out of memory");
+        return -1;
+    }
+    SaxElementFrame* f = &p->elem_stack[p->elem_depth];
+    f->name       = (char*)nm;   /* frame only ever reads the name */
+    f->name_heap  = NULL;
+    f->name_len   = name_len;
+    f->attrs      = f->attrs_inline;
+    f->attrs_inline[0] = NULL;
+    f->attrs_heap = NULL;
+    f->attr_count = 0;
+    f->attr_cap   = SAX_ATTRS_INLINE;
+    f->self_closing = 0;
+    p->elem_depth++;
+    return 0;
+}
+
 static void sxs_elem_pop(LeptrisSAXParser* p) {
     if (p->elem_depth == 0) return;
     p->elem_depth--;
@@ -591,7 +621,7 @@ static int sxs_step_elem_open_name(LeptrisSAXParser* p, int is_final) {
         }
         const char* nb = p->pos;
         while (p->pos < p->end && sxs_is_name_char(*p->pos)) p->pos++;
-        if (sxs_elem_push(p, nb, (size_t)(p->pos - nb)) < 0) {
+        if (sxs_elem_push_oneshot(p, nb, (size_t)(p->pos - nb)) < 0) {
             return SAX_STEP_ERR;
         }
         p->column += (int)(p->pos - nb);
@@ -716,6 +746,32 @@ static int sxs_step_attr_list(LeptrisSAXParser* p, int is_final) {
  * ============================================================================ */
 
 static int sxs_step_attr_name(LeptrisSAXParser* p, int is_final) {
+    if (p->one_shot) {
+        /* Slice 1 (TODO.max-perf/2-3): single-feed input never
+         * splits the token — scan in place, materialize the name
+         * with ONE scratch copy; the carry path below costs a
+         * reserve+store call per name byte. */
+        if (p->pos >= p->end) {
+            return is_final ? (sxs_set_error(p, "Expected attribute name"), SAX_STEP_ERR)
+                            : SAX_STEP_NEED_MORE;
+        }
+        if (!sxs_is_name_start(*p->pos)) {
+            sxs_set_error(p, "Expected attribute name");
+            return SAX_STEP_ERR;
+        }
+        p->pending_attr_line = p->line;
+        p->pending_attr_column = p->column;
+        const char* nb = p->pos;
+        while (p->pos < p->end && sxs_is_name_char(*p->pos)) {
+            sxs_pos_putc(p, *p->pos);
+            p->pos++;
+        }
+        const char* nm = sxs_scratch_append(p, nb, (size_t)(p->pos - nb));
+        if (!nm) { sxs_set_error(p, "out of memory"); return SAX_STEP_ERR; }
+        p->pending_attr_name = nm;
+        p->state = SAX_ST_ATTR_EQ;
+        return SAX_STEP_OK;
+    }
     /* Diagnostic point for recoverable errors: the name's start
      * (issue #647) — captured before any byte of the name is
      * consumed, including across chunk-boundary resumes (the first
@@ -821,6 +877,26 @@ static int sxs_step_attr_value_quote(LeptrisSAXParser* p, int is_final) {
 
 static int sxs_step_attr_value(LeptrisSAXParser* p, int is_final) {
     char quote = p->carry[0];
+    const char* raw;
+    size_t raw_len;
+    if (p->one_shot) {
+        /* Slice 1: scan the value span in place (same position
+         * accounting as the carry loop); the span below is
+         * materialized with one scratch copy instead of a
+         * reserve+store call per value byte. */
+        raw = p->pos;
+        while (p->pos < p->end && *p->pos != quote) {
+            sxs_pos_putc(p, *p->pos);
+            p->pos++;
+        }
+        if (p->pos >= p->end) {
+            return is_final ? (sxs_set_error(p, "Unterminated attribute value"), SAX_STEP_ERR)
+                            : SAX_STEP_NEED_MORE;
+        }
+        raw_len = (size_t)(p->pos - raw);
+        sxs_pos_putc(p, *p->pos);
+        p->pos++;
+    } else {
     /* p->carry[1..] may already have value bytes if we resumed mid-value. */
     while (p->pos < p->end && *p->pos != quote) {
         if (sxs_carry_putc(p, *p->pos) < 0) {
@@ -838,14 +914,15 @@ static int sxs_step_attr_value(LeptrisSAXParser* p, int is_final) {
     /* p->pos points at closing quote. */
     sxs_pos_putc(p, *p->pos);
     p->pos++;
-    /* Build value: skip carry[0] (quote), copy carry[1..].
+    raw = p->carry + 1;
+    raw_len = p->carry_len - 1;
+    }
+    /* Build value.
      *
      * XML 1.0 3.3.3: attribute values must be delivered with
      * entity/character references expanded. Values without '&'
      * (the common case) copy verbatim; values with '&' decode
      * through a temporary buffer first. */
-    const char* raw = p->carry + 1;
-    size_t raw_len = p->carry_len - 1;
     const char* value;
     if (raw_len && memchr(raw, '&', raw_len)) {
         LeptrisStringView sv = leptris_sv_from_ptr(raw, raw_len);
@@ -995,7 +1072,15 @@ static int sxs_step_elem_content(LeptrisSAXParser* p, int is_final) {
 
 static int sxs_step_text(LeptrisSAXParser* p, int is_final) {
     const char* start = p->pos;
-    while (p->pos < p->end && *p->pos != '<') p->pos++;
+    /* memchr finds the span end at libc speeds; the loop form costs
+     * a load+compare+branch per byte. Position accounting is
+     * unaffected — this state never updates line/column per text
+     * byte (tag states own the counters). */
+    {
+        const char* lt = (const char*)memchr(p->pos, '<',
+                                             (size_t)(p->end - p->pos));
+        p->pos = lt ? lt : p->end;
+    }
     size_t len = (size_t)(p->pos - start);
 
     if (p->carry_len == 0 && (len == 0 || !memchr(start, '&', len))) {

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

@@ -103,6 +103,42 @@ TEST(Digest, DropWsTextSkipsWhitespaceOnlyNodes) {
               digest_of("<r><a/> <b/></r>", LEPTRIS_DIGEST_DEFAULT));
 }
 
+/* #1200: ATTR_ORDER keeps document order in the hash — reordered
+ * attributes digest DIFFERENT, same-order documents stay equal,
+ * and the flag composes with DROP_WS_TEXT. The dedup (first-wins
+ * on the resolved key) still applies. */
+TEST(Digest, AttrOrderSensitiveVariant) {
+    EXPECT_NE(digest_of("<r a='1' b='2'/>", LEPTRIS_DIGEST_ATTR_ORDER),
+              digest_of("<r b='2' a='1'/>", LEPTRIS_DIGEST_ATTR_ORDER));
+    EXPECT_EQ(digest_of("<r a='1' b='2'/>", LEPTRIS_DIGEST_ATTR_ORDER),
+              digest_of("<r a='1' b='2'/>", LEPTRIS_DIGEST_ATTR_ORDER));
+}
+
+TEST(Digest, AttrOrderComposesWithDropWs) {
+    EXPECT_EQ(
+        digest_of("<r a='1' b='2'><a/><b/></r>",
+                  (LeptrisDigestFlags)(LEPTRIS_DIGEST_ATTR_ORDER |
+                                       LEPTRIS_DIGEST_DROP_WS_TEXT)),
+        digest_of("<r a='1' b='2'><a/> <b/></r>",
+                  (LeptrisDigestFlags)(LEPTRIS_DIGEST_ATTR_ORDER |
+                                       LEPTRIS_DIGEST_DROP_WS_TEXT)));
+    EXPECT_NE(
+        digest_of("<r a='1' b='2'><a/></r>",
+                  (LeptrisDigestFlags)(LEPTRIS_DIGEST_ATTR_ORDER |
+                                       LEPTRIS_DIGEST_DROP_WS_TEXT)),
+        digest_of("<r b='2' a='1'><a/></r>",
+                  (LeptrisDigestFlags)(LEPTRIS_DIGEST_ATTR_ORDER |
+                                       LEPTRIS_DIGEST_DROP_WS_TEXT)));
+}
+
+TEST(Digest, AttrOrderRecursesIntoChildren) {
+    /* The child's attribute order participates too: the Merkle
+     * combine feeds each child's digest (with the flag) upward. */
+    EXPECT_NE(
+        digest_of("<r><c x='1' y='2'/></r>", LEPTRIS_DIGEST_ATTR_ORDER),
+        digest_of("<r><c y='2' x='1'/></r>", LEPTRIS_DIGEST_ATTR_ORDER));
+}
+
 /* Null contract: no node, no digest. */
 TEST(Digest, NullNodeIsZero) {
     EXPECT_EQ(leptris_node_digest(nullptr, LEPTRIS_DIGEST_DEFAULT), 0u);

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

@@ -32,6 +32,30 @@ TEST(DomBasics, EmptyDocumentRoundTrips) {
     leptris_document_free(doc);
 }
 
+// #1197: the close-tag fast-path compare masked the wrong end of the
+// 8-byte load on big-endian and failed every paired close tag. The
+// unit corpus was self-closing-heavy and never caught it; sweep the
+// compare across all mask lengths plus the wide-family report.
+TEST(DomBasics, CloseTagCompareAcrossNameLengths) {
+    for (int len = 1; len <= 9; len++) {
+        std::string name(static_cast<size_t>(len), 'n');
+        std::string xml = "<" + name + "><" + name + "/></" + name + ">";
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisDocument doc =
+            leptris_parse_string(xml.data(), xml.size(), &st);
+        ASSERT_NE(doc, nullptr)
+            << "close-tag name of length " << len << " failed to parse";
+        leptris_document_free(doc);
+    }
+    std::string xml = "<r>";
+    for (int i = 1; i <= 80; i++) xml += "<n" + std::to_string(i) + "/>";
+    xml += "</r>";
+    LeptrisDocument doc =
+        leptris_parse_string(xml.data(), xml.size(), NULL);
+    ASSERT_NE(doc, nullptr) << "80-child family failed to parse";
+    leptris_document_free(doc);
+}
+
 TEST(DomBasics, DocumentCreateHasNoRoot) {
     LeptrisDocument doc = leptris_document_create();
     ASSERT_NE(doc, nullptr);

data/vendor-src/libleptris/test/parser/test_parser.cpp

@@ -563,3 +563,46 @@ TEST(FreshDocumentContract, TruncatedLengthIsACleanParseError) {
     EXPECT_EQ(doc, nullptr);
     EXPECT_EQ(st, LEPTRIS_ERROR_PARSE);
 }
+
+// ---- #1200 part 2: recover diagnostics on the DOM parse -------
+
+TEST(ParseDiag, DuplicateAttributeKeepsFirstAndReports) {
+    /* libxml2/SAX-lane parity: recover-class diagnostic on the DOM
+     * parse instead of silence. First definition wins (the digest's
+     * first-wins semantics made official). */
+    const char xml[] =
+        "<body lang=\"en\" xml:lang=\"en\" xml:lang=\"fr\"><div/></body>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string(xml, strlen(xml), NULL);
+    ASSERT_NE(doc, nullptr);
+
+    EXPECT_EQ(leptris_document_parse_diag_count(doc), 1u);
+    LeptrisDiagKind kind = (LeptrisDiagKind)-1;
+    char msg[192] = {0};
+    ASSERT_EQ(leptris_document_parse_diag(doc, 0, &kind, msg,
+                                          sizeof(msg)), 1);
+    EXPECT_EQ(kind, LEPTRIS_DIAG_RECOVER);
+    EXPECT_STREQ(msg, "Attribute xml:lang redefined");
+
+    /* First value survived; the duplicate never entered the list. */
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+    EXPECT_EQ(leptris_element_attribute_count(root), 2u);
+    EXPECT_STREQ(leptris_element_attribute(root, "xml:lang"), "en");
+    leptris_document_free(doc);
+}
+
+TEST(ParseDiag, CleanDocumentHasNoDiags) {
+    const char xml[] = "<body lang=\"en\" xml:lang=\"en\"><div/></body>";
+    LeptrisDocument doc = leptris_parse_string(xml, strlen(xml), NULL);
+    ASSERT_NE(doc, nullptr);
+    EXPECT_EQ(leptris_document_parse_diag_count(doc), 0u);
+    LeptrisDiagKind kind;
+    char msg[64];
+    EXPECT_EQ(leptris_document_parse_diag(doc, 0, &kind, msg,
+                                          sizeof(msg)), 0);
+    EXPECT_EQ(leptris_document_parse_diag(NULL, 0, &kind, msg,
+                                          sizeof(msg)), 0);
+    EXPECT_EQ(leptris_document_parse_diag_count(NULL), 0u);
+    leptris_document_free(doc);
+}

data/vendor-src/libleptris/test/sax/test_pull.cpp

@@ -88,6 +88,38 @@ TEST(Pull, CommentsCdataPiAndEndDocument) {
     EXPECT_EQ(end_doc, 1);
 }
 
+TEST(Pull, EntityTextAndAttrValuesExpandInBufferMode) {
+    /* Buffer-mode (one-shot) pulls borrow event strings from the
+     * input/scratch — entities must still arrive EXPANDED, for both
+     * text and attribute values (borrow-safety pin for
+     * TODO.max-perf/2-3 slice 1). */
+    const char* xml =
+        "<r tag='r&amp;d' code='&#65;'>a &amp; b &lt;c&gt;</r>";
+    LeptrisPullParser p = leptris_pull_new(xml, strlen(xml));
+    ASSERT_NE(p, nullptr);
+    const LeptrisPullEvent* ev = leptris_pull_next(p);
+    ASSERT_NE(ev, nullptr);
+    ASSERT_EQ(ev->type, LEPTRIS_PULL_START_ELEMENT);
+    EXPECT_EQ(leptris_pull_attr_count(p), 2u);
+    EXPECT_STREQ(leptris_pull_attr_name(p, 0), "tag");
+    EXPECT_STREQ(leptris_pull_attr_value(p, 0), "r&d");
+    EXPECT_STREQ(leptris_pull_attr_name(p, 1), "code");
+    EXPECT_STREQ(leptris_pull_attr_value(p, 1), "A");
+    ev = leptris_pull_next(p);
+    ASSERT_NE(ev, nullptr);
+    ASSERT_EQ(ev->type, LEPTRIS_PULL_TEXT);
+    ASSERT_NE(ev->text, nullptr);
+    EXPECT_STREQ(ev->text, "a & b <c>");
+    ev = leptris_pull_next(p);
+    ASSERT_NE(ev, nullptr);
+    ASSERT_EQ(ev->type, LEPTRIS_PULL_END_ELEMENT);
+    EXPECT_STREQ(ev->name, "r");
+    ev = leptris_pull_next(p);
+    ASSERT_NE(ev, nullptr);
+    EXPECT_EQ(ev->type, LEPTRIS_PULL_END_DOCUMENT);
+    leptris_pull_free(p);
+}
+
 TEST(Pull, MalformedInputYieldsErrorEvent) {
     LeptrisPullParser p = leptris_pull_new("<a><b></a>", 10);
     ASSERT_NE(p, 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.204",
+  "version": "1.9.207",
   "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.204.0
+  version: 1.9.207.0
 platform: ruby
 authors:
 - Ribose Inc.