leptris 1.9.282.0-x86_64-linux → 1.9.285.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6588c7f7a1cc752a55e2b6004645b95f88d8917167627d216dc598fc45a15ce
-  data.tar.gz: d49b8bd941c24ec3904b607c0f3d6ccb90c31e3398f02b2e39476b6dea9fe2af
+  metadata.gz: 1cbf52fef11af3a2a989e2d9c976be1830e9778f9f80a074ab93cc5d7f740bcd
+  data.tar.gz: 636a0e2c00986bb22caa232b80b250175cfdf4906173e67e65846fb216fe95b0
 SHA512:
-  metadata.gz: e2748a8af7450a4ffb3243ea71abbc25695f979b3c562f581aae3c493adb277f31e67885b8c86e71a809df5b08fe68b112ae639fbbfec317ebbcbe0f13bd712f
-  data.tar.gz: 68a1f7ceffeae91777c58f5424ce0fb40abe485f87b741a40e55b0545f338d9d0ebc8365547f2fb8f47b5813e0ede75867526685d354e8e8a4eab3f4c2abb676
+  metadata.gz: c0ce1e3a7abe74fe2c2958a81bd1619839957adbe375a157caeed0807d79078d6d059872ab87bfe175072da70fdb82e4590600f50c3a859b9f8759a7166a00ea
+  data.tar.gz: 6e954ed7a59241c1d7490af5ecbeddbfd91ef847a99bd4a399c320260ae25c3845650f348ff48a07edbed14278d75c368537ebcb422834ae50406d310b426ebc

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## [1.9.285.0] - 2026-10-01
+
+### Added — streaming Door A opt-outs (libleptris 1.9.283, #1459)
+
+- The 1.9.273 `ParseOptions` opt-outs now reach the streaming
+  faces: `options:` on `Iterparse.parse` / `parse_file`,
+  `Pull::Parser.parse` / `parse_file`, `SAX::Recorder.open`, and
+  `SAX::Parser` (`options:` + a `skip_flags=` setter applied
+  before the first feed on the IO path). Duplicate attributes are
+  admitted with the FIRST value winning (DOM parity — the pull
+  Hash view keeps the first of a redefined pair; the raw event
+  pair list is unchanged), error positions degrade to the last
+  tracked state. `ParseOptions.stream_flags` resolves only the two
+  Door A bits; nil keeps the flagless C twins byte-identical.
+  Six new attaches (audit 361/360).
+
+### Fixed — engine sync (1.9.284-1.9.285)
+
+- Vendored libleptris 1.9.284+1.9.285: iterparse full-document
+  mode materializes ONE intact tree (1.9.284) — and 1.9.285
+  completes it: TEXT at depth >= 2 pooled against a document
+  full mode never creates and silently vanished
+  (`<deep>x</deep>` yielded `<deep/>`); text now pools into
+  root_doc at every depth (leptris#1471, red/green pinned), plus
+  `fn:current-date/-time/-dateTime` clock fixes, XQuery
+  contains-token/collation accessors, and the XQuery lexer's
+  doubled-quote escapes. Tree-integrity and text-survival specs
+  pin both fixes on the binding side.
+
 ## [1.9.282.0] - 2026-10-01
 
 ### Fixed — engine sync (1.9.281)

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.282"
+LIBLEPTRIS_VERSION = "1.9.285"
 # 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.282.0"
+  VERSION = "1.9.285.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -971,6 +971,11 @@ attach_function :leptris_parse_string,
       # drains in bulk — callbacks become O(chunks), not O(events).
       attach_function :leptris_sax_recorder_new,
         [], :leptris_sax_recorder
+      # Door A opt-outs (1.9.283, #1459): recorder twin — error
+      # record positions degrade to the last tracked state when
+      # SKIP_SOURCE_POSITIONS is set.
+      attach_function :leptris_sax_recorder_new_flags,
+        [:uint], :leptris_sax_recorder
       attach_function :leptris_sax_recorder_feed,
         [:leptris_sax_recorder, :string, :size_t, :int], :int
       attach_function :leptris_sax_recorder_records,
@@ -987,13 +992,24 @@ attach_function :leptris_parse_string,
       attach_function :leptris_sax_parser_free,
         [:leptris_sax_parser], :void
       attach_function :leptris_sax_parser_set_streaming,
-        [:leptris_sax_parser, :int], :int
+        [:leptris_sax_parser, :int], :int      # Door A opt-outs (1.9.283, #1459): set once before the first
+      # feed(); duplicate attributes admitted keep the first value
+      # (DOM parity), error positions degrade.
+      attach_function :leptris_sax_parser_set_skip_flags,
+        [:leptris_sax_parser, :uint], :void
 
       # Pull parsing (v1.6.0): StAX-style cursor over a document.
       attach_function :leptris_pull_new,
         [:string, :size_t], :leptris_pull_parser
       attach_function :leptris_pull_new_file,
-        [:string], :leptris_pull_parser
+        [:string], :leptris_pull_parser      # Door A opt-outs on the streaming path (1.9.283, #1459):
+      # LEPTRIS_PARSE_SKIP_DUP_DETECTION / SKIP_SOURCE_POSITIONS —
+      # same bits the DOM parse flags consume. 0 matches the
+      # flagless twins above.
+      attach_function :leptris_pull_new_flags,
+        [:string, :size_t, :uint], :leptris_pull_parser
+      attach_function :leptris_pull_new_file_flags,
+        [:string, :uint], :leptris_pull_parser
       attach_function :leptris_pull_next,
         [:leptris_pull_parser], :pointer
       attach_function :leptris_pull_next_batch,
@@ -1023,7 +1039,13 @@ attach_function :leptris_parse_string,
       attach_function :leptris_iterparse_new_ex,
         [:string, :size_t, :int], :leptris_iterparse
       attach_function :leptris_iterparse_new_file_ex,
-        [:string, :int], :leptris_iterparse
+        [:string, :int], :leptris_iterparse      # Door A opt-outs (1.9.283, #1459): flags as in the pull
+      # twins; iterparse over huge files is exactly the workload
+      # that never consumes diagnostics.
+      attach_function :leptris_iterparse_new_ex_flags,
+        [:string, :size_t, :int, :uint], :leptris_iterparse
+      attach_function :leptris_iterparse_new_file_ex_flags,
+        [:string, :int, :uint], :leptris_iterparse
       attach_function :leptris_iterparse_ns_count,
         [:leptris_iterparse], :size_t
       attach_function :leptris_iterparse_ns_uri,

data/lib/leptris/xml/iterparse.rb

@@ -42,10 +42,22 @@ class Leptris::XML::Iterparse
   # NOTE: an IO argument is read fully into memory before the C
   # iterator starts — the bounded-memory path is parse_file (C-side
   # file streaming). The C API takes one (xml, len) buffer.
-  def self.parse(xml_or_io, mode: :top_level, &block)
+  # options: a ParseOptions carrying the Door A opt-outs
+  # (1.9.283, #1459) — duplicate attributes admitted keep the
+  # first value, error positions degrade to the last tracked
+  # state. Iterparse over huge files never consumes diagnostics.
+  def self.parse(xml_or_io, mode: :top_level, options: nil, &block)
     xml = xml_or_io.is_a?(String) ? xml_or_io : xml_or_io.read
-    iterator = new(Leptris::XML::FFI.leptris_iterparse_new_ex(
-      xml, xml.bytesize, mode_code(mode)))
+    flags = Leptris::XML::ParseOptions.stream_flags(options)
+    handle =
+      if flags
+        Leptris::XML::FFI.leptris_iterparse_new_ex_flags(
+          xml, xml.bytesize, mode_code(mode), flags)
+      else
+        Leptris::XML::FFI.leptris_iterparse_new_ex(
+          xml, xml.bytesize, mode_code(mode))
+      end
+    iterator = new(handle)
     # leptris_iterparse_new_ex retains the buffer and reads it
     # lazily in bounded slices (#1207-class): without this
     # reference the input String is collectable the moment parse
@@ -61,9 +73,17 @@ class Leptris::XML::Iterparse
     iterator
   end
 
-  def self.parse_file(path, mode: :top_level, &block)
-    iterator = new(Leptris::XML::FFI.leptris_iterparse_new_file_ex(
-      path, mode_code(mode)))
+  def self.parse_file(path, mode: :top_level, options: nil, &block)
+    flags = Leptris::XML::ParseOptions.stream_flags(options)
+    handle =
+      if flags
+        Leptris::XML::FFI.leptris_iterparse_new_file_ex_flags(
+          path, mode_code(mode), flags)
+      else
+        Leptris::XML::FFI.leptris_iterparse_new_file_ex(
+          path, mode_code(mode))
+      end
+    iterator = new(handle)
     return iterator unless block
     begin
       iterator.run(&block)

data/lib/leptris/xml/parse_options.rb

@@ -72,6 +72,21 @@ class Leptris::XML::ParseOptions
     new(DTDATTR)
   end
 
+  # Streaming-path resolver (1.9.283, #1459): the iterparse / pull /
+  # recorder / SAX-IO faces consume exactly the two Door A opt-out
+  # bits — everything else on a ParseOptions is DOM-parse surface.
+  # Returns nil when no opt-out is set, so the flagless C twins
+  # keep their zero-flag default byte-parity.
+  def self.stream_flags(options)
+    return nil unless options
+    unless options.is_a?(Leptris::XML::ParseOptions)
+      raise ArgumentError, "options must be a Leptris::XML::ParseOptions"
+    end
+
+    mask = SKIP_DUP_DETECTION | SKIP_SOURCE_POSITIONS
+    flags = options.flags & mask
+    flags.zero? ? nil : flags
+  end
   def self.skip_dup_detection
     new(SKIP_DUP_DETECTION)
   end

data/lib/leptris/xml/pull.rb

@@ -38,13 +38,29 @@ module Leptris::XML::Pull
   }.freeze
 
   class Parser
