leptris 1.9.324.0 → 1.9.333.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20ca01027af6d2d9c7dd54b359eb38fb8243682d85499c82fa021f22605718f6
-  data.tar.gz: 67293f668204144634cac5a732f48376f218ac225378f1139809900ccd459c06
+  metadata.gz: b49c473e39e2876b99fafc9c9bf9c6025fe52640699d0eac17a7054a699fdb5d
+  data.tar.gz: 42f69045bf2379d40d51b8503bec81e7e7bbf5dbc5e89eaef959e7b6a15d5db6
 SHA512:
-  metadata.gz: 8a6421039f5259c8887348842d639ab31c270fb628b22538b51d5426093aee61dce662de3a5c1386a00faa8fbd6cc2ddc715fe856c14ed3dc0e073c369491858
-  data.tar.gz: 17a7df64ddb31b03471b14fcbe99c15ced17574da99709fa316de42b8176b62c8cc6b6722f6c8d6f3529981e6b53b4e7b28ec1474046bd33fb2dceebe33ca8f7
+  metadata.gz: fd6fcd375d425f8dcaf8069c83c9d169acc45dd60fff80e7ff3661b6d119b06f61d3285f79b788fe693ba061c884d06469639976d9b9ac807012a475d70a5217
+  data.tar.gz: f8145e11531fd836f617a233634ec23fefc5faca631d28fd475f281951cbeaf838f522fbc338157490932e80ec04fba2fa9f096fdecd87ce5439e5762470e3ed

data/CHANGELOG.md

