leptris 1.9.270.0 → 1.9.273.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb2a0e979362ca73a36edb1e16e47d1e69db7e3ce0f4dc1efc3fe012eeadfd53
-  data.tar.gz: ba0d63880b1060c14dda81a33b835c88c37a294dd093dd0bf9801d9ebea8070c
+  metadata.gz: eac60497cce482f9c8a82023dfe9af7437aca757483c90e2a8af52c0aa9f9f40
+  data.tar.gz: aadeb53448aabd955c1ede63cf1b468d50ab575100f0d7f3e57f1675a460f9f0
 SHA512:
-  metadata.gz: f1ec1c35f4d191afdaee7e5b5e4c799532d1ea58f4ad388f63b4ebfc3b7fbce759022f1a6be01b341d167c6998b6adfe72619e7e90ba2c261a3f26ca6f5b577f
-  data.tar.gz: 9c0d192018890d531cd645df8866164093baa9dbd9974fd0500b4bdc32ed566906fcb8d2bf3d7c748c223fb54df88124c6476f373d04fa21350b3739598ac7c4
+  metadata.gz: 9d695d666df1ebec848d062cee08f7f35101f872d799ffb18ec2bc2de502b25f410fe086f02f280658c76972511e3d532b42d4bfca78c4fee5ea38d8b94cf1e2
+  data.tar.gz: f1704c469043bf964a5b52def67dede9a719a36e42732d0e4abd818e8de6f8ef076c12c30bce82a2d39591c1951e2518fdafbb2af7f821a46eaf5ba9f973a1de

data/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.270.0] - 2026-09-29
+
+### Performance — engine sync (1.9.269-1.9.270)
+
+- Vendored libleptris 1.9.270:
+  - A parse+free cycle is exactly ONE system allocation (the arena
+    header carved into the span; frozen by an exact-count allocator
+    pin) — and the 256-byte error buffer leaves the construction
+    memset.
+  - The lazy #635 raw-attribute journal was reverted (#1431,
+    release-blocking): chain synthesis on stale elements walked
+    freed chains — the eager journal is restored, byte-identical to
+    1.9.268 on that surface. The lazy form returns only behind a
+    real lifetime contract.
+
 ## [1.9.268.0] - 2026-09-29
 
 ### Performance — engine sync (1.9.266-1.9.268)

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.270"
+LIBLEPTRIS_VERSION = "1.9.273"
 # 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.270.0"
+  VERSION = "1.9.273.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -384,6 +384,14 @@ module Leptris
         [:leptris_plan_result, :size_t], :leptris_plan_result
       attach_function :leptris_plan_value_attribute,
         [:leptris_plan_result, :string], UTF8_STRING
+      # One-call flat child list: names blob with per-child offsets
+      # (SIZE_MAX = NULL name, i.e. content runs), type tags, and
+      # borrowed child handles. Returns 0 on success or the blob
+      # capacity required (buffers untouched) — the host retries at
+      # that capacity.
+      attach_function :leptris_plan_value_children_snapshot,
+        [:leptris_plan_result, :pointer, :size_t, :pointer, :pointer,
+         :pointer], :size_t
       # #1254 (leptris 1.9.216): one-call flat attribute read —
       # parallel name/value/handle arrays, capacity-bounded; total
       # count returned (min(total, max_count) copied). Also the

data/lib/leptris/xml/plan_value.rb

@@ -112,6 +112,30 @@ class Leptris::XML::PlanValue
                                     counter: @counter)
   end
 
