leptris 1.9.232.1-x86_64-linux → 1.9.237.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ba53744540c28404f1bc989ea8adc5c39748fddd122ff486c53c27d5c4ac2b9
-  data.tar.gz: 01e2933fdba151d73f3c14be0f00d1fb517030096c82ba90ac0daeb55cb0e167
+  metadata.gz: b0980ce39059f99e83b70c3ed61b4321646a504f9b8215ecd20ecc6e74186bf2
+  data.tar.gz: 90bae571c397117bf80df020632b011a992e4237b496a4239648126a70c6a18a
 SHA512:
-  metadata.gz: d2c77cd9d3679638ff28f888b7e3aa8291da2a82f772510027f3465bc04d746c782c5dc7984889cc01a43c7a1974d5147fa1a877de1fdddeb9b79403140b522d
-  data.tar.gz: 0f9decc635addafae53c4235317d09846cb784e29f3cfb4a209f9bd7edd2dff1e78b6fc012e9797e635e0c3a295ca56d042b0b36c84e38eb29b2d9c37105cc53
+  metadata.gz: 1992c190b97c21cc24b0bfd3a881bf8ed4ae989e97e80ba6addb281c8834fc93ba7ea2b03cb9b00baddd1ac62c223720f7189190d3f74b44a4b2dca817db3672
+  data.tar.gz: bb5fd9e39cb45c2aad5b363ace91319334d39c341eb4bc2894484b96db56eb8c05c4eb10b8fa310bbdfdad409bd5ebabb60d2364694776003b9db77507c59d0e

data/CHANGELOG.md