-    def self.parse(xml_or_io)
+    # options: Door A opt-outs (1.9.283, #1459) — same semantics
+    # as Document.parse's.
+    def self.parse(xml_or_io, options: nil)
       xml = xml_or_io.is_a?(String) ? xml_or_io : xml_or_io.read
-      new(Leptris::XML::FFI.leptris_pull_new(xml, xml.bytesize))
+      flags = Leptris::XML::ParseOptions.stream_flags(options)
+      handle =
+        if flags
+          Leptris::XML::FFI.leptris_pull_new_flags(xml, xml.bytesize, flags)
+        else
+          Leptris::XML::FFI.leptris_pull_new(xml, xml.bytesize)
+        end
+      new(handle)
     end
 
-    def self.parse_file(path)
-      new(Leptris::XML::FFI.leptris_pull_new_file(path))
+    def self.parse_file(path, options: nil)
+      flags = Leptris::XML::ParseOptions.stream_flags(options)
+      handle =
+        if flags
+          Leptris::XML::FFI.leptris_pull_new_file_flags(path, flags)
+        else
+          Leptris::XML::FFI.leptris_pull_new_file(path)
+        end
+      new(handle)
     end
 
     def initialize(handle)
@@ -187,7 +203,11 @@ module Leptris::XML::Pull
           .force_encoding(Encoding::UTF_8)
         value = buffer.get_pointer((2 * i + 1) * ptr_size).read_string
           .force_encoding(Encoding::UTF_8)