@@ -1,3 +1,45 @@
+## [1.9.331.0] - 2026-10-10
+
+### Added — engine sync (libleptris 1.9.325-1.9.331)
+
+- **XSD.compile_file (1.9.326)**: the file-path compile face —
+  unreadable files raise; malformed schemas compile to
+  error-carrying handles, exactly like the string face.
+  Audit 382/381.
+- **XSD charter completion (1.9.326)**: xs:union / xs:list
+  derivation (typed items, length semantics), groups,
+  attributeGroups, complexContent/simpleContent derivation,
+  substitution groups, fixed values, includes — pinned for
+  unions (any-member acceptance, lexical + instance) and lists
+  (per-item typing). KNOWN GAP filed upstream (leptris#1615):
+  memberTypes + an inline anonymous member together over-accept;
+  each spelling alone is correct and pinned.
+
+### Fixed — engine sync
+
+- 1.9.325: local particle declarations govern nested children —
+  particle-only children's attributes and content models validate
+  (the `<item qty="nan"/>` shape), pinned.
+- 1.9.327-1.9.331: five nightly-fuzz finds (NUL-leading text
+  runs, two dp-fail-path leaks, the fast-path declaration probe
+  read, duplicate DOCTYPE model replacement) — the observable one
+  pinned: a duplicate DOCTYPE keeps the FIRST internal subset
+  (keep-first, matching the duplicate-attribute rule).
+
+## [1.9.324.0] - 2026-10-09
+
+### Added — engine sync (libleptris 1.9.324)
+
+- **XSD identity constraints — tier-1 scope complete (#1075)**:
+  `xs:key` / `xs:unique` / `xs:keyref` capture on top-level
+  declarations (incl. inline complexTypes) and two-pass instance
+  validation: key/unique tuple collection with uniqueness +
+  non-empty-field enforcement, then keyref resolution — attribute
+  fields included, selectors through the engine's own XPath.
+  Completes compile → datatypes/facets → content models →
+  instance validation → identity constraints. Pinned: resolved
+  refs, duplicate tuples, dangling refs, empty fields.
+
 ## [1.9.323.0] - 2026-10-08
 
 ### Fixed — engine sync (libleptris 1.9.323)

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.324"
+LIBLEPTRIS_VERSION = "1.9.333"
 # 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.324.0"
+  VERSION = "1.9.333.0"
 end

data/lib/leptris/xml/cdata.rb

@@ -31,4 +31,8 @@ class Leptris::XML::CDATA < Leptris::XML::Text
       Leptris::XML::FFI.leptris_cdata_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    "<![CDATA[#{content}]]>"
+  end
 end

data/lib/leptris/xml/comment.rb

@@ -31,4 +31,8 @@ class Leptris::XML::Comment < Leptris::XML::Node
       Leptris::XML::FFI.leptris_comment_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    "<!--#{content}-->"
+  end
 end

data/lib/leptris/xml/entity_reference.rb

@@ -10,4 +10,8 @@ class Leptris::XML::EntityReference < Leptris::XML::Node
     Leptris::XML::FFI.leptris_entity_ref_node_name(c_ptr)
   end
   alias_method :node_name, :name
+
+  def to_s
+    "&#{name};"
+  end
 end

data/lib/leptris/xml/ffi.rb

@@ -1289,6 +1289,11 @@ attach_function :leptris_parse_string,
       # schema-level errors. Validation is a later tier.
       attach_function :leptris_xsd_compile,
         [:string, :size_t, :pointer], :leptris_xsd_schema
+      # libleptris 1.9.326: compile from a file path — NULL only
+      # when unreadable; malformed schemas yield error-carrying
+      # handles, exactly like the string face.
+      attach_function :leptris_xsd_compile_file,
+        [:string, :pointer], :leptris_xsd_schema
       attach_function :leptris_xsd_free,
         [:leptris_xsd_schema], :void
       attach_function :leptris_xsd_declaration_count,

data/lib/leptris/xml/node.rb

@@ -8,6 +8,7 @@ class Leptris::XML::Node
     @c_ptr ||= ::FFI::Pointer.new(@c_address)
   end
 
+
   # The Integer twin of #c_ptr — reading it never materializes a
   # Pointer (the native faces take addresses).
   def c_address

data/lib/leptris/xml/processing_instruction.rb

@@ -50,6 +50,10 @@ class Leptris::XML::ProcessingInstruction < Leptris::XML::Node
     new_data
   end
 
+  def to_s
+    content.to_s.empty? ? "<?#{name}?>" : "<?#{name} #{content}?>"
+  end
+
   # Document-level PIs have no tree parent for leptris_node_unlink
   # — route through the document-level removal (libleptris 1.9.9,
   # #612), identity-matched by index so the right same-target PI

data/lib/leptris/xml/text.rb

@@ -36,4 +36,8 @@ class Leptris::XML::Text < Leptris::XML::Node
       Leptris::XML::FFI.leptris_text_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    Leptris::XML::Serialization.escape_text(content)
+  end
 end

data/lib/leptris/xml/xsd.rb

@@ -9,6 +9,13 @@ module Leptris::XML::XSD
     Schema.compile(schema_xml)
   end
 
+  # Compile from a file path (libleptris >= 1.9.326): unreadable
+  # files raise; malformed schemas compile to an error-carrying
+  # handle, exactly like .compile.
+  def compile_file(path)
+    Schema.compile_file(path)
+  end
+
   # Slice 2 (libleptris 1.9.319, #1075): built-in lexical table.
   # +builtin+ takes the "xs:NAME" reference spelling. Returns
   # true/false; an unknown table name raises — a silent false
@@ -61,6 +68,17 @@ module Leptris::XML::XSD
       @handle = handle
     end
 
+    # Compile from a file path: the engine reads it directly.
+    def self.compile_file(path)
+      status = ::FFI::MemoryPointer.new(:int)
+      raw = Leptris::XML::FFI.leptris_xsd_compile_file(path.to_s, status)
+      if raw.null?
+        raise Leptris::XML::Error,
+          "schema file unreadable (status #{status.read_int}): #{path}"
+      end
+      new(Handle.new(raw))
+    end
+
     # Number of top-level schema declarations the compiler
     # recognized (elements, types, groups, ...).
     def declaration_count

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,186 @@
 ## [Unreleased]
 
+## [1.9.333] - 2026-10-10
+
+### Added
+
+- **Regression pin: union `memberTypes` + inline anonymous members
+  (#1615, PR #1618).** The reported over-acceptance was not
+  reproducible on any engine artifact (main, the v1.9.331 tag,
+  every published gem binary — including through the full Ruby
+  binding path). The exact schema now asserts in CI through both
+  `leptris_xsd_simple_valid` and instance validation, so the
+  mixed-member semantics are verifiable binary-independent of any
+  binding environment.
+
+
+## [1.9.332] - 2026-10-09
+
+### Added
+
+- **XSD 1.1 — tier 2 (#1075, PR #1616).** Gated on
+  `xs:schema @version="1.1"`: `xs:assert` on complexTypes (direct
+  and derivation-nested; compiled once, evaluated per instance
+  through the engine's XPath 2 lane; evaluation errors are
+  failures); `xs:assertion` on simpleTypes (`$value` binds the
+  lexical, element context); `xs:openContent` interleave/suffix
+  (wildcard self-loops at the Thompson NFA's junction states;
+  `xs:defaultOpenContent` schema-wide with `appliesToEmpty`) and
+  `xs:alternative` conditional type assignment (first passing
+  test types the instance, declared type as fallback). Ten
+  red-first specs; ctest 1951/1951; 1.0 schemas unaffected.
+
+### Fixed
+
+- free the defaultOpenContent wildcard with the schema (xsd)
+
+
+
+## [1.9.331] - 2026-10-09
+
+### Fixed
+
+- **a second DOCTYPE keeps the first model (PR #1613).** A
+  duplicate `<!DOCTYPE` re-entered the direct-parse DOCTYPE handler
+  and replaced the already-parsed model — the orphan's heap-grown
+  attribute-default array leaked (fifth nightly-fuzz find,
+  artifact `leak-168da36a`). The lane stays lenient about the
+  duplicate, but the FIRST model wins now, matching the
+  duplicate-attribute keep-first rule — so the first internal
+  subset's entities and defaults apply (previously the second
+  silently won). The replacement model is freed on arrival.
+
+
+
+## [1.9.330] - 2026-10-09
+
+### Fixed
+
+- **dp fail path frees the parsed internal-subset DTD (PR #1611).**
+  A DOCTYPE internal subset with a default attribute declaration
+  grows the DTD model's heap array; the parse-success epilogue
+  transfers the model to the document, but a parse failure after
+  the DOCTYPE never did — and the fail teardown freed the diags
+  and line-break table but not the model (fourth nightly-fuzz
+  find, artifact `leak-e3246602`). The fail block frees the model
+  now, beside the other heap-owned pieces.
+
+
+
+## [1.9.329] - 2026-10-09
+
+### Fixed
+
+- **fast-path declaration probe bounds against the span
+  (PR #1609).** `leptris_parse_string`'s fast-path `<?xml` probe
+  checked the ABSOLUTE length while indexing from the first
+  non-whitespace offset, so an input whose markup starts after
+  leading whitespace read one byte past the caller's buffer
+  (heap-buffer-overflow; third nightly-fuzz find, artifact
+  `crash-aac3c9bb`). The probe bounds against the remaining span
+  now. The regression spec reproduces the fuzzer's exact shape —
+  a terminator-free 9-byte heap buffer: a string literal's
+  implicit NUL lands the read in bounds and 32-byte stack slot
+  padding hides the overread from ASAN.
+
+
+
+## [1.9.328] - 2026-10-09
+
+### Fixed
+
+- **dp fail path frees the parse-diag array (PR #1607).** A RECOVER
+  diagnostic (duplicate attribute) emitted before an eventual parse
+  failure leaked its heap-grown `parse_diags` array: the dp fail
+  teardown freed the line-break table and destroyed the pool but
+  never the diag array or its offender names. Second nightly-fuzz
+  find (artifact `leak-75e0ee81`, 2304 bytes). The fail path runs
+  `leptris_diag_free` beside the line-break free now.
+
+
+
+## [1.9.327] - 2026-10-09
+
+### Fixed
+
+- **NUL-leading text runs keep a real content pointer — ASAN
+  global-buffer-overflow (PR #1605).** The text-content setter
+  collapsed any run whose first byte is NUL onto the shared EMPTY
+  sentinel regardless of its length, so a NUL-leading run stored
+  content `""` with its real `content_len` — the serializer then
+  read past the 1-byte global. Found by the nightly libFuzzer run
+  (artifact `crash-0a24082b`, the harness's first working session
+  after #1604 repaired it). The setter is length-aware now: EMPTY
+  only for genuinely empty runs; NUL-leading runs serialize
+  verbatim, consistent with the never-trimmed content contract.
+- **Nightly fuzz binary lands at the documented path (PR #1604).**
+  `fuzz_parse` is a `test/` subdirectory target, so it built under
+  `build/test/` while `fuzz-nightly.yml` invoked `./build/fuzz_parse`
+  — every scheduled run since 2026-09-30 failed before fuzzing
+  started. The target now sets its runtime output directory to the
+  build root, where the workflow and the harness's own docs expect
+  it.
+
+
+
+## [1.9.326] - 2026-10-09
+
+### Added
+
+- **XSD: tier-1 charter completion — unions, lists, groups,
+  attributeGroups, derivation, substitution groups, fixed values,
+  includes (#1075, PR #1602).** Every remaining charter feature
+  ships: `xs:union`/`xs:list` derivation (lists type every token,
+  length counts items; unions accept any named or inline member);
+  `xs:group` definitions with refs that expand lazily at NFA build
+  (forward references need no capture order, cyclic refs splice
+  nothing); `xs:attributeGroup` refs plus top-level attribute refs
+  and inline anonymous attribute simpleTypes;
+  complexContent/simpleContent extension and restriction through a
+  shared complexType capture (extension splices base content and
+  attribute rows, restriction replaces them, simpleContent types
+  element text); `xs:substitutionGroup` members bind in content
+  models; `@fixed` enforced on attributes and element text; and
+  `leptris_xsd_compile_file` resolves `xs:include`/`xs:import`/
+  `xs:redefine` schemaLocations against the schema's own directory
+  — the CLI `--xsd` path and the corpus gate now use it, so the
+  gate's 23 multi-file fixtures resolve their includes. Multi-
+  particle derivation splices normalize under a sequence (the NFA
+  consumes one root particle). 14 new red-first specs; ctest
+  1937/1937; corpus gate green with its floor held.
+
+### Fixed
+
+- **follow-up on the same PR (52a5a8d9):** the direct-content
+  fallback re-captured attribute rows when a derivation had already
+  captured them (attributes-only restriction), orphaning the chain
+  — 1309 bytes across 69 allocations under ASAN; the fallback now
+  captures only when no derivation did. `leptris_xsd_compile_file`
+  split the base directory on `/` only; Windows paths carry
+  backslashes, so includes never resolved there.
+
+
+
+## [1.9.325] - 2026-10-09
+
+### Fixed
+
+- **XSD: local particle declarations govern nested children —
+  tier-1 boundary closed (#1075, PR #1600).** Children declared
+  only as particles of a parent's content model — no global
+  `xs:element` of that name — skipped attribute and content-model
+  validation: the instance walk resolved every child through the
+  global element table and at most text-typed local particles, so
+  `<order><item id="nan"/></order>` against an `xs:integer`
+  particle attribute validated clean. When no global declaration
+  exists, the parent's particle declaration now governs the child:
+  the particle's type drives the full element check — attribute
+  rows, content model, lexical text — through the shared
+  `validate_local` tail that global declarations use, and
+  grandchildren type through the particle chain.
+
+
+
 ## [1.9.324] - 2026-10-08
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -266,17 +266,15 @@ static cli_result_t validate_execute(int argc, char** argv) {
         leptris_rng_free(rng);
     }
     if (xsd_path) {
-        size_t xsd_len = 0;
-        char* xsd_content = read_file(xsd_path, &xsd_len);
-        if (!xsd_content) {
+        /* compile_file resolves schemaLocations relative to the
+         * schema's own directory */
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisXsdSchema xsd = leptris_xsd_compile_file(xsd_path, &st);
+        if (!xsd) {
             cli_error("cannot read XSD: %s", xsd_path);
             leptris_document_free(doc);
             return CLI_ERROR_IO;
         }
-        LeptrisStatus st = LEPTRIS_OK;
-        LeptrisXsdSchema xsd =
-            leptris_xsd_compile(xsd_content, xsd_len, &st);
-        free(xsd_content);
         /* compile returns an error-carrying handle on failure — the
          * status, not the pointer, says whether it succeeded. */
         if (st != LEPTRIS_OK) {

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

@@ -900,6 +900,14 @@ LEPTRIS_API void leptris_rng_free(LeptrisRelaxNG rng);
  * @return compiled schema; on failure an error-carrying handle
  *         (leptris_xsd_error says why — free it the same way)
  */
+/* Compile a schema from a file: relative xs:include/xs:import/
+ * xs:redefine schemaLocations resolve against the schema's own
+ * directory. Returns NULL only when the file cannot be read; a
+ * malformed schema yields an error-carrying handle, exactly like
+ * leptris_xsd_compile. (Memory: free with leptris_xsd_free.) */
+LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile_file(const char* path,
+                                                     LeptrisStatus* status);
+
 LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
                                                  size_t len,
                                                  LeptrisStatus* status);

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

@@ -416,7 +416,7 @@ LEPTRIS_API LeptrisStatus leptris_text_node_set_content(LeptrisNodeRef node,
     if (!doc || !doc->pool) return LEPTRIS_ERROR_INVALID_ARG;
     char* copy = node_public_pool_strdup(doc->pool, content, len);
     if (!copy) return LEPTRIS_ERROR_MEMORY;
-    leptris_textnode_set_content_ptr_doc(t, copy, doc);
+    leptris_textnode_set_content_ptr_doc(t, copy, len, doc);
     t->content_len = (uint32_t)len;
     return LEPTRIS_OK;
 }

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

@@ -42,7 +42,8 @@ LeptrisTextNode* leptris_text_create(const char* content,
     /* Contiguous with the node in the same pool alloc — the offset
      * is a small positive delta; doc tags the oversized-content
      * fallback should it ever leave the inline window. */
-    leptris_textnode_set_content_ptr_doc(node, content_storage, doc);
+    leptris_textnode_set_content_ptr_doc(node, content_storage,
+                                        content_len, doc);
     node->content_len = (uint32_t)content_len;
 
     return node;
@@ -76,7 +77,8 @@ LeptrisTextNode* leptris_text_create_borrowed(const char* content,
      * lifetime + termination (#1285 slice 4). The buffer-to-node
      * distance crosses allocations — the doc-tagged stamp is
      * MANDATORY here (TLS is unset on parse worker threads). */
-    leptris_textnode_set_content_ptr_doc(node, content, doc);
+    leptris_textnode_set_content_ptr_doc(node, content, content_len,
+                                        doc);
     node->content_len = (uint32_t)content_len;
     node->parent_off = 0;
     node->next_sibling_off = 0;

data/vendor-src/libleptris/src/leptris/dom/text.h

@@ -162,10 +162,15 @@ static inline const char* leptris_textnode_content(const LeptrisTextNode* t) {
  * use this form; the pooled-create contiguous path never spills but
  * takes doc anyway so the oversized-content fallback is covered. */
 static inline void leptris_textnode_set_content_ptr_doc(
-    LeptrisTextNode* t, const char* p, struct leptris_document* doc) {
+    LeptrisTextNode* t, const char* p, size_t len,
+    struct leptris_document* doc) {
     if (!t) return;
     if (!p) { t->content_off = 0; return; }
-    if (*p == '\0') { t->content_off = LEPTRIS_COMPACT_INT32_EMPTY; return; }
+    /* EMPTY only for genuinely empty runs. A NUL FIRST byte is
+     * content (nightly-fuzz 2026-10-09: NUL-leading runs collapsed
+     * here while content_len kept the length — the serializer then
+     * walked past the 1-byte EMPTY global). */
+    if (len == 0) { t->content_off = LEPTRIS_COMPACT_INT32_EMPTY; return; }
     ptrdiff_t d = (char*)p - (char*)t;
     if (d < INT32_MIN || d >= INT32_MAX)
         t->content_off = leptris_compact_int32_encode_doc(

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

@@ -845,7 +845,16 @@ static LEPTRIS_NOINLINE int dp_parse_doctype(char** pos_io, char* end,
             subset_start, (size_t)(subset_end - subset_start),
             pool);
         if (parsed) {
-            dtd = parsed;
+            extern void leptris_dtd_free(struct LeptrisDTD*);
+            if (dtd) {
+                /* a second <!DOCTYPE: the first model wins (the
+                 * duplicate-attribute keep-first rule); the
+                 * replacement's heap default_decls array would
+                 * leak otherwise (nightly-fuzz leak-168da36a) */
+                leptris_dtd_free(parsed);
+            } else {
+                dtd = parsed;
+            }
         }
     }
     *pos_io = pos;
@@ -1260,7 +1269,8 @@ static inline LeptrisTextNode* dp_text_create(DParser* p,
      * carve (dispatch-entry dp_nul / walker '&' NUL / EOF sentinel)
      * — the terminator write lives with the byte's last reader, not
      * here. */
-    leptris_textnode_set_content_ptr_doc(tn, content, p->doc);
+    leptris_textnode_set_content_ptr_doc(tn, content, content_len,
+                                           p->doc);
     tn->content_len = (uint32_t)content_len;
     tn->parent_off = 0;
     tn->next_sibling_off = 0;
@@ -2336,7 +2346,24 @@ fail:
     }
     /* The eagerly-built line-break table is malloc'd, not pool-owned
      * — the fail path never reaches leptris_document_free. Free it
-     * BEFORE pool_destroy reclaims the doc struct. */
+     * BEFORE pool_destroy reclaims the doc struct. The parse-diag
+     * array is the same: heap-realloc'd (leptris_diag_emit), and a
+     * RECOVER diag (e.g. duplicate attribute) can precede the
+     * failure — nightly-fuzz leak-75e0ee81, 2304 bytes. */
+    {
+        extern void leptris_diag_free(struct LeptrisDiag**, int*, int*);
+        leptris_diag_free(&doc->parse_diags, &doc->parse_diag_count,
+                          &doc->parse_diag_cap);
+    }
+    /* The parsed internal-subset DTD is heap-modelled
+     * (default_decls realloc, ttdtd_add_attribute) and never
+     * transferred to the doc on this path — the success epilogue
+     * assigns doc->dtd; without this free the model leaks
+     * (nightly-fuzz leak-e3246602, 8 bytes). */
+    {
+        extern void leptris_dtd_free(struct LeptrisDTD*);
+        if (p.dtd) leptris_dtd_free(p.dtd);
+    }
     free(doc->line_breaks);
     /* Round 10: the elem_pos journal + lazy index are pool-carved —
      * pool_destroy below reclaims them. */
@@ -2959,7 +2986,8 @@ static struct leptris_document* dp_il_build(
             tn->base.type = LEPTRIS_NODE_TYPE_TEXT;
             tn->base.frozen = 1;
             tn->base.line = r->line;
-            leptris_textnode_set_content_ptr_doc(tn, content, doc);
+            leptris_textnode_set_content_ptr_doc(tn, content,
+                                               content_len, doc);
             tn->content_len = (uint32_t)content_len;
             /* (slice 4: pool/borrowed fields gone; the il scratch
              * run is already NUL-terminated at carve) */

data/vendor-src/libleptris/src/leptris/html/html_parse.c

@@ -4005,7 +4005,8 @@ static void h_append(HBuilder* b, LeptrisNodeRef n) {
                 w9++;
         if (t9 && w9 && t9[w9]) {
             LeptrisTextNode* tn9 = (LeptrisTextNode*)n;
-            leptris_textnode_set_content_ptr_doc(tn9, t9 + w9, b->doc);
+            leptris_textnode_set_content_ptr_doc(
+                tn9, t9 + w9, (size_t)(tn9->content_len - w9), b->doc);
             tn9->content_len -= w9;
         } else if (t9 && w9 && !t9[w9]) {
             return;   /* pure before-head ws: dropped (tests7:7) */

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

@@ -471,8 +471,13 @@ LEPTRIS_API LeptrisDocument leptris_parse_string(const char* xml, size_t length,
              (d[i] == 0xFE && d[i + 1] == 0xFF))) {
             /* Fall through to slow path. */
         } else if (i < length && d[i] == '<' &&
-                   !(length >= 5 && d[i + 1] == '?' &&
-                     d[i + 2] == 'x' && d[i + 3] == 'm' && d[i + 4] == 'l')) {
+                   /* bound against the REMAINING span: i indexes
+                    * past leading whitespace, so an absolute-length
+                    * check read d[i+4] one past the buffer
+                    * (nightly-fuzz crash-aac3c9bb) */
+                   !(length - i >= 5 && d[i + 1] == '?' &&
+                     d[i + 2] == 'x' && d[i + 3] == 'm' &&
+                     d[i + 4] == 'l')) {
             /* Not a "<?xml" declaration. Check for embedded NUL bytes
              * in the first 64 bytes (UTF-16 without BOM indicator). */
             int has_nul = 0;