leptris 1.9.160.0 → 1.9.162.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2644772a66a1e58e517fe5b5e2b2fb417ac1592863f3de375d1659ecebfeaec6
-  data.tar.gz: ee478cc9f2387ff6527a680c37817d1c650bfe50c0e9c891768784db396cc29c
+  metadata.gz: c862a7a722a5595a09c5f2507c0f27cfb17a15d5a3216147301b07dcde63d75e
+  data.tar.gz: 2e672c08d5f6149c8bbda83fa4bb9be56ca981a290172a8e9fb4835c86d6ea58
 SHA512:
-  metadata.gz: 7e6dfa835f5704689bf7fa50bfac557bf4637b556b9f84f6ae437cf020bafe09cb42c866692d159da8f11ed0a8bad9439d13639f4c6380159d9d0c2a75600d42
-  data.tar.gz: 33558c5c76bbc5130b52e4d4d2258f4918e9c101e18494772d29a55ad758ab089b98753d9ca6cea9cd0ca7ae09107d952c701d6dcdcbdb7557a0c3b13ea7e067
+  metadata.gz: 65bf38576bd8bd1873946b7944661b450a7f2ccc42e82eae2f875e8667cc2809cb634172d7ddaf997b5040273b3dfd7608b501be21f1c27a309fd4ac2c62c226
+  data.tar.gz: 24c01320b932f27ba2483c46777ffd7e16c841b19aaa2bf78c2dbddc982eb35b46d4b9d58bbb81754ee51cb40423cc1f0b20bce25688427d067f2db37f0a0673

data/CHANGELOG.md