+  # ELEMENT: the whole child list in one FFI crossing — parallel
+  # arrays of name (nil for content runs), type_tag, and the wrapped
+  # children. Enumerating through #at/#name/#type_tag costs three
+  # crossings per child; this costs one per subtree, with the
+  # PlanValue wrapping Ruby-side. Returns [names, tags, children].
+  def children_snapshot
+    n = Leptris::XML::FFI.leptris_plan_value_count(@ptr)
+    return [[], [], []] if n.zero?
+
+    @counter[0] += 2 # count + the snapshot crossing
+    cap = 64 * n
+    loop do
+      blob = ::FFI::MemoryPointer.new(:char, cap)
+      offsets = ::FFI::MemoryPointer.new(:size_t, n + 1)
+      tags = ::FFI::MemoryPointer.new(:uint8, n)
+      handles = ::FFI::MemoryPointer.new(:pointer, n)
+      needed = Leptris::XML::FFI.leptris_plan_value_children_snapshot(
+        @ptr, blob, cap, offsets, tags, handles)
+      break snapshot_build(blob, offsets, tags, handles, n) if needed.zero?
+
+      cap = needed
+    end
+  end
+
   # ELEMENT: attribute value by wire_name (nil when absent).
   def attribute(wire_name)
     @counter[0] += 1
@@ -282,13 +306,40 @@ class Leptris::XML::PlanValue
   # row — the FFI name probe is skipped (#298 crossings floor).
   # Multi-row plans probe by wire_name (result positions only
   # cover matched children, so positional mapping is unsafe).
-  def child_plan_for_position(ptr)
+  SNAPSHOT_NULL_OFFSET = 0xFFFFFFFFFFFFFFFF
+
+  # FFI get_uint64/get_pointer take BYTE offsets, not indices.
+  SIZE_T_SIZE = ::FFI::MemoryPointer.new(:size_t, 2).total / 2
+  POINTER_SIZE = ::FFI::Type::POINTER.size
+
+  def snapshot_build(blob, offsets, tags, handles, n)
+    names = ::Array.new(n)
+    n.times do |i|
+      off = offsets.get_uint64(i * SIZE_T_SIZE)
+      names[i] = off == SNAPSHOT_NULL_OFFSET ? nil : blob.get_string(off)
+    end
+    tag_values = ::Array.new(n) { |i| tags.get_uint8(i) }
+    children = ::Array.new(n)
+    n.times do |i|
+      ptr = handles.get_pointer(i * POINTER_SIZE)
+      child_plan = child_plan_for_position(ptr, name: names[i])
+      children[i] = Leptris::XML::PlanValue.new(ptr, plans: @plans,
+                                                plan: child_plan,
+                                                counter: @counter)
+    end
+    [names, tag_values, children]
+  end
+
+  def child_plan_for_position(ptr, name: nil)
     return nil unless @plan
     rows = @plan[:children] || []
     row = rows.size == 1 ? rows.first : nil
     unless row
-      @counter[0] += 1
-      child_name = Leptris::XML::FFI.leptris_plan_value_name(ptr)
+      child_name = name
+      if child_name.nil?
+        @counter[0] += 1
+        child_name = Leptris::XML::FFI.leptris_plan_value_name(ptr)
+      end
       row = rows.find { |r| r[:name] == child_name }
     end
     return nil unless row && @plans

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,42 @@
 ## [Unreleased]
 
+## [1.9.273] - 2026-09-29
+
+### Fixed
+
+- children snapshot returns child handles (descriptor)
+
+
+
+## [1.9.272] - 2026-09-29
+
+### Added
+
+- `LEPTRIS_PARSE_SKIP_DUP_DETECTION` (8u) and `LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS` (16u) parse
+  flags for `leptris_parse_string_flags` — leptris#1436 Door A. Opt-out gates for the two remaining
+  fixed per-attribute/per-element bookkeeping costs; defaults unchanged (a zero flag word parses
+  byte-identically to 1.9.271).
+
+### Performance
+
+- `SKIP_DUP_DETECTION`: the name-hash serial-multiply chain and duplicate probe are skipped
+  (~2.5 ns/attr measured floor). Duplicate attributes are admitted silently — no recover
+  diagnostic; both copies stay visible in the chain and the raw view; queries resolve first-wins.
+  Measured -11-13% opt-in on the 100-attribute wide parse row (1522-1535 -> 1315-1357 ns/doc).
+- `SKIP_SOURCE_POSITIONS`: the element position journal is not built; element columns degrade
+  (col_start falls back to 1, col_end unwritten) while lines continue to resolve via the lazy
+  newline table.
+
+
+
+## [1.9.271] - 2026-09-29
+
+### Added
+
+- plan-value children snapshot — one crossing per child list (descriptor)
+
+
+
 ## [1.9.270] - 2026-09-29
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -211,6 +211,22 @@ LEPTRIS_API size_t leptris_plan_value_count(const LeptrisPlanResult v);
 /* ELEMENT child value / COLLECTION item at i; NULL out of range. */
 LEPTRIS_API LeptrisPlanResult leptris_plan_value_at(const LeptrisPlanResult v,
                                                     size_t i);