-        hash[name] = value
+        # DOM parity (1.9.283, #1459): with SKIP_DUP_DETECTION the
+        # raw event still carries both pairs (libxml2-recover keeps
+        # every attribute); the Hash view keeps the FIRST value,
+        # like iterparse and the DOM path.
+        hash[name] = value unless hash.key?(name)
         i += 1
       end
       hash

data/lib/leptris/xml/sax/parser.rb

@@ -18,10 +18,19 @@ class Leptris::XML::SAX::Parser
   # correctness-first fallback kept for engines older than 1.9.18
   # and for consumers wanting the DOM view's shapes.
   def initialize(handler = Leptris::XML::SAX::Document.new,
-                 encoding = nil, streaming: true)
+                 encoding = nil, streaming: true, options: nil)
     @document = handler
     @encoding = encoding
     @streaming = streaming
+    @skip_flags = Leptris::XML::ParseOptions.stream_flags(options)
+  end
+
+  # Door A opt-outs (1.9.283, #1459) applied before the first
+  # feed on the IO path — set once, not thread-safe per the C
+  # contract.
+  def skip_flags=(flags)
+    @skip_flags = flags.to_i & (Leptris::XML::ParseOptions::SKIP_DUP_DETECTION |
+                                Leptris::XML::ParseOptions::SKIP_SOURCE_POSITIONS)
   end
 
   # Swapping the handler invalidates the memoized callback struct so
