leptris 1.9.313.0 → 1.9.317.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 716410c15581403307f3b94bd529c21d2bc778478bcfca064b6778f8e1826a9b
-  data.tar.gz: c566d9e1828cd1803523b0eb99ffc9b861995aee576ef7fae6d24ac536bea7d0
+  metadata.gz: 44f00da545382eef1ba06a526478752ab7f2fb16ecc609a60df9fd88f1cd46aa
+  data.tar.gz: bcc75b40350199bdb1db2dd502d1d6fa1f0398f499bbda57e2aaf4bfe1c4901f
 SHA512:
-  metadata.gz: 66c08d6699d345e0a74c313c9d02bef8b84a6f25e0b310e846a5694dd01e78c45c983f1871bba57e4711564208d90e6710d08d2a499d88582c1ec4cf3ab3f211
-  data.tar.gz: ecda89d28b0ad3e7954a93064c6abeaf430159bad758c0dcf88db4c4ad20fe7e6b56a17201142ead36aac05c64a025c759dfff7736e36969dc2635265f302083
+  metadata.gz: 75b5e89df9de5a924bfdcce746668b6a2f81114d459de3ec9b8aae72c2acb11a6c1c26c1bd12b2a1227fc19d52873004badd77298ba9f4437877679a8dfa52c2
+  data.tar.gz: b1ed2f7fef77ba8900ab4a323cc1915ef501fd6cc11078b3912187349b7c62b13fb58766c623ad0db6f1a67ed71bcab19c9d5740785a951867769ea8b18d4852

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.317"
 # 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.317.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.317
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,97 @@
 ## [Unreleased]
 
