leptris 1.9.222.3 → 1.9.225.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65c927a5db55dcad7c2b10b3eb7f4dc568cddd7e9c1762693a19697b9e4adaf7
-  data.tar.gz: 472acbd73babf9608170f2f1f5d439d39e0dd97594034364db22cd5bacb94c21
+  metadata.gz: a65d81fa73df8297d35b8e095e69c656d4ff8819620a40bd2c173ae685727452
+  data.tar.gz: de25ee0a34c202432ccbc870a5a40b689000827902851d4387c1a1f98aebfa80
 SHA512:
-  metadata.gz: fc9fb646488eade1050dbd2bb32cb88d94bf1df6858480480fc5f6b7aabe333225b689e72311483682367fe44f0bbbfbaa8624af2d65b91e4c88d963c24d896d
-  data.tar.gz: 56075f78ab3fff389106a27c819967de112b80dbbafdaab83d6e0cc8ba56c8d9993b1984a74f69ca8e16ab40eeda57938a040b439f14941a4778dfffe64bd18b
+  metadata.gz: 2a61094f9eff1615f87cccb47791ecb899b8d2ca1a23afd4579238bbc9cf3afea51220a82ad5a6556ae21462a7f928c008277da2d10045e41c52a8ed6422d76f
+  data.tar.gz: 6833ca765302ade1e2874962bb86ae419b17671caa75e556b7324636b7930b5c568f1dc759abd7e6767388b36a3c1ddab89c539f263c1a139c303ef1683754f4