@@ -5,6 +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.237.0] - 2026-09-24
+
+### Added
+
+- `Document#create_element` accepts an attributes hash:
+  `doc.create_element("book", "id" => "1", "lang" => "en")` creates
+  the element with every attribute in ONE engine crossing
+  (leptris_element_new_with_attributes, #1344) — builder paths
+  collapse from 1 + N crossings to one. Duplicate names replace,
+  last wins; `nil` values store the empty string (engine
+  semantics). The native face falls back to create + per-pair sets
+  on pins predating #1344.
+
+### Performance — engine sync (1.9.237)
+
+- Vendored libleptris 1.9.237: typed atoms for QT3 equality
+  (typed constructors, float32, the xs: constructor surface),
+  per-function equality semantics (index-of/distinct-values/
+  deep-equal), the F&O fn:subsequence window with NaN safety and
+  member-type preservation, the xpath per-eval registry init fix,
+  QT3 slice 3 (405 gated cases), the matched-shape traversal
+  benchmark correction (#1341: the structural gap vs libxml2 is
+  1.5-1.7x, not 1.8-4.2x), and the single-crossing element
+  constructor (#1344).
+
 ## [1.9.232.0] - 2026-09-24
 
 ### Added

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.232"
+LIBLEPTRIS_VERSION = "1.9.237"
 # 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

@@ -42,6 +42,8 @@ typedef size_t (*node_offset_fn)(void *);
 typedef const char *(*element_text_fn)(void *);
 typedef void *(*doc_create_fn)(void);
 typedef void *(*elem_create_fn)(void *, const char *);
+typedef void *(*elem_new_attrs_fn)(void *, const char *, const char **,
+                                   const char **, size_t);
 typedef void *(*text_create_fn)(void *, const char *);
 typedef void *(*create_child_fn)(void *, const char *);
 typedef int (*append_child_fn)(void *, void *);
@@ -75,10 +77,14 @@ static node_offset_fn f_node_offset;
 static element_text_fn f_element_text;
 static doc_create_fn f_doc_create;
 static elem_create_fn f_elem_create;
+static elem_new_attrs_fn f_elem_new_with_attrs;
 static text_create_fn f_text_create;
 static create_child_fn f_create_child;
 static append_child_fn f_append_child;
 static append_child_fn f_prepend_child, f_insert_after, f_insert_before;
+typedef void *(*elem_new_attrs_fn)(void *, const char *, const char **,
+                                   const char **, size_t);
+static elem_new_attrs_fn f_elem_new_with_attrs;
 static set_attr_fn f_set_attr;
 typedef int (*xp_type_fn)(void *);
 typedef void (*xp_free_fn)(void *);
@@ -218,6 +224,11 @@ static void resolve_symbols(const char *lib_path)
     f_element_text = (element_text_fn)lib_sym(h, "leptris_element_text");
     f_doc_create = (doc_create_fn)lib_sym(h, "leptris_document_create");
     f_elem_create = (elem_create_fn)lib_sym(h, "leptris_element_create");
+    /* Single-crossing element construction (libleptris 1.9.237,
+     * #1344): NULL in older engine pins; the create path falls
+     * back to create + per-pair sets. */
+    f_elem_new_with_attrs =
+        (elem_new_attrs_fn)lib_sym(h, "leptris_element_new_with_attributes");
     f_text_create = (text_create_fn)lib_sym(h, "leptris_text_node_create");
     f_create_child = (create_child_fn)lib_sym(h, "leptris_element_create_child");
     f_append_child = (append_child_fn)lib_sym(h, "leptris_element_append_child");
@@ -225,6 +236,11 @@ static void resolve_symbols(const char *lib_path)
     f_insert_after = (append_child_fn)lib_sym(h, "leptris_element_insert_after");
     f_insert_before = (append_child_fn)lib_sym(h, "leptris_element_insert_before");
     f_set_attr = (set_attr_fn)lib_sym(h, "leptris_element_set_attribute");
+    /* Engine single-crossing construction (leptris#1344, 1.9.236+):
+     * optional; absent engines use the create_child + set_attr
+     * loop, which is still one Ruby->C crossing. */
+    f_elem_new_with_attrs =
+        (elem_new_attrs_fn)lib_sym(h, "leptris_element_new_with_attributes");
     f_xp_type = (xp_type_fn)lib_sym(h, "leptris_xpath_result_type");
     f_xp_free = (xp_free_fn)lib_sym(h, "leptris_xpath_result_free");
     f_first_child = (first_child_fn)lib_sym(h, "leptris_node_first_child");
@@ -1638,15 +1654,88 @@ static VALUE nf_bulk_attributes(VALUE self, VALUE addr)
 /* ---- Binding create via C (TODO.perf/09): one call creates the
  * node AND constructs the binding wrapper (class dispatch, ivars,
  * identity-cache store) — no FFI marshaling, no wrap_fresh path. */
+static int set_attr_pair(VALUE key, VALUE value, VALUE data)
+{
+    void *elem =
+        (void *)(uintptr_t)NUM2ULL(rb_ary_entry(data, 0));
+    VALUE k = RB_TYPE_P(key, T_STRING) ? key : rb_obj_as_string(key);
+    VALUE v = NIL_P(value) ? rb_usascii_str_new(0, 0)
+                           : (RB_TYPE_P(value, T_STRING) ? value
+                                                         : rb_obj_as_string(value));
+
+    rb_ary_push(rb_ary_entry(data, 1), k);
+    rb_ary_push(rb_ary_entry(data, 2), v);
+    f_set_attr(elem, RSTRING_PTR(k), RSTRING_PTR(v));
+    return ST_CONTINUE;
+}
+
 static VALUE nf_create_binding_element(VALUE self, VALUE document,
-                                       VALUE name)
+                                       VALUE name, VALUE attrs)
 {
     void *doc = doc_ptr_of(document);
-    void *ptr = f_elem_create(doc, RSTRING_PTR(StringValue(name)));
+    void *ptr;
+    VALUE name_str = StringValue(name);
     VALUE node, cache, key;
 
     (void)self;
     resolve_binding_classes();
+    if (attrs == Qnil ||
+        (RB_TYPE_P(attrs, T_HASH) && RHASH_SIZE(attrs) == 0)) {
+        ptr = f_elem_create(doc, RSTRING_PTR(name_str));
+    } else if (f_elem_new_with_attrs != NULL) {
+        /* #1344: element + every attribute in ONE crossing.
+         * Duplicate names replace, last wins; NULL values store
+         * the empty string — engine semantics, identical to
+         * per-pair set_attribute.
+         *
+         * Iteration goes through keys + aref (no rb_hash_foreach
+         * state pointer): every converted key/value is pushed into
+         * Ruby arrays BEFORE its pointer enters the C arrays, so
+         * temporaries (non-String keys, nil -> "") survive until
+         * the engine call returns — no C pointer rides through a
+         * boxed VALUE (long is 32-bit on Windows/LLP64; the
+         * foreach+boxed-struct shape truncated it and segfaulted
+         * the windows CI leg). */
+        VALUE keys, names, values;
+        const char **np, **vp;
+        long cap, i;
+        Check_Type(attrs, T_HASH);
+        cap = (long)RHASH_SIZE(attrs);
+        keys = rb_funcall(attrs, rb_intern("keys"), 0);
+        names = rb_ary_new_capa(cap);
+        values = rb_ary_new_capa(cap);
+        np = ruby_xmalloc(sizeof(char *) * (cap + 1));
+        vp = ruby_xmalloc(sizeof(char *) * (cap + 1));
+        for (i = 0; i < cap; i++) {
+            VALUE k = rb_ary_entry(keys, i);
+            VALUE v = rb_hash_aref(attrs, k);
+            k = RB_TYPE_P(k, T_STRING) ? k : rb_obj_as_string(k);
+            v = NIL_P(v) ? rb_usascii_str_new(0, 0)
+                         : (RB_TYPE_P(v, T_STRING) ? v
+                                                   : rb_obj_as_string(v));
+            rb_ary_push(names, k);
+            rb_ary_push(values, v);
+            np[i] = RSTRING_PTR(k);
+            vp[i] = RSTRING_PTR(v);
+        }
+        ptr = f_elem_new_with_attrs(doc, RSTRING_PTR(name_str),
+                                    np, vp, (size_t)cap);
+        ruby_xfree(np);
+        ruby_xfree(vp);
+    } else {
+        /* Older pin: create + per-pair sets (N+1 crossings). */
+        VALUE addr = Qnil;
+        VALUE anchor;
+        Check_Type(attrs, T_HASH);
+        anchor = rb_ary_new_capa((long)RHASH_SIZE(attrs));
+        ptr = f_elem_create(doc, RSTRING_PTR(name_str));
+        if (!ptr)
+            return Qnil;
+        addr = ULL2NUM((uint64_t)(uintptr_t)ptr);
+        rb_hash_foreach(attrs, set_attr_pair,
+                        rb_ary_new3(3, addr, anchor,
+                                    rb_ary_new_capa(0)));
+    }
     if (!ptr)
         return Qnil; /* caller raises with the error channel */
     node = rb_obj_alloc(c_b_element);
@@ -2194,6 +2283,56 @@ static VALUE nf_plan_structs_typed_p(VALUE self)
  * to the per-attribute FFI chain (first/next/get_name/get_value,
  * 4 crossings each) — the win amplifies with attribute density
  * (40-attr elements: ~7x on the listing). */
+/* ---- Single-crossing element construction (leptris#1344) --------
+ * Creates an element attached under parent (parent_addr 0 = free
+ *floating, owner document only) with all attributes set — ONE
+ * Ruby->C crossing for the whole construction. Internal calls are
+ * C->C dlsym dispatches (create_child = create+attach in one
+ * engine call; set_attr per attribute). Returns the new node's
+ * address for wrapper minting. */
+static VALUE nf_create_element_with_attrs(VALUE self, VALUE document,
+                                          VALUE parent_addr, VALUE name,
+                                          VALUE attrs)
+{
+    (void)self;
+    (void)document;
+    void *parent = NIL_P(parent_addr)
+                       ? NULL
+                       : (void *)(uintptr_t)NUM2ULL(parent_addr);
+    const char *cname = StringValueCStr(name);
+
+    if (f_elem_new_with_attrs && parent && RARRAY_LEN(attrs) > 0 &&
+        RARRAY_LEN(attrs) % 2 == 0) {
+        /* Engine single-crossing construction (1.9.236+): arena
+         * create + all attributes with no per-attr calls at all. */
+        long n = RARRAY_LEN(attrs) / 2;
+        const char **names = ALLOCA_N(const char *, n);
+        const char **values = ALLOCA_N(const char *, n);
+        for (long i = 0; i < n; i++) {
+            /* Hoist to lvalues: truffleruby's StringValueCStr takes
+             * the address of its argument (RARRAY_AREF is not one). */
+            VALUE an = RARRAY_AREF(attrs, 2 * i);
+            VALUE av = RARRAY_AREF(attrs, 2 * i + 1);
+            names[i] = StringValueCStr(an);
+            values[i] = StringValueCStr(av);
+        }
+        void *elem = f_elem_new_with_attrs(parent, cname, names, values,
+                                           n);
+        return elem ? ULL2NUM((uintptr_t)elem) : Qnil;
+    }
+
+    void *elem = parent ? f_create_child(parent, cname) : NULL;
+    if (!elem) return Qnil;
+
+    long i, n = RARRAY_LEN(attrs);
+    for (i = 0; i + 1 < n; i += 2) {
+        VALUE an = RARRAY_AREF(attrs, i);
+        VALUE av = RARRAY_AREF(attrs, i + 1);
+        f_set_attr(elem, StringValueCStr(an), StringValueCStr(av));
+    }
+    return ULL2NUM((uintptr_t)elem);
+}
+
 static VALUE nf_attribute_rows(VALUE self, VALUE document, VALUE addr)
 {
     (void)self;
@@ -2808,6 +2947,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_plan_structs, 3);
     rb_define_module_function(m_native, "attribute_rows",
                               nf_attribute_rows, 2);
+    rb_define_module_function(m_native, "create_element_with_attrs",
+                              nf_create_element_with_attrs, 4);
     rb_define_module_function(m_native, "plan_structs_typed?",
                               nf_plan_structs_typed_p, 0);
     rb_define_module_function(m_native, "doc_handle_attach",
@@ -2822,7 +2963,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     rb_define_module_function(m_native, "bulk_attr_faces",
                               nf_bulk_attr_faces, 2);
     rb_define_module_function(m_native, "create_binding_element",
-                              nf_create_binding_element, 2);
+                              nf_create_binding_element, 3);
     rb_define_module_function(m_native, "create_binding_text",
                               nf_create_binding_text, 2);
     rb_define_module_function(m_native, "bulk_children", nf_bulk_children, 2);

data/lib/leptris/version.rb

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

data/lib/leptris/xml/document.rb

@@ -389,15 +389,32 @@ class Leptris::XML::Document
     element
   end
 
-  def create_element(name)
+  # attributes: optional Hash of {name => value} applied in the
+  # SAME engine crossing as construction
+  # (leptris_element_new_with_attributes, #1344) — builder paths
+  # collapse from 1 + N crossings to one. nil values store the
+  # empty string; duplicate names replace, last wins (engine
+  # semantics, identical to per-pair set_attribute).
+  def create_element(name, attributes = nil)
     # TODO.perf/09: one C call creates + wraps when the ext is
     # loaded — no FFI marshaling, no wrap_fresh frames.
     if defined?(Leptris::XML::NATIVE_FAST)
-      node = Leptris::XML::Native.create_binding_element(self, name.to_s)
+      node = Leptris::XML::Native.create_binding_element(
+        self, name.to_s, attributes)
       raise Leptris::XML::Error, "leptris_element_create failed" if node.nil?
       return node
     end
-    ptr = Leptris::XML::FFI.leptris_element_create(c_ptr, name)
+    ptr =
+      if attributes && !attributes.empty?
+        names = attributes.map { |k, _| k.to_s }
+        values = attributes.map { |_, v| v.nil? ? "" : v.to_s }
+        nb, na = Leptris::XML::CStringArray.to_c(names)
+        vb, va = Leptris::XML::CStringArray.to_c(values)
+        Leptris::XML::FFI.leptris_element_new_with_attributes(
+          c_ptr, name.to_s, nb, vb, names.size)
+      else
+        Leptris::XML::FFI.leptris_element_create(c_ptr, name)
+      end
     raise Leptris::XML::Error, "leptris_element_create failed" if ptr.null?
     Leptris::XML::Node.wrap_fresh(ptr, self, Leptris::XML::FFI::NODE_ELEMENT)
   end

data/lib/leptris/xml/ffi.rb

@@ -716,6 +716,13 @@ attach_function :leptris_parse_string,
       attach_function :leptris_element_previous_sibling_any,
         [:leptris_element], :leptris_element
 
+      # Single-crossing element construction (libleptris 1.9.237,
+      # #1344): element + every attribute in one C call. The name
+      # and value arrays are count-bounded char** (the NULL
+      # terminators CStringArray appends are simply never read).
+      attach_function :leptris_element_new_with_attributes,
+        [:leptris_document, :string, :pointer, :pointer, :size_t],
+        :leptris_element
       attach_function :leptris_element_create,
         [:leptris_document, :string], :leptris_element
       attach_function :leptris_element_set_name,

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,102 @@
 ## [Unreleased]
 
+## [1.9.237] - 2026-09-24
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Added
+
+- dom: `leptris_element_new_with_attributes` — single-crossing
+  element construction (#1344). One call creates the element in the
+  document arena with every attribute attached — identical per-pair
+  semantics to leptris_element_set_attribute (duplicate names
+  replace, last wins; NULL values store the empty string). Builder
+  paths collapse from 1 + N crossings plus wrapper allocations per
+  node to a single crossing.
+
+
+## [1.9.236] - 2026-09-24
+
+### Added
+
+- xpath: fn:subsequence implements the F&O window in position space —
+  NaN start/length yields empty, the window is NaN-safe including
+  -INF + INF = NaN, positions are never clamped to 1, the 2-arg form
+  is unbounded, and start/length round half-up like fn:round
+  (cbcl-subsequence-001..009, K2-5).
+- xpath: boolean and xs:decimal sequence members carry their type
+  (\x03B/\x03D markers) — a false boolean stays falsy through
+  fn:subsequence/fn:remove round-trips (EBV reads the marker) and
+  xs:decimal equality compares lexically where the double carrier
+  cannot hold 30 significant digits.
+- xpath: fn:subsequence and fn:remove preserve member types, so
+  `instance of`, deep-equal and effective boolean value agree across
+  the round-trip.
+- QT3 runner: assert-permutation evaluates expected items as
+  expressions.
+
+### Fixed
+
+- QT3 corpus: subsequence 51→61, distinct-values 84→87, remove
+  21→23 adopted; typed-atom pins 86→67.
+
+
+
+## [1.9.235] - 2026-09-24
+
+### Added
+
+- xpath: typed atoms for QT3 equality — an atomic_type channel on
+  XPath results (typed constructors carry interned type names),
+  float32 precision for xs:float (float(1.01) ne double(1.01) while
+  decimal-vs-float promotes per F&O rank), typed \x03F sequence
+  markers, and the missing constructor surface (xs:untypedAtomic,
+  xs:hexBinary, xs:base64Binary, xs:gYear/gYearMonth/gMonthDay/
+  gMonth/gDay).
+
+### Fixed
+
+- xpath: per-function equality semantics — fn:index-of never matches
+  NaN and does not coerce numbers to strings; fn:distinct-values
+  dedups NaN with itself and keeps the first spelling
+  (distinct((1, 2.0, 3, 2)) = 1, 2.0, 3); fn:reverse, fn:index-of and
+  fn:distinct-values preserve sequence-member types.
+- xpath: fn:deep-equal ignores comment/PI children (F&O 3.0),
+  compares typed string classes (xs:date vs string = false), and
+  accepts the 3-argument collation form.
+- QT3 corpus: deep-equal 180→192, distinct-values 74→84, index-of
+  34→42, reverse 53→57 adopted (125 typed-atom pins → 86).
+
+
+
+## [1.9.234] - 2026-09-24
+
+### Fixed
+
+- benchmarks: the DOM Tree Traversal row now walks the documented
+  O(1) iteration shape (`leptris_element_first_child_any` +
+  `leptris_element_next_sibling_any`). The previous shape used
+  `child_count()` + indexed `child(elem, i)` — O(N^2/2) re-seeking
+  per parent — which measured the indexed-lookup algorithm instead of
+  per-hop engine cost, overstating the libxml2 gap at 1.8-4.2x.
+  Matched-shape gap vs libxml2 is 1.5-1.7x (#1341, closed as the
+  structural cost of the 64-byte compact node design).
+
+
+
+## [1.9.233] - 2026-09-24
+
+### Added
+
+- QT3 corpus slice 3 — empty/exists/head/tail/count, 405 gated cases (xquery)
+
+### Fixed
+
+- initialize registry_borrowed on every context init (xpath)
+
+
+
 ## [1.9.232] - 2026-09-24
 
 ### Added
@@ -591,9 +688,15 @@ W3C QT3 suite as the gate:
 <!-- Edit this section with the actual release notes. -->
 <!-- See https://keepachangelog.com for format guidance. -->
 
-### Changed
+### Added
 
-- (describe changes here)
+- dom: `leptris_element_new_with_attributes` — single-crossing
+  element construction (#1344). One call creates the element in the
+  document arena with every attribute attached — identical per-pair
+  semantics to leptris_element_set_attribute (duplicate names
+  replace, last wins; NULL values store the empty string). Builder
+  paths collapse from 1 + N crossings plus wrapper allocations per
+  node to a single crossing.
 
 
 ## [1.9.200] - 2026-09-18
@@ -8293,9 +8396,15 @@ fall back to the legacy parser.
 <!-- Edit this section with the actual release notes. -->
 <!-- See https://keepachangelog.com for format guidance. -->
 
-### Changed
+### Added
 
-- (describe changes here)
+- dom: `leptris_element_new_with_attributes` — single-crossing
+  element construction (#1344). One call creates the element in the
+  document arena with every attribute attached — identical per-pair
+  semantics to leptris_element_set_attribute (duplicate names
+  replace, last wins; NULL values store the empty string). Builder
+  paths collapse from 1 + N crossings plus wrapper allocations per
+  node to a single crossing.
 
 
 All notable changes to Leptris will be documented in this file.

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/benchmarks/dom/bench_leptris.c

@@ -35,7 +35,14 @@ typedef struct {
     LeptrisDocument doc;
 } doc_ctx_t;
 
-/* Recursive tree traversal helper */
+/* Recursive tree traversal helper.
+ *
+ * Walks the same shape as the libxml2 bench (hop EVERY child via the
+ * sibling link, recurse into elements): first_child_any +
+ * next_sibling_any is the documented O(1)-per-step iteration. The
+ * previous shape — child_count() + child(elem, i) — re-seeked the
+ * child list from its head per access, O(N²/2) hops per parent, which
+ * measured the indexed-lookup algorithm, not per-hop engine cost. */
 static void traverse_tree(LeptrisElement elem) {
     if (!elem) return;
 
@@ -43,11 +50,12 @@ static void traverse_tree(LeptrisElement elem) {
     const char* name = leptris_element_name(elem);
     (void)name;
 
-    /* Traverse children */
-    size_t child_count = leptris_element_child_count(elem);
-    for (size_t i = 0; i < child_count; i++) {
-        LeptrisElement child = leptris_element_child(elem, i);
-        traverse_tree(child);
+    /* Traverse children (hop every child; recurse into elements) */
+    for (LeptrisElement child = leptris_element_first_child_any(elem);
+         child; child = leptris_element_next_sibling_any(child)) {
+        if (leptris_node_get_type((LeptrisNodeRef)child) ==
+            LEPTRIS_NODE_TYPE_ELEMENT)
+            traverse_tree(child);
     }
 }
 

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

@@ -1984,6 +1984,33 @@ LEPTRIS_API size_t leptris_element_hash_value(LeptrisElement elem);
  */
 LEPTRIS_API LeptrisElement leptris_element_create(LeptrisDocument doc, const char* name);
 
+/**
+ * Create a new element with attributes set in one call (#1344)
+ *
+ * The fused twin of create + N x set_attribute: one crossing
+ * builds the element with every attribute attached — the
+ * builder-shape answer for programmatic document construction.
+ * Attribute semantics are identical to leptris_element_set_attribute
+ * per pair (same name handling, same value copy); a duplicate name
+ * replaces, last wins.
+ *
+ * @param doc Document that will own the element
+ * @param name Element name (QName prefixes handled like
+ *             leptris_element_create)
+ * @param attr_names Attribute names; may be NULL when attr_count
+ *                   is 0. A NULL element or NULL name string fails
+ *                   the call.
+ * @param attr_values Attribute values; a NULL entry stores the
+ *                    empty string
+ * @param attr_count Number of name/value pairs
+ * @return New element or NULL on error
+ *
+ * Memory: Element owned by document, freed when document freed
+ */
+LEPTRIS_API LeptrisElement leptris_element_new_with_attributes(
+    LeptrisDocument doc, const char* name, const char** attr_names,
+    const char** attr_values, size_t attr_count);
+
 /**
  * Set element name (rename element tag)
  *

data/vendor-src/libleptris/src/leptris/dom/element_modify.c

@@ -232,6 +232,26 @@ LeptrisElement leptris_element_create(LeptrisDocument doc, const char* name) {
     return elem;
 }
 
+/* #1344: fused create + attribute-set — one crossing for the
+ * builder path. Identical per-pair semantics to
+ * leptris_element_set_attribute. */
+LeptrisElement leptris_element_new_with_attributes(
+        LeptrisDocument doc, const char* name, const char** attr_names,
+        const char** attr_values, size_t attr_count) {
+    LeptrisElement elem = leptris_element_create(doc, name);
+    if (!elem) return NULL;
+    if (attr_count && !attr_names) return NULL;
+    for (size_t i = 0; i < attr_count; i++) {
+        if (!attr_names[i]) return NULL;
+        if (leptris_element_set_attribute(
+                elem, attr_names[i],
+                (attr_values && attr_values[i]) ? attr_values[i] : "") !=
+            LEPTRIS_OK)
+            return NULL;
+    }
+    return elem;
+}
+
 /**
  * Append child element (Public API)
  */

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

@@ -649,6 +649,11 @@ struct leptris_xpath_result {
      * free-list. */
     int is_int;
     long long int_value;
+    /* Typed-atom tag (QT3 slice): interned type name ("xs:date",
+     * "xs:float", ...) when the atom came from a typed constructor,
+     * NULL for the untyped/string class. NOT owned — static
+     * literals only. Cleared in result_new (free-list recycle). */
+    const char* atomic_type;
 };
 
 /* Namespace mapping for XPath context (v0.8.0) */

data/vendor-src/libleptris/src/leptris/xpath/evaluator.c

@@ -126,6 +126,12 @@ void xpath_context_init(XPathContext* context,
     context->input_len = 0;
 
     extern XPathFunctionRegistry* leptris_xpath_build_custom_registry(struct leptris_document*);
+    /* The borrow flag MUST be established on every init: the
+     * context is stack storage and cleanup's registry-free is
+     * gated on this flag — stale stack bytes read as borrowed=1
+     * and leak the per-eval XQuery registry (the common no-custom
+     * -fns path never wrote the flag). */
+    context->registry_borrowed = 0;
     context->function_registry = leptris_xpath_build_custom_registry(document);
     if (!context->function_registry) {
         context->function_registry = xpath_function_registry_get_standard();
@@ -736,6 +742,7 @@ struct leptris_xpath_result* xpath_result_new(XPathResultType type) {
 
     result->type = type;
     result->is_int = 0;   /* free-list recycling would leak it */
+    result->atomic_type = NULL;
 
     /* Initialize union based on type. XPATH_RESULT_CACHED is the
      * free-list sentinel — a fresh result never carries it. */