leptris 1.9.255.1 → 1.9.260.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80db2239df7aa12318a22410954564698cad3c4d42955c42222939d970881910
-  data.tar.gz: d7e27ab76785965b5ccd4a10e8bf3cb9999cb2d145d88956602e970bde6f0963
+  metadata.gz: 719ba38dafe5b398d166a1f53a629fca56336f077756d23e64bfb287387547ba
+  data.tar.gz: d228ec1939792d3e06349b1349917735dc65aa2f34e7dc70b186140fc79ec46e
 SHA512:
-  metadata.gz: b8340ac642d3e6e09f2080bec1131d090773ad39aa9b983b87f9b7222c57580d180e11dc551522ed47f2c10d47c9f6c2a763b01abe6e71c31c4bd6f1672774bb
-  data.tar.gz: ab4582f730fe04b6e6ede9a89fcbb9791bbbb4f55d0627a3dbc9caabad03874334ee3c2069bdb9030e876816f8a8932afd36b3faeb8fbcc0f1ce2d1727ade037
+  metadata.gz: 41ab471e5e9b3cf63ea73db78c096514f059949f2bbcf97bc64ee5fe1c9f6523131b875c1397f18ab0d1157e5ebeeeb36fb892da549d80b2c2114f365996e4b3
+  data.tar.gz: ea4e2d9a746e7be541d10abe280e77ed96ce5891f4ec66e2b9c7fda0132f024774a8d3c11c0c818b0b9e2b87013e0a5bb6f57f27813b54ff8ff03b419aa9e293

data/CHANGELOG.md

@@ -5,6 +5,23 @@ 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.260.0] - 2026-09-27
+
+### Fixed
+
+- Vendored libleptris 1.9.260 (riding 1.9.256-1.9.260):
+  - xquery: numeric variable predicates are positional, not EBV
+    (v1.9.256); typed-scalar carriers convert in the single-item
+    predicate path (v1.9.259); the bare FLWOR initializer scan
+    terminates at outer clause words (v1.9.260).
+
+### Performance — engine sync
+
+- Lane 18 rounds 1-2 (v1.9.257/258): duplicate-attribute scan via
+  a per-element FNV-1a hash prefilter (was an O(N^2) memcmp walk)
+  and namebp document resolution before the locked root-map
+  lookup — builder append 39.7 -> ~30 ns/child.
+
 ## [1.9.255.0] - 2026-09-26
 
 ### 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.255"
+LIBLEPTRIS_VERSION = "1.9.260"
 # 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

@@ -627,6 +627,60 @@ static void *doc_ptr_of(VALUE document)
 /* Per-document identity caches. Both are lazily allocated on the
  * Ruby side (@x ||= {}), so replicate that here: ivar read, create
  * and store when unset. */