+/* ELEMENT: one crossing for the whole child list. Writes each
+ * child's NUL-terminated name into names_blob at the byte offsets
+ * recorded in name_offsets (kid_count+1 entries; the final entry is
+ * the total blob size), each child's type_tag into type_tags, and
+ * each child's borrowed handle into child_handles. A child whose
+ * name is NULL (content runs) records SIZE_MAX in its offsets entry
+ * and writes nothing to the blob. Returns 0 on success; otherwise
+ * returns the blob capacity the child names require and leaves the
+ * buffers untouched, so the host retries with the returned
+ * capacity. Handles stay borrowed — leptris_plan_value_at is no
+ * longer needed for enumeration. */
+LEPTRIS_API size_t leptris_plan_value_children_snapshot(
+    const LeptrisPlanResult v,
+    char* names_blob, size_t blob_cap,
+    size_t* name_offsets, uint8_t* type_tags,
+    LeptrisPlanResult* child_handles);
 /* ELEMENT: attribute value by wire_name; NULL when absent. */
 LEPTRIS_API const char* leptris_plan_value_attribute(const LeptrisPlanResult v,
                                                      const char* wire_name);

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

@@ -226,7 +226,17 @@ typedef enum {
     /* Keep &name; references unexpanded as ENTITY_REF nodes in the
      * tree (#1094): text runs split around them and reads resolve
      * them lazily (libxml2's default, pre-NOENT). */
-    LEPTRIS_PARSE_KEEP_ENTITY_REFS = 4u
+    LEPTRIS_PARSE_KEEP_ENTITY_REFS = 4u,
+    /* Lane-18 round 18 (leptris#1436 Door A): performance opt-outs
+     * for callers that do not consume diagnostics features pugixml
+     * does not carry. Defaults keep every feature ON — these bits
+     * SKIP work:
+     * - SKIP_DUP_DETECTION: duplicate attributes are admitted
+     *   silently (first still wins for queries; no recover diag).
+     * - SKIP_SOURCE_POSITIONS: element source columns degrade to
+     *   zeros (line still resolves from the buffer). */
+    LEPTRIS_PARSE_SKIP_DUP_DETECTION = 8u,
+    LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS = 16u
 } LeptrisParseFlags;
 
 /* ============================================================================

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

@@ -12,6 +12,7 @@
  * recursively by leptris_plan_result_free. */
 #include <errno.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -909,6 +910,40 @@ LEPTRIS_API LeptrisPlanResult leptris_plan_value_at(const LeptrisPlanResult v, s
     return v->kids[i];
 }
 