@@ -163,6 +172,8 @@ class Leptris::XML::SAX::Parser
       handler_struct.pointer, nil)
     if parser_ptr.null?
       raise Leptris::XML::Error, "leptris_sax_parser_create failed"
+      Leptris::XML::FFI.leptris_sax_parser_set_skip_flags(
+        parser_ptr, @skip_flags || 0)
     end
     begin
       while (chunk = io.read(CHUNK_SIZE))

data/lib/leptris/xml/sax/recorder.rb

@@ -33,8 +33,17 @@ class Leptris::XML::SAX::Recorder
   # not a Hash lookup per event.
   KIND_BY_CODE = Array.new(KINDS.size) { |code| KINDS[code] }.freeze
 
-  def self.open
-    raw = Leptris::XML::FFI.leptris_sax_recorder_new
+  # options: Door A opt-outs (1.9.283, #1459) — error record
+  # positions degrade to the last tracked state when
+  # SKIP_SOURCE_POSITIONS is set.
+  def self.open(options: nil)
+    flags = Leptris::XML::ParseOptions.stream_flags(options)
+    raw =
+      if flags
+        Leptris::XML::FFI.leptris_sax_recorder_new_flags(flags)
+      else
+        Leptris::XML::FFI.leptris_sax_recorder_new
+      end
     if raw.null?
       raise Leptris::XML::Error, "leptris_sax_recorder_new failed"
     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.282
+- libleptris v1.9.285
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,43 @@
 ## [Unreleased]
 
