leptris 1.9.222.2-arm-linux → 1.9.225.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2da4a19cbca71331b31eb5eacc93924035fc1f4051bde8361b127c318354cb63
-  data.tar.gz: c794ac2ce4219f5b97ea0264b766c6e2caa9fb7acf35a3254eaa4bc62744ae35
+  metadata.gz: 3ddb9c850703c6cc75a0d22649d3065ed7535d15e3b0b66db6a7aa8af4d73286
+  data.tar.gz: bcf50f7e810b2caa0405f5e9e0043f4682e50c7bf7c03897a74c8731caf05c6a
 SHA512:
-  metadata.gz: 7a7acc7d9a8828a9d4bf441240bfb0312f464e5e3556c554af119a91626373babd03fa9ab7087433936f6fdd2a0c0c648c9dd1f4d8507ef5a8b72abc36c9530a
-  data.tar.gz: 24a2ba0806bd7fcc23dfac774b6c90c6ff9ef93082140421070fc4210abde3835c4133615726a37efda58753ae678c8760b74932cdb0bbd068479727de6c1b85
+  metadata.gz: 7c463cf68fb31d8ab1a1b02ec65a15190008d27700326f0b30698268a97fca76176516ef9e5f92a891b24f92b607a6c10d6a8a764e122151c976f1fc54e737ec
+  data.tar.gz: cb509afb2b2be7edcdf3502289865febbc607a938e07ce35a1449a047c71240c4c587fe8e6150051bbba6f271526205be0681ea2a14b8ff32f1e7437b98320fa

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/ext/leptris/native/native.c

@@ -135,6 +135,9 @@ static VALUE c_iteration_scope;
 static VALUE c_leptris_error;
 static VALUE c_b_document, c_b_freed, c_ffi_pointer;
 static ID id_ptr_new, id_freed_new, id_alive;
+static ID id_iv_c_address, id_iv_document, id_iv_parent;
+static ID id_iv_structure_memoizable, id_iv_native_fast;
+static ID id_iv_pub_document, id_iv_addr_reads_fast, id_iv_node_type;
 static void check_status_c(int st);
 
 #define NT_ELEMENT 0
@@ -839,8 +842,38 @@ struct trav_state {
     VALUE err;
     void *self_ptr;
     int for_visit;
+    /* Hoisted per-walk state (was re-resolved per node): the
+     * document's wrapper cache and the iteration-scope class
+     * check. #312 item 1. */
+    VALUE cache;
+    VALUE klass_memo_flag;
 };
 