data/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.225.0] - 2026-09-22
+
+### Added — native HTML serialization, construction, and the bulk SAX drain (engine 1.9.223–225)
+
+- **`to_html` re-pointed at the engine's native HTML mode**
+  (1.9.225, upstream #1309/#1311 — our filing answered in one
+  release): `Document#to_html` → `leptris_document_serialize_html`,
+  `Element#to_html` → the ext serializer with `html_method: 1`.
+  Byte-parity with the interim Ruby walk is pinned by the #309
+  spec battery; the native path also fixes the walk's PI branch
+  (the Ruby walk crashed on processing instructions — target/data
+  readers don't exist on the wrapper). The Ruby walk is removed.
+- **`Document#save(path, mode: :html)`** → `leptris_document_save_html`.
+- **`leptris_document_create_html` attached** (native HTML-mode
+  documents — serialize AS HTML by default, Nokogiri behavior);
+  the facade's `create` stays on the XML base + doctype preset so
+  `to_xml` output on facade docs is unchanged. `html_method`
+  (tri-state) rides `SerializeExtStruct` — `to_xml` on an HTML
+  document can force XML with `-1` when the face needs it.
+- **Bulk SAX record drain attached** (1.9.223, upstream #1298,
+  Canon-reported): `leptris_sax_records_*` — one call yields the
+  whole document as a flat record table (tree edges, source
+  offsets, flat attribute table with §3.3.3 normalization flags).
+  Attach-only until the SAX face wants the bulk lane.
+- 1.9.224 rides along (LeakSanitizer fix on the direct-parse
+  failure path). Audit 351/351, suite 780/0.
+
 ## [1.9.222.0] - 2026-09-22
 
 ### Fixed — engine sync (1.9.222): the interleaved lane's namespace regression

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.222"
+LIBLEPTRIS_VERSION = "1.9.225"
 # 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.222.3"
+  VERSION = "1.9.225.0"
 end

data/lib/leptris/xml/document.rb

@@ -481,16 +481,24 @@ class Leptris::XML::Document
   # the perf headroom this face gates on.
   def to_html
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
-    Leptris::XML::HTMLSerialize.document(self)
+    Leptris::XML::Serialization.document_html(c_ptr)
   end
 
-  def save(path, **opts)
+  def save(path, mode: :xml, **opts)
     opts_struct, _encoding_anchor = Leptris::XML::Serialization.build_options(
       indent: opts.fetch(:indent, 0),
       no_decl: opts.fetch(:no_decl, false),
       encoding: opts[:encoding])
-    status = Leptris::XML::FFI.leptris_document_save_file(
-      c_ptr, path, opts_struct.pointer)
+    status =
+      if mode == :html
+        Leptris::XML::FFI.leptris_document_save_html(
+          c_ptr, path, opts_struct.pointer)
+      elsif mode != :xml
+        raise ArgumentError, "mode must be :xml or :html, got #{mode.inspect}"
+      else
+        Leptris::XML::FFI.leptris_document_save_file(
+          c_ptr, path, opts_struct.pointer)
+      end
     Leptris::XML::FFI.check_status(status)
     self
   end

data/lib/leptris/xml/element.rb

@@ -784,7 +784,7 @@ class Leptris::XML::Element < Leptris::XML::Node
   # Document#to_html for the semantics).
   def to_html
     ensure_alive!
-    Leptris::XML::HTMLSerialize.element(self)
+    Leptris::XML::Serialization.element_html(c_ptr)
   end
 
   def canonicalize(version = Leptris::XML::FFI::C14N_1_0,

data/lib/leptris/xml/ffi.rb

@@ -169,7 +169,11 @@ module Leptris
       class SerializeExtStruct < ::FFI::Struct
         layout :indent_text, :int,
                :indent_unit, :pointer,
-               :expand_empty, :int
+               :expand_empty, :int,
+               # libleptris 1.9.225 (#1311): tri-state — 0 = the
+               # document's default method, 1 = force HTML, -1 =
+               # force XML (to_xml on an HTML document).
+               :html_method, :int
       end
 
       # Mirrors LeptrisParseOptions (libleptris >= 1.9.0 carries the
@@ -992,6 +996,28 @@ attach_function :leptris_parse_string,
         [:leptris_element, :pointer, :size_t, :pointer, :pointer], :size_t
       attach_function :leptris_document_save_file,
         [:leptris_document, :string, :pointer], :leptris_status
+      # HTML construction + serialization (libleptris 1.9.225,
+      # upstream #1309/#1311 — the engine side of #309): native HTML
+      # documents carry the html serialization mode (voids unclosed,
+      # raw-text script/style, explicit closes, no declaration).
+      attach_function :leptris_document_create_html, [], :leptris_document
+      attach_function :leptris_document_serialize_html,
+        [:leptris_document, :pointer], :pointer
+      attach_function :leptris_document_save_html,
+        [:leptris_document, :string, :pointer], :leptris_status
+      # Bulk SAX record drain (libleptris 1.9.223, upstream #1298):
+      # ONE call parses the document into a flat record table —
+      # tree edges, source offsets, and a flat attribute table, all
+      # offset-views into a parser-owned buffer. Attach-only until
+      # the SAX face wants the bulk lane.
+      attach_function :leptris_sax_records_parse,
+        [:string, :size_t, :uint, :pointer], :leptris_status
+      attach_function :leptris_sax_records_count, [:pointer], :size_t
+      attach_function :leptris_sax_records_data, [:pointer], :pointer
+      attach_function :leptris_sax_records_attrs,
+        [:pointer, :pointer], :pointer
+      attach_function :leptris_sax_records_buffer, [:pointer], :string
+      attach_function :leptris_sax_records_free, [:pointer], :void
       # XSLT 1.0 engine (libleptris 1.9.1): compile once, apply many.
       # XQuery 1.0 core (libleptris 1.9.64-1.9.66): orchestration
       # over the XPath engine — prolog (declare variable/namespace/

data/lib/leptris/xml/serialization.rb

@@ -58,6 +58,33 @@ module Leptris::XML::Serialization
   # Default-options element serialization for inner_html's per-child
   # loop: no kwargs, no options rebuild, no method allocation —
   # one FFI fast-path dispatch per child.
+  # Document HTML serialization (libleptris 1.9.225, #1311): the
+  # native HTML mode — voids unclosed, raw-text script/style,
+  # explicit closes, no declaration, DOCTYPE first.
+  def self.document_html(c_ptr)
+    Leptris::XML::FFI.read_owned_string(
+      Leptris::XML::FFI.leptris_document_serialize_html(c_ptr, nil))
+  end
+
+  # Element-level HTML mode through the ext serializer (the
+  # html_method tri-state forces HTML regardless of the document
+  # flavor).
+  HTML_METHOD_EXT = begin
+    ext = Leptris::XML::FFI::SerializeExtStruct.new
+    ext[:indent_text] = 0
+    ext[:indent_unit] = nil
+    ext[:expand_empty] = 0
+    ext[:html_method] = 1
+    ext
+  end
+  private_constant :HTML_METHOD_EXT
+
+  def self.element_html(c_ptr)
+    Leptris::XML::FFI.read_owned_string(
+      Leptris::XML::FFI.leptris_element_serialize_ext(
+        c_ptr, nil, HTML_METHOD_EXT.pointer))
+  end
+
   def self.element_xml_default(c_ptr)
     return Leptris::XML::Native.fast_element_xml(c_ptr.address, 0, true,
                                                   nil) if

data/lib/leptris/xml.rb

@@ -21,7 +21,6 @@ module Leptris
     autoload :CssToXPath, "leptris/xml/css_to_xpath"
     autoload :CStringArray, "leptris/xml/c_string_array"
     autoload :Serialization, "leptris/xml/serialization"
-    autoload :HTMLSerialize, "leptris/xml/html_serialize"
     autoload :SAX, "leptris/xml/sax"
     autoload :XPath, "leptris/xml/xpath"
     autoload :EvaluationContext, "leptris/xml/evaluation_context"

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.222
+- libleptris v1.9.225
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,78 @@
 ## [Unreleased]
 
+## [1.9.225] - 2026-09-22
+
+### Added
+
+- **html: public HTML construction + serialization surface (#1309,
+  #1311).** HTML documents now serialize AS HTML by default
+  (libxml2/Nokogiri behavior): void elements unclosed (`<br>`,
+  `<meta charset="utf-8">`), raw-text script/style verbatim,
+  childless non-voids explicitly closed, no XML declaration. New:
+  `leptris_document_create_html()`, `leptris_document_serialize_html()`,
+  `leptris_document_save_html()`, and `LeptrisSerializeExtOptions.html_method`
+  (tri-state: 0 = document default, 1 = force HTML, -1 = force XML —
+  to_xml on an HTML doc). Element-level `html_method` maps through the
+  ext serializer too. HTML-parsed documents (whatwg + html4 modes)
+  carry the mode automatically; XSLT `method="html"` output unchanged
+  (#1312).
+
+
+## [1.9.224] - 2026-09-22
+
+### Fixed
+
+- **mem:** the element source-offset side table (new in this
+  release) is now also freed on the direct-parse failure path,
+  which bypasses leptris_document_free — caught by CI LeakSanitizer.
+- **test:** the runner-contention perf gate
+  (SmallDocumentParseIsFast) retries across settling windows instead
+  of failing on a single contended measurement (three CI flakes in
+  one day, budget unchanged).
+
+### Performance
+
+- **dom:** elements shrink **72 -> 64 bytes** (ILP32 56 -> 48;
+  #1285 slice 3a): the namespace side-cache pointer became a
+  self-relative int32 offset (the attrs' round-19 pattern), and the
+  #1124 source offsets moved to a document-owned side table — cold
+  diagnostics-only data no longer costs hot-path cache lines.
+  Position accessors are unchanged (#1124 specs green). Part of the
+  pugi-style node-storage lane (#1222/#1238) (#1308).
+
+
+
+## [1.9.223] - 2026-09-22
+
+### Added
+
+- **sax:** `leptris_sax_records_parse` — a bulk record drain for hot SAX
+  loops (#1298, reported by Canon): ONE call returns the whole document
+  as a flat record table (element tree edges, start/end offsets, flat
+  attribute table with XML 1.0 §3.3.3 normalization flags), all
+  NUL-terminated views into a parser-owned buffer. Unsupported
+  constructs (comments/PIs/CDATA/DOCTYPE/entities/xmlns) return
+  `LEPTRIS_ERROR_NOT_SUPPORTED` — fall back to the pull API. New
+  additive status code (#1305).
+
+### Fixed
+
+- **dom:** `LEPTRIS_DIGEST_ATTR_ORDER` is now actually honored — the
+  1.9.205 flag shipped only as a C enum with no env reader and no
+  binding carrier, so `strings` never found it in shipped bundles
+  (#1297, reported by Canon). `leptris_node_digest` reads the env
+  per call and ORs it into the passed flags (#1304).
+
+### Performance
+
+- **dom:** text nodes shrink **64 → 48 bytes** (#1285 slice 4): the
+  `pool`/`borrowed` fields are gone — every parse lane terminates
+  text in place and entities decode eagerly at parse time, so
+  `leptris_text_get_content` is a plain field read. Content is
+  always NUL-terminated; `content_len` is authoritative (#1303).
+
+
+
 ## [1.9.222] - 2026-09-22
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -35,6 +35,7 @@ set(LEPTRIS_SOURCES
     leptris/dom/node_public.c
     leptris/descriptor/plan.c
     leptris/dom/element.c
+    leptris/dom/elem_pos.c
     leptris/dom/element_query.c
     leptris/dom/element_modify.c
     leptris/dom/element_index.c
@@ -112,6 +113,7 @@ set(LEPTRIS_SOURCES
     leptris/sax/iterparse.c
     leptris/sax/streaming.c
     leptris/sax/recorder.c
+    leptris/sax/records.c
 
     # DTD
     leptris/dtd/model.c

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

@@ -596,6 +596,93 @@ LEPTRIS_API const char* leptris_iterparse_error(LeptrisIterparse it);
 
 LEPTRIS_API void leptris_iterparse_free(LeptrisIterparse it);
 
+
+/* ============================================================================
+ * Bulk SAX records (issue #1298) — one-crossing whole-document drain
+ * ============================================================================ */
+
+/** Record kinds (LeptrisSaxRecord.kind). */
+enum {
+    LEPTRIS_SAX_REC_ELEMENT = 0,   /**< start+end collapsed; tree via parent/next_sib */
+    LEPTRIS_SAX_REC_TEXT    = 1    /**< character data run (entity-free docs only) */
+};
+
+/** One element or text record. Offsets are byte positions into the
+ * buffer returned by leptris_sax_records_buffer; every view is
+ * NUL-terminated at off+len (names and text both). */
+typedef struct LeptrisSaxRecord {
+    uint32_t kind;          /**< LEPTRIS_SAX_REC_* */
+    uint32_t parent;        /**< record index, 0xFFFFFFFF for the root */
+    uint32_t next_sib;      /**< record index, 0xFFFFFFFF = last sibling */
+    uint32_t off;           /**< element: name; text: content */
+    uint32_t len;           /**< byte length at off (excl. NUL) */
+    uint32_t line;          /**< byte offset of '<' (or text start) + 1 (#1124 dp semantics) */
+    uint32_t start_tag_end; /**< byte offset after the open '>' (elements; 0 when unknown) */
+    uint32_t elem_end;      /**< byte offset after the close '>' (self-close == start) */
+    uint32_t attr_first;    /**< index into the flat attr table, 0xFFFFFFFF = none */
+    uint32_t attr_count;    /**< number of attributes */
+    uint8_t  self_closing;  /**< element written <a/> */
+} LeptrisSaxRecord;
+
+/** One attribute: flat (off,len) views + 3.3.3 normalization need. */
+typedef struct LeptrisSaxAttr {
+    uint32_t name_off, name_len;    /**< attribute name (qname, NUL-terminated at [name_len]) */
+    uint32_t value_off, value_len;  /**< raw value (NUL-terminated at [value_len]) */
+    uint8_t  value_has_ws;          /**< literal \t/\n/\r present — apply XML 1.0 3.3.3 normalization */
+} LeptrisSaxAttr;
+
+/** Opaque whole-document record table. */
+typedef struct LeptrisSaxRecords LeptrisSaxRecords;
+
+/**
+ * Parse a whole document into a flat record table (ONE call)
+ *
+ * The engine-side surface for #1298: hosts with hot SAX loops drain
+ * the entire document with a single crossing and then walk plain C
+ * structs — no per-event callback dispatch, no per-event string
+ * minting C-side. Records are (off,len) views into the parser's
+ * private copy of the input; every view is NUL-terminated in place.
+ *
+ * Coverage: the interleaved lane's scannable subset — elements,
+ * text, attributes; well-formed entity-free documents without
+ * comments/PIs/CDATA/DOCTYPE/xmlns declarations. Anything outside
+ * that subset returns LEPTRIS_ERROR_NOT_SUPPORTED (zero allocation);
+ * hosts fall back to the pull API (leptris_pull_new) for those
+ * documents. Malformed input returns LEPTRIS_ERROR_PARSE.
+ *
+ * @param xml Input (copied; the caller's buffer is untouched)
+ * @param len Input length in bytes (< 2 GiB)
+ * @param flags Reserved; pass 0
+ * @param out Receives the table handle
+ * @return LEPTRIS_OK, LEPTRIS_ERROR_NULL_ARG, LEPTRIS_ERROR_NOT_SUPPORTED,
+ *         LEPTRIS_ERROR_PARSE, or LEPTRIS_ERROR_MEMORY
+ *
+ * Memory: free with leptris_sax_records_free; all views die with it.
+ */
+LEPTRIS_API LeptrisStatus leptris_sax_records_parse(const char* xml,
+                                                    size_t len,
+                                                    unsigned flags,
+                                                    LeptrisSaxRecords** out);
+
+/** Number of records. */
+LEPTRIS_API size_t leptris_sax_records_count(const LeptrisSaxRecords* recs);
+
+/** Record array (count entries; valid until free). */
+LEPTRIS_API const LeptrisSaxRecord* leptris_sax_records_data(
+    const LeptrisSaxRecords* recs);
+
+/** Flat attribute table + its length (valid until free). */
+LEPTRIS_API const LeptrisSaxAttr* leptris_sax_records_attrs(
+    const LeptrisSaxRecords* recs, size_t* out_attr_count);
+
+/** The buffer all record/attr offsets index into (NUL-padded past
+ * len). */
+LEPTRIS_API const char* leptris_sax_records_buffer(
+    const LeptrisSaxRecords* recs);
+
+/** Free the table (invalidates every view). */
+LEPTRIS_API void leptris_sax_records_free(LeptrisSaxRecords* recs);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -49,7 +49,8 @@ typedef enum {
     LEPTRIS_ERROR_INVALID_ARG = -5, /* Invalid argument */
     LEPTRIS_ERROR_NOT_FOUND = -6,   /* Resource not found */
     LEPTRIS_ERROR_IO = -7,          /* I/O error (file not found, etc.) */
-    LEPTRIS_ERROR_NOT_IMPLEMENTED = -8 /* Feature not yet implemented */
+    LEPTRIS_ERROR_NOT_IMPLEMENTED = -8, /* Feature not yet implemented */
+    LEPTRIS_ERROR_NOT_SUPPORTED = -9    /* Construct outside this API's subset (additive, #1298) */
 } LeptrisStatus;
 
 /* ============================================================================
@@ -342,6 +343,11 @@ typedef struct {
      * Applies to the XML method only — HTML void elements keep
      * their HTML shapes. */
     int expand_empty;
+    /* §16.2 HTML method control (#1309): 0 = document default
+     * (HTML-parsed and create_html documents serialize as HTML),
+     * 1 = force HTML on any document, -1 = force XML (to_xml on an
+     * HTML document). XSLT method="html" maps to 1. */
+    int html_method;
 } LeptrisSerializeExtOptions;
 
 /* ============================================================================

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

@@ -191,9 +191,14 @@ LEPTRIS_API size_t leptris_node_child_count(LeptrisNodeRef node);
  *
  * @param node Subtree root (any node type; NULL hashes to 0)
  * @param flags LEPTRIS_DIGEST_DROP_WS_TEXT skips whitespace-only
- *              text nodes
+ *              text nodes; LEPTRIS_DIGEST_ATTR_ORDER makes attribute
+ *              ORDER identity (no sort)
  * @return 64-bit content digest
- */
+ *
+ * Environment opt-in (#1297): setting LEPTRIS_DIGEST_ATTR_ORDER=1 in
+ * the process environment ORs LEPTRIS_DIGEST_ATTR_ORDER into every
+ * call — the carrier for hosts whose binding exposes no flags
+ * parameter. "0" or an empty value leaves the passed flags alone. */
 LEPTRIS_API uint64_t leptris_node_digest(LeptrisNodeRef node,
                                          LeptrisDigestFlags flags);
 
@@ -773,6 +778,19 @@ LEPTRIS_API const char* leptris_pi_node_get_data(LeptrisNodeRef node);
  */
 LEPTRIS_API LeptrisDocument leptris_document_create(void);
 
+/**
+ * Create an empty HTML-mode document (#1309)
+ *
+ * Identical to leptris_document_create except the document carries
+ * html_mode: the default serializer emits §16.2 HTML output (void
+ * elements unclosed, raw-text script/style, HTML attribute
+ * escaping). Build with the regular element APIs.
+ *
+ * @return New empty HTML document, or NULL on failure
+ * Memory: free with leptris_document_free.
+ */
+LEPTRIS_API LeptrisDocument leptris_document_create_html(void);
+
 /**
  * Attach an element as the document's root element
  *
@@ -2451,6 +2469,35 @@ LEPTRIS_API char* leptris_document_serialize_ext_sized(LeptrisDocument doc,
     const LeptrisSerializeExtOptions* ext,
     size_t ext_size);
 
+/**
+ * Serialize a document with the §16.2 HTML method (#1309)
+ *
+ * Forces the HTML serialization rules (void elements unclosed,
+ * raw-text script/style, HTML attribute escaping) regardless of the
+ * document's mode — the XSLT method="html" semantic, public.
+ * HTML-parsed and create_html documents get this behavior by
+ * default; this entry forces it on any document.
+ *
+ * @param doc Document
+ * @param options Frozen serialize options (NULL = defaults)
+ * @return Serialized HTML string
+ * Memory: Caller must call leptris_free_string() when done.
+ */
+LEPTRIS_API char* leptris_document_serialize_html(
+    LeptrisDocument doc, const LeptrisSerializeOptions* options);
+
+/**
+ * Save a document as HTML to a file (#1309)
+ *
+ * @param doc Document
+ * @param filepath Destination path
+ * @param options Frozen serialize options (NULL = defaults)
+ * @return LEPTRIS_OK (0), or a negative LeptrisStatus on failure
+ */
+LEPTRIS_API int leptris_document_save_html(LeptrisDocument doc,
+                                           const char* filepath,
+                                           const LeptrisSerializeOptions* options);
+
 /**
  * Extended element serialization (issue #882): the same option
  * surface as leptris_document_serialize_ext — indent_text,

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

@@ -224,6 +224,17 @@ static uint64_t digest_element(LeptrisElement e, LeptrisDigestFlags flags) {
 LEPTRIS_API uint64_t leptris_node_digest(LeptrisNodeRef node,
                                          LeptrisDigestFlags flags) {
     if (!node) return 0;
+    /* #1297: process-global opt-in for ATTR_ORDER (#1200 part 1) —
+     * hosts whose binding has no flags carrier (moxml's Node#digest
+     * takes no flags parameter) set LEPTRIS_DIGEST_ATTR_ORDER. Read
+     * per call, same discipline as the LEPTRIS_INTERLEAVED lane
+     * gate; empty string counts as unset (MSVC _putenv_s(k, "")),
+     * "0" disables. ORs with explicitly passed flags. */
+    {
+        const char* env = getenv("LEPTRIS_DIGEST_ATTR_ORDER");
+        if (env && *env && *env != '0')
+            flags = (LeptrisDigestFlags)(flags | LEPTRIS_DIGEST_ATTR_ORDER);
+    }
     LeptrisNode* n = (LeptrisNode*)node;
     switch (n->type) {
         case LEPTRIS_NODE_TYPE_ELEMENT:

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

@@ -0,0 +1,88 @@
+/* lib/src/dom/elem_pos.c — element source-offset side table.
+ *
+ * #1285 slice 3a: start_tag_end_off/element_end_off (#1124) left the
+ * element struct (cold diagnostics-only data was costing hot-path
+ * cache lines). Parse lanes record here instead; the single reader
+ * (node_public.c position accessor) probes. Open addressing,
+ * Fibonacci hash, insert-or-update, power-of-two capacity, freed
+ * with the document. */
+#include "../leptris_internal.h"
+#include "element.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+struct leptris_elem_pos_entry {
+    struct leptris_element* elem;
+    uint32_t start_tag_end;
+    uint32_t element_end;
+};
+
+static size_t elem_pos_hash(const struct leptris_element* e, size_t cap) {
+    uintptr_t k = (uintptr_t)e;
+    return ((size_t)((k * 0x9E3779B97F4A7C15ULL) >> 32)) & (cap - 1);
+}
+
+static void elem_pos_insert_raw(struct leptris_elem_pos_entry* tab,
+                                size_t cap, struct leptris_element* elem,
+                                uint32_t ste, uint32_t ee) {
+    size_t i = elem_pos_hash(elem, cap);
+    while (tab[i].elem && tab[i].elem != elem)
+        i = (i + 1) & (cap - 1);
+    tab[i].elem = elem;
+    tab[i].start_tag_end = ste;
+    tab[i].element_end = ee;
+}
+
+static int elem_pos_grow(struct leptris_document* doc) {
+    size_t ncap = doc->elem_pos_cap ? doc->elem_pos_cap * 2 : 64;
+    struct leptris_elem_pos_entry* nt =
+        (struct leptris_elem_pos_entry*)calloc(ncap, sizeof(*nt));
+    if (!nt) return -1;
+    for (size_t i = 0; i < doc->elem_pos_cap; i++) {
+        struct leptris_elem_pos_entry* e = &doc->elem_pos[i];
+        if (e->elem)
+            elem_pos_insert_raw(nt, ncap, e->elem, e->start_tag_end,
+                                e->element_end);
+    }
+    free(doc->elem_pos);
+    doc->elem_pos = nt;
+    doc->elem_pos_cap = ncap;
+    return 0;
+}
+
+void leptris_elem_pos_record(struct leptris_document* doc,
+                             struct leptris_element* elem,
+                             uint32_t start_tag_end, uint32_t element_end) {
+    if (!doc || !elem) return;
+    if (doc->elem_pos_count * 2 + 2 >= doc->elem_pos_cap) {
+        if (elem_pos_grow(doc) != 0) return;   /* cold data: skip on OOM */
+    }
+    struct leptris_elem_pos_entry* tab = doc->elem_pos;
+    size_t cap = doc->elem_pos_cap;
+    size_t i = elem_pos_hash(elem, cap);
+    while (tab[i].elem && tab[i].elem != elem)
+        i = (i + 1) & (cap - 1);
+    if (!tab[i].elem) {
+        tab[i].elem = elem;
+        doc->elem_pos_count++;
+    }
+    tab[i].start_tag_end = start_tag_end;
+    tab[i].element_end = element_end;
+}
+
+int leptris_elem_pos_lookup(const struct leptris_document* doc,
+                            const struct leptris_element* elem,
+                            uint32_t* start_tag_end, uint32_t* element_end) {
+    if (!doc || !elem || !doc->elem_pos_cap) return 0;
+    size_t i = elem_pos_hash(elem, doc->elem_pos_cap);
+    while (doc->elem_pos[i].elem) {
+        if (doc->elem_pos[i].elem == elem) {
+            if (start_tag_end) *start_tag_end = doc->elem_pos[i].start_tag_end;
+            if (element_end) *element_end = doc->elem_pos[i].element_end;
+            return 1;
+        }
+        i = (i + 1) & (doc->elem_pos_cap - 1);
+    }
+    return 0;
+}

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

@@ -425,7 +425,8 @@ const char* leptris_element_get_name(LeptrisElement elem) {
 void leptris_element_set_namespace_uri_view(LeptrisElement elem, LeptrisStringView uri_view) {
     if (!elem) return;
     if (leptris_sv_is_empty(&uri_view)) {
-        if (elem->ns_cache) elem->ns_cache->namespace_uri = NULL;
+        struct leptris_ns_cache* nsc = elem_get_ns_cache(elem);
+        if (nsc) nsc->namespace_uri = NULL;
         return;
     }
     /* Issue #525: a namespace now exists — unprefixed XPath name