+/* #340: per-document wrapper-klass registration. The ivar holds an
+ * Array of classes/nil indexed by node kind (the same shape
+ * install_child_klasses uses at the klass level). When an entry is
+ * set, the walk cache AND the create faces mint that klass
+ * (NativeNode subclass, TypedData path) instead of the binding
+ * wrapper classes — consumers receive their own contract-carrying
+ * nodes straight from C, and their re-wrap drops out. */
+static ID id_iv_doc_klass_map;
+
+static VALUE doc_klass_for_kind(VALUE document, int kind)
+{
+    VALUE map = rb_ivar_get(document, id_iv_doc_klass_map);
+    VALUE k;
+    if (NIL_P(map)) return Qnil;
+    k = rb_ary_entry(map, (long)kind);
+    return RB_TYPE_P(k, T_CLASS) ? k : Qnil;
+}
+
+static VALUE mint_consumer_node(VALUE klass, VALUE document, void *ptr)
+{
+    struct native_node *n;
+    VALUE node =
+        TypedData_Make_Struct(klass, struct native_node, &nn_type, n);
+    n->ptr = ptr;
+    n->document = document;
+    rb_hash_aset(native_cache_of(document),
+                 ULL2NUM((uint64_t)(uintptr_t)ptr), node);
+    return node;
+}
+
+static VALUE nf_register_doc_klasses(VALUE self, VALUE document, VALUE map)
+{
+    long i, len;
+    (void)self;
+    resolve_binding_classes();
+    Check_Type(map, T_ARRAY);
+    len = RARRAY_LEN(map);
+    if (len > 5)
+        rb_raise(rb_eArgError,
+                 "wrapper klasses: Array of classes/nil indexed by "
+                 "node kind (element, text, comment, cdata, pi)");
+    for (i = 0; i < len; i++) {
+        VALUE k = rb_ary_entry(map, i);
+        if (!NIL_P(k) &&
+            !(RB_TYPE_P(k, T_CLASS) &&
+              RTEST(rb_class_inherited_p(k, c_native_node))))
+            rb_raise(rb_eTypeError,
+                     "wrapper klasses entries must be nil or a "
+                     "Leptris::XML::NativeNode subclass");
+    }
+    rb_ivar_set(document, id_iv_doc_klass_map, map);
+    return document;
+}
+
 static VALUE native_cache_of(VALUE document)
 {
     VALUE cache = rb_ivar_get(document, id_iv_native_cache);
@@ -877,7 +931,20 @@ static VALUE trav_wrapper_for(struct trav_state *st, void *node_ptr,
                               int kind)
 {
     VALUE key = ULL2NUM((uint64_t)(uintptr_t)node_ptr);
-    VALUE node = rb_hash_aref(st->cache, key);
+    VALUE node;
+    VALUE ck = doc_klass_for_kind(st->document, kind);
+
+    /* #340 klass-parameterized walk cache: registered consumer
+     * klasses mint (and identity-cache) through the TypedData
+     * path — nodes arrive already being the consumer's wrapper. */
+    if (!NIL_P(ck)) {
+        VALUE ncache = native_cache_of(st->document);
+        node = rb_hash_aref(ncache, key);
+        if (!NIL_P(node)) return node;
+        return mint_consumer_node(ck, st->document, node_ptr);
+    }
+
+    node = rb_hash_aref(st->cache, key);
     if (!NIL_P(node)) return node;
 
     node = rb_obj_alloc(binding_klass_for(kind));
@@ -2290,20 +2357,15 @@ static VALUE nf_plan_structs_typed_p(VALUE self)
  * 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 *doc_ptr = NIL_P(document)
-                        ? NULL
-                        : (void *)(uintptr_t)NUM2ULL(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 && doc_ptr && parent && RARRAY_LEN(attrs) > 0 &&
-        RARRAY_LEN(attrs) % 2 == 0) {
+/* Creation core shared by the raw-address face and the #340
+ * wrapper-returning variant: single-crossing arena create +
+ * attributes when the engine has #1344, else create + per-pair
+ * sets. Returns the raw element pointer (NULL on failure). */
+static void *create_elem_core(void *doc_ptr, void *parent,
+                              const char *cname, VALUE attrs)
+{
+    if (f_elem_new_with_attrs && doc_ptr && 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;
@@ -2319,15 +2381,15 @@ static VALUE nf_create_element_with_attrs(VALUE self, VALUE document,
         }
         void *elem = f_elem_new_with_attrs(doc_ptr, cname, names,
                                            values, n);
-        if (!elem) return Qnil;
+        if (!elem) return NULL;
         /* The face creates a floating element owned by the
          * document — append under the parent afterwards. */
-        if (parent) f_append_child(parent, elem);
-        return ULL2NUM((uintptr_t)elem);
+        f_append_child(parent, elem);
+        return elem;
     }
 
     void *elem = parent ? f_create_child(parent, cname) : NULL;
-    if (!elem) return Qnil;
+    if (!elem) return NULL;
 
     long i, n = RARRAY_LEN(attrs);
     for (i = 0; i + 1 < n; i += 2) {
@@ -2335,7 +2397,65 @@ static VALUE nf_create_element_with_attrs(VALUE self, VALUE document,
         VALUE av = RARRAY_AREF(attrs, i + 1);
         f_set_attr(elem, StringValueCStr(an), StringValueCStr(av));
     }
-    return ULL2NUM((uintptr_t)elem);
+    return elem;
+}
+
+static VALUE nf_create_element_with_attrs(VALUE self, VALUE document,
+                                          VALUE parent_addr, VALUE name,
+                                          VALUE attrs)
+{
+    void *doc_ptr = NIL_P(document)
+                        ? NULL
+                        : (void *)(uintptr_t)NUM2ULL(document);
+    void *parent = NIL_P(parent_addr)
+                       ? NULL
+                       : (void *)(uintptr_t)NUM2ULL(parent_addr);
+    void *elem = create_elem_core(doc_ptr, parent,
+                                  StringValueCStr(name), attrs);
+    return elem ? ULL2NUM((uintptr_t)elem) : Qnil;
+}
+
+/* #340 construction registration: create + attach + attributes in
+ * one crossing AND mint the wrapper C-side — the registered
+ * consumer klass when one is installed for elements (TypedData
+ * path + native-cache identity), else the binding Element minted
+ * exactly like nf_create_binding_element. The caller receives a
+ * contract-carrying node straight from the crossing; no separate
+ * Node.wrap, no consumer re-wrap. */
+static VALUE nf_create_element_with_attrs_wrapped(
+    VALUE self, VALUE document, VALUE parent_addr, VALUE name,
+    VALUE attrs)
+{
+    void *doc_ptr = doc_ptr_of(document);
+    void *parent = NIL_P(parent_addr)
+                       ? NULL
+                       : (void *)(uintptr_t)NUM2ULL(parent_addr);
+    void *elem = create_elem_core(doc_ptr, parent,
+                                  StringValueCStr(name), attrs);
+    VALUE ck, key, node, cache;
+
+    (void)self;
+    if (!elem) return Qnil;
+    resolve_binding_classes();
+    ck = doc_klass_for_kind(document, 0 /* element */);
+    if (!NIL_P(ck))
+        return mint_consumer_node(ck, document, elem);
+
+    key = ULL2NUM((uint64_t)(uintptr_t)elem);
+    cache = binding_cache_of(document);
+    node = rb_hash_aref(cache, key);
+    if (!NIL_P(node)) return node;
+    node = rb_obj_alloc(c_b_element);
+    rb_iv_set(node, "@c_address", key);
+    rb_iv_set(node, "@document", document);
+    rb_iv_set(node, "@parent", Qnil);
+    rb_iv_set(node, "@structure_memoizable", Qtrue);
+    rb_iv_set(node, "@native_fast", Qtrue);
+    rb_iv_set(node, "@pub_document", document);
+    rb_iv_set(node, "@addr_reads_fast", Qtrue);
+    rb_iv_set(node, "@node_type", INT2FIX(0));
+    rb_hash_aset(cache, key, node);
+    return node;
 }
 
 static VALUE nf_attribute_rows(VALUE self, VALUE document, VALUE addr)
@@ -2844,6 +2964,7 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
     id_iv_nn_attrs = rb_intern("@nn_attrs");
     id_iv_nn_attrs_ver = rb_intern("@nn_attrs_ver");
     id_child_klasses = rb_intern("@nn_child_klasses");
+    id_iv_doc_klass_map = rb_intern("@doc_klass_map");
     id_iv_doc_handle = rb_intern("@doc_handle");
     id_freed_new = rb_intern("new");
     id_alive = rb_intern("alive");
@@ -2954,6 +3075,11 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               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, "register_doc_klasses",
+                              nf_register_doc_klasses, 2);
+    rb_define_module_function(m_native,
+                              "create_element_with_attrs_wrapped",
+                              nf_create_element_with_attrs_wrapped, 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",

data/lib/leptris/version.rb

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

data/lib/leptris/xml/native_layer.rb

@@ -75,6 +75,18 @@ class Leptris::XML::Document
     Leptris::XML::NativeNode.from(self, r.c_ptr)
   end
 
+  # #340: per-kind wrapper-klass registration for THIS document.
+  # map is an Array of classes/nil indexed by node kind (element,
+  # text, comment, cdata, pi) — the same shape
+  # NativeNode.install_child_klasses uses. Once registered, the C
+  # walk cache (trav/visit) and the create faces mint those
+  # klasses directly (TypedData path, native-cache identity), so
+  # consumers receive their own contract-carrying nodes straight
+  # from the crossing with no re-wrap.
+  def register_wrapper_klasses(map)
+    Leptris::XML::Native.register_doc_klasses(self, map)
+  end
+
   # Builder factories that return NativeNodes (#149): one C call
   # and a TypedData wrap — no FFI::Pointer, no wrap_fresh path.
   def native_create_element(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.255
+- libleptris v1.9.260
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,49 @@
 ## [Unreleased]
 
+## [1.9.260] - 2026-09-27
+
+### Fixed
+
+- bare FLWOR initializer scan terminates at outer clause words (xquery)
+
+
+
+## [1.9.259] - 2026-09-26
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.258] - 2026-09-26
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.257] - 2026-09-26
+
+### Performance
+
+- resolve namebp documents before the locked root-map lookup (dom)
+
+
+
+## [1.9.256] - 2026-09-26
+
+### Fixed
+
+- numeric variable predicates are positional, not EBV (xquery)
+
+
+
 ## [1.9.255] - 2026-09-26
 
 <!-- Edit this section with the actual release notes. -->

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -414,6 +414,14 @@ struct leptris_document* leptris_element_get_document(LeptrisElement elem) {
         if (!parent) break;
         cur = parent;
     }
+    /* Lane 18 P2: resolve the namebp backpointer BEFORE the locked
+     * map. Fast-path-created roots (mut_elem_carve) carry the doc
+     * statelessly in the name slot and never register, so the map
+     * below always misses for them — the append/builder loop paid
+     * the mutex on every call to reach the same answer. The namebp
+     * value is stamped at create and cannot go stale. */
+    if (cur->name && leptris_elem_has_namebp(cur))
+        return leptris_elem_namebp_doc(cur);
     /* Locked bucket walk with an UNDER-THE-LOCK generation
      * snapshot: a death that acquires the lock after we release
      * bumps the global generation past our snapshot, so the primed

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

@@ -1004,7 +1004,8 @@ struct leptris_xpath_result* evaluate_expr(XPathContext* ctx, XPathASTNode* ast)
                     ctx->context_position = 1;
                     ctx->context_size = 1;
                     struct leptris_xpath_result* pr =
-                        evaluate_expr(ctx, pred);
+                        leptris_pred_scalar_convert(
+                            evaluate_expr(ctx, pred));
                     ctx->context_node = old_node;
                     ctx->context_position = old_pos;
                     ctx->context_size = old_size;

data/vendor-src/libleptris/src/leptris/xpath/evaluator_internal.h

@@ -76,6 +76,11 @@ struct leptris_xpath_result* evaluate_expr(XPathContext* ctx, XPathASTNode* ast)
 /* Marker-aware atomic eq over raw item strings (evaluator_operators.c). */
 int leptris_atom_seq_eq_n(const char* a, const char* b, int nan_equal);
 
+/* Typed-scalar carrier conversion for predicates (evaluator_path.c):
+ * takes ownership; single numeric-marker carriers become NUMBER. */
+struct leptris_xpath_result* leptris_pred_scalar_convert(
+    struct leptris_xpath_result* r);
+
 /* xs:time lexical -> timezone-normalized seconds (cycle = mod 86400
  * for equality; linear = unbounded for ordering); either out may be
  * NULL. Returns 0 when s is not a time lexical. */

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

@@ -281,6 +281,34 @@ int matches_node_test(XPathContext* ctx, LeptrisNode* node, XPathASTNode* test)
 /* Helper: Evaluate a single predicate for a node in-place
  * Returns 1 if node matches predicate, 0 otherwise
  */
+/* Typed-scalar carrier conversion for predicates: the xq driver
+ * binds every variable as a sequence carrier, so a numeric atomic
+ * rides one marked text node. A bare variable predicate must then be
+ * POSITIONAL (number -> position compare), not EBV-of-a-one-item
+ * sequence (cbcl-distinct-values-007). Takes ownership of r; when
+ * converted, the carrier copy is freed through the result and a
+ * fresh NUMBER result returns. NULL propagates. */
+struct leptris_xpath_result* leptris_pred_scalar_convert(
+    struct leptris_xpath_result* r) {
+    if (!r || r->type != XPATH_RESULT_NODESET || !r->value.nodeset_value ||
+        r->value.nodeset_value->count != 1 ||
+        !r->value.nodeset_value->nodes[0] ||
+        XPATH_NODE_TYPE(r->value.nodeset_value->nodes[0]) !=
+            LEPTRIS_NODE_TEXT)
+        return r;
+    const char* c =
+        ((XPathTextNode*)r->value.nodeset_value->nodes[0])->content;
+    if (!c || c[0] != '\x03' ||
+        (c[1] != 'N' && c[1] != 'F' && c[1] != 'D'))
+        return r;
+    double v = strtod(c + 2, NULL);
+    xpath_result_free(r);
+    struct leptris_xpath_result* out =
+        xpath_result_new(XPATH_RESULT_NUMBER);
+    if (out) out->value.number_value = v;
+    return out;
+}
+
 static int evaluate_predicate_for_node(XPathContext* ctx,
                                        void* node,
                                        XPathASTNode* predicate,
@@ -328,6 +356,9 @@ static int evaluate_predicate_for_node(XPathContext* ctx,
     struct leptris_xpath_result* pred_result = evaluate_expr(ctx, predicate);
     int matches = 0;
 
+    pred_result = leptris_pred_scalar_convert(pred_result);
+    if (!pred_result) return 0;
+
     if (pred_result) {
         /* Numeric predicate: matches position */
         if (pred_result->type == XPATH_RESULT_NUMBER) {

data/vendor-src/libleptris/src/leptris/xquery/xquery.c

@@ -173,24 +173,39 @@ static int is_clause_word(const char* w, size_t len) {
 /* Advance over one FLWOR expression segment: stops before a clause
  * keyword at nesting depth 0 (a bare word delimited by whitespace
  * or segment end). */
-static void scan_expr_segment(Scan* s, int stop_at_comma) {
+static void scan_expr_segment(Scan* s, int stop_at_comma,
+                              int allow_bare_flwor) {
     int depth = 0;
+    /* A binding expression that STARTS with for/let is a bare
+     * nested FLWOR (let $x := for ... return ...): its clause
+     * keywords are inert and `return` closes the nesting. Segments
+     * that merely CONTAIN a depth-0 for/let after a complete
+     * expression (for $i in (1,2,3) let ...) keep the old boundary.
+     * allow_bare_flwor arms the check for the first word only. */
+    int flwor_nest = 0;
+    int seen_token = 0;   /* any non-space token consumed yet? */
     while (s->p < s->end) {
         char c = *s->p;
         if (c == '\'' || c == '"') {
             scan_string(s);
+            seen_token = 1;
             continue;
         }
         if (c == '`') {
             s->p++;
             while (s->p < s->end && *s->p != '`') s->p++;
             if (s->p < s->end) s->p++;
+            seen_token = 1;
             continue;
         }
-        if (c == '(' || c == '[' || c == '{') depth++;
+        if (c == '(' || c == '[' || c == '{') {
+            depth++;
+            seen_token = 1;
+        }
         else if (c == ')' || c == ']' || c == '}') {
             if (depth == 0) return;   /* segment boundary */
             depth--;
+            seen_token = 1;
         } else if (c == ',' && depth == 0 && stop_at_comma) {
             return;
         } else if (depth == 0 &&
@@ -202,9 +217,25 @@ static void scan_expr_segment(Scan* s, int stop_at_comma) {
                  * by whitespace/segment end. scan_word does not
                  * advance the cursor — look past the word. */
                 const char* after = w + wl;
-                if (after >= s->end || isspace((unsigned char)*after))
-                    return;
+                int at_boundary =
+                    after >= s->end || isspace((unsigned char)*after);
+                if (at_boundary && !seen_token && allow_bare_flwor &&
+                    (word_is(w, wl, "for") || word_is(w, wl, "let"))) {
+                    flwor_nest = 1;
+                    seen_token = 1;
+                    s->p += wl;
+                    continue;
+                }
+                if (at_boundary && flwor_nest > 0) {
+                    if (word_is(w, wl, "return")) flwor_nest--;
+                    seen_token = 1;
+                    s->p += wl;
+                    continue;
+                }
+                seen_token = 1;
+                if (at_boundary) return;
             }
+            seen_token = 1;
             s->p += wl ? wl : 1;
             continue;
         }
@@ -1424,7 +1455,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                             }
                             s.p = iw + iwl;
                             Scan e = s;
-                            scan_expr_segment(&e, 0);
+                            scan_expr_segment(&e, 0, 0);
                             wc.win.domain = parse_expr_span(s.p, e.p);
                             if (!wc.win.domain) {
                                 xq_clause_partial_free(&wc);
@@ -1471,7 +1502,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                                 if (wwl2 && word_is(ww, wwl2, "when")) {
                                     s.p = ww + wwl2;
                                     Scan se = s;
-                                    scan_expr_segment(&se, 0);
+                                    scan_expr_segment(&se, 0, 0);
                                     wc.win.s_when =
                                         parse_expr_span(s.p, se.p);
                                     if (!wc.win.s_when) {
@@ -1520,7 +1551,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                                     if (wwl2 && word_is(ww, wwl2, "when")) {
                                         s.p = ww + wwl2;
                                         Scan ee = s;
-                                        scan_expr_segment(&ee, 0);
+                                        scan_expr_segment(&ee, 0, 0);
                                         wc.win.e_when =
                                             parse_expr_span(s.p, ee.p);
                                         if (!wc.win.e_when) {
@@ -1616,7 +1647,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                             s.p += 2;
                         }
                         Scan e = s;
-                        scan_expr_segment(&e, 1);
+                        scan_expr_segment(&e, 1, 1);
                         XPathASTNode* expr = parse_expr_span(s.p, e.p);
                         if (!expr) {
                             free(var);
@@ -1649,7 +1680,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                     }
                 } else if (word_is(kw, kwl, "where")) {
                     Scan e = s;
-                    scan_expr_segment(&e, 0);
+                    scan_expr_segment(&e, 0, 0);
                     /* WHERE after GROUP BY filters the GROUPED
                      * tuples (aggregates see the whole group) */
                     XPathASTNode* w_ast = parse_expr_span(s.p, e.p);
@@ -1722,7 +1753,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                             s.p[1] == '=') {
                             s.p += 2;
                             Scan e = s;
-                            scan_expr_segment(&e, 0);
+                            scan_expr_segment(&e, 0, 0);
                             gk = parse_expr_span(s.p, e.p);
                             if (!gk) {
                                 free(gvar);
@@ -1800,7 +1831,7 @@ LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
                     for (;;) {
                         scan_ws(&s);
                         Scan e = s;
-                        scan_expr_segment(&e, 1);   /* stop at ',' */
+                        scan_expr_segment(&e, 1, 1);   /* stop at ',' */
                         XPathASTNode* key = parse_expr_span(s.p, e.p);
                         if (!key) {
                             xq_free(q);

data/vendor-src/libleptris/test/dom/test_dom.cpp

@@ -160,7 +160,13 @@ TEST(DomBasics, DocumentSetRootRejectsParentedElement) {
 TEST(DomBasics, RootDocMemoClearedWhenRootUnregisters) {
     LeptrisDocument doc = leptris_document_create();
     ASSERT_NE(doc, nullptr);
-    LeptrisElement e = leptris_element_create(doc, "r");
+    /* A >254-char name forces the pool-fallback create: no namebp
+     * backpointer, so the element is MAP-resolved. Lane 18 P2 made
+     * namebp-carrying elements resolve statelessly before the map
+     * (no memo to prime, nothing to invalidate); the unregistration
+     * contract below is about the map-primed memo. */
+    std::string long_name(300, 'x');
+    LeptrisElement e = leptris_element_create(doc, long_name.c_str());
     ASSERT_NE(e, nullptr);
     leptris_root_doc_register(e, doc);
     /* Prime the memo through a resolution. */

data/vendor-src/libleptris/test/xquery/test_qt3.cpp

@@ -983,14 +983,21 @@ TEST(Qt3Subset, FnDistinctValues) {
      * fn-distinct-values-1 (Bugzilla 5183: float must promote UP to
      * double, never the reverse) close with F&O promotion in the
      * dedup comparator. */
-    /* fn-distinct-values-2 adopted: the assert-permutation
-     * harness expands "N to M" range tokens (values were already
-     * engine-correct; the blocker was harness-side). */
-    run_test_set("fn/distinct-values.xml", {}, 98, {},
+    /* cbcl-distinct-values-007: both halves are in (tz-normalized
+     * time equality + typed-scalar predicates) and the query is
+     * correct on macOS, but Linux/ASAN still evaluates
+     * xs:dayTimeDuration("PT0S")[$p] with the at-bound position as
+     * EBV-true (all-Z output) — a narrow platform divergence to
+     * chase separately. */
+    /* cbcl-distinct-values-007 now passes everywhere: BOTH predicate
+     * paths convert typed-scalar carriers (the nodeset-base path via
+     * evaluate_predicate_for_node AND the single-item base path in
+     * the XPATH_AST_PREDICATE handler — xs:dayTimeDuration("PT0S")[$p]
+     * takes the latter). */
+    run_test_set("fn/distinct-values.xml", {}, 99, {},
                  {
                    "cbcl-distinct-values-002",
                    "cbcl-distinct-values-002b",
-                   "cbcl-distinct-values-007",
 
                  });
 }

data/vendor-src/libleptris/test/xquery/test_xquery.cpp

@@ -66,6 +66,27 @@ TEST(XQueryCore, PrologVariableAndFlwor) {
     leptris_document_free(doc);
 }
 
+TEST(XQueryCore, BareFlworInitializer) {
+    /* A binding expression may itself start a FLWOR without
+     * parentheses; the OUTER clause words (let/order by/where/
+     * return) must still terminate the inner scan. Regression
+     * shape from QT3 K2-OrderbyExprWithout. */
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    EXPECT_EQ(seq_string(doc,
+        "let $x := for $i in (1,2) return $i * 10 return $x"),
+        "10 20");
+    EXPECT_EQ(seq_string(doc,
+        "for $a in (1, 4, 2) let $i := (1, 3, 2) "
+        "order by $a return $i"),
+        "1 3 2 1 3 2 1 3 2");
+    EXPECT_EQ(seq_string(doc,
+        "for $i in (1, 2, 3) let $s := $i * $i "
+        "where $i > 1 return $s"),
+        "4 9");
+    leptris_document_free(doc);
+}
+
 TEST(XQueryCore, OrderByDescending) {
     LeptrisDocument doc = leptris_parse_string(kBooks, strlen(kBooks),
                                                nullptr);
@@ -1215,6 +1236,52 @@ TEST(XQueryCore, MixedNumericCompare) {
 }
 
 
+TEST(XQueryCore, VarPredicatePositional) {
+    LeptrisDocument doc = leptris_parse_string("<e/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    struct {
+        const char* q;
+        const char* want;
+    } cases[] = {
+        /* a numeric variable is a POSITIONAL predicate: position()
+         * = $p — not EBV. The xq driver binds vars as sequence
+         * carriers, so the bare-var predicate took the EBV-true
+         * path and kept the whole sequence. */
+        {"let $p := 2 return count((10,20,30)[$p])", "1"},
+        {"let $p := 2 return (10,20,30)[$p]", "20"},
+        {"string-join(for $p in (2,3) return"
+         " string((10,20,30)[$p]), '|')", "20|30"},
+        {"let $p := 2.0 return count((10,20,30)[$p])", "1"},
+        {/* cbcl-distinct-values-007's shape: positional predicate
+         * on a singleton sequence (function-call base) */
+         "let $p := 1 return"
+         " count(xs:dayTimeDuration('PT0S')[$p])", "1"},
+        {/* single-item base path: the XQUERY entry must convert the
+         * carrier in the AST_PREDICATE handler too */
+         "let $p := 2 return"
+         " string(adjust-time-to-timezone(xs:time('12:00:00'),"
+         " (xs:dayTimeDuration('PT0S')[$p])))", "12:00:00"},
+        {"count(distinct-values((xs:time('12:00:00'),"
+         " xs:time('12:00:00'), xs:time('20:00:00'),"
+         " xs:time('01:00:00+12:00'), xs:time('02:00:00+13:00'))))",
+         "3"},
+    };
+    for (auto& c : cases) {
+        LeptrisXQuery xq = leptris_xquery_parse(c.q, strlen(c.q));
+        ASSERT_NE(xq, nullptr) << c.q;
+        LeptrisXPathResult r = leptris_xquery_eval(xq, doc, NULL);
+        ASSERT_NE(r, nullptr) << c.q;
+        char* s = leptris_xpath_result_string(r);
+        ASSERT_NE(s, nullptr) << c.q;
+        EXPECT_STREQ(s, c.want) << c.q;
+        leptris_free_string(s);
+        leptris_xpath_result_free(r);
+        leptris_xquery_free(xq);
+    }
+    leptris_document_free(doc);
+}
+
+
 TEST(XQueryCore, TimeTzEq) {
     LeptrisDocument doc = leptris_parse_string("<e/>", 4, nullptr);
     ASSERT_NE(doc, nullptr);

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.255",
+  "version": "1.9.260",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.255.1
+  version: 1.9.260.0
 platform: ruby
 authors:
 - Ribose Inc.