+LEPTRIS_API size_t leptris_plan_value_children_snapshot(
+    const LeptrisPlanResult v,
+    char* names_blob, size_t blob_cap,
+    size_t* name_offsets, uint8_t* type_tags,
+    LeptrisPlanResult* child_handles) {
+    if (!v) return 0;
+    size_t need = 0;
+    for (size_t i = 0; i < v->kid_count; i++) {
+        const char* n = v->kids[i]->name;
+        need += (n ? strlen(n) : 0) + 1;
+    }
+    if (need > blob_cap || !names_blob || !name_offsets || !type_tags ||
+        !child_handles)
+        return need;
+    size_t off = 0;
+    for (size_t i = 0; i < v->kid_count; i++) {
+        const LeptrisPlanResult kid = v->kids[i];
+        const char* n = kid->name;
+        if (n) {
+            size_t len = strlen(n);
+            memcpy(names_blob + off, n, len);
+            names_blob[off + len] = '\0';
+            name_offsets[i] = off;
+            off += len + 1;
+        } else {
+            name_offsets[i] = (size_t)-1;
+        }
+        type_tags[i] = kid->type_tag;
+        child_handles[i] = kid;
+    }
+    name_offsets[v->kid_count] = off;
+    return 0;
+}
+
 LEPTRIS_API const char* leptris_plan_value_attribute(const LeptrisPlanResult v,
                                          const char* wire_name) {
     if (!v || !wire_name) return NULL;

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -184,6 +184,7 @@ typedef struct {
      * the first ws-normalized/entity value flips this on and
      * backfills the clean prefix, preserving the source-byte
      * contract exactly where synthesis could not. */
+    unsigned skip_flags;   /* LEPTRIS_PARSE_SKIP_* (round 18, #1436 Door A) */
     struct leptris_ns_cache* nsc_cursor;
     struct leptris_ns_cache* nsc_end;
     /* DTD parsed from the DOCTYPE internal subset. NULL when the
@@ -552,7 +553,7 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
      * (libxml2 recover semantics, and the digest's first-wins
      * becomes official); the duplicate never enters the chain, it
      * costs its already-carved slot. */
-    {
+    if (!(p->skip_flags & LEPTRIS_PARSE_SKIP_DUP_DETECTION)) {
         int dup = 0;
         if (dp_dup_seen_or_add(p, name_hash) &&
             elem->first_attribute_off != 0) {
@@ -594,7 +595,8 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
              * the raw-attr registration so BOTH surfaces agree. */
             return 1;
         }
-        if (elem->first_attribute_off != 0) {
+    }
+    if (elem->first_attribute_off != 0) {
         /* Cache should always be valid mid-parse. Fall back to walk
          * only if cache is NULL (defensive — shouldn't happen). */
         struct leptris_attribute* tail = p->current_elem_last_attr;
@@ -612,7 +614,6 @@ static inline int dp_add_attr_inline(DParser* p, LeptrisElement elem,
          * offset is ever needed. */
         elem->first_attribute_off =
             (int32_t)((char*)attr - (char*)elem);
-        }
     }
     p->current_elem_last_attr = attr;
     p->cur_attr_count++;
@@ -902,8 +903,16 @@ static int dp_parse_attrs(DParser* p, LeptrisElement elem) {
          * bytes, was the cost. */
         char* name_start = p->pos;
         if (!IS_NAME_START(*p->pos)) return -1;
-        uint32_t dh = 2166136261u ^ (unsigned char)name_start[0];
-        dh *= 16777619u;
+        /* The name hash feeds only the duplicate probe (the dup
+         * confirm is bytewise) — SKIP_DUP_DETECTION callers skip the
+         * whole serial-multiply chain. */
+        const int need_dup_hash =
+            (p->skip_flags & LEPTRIS_PARSE_SKIP_DUP_DETECTION) == 0;
+        uint32_t dh = 0;
+        if (need_dup_hash) {
+            dh = 2166136261u ^ (unsigned char)name_start[0];
+            dh *= 16777619u;
+        }
         const char* attr_colon =
             (name_start[0] == ':') ? name_start : NULL;
         p->pos++;
@@ -912,19 +921,19 @@ static int dp_parse_attrs(DParser* p, LeptrisElement elem) {
             for (;;) {
                 char c0 = s[0];
                 if (DP_UNLIKELY(!IS_NAME_CHAR(c0))) break;
-                dh ^= (unsigned char)c0; dh *= 16777619u;
+                if (need_dup_hash) { dh ^= (unsigned char)c0; dh *= 16777619u; }
                 if (c0 == ':') attr_colon = s;
                 char c1 = s[1];
                 if (DP_UNLIKELY(!IS_NAME_CHAR(c1))) { s += 1; break; }
-                dh ^= (unsigned char)c1; dh *= 16777619u;
+                if (need_dup_hash) { dh ^= (unsigned char)c1; dh *= 16777619u; }
                 if (c1 == ':') attr_colon = s + 1;
                 char c2 = s[2];
                 if (DP_UNLIKELY(!IS_NAME_CHAR(c2))) { s += 2; break; }
-                dh ^= (unsigned char)c2; dh *= 16777619u;
+                if (need_dup_hash) { dh ^= (unsigned char)c2; dh *= 16777619u; }
                 if (c2 == ':') attr_colon = s + 2;
                 char c3 = s[3];
                 if (DP_UNLIKELY(!IS_NAME_CHAR(c3))) { s += 3; break; }
-                dh ^= (unsigned char)c3; dh *= 16777619u;
+                if (need_dup_hash) { dh ^= (unsigned char)c3; dh *= 16777619u; }
                 if (c3 == ':') attr_colon = s + 3;
                 s += 4;
             }
@@ -1258,6 +1267,7 @@ static inline LeptrisTextNode* dp_text_create_norm(DParser* p,
  * bearing declaration whose element matches, materialize the value
  * when the element does not carry the attribute. */
 static struct leptris_document* direct_parse_internal(char* buf, size_t len,
+                                                      unsigned skip_flags,
                                                      int owns_buffer,
                                                      int drop_ws_text,
                                                      int apply_dtd_attrs,
@@ -1474,6 +1484,7 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
     p.end = buf + len;
     p.pool = pool;
     p.doc = doc;
+    p.skip_flags = skip_flags;
     p.depth = 0;
     p.root = NULL;
     p.dc_head = NULL;
@@ -1823,7 +1834,8 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
             /* Parse attributes (scans from the delimiter position). */
             int self_closing = dp_parse_attrs(&p, elem);
             if (self_closing < 0) goto fail;
-            if (p.line_offsets_ok) {
+            if (p.line_offsets_ok &&
+                !(p.skip_flags & LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS)) {
                 uint32_t ste = (uint32_t)(p.pos - p.buf);
                 p.pos_slot_stack[p.depth] = leptris_elem_pos_record(
                     p.doc, elem, ste, self_closing ? ste : 0u);
@@ -3080,7 +3092,7 @@ struct leptris_document* direct_parse(const char* xml, size_t len) {
         struct leptris_document* d = dp_il_try(xml, len, 0, 0, 0);
         if (d) return d;
     }
-    return direct_parse_internal((char*)xml, len, 2, 0, 0, 0);
+    return direct_parse_internal((char*)xml, len, 0, 2, 0, 0, 0);
 }
 
 /* Public flagged entry (LEPTRIS_PARSE_DROP_WS_TEXT et al.). */
@@ -3095,7 +3107,10 @@ struct leptris_document* direct_parse_flags(const char* xml, size_t len,
             (parse_flags & LEPTRIS_PARSE_DTDATTR) ? 1 : 0);
         if (d) return d;
     }
-    return direct_parse_internal((char*)xml, len, 2,
+    return direct_parse_internal((char*)xml, len,
+                                 parse_flags & (LEPTRIS_PARSE_SKIP_DUP_DETECTION |
+                                     LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS),
+                                 2,
                                  (parse_flags & LEPTRIS_PARSE_DROP_WS_TEXT)
                                      ? 1 : 0,
                                  (parse_flags & LEPTRIS_PARSE_DTDATTR)
@@ -3108,5 +3123,5 @@ struct leptris_document* direct_parse_flags(const char* xml, size_t len,
 struct leptris_document* direct_parse_inplace(char* buf, size_t len) {
     if (!buf || len == 0) return NULL;
     buf[len] = '\0';  /* Ensure NUL termination */
-    return direct_parse_internal(buf, len, 0, 0, 0, 0);
+    return direct_parse_internal(buf, len, 0, 0, 0, 0, 0);
 }

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

@@ -2393,6 +2393,75 @@ TEST(DomBasics, RawAttributesBackfillWhenXmlnsArrivesLate) {
     leptris_document_free(doc);
 }
 
+/* Lane-18 round 18 (leptris#1436 Door A): the SKIP_ parse flags let
+ * performance-critical callers drop diagnostics features pugixml
+ * does not carry. Defaults keep every feature ON — zero-initialized
+ * flag words parse exactly like today. */
+TEST(DomBasics, ParseSkipDupDetectionAdmitsBothSilently) {
+    /* Default-lane pin: the interleaved lane always tracks (its
+     * builder is a separate construction path). */
+    if (getenv("LEPTRIS_INTERLEAVED")) GTEST_SKIP();
+    const char xml[] = "<r a='1' a='2'/>";
+    LeptrisDocument d0 =
+        leptris_parse_string_flags(xml, std::strlen(xml),
+                                   (LeptrisParseFlags)0, nullptr);
+    ASSERT_NE(d0, nullptr);
+    LeptrisElement r0 = leptris_document_root(d0);
+    EXPECT_EQ(leptris_document_parse_diag_count(d0), 1u);
+    EXPECT_EQ(leptris_element_attributes_raw(r0, nullptr, nullptr, 0), 1u);
+    leptris_document_free(d0);
+
+    LeptrisDocument d1 = leptris_parse_string_flags(
+        xml, std::strlen(xml), LEPTRIS_PARSE_SKIP_DUP_DETECTION,
+        nullptr);
+    ASSERT_NE(d1, nullptr);
+    LeptrisElement r1 = leptris_document_root(d1);
+    EXPECT_EQ(leptris_document_parse_diag_count(d1), 0u);
+    EXPECT_EQ(leptris_element_attributes_raw(r1, nullptr, nullptr, 0), 2u);
+    const char* q[2]; const char* v[2];
+    ASSERT_EQ(leptris_element_attributes_raw(r1, q, v, 2), 2u);
+    EXPECT_STREQ(q[0], "a"); EXPECT_STREQ(v[0], "1");
+    EXPECT_STREQ(q[1], "a"); EXPECT_STREQ(v[1], "2");
+    /* Queries still resolve first-wins by chain order. */
+    EXPECT_STREQ(leptris_element_attribute(r1, "a"), "1");
+    leptris_document_free(d1);
+}
+
+TEST(DomBasics, ParseSkipPositionsDegradesColumnsToZeros) {
+    if (getenv("LEPTRIS_INTERLEAVED")) GTEST_SKIP();
+    const char xml[] = "<r>\n  <e id='7'/>\n</r>";
+    LeptrisDocument d0 =
+        leptris_parse_string_flags(xml, std::strlen(xml),
+                                   (LeptrisParseFlags)0, nullptr);
+    ASSERT_NE(d0, nullptr);
+    LeptrisElement e0 = leptris_element_child(
+        leptris_document_root(d0), 0);
+    LeptrisSourcePosition p0;
+    memset(&p0, 0, sizeof(p0));
+    leptris_node_source_position((LeptrisNodeRef)e0, &p0);
+    EXPECT_GT(p0.line, 0);
+    EXPECT_GT(p0.col_start, 0);
+    leptris_document_free(d0);
+
+    LeptrisDocument d1 = leptris_parse_string_flags(
+        xml, std::strlen(xml), LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS,
+        nullptr);
+    ASSERT_NE(d1, nullptr);
+    LeptrisElement e1 = leptris_element_child(
+        leptris_document_root(d1), 0);
+    LeptrisSourcePosition p1;
+    memset(&p1, 0, sizeof(p1));
+    leptris_node_source_position((LeptrisNodeRef)e1, &p1);
+    /* Line still resolves (base.line + the lazy newline table).
+     * The journaled columns degrade: col_start falls back to the
+     * generic column 1 (start offset 0), col_end is never written
+     * (element_end 0 -> the setter skips it). */
+    EXPECT_GT(p1.line, 0);
+    EXPECT_EQ(p1.col_start, 1);
+    EXPECT_EQ(p1.col_end, 0);
+    leptris_document_free(d1);
+}
+
 /* Issue #635: the raw attribute view carries xmlns declarations
  * interleaved among the attributes in SOURCE order — the mixed
  * qname-ordered list the streaming transports deliver, which the

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.270",
+  "version": "1.9.273",
   "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.270.0
+  version: 1.9.273.0
 platform: ruby
 authors:
 - Ribose Inc.