leptris 1.9.311.3-ppc64le-linux → 1.9.312.1-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffe8f4a4632aa5c0433127b27a2fe02fd9f6e662f50ea2e0302eb639c01a3823
-  data.tar.gz: 59459801b12745b0c4260fcad1c9343bfa1c72e474c280617b0fc3395af7035c
+  metadata.gz: 8be66f684edb1d18e35ab05b6926becf591022c5c776c8fb27c2bf7fb9c6578c
+  data.tar.gz: caf2d6f092fcc16dfe7931b8372fea55f244186a512612552f2bac89435e320c
 SHA512:
-  metadata.gz: cc5d3214f664abfb6a43efe6b646d4b5b46bbde230aca662e5c1d87781c7990d0c82147f4ce3ade2eca4fa3da05ee78ae2ccab939c88f80bc8fe79de03243369
-  data.tar.gz: 731ed271acf74deb3c25f09cb70825ad7aed0f6178c73de1edb9c0a8576ddaf689cadb4e627bd792d1c3ca621f930023483a043df31f205905655de28f044ad3
+  metadata.gz: be6b60f3574628511bc8b304865be8462b0ba8b1089333e507fe28f1806b7fda751877fd8fa2e263dc0755dec5c37f2bc4305660988d90aa99b8c02d713077c6
+  data.tar.gz: 2ca1422057b28d7cfbeb8422f5ab7ec35047d07dca0fe5ae8098358984e80c80486c1bc3ffb489e8a91fce2625dcbf54611feb0f3a552cc6ef637e166ded9684

data/CHANGELOG.md