+/* Construct-or-fetch the binding wrapper for node_ptr against the
+ * per-walk hoisted cache (#312 item 1): static-ID ivar writes (no
+ * per-call string interning), the scope class check precomputed. */
+static VALUE trav_wrapper_for(struct trav_state *st, void *node_ptr,
+                              int kind)
+{
+    VALUE key = ULL2NUM((uint64_t)(uintptr_t)node_ptr);
+    VALUE node = rb_hash_aref(st->cache, key);
+    if (!NIL_P(node)) return node;
+
+    node = rb_obj_alloc(binding_klass_for(kind));
+    rb_ivar_set(node, id_iv_c_address, key);
+    rb_ivar_set(node, id_iv_document, st->document);
+    rb_ivar_set(node, id_iv_parent, Qnil);
+    VALUE fast = st->klass_memo_flag;
+    rb_ivar_set(node, id_iv_structure_memoizable, fast);
+    rb_ivar_set(node, id_iv_native_fast, fast);
+    rb_ivar_set(node, id_iv_pub_document,
+                fast == Qtrue ? st->document : Qnil);
+    rb_ivar_set(node, id_iv_addr_reads_fast, Qtrue);
+    rb_ivar_set(node, id_iv_node_type, INT2FIX(kind));
+    rb_hash_aset(st->cache, key, node);
+    return node;
+}
+
 static VALUE trav_yield_one(VALUE arg)
 {
     return rb_yield(arg);
@@ -849,33 +882,13 @@ static VALUE trav_yield_one(VALUE arg)
 static int trav_cb(void *node_ptr, void *user)
 {
     struct trav_state *st = user;
-    VALUE cache, key, node;
+    VALUE node;
     int kind, state;
 
     if (st->err != Qnil)
         return 1;
     kind = f_node_type(node_ptr);
-    cache = binding_cache_of(st->document);
-    key = ULL2NUM((uint64_t)(uintptr_t)node_ptr);
-    node = rb_hash_aref(cache, key);
-    if (NIL_P(node)) {
-        node = rb_obj_alloc(binding_klass_for(kind));
-        rb_iv_set(node, "@c_address", key);
-        rb_iv_set(node, "@document", st->document);
-        rb_iv_set(node, "@parent", Qnil);
-        if (rb_obj_class(st->document) == c_iteration_scope) {
-            rb_iv_set(node, "@structure_memoizable", Qfalse);
-            rb_iv_set(node, "@native_fast", Qfalse);
-            rb_iv_set(node, "@pub_document", Qnil);
-        } else {
-            rb_iv_set(node, "@structure_memoizable", Qtrue);
-            rb_iv_set(node, "@native_fast", Qtrue);
-            rb_iv_set(node, "@pub_document", st->document);
-        }
-        rb_iv_set(node, "@addr_reads_fast", Qtrue);
-        rb_iv_set(node, "@node_type", INT2FIX(kind));
-        rb_hash_aset(cache, key, node);
-    }
+    node = trav_wrapper_for(st, node_ptr, kind);
     rb_protect(trav_yield_one, node, &state);
     if (state) {
         st->err = rb_errinfo();
@@ -894,6 +907,9 @@ static VALUE nf_traverse_binding(VALUE self, VALUE document,
     st.document = document;
     st.err = Qnil;
     st.self_ptr = (void *)(uintptr_t)NUM2ULL(addr);
+    st.cache = binding_cache_of(document);
+    st.klass_memo_flag =
+        rb_obj_class(document) == c_iteration_scope ? Qfalse : Qtrue;
     st.for_visit = 0;
     f_node_traverse(st.self_ptr, 1 /* TRAVERSE_POST_ORDER */,
                     trav_cb, &st);
@@ -922,33 +938,13 @@ static void visit_cb(void *user, void *node_ptr, int entering,
      * happens after the walk, same observable outcome. */
     struct trav_state *st = user;
     struct visit_yield_args va;
-    VALUE cache, key, node;
+    VALUE node;
     int kind, state;
 
     if (st->err != Qnil)
         return;
     kind = f_node_type(node_ptr);
-    cache = binding_cache_of(st->document);
-    key = ULL2NUM((uint64_t)(uintptr_t)node_ptr);
-    node = rb_hash_aref(cache, key);
-    if (NIL_P(node)) {
-        node = rb_obj_alloc(binding_klass_for(kind));
-        rb_iv_set(node, "@c_address", key);
-        rb_iv_set(node, "@document", st->document);
-        rb_iv_set(node, "@parent", Qnil);
-        if (rb_obj_class(st->document) == c_iteration_scope) {
-            rb_iv_set(node, "@structure_memoizable", Qfalse);
-            rb_iv_set(node, "@native_fast", Qfalse);
-            rb_iv_set(node, "@pub_document", Qnil);
-        } else {
-            rb_iv_set(node, "@structure_memoizable", Qtrue);
-            rb_iv_set(node, "@native_fast", Qtrue);
-            rb_iv_set(node, "@pub_document", st->document);
-        }
-        rb_iv_set(node, "@addr_reads_fast", Qtrue);
-        rb_iv_set(node, "@node_type", INT2FIX(kind));
-        rb_hash_aset(cache, key, node);
-    }
+    node = trav_wrapper_for(st, node_ptr, kind);
     va.node = node;
     va.entering = entering ? Qtrue : Qfalse;
     va.depth = INT2NUM(depth);
@@ -966,6 +962,9 @@ static VALUE nf_visit_binding(VALUE self, VALUE document, VALUE addr)
     st.document = document;
     st.err = Qnil;
     st.self_ptr = (void *)(uintptr_t)NUM2ULL(addr);
+    st.cache = binding_cache_of(document);
+    st.klass_memo_flag =
+        rb_obj_class(document) == c_iteration_scope ? Qfalse : Qtrue;
     st.for_visit = 1;
     f_node_visit(st.self_ptr, visit_cb, &st);
     if (st.err != Qnil)
@@ -2648,6 +2647,14 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     id_iv_c_address = rb_intern("@c_address");
     id_iv_native_cache = rb_intern("@native_cache");
     id_iv_binding_cache = rb_intern("@wrapper_cache");
+    id_iv_c_address = rb_intern("@c_address");
+    id_iv_document = rb_intern("@document");
+    id_iv_parent = rb_intern("@parent");
+    id_iv_structure_memoizable = rb_intern("@structure_memoizable");
+    id_iv_native_fast = rb_intern("@native_fast");
+    id_iv_pub_document = rb_intern("@pub_document");
+    id_iv_addr_reads_fast = rb_intern("@addr_reads_fast");
+    id_iv_node_type = rb_intern("@node_type");
     id_iv_version = rb_intern("@version");
     id_iv_readonly = rb_intern("@readonly");
     id_address = rb_intern("address");

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.222.2"
+  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,