leptris 1.9.231.1-ppc64le-linux → 1.9.232.1-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a03ce93f7f2e1523f2da2f36d5e5a8673208f152681b0522169c7aa3858c040
-  data.tar.gz: 99434e64ab561f2250851815dda490924545e7d03bf8584c663760c64e7b544a
+  metadata.gz: dbea4290be718ca7b75aa45539d8573ab5c5d410e8d3f21b9dae2fecf373ae4e
+  data.tar.gz: ac6e1d2b0ed35acc86b80f95299bfb07482fe2e10db91cc7829fe101171de6ad
 SHA512:
-  metadata.gz: e8414dd067704ec35c08b107873143df153b8c25cf3d362f672b6314486b41df82bff4a68d51ae4fc9a7889721c2ae840aaef305d1835c54003a35298a074517
-  data.tar.gz: 7334dd4eebd5482253441b45bc5ff666fa3d79dd5111d3f5685df5cd4710e2f5382f0b8ac5f4e68e80640426cad762d1646ce5cd7e4a2e9bed863b66030e05d4
+  metadata.gz: f8f75c17ec559fbe6ff018b1ec831313754ff34bc64953b6f8063f97130f831a0860a24166c64423382f8b0b331b1ca32e8717230335243c9dbd284b7eb9b8fe
+  data.tar.gz: 4c19cc71b5284ac325c75916d3a855d6cfb0ecda7ed7c15db5c3d36e296dc75509607049658c0469936f60af8c999084143f69ba22834c82f7dd93761a56a19e

data/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.232.0] - 2026-09-24
+
+### Added
+
+- `Node#visit_entering` (libleptris #1332): the entering-only walk
+  — one C call yields `(node, true, depth)` exactly once per node,
+  halving the C→Ruby transitions against `#visit` for walks that
+  never acted on the leaving half. Same order and depths as
+  `#visit`; the native face falls back to the filtering visit on
+  pins predating #1332.
+
+### Performance — engine sync (1.9.232)
+
+- Vendored libleptris 1.9.232: the per-eval registry leak fix, the
+  range NaN fix, string-literal character-reference expansion, and
+  the plan-walker prefixed-name fix — moxml/lutaml hydration of
+  `w:*` elements resolves correctly with no binding-side change —
+  plus 907 new QT3-gated engine behaviors.
+
 ## [1.9.231.0] - 2026-09-23
 
 ### Fixed

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.231"
+LIBLEPTRIS_VERSION = "1.9.232"
 # 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

@@ -971,10 +971,39 @@ static VALUE nf_visit_binding(VALUE self, VALUE document, VALUE addr)
     st.klass_memo_flag =
         rb_obj_class(document) == c_iteration_scope ? Qfalse : Qtrue;
     st.for_visit = 1;
-    if (f_node_visit_entering)
-        f_node_visit_entering(st.self_ptr, visit_cb, &st);
-    else
-        f_node_visit(st.self_ptr, visit_cb, &st);
+    /* ALWAYS the two-event engine call: this seam backs the PUBLIC
+     * Node#visit, whose contract (specs since libleptris 1.9.20)
+     * is (node, entering, depth) enter/leave PAIRS. Entering-only
+     * walks belong to visit_entering_binding below — swapping the
+     * call here silently dropped every leaving callback and broke
+     * the contract. */
+    f_node_visit(st.self_ptr, visit_cb, &st);
+    if (st.err != Qnil)
+        rb_exc_raise(st.err);
+    return Qnil;
+}
+
+/* Entering-only walk (libleptris #1332): one callback per node.
+ * Yields the same (node, true, depth) shape as visit_binding — the
+ * entering argument is constant true here, but keeping the 3-arity
+ * yield lets a block be shared between the two walk modes. */
+static VALUE nf_visit_entering_binding(VALUE self, VALUE document,
+                                       VALUE addr)
+{
+    struct trav_state st;
+
+    (void)self;
+    if (!f_node_visit_entering)
+        return nf_visit_binding(self, document, addr);
+    resolve_binding_classes();
+    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_entering(st.self_ptr, visit_cb, &st);
     if (st.err != Qnil)
         rb_exc_raise(st.err);
     return Qnil;
@@ -2739,6 +2768,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_traverse_binding, 2);
     rb_define_module_function(m_native, "visit_binding",
                               nf_visit_binding, 2);