@@ -1,3 +1,52 @@
+## [1.9.312.1] - 2026-10-07
+
+### Added
+
+- **Document#build / Element#build — the builder face (#374 lever
+  2)**: markup-accumulating construction. The block turns into
+  well-formed markup in Ruby (method_missing element dispatch
+  with attrs/text, `#text`/`#cdata`/`#comment`/`#raw`, one-pass
+  escaping of `& < > "`), and the flush performs ONE native
+  crossing for the whole subtree — parse + `root=` adoption for
+  document sinks (exactly one root, the parser enforces it;
+  returns the installed root wrapper), `append_markup` for
+  element sinks (returns the added NodeSet). Measured DSL-vs-DSL
+  under load (interleaved CPU-time medians, build(500)):
+  leptris builder 2.68 ms vs nokogiri's builder 5.29 ms —
+  **~2.0x** — and ~1.2x over our own object face (3.19 ms,
+  itself ~1.7x nokogiri after the 1.9.311.3 trim).
+
+## [1.9.312.0] - 2026-10-07
+
+### Added — engine sync (libleptris 1.9.312)
+
+- **Descriptor#serialize — plan-guided serialization (#1551)**:
+  `leptris_plan_serialize` round-trips a walk result back to XML —
+  the plan supplies element wrappers (row wire_name + the new
+  `ns_prefix:` field on element/child/attr rows), the result the
+  content. Children emit in document order; rows with ns EXACT +
+  `ns_prefix:` emit prefixed names and every distinct (prefix,
+  uri) pair is declared exactly once, on the output root, in
+  first-encounter order; text/attr values escape; RAW members are
+  verbatim. The three plan structs take the additive trailing
+  `ns_prefix` field (attr row 40 → 48B; the row-size skew gate
+  holds). `PlanValue#result_ptr` exposes the whole-result handle
+  the face reads.
+- **Wildcard child rows (#1552)**: `kind: :wildcard` binds every
+  element child no named sibling row bound — named rows win
+  regardless of row order; the row emits exactly one COLLECTION
+  (echoing wire_name/type_tag, even when empty); members keep
+  document order; an explicit `ns:` filters the remainder
+  (`ns: :none` binds no-namespace children alone; unset stays the
+  catch-all ANY default). PLAN_KIND_WILDCARD = 7.
+
+### Fixed — engine sync (1.9.312)
+
+- **Root-level leaf splices adopt single-node (#1539)**: a leaf
+  directly on a scratch document's children chain (prolog
+  comment / PI) no longer reports LEPTRIS_ERROR_MEMORY on
+  cross-document append — spec-pinned in the adoption suite.
+
 ## [1.9.311.3] - 2026-10-06
 
 ### Performance

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.311"
+LIBLEPTRIS_VERSION = "1.9.312"
 # 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.311.3"
+  VERSION = "1.9.312.1"
 end

data/lib/leptris/xml/builder.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# Markup-accumulating subtree construction (#374 lever 2): the
+# builder turns a Ruby block into well-formed markup in a plain
+# String (Ruby-side cost only), and the flush performs ONE native
+# crossing — parse + attach — for the whole subtree. The
+# per-element FFI crossing that dominated the object-face build
+# profile collapses to one per #build call.
+#
+#     doc.build do |b|
+#       b.catalog(id: "c") do
+#         b.item(id: 7) { b.name "Item 7" }
+#       end
+#     end
+#
+# Element names arriving through method_missing are identifier-
+# shaped by construction (Ruby method names cannot carry markup
+# metacharacters); the explicit #element path checks NAME_RE.
+# Text and attribute values escape in one pass per string.
+class Leptris::XML::Builder
+  NAME_RE = /\A[a-zA-Z_][\w.-]*\z/
+
+  ESCAPE = {
+    "&" => "&",
+    "<" => "&lt;",
+    ">" => "&gt;",
+    '"' => "&quot;",
+  }.freeze
+  ESCAPE_RE = /[&<>"]/
+  private_constant :ESCAPE, :ESCAPE_RE
+
+  # +sink+ receives the flushed markup (a Document or Element).
+  def initialize(sink)
+    @sink = sink
+    @buf = +""
+    @depth = 0
+  end
+
+  def element(name, attributes = nil)
+    name = name.to_s
+    unless name =~ NAME_RE
+      raise ArgumentError,
+        "element name must match #{NAME_RE.inspect}, got #{name.inspect}"
+    end
+    @buf << "<" << name
+    write_attributes(attributes) if attributes
+    if block_given?
+      @buf << ">"
+      @depth += 1
+      begin
+        yield self
+      ensure
+        @depth -= 1
+      end
+      @buf << "</" << name << ">"
+    else
+      @buf << "/>"
+    end
+    self
+  end
+
+  def text(content)
+    @buf << escape_text(content.to_s)
+    self
+  end
+
+  def cdata(content)
+    @buf << "<![CDATA[" << content.to_s << "]]>"
+    self
+  end
+
+  def comment(content)
+    @buf << "<!--" << escape_text(content.to_s) << "-->"
+    self
+  end
+
+  # Verbatim markup — the escape hatch for pre-serialized
+  # fragments; the caller owns well-formedness.
+  def raw(markup)
+    @buf << markup.to_s
+    self
+  end
+
+  def method_missing(name, *args, &block)
+    # Method names are identifier-shaped: they cannot carry <, >,
+    # &, quotes, or whitespace, so they need no NAME_RE round-trip
+    # (trailing = / ? / ! are legal Ruby but never legal XML
+    # name tails here — reject them explicitly).
+    return super if name.to_s.end_with?("=", "?", "!")
+    case args.length
+    when 0
+      element(name.to_s, &block)
+    when 1
+      arg = args[0]
+      if arg.is_a?(Hash)
+        element(name.to_s, arg, &block)
+      else
+        element(name.to_s) { |b| b.text(arg); block&.call(b) }
+      end
+    when 2
+      attrs, txt = args
+      return super unless attrs.is_a?(Hash)
+      element(name.to_s, attrs) { |b| b.text(txt); block&.call(b) }
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    !name.to_s.end_with?("=", "?", "!") || super
+  end
+
+  # One native crossing for the accumulated subtree: the flush
+  # parses + attaches. Document sinks take exactly one root
+  # (set_root_ex adopts the parsed root); element sinks append
+  # every fragment child.
+  def flush
+    unless @depth.zero?
+      raise Leptris::XML::Error,
+        "unbalanced builder — unclosed elements remain (depth #{@depth})"
+    end
+    markup = @buf
+    return @sink if markup.empty?
+    case @sink
+    when Leptris::XML::Document
+      parsed = Leptris::XML::Document.parse(markup)
+      root = parsed.root
+      if root.nil?
+        raise Leptris::XML::Error,
+          "builder markup produced no root element"
+      end
+      @sink.root = root
+      @buf = +""
+      # The INSTALLED root — the same wrapper #root now yields
+      # (root= returns the parsed source, not the adoption copy).
+      @sink.root
+    when Leptris::XML::Element
+      added = @sink.add_child(markup)
+      @buf = +""
+      added
+    else
+      raise ArgumentError,
+        "builder sink must be a Document or Element, got #{@sink.class}"
+    end
+  end
+
+  private
+
+  def write_attributes(attributes)
+    case attributes
+    when Hash
+      attributes.each do |k, v|
+        @buf << " " << k.to_s << '="' << escape_attr(v) << '"'
+      end
+    when nil then # nothing
+    else
+      raise ArgumentError,
+        "attributes must be a Hash, got #{attributes.class}"
+    end
+  end
+
+  def escape_text(value)
+    value.gsub(ESCAPE_RE, ESCAPE)
+  end
+
+  def escape_attr(value)
+    value.to_s.gsub(ESCAPE_RE, ESCAPE)
+  end
+end

data/lib/leptris/xml/descriptor.rb

@@ -74,6 +74,12 @@ class Leptris::XML::Descriptor
     raw: Leptris::XML::FFI::PLAN_KIND_RAW,
     content: Leptris::XML::FFI::PLAN_KIND_CONTENT,
     callback: Leptris::XML::FFI::PLAN_KIND_CALLBACK,
+    # libleptris 1.9.312 (#1552): the remainder bucket — binds
+    # every element child no named sibling row bound. Emits one
+    # COLLECTION (even when empty); named rows win regardless of
+    # row order. child_plan_index >= 0 walks members through that
+    # plan; -1 (the default) emits RAW serialized subtrees.
+    wildcard: Leptris::XML::FFI::PLAN_KIND_WILDCARD,
   }.freeze
   private_constant :KINDS
 
@@ -177,6 +183,10 @@ class Leptris::XML::Descriptor
         end
       ep[:ns_form] = ns_form
       ep[:ns_uri] = ns_uri
+      # libleptris 1.9.312 (#1551): the root plan's serialization
+      # prefix (ns_form EXACT rows emit "prefix:local" and the
+      # xmlns declaration lands once on the output root).
+      ep[:ns_prefix] = anchor_string(anchors, plan[:ns_prefix]) if plan[:ns_prefix]
       attrs = plan[:attributes] || []
       attr_memory = attrs.empty? ? nil :
         ::FFI::MemoryPointer.new(Leptris::XML::FFI::AttrPlan, attrs.size)
@@ -198,6 +208,9 @@ class Leptris::XML::Descriptor
         ap[:ns_uri] =
           row[:ns].is_a?(Hash) ?
             anchor_string(anchors, row[:ns].fetch(:exact)) : nil
+        # libleptris 1.9.312 (#1551): serialization prefix — with
+        # ns_form EXACT the attribute emits as "prefix:local".
+        ap[:ns_prefix] = anchor_string(anchors, row[:ns_prefix]) if row[:ns_prefix]
         pack_predicates(ap, row, anchors)
       end
       ep[:attribute_count] = attrs.size
@@ -214,16 +227,24 @@ class Leptris::XML::Descriptor
         cp[:child_plan_index] = row[:child_plan_index] || -1
         # Rule-level ns form (libleptris 1.9.178, #1115): siblings
         # under one parent can require different URIs when set;
-        # defaults to NONE for backward compatibility.
+        # defaults to NONE for backward compatibility. WILDCARD
+        # rows (#1552) read an explicit :ns through pad0 (an
+        # explicit :none filters no-namespace remainder alone;
+        # unset stays the catch-all ANY default).
         cp[: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
+        cp[:pad0] = 1 if row[:kind] == :wildcard && row.key?(:ns)
         cp[:ns_uri] =
           row[:ns].is_a?(Hash) ?
             anchor_string(anchors, row[:ns].fetch(:exact)) : nil
+        # libleptris 1.9.312 (#1551): serialization prefix — with
+        # ns_form EXACT the element emits as "prefix:local" and
+        # its declaration lands once on the output root.
+        cp[:ns_prefix] = anchor_string(anchors, row[:ns_prefix]) if row[:ns_prefix]
         pack_predicates(cp, row, anchors)
       end
       ep[:child_count] = children.size
@@ -318,6 +339,26 @@ class Leptris::XML::Descriptor
                                 owner: true, plans: @plans, plan: @plans[0])
   end
 
+  # libleptris 1.9.312 (#1551): serialize a walk result back to
+  # XML guided by this plan — the plan supplies element wrappers
+  # (row wire_name + ns_prefix), the result the content; children
+  # emit in document order. Rows with ns_form EXACT + ns_prefix
+  # emit prefixed names and every distinct (prefix, uri) pair is
+  # declared exactly once, on the output root, first-encounter
+  # order. Text and attribute values are escaped; RAW members are
+  # verbatim.
+  def serialize(plan_value)
+    result_ptr = plan_value.result_ptr
+    status = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_plan_serialize(
+      @handle, result_ptr, status)
+    if raw.null?
+      raise Leptris::XML::Error,
+        "plan serialize failed (status=#{status.read_int})"
+    end
+    Leptris::XML::FFI.read_owned_string(raw)
+  end
+
   # The fused loop (#1269b): source bytes → typed rows in ONE C
   # call — leptris_plan_materialize runs parse, walk, and free
   # natively; the returned PlanValue tree is standalone and the

data/lib/leptris/xml/document.rb

@@ -232,6 +232,20 @@ class Leptris::XML::Document
     wrap(raw)
   end
 
+  # Markup-accumulating construction (#374 lever 2): the block
+  # accumulates well-formed markup in Ruby; the flush performs
+  # ONE native crossing for the whole subtree. Exactly one root
+  # element — the parsed root is adopted with set_root_ex.
+  # Returns the flush's value (the installed root element).
+  #
+  #     doc = Leptris::XML::Document.create
+  #     doc.build { |b| b.catalog(id: "c") { b.item { b.name "x" } } }
+  def build
+    builder = Leptris::XML::Builder.new(self)
+    yield builder
+    builder.flush
+  end
+
   # Deep copy of +node+ in a NEW document — the one authority
   # behind Node#dup / Element#dup and the indent-unit path.
   # Elements deep-copy through the C copier (every child kind and

data/lib/leptris/xml/element.rb

@@ -665,6 +665,17 @@ class Leptris::XML::Element < Leptris::XML::Node
     Leptris::XML::Node.wrap_fresh(ptr, @document, Leptris::XML::FFI::NODE_ELEMENT)
   end
 
+  # Markup-accumulating child construction (#374 lever 2): the
+  # block accumulates well-formed child markup in Ruby; the flush
+  # appends every fragment child in ONE native crossing
+  # (append_markup). Returns the flush's value (the NodeSet of
+  # added children).
+  def build
+    builder = Leptris::XML::Builder.new(self)
+    yield builder
+    builder.flush
+  end
+
   def add_child(node_or_markup)
     case node_or_markup
     when Leptris::XML::Node

data/lib/leptris/xml/ffi.rb

@@ -306,7 +306,12 @@ module Leptris
                # unset = the historical wire-name lookup.
                :ns_form, :uint8,
                :pad_ns, :uint8,
-               :ns_uri, :pointer
+               :ns_uri, :pointer,
+               # libleptris 1.9.312 (#1551): intended wire prefix
+               # for plan-path serialization (ns_form EXACT emits
+               # "ns_prefix:wire_name"). NULL keeps matching-only
+               # behavior.
+               :ns_prefix, :pointer
       end
       class ChildPlan < ::FFI::Struct
         layout :wire_name, :pointer,
@@ -321,7 +326,13 @@ module Leptris
                # #1272: element-side predicates (same semantics).
                :predicate_count, :uint16,
                :pad_pred, :uint16,
-               :predicates, :pointer
+               :predicates, :pointer,
+               # libleptris 1.9.312 (#1551): serialization prefix,
+               # same contract as AttrPlan's. For WILDCARD rows
+               # (libleptris 1.9.312, #1552) pad0 marks an EXPLICIT
+               # ns_form (0 then filters no-namespace remainder);
+               # unset keeps the catch-all ANY default.
+               :ns_prefix, :pointer
       end
       class ElementPlan < ::FFI::Struct
         layout :element_name, :pointer,
@@ -333,7 +344,10 @@ module Leptris
                :attribute_plans, :pointer,
                :child_plans, :pointer,
                :flags, :uint16,
-               :pad1, :uint16
+               :pad1, :uint16,
+               # libleptris 1.9.312 (#1551): the root plan's
+               # serialization prefix.
+               :ns_prefix, :pointer
       end
       class PlanSpec < ::FFI::Struct
         layout :abi_version, :uint32,
@@ -349,6 +363,11 @@ module Leptris
       PLAN_KIND_RAW = 4
       PLAN_KIND_CONTENT = 5
       PLAN_KIND_CALLBACK = 6
+      # libleptris 1.9.312 (#1552): catch-all row — binds every
+      # element child no named sibling row bound (named rows win
+      # regardless of order); emits one COLLECTION echoing the
+      # row's wire_name/type_tag, members in document order.
+      PLAN_KIND_WILDCARD = 7
 
       PLAN_FLAG_MIXED_CONTENT = 0x1
       PLAN_FLAG_ORDERED = 0x2
@@ -391,6 +410,12 @@ module Leptris
         :leptris_plan_result
       attach_function :leptris_plan_result_free,
         [:leptris_plan_result], :void
+      # libleptris 1.9.312 (#1551): serialize a walk result back
+      # to XML guided by its plan — the plan supplies element
+      # wrappers (row wire_name + ns_prefix), the result the
+      # content. Caller-freed string (leptris_free_string).
+      attach_function :leptris_plan_serialize,
+        [:leptris_plan, :leptris_plan_result, :pointer], :pointer
       attach_function :leptris_plan_value_kind,
         [:leptris_plan_result], :int
       attach_function :leptris_plan_value_name,

data/lib/leptris/xml/plan_value.rb

@@ -30,6 +30,13 @@ class Leptris::XML::PlanValue
     @counter = counter || [0]
   end
 
+  # The engine value handle — the ROOT value's is the whole-result
+  # handle whole-result faces (leptris_plan_serialize) read. Pass
+  # the value Descriptor#walk/#materialize returned.
+  def result_ptr
+    @ptr
+  end
+
   def kind
     @counter[0] += 1
     VALUE_KINDS.fetch(Leptris::XML::FFI.leptris_plan_value_kind(@ptr))

data/lib/leptris/xml.rb

@@ -14,6 +14,7 @@ module Leptris
     autoload :Namespace, "leptris/xml/namespace"
     autoload :Document, "leptris/xml/document"
     autoload :DocumentFragment, "leptris/xml/document_fragment"
+    autoload :Builder, "leptris/xml/builder"
     autoload :DocType, "leptris/xml/doc_type"
     autoload :NodeSet, "leptris/xml/node_set"
     autoload :Searchable, "leptris/xml/searchable"

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,50 @@
 ## [Unreleased]
 
+## [1.9.312] - 2026-10-06
+
+### Added
+
+- **Plan-path serialization emits namespace declarations (#1551,
+  PR #1558).** New `leptris_plan_serialize(plan, result)`: the plan
+  supplies element wrappers, the result the content — children emit
+  in document order, collections are transparent, RAW members
+  verbatim, text and attributes escaped. Rows carrying
+  `ns_form = EXACT` plus the new trailing `ns_prefix` field emit
+  prefixed wire names, and every distinct (prefix, uri) pair is
+  declared exactly once on the output root in first-encounter
+  order. `leptris_attr_plan` takes the same field, so #1486-matched
+  attributes emit the plan-chosen spelling. Byte-parity gates on a
+  `w:document` corpus; additive trailing fields keep
+  `PLAN_ABI_VERSION` at 1 (64-bit attr row 40 -> 48 bytes). Rust
+  mirror (`leptris-descriptor`) updated in lockstep.
+- **Wildcard (catch-all) child rows (#1552, PR #1555).**
+  `LEPTRIS_PLAN_KIND_WILDCARD` binds every element child no named
+  sibling row bound — named rows take precedence regardless of row
+  order (a two-pass walk over a completed `bound[]` map; a named
+  row that rejected a child does not reserve it). Namespace-form
+  aware (`pad0` marks the form explicit so `NS_NONE` is
+  expressible; unset keeps the catch-all ANY default), emits one
+  COLLECTION echoing the row wire_name/type_tag even when empty,
+  members in document order; `child_plan_index >= 0` walks members
+  through that plan. Rust mirror gains `PLAN_KIND_WILDCARD = 7`.
+
+### Fixed
+
+- **Root-level leaf splice arguments adopt single-node (#1539,
+  PR #1554).** A leaf directly on a scratch document's children
+  chain (prolog/epilog comment or PI) reported
+  `LEPTRIS_ERROR_MEMORY` on cross-document append: the chain
+  copier hit the root element and misread it as OOM. The seam now
+  copies exactly the argument for the doc-level shape; in-element
+  leaves keep the #540 chain shape.
+- **Emulated-i386 perf-gate stability (PR #1561).** The
+  indexed-child-access shape budget widens 6x -> 7.5x: the qemu
+  timer noise of the ILP32 leg flaked past 6x three times in one
+  day while every native leg measured ~3x. Linear ~3x, quadratic
+  ~9x, O(N^3) ~27x — the gate keeps its discrimination.
+
+
+
 ## [1.9.311] - 2026-10-06
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/bindings/rust/descriptor/src/lib.rs

@@ -31,6 +31,11 @@ pub const PLAN_KIND_NESTED: PlanKind = 3;
 pub const PLAN_KIND_RAW: PlanKind = 4;
 pub const PLAN_KIND_CONTENT: PlanKind = 5;
 pub const PLAN_KIND_CALLBACK: PlanKind = 6;
+/// #1552: catch-all row — binds every element child no named
+/// sibling row bound; emits one COLLECTION echoing the row
+/// wire_name/type_tag; `child_plan_index >= 0` walks members
+/// through that plan, else members are RAW serialized subtrees.
+pub const PLAN_KIND_WILDCARD: PlanKind = 7;
 
 /// Element plan flags.
 pub const PLAN_FLAG_MIXED_CONTENT: u32 = 0x1;
@@ -83,6 +88,9 @@ pub struct AttrPlan {
     pub pad_ns: u8,
     /// `PLAN_NS_EXACT` only.
     pub ns_uri: *const c_char,
+    /// #1551: intended wire prefix for serialized output
+    /// (`leptris_plan_serialize`); meaningful with EXACT.
+    pub ns_prefix: *const c_char,
 }
 
 /// Child binding row.
@@ -107,6 +115,9 @@ pub struct ChildPlan {
     pub predicate_count: u16,
     pub pad_pred: u16,
     pub predicates: *const AttrPredicate,
+    /// #1551: intended wire prefix for serialized output
+    /// (`leptris_plan_serialize`); meaningful with EXACT.
+    pub ns_prefix: *const c_char,
 }
 
 /// One element plan: the attribute and child rows bound to a name.
@@ -127,6 +138,9 @@ pub struct ElementPlan {
     /// `PLAN_FLAG_*`.
     pub flags: u16,
     pub pad1: u16,
+    /// #1551: the root plan's intended wire prefix for serialized
+    /// output (`leptris_plan_serialize`); meaningful with EXACT.
+    pub ns_prefix: *const c_char,
 }
 
 /// Top-level plan specification handed to the engine.

data/vendor-src/libleptris/bindings/rust/tests/descriptor_abi.rs

@@ -86,6 +86,7 @@ fn plan_build_and_walk_round_trip() {
         ns_form: descriptor::PLAN_NS_NONE,
         pad_ns: 0,
         ns_uri: ptr::null(),
+        ns_prefix: ptr::null(),
     };
     let child_row = descriptor::ChildPlan {
         wire_name: title.as_ptr(),
@@ -98,6 +99,7 @@ fn plan_build_and_walk_round_trip() {
         predicate_count: 0,
         pad_pred: 0,
         predicates: ptr::null(),
+        ns_prefix: ptr::null(),
     };
     let book_plan = descriptor::ElementPlan {
         element_name: book.as_ptr(),
@@ -110,6 +112,7 @@ fn plan_build_and_walk_round_trip() {
         child_plans: &child_row,
         flags: 0,
         pad1: 0,
+        ns_prefix: ptr::null(),
     };
     let root_child = descriptor::ChildPlan {
         wire_name: book.as_ptr(),
@@ -124,6 +127,7 @@ fn plan_build_and_walk_round_trip() {
         predicate_count: 0,
         pad_pred: 0,
         predicates: ptr::null(),
+        ns_prefix: ptr::null(),
     };
     let root_plan = descriptor::ElementPlan {
         element_name: catalog.as_ptr(),
@@ -136,6 +140,7 @@ fn plan_build_and_walk_round_trip() {
         child_plans: &root_child,
         flags: 0,
         pad1: 0,
+        ns_prefix: ptr::null(),
     };
     let plans = [root_plan, book_plan];
     let spec = descriptor::PlanSpec {