+## [1.9.317] - 2026-10-07
+
+### Added
+
+- **Descriptor: unqualified-only ns form for child rows (#1560,
+  PR #1574).** `LEPTRIS_PLAN_NS_UNQUALIFIED = 3` matches the WRITTEN
+  spelling — a child row binds children with no written prefix
+  regardless of the effective namespace URI, and refuses prefixed
+  spellings. An unprefixed child binds under both a namespace-less
+  document and a default-`xmlns` document (`NS_NONE` drops the
+  latter); a `p:child` never binds (the `NS_ANY` superset
+  lutaml-model#932 had to settle for). The serialize -> re-parse ->
+  re-walk round-trip agrees on all three shapes because the form
+  keys on the spelling, not the URI: the serializer emits prefix
+  declarations only, so a default-ns child serializes bare and
+  still re-binds. Rust descriptor-ABI mirror shipped in the same
+  wave (leptris-rs#4).
+
+
+
+## [1.9.316] - 2026-10-07
+
+### Fixed
+
+- **Descriptor plan serializer: nested captures emit their own rows
+  (#1565, PR #1573).** A captured child's rows now resolve against the
+  CAPTURING row's `child_plan_index` plan instead of the plan that
+  walked it, so a child bound by a nested row (the `w:font`-in-
+  `w:fonts` shape) serializes its own attribute and child rows —
+  previously they resolved against the parent plan and silently
+  vanished. CONTENT rows inline their text at every nesting level.
+  The new nested-capture spec also exposed a 2 x 16B leak: the inner
+  walk's ns stamp was overwritten without freeing; fixed
+  free-before-overwrite (leaks gate clean).
+
+
+
+## [1.9.315] - 2026-10-07
+
+### Added
+
+- **Carrier-by-pointer node identity — QT3 fold-left-009/016
+  adopted (PR #1571).** Element members riding the higher-order
+  function argument channel keep their NODE POINTER (the \x03P
+  carrier), so node identity survives a string-typed channel:
+  `$foundSoFar intersect $this` dedups by node (fold-left-009's
+  distinct-nodes-stable), and fold results decode to real nodes so
+  `$result/text()` steps (fold-left-016's css-selector interpreter).
+  The fold suite runs 16/16 — both long-pinned cases adopted.
+  Pointers are eval-safe: constructor documents anchor on the
+  source tree (the #691 discipline). Along the way, three language
+  gaps closed: typeswitch arms accept `element(id)` /
+  `element(class)` NAME arguments with case-bound variables binding
+  node operands as nodes; keyword-named constructors parse
+  (`<div/>`, `<mod/>` — HTML tag names colliding with XQuery
+  operators); and single-element results ride the carrier instead
+  of collapsing to their string value.
+
+### Fixed
+
+- **Pointer carriers only for real ELEMENT members.** The item
+  collector handed \x03P carriers to synthetic attribute and
+  namespace nodes too — heap-owned by the carrying nodeset, so the
+  carrier dangled once it was freed (AddressSanitizer
+  heap-use-after-free via fn:subsequence over an attribute step).
+  Real elements stay document-anchored for the evaluation;
+  attributes and namespaces keep the markup snapshot.
+
+
+
+## [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.317
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/bindings/rust/descriptor/src/lib.rs

@@ -49,6 +49,12 @@ pub type PlanNsForm = u8;
 pub const PLAN_NS_NONE: PlanNsForm = 0;
 pub const PLAN_NS_EXACT: PlanNsForm = 1;
 pub const PLAN_NS_ANY: PlanNsForm = 2;
+/// #1560: matches the UNWRITTEN spelling — no written prefix,
+/// regardless of the effective namespace URI. An unprefixed child
+/// binds under both a namespace-less document and a default-xmlns
+/// document; prefixed spellings never bind. Element rows only
+/// (unprefixed attributes have no namespace by XML rules).
+pub const PLAN_NS_UNQUALIFIED: PlanNsForm = 3;
 
 /// Result node kinds (the value tree a walk returns).
 pub type PlanValueKind = i32;

data/vendor-src/libleptris/bindings/rust/descriptor/tests/layout.rs

@@ -34,6 +34,7 @@ fn kind_and_flag_constants_match_engine_headers() {
     assert_eq!(PLAN_NS_NONE, 0);
     assert_eq!(PLAN_NS_EXACT, 1);
     assert_eq!(PLAN_NS_ANY, 2);
+    assert_eq!(PLAN_NS_UNQUALIFIED, 3);
     assert_eq!(PLAN_VALUE_ELEMENT, 0);
     assert_eq!(PLAN_VALUE_SCALAR, 1);
     assert_eq!(PLAN_VALUE_COLLECTION, 2);

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

@@ -119,11 +119,34 @@ static cli_result_t xquery_run(int argc, char** argv) {
         cli_error("XQuery evaluation failed");
         rc = CLI_ERROR_XPATH;
     } else if (leptris_xpath_result_type(r) == LEPTRIS_XPATH_NODESET) {
+        /* carrier-by-pointer (fold-left-009/016): synth members may
+         * carry a node pointer — render its markup. */
+        extern void* xpath_carrier_node_of(const char* s);
         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);
+            LeptrisElement el = NULL;
+            if (leptris_xpath_result_node_kind(r, k) ==
+                LEPTRIS_XPATH_NODE_ELEMENT) {
+                el = leptris_xpath_result_get(r, k);
+            } else {
+                const char* raw =
+                    leptris_xpath_result_node_value(r, k);
+                if (raw && (unsigned char)raw[0] == 0x03 &&
+                    raw[1] == 'P')
+                    el = (LeptrisElement)xpath_carrier_node_of(raw);
+            }
+            /* Constructed elements (#181) are real nodes now — print
+             * their serialized markup, not the string-value (the
+             * pre-node ctor spelling printed markup too). */
+            if (el) {
+                char* m = leptris_element_serialize(el, 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/include/leptris/descriptor.h

@@ -96,7 +96,14 @@ typedef enum {
 typedef enum {
     LEPTRIS_PLAN_NS_NONE = 0,  /* only elements with no namespace */
     LEPTRIS_PLAN_NS_EXACT = 1, /* resolved namespace URI equals ns_uri */
-    LEPTRIS_PLAN_NS_ANY = 2
+    LEPTRIS_PLAN_NS_ANY = 2,
+    /* #1560: matches the UNWRITTEN spelling — children with no
+     * prefix, regardless of the effective namespace URI. An
+     * unprefixed child binds under both a namespace-less document
+     * and a default-xmlns document; prefixed spellings never bind.
+     * Unprefixed attributes have no namespace by XML rules, so
+     * this form only applies to element rows. */
+    LEPTRIS_PLAN_NS_UNQUALIFIED = 3
 } LeptrisPlanNsForm;
 
 typedef struct {

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -562,6 +562,11 @@ static int dp_ns_binds(LeptrisElement elem, uint8_t ns_form,
         case LEPTRIS_PLAN_NS_ANY:
         default:
             return 1;
+        case LEPTRIS_PLAN_NS_UNQUALIFIED:
+            /* #1560: the WRITTEN spelling — no prefix, any
+             * effective URI (default-xmlns elements included);
+             * prefixed spellings never bind. */
+            return prefix == NULL;
     }
 }
 
@@ -852,6 +857,11 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                  * back to the target plan's (NESTED matches with
                  * the target's form, #1115). */
                 if (row->ns_prefix) {
+                    /* The inner walk's own #1551 stamp may already
+                     * hold this pair — free before overwriting or
+                     * the first strdup orphans. */
+                    free(v->ns_prefix);
+                    free(v->ns_uri);
                     v->ns_prefix = dp_strdup(row->ns_prefix);
                     v->ns_uri = dp_strdup(row->ns_uri ? row->ns_uri
                                                       : target->ns_uri);
@@ -1343,7 +1353,8 @@ static int dp_emit_value(const struct leptris_plan_result* v,
 
 static int dp_emit_element(const struct leptris_plan_result* v,
                            const char* name, const LeptrisPlan pool,
-                           dp_sb* b, const dp_decls* decls, int is_root) {
+                           const dp_plan* kids_container, dp_sb* b,
+                           const dp_decls* decls, int is_root) {
     if (!dp_emit_element_open(v, name, b, decls, is_root)) return 0;
     const struct leptris_plan_result** kids = NULL;
     size_t nk = 0, cap = 0;
@@ -1360,11 +1371,14 @@ static int dp_emit_element(const struct leptris_plan_result* v,
         return 0;
     }
     qsort((void*)kids, nk, sizeof(*kids), dp_kid_pos_cmp);
-    const dp_plan* container =
-        &((const struct leptris_plan*)pool)->plans[v->container_plan];
+    /* #1565: kid ROWS live in the plan that WALKED this element —
+     * container_plan is the plan whose row CAPTURED it (the
+     * parent), so a nested member resolved its kids' rows against
+     * the parent's rows and a CONTENT row serialized as an
+     * empty-named wrapper. */
     int ok = 1;
     for (size_t i = 0; i < nk && ok; i++)
-        ok = dp_emit_value(kids[i], container, pool, b, NULL, 0);
+        ok = dp_emit_value(kids[i], kids_container, pool, b, NULL, 0);
     free((void*)kids);
     if (!ok) return 0;
     return dp_sb_puts(b, "</") && dp_sb_puts(b, name) &&
@@ -1377,6 +1391,16 @@ static int dp_emit_value(const struct leptris_plan_result* v,
     if (v->kind == LEPTRIS_PLAN_VALUE_RAW)
         return dp_sb_puts(b, v->str ? v->str : "");
     if (v->kind == LEPTRIS_PLAN_VALUE_ELEMENT) {
+        /* #1565: a walk member captured by a CONTENT row is an
+         * unnamed element — the row lookup must precede the name
+         * resolution, or the empty wire name becomes the wrapper
+         * (<w:item><>text</></w:item>). Content emits inline text
+         * at every nesting level. */
+        if (container && v->row_index != UINT32_MAX &&
+            v->row_index < container->child_count &&
+            container->child_plans[v->row_index].kind ==
+                LEPTRIS_PLAN_KIND_CONTENT)
+            return dp_sb_escape(b, v->str ? v->str : "", 0);
         /* The element's own binding was stamped at walk time; a
          * walk member without one falls back to its plan's. */
         char* name = NULL;
@@ -1397,7 +1421,24 @@ static int dp_emit_value(const struct leptris_plan_result* v,
         else
             name = dp_strdup(local ? local : "");
         if (!name) return 0;
-        int ok = dp_emit_element(v, name, pool, b, decls, is_root);
+        /* Kids resolve their rows against the plan that WALKED this
+         * element: the capturing row's child_plan_index when nested,
+         * else container_plan (the walk root is its own plan). */
+        const struct leptris_plan* poolp =
+            (const struct leptris_plan*)pool;
+        const dp_plan* kids_container =
+            &poolp->plans[v->container_plan];
+        if (container && v->row_index != UINT32_MAX &&
+            v->row_index < container->child_count) {
+            const leptris_child_plan* cap =
+                &container->child_plans[v->row_index];
+            if (cap->child_plan_index >= 0 &&
+                (uint32_t)cap->child_plan_index < poolp->plan_count)
+                kids_container =
+                    &poolp->plans[cap->child_plan_index];
+        }
+        int ok = dp_emit_element(v, name, pool, kids_container, b,
+                                 decls, is_root);
         free(name);
         return ok;
     }

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) {