+    rb_define_module_function(m_native, "visit_entering_binding",
+                              nf_visit_entering_binding, 2);
     rb_define_module_function(m_native, "fast_text_content",
                               nf_fast_text_content, 1);
     rb_define_module_function(m_native, "fast_comment_content",

data/lib/leptris/version.rb

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

data/lib/leptris/xml/ffi.rb

@@ -7,6 +7,28 @@ module Leptris
     module FFI
       extend ::FFI::Library
 
+      # FFI's :string return type always tags returned bytes
+      # ASCII-8BIT, but libleptris produces character data (UTF-8,
+      # the XML default encoding). Every string-returning function
+      # therefore uses this converter: same NUL-terminated copy
+      # semantics as :string, tagged UTF-8. Input arguments keep
+      # plain :string (Ruby-to-C reads bytes regardless of tag).
+      UTF8_STRING = Class.new do
+        include ::FFI::DataConverter
+
+        def from_native(ptr, _ctx)
+          return nil if ptr.null? || ptr.address.zero?
+
+          ptr.read_string.force_encoding(Encoding::UTF_8)
+        end
+
+        def to_native(value, _ctx)
+          return nil if value.nil?
+
+          ::FFI::MemoryPointer.from_string(value.to_s)
+        end
+      end.new.tap { |c| c.native_type(::FFI::Type::POINTER) }
+
       # The per-OS vendor directory of the ruby-platform gem
       # (zero-setup TruffleRuby/JRuby, #160): binaries for the
       # common engines' OSes under lib/leptris/vendor/<platform>/.
@@ -321,11 +343,11 @@ module Leptris
       attach_function :leptris_plan_value_kind,
         [:leptris_plan_result], :int
       attach_function :leptris_plan_value_name,
-        [:leptris_plan_result], :string
+        [:leptris_plan_result], UTF8_STRING
       attach_function :leptris_plan_value_type_tag,
         [:leptris_plan_result], :uint8
       attach_function :leptris_plan_value_string,
-        [:leptris_plan_result], :string
+        [:leptris_plan_result], UTF8_STRING
       attach_function :leptris_plan_value_length,
         [:leptris_plan_result], :size_t
       attach_function :leptris_plan_value_position,
@@ -335,7 +357,7 @@ module Leptris
       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
+        [:leptris_plan_result, :string], UTF8_STRING
       # #1254 (leptris 1.9.216): one-call flat attribute read —
       # parallel name/value/handle arrays, capacity-bounded; total
       # count returned (min(total, max_count) copied). Also the
@@ -367,7 +389,7 @@ module Leptris
         [:string, :size_t, :leptris_plan, :pointer],
         :leptris_plan_result
 
-      attach_function :leptris_version, [], :string
+      attach_function :leptris_version, [], UTF8_STRING
       attach_function :leptris_version_components, [:pointer, :pointer, :pointer], :void
 
             # Tolerant HTML4/5 parse into the STANDARD DOM (libleptris
@@ -424,9 +446,9 @@ attach_function :leptris_parse_string,
       attach_function :leptris_entity_ref_node_create,
         [:leptris_document, :string], :leptris_node_ref
       attach_function :leptris_entity_ref_node_name,
-        [:leptris_node_ref], :string
+        [:leptris_node_ref], UTF8_STRING
       attach_function :leptris_document_version,
-        [:leptris_document], :string
+        [:leptris_document], UTF8_STRING
       attach_function :leptris_document_standalone,
         [:leptris_document], :int
       attach_function :leptris_document_set_version,
@@ -447,14 +469,18 @@ attach_function :leptris_parse_string,
       # node walks the document child chain.
       attach_function :leptris_node_visit,
         [:leptris_node_ref, :pointer, :pointer], :void
+      # Entering-only walk (libleptris #1332): one callback per
+      # node. Rides the engine pin that ships it.
+      attach_function :leptris_node_visit_entering,
+        [:leptris_node_ref, :pointer, :pointer], :void
       # Document-level PIs (v1.6.0): not tree nodes — enumerate via
       # these accessors only.
       attach_function :leptris_document_pi_count,
         [:leptris_document], :size_t
       attach_function :leptris_document_pi_target,
-        [:leptris_document, :size_t], :string
+        [:leptris_document, :size_t], UTF8_STRING
       attach_function :leptris_document_pi_data,
-        [:leptris_document, :size_t], :string
+        [:leptris_document, :size_t], UTF8_STRING
       # Document-level PI removal by target or index (1.9.9, #612):
       # unlinks from the child chain; the node is pool-owned and
       # stays valid until document free.
@@ -472,13 +498,13 @@ attach_function :leptris_parse_string,
       attach_function :leptris_document_comment_count,
         [:leptris_document], :size_t
       attach_function :leptris_document_comment_content,
-        [:leptris_document, :size_t], :string
+        [:leptris_document, :size_t], UTF8_STRING
       # Options-struct parse (v1.6.0): supersedes the flags variants;
       # the flags path remains bound for compatibility.
       attach_function :leptris_parse_string_ex,
         [:string, :size_t, :pointer, :pointer], :leptris_document
       attach_function :leptris_document_encoding,
-        [:leptris_document], :string
+        [:leptris_document], UTF8_STRING
       attach_function :leptris_document_finalize_strings,
         [:leptris_document], :int
       attach_function :leptris_document_adopt_child,
@@ -501,10 +527,10 @@ attach_function :leptris_parse_string,
         [:leptris_element], :int
       attach_function :leptris_xinclude_is_fallback_element,
         [:leptris_element], :int
-      attach_function :leptris_xinclude_get_href, [:leptris_element], :string
-      attach_function :leptris_xinclude_get_parse, [:leptris_element], :string
-      attach_function :leptris_xinclude_get_xpointer, [:leptris_element], :string
-      attach_function :leptris_xinclude_get_encoding, [:leptris_element], :string
+      attach_function :leptris_xinclude_get_href, [:leptris_element], UTF8_STRING
+      attach_function :leptris_xinclude_get_parse, [:leptris_element], UTF8_STRING
+      attach_function :leptris_xinclude_get_xpointer, [:leptris_element], UTF8_STRING
+      attach_function :leptris_xinclude_get_encoding, [:leptris_element], UTF8_STRING
 
       attach_function :leptris_node_get_type,
         [:leptris_node_ref], :int
@@ -566,15 +592,15 @@ attach_function :leptris_parse_string,
         [:leptris_node_ref, :int, :pointer, :pointer], :int
 
       attach_function :leptris_text_node_get_content,
-        [:leptris_node_ref], :string
+        [:leptris_node_ref], UTF8_STRING
       attach_function :leptris_comment_node_get_content,
-        [:leptris_node_ref], :string
+        [:leptris_node_ref], UTF8_STRING
       attach_function :leptris_cdata_node_get_content,
-        [:leptris_node_ref], :string
+        [:leptris_node_ref], UTF8_STRING
       attach_function :leptris_pi_node_get_target,
-        [:leptris_node_ref], :string
+        [:leptris_node_ref], UTF8_STRING
       attach_function :leptris_pi_node_get_data,
-        [:leptris_node_ref], :string
+        [:leptris_node_ref], UTF8_STRING
       attach_function :leptris_text_node_create,
         [:leptris_document, :string], :leptris_node_ref
       attach_function :leptris_comment_node_create,
@@ -595,9 +621,9 @@ attach_function :leptris_parse_string,
         [:leptris_node_ref, :string], :leptris_status
 
       attach_function :leptris_element_name,
-        [:leptris_element], :string
+        [:leptris_element], UTF8_STRING
       attach_function :leptris_element_text,
-        [:leptris_element], :string
+        [:leptris_element], UTF8_STRING
       attach_function :leptris_element_text_int,
         [:leptris_element, :int], :int
       attach_function :leptris_element_text_uint,
@@ -609,9 +635,9 @@ attach_function :leptris_parse_string,
       attach_function :leptris_element_text_bool,
         [:leptris_element, :int], :int
       attach_function :leptris_element_attribute,
-        [:leptris_element, :string], :string
+        [:leptris_element, :string], UTF8_STRING
       attach_function :leptris_element_attribute_string,
-        [:leptris_element, :string, :string], :string
+        [:leptris_element, :string, :string], UTF8_STRING
       attach_function :leptris_element_attribute_int,
         [:leptris_element, :string, :int], :int
       attach_function :leptris_element_attribute_uint,
@@ -628,32 +654,32 @@ attach_function :leptris_parse_string,
       # XML Namespaces 1.0 semantics; NULL/"" uri matches only
       # no-namespace attributes, xmlns declarations never match.
       attach_function :leptris_element_attribute_ns,
-        [:leptris_element, :string, :string], :string
+        [:leptris_element, :string, :string], UTF8_STRING
       attach_function :leptris_element_has_attribute_ns,
         [:leptris_element, :string, :string], :int
       # libleptris 1.8.0: per-attribute prefix (name-derived) and
       # namespace URI (resolved through the owning element's
       # in-scope declarations at read time).
       attach_function :leptris_attribute_prefix,
-        [:leptris_attribute], :string
+        [:leptris_attribute], UTF8_STRING
       attach_function :leptris_attribute_namespace_uri,
-        [:leptris_attribute], :string
+        [:leptris_attribute], UTF8_STRING
       attach_function :leptris_element_first_attribute,
         [:leptris_element], :leptris_attribute
       attach_function :leptris_attribute_next,
         [:leptris_attribute], :leptris_attribute
       attach_function :leptris_attribute_get_name,
-        [:leptris_attribute], :string
+        [:leptris_attribute], UTF8_STRING
       attach_function :leptris_attribute_get_value,
-        [:leptris_element, :leptris_attribute], :string
+        [:leptris_element, :leptris_attribute], UTF8_STRING
       attach_function :leptris_element_prefix,
-        [:leptris_element], :string
+        [:leptris_element], UTF8_STRING
       attach_function :leptris_element_attribute_count,
         [:leptris_element], :size_t
       attach_function :leptris_element_attribute_name_at,
-        [:leptris_element, :size_t], :string
+        [:leptris_element, :size_t], UTF8_STRING
       attach_function :leptris_element_attribute_value_at,
-        [:leptris_element, :size_t], :string
+        [:leptris_element, :size_t], UTF8_STRING
       attach_function :leptris_element_remove_all_attributes,
         [:leptris_element], :leptris_status
 
@@ -666,7 +692,7 @@ attach_function :leptris_parse_string,
       attach_function :leptris_element_root,
         [:leptris_element], :leptris_element
       attach_function :leptris_element_child_value,
-        [:leptris_element], :string
+        [:leptris_element], UTF8_STRING
       attach_function :leptris_element_hash_value,
         [:leptris_element], :size_t
       attach_function :leptris_element_find_child,
@@ -752,23 +778,23 @@ attach_function :leptris_parse_string,
       attach_function :leptris_element_set_namespace,
         [:leptris_element, :string], :leptris_status
       attach_function :leptris_element_namespace,
-        [:leptris_element], :string
+        [:leptris_element], UTF8_STRING
       attach_function :leptris_element_namespace_for_prefix,
-        [:leptris_element, :string], :string
+        [:leptris_element, :string], UTF8_STRING
       attach_function :leptris_element_namespace_count,
         [:leptris_element], :size_t
       attach_function :leptris_element_namespace_decl_prefix,
-        [:leptris_element, :size_t], :string
+        [:leptris_element, :size_t], UTF8_STRING
       attach_function :leptris_element_namespace_decl_uri,
-        [:leptris_element, :size_t], :string
+        [:leptris_element, :size_t], UTF8_STRING
       attach_function :leptris_element_add_namespace_definition,
         [:leptris_element, :string, :string], :leptris_status
       attach_function :leptris_element_set_default_namespace,
         [:leptris_element, :string], :leptris_status
       attach_function :leptris_element_remove_namespace_definition,
         [:leptris_element, :string], :leptris_status
-      attach_function :leptris_namespace_uri, [:string], :string
-      attach_function :leptris_namespace_prefix, [:string], :string
+      attach_function :leptris_namespace_uri, [:string], UTF8_STRING
+      attach_function :leptris_namespace_prefix, [:string], UTF8_STRING
 
       attach_function :leptris_xpath_eval,
         [:leptris_document, :leptris_element, :string], :leptris_xpath_result
@@ -803,9 +829,9 @@ attach_function :leptris_parse_string,
       attach_function :leptris_xpath_result_get_node,
         [:leptris_xpath_result, :size_t], :leptris_node_ref
       attach_function :leptris_xpath_result_node_name,
-        [:leptris_xpath_result, :size_t], :string
+        [:leptris_xpath_result, :size_t], UTF8_STRING
       attach_function :leptris_xpath_result_node_value,
-        [:leptris_xpath_result, :size_t], :string
+        [:leptris_xpath_result, :size_t], UTF8_STRING
       # Document-scoped custom XPath functions. The callback receives
       # (const char* const* args, int argc, void* user_data) and returns
       # a heap string the library frees.
@@ -873,7 +899,7 @@ attach_function :leptris_parse_string,
         :leptris_xpath_result
       # Source text of a compiled expression (owned by the handle).
       attach_function :leptris_xpath_compiled_text,
-        [:leptris_xpath_compiled], :string
+        [:leptris_xpath_compiled], UTF8_STRING
       attach_function :leptris_xpath_compiled_free,
 
         [:leptris_xpath_compiled], :void
@@ -918,9 +944,9 @@ attach_function :leptris_parse_string,
       attach_function :leptris_pull_attr_count,
         [:leptris_pull_parser], :size_t
       attach_function :leptris_pull_attr_name,
-        [:leptris_pull_parser, :size_t], :string
+        [:leptris_pull_parser, :size_t], UTF8_STRING
       attach_function :leptris_pull_attr_value,
-        [:leptris_pull_parser, :size_t], :string
+        [:leptris_pull_parser, :size_t], UTF8_STRING
       attach_function :leptris_pull_attrs,
         [:leptris_pull_parser, :pointer, :size_t], :size_t
       attach_function :leptris_pull_free,
@@ -944,9 +970,9 @@ attach_function :leptris_parse_string,
       attach_function :leptris_iterparse_ns_count,
         [:leptris_iterparse], :size_t
       attach_function :leptris_iterparse_ns_uri,
-        [:leptris_iterparse, :string], :string
+        [:leptris_iterparse, :string], UTF8_STRING
       attach_function :leptris_iterparse_error,
-        [:leptris_iterparse], :string
+        [:leptris_iterparse], UTF8_STRING
       attach_function :leptris_iterparse_free,
         [:leptris_iterparse], :void
 
@@ -1016,7 +1042,7 @@ attach_function :leptris_parse_string,
       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_buffer, [:pointer], UTF8_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
@@ -1057,7 +1083,7 @@ attach_function :leptris_parse_string,
       attach_function :leptris_schematron_validate,
         [:leptris_schematron, :leptris_document], :leptris_document
       attach_function :leptris_schematron_error,
-        [:leptris_schematron], :string
+        [:leptris_schematron], UTF8_STRING
 
       # Tree diff (libleptris >= 1.9.126 family): equal subtrees
       # prune in O(1) by the #869 Merkle digest; diverging regions
@@ -1070,13 +1096,13 @@ attach_function :leptris_parse_string,
       attach_function :leptris_diff_op_type,
         [:leptris_diff, :size_t], :int
       attach_function :leptris_diff_op_name,
-        [:leptris_diff, :size_t], :string
+        [:leptris_diff, :size_t], UTF8_STRING
       attach_function :leptris_diff_op_path,
-        [:leptris_diff, :size_t], :string
+        [:leptris_diff, :size_t], UTF8_STRING
       attach_function :leptris_diff_op_before,
-        [:leptris_diff, :size_t], :string
+        [:leptris_diff, :size_t], UTF8_STRING
       attach_function :leptris_diff_op_after,
-        [:leptris_diff, :size_t], :string
+        [:leptris_diff, :size_t], UTF8_STRING
       attach_function :leptris_diff_serialize,
         [:leptris_diff], :pointer
 
@@ -1123,14 +1149,14 @@ attach_function :leptris_parse_string,
       attach_function :leptris_rng_validate,
         [:leptris_relaxng, :leptris_document], :int
       attach_function :leptris_rng_error,
-        [:leptris_relaxng], :string
+        [:leptris_relaxng], UTF8_STRING
       # Accumulated validation errors (libleptris 1.9.179, #878):
       # the validator no longer stops at the first failure;
       # leptris_rng_error keeps returning the first (back-compat).
       attach_function :leptris_rng_error_count,
         [:leptris_relaxng], :size_t
       attach_function :leptris_rng_error_message,
-        [:leptris_relaxng, :size_t], :string
+        [:leptris_relaxng, :size_t], UTF8_STRING
       attach_function :leptris_rng_error_line,
         [:leptris_relaxng, :size_t], :int
       attach_function :leptris_rng_error_column,
@@ -1178,15 +1204,15 @@ attach_function :leptris_parse_string,
       attach_function :leptris_document_internal_subset,
         [:leptris_document], :leptris_doctype
       attach_function :leptris_doctype_get_name,
-        [:leptris_doctype], :string
+        [:leptris_doctype], UTF8_STRING
       attach_function :leptris_doctype_get_root_name,
-        [:leptris_doctype], :string
+        [:leptris_doctype], UTF8_STRING
       attach_function :leptris_doctype_get_public_id,
-        [:leptris_doctype], :string
+        [:leptris_doctype], UTF8_STRING
       attach_function :leptris_doctype_get_system_id,
-        [:leptris_doctype], :string
+        [:leptris_doctype], UTF8_STRING
       attach_function :leptris_doctype_get_internal_subset,
-        [:leptris_doctype], :string
+        [:leptris_doctype], UTF8_STRING
 
       attach_function :leptris_free_string, [:pointer], :void
       attach_function :leptris_explicit_cleanup, [], :void
@@ -1196,8 +1222,8 @@ attach_function :leptris_parse_string,
       attach_function :leptris_get_memory_deallocation_function, [], :pointer
       attach_function :leptris_document_set_allocators,
         [:leptris_document, :pointer, :pointer], :leptris_status
-      attach_function :leptris_status_string, [:leptris_status], :string
-      attach_function :leptris_error_message, [:leptris_status], :string
+      attach_function :leptris_status_string, [:leptris_status], UTF8_STRING
+      attach_function :leptris_error_message, [:leptris_status], UTF8_STRING
       # Engine surface adopted with libleptris 1.9.206 (the FFI
       # mirror audit keeps attachments and exports in lockstep):
       # recover diagnostics (#1200), the standalone DTD family
@@ -1231,9 +1257,9 @@ attach_function :leptris_parse_string,
         [:pointer, :pointer], :void
       # Thread-local since v1.3.0; reliable under the
       # one-document-per-thread contract.
-      attach_function :leptris_last_error, [], :string
+      attach_function :leptris_last_error, [], UTF8_STRING
       attach_function :leptris_document_last_error,
-        [:leptris_document], :string
+        [:leptris_document], UTF8_STRING
       # Optional: release per-thread registry entries when a worker
       # thread exits (long-lived threads never need it).
       attach_function :leptris_thread_cleanup, [], :void

data/lib/leptris/xml/node.rb

@@ -545,6 +545,34 @@ class Leptris::XML::Node
     self
   end
 
+  # Visits the subtree with ONE C call, yielding ONCE per node
+  # (leptris_node_visit_entering, libleptris #1332): every node —
+  # elements included — yields (node, true, depth) exactly once, on
+  # entering. Halves the C-callback invocations against #visit for
+  # walks that never acted on the leaving half (the family-walk
+  # shape); the halving happens in the engine, not in a per-node
+  # Ruby filter. Same order and depths as #visit; read-only.
+  #
+  #     root.visit_entering { |node, entering, depth| ... }
+  def visit_entering(&block)
+    return enum_for(:visit_entering) unless block
+    ensure_alive!
+    if @addr_reads_fast
+      Leptris::XML::Native.visit_entering_binding(@document,
+                                                  @c_address, &block)
+      return self
+    end
+    document = @document
+    visitor = ::FFI::Function.new(
+      :void, [:pointer, :pointer, :int, :int], blocking: true) do |_, node_ptr, entering, depth|
+      block.call(
+        Leptris::XML::Node.wrap(node_ptr, document),
+        entering == 1, depth)
+    end
+    Leptris::XML::FFI.leptris_node_visit_entering(c_ptr, visitor, nil)
+    self
+  end
+
   # Walks the subtree in post-order DFS (matches Nokogiri's
   # semantics): the receiver, its descendants, nothing else.
   #

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [1.9.232] - 2026-09-24
+
+### Added
+
+- QT3 corpus slice 4 — sequence-edit + codepoint families, 501 gated cases; seq member fidelity fixes (xquery)
+- entering-only visit mode — leptris_node_visit_entering (#1332) (dom)
+
+### Fixed
+
+- range A to B with an empty operand yields the empty sequence (xpath)
+- expand character and predefined entity references in string literals (xpath)
+- prefixed wire names bind namespaced elements (XSD-002 fallout) (descriptor)
+
+
+
 ## [1.9.231] - 2026-09-23
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -98,7 +98,11 @@ typedef struct {
 } leptris_attr_plan;
 
 typedef struct {
-    const char* wire_name; /* XML element name as it appears on the wire */
+    const char* wire_name; /* XML element name as it appears on the wire:
+                            * the prefixed form ("w:b") binds that literal
+                            * prefix+local pair; the bare local form ("b")
+                            * binds by local name and lets ns_form do the
+                            * namespace work */
     uint8_t kind;          /* LeptrisPlanKind */
     uint8_t type_tag;      /* host-defined; echoed back verbatim */
     int32_t child_plan_index; /* NESTED: index into leptris_plan_spec.plans;

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

@@ -1195,6 +1195,23 @@ LEPTRIS_API void leptris_node_visit(LeptrisNodeRef root,
                                     LeptrisNodeVisitor visitor,
                                     void* user_data);
 
+/**
+ * Entering-only subtree visitation (issue #1332)
+ *
+ * Same walk as leptris_node_visit — document order, same depths —
+ * but the callback fires ONCE per node, on entering. Elements are
+ * not re-visited after their subtree. Halves the C-callback
+ * invocations for consumers that only act on entering=1 (the lazy
+ * family-walk shape).
+ *
+ * @param root Subtree root (any node kind, or a document node)
+ * @param visitor Callback per node (may be NULL — no-op)
+ * @param user_data Opaque context for the callback
+ */
+LEPTRIS_API void leptris_node_visit_entering(LeptrisNodeRef root,
+                                             LeptrisNodeVisitor visitor,
+                                             void* user_data);
+
 /**
  * Count the document's top-level processing instructions
  *