@@ -5,7 +5,31 @@ 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.160.0] - 2026-09-14
+## [1.9.162.0] - 2026-09-14
+
+### Added
+
+- **`Leptris::XML::Descriptor`** (libleptris 1.9.162, upstream
+  #1039 — the tree-shaped schema-descriptor materialization ABI):
+  compile a plan tree once (`Descriptor.build` — Ruby hash DSL;
+  nested plans flatten to the engine's plan array), then
+  `#walk(element)` materializes a whole subtree in ONE native
+  pass — no per-element Ruby calls. Rows: :scalar / :collection /
+  :nested / :raw / :content (mixed-content text runs) / :callback
+  (value + byte position + type_tag echo); per-plan namespace
+  forms (:none/:any/{exact:}), flags (:mixed_content/:ordered/
+  :cdata/:ns_lenient). Results are lazy PlanValue trees that
+  OUTLIVE the document; `#to_ruby` materializes. ABI
+  version-checked at build. Audit 291 -> 306.
+- **`Node#byte_offset`** — the parse-source byte position of the
+  node's markup (the position CALLBACK rows echo; 0 unknown).
+
+### Changed
+
+- **Lockstep with libleptris 1.9.162** (1.9.160 -> 1.9.162):
+  NEON count3 deferred horizontal reduction (-33% on the 48 KB
+  copy+count pre-scan; parse rows gain ~1 us each) — 1.9.161.
+\n## [1.9.160.0] - 2026-09-14
 
 ### Changed
 

data/README.adoc

@@ -436,6 +436,45 @@ dispositions drop unmatched subtrees in the built-in initial
 descent (https://github.com/leptris/leptris/issues/705[#705]) —
 the other four dispositions are spec-correct. XQuery has no
 entry point yet.
+== Descriptor materialization
+
+Compile a schema descriptor once, then materialize a whole subtree
+against it in ONE native pass — no per-element Ruby calls (frameworks
+rebuilding typed models from XML; libleptris 1.9.162):
+
+[source,ruby]
+----
+descriptor = Leptris::XML::Descriptor.build(
+  name: "catalog",
+  attributes: [{ name: "version", kind: :scalar }],
+  children: [
+    { name: "item", kind: :nested, plan: {
+      name: "item",
+      attributes: [{ name: "id", kind: :scalar }],
+      children: [
+        { name: "name", kind: :scalar },
+        { name: "price", kind: :scalar },
+        { name: "opt", kind: :collection },
+      ] } },
+  ])
+
+tree = descriptor.walk(doc.root).to_ruby
+# { kind: :element, attributes: { "version" => "2.0" }, children: [
+#   { kind: :element, name: "item", attributes: { "id" => "1" },
+#     children: ["first", "1.99", ["a", "b"]] }, ...] }
+----
+
+Row kinds: `:scalar`, `:collection`, `:nested` (via `plan:`), `:raw`
+(serialized subtree), `:content` (mixed-content text runs — pair with
+`flags: [:mixed_content]`), `:callback` (raw value + document byte
+offset + `type_tag` echo, matching `Node#byte_offset`). Namespace
+binding lives on plans: `ns:` is `:none` (default), `:any`, or
+`{ exact: "urn:..." }`; `flags:` also accepts `:cdata`, `:ordered`,
+`:ns_lenient` (#754 out-of-namespace adoption). Children the plan
+does not describe are skipped; undescribed document order within a
+row is preserved. `#walk` returns a lazy `PlanValue` tree (the
+result outlives the document); `#to_ruby` materializes it.
+
 == XQuery
 
 XQuery 1.0 core through `Leptris::XML::XQuery` (compile once,

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.160"
+LIBLEPTRIS_VERSION = "1.9.162"
 # 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.160.0"
+  VERSION = "1.9.162.0"
 end

data/lib/leptris/xml/descriptor.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+# Tree-shaped schema-descriptor materialization (libleptris 1.9.162,
+# upstream #1039): compile a plan tree once, then materialize a whole
+# subtree against it in ONE native pass — no per-element Ruby calls
+# (#185's class of cost). Children the plan does not describe are
+# skipped; matches within a row keep document order.
+#
+#     descriptor = Leptris::XML::Descriptor.build(
+#       name: "catalog",
+#       attributes: [{ name: "version", kind: :scalar }],
+#       children: [
+#         { name: "item", kind: :nested, plan: {
+#             name: "item",
+#             attributes: [{ name: "id", kind: :scalar }],
+#             children: [
+#               { name: "name", kind: :scalar },
+#               { name: "price", kind: :scalar },
+#             ] } },
+#       ])
+#     descriptor.walk(doc.root).to_ruby
+#
+# Plan rows: :scalar, :collection (repeated matches), :nested (recurse
+# via +plan:+), :raw (serialized subtree), :content (mixed-content
+# text runs), :callback (raw value + byte position + type_tag echo).
+# Namespace binding per plan: +ns:+ is :none (default), :any, or
+# { exact: "urn:..." }; +flags: [:mixed_content, :ordered, :cdata,
+# :ns_lenient].
+class Leptris::XML::Descriptor
+  class Handle < ::FFI::AutoPointer
+    def self.release(ptr)
+      Leptris::XML::FFI.leptris_plan_free(ptr)
+    end
+  end
+
+  class ResultHandle < ::FFI::AutoPointer
+    def self.release(ptr)
+      Leptris::XML::FFI.leptris_plan_result_free(ptr)
+    end
+  end
+
+  KINDS = {
+    scalar: Leptris::XML::FFI::PLAN_KIND_SCALAR,
+    collection: Leptris::XML::FFI::PLAN_KIND_COLLECTION,
+    nested: Leptris::XML::FFI::PLAN_KIND_NESTED,
+    raw: Leptris::XML::FFI::PLAN_KIND_RAW,
+    content: Leptris::XML::FFI::PLAN_KIND_CONTENT,
+    callback: Leptris::XML::FFI::PLAN_KIND_CALLBACK,
+  }.freeze
+  private_constant :KINDS
+
+  FLAGS = {
+    mixed_content: Leptris::XML::FFI::PLAN_FLAG_MIXED_CONTENT,
+    ordered: Leptris::XML::FFI::PLAN_FLAG_ORDERED,
+    cdata: Leptris::XML::FFI::PLAN_FLAG_CDATA,
+    ns_lenient: Leptris::XML::FFI::PLAN_FLAG_NS_LENIENT,
+  }.freeze
+  private_constant :FLAGS
+
+  attr_reader :root
+
+  # +tree+ is the root plan (the hash shape documented on the
+  # class). Returns the compiled, engine-owned descriptor; the
+  # Ruby-side spec memory is transient (the engine deep-copies).
+  def self.build(tree)
+    abi = Leptris::XML::FFI.leptris_plan_abi_version
+    if abi != Leptris::XML::FFI::PLAN_ABI_VERSION
+      raise Leptris::XML::Error,
+        "descriptor ABI v#{abi} != binding v#{Leptris::XML::FFI::PLAN_ABI_VERSION}"
+    end
+    plans = []
+    root_index = flatten_plan(tree, plans)
+    spec, plans_pointer, anchors = pack_plans(plans)
+    spec[:abi_version] = abi
+    spec[:plan_count] = plans.size
+    spec[:plans] = plans_pointer
+    status = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_plan_build(spec.pointer, status)
+    if raw.null?
+      raise Leptris::XML::Error,
+        "plan build failed (status=#{status.read_int})"
+    end
+    new(Handle.new(raw), plans, root_index)
+  end
+
+  # Flattens the nested hash tree into the engine's flat plans
+  # array (child rows reference plans by index). Returns the root
+  # plan's index — always 0 for a single root.
+  def self.flatten_plan(tree, plans)
+    tree = tree.dup
+    plans << tree
+    tree_index = plans.size - 1
+    tree[:children] = (tree[:children] || []).map do |row|
+      if row[:kind] == :nested
+        row.merge(child_plan_index: flatten_plan(row.fetch(:plan), plans))
+      else
+        row
+      end
+    end
+    tree_index
+  end
+  private_class_method :flatten_plan
+
+  # Packs the flattened plans into FFI memory: one ElementPlan per
+  # plan plus one AttrPlan/ChildPlan row per attribute/child. Every
+  # C string and row array is anchored in Ruby until the build call
+  # returns (the engine deep-copies).
+  def self.pack_plans(plans)
+    anchors = [nil]
+    plan_memory = ::FFI::MemoryPointer.new(
+      Leptris::XML::FFI::ElementPlan, plans.size)
+    anchors[0] = plan_memory
+    plans.each_with_index do |plan, i|
+      ep = Leptris::XML::FFI::ElementPlan.new(plan_memory[i])
+      ep[:element_name] = anchor_string(anchors, plan.fetch(:name))
+      ns = plan[:ns]
+      ns_form, ns_uri =
+        case ns
+        when nil, :none then [Leptris::XML::FFI::PLAN_NS_NONE, nil]
+        when :any then [Leptris::XML::FFI::PLAN_NS_ANY, nil]
+        when Hash
+          [Leptris::XML::FFI::PLAN_NS_EXACT,
+           anchor_string(anchors, ns.fetch(:exact))]
+        else
+          raise ArgumentError, "ns must be :none, :any, or {exact: uri}"
+        end
+      ep[:ns_form] = ns_form
+      ep[:ns_uri] = ns_uri
+      attrs = plan[:attributes] || []
+      attr_memory = attrs.empty? ? nil :
+        ::FFI::MemoryPointer.new(Leptris::XML::FFI::AttrPlan, attrs.size)
+      anchors << attr_memory
+      attrs.each_with_index do |row, j|
+        ap = Leptris::XML::FFI::AttrPlan.new(attr_memory[j])
+        ap[:wire_name] = anchor_string(anchors, row.fetch(:name))
+        ap[:kind] = kind_code(row[:kind] || :scalar)
+        ap[:type_tag] = row[:type_tag] || 0
+      end
+      ep[:attribute_count] = attrs.size
+      ep[:attribute_plans] = attr_memory
+      children = plan[:children] || []
+      child_memory = children.empty? ? nil :
+        ::FFI::MemoryPointer.new(Leptris::XML::FFI::ChildPlan, children.size)
+      anchors << child_memory
+      children.each_with_index do |row, j|
+        cp = Leptris::XML::FFI::ChildPlan.new(child_memory[j])
+        cp[:wire_name] = anchor_string(anchors, row.fetch(:name))
+        cp[:kind] = kind_code(row[:kind] || :scalar)
+        cp[:type_tag] = row[:type_tag] || 0
+        cp[:child_plan_index] = row[:child_plan_index] || -1
+      end
+      ep[:child_count] = children.size
+      ep[:child_plans] = child_memory
+      ep[:flags] = (plan[:flags] || []).map { |f| FLAGS.fetch(f) }.sum
+    end
+    [Leptris::XML::FFI::PlanSpec.new, plan_memory, anchors]
+  end
+  private_class_method :pack_plans
+
+  # Anchors the NUL-terminated copy in +anchors+ — the engine
+  # deep-copies at build, but the source bytes must live until the
+  # leptris_plan_build call returns.
+  def self.anchor_string(anchors, ruby_string)
+    ptr = ::FFI::MemoryPointer.from_string(ruby_string.to_s)
+    anchors << ptr
+    ptr
+  end
+  private_class_method :anchor_string
+
+  def self.kind_code(kind)
+    KINDS.fetch(kind) do
+      raise ArgumentError,
+        "kind must be one of #{KINDS.keys.inspect}, got #{kind.inspect}"
+    end
+  end
+  private_class_method :kind_code
+
+  def initialize(handle, plans, root_index)
+    @handle = handle
+    @plans = plans
+    @root_index = root_index
+  end
+
+  # Materializes the subtree rooted at +element_or_document+ (the
+  # root plan applies to the context node itself) in one native
+  # pass. Returns the lazy PlanValue tree — a standalone result
+  # that outlives the document.
+  def walk(element_or_document)
+    context = Leptris::XML::EvaluationContext.of(element_or_document)
+    status = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_plan_walk(
+      context.document.c_ptr, context.context_node_ptr, @handle, status)
+    if raw.null?
+      raise Leptris::XML::Error,
+        "plan walk failed (status=#{status.read_int})"
+    end
+    Leptris::XML::PlanValue.new(ResultHandle.new(raw),
+                                owner: true, plans: @plans, plan: @plans[0])
+  end
+end

data/lib/leptris/xml/ffi.rb

@@ -66,6 +66,8 @@ module Leptris
       typedef :pointer, :leptris_xquery
       typedef :pointer, :leptris_schematron
       typedef :pointer, :leptris_diff
+      typedef :pointer, :leptris_plan
+      typedef :pointer, :leptris_plan_result
       typedef :pointer, :leptris_sax_recorder
       typedef :pointer, :leptris_pull_parser
       typedef :pointer, :leptris_iterparse
@@ -153,6 +155,97 @@ module Leptris
           :text_len, :size_t
       end
 
+      # Tree-shaped schema-descriptor materialization (1.9.162,
+      # upstream #1039): hosts compile a plan tree once, then
+      # leptris_plan_walk materializes a whole subtree in one
+      # native pass. The plan/result structs mirror descriptor.h
+      # — POD, ABI-frozen at v1 (leptris_plan_abi_version).
+      class AttrPlan < ::FFI::Struct
+        layout :wire_name, :pointer,
+               :kind, :uint8,
+               :type_tag, :uint8
+      end
+      class ChildPlan < ::FFI::Struct
+        layout :wire_name, :pointer,
+               :kind, :uint8,
+               :type_tag, :uint8,
+               :child_plan_index, :int32
+      end
+      class ElementPlan < ::FFI::Struct
+        layout :element_name, :pointer,
+               :ns_form, :uint8,
+               :pad0, :uint8,
+               :ns_uri, :pointer,
+               :attribute_count, :uint32,
+               :child_count, :uint32,
+               :attribute_plans, :pointer,
+               :child_plans, :pointer,
+               :flags, :uint16,
+               :pad1, :uint16
+      end
+      class PlanSpec < ::FFI::Struct
+        layout :abi_version, :uint32,
+               :plan_count, :uint32,
+               :plans, :pointer
+      end
+
+      PLAN_ABI_VERSION = 1
+
+      PLAN_KIND_SCALAR = 1
+      PLAN_KIND_COLLECTION = 2
+      PLAN_KIND_NESTED = 3
+      PLAN_KIND_RAW = 4
+      PLAN_KIND_CONTENT = 5
+      PLAN_KIND_CALLBACK = 6
+
+      PLAN_FLAG_MIXED_CONTENT = 0x1
+      PLAN_FLAG_ORDERED = 0x2
+      PLAN_FLAG_CDATA = 0x4
+      PLAN_FLAG_NS_LENIENT = 0x8
+
+      PLAN_NS_NONE = 0
+      PLAN_NS_EXACT = 1
+      PLAN_NS_ANY = 2
+
+      PLAN_VALUE_ELEMENT = 0
+      PLAN_VALUE_SCALAR = 1
+      PLAN_VALUE_COLLECTION = 2
+      PLAN_VALUE_RAW = 3
+      PLAN_VALUE_CALLBACK = 4
+
+      # Byte offset of parse-created nodes (1.9.162, #1039): the
+      # position descriptor CALLBACK rows echo; 0 when unknown.
+      attach_function :leptris_node_byte_offset,
+        [:leptris_node_ref], :size_t
+
+      attach_function :leptris_plan_abi_version, [], :uint32
+      attach_function :leptris_plan_build,
+        [:pointer, :pointer], :leptris_plan
+      attach_function :leptris_plan_free, [:leptris_plan], :void
+      attach_function :leptris_plan_walk,
+        [:leptris_document, :leptris_element, :leptris_plan, :pointer],
+        :leptris_plan_result
+      attach_function :leptris_plan_result_free,
+        [:leptris_plan_result], :void
+      attach_function :leptris_plan_value_kind,
+        [:leptris_plan_result], :int
+      attach_function :leptris_plan_value_name,
+        [:leptris_plan_result], :string
+      attach_function :leptris_plan_value_type_tag,
+        [:leptris_plan_result], :uint8
+      attach_function :leptris_plan_value_string,
+        [:leptris_plan_result], :string
+      attach_function :leptris_plan_value_length,
+        [:leptris_plan_result], :size_t
+      attach_function :leptris_plan_value_position,
+        [:leptris_plan_result], :size_t
+      attach_function :leptris_plan_value_count,
+        [:leptris_plan_result], :size_t
+      attach_function :leptris_plan_value_at,
+        [:leptris_plan_result, :size_t], :leptris_plan_result
+      attach_function :leptris_plan_value_attribute,
+        [:leptris_plan_result, :string], :string
+
       attach_function :leptris_version, [], :string
       attach_function :leptris_version_components, [:pointer, :pointer, :pointer], :void
 

data/lib/leptris/xml/node.rb

@@ -199,6 +199,15 @@ class Leptris::XML::Node
     Leptris::XML::FFI.leptris_node_line(@c_ptr)
   end
 
+  # Byte offset of the node's markup in its parse source (the '<'
+  # of the tag; libleptris 1.9.162, #1039 — the position descriptor
+  # CALLBACK rows echo). 0 when unknown: mutation-created nodes, or
+  # documents >= 2 GiB.
+  def byte_offset
+    ensure_alive!
+    Leptris::XML::FFI.leptris_node_byte_offset(@c_ptr)
+  end
+
   def <=>(other)
     return nil unless other.is_a?(Leptris::XML::Node)
     return nil unless @document == other.document

data/lib/leptris/xml/plan_value.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+# One node of a Descriptor#walk result (libleptris 1.9.162, upstream
+# #1039): a lazy view over the engine-owned value tree. The ROOT
+# value owns the whole-result handle (freed by GC); child values
+# borrow from their parent — #at returns borrowed views, so the
+# root must outlive them (hold the root, read freely).
+#
+# The C result API reads attributes BY NAME only, so element
+# attribute enumeration threads the producing plan's attribute
+# rows: Descriptor#walk plants the root plan, #to_ruby walks
+# (value, plan) pairs in parallel.
+class Leptris::XML::PlanValue
+  VALUE_KINDS = {
+    Leptris::XML::FFI::PLAN_VALUE_ELEMENT => :element,
+    Leptris::XML::FFI::PLAN_VALUE_SCALAR => :scalar,
+    Leptris::XML::FFI::PLAN_VALUE_COLLECTION => :collection,
+    Leptris::XML::FFI::PLAN_VALUE_RAW => :raw,
+    Leptris::XML::FFI::PLAN_VALUE_CALLBACK => :callback,
+  }.freeze
+  private_constant :VALUE_KINDS
+
+  def initialize(ptr, owner: nil, plans: nil, plan: nil)
+    @ptr = ptr
+    @owner = owner
+    @plans = plans
+    @plan = plan
+  end
+
+  def kind
+    VALUE_KINDS.fetch(Leptris::XML::FFI.leptris_plan_value_kind(@ptr))
+  end
+
+  # wire_name of the plan row that produced this value.
+  def name
+    Leptris::XML::FFI.leptris_plan_value_name(@ptr)
+  end
+
+  # Host type_tag echoed verbatim (0 when the row had none).
+  def type_tag
+    Leptris::XML::FFI.leptris_plan_value_type_tag(@ptr)
+  end
+
+  # SCALAR / RAW / CALLBACK string value.
+  def string_value
+    Leptris::XML::FFI.leptris_plan_value_string(@ptr)
+  end
+
+  # CALLBACK: document byte offset of the source node (0 unknown).
+  def position
+    Leptris::XML::FFI.leptris_plan_value_position(@ptr)
+  end
+
+  # ELEMENT: child-value count. COLLECTION: item count.
+  def count
+    Leptris::XML::FFI.leptris_plan_value_count(@ptr)
+  end
+
+  # ELEMENT child value / COLLECTION item at +i+ (nil out of
+  # range). Borrowed: the owning root must stay alive.
+  def at(i)
+    ptr = Leptris::XML::FFI.leptris_plan_value_at(@ptr, i)
+    return nil if ptr.null?
+    child_name = Leptris::XML::FFI.leptris_plan_value_name(ptr)
+    child_plan = @plan ? child_row_plan(child_name) : nil
+    Leptris::XML::PlanValue.new(ptr, plans: @plans, plan: child_plan)
+  end
+
+  # ELEMENT: attribute value by wire_name (nil when absent).
+  def attribute(wire_name)
+    Leptris::XML::FFI.leptris_plan_value_attribute(@ptr, wire_name.to_s)
+  end
+
+  # The eager Ruby tree:
+  #   :element    => { kind:, name:, type_tag:, attributes: {...},
+  #                   children: [values] }
+  #   :scalar/:raw => String
+  #   :collection => [values]
+  #   :callback   => { value:, position:, type_tag: }
+  def to_ruby
+    case kind
+    when :element
+      {
+        kind: :element,
+        name: name,
+        type_tag: type_tag,
+        attributes: collected_attributes,
+        children: Array.new(count) { |i| at(i).to_ruby },
+      }
+    when :collection
+      Array.new(count) { |i| at(i).to_ruby }
+    when :callback
+      { value: string_value, position: position, type_tag: type_tag }
+    else
+      string_value
+    end
+  end
+
+  private
+
+  # The element plan that a child row with this wire_name recurses
+  # into (nil for non-nested rows — their values carry no plan).
+  def child_row_plan(child_wire_name)
+    row = (@plan[:children] || []).find do |r|
+      r[:kind] == :nested && r[:name] == child_wire_name
+    end
+    return nil unless row && @plans
+    @plans[row[:child_plan_index]]
+  end
+
+  def collected_attributes
+    result = {}
+    ((@plan && @plan[:attributes]) || []).each do |row|
+      v = attribute(row[:name])
+      result[row[:name]] = v unless v.nil?
+    end
+    result
+  end
+end

data/lib/leptris/xml.rb

@@ -25,6 +25,8 @@ module Leptris
     autoload :EvaluationContext, "leptris/xml/evaluation_context"
     autoload :Schematron, "leptris/xml/schematron"
     autoload :Diff, "leptris/xml/diff"
+    autoload :Descriptor, "leptris/xml/descriptor"
+    autoload :PlanValue, "leptris/xml/plan_value"
     autoload :IterationScope, "leptris/xml/iteration_scope"
     autoload :ResultText, "leptris/xml/result_text"
     autoload :ResultAttr, "leptris/xml/result_attr"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.160.0
+  version: 1.9.162.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -106,6 +106,7 @@ files:
 - lib/leptris/xml/cdata.rb
 - lib/leptris/xml/comment.rb
 - lib/leptris/xml/css_to_xpath.rb
+- lib/leptris/xml/descriptor.rb
 - lib/leptris/xml/diff.rb
 - lib/leptris/xml/doc_type.rb
 - lib/leptris/xml/document.rb
@@ -119,6 +120,7 @@ files:
 - lib/leptris/xml/node.rb
 - lib/leptris/xml/node_set.rb
 - lib/leptris/xml/parse_options.rb
+- lib/leptris/xml/plan_value.rb
 - lib/leptris/xml/processing_instruction.rb
 - lib/leptris/xml/pull.rb
 - lib/leptris/xml/relaxng.rb