+## [1.9.285] - 2026-10-01
+
+### Fixed
+
+- full-document iterparse dropped TEXT at depth >= 2 — pool every node into root_doc (sax)
+
+
+
+## [1.9.284] - 2026-10-01
+
+
+### Added
+
+- adopt contains-token + boolean/collation accessors — string tails batch 5 (xquery)
+
+### Fixed
+
+
+- **iterparse full-document mode silently detached every child of the materialized root** (field-reported total child loss): `<sections><!-- c --><child/>...</sections>` yielded `sections` with 0 children — depth-1 elements were created as roots of throwaway subtree documents instead of appending to the parent. Full-document mode now materializes one intact tree; yields carry the whole subtree at every step. Shipped with an 8-test tree-integrity regression battery (reported shape class, deep subtrees, attributes, chunked/file sources, the v1 contract pinned unchanged, malformed-input error paths).
+- **`fn:current-date` / `fn:current-time` / `fn:current-dateTime` computed from an uninitialized clock and smashed the stack on every call** — the POSIX `gmtime_r` arguments in `h_utc_now` were reversed (`(struct tm*, time_t*)` instead of `(const time_t*, struct tm*)`), so each call read a garbage epoch and wrote the 36-byte result over an 8-byte local. Values are now real (verified against the system clock); the Windows `gmtime_s` branch was always correct.
+- **F&O 14.5-14.7 stability**: the current-date/-time/-dateTime trio now returns ONE instant per evaluation (context-stamped) instead of re-reading the clock per call — same-query comparisons (`current-time() eq current-time()`) can no longer straddle a second boundary. Verified by a 100k-iteration equality loop and a 2000-iteration spec.
+
+## [1.9.283] - 2026-10-01
+
+### Fixed
+
+- **fn:normalize-unicode (F&O conformance)**: the single-argument form now normalizes with NFC (it previously returned the input unchanged); an unknown normalization form raises `FOCH0003` instead of silently falling back to NFC; form matching is case-insensitive with leading/trailing whitespace trimmed, and a zero-length form stays identity. Pinned by the QT3 corpus (29 run-and-agree) with a new runner-side dependency gate for the FULLY-NORMALIZED twins.
+- **fn:iri-to-uri / fn:escape-html-uri (F&O conformance)**: `#` is IRI-legal and no longer percent-encodes; escape-html-uri now keeps printable US-ASCII (0x20–0x7E) and percent-encodes every other UTF-8 byte — it previously emitted HTML entities like `&lt;`. Pinned by the QT3 corpora (38 + 30 run-and-agree).
+- **XQuery lexer**: doubled-quote escapes (XQuery 3.1 A.1 EscapeQuot/EscapeApos) — `"a ""b"" c"` previously failed to parse; the literal decoder also collapses them.
+- **fn:contains-token**: the token argument is trimmed of surrounding whitespace before matching (F&O 5.5.5).
+- **fn:default-collation / fn:default-language** are now implemented (codepoint collation URI; `en`), and `format-integer` accepts its 3-argument language form.
+
+### Added
+
+- **Door A parse opt-outs on the streaming path** (#1459): `leptris_iterparse_new_ex_flags` / `leptris_iterparse_new_file_ex_flags`, `leptris_pull_new_flags` / `leptris_pull_new_file_flags`, `leptris_sax_recorder_new_flags`, and the `leptris_sax_parser_set_skip_flags` primitive — `LEPTRIS_PARSE_SKIP_DUP_DETECTION` and `LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS` now reach iterparse/pull/recorder, with duplicate attributes admitted keeping the first value (DOM parity).
+
+
+
 ## [1.9.282] - 2026-10-01
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -312,6 +312,21 @@ LEPTRIS_API int leptris_sax_parser_set_streaming(LeptrisSAXParser* parser, int s
 LEPTRIS_API void leptris_sax_parser_set_one_shot(LeptrisSAXParser* parser,
                                                  int one_shot);
 
+/**
+ * Set the lane-18 Door A parse opt-outs (#1459): any combination of
+ * LEPTRIS_PARSE_SKIP_DUP_DETECTION (drop the duplicate-attribute
+ * redefinition scan — duplicates are admitted silently) and
+ * LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS (freeze per-byte line/column
+ * accounting; error reports degrade to the position of the last
+ * tracked state). 0 (the create default) keeps full conformance
+ * behavior. These are the same bits leptris_parse_flags consumes on
+ * the DOM path.
+ *
+ * Thread safety: Not thread-safe. Set once before the first feed().
+ */
+LEPTRIS_API void leptris_sax_parser_set_skip_flags(LeptrisSAXParser* parser,
+                                                   unsigned flags);
+
 /* ============================================================================
  * Pull (StAX-style) API — TODO.bindings/04, issue #510 Tier 2
  * ============================================================================ */
@@ -332,6 +347,18 @@ LEPTRIS_API void leptris_sax_parser_set_one_shot(LeptrisSAXParser* parser,
  */
 LEPTRIS_API LeptrisPullParser leptris_pull_new(const char* xml, size_t len);
 
+/**
+ * Create a pull parser with the Door A parse opt-outs (#1459)
+ *
+ * Same event semantics as leptris_pull_new; `flags` is any
+ * combination of LEPTRIS_PARSE_SKIP_DUP_DETECTION and
+ * LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS (see
+ * leptris_sax_parser_set_skip_flags). 0 matches leptris_pull_new.
+ */
+LEPTRIS_API LeptrisPullParser leptris_pull_new_flags(const char* xml,
+                                                     size_t len,
+                                                     unsigned flags);
+
 /**
  * Create a pull parser streaming from a file (TODO.engine/01)
  *
@@ -344,6 +371,14 @@ LEPTRIS_API LeptrisPullParser leptris_pull_new(const char* xml, size_t len);
  */
 LEPTRIS_API LeptrisPullParser leptris_pull_new_file(const char* path);
 
+/**
+ * Create a file-backed pull parser with the Door A parse opt-outs
+ * (#1459) — flags as in leptris_pull_new_flags. 0 matches
+ * leptris_pull_new_file.
+ */
+LEPTRIS_API LeptrisPullParser leptris_pull_new_file_flags(const char* path,
+                                                          unsigned flags);
+
 /**
  * Return the next event, feeding input as needed
  *
@@ -450,6 +485,20 @@ LEPTRIS_API void leptris_pull_free(LeptrisPullParser pull);
  */
 LEPTRIS_API LeptrisSaxRecorder leptris_sax_recorder_new(void);
 
+/**
+ * Create a chunked SAX event recorder with the Door A parse
+ * opt-outs (#1459)
+ *
+ * Same record semantics as leptris_sax_recorder_new; `flags` is any
+ * combination of LEPTRIS_PARSE_SKIP_DUP_DETECTION (no ERROR record
+ * for a redefined attribute) and
+ * LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS (ERROR record positions
+ * degrade to the last tracked state). 0 matches
+ * leptris_sax_recorder_new.
+ */
+LEPTRIS_API LeptrisSaxRecorder leptris_sax_recorder_new_flags(
+    unsigned flags);
+
 /**
  * Feed one input chunk and buffer the events it produces
  *
@@ -564,6 +613,28 @@ LEPTRIS_API LeptrisIterparse leptris_iterparse_new_file(const char* path);
 LEPTRIS_API LeptrisIterparse leptris_iterparse_new_file_ex(
     const char* path, LeptrisIterparseMode mode);
 
+/**
+ * Create an incremental tree-iterator with explicit yield mode and
+ * the Door A parse opt-outs (#1459)
+ *
+ * Same yield semantics as leptris_iterparse_new_ex; `flags` is any
+ * combination of LEPTRIS_PARSE_SKIP_DUP_DETECTION (duplicate
+ * attributes are admitted instead of failing the walk — the first
+ * value surfaces) and LEPTRIS_PARSE_SKIP_SOURCE_POSITIONS (error
+ * positions degrade to the last tracked state). 0 matches
+ * leptris_iterparse_new_ex. Iterparse over huge files is exactly
+ * the workload that never consumes diagnostics.
+ */
+LEPTRIS_API LeptrisIterparse leptris_iterparse_new_ex_flags(
+    const char* xml, size_t len, LeptrisIterparseMode mode,
+    unsigned flags);
+
+/**
+ * File-backed twin of leptris_iterparse_new_ex_flags
+ */
+LEPTRIS_API LeptrisIterparse leptris_iterparse_new_file_ex_flags(
+    const char* path, LeptrisIterparseMode mode, unsigned flags);
+
 /**
  * Return the next completed top-level element
  *

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

@@ -774,6 +774,14 @@ typedef struct xpath_context {
      * 1e-18, INF/-INF) instead of the libxml2-parity XPath 1.0
      * printer. Set by the XQuery eval entry. */
     int xquery_spelling;
+
+    /* F&O 14.5-14.7 stability: current-date/-time/-dateTime return
+     * the same instant for the whole evaluation. First caller
+     * stamps it; the CURRENT_FN trio reads the cache (K2-Codepoint
+     * Equal-1 compares two current-time() renders in one query —
+     * a clock re-read straddling a second boundary flaked CI). */
+    int now_cached;
+    long now_sec;   /* time_t as long (keeps the header self-contained) */
 } XPathContext;
 
 /* XPath operator types - From ext/leptris/xpath.h */

data/vendor-src/libleptris/src/leptris/sax/iterparse.c

@@ -47,6 +47,7 @@ struct leptris_iterparse {
     LeptrisElement stack[IT_MAX_DEPTH];
     int depth;                    /* open element depth (root=1) */
     LeptrisIterparseMode mode;
+    int keep_first_dup;           /* SKIP_DUP_DETECTION: DOM-parity (#1459) */
     char* text_buf;
     size_t text_len, text_cap;
     LeptrisElement done;          /* completed element handed out */
@@ -138,14 +139,21 @@ static void it_flush_text(struct leptris_iterparse* it) {
     /* Text must be created in its PARENT's pool. At depth 1 the
      * parent is the document root (root_doc, full mode only); in v1
      * mode there is no materialized parent — the text is dropped,
-     * exactly as before. */
+     * exactly as before. FULL mode materializes ONE tree entirely
+     * inside root_doc — it->doc is never created there, so text at
+     * any depth must pool into root_doc as well (deeper text used
+     * to create against a NULL doc and silently vanish: nested
+     * <deep>x</deep> yielded <deep/>). */
+    int full_mode = (it->mode == LEPTRIS_ITERPARSE_FULL_DOCUMENT);
     int root_level = (it->depth == 1);
     if (it->text_len == 0 || it->depth < 1 ||
-        (root_level && !it->root_doc)) {
+        (full_mode && !it->root_doc) ||
+        (!full_mode && root_level && !it->root_doc)) {
         it->text_len = 0;
         return;
     }
-    LeptrisDocument pool_doc = root_level ? it->root_doc : it->doc;
+    LeptrisDocument pool_doc =
+        (full_mode || root_level) ? it->root_doc : it->doc;
     it->text_buf[it->text_len] = '\0';
     LeptrisNodeRef t = leptris_text_node_create(pool_doc, it->text_buf);
     if (t) {
@@ -170,13 +178,16 @@ static void it_append_text(struct leptris_iterparse* it,
 }
 
 static LeptrisIterparse it_new_common(LeptrisPullParser pull,
-                                      LeptrisIterparseMode mode) {
+                                      LeptrisIterparseMode mode,
+                                      unsigned flags) {
     if (!pull) return NULL;
     struct leptris_iterparse* it =
         (struct leptris_iterparse*)calloc(1, sizeof(*it));
     if (!it) { leptris_pull_free(pull); return NULL; }
     it->pull = pull;
     it->mode = mode;
+    it->keep_first_dup =
+        (flags & LEPTRIS_PARSE_SKIP_DUP_DETECTION) ? 1 : 0;
     it->sub_arena = leptris_arena_create(IT_SUBTREE_ARENA_BYTES);
     return it;
 }
@@ -188,8 +199,15 @@ LEPTRIS_API LeptrisIterparse leptris_iterparse_new(const char* xml,
 
 LEPTRIS_API LeptrisIterparse leptris_iterparse_new_ex(
         const char* xml, size_t len, LeptrisIterparseMode mode) {
+    return leptris_iterparse_new_ex_flags(xml, len, mode, 0);
+}
+
+LEPTRIS_API LeptrisIterparse leptris_iterparse_new_ex_flags(
+        const char* xml, size_t len, LeptrisIterparseMode mode,
+        unsigned flags) {
     if (!xml || len == 0) return NULL;
-    return it_new_common(leptris_pull_new(xml, len), mode);
+    return it_new_common(leptris_pull_new_flags(xml, len, flags),
+                         mode, flags);
 }
 
 LEPTRIS_API LeptrisIterparse leptris_iterparse_new_file(const char* path) {
@@ -198,8 +216,14 @@ LEPTRIS_API LeptrisIterparse leptris_iterparse_new_file(const char* path) {
 
 LEPTRIS_API LeptrisIterparse leptris_iterparse_new_file_ex(
         const char* path, LeptrisIterparseMode mode) {
+    return leptris_iterparse_new_file_ex_flags(path, mode, 0);
+}
+
+LEPTRIS_API LeptrisIterparse leptris_iterparse_new_file_ex_flags(
+        const char* path, LeptrisIterparseMode mode, unsigned flags) {
     if (!path || !*path) return NULL;
-    return it_new_common(leptris_pull_new_file(path), mode);
+    return it_new_common(leptris_pull_new_file_flags(path, flags),
+                         mode, flags);
 }
 
 /* Advance past the last yield. When a completed TOP-LEVEL child was
@@ -278,8 +302,13 @@ static LeptrisElement handle_start(struct leptris_iterparse* it,
     /* depth==1: a new top-level child — a fresh document over the
      * REUSED arena (bump-reset at release; grown when a child nearly
      * fills the span). Arena creation failure falls back to the
-     * plain 32 KB-page document. */
-    if (it->depth == 1 && !it->doc) {
+     * plain 32 KB-page document. TOP_LEVEL only: full-document mode
+     * materializes ONE tree in root_doc — depth-1 children used to
+     * take this path too and became roots of throwaway subtree
+     * documents, shattering the tree at every root child
+     * (yields looked right; the parent ended up empty). */
+    if (it->mode == LEPTRIS_ITERPARSE_TOP_LEVEL &&
+        it->depth == 1 && !it->doc) {
         it->doc = it->sub_arena
             ? leptris_document_create_on_arena(it->sub_arena)
             : leptris_document_create();
@@ -300,24 +329,35 @@ static LeptrisElement handle_start(struct leptris_iterparse* it,
         prefix_buf[plen] = '\0';
         prefix = prefix_buf;
     }
-    LeptrisDocument target =
-        (it->depth == 0) ? it->root_doc : it->doc;
+    LeptrisDocument target;
+    if (it->mode == LEPTRIS_ITERPARSE_FULL_DOCUMENT)
+        target = it->root_doc;   /* one tree, one pool (#592 contract) */
+    else
+        target = (it->depth == 0) ? it->root_doc : it->doc;
     LeptrisElement e = leptris_element_create(target, local);
     if (!e) { it->exhausted = 1; return NULL; }
     if (prefix) leptris_element_set_prefix(e, prefix);
     attach_namespaces(it, e, prefix);
     size_t na = leptris_pull_attr_count(it->pull);
     for (size_t i = 0; i < na; i++) {
-        leptris_element_set_attribute(e, leptris_pull_attr_name(it->pull, i),
+        const char* an = leptris_pull_attr_name(it->pull, i);
+        /* SKIP_DUP_DETECTION admits duplicates with DOM parity:
+         * keep the first (direct_parse's dup-skip contract); the
+         * lookup runs only when the opt-out is armed. */
+        if (it->keep_first_dup && leptris_element_attribute(e, an))
+            continue;
+        leptris_element_set_attribute(e, an,
                                       leptris_pull_attr_value(it->pull, i));
     }
     if (it->depth == 0) {
         leptris_document_set_root(it->root_doc, e);
-    } else if (it->depth == 1) {
-        /* A top-level child is the ROOT of its own subtree document —
-         * never attached to the document root (that would link two
-         * pools; freeing the subtree would leave the root's child
-         * chain dangling — the ASAN UAF in PR #590). */
+    } else if (it->mode == LEPTRIS_ITERPARSE_TOP_LEVEL && it->depth == 1) {
+        /* TOP_LEVEL: a top-level child is the ROOT of its own
+         * subtree document — never attached to the document root
+         * (that would link two pools; freeing the subtree would
+         * leave the root's child chain dangling — the ASAN UAF in
+         * PR #590). FULL_DOCUMENT appends below: the whole tree
+         * lives in root_doc and must stay INTACT. */
         leptris_document_set_root(it->doc, e);
     } else {
         leptris_element_append_child(it->stack[it->depth - 1], e);

data/vendor-src/libleptris/src/leptris/sax/parser.c

@@ -62,6 +62,7 @@ LEPTRIS_API LeptrisSAXParser* leptris_sax_parser_create(LeptrisSAXHandler* handl
     parser->line = 1;
     parser->column = 1;
     parser->has_error = 0;
+    parser->skip_flags = 0;
     parser->error_message[0] = '\0';
     parser->scratch = NULL;
     parser->scratch_tail = NULL;