leptris 1.9.285.1-ppc64le-linux → 1.9.290.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e305ee50f7fa5119eb8cf30665f5710954d9165d34bfdc2553456600454246f0
-  data.tar.gz: ce035151452f84bd5bd185765a19daf0ac7318b32bc0db1ce3e3c3b7505547f4
+  metadata.gz: 505fb9e6093b335b955a6c776e97beb0cd43d9e498d8f44333b3faccc93bee26
+  data.tar.gz: 69b07068ad720f0da28fbc713625884621cf067a0fe0134b88bed2eba8549fa5
 SHA512:
-  metadata.gz: 87fb81993e4eaf0f5efbcc52ebf2edcbe01e2c14ae48949e7b6589b7066880e78511ce10ff2e4cbb497016bf3cd68350a826ad26500f1d6fcb2226172ec3985f
-  data.tar.gz: aa5cdd0872af74dfd273b2b85fec1ad2613cf80c14301d3b0a0c275078b1333378b2f8d6e58aed768856cad0119866f50fe871ac0840118fa55bffc75964f28b
+  metadata.gz: aba2088b46d2f97563715259e4a8c8f12fa49f5918a42272f849c64030aad24fa0051449e9f29a0e90c5f7e118be49cc8dc9eae14f4575f4c7552c524715205c
+  data.tar.gz: ea9d90fb9c71b40bcd3692b81d138752a9e4d5aca9943baa6f6a62769f1136773cb0b54e28ed36e0c7ca4a46c7e40b874351f4d76ebdbf227d64611f38502bad

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## [1.9.287.0] - 2026-10-02
+
+### Added
+
+- **Stylesheet top-level params (#360)**: `Stylesheet#apply_to(doc,
+  params: {name => value})` and `#serialize(doc, params: {...})`
+  thread XSLT `<xsl:param>` overrides through the new engine faces
+  (libleptris 1.9.287, leptris#1478): a supplied name binds its
+  string directly and never evaluates select/@default; absent names
+  keep them. Values bind as XPath strings — the caller owns
+  numeric/boolean quoting (nokogiri quote_params conventions for
+  moxml parity). nil/empty params keeps the flagless v1 faces.
+
+### Fixed
+
+- **NativeNode#content on comment nodes (#344)**: the C-side walk
+  accessor now dispatches by node kind — comment and CDATA payloads
+  read through their dedicated engine accessors (comment-kind nodes
+  answered nil while text/CDATA worked); element aggregation and
+  text reads unchanged.
+
+### Engine sync (1.9.287)
+
+- leptris_xslt_apply_params / leptris_xslt_apply_string_params
+  (leptris#1478) — the param overrides ride above.
+
 ## [1.9.285.0] - 2026-10-01
 
 ### Added — streaming Door A opt-outs (libleptris 1.9.283, #1459)

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.285"
+LIBLEPTRIS_VERSION = "1.9.290"
 # 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

@@ -17,7 +17,6 @@
 
 typedef const char *(*elem_name_fn)(void *);
 typedef const char *(*text_content_fn)(void *);
-
 /* Engine node-kind ids (leptris_node_get_type) — hoisted above the
  * read accessors so every dispatch shares one spelling. */
 #define WS_NODE_ELEMENT 0
@@ -330,9 +329,9 @@ static VALUE nn_content(VALUE self)
     if (doc != Qnil && n->content_ver != Qnil &&
         n->content_ver == rb_ivar_get(doc, id_iv_version))
         return n->content_val;
-    /* #344: every kind reads through its own accessor — the old
-     * element-vs-text ternary handed comments and PIs to the text
-     * accessor, which answers NULL for them. */
+    /* every kind through its own accessor (#344): elements
+     * aggregate, text/comment/CDATA/PI carry their payload
+     * directly; unknown kinds answer nil. */
     switch (f_node_type(n->ptr)) {
     case WS_NODE_ELEMENT: s = f_element_text(n->ptr);   break;
     case WS_NODE_TEXT:    s = f_text_content(n->ptr);   break;
@@ -795,6 +794,54 @@ static VALUE nf_append_binding_child(VALUE self, VALUE document,
     return Qtrue;
 }
 
+/* Batch append (leptris-ruby#366): one crossing for N children.
+ * Same gates and provable no-op lift predicate as
+ * nf_append_binding_child; ONE version bump covers the batch (a
+ * failed mutation discards memos either way). Children are passed
+ * as pre-flattened element ADDRESSES (Integer) — the Ruby side
+ * keeps the node objects for the cross-document invalidation
+ * sweep, which is pure Ruby and needs no crossing.
+ *
+ * Returns the index of the first child that needs the Ruby-side
+ * namespace-lift path (source order preserved: the caller runs
+ * the full per-child path from there); n when every child was
+ * appended. Status failures raise at the failing child — earlier
+ * appends stay appended, exactly like the per-child face. */
+static VALUE nf_append_binding_children(VALUE self, VALUE document,
+                                        VALUE parent_addr, VALUE addrs)
+{
+    void *parent;
+    const char *uri;
+    long i, n;
+    int st;
+
+    (void)self;
+    resolve_binding_classes();
+    if (NIL_P(rb_ivar_get(document, id_iv_c_address)))
+        rb_raise(c_use_after_free_error,
+                 "owning document has been freed");
+    if (rb_ivar_get(document, id_iv_readonly) == Qtrue)
+        rb_raise(c_readonly_error,
+                 "document is readonly — mutation attempted");
+    Check_Type(addrs, T_ARRAY);
+    parent = (void *)(uintptr_t)NUM2ULL(parent_addr);
+    n = RARRAY_LEN(addrs);
+    rb_ivar_set(document, id_iv_version,
+                LONG2FIX(FIX2LONG(rb_ivar_get(document, id_iv_version)) + 1));
+    for (i = 0; i < n; i++) {
+        void *child = (void *)(uintptr_t)NUM2ULL(RARRAY_AREF(addrs, i));
+        if (f_node_type(child) == NT_ELEMENT) {
+            if (f_elem_ns_count(child) > 0)
+                return LONG2NUM(i);
+            uri = f_elem_ns(child);
+            if (uri && *uri)
+                return LONG2NUM(i);
+        }
+        st = f_append_child(parent, child);
+        check_status_c(st);
+    }
+    return LONG2NUM(n);
+}
 /* C-bound set_attribute (TODO.perf/11, #204 gap row 0.25x): the
  * gates, the version bump (which drops the version-stamped
  * attribute memos on both surfaces), and the engine write in one
@@ -1984,6 +2031,12 @@ static VALUE nf_fast_element_xml(VALUE self, VALUE addr,
  * construction — the consumer iterates rows and builds their
  * typed objects directly. */
 /* Node kinds (mirror types.h). Documented in descriptor comment. */
+#define WS_NODE_ELEMENT 0
+#define WS_NODE_TEXT 1
+#define WS_NODE_COMMENT 2
+#define WS_NODE_CDATA 3
+#define WS_NODE_PI 4
+#define WS_NODE_DOCTYPE 5
 
 static VALUE build_element_row(VALUE doc, void *elem, int depth)
 {
@@ -3030,6 +3083,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_module_function(m_native, "fast_prefix", nf_prefix, 1);
     rb_define_module_function(m_native, "fast_attribute2", nf_fast_attribute2, 2);
     rb_define_module_function(m_native, "ns_lift_needed?", nf_ns_lift_needed, 1);
+    rb_define_module_function(m_native, "append_binding_children",
+                              nf_append_binding_children, 3);
     rb_define_module_function(m_native, "append_binding_child",
                               nf_append_binding_child, 3);
     rb_define_module_function(m_native, "set_binding_attribute",

data/lib/leptris/version.rb

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

data/lib/leptris/xml/descriptor.rb

@@ -167,6 +167,18 @@ class Leptris::XML::Descriptor
         ap[:wire_name] = anchor_string(anchors, row.fetch(:name))
         ap[:kind] = kind_code(row[:kind] || :scalar)
         ap[:type_tag] = type_tag_code(row)
+        # Attribute-level namespace form (libleptris 1.9.289, #1486):
+        # ns rows match by (URI, local) — the wire prefix is irrelevant.
+        # Mirrors the child-row packing.
+        ap[:ns_form] =
+          case row[:ns]
+          when :any then Leptris::XML::FFI::PLAN_NS_ANY
+          when Hash  then Leptris::XML::FFI::PLAN_NS_EXACT
+          else         Leptris::XML::FFI::PLAN_NS_NONE
+          end
+        ap[:ns_uri] =
+          row[:ns].is_a?(Hash) ?
+            anchor_string(anchors, row[:ns].fetch(:exact)) : nil
         pack_predicates(ap, row, anchors)
       end
       ep[:attribute_count] = attrs.size

data/lib/leptris/xml/element.rb

@@ -490,7 +490,42 @@ class Leptris::XML::Element < Leptris::XML::Node
     # Remove existing children, then attach the new ones in source order.
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_remove_children(c_ptr))
-    Array(node_or_nodes).each { |n| add_child(n) }
+    append_children(Array(node_or_nodes))
+  end
+
+  # Batch append (leptris-ruby#366): one C crossing for N children.
+  # The C loop runs the same gates and provable no-op lift
+  # predicate as the per-child fast path with ONE version bump for
+  # the batch; it stops at the first child needing the Ruby-side
+  # namespace lift (source order preserved — the remainder goes
+  # through the full per-child path). Strings and non-Nodes fall
+  # back to add_child. The cross-document memo invalidation sweep
+  # is pure Ruby and stays on this side.
+  def append_children(nodes)
+    ensure_writable!
+    return if nodes.empty?
+    unless nodes.all? { |n| n.is_a?(Leptris::XML::Node) }
+      nodes.each { |n| add_child(n) }
+      return
+    end
+    if native_fast_children?
+      addrs = nodes.map { |n| n.c_ptr.address }
+      done = Leptris::XML::Native.append_binding_children(
+        @document, @c_address, addrs)
+      done = 0 unless done.is_a?(Integer)
+      if done >= nodes.size
+        nodes.each do |n|
+          Leptris::XML::Node.invalidate_cross_document!(n, @document)
+        end
+        return nodes
+      end
+      nodes[0, done].each do |n|
+        Leptris::XML::Node.invalidate_cross_document!(n, @document)
+      end
+      nodes = nodes[done..]
+    end
+    nodes.each { |n| add_child(n) }
+    nodes
   end
 
   # Replace this element with +new_node+ in the parent's child list.

data/lib/leptris/xml/ffi.rb

@@ -299,7 +299,13 @@ module Leptris
                :type_tag, :uint8,
                :predicate_count, :uint16,
                :pad_pred, :uint16,
-               :predicates, :pointer
+               :predicates, :pointer,
+               # libleptris 1.9.289 (#1486): attribute-level namespace
+               # form — ns rows match by (URI, local), wire_name is the
+               # LOCAL name; NONE keeps wire-name-exact matching.
+               :ns_form, :uint8,
+               :pad_ns, :uint8,
+               :ns_uri, :pointer
       end
       class ChildPlan < ::FFI::Struct
         layout :wire_name, :pointer,
@@ -1272,7 +1278,14 @@ attach_function :leptris_parse_string,
       # apply + serialize in one call, keeping top-level text nodes
       # and result fragments the tree API would flatten.
       attach_function :leptris_xslt_apply_string,
-        [:leptris_xslt, :leptris_document], :pointer
+        [:leptris_xslt, :leptris_document], :pointer      # Top-level xsl:param overrides (#360): flat name/value pairs,
+      # 2*pair_count entries; supplied names skip select/@default.
+      attach_function :leptris_xslt_apply_params,
+        [:leptris_xslt, :leptris_document, :pointer, :size_t],
+        :leptris_document
+      attach_function :leptris_xslt_apply_string_params,
+        [:leptris_xslt, :leptris_document, :pointer, :size_t],
+        :pointer
       attach_function :leptris_c14n_canonicalize,
 
         [:leptris_document, :int, :int], :pointer

data/lib/leptris/xml/xslt.rb

@@ -28,6 +28,9 @@ module Leptris::XML::XSLT
   #                              #    text nodes preserved)
   #
   class Stylesheet
+    FFI_PTR_SIZE = ::FFI.type_size(:pointer)
+    private_constant :FFI_PTR_SIZE
+
     # GC-managed compiled handle.
     class Handle < ::FFI::AutoPointer
       def self.release(ptr)
@@ -65,8 +68,22 @@ module Leptris::XML::XSLT
 
     # Apply to +document+ (not modified) and return the result tree
     # as an owning Document — query it with xpath/css like any other.
-    def apply_to(document)
-      raw = Leptris::XML::FFI.leptris_xslt_apply(@handle, document.c_ptr)
+    #
+    # params (#360): top-level xsl:param overrides as a Hash of
+    # name => value. Values bind as XPath STRINGS verbatim — the
+    # caller owns numeric/boolean quoting (libxslt conventions:
+    # pass '7' for a number, matching nokogiri's quote_params).
+    # Absent names keep the param's select/@default.
+    def apply_to(document, params: nil)
+      raw, buffer, = with_param_pairs(params) do |pairs, count|
+        if pairs
+          Leptris::XML::FFI.leptris_xslt_apply_params(
+            @handle, document.c_ptr, pairs, count)
+        else
+          Leptris::XML::FFI.leptris_xslt_apply(@handle, document.c_ptr)
+        end
+      end
+      buffer&.free
       if raw.null?
         raise Leptris::XML::XPathError,
           "transform failed: #{document.last_error || Leptris::XML::FFI.leptris_last_error}"
@@ -75,11 +92,40 @@ module Leptris::XML::XSLT
     end
 
     # Apply and serialize in one call — keeps top-level text nodes and
-    # result fragments that the tree API would flatten.
-    def serialize(document)
-      str_ptr = Leptris::XML::FFI.leptris_xslt_apply_string(
-        @handle, document.c_ptr)
+    # result fragments that the tree API would flatten. params: as
+    # #apply_to.
+    def serialize(document, params: nil)
+      str_ptr, buffer, = with_param_pairs(params) do |pairs, count|
+        if pairs
+          Leptris::XML::FFI.leptris_xslt_apply_string_params(
+            @handle, document.c_ptr, pairs, count)
+        else
+          Leptris::XML::FFI.leptris_xslt_apply_string(
+            @handle, document.c_ptr)
+        end
+      end
+      buffer&.free
       Leptris::XML::FFI.read_owned_string(str_ptr)
     end
+
+    # Flattens a params Hash into the engine's flat char** pairs
+    # array (borrowed for the C call's lifetime — allocated here,
+    # freed by the caller; the per-string MemoryPointers stay
+    # anchored until the call returns).
+    def with_param_pairs(params)
+      return yield(nil, 0) if params.nil? || params.empty?
+      unless params.is_a?(Hash)
+        raise ArgumentError, "params must be a Hash of name => value"
+      end
+
+      entries = params.keys.map(&:to_s)
+                      .zip(params.values.map { |v| v.nil? ? "" : v.to_s })
+      strings = entries.flatten.map { |s| ::FFI::MemoryPointer.from_string(s) }
+      buffer = ::FFI::MemoryPointer.new(:pointer, strings.size)
+      strings.each_with_index do |ptr, i|
+        buffer.put_pointer(i * FFI_PTR_SIZE, ptr)
+      end
+      [yield(buffer, entries.size), buffer, strings]
+    end
   end
 end

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.285
+- libleptris v1.9.290
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,79 @@
 ## [Unreleased]
 
+## [1.9.290] - 2026-10-02
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Added
+
+- namespace forms for attribute plan rows — `ns_form`/`ns_uri` on `leptris_attr_plan` (#1486)
+  - Extends #1115's child-row pattern to attribute rows: `ns_form = 0` (the zero value) keeps the historical wire-name lookup byte-for-byte and existing aggregate initializers stay valid; `LEPTRIS_PLAN_NS_EXACT` + `ns_uri` makes `wire_name` the LOCAL name and binds the (namespace URI, local) identity through the element's in-scope prefix bindings — prefix-spelling-independent, so a `w14:paraId`-typed row binds whatever prefix the document uses for the Word 2010 URI. `LEPTRIS_PLAN_NS_ANY` matches the local name in any namespace; unprefixed attributes have no namespace and never bind EXACT (XML Namespaces §5.2).
+  - Unlocks the plan fast path for typed-attribute models: lutaml-model's `attr_type_ns` opt-out (one `w14:paraId` leaf cascading the WordprocessingML paragraph chain out of the plan path, against a measured 33% parse-CPU saving) can now emit ns-exact attribute rows instead.
+  - Build deep-copies `ns_uri`, zero-guards the trailing fields for hosts that `malloc` the spec without value-initialization (#1272 lesson), rejects `EXACT` without a URI as `INVALID_ARG`; free releases the copies. RED-first spec plus the full battery (1773/1773). (#1487)
+
+## [1.9.289] - 2026-10-02
+
+### Performance
+
+- open-id compares for the scope/table-context stack walks (#1218 slice 6, tranche 2) (html)
+  - The scope walks (p-in-button-scope, button-in-scope, AFE `kn`), the table-context searches, and the table-context dispatch block compare `b->open_id[k]` integers instead of fetching the element name and running case-insensitive literal chains per stack slot. The AFE furthest-block scan deliberately keeps the name fetch — it runs mid-AFE between stack splices, where the id stack is not yet authoritative (webkit02:14). Interleaved A/B vs the tranche-1 tree: 48.2-53.7 -> 51.0-58.2 MB/s (+11% median) on the 2.6MB table-rows shape. (#1485)
+- id-LUT membership for the foster/formatting/stack checks (#1218 slice 6) (html)
+  - The classifier table grows the 22 compared-but-unlisted names (HTML4 formatting set + MathML/SVG integration points, inert flags); `h_is_formatting` (14-way) and `h_fosterable` (15-way) become id-LUT lookups; 15 insertion-mode stack checks read `open_id[]` directly. 56.1 -> 59.0 MB/s (+5.2%) interleaved. Cumulative slice 6: ~+15% on the issue's fixture shape; the 3.4-7x deficit the issue reported at 1.9.203 is now a 1.3-1.55x LEAD over htmlReadMemory locally. (#1484)
+
+
+
+## [1.9.288] - 2026-10-02
+
+### Fixed
+
+- top-level param values are XPath expressions (libxslt convention) — follow-up to #1478 (xslt)
+  - **Semantics correction to `leptris_xslt_apply_params` / `leptris_xslt_apply_string_params`, released briefly in 1.9.287:** value strings are now evaluated as XPath EXPRESSIONS (libxslt `params` convention; nokogiri's `quote_params` exists for exactly this), not bound as raw strings. Callers pass quoted literals — `{"n", "'7'"}` binds the string `7`; under 1.9.287 the quotes were part of the value. Numbers and source-derived expressions work (`7 * 6` → 42, `string(/r/@v)`), a later pair may reference an earlier one, a global `xsl:variable` may consume a caller value (§11 ordering), undeclared names bind into scope (libxslt parity), and a malformed expression fails the transform. Caller values bind before the globals run and a declared `xsl:param` default whose name a caller supplied never evaluates (§11.4). Specs ported from #1478 plus three RED-first expression cases; 1771/1771 and an external-consumer end-to-end probe. (#1481)
+
+
+
+## [1.9.287] - 2026-10-02
+
+### Added
+
+- top-level param overrides — leptris_xslt_apply_params / _apply_string_params (leptris-ruby#360) (xslt)
+
+### Performance
+
+- fused attr-loop dispatch on the shared chartype table (#1436) (parser)
+
+
+
+## [1.9.286] - 2026-10-02
+
+### Added
+
+- top-level param overrides — leptris_xslt_apply_params / _apply_string_params (leptris-ruby#360) (xslt)
+
+### Performance
+
+- fused attr-loop dispatch on the shared chartype table (#1436) (parser)
+
+
+
+## [1.9.286] - 2026-10-01
+
+### Fixed
+
+- Door A skip flags must survive recorder reset and be accepted by sax_records (sax)
+  - `leptris_sax_recorder_reset()` rebuilt the parser without the creation-time `LEPTRIS_PARSE_SKIP_DUP_DETECTION` / `LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS` bits, silently re-enabling both probes mid-stream: record counts diverged between the first pass and post-reset passes on the same document. The recorder now stores its flags and re-applies them on reset.
+  - `leptris_sax_records_parse()` rejected every nonzero flag, so the bulk-records lane could not opt out of either probe. The two Door A bits are now accepted (no-ops on the interleaved lane, which carries neither probe); unknown bits still return `LEPTRIS_ERROR_INVALID_ARG`.
+  - Regression specs: `Recorder.DoorAFlagsSurviveReset`, `SaxRecords.DoorAFlagsAccepted`. (#1472)
+
+### Changed
+
+- element name stored as a self-relative int32 offset — `struct leptris_element` 48 → 44 bytes (#1285)
+  - The `char* name` was the struct's last 8-aligned member; replacing it with the tree-edge offset encoding drops the struct alignment to 4 and reclaims the tail padding.
+  - The dp parse lane packs element arrays at true size: peak RSS on a 15 MB / 400k-element document drops 253 → 239 MB (-5.4%) with parse and serialize times flat. Pool-allocated elements keep their stride (`LEPTRIS_POOL_ALIGNMENT` rounds up); ILP32 layouts are unchanged.
+  - Mutation/public-creator name stamps use the doc-tagged compact encoder (#1320 pattern) so far-mut-block spills register with the correct document. New specs: `ElementNameOffsetRoundTrip` plus a hard 44-byte size pin.
+
+
+
 ## [1.9.285] - 2026-10-01
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -95,6 +95,18 @@ typedef struct {
     uint16_t predicate_count;
     uint16_t pad_pred;
     const leptris_attr_predicate* predicates;
+    /* #1486 (additive trailing fields, the #1115 child-row
+     * pattern): attribute-level namespace form. A row with
+     * ns_form set matches by (namespace URI, local name) —
+     * wire_name is the LOCAL name and the prefix spelling on the
+     * wire is irrelevant. NONE (0, the zero value) keeps the
+     * historical behavior: lookup by wire_name exactly as it
+     * appears on the wire (prefixed or bare). Unprefixed
+     * attributes have no namespace; EXACT requires a prefixed
+     * attribute whose prefix binds to ns_uri. */
+    uint8_t ns_form;       /* LeptrisPlanNsForm */
+    uint8_t pad_ns;
+    const char* ns_uri;    /* LEPTRIS_PLAN_NS_EXACT only */
 } leptris_attr_plan;
 
 typedef struct {

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

@@ -3096,7 +3096,6 @@ LEPTRIS_API void leptris_xslt_free(LeptrisXslt xslt);
  */
 LEPTRIS_API LeptrisDocument leptris_xslt_apply(LeptrisXslt xslt,
                                                 LeptrisDocument doc);
-
 /**
  * Apply a compiled stylesheet and serialize the result
  *
@@ -3111,6 +3110,50 @@ LEPTRIS_API LeptrisDocument leptris_xslt_apply(LeptrisXslt xslt,
 LEPTRIS_API char* leptris_xslt_apply_string(LeptrisXslt xslt,
                                              LeptrisDocument doc);
 
+/**
+ * Apply a compiled stylesheet with caller-supplied top-level params
+ *
+ * Binds the given xsl:param values BEFORE the stylesheet's globals
+ * run (XSLT §11.4): a caller value replaces the declared default,
+ * unspecified params keep their defaults, and the value expressions
+ * may reference the source document and earlier pairs.
+ *
+ * pairs is a flat name/value array — [name0, value0, name1,
+ * value1, ...] — and count is the number of PAIRS (the array holds
+ * 2*count entries). Each value is an XPath EXPRESSION evaluated
+ * with the source document node as context; callers pre-quote
+ * string literals ("'text'"), matching the libxslt convention.
+ *
+ * @param xslt Compiled stylesheet
+ * @param doc Source document (not modified)
+ * @param pairs Flat name/expression array, or NULL with count 0
+ * @param count Number of name/expression pairs
+ * @return Result tree (free with leptris_document_free), or NULL on
+ *         error — including a value expression that fails to
+ *         compile (message via leptris_document_last_error)
+ */
+LEPTRIS_API LeptrisDocument leptris_xslt_apply_params(
+    LeptrisXslt xslt, LeptrisDocument doc,
+    const char* const* pairs, size_t count);
+
+/**
+ * Apply with caller-supplied top-level params and serialize
+ *
+ * leptris_xslt_apply_params + the leptris_xslt_apply_string
+ * serialization contract (top-level text nodes and fragments
+ * preserved).
+ *
+ * @param xslt Compiled stylesheet
+ * @param doc Source document
+ * @param pairs Flat name/expression array (see
+ *        leptris_xslt_apply_params), or NULL with count 0
+ * @param count Number of name/expression pairs
+ * @return Serialized result (free with leptris_free_string), or NULL
+ */
+LEPTRIS_API char* leptris_xslt_apply_string_params(
+    LeptrisXslt xslt, LeptrisDocument doc,
+    const char* const* pairs, size_t count);
+
 /**
  * Custom XPath function handler (string-valued).
  *

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

@@ -51,6 +51,10 @@ const uint8_t leptris_chartype_table[256] = {
     ['-']=CT_NAME, ['.']=CT_NAME,
     /* Whitespace */
     [' ']=CT_WS, ['\t']=CT_WS, ['\n']=CT_WS, ['\r']=CT_WS,
+    /* Attr-loop delimiters (#1436 fused scanner; see chartype.h) */
+    ['>']=CT_ATTR_GT, ['/']=CT_ATTR_SLASH,
+    ['=']=CT_ATTR_EQ,
+    ['"']=CT_ATTR_QUOTE, ['\'']=CT_ATTR_QUOTE,
     /* UTF-8 multibyte lead and continuation bytes — every byte
      * >= 0x80 is CT_UTF8 (lenient name scanning, <café>). */
 #define CT_U8(n) [n]=CT_UTF8

data/vendor-src/libleptris/src/leptris/common/chartype.h

@@ -24,6 +24,16 @@
                               * Matches flat_parser's lenient UTF-8
                               * fallback (c >= 0xC0 for start, c >= 0x80
                               * for continuation). */
+/* Attr-loop delimiter bits (#1436 fused scanner). The open-tag/
+ * attribute loop dispatches on ONE table load: the whitespace skip
+ * itself yields the stop byte's class — tag close, self-close, '=',
+ * or the value quote (pugixml ct_parse_attr's combined-mask shape).
+ * These five bytes carry none of the flags above, so every existing
+ * mask is unaffected. */
+#define CT_ATTR_GT     0x10  /* '>' — end of the open tag */
+#define CT_ATTR_SLASH  0x20  /* '/' — self-close (with '>' lookahead) */
+#define CT_ATTR_EQ     0x40  /* '=' — name/value separator */
+#define CT_ATTR_QUOTE  0x80  /* '"', '\'' — value delimiters */
 
 /* The shared table. Defined once in chartype.c — fully static and
  * const, including the CT_UTF8 entries for bytes >= 0x80 (no

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

@@ -246,6 +246,7 @@ static void dp_plan_free(LeptrisPlan p) {
         dp_plan* d = &p->plans[i];
         for (uint32_t a = 0; a < d->attribute_count; a++) {
             free((char *)d->attribute_plans[a].wire_name);
+            free((char *)d->attribute_plans[a].ns_uri);
             for (uint16_t pi = 0;
                  pi < d->attribute_plans[a].predicate_count; pi++) {
                 free((char*)d->attribute_plans[a]
@@ -332,6 +333,32 @@ LEPTRIS_API LeptrisPlan leptris_plan_build(const leptris_plan_spec* spec,
                     d->attribute_plans[a].predicate_count = 0;
                     d->attribute_plans[a].pad_pred = 0;
                 }
+                /* #1486 additive-ABI guard (the #1272 lesson): a
+                 * host that mallocs the spec leaves the trailing
+                 * ns fields garbage — normalize unset forms so the
+                 * walker never reads a garbage pointer, and deep-
+                 * copy EXACT uris. EXACT without a uri cannot
+                 * express an identity: reject the spec. */
+                if (!s->attribute_plans[a].ns_form) {
+                    d->attribute_plans[a].ns_form = 0;
+                    d->attribute_plans[a].pad_ns = 0;
+                    d->attribute_plans[a].ns_uri = NULL;
+                } else {
+                    d->attribute_plans[a].pad_ns = 0;
+                    if (s->attribute_plans[a].ns_form ==
+                            LEPTRIS_PLAN_NS_EXACT) {
+                        if (!s->attribute_plans[a].ns_uri) {
+                            if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+                            dp_plan_free(p);
+                            return NULL;
+                        }
+                        d->attribute_plans[a].ns_uri =
+                            dp_strdup(s->attribute_plans[a].ns_uri);
+                        if (!d->attribute_plans[a].ns_uri) goto oom;
+                    } else {
+                        d->attribute_plans[a].ns_uri = NULL;
+                    }
+                }
                 if (s->attribute_plans[a].wire_name) {
                     d->attribute_plans[a].wire_name =
                         dp_strdup(s->attribute_plans[a].wire_name);
@@ -491,6 +518,50 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                             const LeptrisPlan pool,
                             struct leptris_plan_result* out);
 
+/* #1486 attribute-row binding. ns_form 0 = the historical
+ * wire-name lookup (the string exactly as it appears on the
+ * wire). A set form matches (namespace, local): the row's
+ * wire_name is the LOCAL name; each attribute's prefix resolves
+ * through the ELEMENT's in-scope bindings, so the identity holds
+ * across prefix spellings. Unprefixed attributes have no
+ * namespace (XML namespaces §5.2) — EXACT never binds them. */
+static const char* dp_attr_value(LeptrisElement elem,
+                                 const leptris_attr_plan* ap) {
+    if (!ap->ns_form)
+        return leptris_element_attribute(elem, ap->wire_name);
+    for (LeptrisAttribute at = leptris_element_first_attribute(elem);
+         at; at = leptris_attribute_next(at)) {
+        const char* qn = leptris_attribute_get_name(at);
+        if (!qn) continue;
+        const char* colon = strchr(qn, ':');
+        const char* local = colon ? colon + 1 : qn;
+        if (strcmp(local, ap->wire_name) != 0) continue;
+        const char* uri = NULL;
+        if (colon) {
+            char prefix[128];
+            size_t plen = (size_t)(colon - qn);
+            if (plen >= sizeof(prefix)) continue;
+            memcpy(prefix, qn, plen);
+            prefix[plen] = 0;
+            uri = leptris_element_namespace_for_prefix(elem, prefix);
+        }
+        switch (ap->ns_form) {
+            case LEPTRIS_PLAN_NS_NONE:
+                if (uri) continue;
+                break;
+            case LEPTRIS_PLAN_NS_EXACT:
+                if (!uri || !ap->ns_uri ||
+                    strcmp(uri, ap->ns_uri) != 0)
+                    continue;
+                break;
+            default: /* ANY */
+                break;
+        }
+        return leptris_attribute_get_value(elem, at);
+    }
+    return NULL;
+}
+
 static struct leptris_plan_result* dp_walk_element(LeptrisElement elem,
                                                    const dp_plan* plan,
                                                    const LeptrisPlan pool) {
@@ -510,7 +581,7 @@ static struct leptris_plan_result* dp_walk_element(LeptrisElement elem,
         for (uint32_t a = 0; a < plan->attribute_count; a++) {
             const leptris_attr_plan* ap = &plan->attribute_plans[a];
             if (!ap->wire_name) continue;
-            const char* val = leptris_element_attribute(elem, ap->wire_name);
+            const char* val = dp_attr_value(elem, ap);
             if (!val) continue;
             v->attr_names[v->attr_count] = dp_strdup(ap->wire_name);
             v->attr_values[v->attr_count] = dp_strdup(val);