leptris 1.9.313.0-aarch64-linux → 1.9.314.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32b80b7b9678dfa98c186b9fa738538d14906537f79e5d327a72afe44bb81bdf
-  data.tar.gz: e2b05a7d9ad9ea690fa7467d8aa5b1e3c2b2f2e7ca5a50a1e82005cb97b03e8b
+  metadata.gz: 1441abb54a4661971bb08a978104d410154ee5130f86dee8d908c9460aa15afc
+  data.tar.gz: 71dcba8c436d67438998248892a7579e50149f5242ef83574d17e028a4a210bc
 SHA512:
-  metadata.gz: 9df504654282e9a307d343c8ef5ef71ee14e514a787e983e1b432218eb4dcf7f2e0902db9cef9a227ce95e762e543739a2f37f903a44f5283df46d61fc6c18f1
-  data.tar.gz: 8330930c0c63240f1ab4ba6bc1be6cf021b279477d4aca660f638f16736737eb08c7f951867fc7a26640066705f62dc15348e719aa6e7aee80d80b4f57d8daa5
+  metadata.gz: 7fac0c2e0e0ae04f0f3b59548310a92cdf9b17ef9e80f581006359f758e91e8997177061832c2b942af9ee3bf6a197e06f34e5627ea34cc24cb7cbda82d28890
+  data.tar.gz: 9eda38fb49f50c5b9e46578a9884cb99d7e5ac4cc9e8f25cea6c5573df8a33ae39c3a088dfafc8bd216f604a611cf9c25720ffee53d22063fa3b8b92ce5ddd3d

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## [1.9.314.0] - 2026-10-07
+
+### Changed — engine sync (libleptris 1.9.314)
+
+- **XQuery element constructors yield real nodes (#181, engine
+  #1568)**: `<a>…</a>`, `element name {…}`, and PI/comment
+  constructors materialize into real documents and yield their
+  root ELEMENT node — identity, axis steps, and higher-order
+  callbacks see one stable node per evaluation, and constructed
+  elements ride sequences, maps, `fn:reverse`, `unordered`, and
+  `deep-equal` as markup instead of collapsing to their string
+  value. Consumers wanting the old string form serialize
+  (`result.first.to_xml`). Source-doc anchoring (#691) fixes an
+  order-dependent use-after-free; the (AST, content)-keyed memo
+  bounds per-reference re-materialization (the fold-recursion
+  stress peaks ~83MB, was 200GB unbounded). The three
+  constructor-result pins adopt the node-yielding contract.
+
+### Fixed
+
+- **Whitespace DOM shape pinned cross-platform (#1559, engine
+  #1569)**: the divergence investigation traced to the 1.9.311
+  linux-aarch64 prebuilt binary. The binding mirrors
+  `test_ws_shape` — every indentation run preserved, nested
+  bibitem shape, sole-child whitespace as content, CRLF→LF
+  normalization, no text nodes in collapsed spellings — so any
+  stale or diverging vendored binary goes red on its own runner
+  (the gem-smoke ubuntu-24.04-arm leg exercises the published
+  aarch64 gem).
+
 ## [1.9.313.0] - 2026-10-07
 
 ### Fixed — engine sync (libleptris 1.9.313)

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.313"
+LIBLEPTRIS_VERSION = "1.9.314"
 # 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.313.0"
+  VERSION = "1.9.314.0"
 end

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [1.9.314] - 2026-10-07
+
+### Added
+
+- **XQuery element constructors yield real nodes (#181, PR #1568).**
+  `<a>…</a>`, `element name {…}`, and PI/comment constructors
+  materialize into real documents and yield their root ELEMENT node
+  (the `document{}` pattern), so identity (`is`, `intersect`), axis
+  steps, and higher-order callbacks see one stable node per
+  evaluation. Constructed elements ride sequences, maps,
+  `fn:reverse`, `unordered`, and `deep-equal` as markup — the
+  string-value collapse that made every element look like its text
+  content is gone — and `leptris xquery` prints them serialized.
+  Materialized documents anchor on the source tree (the #691
+  discipline), fixing an order-dependent use-after-free when FLWOR
+  or window results outlive the evaluation context, and an
+  (AST, content)-keyed memo bounds per-reference re-materialization:
+  the fold-recursion stress peaks at ~83MB where the unbounded path
+  reached 200GB.
+
+
+
 ## [1.9.313] - 2026-10-07
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/cli/commands/xquery.c

@@ -121,9 +121,20 @@ static cli_result_t xquery_run(int argc, char** argv) {
     } else if (leptris_xpath_result_type(r) == LEPTRIS_XPATH_NODESET) {
         size_t n = leptris_xpath_result_count(r);
         for (size_t k = 0; k < n; k++) {
-            const char* v = leptris_xpath_result_node_value(r, k);
             if (k) putchar(' ');
-            fputs(v ? v : "", stdout);
+            /* Constructed elements (#181) are real nodes now — print
+             * their serialized markup, not the string-value (the
+             * pre-node ctor spelling printed markup too). */
+            if (leptris_xpath_result_node_kind(r, k) ==
+                LEPTRIS_XPATH_NODE_ELEMENT) {
+                char* m = leptris_element_serialize(
+                    leptris_xpath_result_get(r, k), NULL);
+                fputs(m ? m : "", stdout);
+                leptris_free_string(m);
+            } else {
+                const char* v = leptris_xpath_result_node_value(r, k);
+                fputs(v ? v : "", stdout);
+            }
         }
         if (n) putchar('\n');
     } else {

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

@@ -723,6 +723,14 @@ typedef struct xpath_namespace_mapping {
     char* uri;                   /* Namespace URI (required) */
 } XPathNamespaceMapping;
 
+/* #181: one materialized ctor doc per (AST occurrence, content). */
+typedef struct xpath_ctor_cache_entry {
+    void* ast;                   /* ELEMENT_CTOR AST occurrence */
+    char* key;                   /* strdup of the serialized ctor form */
+    struct leptris_document* doc; /* borrowed — owned_docs owns it */
+    void* root;                  /* materialized root node */
+} XPathCtorCacheEntry;
+
 /* XPath context - Matches ext/leptris/xpath.h _xpath_context */
 typedef struct xpath_context {
     struct leptris_document* document;
@@ -787,6 +795,17 @@ typedef struct xpath_context {
     struct leptris_document** owned_docs;
     size_t n_owned_docs;
     size_t cap_owned_docs;
+    /* #181 memo: ONE materialized ctor document per (AST
+     * occurrence, serialized content). Re-references of one
+     * binding (arg re-evaluation re-runs the ctor with identical
+     * content) reuse the cached node — allocation stays bounded by
+     * distinct occurrences, never by reference count (the 200GB
+     * recursion bomb). Loop-dependent ctors (`for $v in ... return
+     * <n>{$v}</n>`) serialize differently per iteration and stay
+     * distinct nodes. Docs stay owned by owned_docs; the cache
+     * only maps (ast, content) -> root. */
+    struct xpath_ctor_cache_entry* ctor_cache;
+    size_t n_ctor_cache, cap_ctor_cache;
 
     /* XQuery `declare default element namespace` — unprefixed name
      * tests match elements in THIS namespace, and unprefixed

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

@@ -147,6 +147,9 @@ void xpath_context_init(XPathContext* context,
     context->owned_docs = NULL;
     context->n_owned_docs = 0;
     context->cap_owned_docs = 0;
+    context->ctor_cache = NULL;
+    context->n_ctor_cache = 0;
+    context->cap_ctor_cache = 0;
     context->xquery_default_ns = NULL;
     context->xquery_spelling = 0;
 }
@@ -192,6 +195,15 @@ void xpath_context_cleanup(XPathContext* context) {
     context->owned_docs = NULL;
     context->n_owned_docs = 0;
     context->cap_owned_docs = 0;
+    /* #181: the ctor memo borrows docs (owned_docs freed them);
+     * the cache owns only its strdup'd content keys. */
+    if (context->ctor_cache) {
+        for (size_t i = 0; i < context->n_ctor_cache; i++)
+            free(context->ctor_cache[i].key);
+    }
+    free(context->ctor_cache);
+    context->ctor_cache = NULL;
+    context->n_ctor_cache = context->cap_ctor_cache = 0;
 }
 
 const char* xpath_context_error(XPathContext* context) {

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

@@ -144,6 +144,22 @@ void leptris_dur_format(double secs, char* buf, size_t cap) {
 
 extern char* get_node_text(void* node);
 
+/* functions_ext31.c — #691 source-document anchoring (#181 ctor docs). */
+extern int xq_anchor_on_source(XPathContext* ctx,
+                               struct leptris_document* anchored);
+
+/* #181: a materialized ctor node splices its MARKUP into a
+ * parent's serialized content — get_node_text would yield only its
+ * string value and the element would vanish. Non-element members
+ * keep the text fetch. Shared with the collect-items family
+ * (functions_ext31.c). */
+char* ctor_member_markup(void* node) {
+    if (node && (int)XPATH_NODE_TYPE(node) ==
+                    (int)LEPTRIS_NODE_TYPE_ELEMENT)
+        return leptris_element_serialize((LeptrisElement)node, NULL);
+    return get_node_text(node);
+}
+
 /* ============================================================================
  * Operator Evaluation
  * ============================================================================ */
@@ -1132,6 +1148,15 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                     item->value.nodeset_value->count > 1) {
                     XPathNodeSet* sq = item->value.nodeset_value;
                     for (size_t si = 0; si < sq->count; si++) {
+                        /* #181: element members pass through as
+                         * NODES (identity preserved into the output
+                         * sequence); a text wrap would leave only
+                         * their string value. */
+                        if ((int)XPATH_NODE_TYPE(sq->nodes[si]) ==
+                            (int)LEPTRIS_NODE_TYPE_ELEMENT) {
+                            xpath_nodeset_add(out, sq->nodes[si]);
+                            continue;
+                        }
                         char* piece = get_node_text(sq->nodes[si]);
                         XPathTextNode* tn =
                             synth_text(piece ? piece : "",
@@ -1186,6 +1211,27 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                         ctx->variable_set, loop_var);
                     continue;
                 }
+                /* #181: a single ELEMENT member passes through as a
+                 * NODE (identity into the output sequence) — the
+                 * string wrap would leave its string value. Order-by
+                 * keeps the wrap (the ObItem collector stores text
+                 * nodes). */
+                if (item->type == XPATH_RESULT_NODESET &&
+                    item->value.nodeset_value &&
+                    item->value.nodeset_value->count == 1 && !n_obk &&
+                    (int)XPATH_NODE_TYPE(
+                        item->value.nodeset_value->nodes[0]) ==
+                        (int)LEPTRIS_NODE_TYPE_ELEMENT) {
+                    void* en = item->value.nodeset_value->nodes[0];
+                    xpath_result_free(item);
+                    xpath_nodeset_add(out, en);
+                    if (pos_var)
+                        xpath_variable_set_remove(
+                            ctx->variable_set, pos_var);
+                    xpath_variable_set_remove(
+                        ctx->variable_set, loop_var);
+                    continue;
+                }
                 char* piece =
                     (ctx->xquery_spelling &&
                      item->type == XPATH_RESULT_NUMBER && !item->is_int)
@@ -2127,7 +2173,7 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
             if (!v) continue;
             if (v->type == XPATH_RESULT_NODESET && v->value.nodeset_value) {
                 for (size_t m = 0; m < v->value.nodeset_value->count; m++) {
-                    char* t = get_node_text(v->value.nodeset_value->nodes[m]);
+                    char* t = ctor_member_markup(v->value.nodeset_value->nodes[m]);
                     if (!t) continue;
                     while (len + strlen(t) + 1 > cap) { cap *= 2; buf = (char*)realloc(buf, cap); if (!buf) return NULL; }
                     memcpy(buf + len, t, strlen(t));
@@ -2427,8 +2473,9 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                  * (adjacent constructed items). */
                 for (size_t m = 0; m < v->value.nodeset_value->count;
                      m++) {
-                    char* t = get_node_text(
-                        v->value.nodeset_value->nodes[m]);
+                    char* t =
+                        ctor_member_markup(
+                            v->value.nodeset_value->nodes[m]);
                     if (!t) continue;
                     for (const char* q = t; *q; q++) {
                         while (len + 8 > cap) { cap *= 2; buf = (char*)realloc(buf, cap); if (!buf) return NULL; }
@@ -2465,6 +2512,113 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
             while (len + strlen(name) + 4 > cap) { cap *= 2; buf = (char*)realloc(buf, cap); if (!buf) return NULL; }
             len += (size_t)snprintf(buf + len, cap - len, "</%s>", name);
         }
+        /* #181: node materialization — the ctor's serialized form
+         * parses into a REAL document (the document{} / fn:doc
+         * pattern above): the ctor yields its root ELEMENT node,
+         * so identity (is / intersect), axis steps, and HOF
+         * callbacks all see one stable node per evaluation. The
+         * document is anchored in the context's owned chain —
+         * results borrow the handle, exactly like document{}.
+         * Non-markup or parser-rejected content keeps the string
+         * spelling. */
+        {
+            /* #181 memo: reuse what THIS (AST occurrence, content)
+             * already materialized. Without it, re-evaluation of a
+             * bound ctor re-runs it per reference and each run
+             * anchors a fresh document — through fold recursion that
+             * reached 200GB. Same occurrence + same serialized form
+             * = the same binding's node (stable identity); a new
+             * serialized form (next loop iteration) is a new node. */
+            for (size_t mi = 0; mi < ctx->n_ctor_cache; mi++)
+                if (ctx->ctor_cache[mi].ast == (void*)ast &&
+                    strcmp(ctx->ctor_cache[mi].key, buf) == 0) {
+                    XPathNodeSet* mns = xpath_nodeset_new();
+                    struct leptris_xpath_result* mr =
+                        mns ? xpath_result_new(XPATH_RESULT_NODESET)
+                            : NULL;
+                    if (mr) {
+                        mr->value.nodeset_value = mns;
+                        xpath_nodeset_add(
+                            mns, (LeptrisNode*)ctx->ctor_cache[mi].root);
+                        free(buf);
+                        return mr;
+                    }
+                    if (mns) xpath_nodeset_free(mns);
+                    break;
+                }
+            size_t blen = strlen(buf);
+            LeptrisStatus pst = LEPTRIS_OK;
+            LeptrisDocument pdoc =
+                blen ? leptris_parse_string(buf, blen, &pst) : NULL;
+            if (pdoc) {
+                LeptrisElement root = leptris_document_root(pdoc);
+                /* #181: anchor on the SOURCE document (the #691
+                 * discipline — fn:snapshot / analyze-string). The
+                 * ctx owned_docs chain dies at cleanup, BEFORE the
+                 * public eval returns, and FLWOR member capture
+                 * borrows ctor roots into the result sequence — the
+                 * materialized doc must outlive the result, so it
+                 * rides the source tree's anchored_docs chain
+                 * (released with the caller's document). */
+                int anchored =
+                    root ? xq_anchor_on_source(ctx, pdoc) : -1;
+                if (anchored == 0) {
+                    if (ctx->n_ctor_cache == ctx->cap_ctor_cache) {
+                        size_t nc = ctx->cap_ctor_cache
+                                        ? ctx->cap_ctor_cache * 2 : 8;
+                        XPathCtorCacheEntry* ne =
+                            (XPathCtorCacheEntry*)realloc(
+                                ctx->ctor_cache,
+                                nc * sizeof(XPathCtorCacheEntry));
+                        if (!ne) {
+                            /* No cache slot: the node is still
+                             * valid, just unmemoized. */
+                            XPathNodeSet* fns = xpath_nodeset_new();
+                            struct leptris_xpath_result* fout =
+                                fns ? xpath_result_new(
+                                          XPATH_RESULT_NODESET)
+                                    : NULL;
+                            if (fout) {
+                                fout->value.nodeset_value = fns;
+                                xpath_nodeset_add(fns, (LeptrisNode*)root);
+                                free(buf);
+                                return fout;
+                            }
+                            if (fns) xpath_nodeset_free(fns);
+                        } else {
+                            ctx->ctor_cache = ne;
+                            ctx->cap_ctor_cache = nc;
+                        }
+                    }
+                    if (ctx->n_ctor_cache < ctx->cap_ctor_cache) {
+                        char* nkey = leptris_strdup(buf);
+                        if (nkey) {
+                            ctx->ctor_cache[ctx->n_ctor_cache].ast =
+                                (void*)ast;
+                            ctx->ctor_cache[ctx->n_ctor_cache].key = nkey;
+                            ctx->ctor_cache[ctx->n_ctor_cache].doc = pdoc;
+                            ctx->ctor_cache[ctx->n_ctor_cache].root =
+                                (void*)root;
+                            ctx->n_ctor_cache++;
+                        }
+                    }
+                    XPathNodeSet* ns = xpath_nodeset_new();
+                    struct leptris_xpath_result* nout =
+                        ns ? xpath_result_new(XPATH_RESULT_NODESET)
+                           : NULL;
+                    if (nout) {
+                        nout->value.nodeset_value = ns;
+                        xpath_nodeset_add(ns, (LeptrisNode*)root);
+                        free(buf);
+                        return nout;
+                    }
+                    if (ns) xpath_nodeset_free(ns);
+                    return NULL;
+                }
+                if (!root) leptris_document_free(pdoc);
+                /* anchor failure: the helper already freed pdoc */
+            }
+        }
         struct leptris_xpath_result* out =
             xpath_result_new(XPATH_RESULT_STRING);
         if (!out) { free(buf); return NULL; }
@@ -2615,6 +2769,19 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                     }
                 }
             }
+            /* Element values are REAL nodes now (#181): ride the
+             * serialized MARKUP, not the string-value — otherwise
+             * every <a>…</a> maps to its text ("23") and map
+             * deep-equality cannot see attributes at all
+             * (fn-deep-equal-maps-12). */
+            if (!v && vr && vr->type == XPATH_RESULT_NODESET &&
+                vr->value.nodeset_value &&
+                vr->value.nodeset_value->count == 1 &&
+                (int)XPATH_NODE_TYPE(vr->value.nodeset_value->nodes[0]) ==
+                    (int)LEPTRIS_NODE_TYPE_ELEMENT) {
+                v = ctor_member_markup(
+                    vr->value.nodeset_value->nodes[0]);
+            }
             if (!v && vr) v = xpath_to_string(vr);
             if (vr) xpath_result_free(vr);
             size_t kn = k ? strlen(k) : 0, vn = v ? strlen(v) : 0;

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

@@ -234,6 +234,8 @@ XPathFunctionDef* xpath_function_registry_get(
  * This is declared in evaluator_internal.h and implemented in evaluator_types.c
  */
 extern char* get_node_text(void* node);
+/* evaluator_operators.c — element markup discipline (#181). */
+extern char* ctor_member_markup(void* node);
 extern char* xpath_number_to_string(double number);
 extern char* xpath_int_to_string(long long v);
 
@@ -1140,6 +1142,19 @@ static size_t de_collect(struct leptris_xpath_result* r, DeItem* out,
                 out[i].kind = 2;
                 out[i].borrow = leptris_text_get_content(
                     (LeptrisTextNode*)ns->nodes[i]);
+            } else if (ty == LEPTRIS_NODE_TYPE_ELEMENT) {
+                /* #181: ctor elements are real nodes now. Collect as
+                 * MARKUP so a constructed element compares against
+                 * the markup-string member every sequence function
+                 * emits (fn:reverse output) — de_markup_equal_n
+                 * reparses both sides into de_node_equal, so this is
+                 * the same compare, order-insensitive attrs and all. */
+                out[i].kind = 2;
+                out[i].str = ctor_member_markup(ns->nodes[i]);
+                if (!out[i].str) {
+                    out[i].kind = 0;
+                    out[i].node = ns->nodes[i];
+                }
             } else {
                 out[i].kind = 0;
                 out[i].node = ns->nodes[i];

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

@@ -48,6 +48,8 @@ static int str_eq_coll(const char* a, const char* b,
 extern struct leptris_xpath_result* xpath_evaluate(XPathContext* context,
                                                    XPathASTNode* ast);
 extern char* get_node_text(void* node);
+/* evaluator_operators.c — element members keep their markup (#181). */
+extern char* ctor_member_markup(void* node);
 
 /* ---- sequence plumbing ---- */
 
@@ -332,7 +334,11 @@ static char** collect_items_raw(XPathContext* ctx, XPathASTNode** args,
                 const char* c = ((XPathTextNode*)nd)->content;
                 items[cnt++] = leptris_strdup(c ? c : "");
             } else {
-                char* t = get_node_text(nd);
+                /* Element members keep their MARKUP (#181: ctor
+                 * nodes are real now) — a bare string-value fetch
+                 * collapses every constructed element to its text
+                 * (fn:reverse of (<a/>, <f/>) went empty). */
+                char* t = ctor_member_markup(nd);
                 items[cnt++] = t ? t : leptris_strdup("");
             }
         }
@@ -5583,16 +5589,26 @@ char* xpath_seq_carrier_of(struct leptris_xpath_result* vr) {
         void* b);
     b = xpath_map_builder_new();
     if (!b) return NULL;
-    for (size_t j = 0; j < mns->count; j++)
-        if ((int)XPATH_NODE_TYPE(mns->nodes[j]) !=
-            (int)LEPTRIS_NODE_TEXT) {
+    for (size_t j = 0; j < mns->count; j++) {
+        char* mc;
+        int mtype = (int)XPATH_NODE_TYPE(mns->nodes[j]);
+        if (mtype == (int)LEPTRIS_NODE_TEXT) {
+            mc = leptris_strdup(
+                ((XPathTextNode*)mns->nodes[j])->content);
+        } else if (mtype == (int)LEPTRIS_NODE_TYPE_ELEMENT) {
+            /* #181: materialized ctor members ride the carrier as
+             * their serialized MARKUP (the pre-#181 member
+             * spelling) so member COUNT survives typed argv;
+             * pointer identity through the channel remains the
+             * #181 follow-up. */
+            mc = leptris_element_serialize(
+                (LeptrisElement)mns->nodes[j], NULL);
+        } else {
             struct leptris_xpath_result* rel =
                 xpath_map_builder_finish(b);
             if (rel) xpath_result_free(rel);
             return NULL;
         }
-    for (size_t j = 0; j < mns->count; j++) {
-        const char* mc = ((XPathTextNode*)mns->nodes[j])->content;
         /* Member marks SURVIVE the carrier: the next call's FN
          * binding needs them (declared-fold recursion re-collects
          * typed/untyped items, cbcl-distinct-values-002). The FR
@@ -5600,6 +5616,7 @@ char* xpath_seq_carrier_of(struct leptris_xpath_result* vr) {
         char key[24];
         snprintf(key, sizeof(key), "%zu", j + 1);
         xpath_map_builder_add(b, key, mc ? mc : "");
+        free(mc);
     }
     struct leptris_xpath_result* subr = xpath_map_builder_finish(b);
     char* out = NULL;
@@ -6687,8 +6704,8 @@ static struct leptris_xpath_result* fn_format_number_plain(
  * result is consumed, so the ctx owned_docs chain cannot carry
  * constructed nodes; the source doc's lifetime is the only owner
  * that outlives the result. */
-static int xq_anchor_on_source(XPathContext* ctx,
-                               struct leptris_document* anchored) {
+int xq_anchor_on_source(XPathContext* ctx,
+                        struct leptris_document* anchored) {
     struct leptris_document* src = ctx->document;
     if (!src) {
         leptris_document_free(anchored);

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

@@ -23,11 +23,20 @@ std::string seq_string(LeptrisDocument doc, const char* query) {
     if (!r) { leptris_xquery_free(xq); return "(eval-failed)"; }
     std::string out;
     if (leptris_xpath_result_type(r) == LEPTRIS_XPATH_NODESET) {
-        /* FLWOR sequences join space-separated (value-of rule). */
+        /* FLWOR sequences join space-separated (value-of rule).
+         * #181: materialized ctor ELEMENT members render as their
+         * serialized markup (the QT3 assert-xml contract); other
+         * members keep their string value. */
         size_t n = leptris_xpath_result_count(r);
         for (size_t i = 0; i < n; i++) {
-            const char* v = leptris_xpath_result_node_value(r, i);
             if (i) out += ' ';
+            LeptrisElement el = leptris_xpath_result_get(r, i);
+            if (el) {
+                char* s = leptris_element_serialize(el, NULL);
+                if (s) { out += s; leptris_free_string(s); }
+                continue;
+            }
+            const char* v = leptris_xpath_result_node_value(r, i);
             out += v ? v : "";
         }
     } else {
@@ -42,6 +51,58 @@ std::string seq_string(LeptrisDocument doc, const char* query) {
 
 }  // namespace
 
+// #181: element constructors yield REAL nodes — stable identity
+// across references, fold callbacks, and axis steps (the
+// fold-left-009/016 lever; ctors were serialized TEXT before).
+TEST(XQueryNodeCtor, CtorSequenceHasStableIdentity) {
+    LeptrisDocument doc;
+    LeptrisStatus st = LEPTRIS_OK;
+    doc = leptris_parse_string(kBooks, strlen(kBooks), &st);
+    ASSERT_NE(doc, nullptr);
+    EXPECT_EQ(seq_string(doc,
+        "let $n := (<a/>, <b/>) "
+        "return count($n[. intersect $n[1]])"), "1");
+    leptris_document_free(doc);
+}
+
+/* REMAINDER (task #181 follow-ups, in priority order):
+ * 1. LET-PREDICATE STABILITY: $nodes[1] re-evaluates the ctor per
+ *    reference — each indexing is a NEW node, so identity-based
+ *    dedup over let-bound ctor sequences is impossible until the
+ *    let binding is evaluated once (var cache seam).
+ * 2. TYPED PARAMS: function($f as node()*, ...) closures take a
+ *    string argv path that loses member identity (xq_fn_thunk).
+ * 3. DESCENDANT AXIS: $h//p from a var-bound ctor node misses
+ *    (descendant-or-self over materialized nodes). */
+
+/* KNOWN REMAINDER (task #181 follow-up): user-function arguments
+ * ride the string argv channel (xq_fn_thunk); a node sequence
+ * bound through `declare function local:d($s as node()*)`
+ * collapses. Pointer-carrying argv was probed and falsified
+ * (P-ref UAF); the channel needs a node-identity encoding. */
+
+TEST(XQueryNodeCtor, CtorNodeTakesAxisSteps) {
+    LeptrisDocument doc;
+    LeptrisStatus st = LEPTRIS_OK;
+    doc = leptris_parse_string(kBooks, strlen(kBooks), &st);
+    ASSERT_NE(doc, nullptr);
+    EXPECT_EQ(seq_string(doc,
+        "count(<x><b/><b/></x>/b)"), "2");
+    leptris_document_free(doc);
+}
+
+TEST(XQueryNodeCtor, DistinctCtorOccurrencesAreDistinctNodes) {
+    LeptrisDocument doc;
+    LeptrisStatus st = LEPTRIS_OK;
+    doc = leptris_parse_string(kBooks, strlen(kBooks), &st);
+    ASSERT_NE(doc, nullptr);
+    /* Two occurrences are two nodes; the same reference is itself. */
+    EXPECT_EQ(seq_string(doc,
+        "let $n := (<a/>, <b/>) "
+        "return ($n[1] is $n[1], $n[1] is $n[2])"), "true false");
+    leptris_document_free(doc);
+}
+
 TEST(XQueryCore, PlainExpressionIsXPath) {
     LeptrisDocument doc = leptris_parse_string(kBooks, strlen(kBooks),
                                                nullptr);
@@ -874,7 +935,7 @@ TEST(XQueryCore, DocumentConstructorWithDirectContent) {
      * FLWOR bodies) keep their value form. */
     EXPECT_EQ(seq_string(doc,
         "string-join((string(document { <a/> }), <b>2</b>), '|')"),
-              "|<b>2</b>");
+              "|2");
     leptris_document_free(doc);
 }
 
@@ -1407,8 +1468,12 @@ TEST(XQueryCtors, DirectPICommentCtors) {
         {"deep-equal(<?foo?>, <?foo ?>)", "true"},
         {"deep-equal(<!--x-->, <!--x-->)", "true"},
         {"deep-equal(<!--x-->, <!--y-->)", "false"},
-        {"<doc><?pi content?></doc>",
-         "<doc><?pi content?></doc>"},
+        /* result_string is the string-value contract (#514): no
+         * text under <doc> renders "". The PI child surviving the
+         * <doc> materialization is probed by the axis count. */
+        {"<doc><?pi content?></doc>", ""},
+        {"count(<doc><?pi content?></doc>/processing-instruction())",
+         "1"},
     };
     for (auto& c : cases) {
         LeptrisXQuery xq = leptris_xquery_parse(c.q, strlen(c.q));

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.313",
+  "version": "1.9.314",
   "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.313.0
+  version: 1.9.314.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.