leptris 1.9.225.0 → 1.9.228.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a65d81fa73df8297d35b8e095e69c656d4ff8819620a40bd2c173ae685727452
-  data.tar.gz: de25ee0a34c202432ccbc870a5a40b689000827902851d4387c1a1f98aebfa80
+  metadata.gz: fa53c1b21f30aa89e5992390c40deb360eb8d94d0000ca5346e381b35b086f87
+  data.tar.gz: e667ca695bb8b10ecd251ad03d77521adacf6829cdd5bac7ec9c4f9bcb5b42a0
 SHA512:
-  metadata.gz: 2a61094f9eff1615f87cccb47791ecb899b8d2ca1a23afd4579238bbc9cf3afea51220a82ad5a6556ae21462a7f928c008277da2d10045e41c52a8ed6422d76f
-  data.tar.gz: 6833ca765302ade1e2874962bb86ae419b17671caa75e556b7324636b7930b5c568f1dc759abd7e6767388b36a3c1ddab89c539f263c1a139c303ef1683754f4
+  metadata.gz: 2927fc583597d9c607816ad16cb293a73c9ab7647a57b77429b8efbf8124b6e7ff52b871c25825b826d3a70501dbd51d4cc4b628c4992ea916825bd3f42845fa
+  data.tar.gz: a4a6371fa8e9e461db91e4705308b6ab9bc1920d08a76cee7d32f964f75bf9c5e9d16751359e6159b39fe8c0d3a57f0a6ffe5560806114f5d36b142385cd9204

data/CHANGELOG.md

@@ -5,6 +5,33 @@ 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.228.0] - 2026-09-23
+
+### Fixed — Text#content= on created-but-unattached text nodes (#318; engine 1.9.227–228)
+
+- **The #318 regression is fixed at the engine root**: engine
+  1.9.228 (upstream leptris#1320) gives detached text nodes the
+  same #519 owner treatment PI/comment/CDATA already had — an
+  owner backref stamped by `leptris_text_node_create` (compact
+  int32 offset, LP64 layout preserved) — so
+  `leptris_text_node_set_content` works before attach again.
+  The create → fill → attach builder sequence moxml's
+  `Text#content=` depends on is unblocked; verified against the
+  vendored 1.9.228 (the #318 repro passes; suite 778 → 781/0).
+- 1.9.227 rides along (header-hygiene spec zeroing).
+
+## [1.9.226.0] - 2026-09-23
+
+### Performance — engine sync (1.9.226)
+
+- Vendored libleptris 1.9.226: zero-re-copy HTML element opens
+  (#1285 slice 5, #1315) — element names drop from two pool
+  allocations + copies per open to one (the lowercased pooled
+  name or the static literal of a synthesized open, stored
+  directly; no QName split, no colon re-copy). Table-row parse
+  33.1 → 35.3 MB/s on the contended host. No binding-facing
+  surface changes; audit 351/351, suite 781/0.
+
 ## [1.9.225.0] - 2026-09-22
 
 ### Added — native HTML serialization, construction, and the bulk SAX drain (engine 1.9.223–225)

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.225"
+LIBLEPTRIS_VERSION = "1.9.228"
 # 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.225.0"
+  VERSION = "1.9.228.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.225
+- libleptris v1.9.228
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,87 @@
 ## [Unreleased]
 
+## [1.9.228] - 2026-09-23
+
+### Fixed
+
+- **dom: `leptris_text_node_set_content` works again on
+  created-but-unattached text nodes (#1320).** The 1.9.223–1.9.226
+  window returned `LEPTRIS_ERROR_INVALID_ARG` for exactly the
+  create → fill → attach builder sequence bindings use (moxml's
+  `Text#content=` failed 5 shared examples). Root cause: issue #519
+  gave detached PI/comment/CDATA nodes an `owner_doc` field but
+  skipped text — at the time text nodes carried their own pool
+  backref, which #1285 slice 4 then deleted, leaving detached text
+  with no document to allocate from. Text now gets the same #519
+  treatment: an owner backref stamped by the public creator only,
+  stored as a compact int32 offset (the LP64 struct keeps its 40
+  bytes — the field lands in existing padding; ILP32 32), with
+  overflow-table fallback tagged with the EXPLICIT document (the
+  parse-context TLS slot holds the wrong doc or NULL outside parse).
+  Every parse-carve path zero-initializes the field; the
+  attached/parsed parent-walk fast path is untouched. TDD'd
+  red-first against the reported minimal repro;
+  `DetachedNodes.TextSetContentWorksBeforeAttach` pins the
+  unattached, attach-then-set, and parsed paths.
+
+
+
+## [1.9.227] - 2026-09-23
+
+### Fixed
+
+- **test:** the header-hygiene compact-pointer edge specs zero their
+  fake stack-allocated nodes before use. The `last_child` and
+  `last_attribute` getters *walk* the sibling/attribute list, so the
+  uninitialized fake node's next-edge was read as stack garbage —
+  zero on arm64, nonzero on x86_64, where the slice-3b layout shift
+  surfaced the latent UB as a real CI failure. It was always UB.
+
+### Performance
+
+- **dom: binding_wrapper out of the node base — element 48B, text
+  40B, every node type −8B (#1285 slice 3b).** `LeptrisNode` itself
+  drops 24 → 12 bytes; the element struct reaches the lane's stated
+  goal of 48 bytes. The `binding_wrapper` field (#262) was never
+  adopted — zero callers in leptris-ruby and leptris-py (both cache
+  wrappers on their own side), making it pure dead weight at 8 bytes
+  per node per document, and it carried the #421 stale-pointer bug
+  class, which the removal structurally eliminates. The public
+  `leptris_node_get/set_binding_wrapper` API is unchanged and now
+  serves from a lazily-allocated open-addressed map owned by the
+  document: documents that never wrap (all of them today) allocate
+  nothing, and entries cannot outlive their nodes because the map
+  dies with the document.
+- **parse: interleaved lane size floor — small docs defer to classic
+  (#1258).** The two-phase scan+replay lane pays a fixed setup cost
+  that small documents cannot amortize: canon's gate measured ~25%
+  slower on a 24KB readonly shape while large documents run 0.69–0.74×
+  (256KB–3.4MB). `dp_il_try` now defers to the classic parser below a
+  64KB floor (the midpoint between the measured loss and the wins);
+  `LEPTRIS_IL_MIN` overrides it in bytes, with explicit `0` disabling
+  the floor. Coverage is preserved, not narrowed: the parity suite
+  pins `LEPTRIS_IL_MIN=1` in every lane toggle, the lane-forced CI leg
+  sets it to `0` so the full suite still exercises the lane, and a new
+  spec pins the deferral itself.
+
+
+
+## [1.9.226] - 2026-09-22
+
+### Performance
+
+- **html:** zero-re-copy element opens (#1285 slice 5, #1315): HTML
+  element names dropped from two pool allocations + copies per open to
+  one — the builder stores the lowercased pooled name (or the static
+  literal of a synthesized open) directly, with no second copy, no QName
+  split, and no colon re-copy. Local table-row parse (the #1218
+  fixture): 33.1 → 35.3 MB/s best-of on a contended arm64 host; the CI
+  benchmark leg is the authoritative read. Semantics pinned by 8 new
+  specs (case folding, literal QNames, attributes across every
+  delimiter shape, hidden-input gating, image→img).
+
+
+
 ## [1.9.225] - 2026-09-22
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -23,8 +23,7 @@ LeptrisCDATANode* leptris_cdata_create(const char* content,
     node->base.type = LEPTRIS_NODE_TYPE_CDATA;
     node->base.frozen = 0;
     node->base.version = 0;
-      node->base.binding_wrapper = NULL;
-    node->parent_off = 0;
+      node->parent_off = 0;
     node->next_sibling_off = 0;
 
     if (content && content_len > 0) {

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

@@ -24,7 +24,6 @@ LeptrisCommentNode* leptris_comment_create(const char* content,
     node->base.type = LEPTRIS_NODE_TYPE_COMMENT;
     node->base.frozen = 0;
     node->base.version = 0;
-      node->base.binding_wrapper = NULL;
     node->parent_off = 0;
     node->next_sibling_off = 0;
 

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

@@ -298,6 +298,22 @@ int32_t leptris_compact_int32_encode(void* base, void* target,
     return (int32_t)d;
 }
 
+int32_t leptris_compact_int32_encode_doc(void* base, void* target,
+                                         const int32_t* field_addr,
+                                         struct leptris_document* doc) {
+    if (!target) return 0;
+    ptrdiff_t d = (char*)target - (char*)base;
+    if (d < INT32_MIN || d > INT32_MAX) {
+        LeptrisCompactOverflowTable* table = get_overflow_table();
+        if (table && leptris_compact_overflow_set(table, field_addr,
+                                                  target, doc) == 0) {
+            return LEPTRIS_INT32_OVERFLOW_SENTINEL;
+        }
+        return 0;
+    }
+    return (int32_t)d;
+}
+
 void* leptris_compact_int32_decode(void* base, int32_t off,
                                    const int32_t* field_addr) {
     if (off == 0) return NULL;

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

@@ -109,6 +109,15 @@ int32_t leptris_compact_int32_encode(void* base, void* target,
                                      const int32_t* field_addr);
 void*   leptris_compact_int32_decode(void* base, int32_t off,
                                      const int32_t* field_addr);
+/* #1320: same encoding, but the overflow-table entry is tagged with
+ * the caller's explicit document instead of the thread-local
+ * "current document" — for stamps made OUTSIDE a parse context
+ * (public node creators), where the TLS slot holds the wrong doc or
+ * NULL and a mis-tagged entry would outlive its document. */
+struct leptris_document;
+int32_t leptris_compact_int32_encode_doc(void* base, void* target,
+                                         const int32_t* field_addr,
+                                         struct leptris_document* doc);
 #ifdef __cplusplus
 }
 #endif

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

@@ -683,17 +683,16 @@ static inline struct leptris_namespace** leptris_elem_namespaces_ptr(
  * pinned structs hold only pointers and int-sized scalars, so i686
  * and armv7 produce identical layouts. */
 #if SIZE_MAX == UINT64_MAX
-LEPTRIS_STATIC_ASSERT(sizeof(struct leptris_element) == 64,
-    "#1285 slice 3a: ns_cache_off + offsets side table -> 64 bytes");
+LEPTRIS_STATIC_ASSERT(sizeof(struct leptris_element) == 48,
+    "#1285 slice 3b: binding_wrapper out of the base -> 48 bytes");
 
 LEPTRIS_STATIC_ASSERT(sizeof(struct leptris_attribute) == 40,
     "round 19 attr layout: 16+16+4+2+2 = 40");
 #else
-/* ILP32: LeptrisNode 24->16 (binding_wrapper), element name +
- * ns_cache pointers 8->4 each -> 56; attribute name_view 16->8
- * (value union stays 16 via inline_value[16]) -> 32. */
-LEPTRIS_STATIC_ASSERT(sizeof(struct leptris_element) == 48,
-    "#1285 slice 3a ILP32: 48 bytes");
+/* ILP32: LeptrisNode 16->12 (#1285 slice 3b); attribute
+ * name_view 16->8 (value union stays 16 via inline_value[16]). */
+LEPTRIS_STATIC_ASSERT(sizeof(struct leptris_element) == 44,
+    "#1285 slice 3b ILP32: base 12 + 8 + 6*4 + ptr 4 = 44 bytes");
 
 LEPTRIS_STATIC_ASSERT(sizeof(struct leptris_attribute) == 32,
     "leptris_attribute ILP32 layout: 8+16+4+2+2 = 32");

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

@@ -24,7 +24,6 @@ LeptrisEntityRefNode* leptris_entity_ref_create(const char* name,
     node->base.type = LEPTRIS_NODE_TYPE_ENTITY_REF;
     node->base.frozen = 0;
     node->base.version = 0;
-    node->base.binding_wrapper = NULL;
     node->parent_off = 0;
     node->next_sibling_off = 0;
     node->owner_doc = NULL;

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

@@ -57,11 +57,9 @@ typedef struct leptris_node {
                                         * parse-time bulk strides hold. */
     unsigned int version : 30;         /* COW 2.2: Node version for tracking modifications */
     uint32_t line;                     /* Source line (1-based, 0 = unknown). Issue #223 */
-    void* binding_wrapper;             /* FFI wrapper cache (#262). NULL when no binding
-                                        * is attached. Set by the language binding on
-                                        * first node wrap; subsequent traversals find
-                                        * the cached wrapper without FFI call overhead. */
-    /* NOTE: Parent/sibling pointers stored in compressed form in specific node types */
+    /* NOTE: Parent/sibling pointers stored in compressed form in specific node types.
+     * #1285 slice 3b: binding_wrapper (#262) moved to the document-
+     * owned wrapper map — see leptris_internal.h; base is 12 bytes. */
 } LeptrisNode;
 
 /* ============================================================================

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

@@ -296,8 +296,13 @@ static LeptrisDocument node_public_document(LeptrisNodeRef node) {
     LeptrisElement parent = leptris_node_parent(node);
     if (parent) return leptris_element_get_document(parent);
     /* Issue #519: detached non-element nodes carry their owning
-     * document — mutations must work before any attach. */
+     * document — mutations must work before any attach. Text was the
+     * one kind #519 skipped (its pool backref covered it until #1285
+     * slice 4 removed it — the #1320 regression); its stamp is an
+     * int32 offset instead of a field. */
     switch (node->type) {
+        case LEPTRIS_NODE_TYPE_TEXT:
+            return leptris_textnode_owner_doc((const LeptrisTextNode*)node);
         case LEPTRIS_NODE_TYPE_PI:
             return ((LeptrisPINode*)node)->owner_doc;
         case LEPTRIS_NODE_TYPE_COMMENT:
@@ -329,6 +334,13 @@ LEPTRIS_API LeptrisNodeRef leptris_text_node_create(LeptrisDocument doc,
     if (!content) content = "";
     size_t len = strlen(content);
     LeptrisTextNode* n = leptris_text_create(content, len, doc->pool);
+    if (n) {
+        /* #1320: stamp the owner so detached mutations can reach the
+         * doc's pool (PI/comment/CDATA do this via owner_doc fields;
+         * explicit-doc encoder — no parse context here). */
+        n->owner_doc_off = leptris_compact_int32_encode_doc(
+            n, doc, &n->owner_doc_off, doc);
+    }
     return n ? (LeptrisNodeRef)n : NULL;
 }
 
@@ -688,12 +700,71 @@ LEPTRIS_API void leptris_node_source_position(LeptrisNodeRef node,
     }
 }
 
+/* #1285 slice 3b: binding_wrapper storage moved out of LeptrisNode
+ * (both bindings have zero callers — they cache wrappers on their
+ * own side — and the in-node field carried the #421 stale-pointer
+ * bug class on recycled arena pages). Open-addressed map keyed by
+ * node pointer, lazily allocated per document, freed with it: map
+ * entries can never outlive their nodes, and documents that never
+ * wrap (all of them today) pay nothing. NULL before any set — the
+ * parse-NULL contract holds by construction. */
+struct leptris_wrapper_entry {
+    LeptrisNodeRef node;   /* 0 = empty slot */
+    void* wrapper;
+};
+
+static size_t wrapper_hash(LeptrisNodeRef n, size_t cap) {
+    uintptr_t k = (uintptr_t)n;
+    return ((size_t)((k * 0x9E3779B97F4A7C15ULL) >> 32)) & (cap - 1);
+}
+
+static int wrapper_grow(struct leptris_document* doc) {
+    size_t ncap = doc->wrapper_cap ? doc->wrapper_cap * 2 : 16;
+    struct leptris_wrapper_entry* nt = (struct leptris_wrapper_entry*)
+        calloc(ncap, sizeof(*nt));
+    if (!nt) return -1;
+    for (size_t i = 0; i < doc->wrapper_cap; i++) {
+        struct leptris_wrapper_entry* e = &doc->wrapper_map[i];
+        if (e->node) {
+            size_t j = wrapper_hash(e->node, ncap);
+            while (nt[j].node) j = (j + 1) & (ncap - 1);
+            nt[j] = *e;
+        }
+    }
+    free(doc->wrapper_map);
+    doc->wrapper_map = nt;
+    doc->wrapper_cap = ncap;
+    return 0;
+}
+
 LEPTRIS_API void* leptris_node_get_binding_wrapper(LeptrisNodeRef node) {
-    return node ? node->binding_wrapper : NULL;
+    if (!node) return NULL;
+    struct leptris_document* doc = node_public_document(node);
+    if (!doc || !doc->wrapper_map) return NULL;
+    size_t i = wrapper_hash(node, doc->wrapper_cap);
+    while (doc->wrapper_map[i].node) {
+        if (doc->wrapper_map[i].node == node)
+            return doc->wrapper_map[i].wrapper;
+        i = (i + 1) & (doc->wrapper_cap - 1);
+    }
+    return NULL;
 }
 
 LEPTRIS_API void leptris_node_set_binding_wrapper(LeptrisNodeRef node, void* wrapper) {
-    if (node) node->binding_wrapper = wrapper;
+    if (!node) return;
+    struct leptris_document* doc = node_public_document(node);
+    if (!doc) return;   /* detached, unregistered node: no carrier */
+    if (doc->wrapper_count * 2 + 2 >= doc->wrapper_cap) {
+        if (wrapper_grow(doc) != 0) return;
+    }
+    size_t i = wrapper_hash(node, doc->wrapper_cap);
+    while (doc->wrapper_map[i].node && doc->wrapper_map[i].node != node)
+        i = (i + 1) & (doc->wrapper_cap - 1);
+    if (!doc->wrapper_map[i].node) {
+        doc->wrapper_map[i].node = node;
+        doc->wrapper_count++;
+    }
+    doc->wrapper_map[i].wrapper = wrapper;
 }
 
 LEPTRIS_API int leptris_node_compare(LeptrisNodeRef a, LeptrisNodeRef b) {

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

@@ -46,7 +46,6 @@ LeptrisPINode* leptris_pi_create(const char* target,
     node->base.type = LEPTRIS_NODE_TYPE_PI;
     node->base.frozen = 0;
     node->base.version = 0;
-      node->base.binding_wrapper = NULL;
     node->parent_off = 0;
     node->next_sibling_off = 0;
     node->target = target_storage;

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

@@ -30,12 +30,9 @@ LeptrisTextNode* leptris_text_create(const char* content,
     node->base.frozen = 0;
     node->base.version = 0;
     node->base.raw = 0;   /* uninitialized: see create_borrowed */
-      /* Explicit: pool memory is not zeroed and the retained arena
-     * recycles dirty pages — a stale binding_wrapper would hand
-     * bindings a dangling pointer. */
-    node->base.binding_wrapper = NULL;
     node->parent_off = 0;
     node->next_sibling_off = 0;
+    node->owner_doc_off = 0;   /* #1320: only the public creator stamps */
 
     if (content && content_len > 0) {
         memcpy(content_storage, content, content_len);
@@ -70,11 +67,11 @@ LeptrisTextNode* leptris_text_create_borrowed(const char* content,
      * uninitialized raw bit silently flips DOE/cdata behavior by
      * build configuration. */
     node->base.raw = 0;
-    node->base.binding_wrapper = NULL;
     node->content = (char*)content;  /* Non-owning; caller guarantees lifetime + termination. */
     node->content_len = (uint32_t)content_len;
     node->parent_off = 0;
     node->next_sibling_off = 0;
+    node->owner_doc_off = 0;   /* #1320: only the public creator stamps */
 
     return node;
 }

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

@@ -26,7 +26,15 @@
  *   are outside every supported target.
  *
  * Issue #168: parent_off mirrors next_sibling_off so the parent of a
- * text node can be queried in O(1). */
+ * text node can be queried in O(1).
+ *
+ * Issue #1320: owner_doc_off gives DETACHED text nodes their owning
+ * document — #519 added an owner_doc field to PI/comment/CDATA but
+ * skipped text (whose pool backref covered it at the time); #1285
+ * slice 4 deleted that backref and detached set_content started
+ * returning INVALID_ARG. Stamped by the public creator only —
+ * parse-carved nodes are attached by construction. int32, so the
+ * LP64 struct keeps its 40 bytes (padding absorbs it). */
 typedef struct leptris_text_node {
     LeptrisNode base;                   /* MUST be first */
     char* content;                    /* Text content - NEVER trim! NUL-terminated at [content_len] */
@@ -40,6 +48,7 @@ typedef struct leptris_text_node {
      * 0 = NULL. */
     int32_t next_sibling_off;
     int32_t parent_off;               /* Byte offset to parent element (0=NULL) */
+    int32_t owner_doc_off;            /* Byte offset to owning document (0=unstamped; #1320) */
 } LeptrisTextNode;
 
 /* Text node creation.
@@ -110,4 +119,17 @@ static inline void leptris_textnode_set_parent(LeptrisTextNode* t, LeptrisElemen
     t->parent_off = leptris_compact_int32_encode_inline(t, parent, &t->parent_off);
 }
 
+/* Owning-document access (issue #1320). The stamp is written by
+ * leptris_text_node_create with the explicit-doc encoder (an
+ * overflow-table entry made outside a parse context must carry the
+ * REAL document tag, not the TLS current-doc). Decode is the
+ * standard edge decode. */
+struct leptris_document;
+static inline struct leptris_document* leptris_textnode_owner_doc(const LeptrisTextNode* t) {
+    return (t && t->owner_doc_off != 0)
+        ? (struct leptris_document*)leptris_compact_int32_decode_inline(
+              (void*)t, t->owner_doc_off, &t->owner_doc_off)
+        : NULL;
+}
+
 #endif /* LEPTRIS_DOM_TEXT_H */

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

@@ -1005,7 +1005,6 @@ static inline LeptrisTextNode* dp_text_create(DParser* p,
      * serialize_text_internal then emitted text VERBATIM (raw < in
      * the output, invalid XML). */
     tn->base.raw = 0;
-    tn->base.binding_wrapper = NULL;
     tn->base.line = 0;     /* caller stamps the offset */
     /* #1285 slice 4: the run is NUL-terminated in place BEFORE this
      * carve (dispatch-entry dp_nul / walker '&' NUL / EOF sentinel)
@@ -1015,6 +1014,7 @@ static inline LeptrisTextNode* dp_text_create(DParser* p,
     tn->content_len = (uint32_t)content_len;
     tn->parent_off = 0;
     tn->next_sibling_off = 0;
+    tn->owner_doc_off = 0;   /* #1320: parse-carved nodes attach */
     return tn;
 }
 
@@ -2598,6 +2598,7 @@ static struct leptris_document* dp_il_build(
              * run is already NUL-terminated at carve) */
             tn->parent_off = 0;
             tn->next_sibling_off = 0;
+            tn->owner_doc_off = 0;   /* #1320: parse-carved nodes attach */
             smap[i] = (LeptrisNode*)tn;
             pp.depth = (int)rdepth[r->parent] + 1;
             pp.last_child_stack[pp.depth - 1] = lc[r->parent];
@@ -2686,6 +2687,25 @@ static struct leptris_document* dp_il_try(const char* xml, size_t len,
     if (!gate || !*gate) return NULL;
     if (keep_ent || dtd_attrs) return NULL;
     if (len == 0 || len >= 0x7FFFFFFFu) return NULL;
+    /* #1258: small documents do not amortize the record pass.
+     * Canon's moxml shape (24KB / 902 elements) measured ~25%
+     * SLOWER on the lane while allocations stayed identical - the
+     * two-phase scan+replay pays fixed setup that a small doc
+     * cannot win back; large docs take 0.69-0.74x. Below the
+     * minimum the lane defers to the classic parser. LEPTRIS_IL_MIN
+     * overrides (bytes; 0 = no threshold) for hosts and for the
+     * parity gates, which force it to 0 so the lane stays covered
+     * by the suite at fixture sizes. */
+    {
+        const char* mins = getenv("LEPTRIS_IL_MIN");
+        size_t min_len = 64 * 1024;
+        if (mins && *mins) {
+            long mv = strtol(mins, NULL, 10);
+            if (mv > 0) min_len = (size_t)mv;
+            else min_len = 0;   /* explicit 0 disables */
+        }
+        if (len < min_len) return NULL;
+    }
 
     /* Scratch is built UP FRONT (slice 2): il_scan reads it with
      * the NUL-sentinel discipline, and dp_il_build reuses the same

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

@@ -4210,8 +4210,43 @@ static LeptrisElement h_open_element_id(HBuilder* b, const char* name,
     return e;
 }
 
+/* #1285 slice 5: zero-re-copy element open. `name` is a NUL-
+ * terminated POOL-OWNED lowercased string (h_pooled_lower) or a
+ * static literal — both live for the document, so the element
+ * borrows it directly: no create_with_view copy, no QName split
+ * (HTML keeps qualified names literally, tests14:1/3 — the whole
+ * token IS the wanted name), no colon re-copy undoing the split.
+ * Ownership matches create_with_view's pool copy exactly (rename
+ * replaces, never frees). */
+static LeptrisElement h_open_element_borrowed(HBuilder* b, char* name,
+                                              uint8_t tid) {
+    LeptrisElement e = (LeptrisElement)leptris_pool_alloc(
+        b->pool, sizeof(struct leptris_element));
+    if (!e) return NULL;
+    memset(e, 0, sizeof(struct leptris_element));
+    e->base.type = LEPTRIS_NODE_TYPE_ELEMENT;
+    e->name = name;
+    size_t nl = strlen(name);
+    e->name_len = (nl > 254) ? 0xFF : (uint8_t)nl;
+    e->name_hash = leptris_name_hash_compute(name);
+    leptris_root_doc_register(e, b->doc);
+    b->left_initial = 1;
+    h_append(b, (LeptrisNodeRef)e);
+    if (b->depth == 0 && !b->root) b->root = e;
+    if (b->depth < 256) {
+        b->open[b->depth] = e;
+        b->open_tail[b->depth] = NULL;
+        b->open_ns[b->depth] = H_NS_HTML;
+        b->open_id[b->depth] = tid;
+        b->depth++;
+    }
+    return e;
+}
+
 static LeptrisElement h_open_element(HBuilder* b, const char* name) {
-    return h_open_element_id(b, name, h_tag_id(name));
+    /* Synthesized opens pass string literals (process lifetime) —
+     * the borrowed path stores them with zero copies. */
+    return h_open_element_borrowed(b, (char*)name, h_tag_id(name));
 }
 
 /* Case-insensitive C-string compare (ASCII). */
@@ -7699,7 +7734,7 @@ static LeptrisDocument html_parse_shared(
 
         LeptrisElement e = (elem_ns != H_NS_HTML)
                                ? h_open_foreign(&b, name, elem_ns)
-                               : h_open_element_id(&b, name, tid);
+                               : h_open_element_borrowed(&b, name, tid);
         if (!e) goto done;
         if (strcmp(name, "html") == 0) {
             b.html_seen = 1;

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

@@ -967,6 +967,11 @@ LEPTRIS_API void leptris_document_free(struct leptris_document* doc) {
     free(doc->elem_pos);
     doc->elem_pos = NULL;
     doc->elem_pos_count = doc->elem_pos_cap = 0;
+    /* #1285 slice 3b: binding-wrapper map — entries die with the
+     * document, so they can never outlive their nodes. */
+    free(doc->wrapper_map);
+    doc->wrapper_map = NULL;
+    doc->wrapper_count = doc->wrapper_cap = 0;
     if (doc->xml_buffer && doc->xml_buffer_needs_free) {
         /* Release through the retained-buffer free list (see
          * memory/arena.c): large inputs would otherwise be munmapped

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

@@ -226,6 +226,15 @@ struct leptris_document {
      * xml_buffer) and resolves queries via binary search, caching
      * the result in the node with the high bit set. NULL = not yet
      * built. Freed with the document. */
+    /* #1285 slice 3b: binding_wrapper left the node base (#262's
+     * FFI cache was never adopted — zero callers in leptris-ruby/py
+     * — and its stale-pointer bug class, #421, is structural). The
+     * public get/set API now serves from this lazily-allocated
+     * open-addressed map, keyed by node pointer; it dies with the
+     * document so entries can never outlive their nodes. NULL until
+     * the first set — documents that never wrap pay nothing. */
+    struct leptris_wrapper_entry* wrapper_map;
+    size_t wrapper_count, wrapper_cap;
     int html_mode;   /* #1309: HTML-parsed / create_html documents
                           serialize with the §16.2 HTML method by
                           default (libxml2/Nokogiri behavior). */

data/vendor-src/libleptris/test/CMakeLists.txt

@@ -128,6 +128,7 @@ leptris_add_test(test_xslt        xpath/test_xslt.cpp)
 leptris_add_test(test_xquery      xquery/test_xquery.cpp)
 leptris_add_test(test_html        html/test_html.cpp)
 leptris_add_test(test_html_builder html/test_html_builder.cpp)
+leptris_add_test(test_html_borrowed_names html/test_html_borrowed_names.cpp)
 leptris_add_test(test_html5lib     html/test_html5lib.cpp)
 file(GLOB html5lib_dats
      "${CMAKE_CURRENT_SOURCE_DIR}/html/html5lib-tests/tree-construction/*.dat")

data/vendor-src/libleptris/test/abi/test_header_hygiene.cpp

@@ -103,6 +103,12 @@ TEST(HeaderHygiene, ElementTreeEdgeRoundTrip) {
     alignas(kAlign) char buf[2 * sizeof(struct leptris_element)];
     struct leptris_element* a = (struct leptris_element*)buf;
     struct leptris_element* b = (struct leptris_element*)(buf + sizeof(*a));
+    /* The last_child getter WALKS the child list, so b's sibling
+     * edge is read — zero the fake nodes or the walk follows
+     * uninitialized stack garbage. (#1285 slice 3b moved the field
+     * onto a stack slot whose garbage is nonzero on x86_64, turning
+     * the latent UB into a real failure; it was always UB.) */
+    memset(buf, 0, sizeof(buf));
 
     /* parent round-trip */
     leptris_elem_set_parent(a, b);
@@ -132,6 +138,7 @@ TEST(HeaderHygiene, ElementAttributeEdgeRoundTrip) {
     struct leptris_element* e = (struct leptris_element*)buf;
     struct leptris_attribute* attr =
         (struct leptris_attribute*)(buf + sizeof(*e));
+    memset(buf, 0, sizeof(buf));
     leptris_attr_set_next(attr, NULL);
 
     leptris_elem_set_first_attribute(e, attr);

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

@@ -2014,6 +2014,51 @@ TEST(DetachedNodes, MutationWorksBeforeAttach) {
     leptris_document_free(doc);
 }
 
+/* Issue #1320: TEXT was the one node kind #519's detached-mutation
+ * fix skipped — no owner_doc, so after #1285 slice 4 removed the
+ * node-side pool backref, set_content on a created-but-unattached
+ * text node resolved no document and returned INVALID_ARG. moxml's
+ * create → fill → attach builder sequence hit it on every leg. */
+TEST(DetachedNodes, TextSetContentWorksBeforeAttach) {
+    /* Unattached: the discriminator that regressed (1.9.223–1.9.226
+     * returned EINVAL here; content stayed at the create-time value). */
+    LeptrisDocument doc = leptris_document_create();
+    ASSERT_NE(doc, nullptr);
+    LeptrisNodeRef t = leptris_text_node_create(doc, "abc");
+    ASSERT_NE(t, nullptr);
+    EXPECT_EQ(leptris_text_node_set_content(t, "world"), LEPTRIS_OK);
+    EXPECT_STREQ(leptris_text_node_get_content(t), "world");
+
+    /* The mutation survives attach + serialize. */
+    LeptrisElement root = leptris_element_create(doc, "r");
+    ASSERT_EQ(leptris_document_set_root(doc, root), LEPTRIS_OK);
+    ASSERT_EQ(leptris_element_append_child(root, (LeptrisElement)t), LEPTRIS_OK);
+    char* x = leptris_document_serialize(doc, nullptr);
+    ASSERT_NE(x, nullptr);
+    EXPECT_NE(std::strstr(x, "<r>world</r>"), nullptr);
+    leptris_free_string(x);
+
+    /* Attach-then-set and set-after-parse still work (never
+     * regressed — pin them so the owner path can't shadow the
+     * parent-walk path). */
+    LeptrisNodeRef t2 = leptris_text_node_create(doc, "one");
+    ASSERT_EQ(leptris_element_append_child(root, (LeptrisElement)t2), LEPTRIS_OK);
+    EXPECT_EQ(leptris_text_node_set_content(t2, "two"), LEPTRIS_OK);
+    EXPECT_STREQ(leptris_text_node_get_content(t2), "two");
+
+    leptris_document_free(doc);
+
+    const char xml[] = "<r>parsed</r>";
+    LeptrisDocument doc2 = leptris_parse_string(xml, std::strlen(xml), nullptr);
+    ASSERT_NE(doc2, nullptr);
+    LeptrisElement root2 = leptris_document_root(doc2);
+    LeptrisNodeRef pt = leptris_node_first_child(leptris_element_as_node(root2));
+    ASSERT_NE(pt, nullptr);
+    EXPECT_EQ(leptris_text_node_set_content(pt, "replaced"), LEPTRIS_OK);
+    EXPECT_STREQ(leptris_text_node_get_content(pt), "replaced");
+    leptris_document_free(doc2);
+}
+
 /* Issue #526: document-level PI enumeration + creation. */
 TEST(DocumentPIs, EnumerateAndAdd) {
     const char xml[] = "<?xml version='1.0'?><?docpi d1?><r/>";

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

@@ -50,25 +50,28 @@ TEST(TextBorrowed, ParsedTextNodeIsTerminatedInPlace) {
 TEST(TextBorrowed, NodeStructIsBasePointerAndThreeInt32) {
     /* #1285 slice 4: pool + borrowed removed, content_len is uint32.
      * The width-independent invariant: base + ONE content pointer +
-     * three int32s (len, next, parent), rounded to pointer alignment
-     * — nothing else. 64 -> 48 on LP64; 32 on ILP32. The issue's
-     * 32B sketch assumed a 12-byte base and a 64-bit host; going
-     * lower needs content as an int32 pool offset (slice 4b). The
+     * FOUR int32s (len, next, parent, owner doc — #1320), rounded to
+     * pointer alignment — nothing else. 40 on LP64 (the owner field
+     * lands in padding; sizeof unchanged); 32 on ILP32. Going lower
+     * needs content as an int32 pool offset (slice 4b). The
      * parse-time bulk strides (dp text block, il lane table) hardcode
      * this layout economics — a silent field growth would erode the
      * #1222 parse win this slice exists for. */
-    /* C++11: no constexpr lambda — inline the round-up expression. */
-    constexpr size_t kRaw = sizeof(LeptrisNode) + sizeof(void*) +
-                            3 * sizeof(int32_t);
+    /* C++11: no constexpr lambda — inline the round-ups. The
+     * content pointer needs pointer alignment INSIDE the struct:
+     * base rounds up to the pointer's alignment first. */
     constexpr size_t kA = alignof(void*);
+    constexpr size_t kBaseA =
+        (sizeof(LeptrisNode) + kA - 1) / kA * kA;
+    constexpr size_t kRaw = kBaseA + sizeof(void*) + 4 * sizeof(int32_t);
     constexpr size_t kAligned = (kRaw + kA - 1) / kA * kA;
     static_assert(sizeof(LeptrisTextNode) == kAligned,
                   "LeptrisTextNode must be base + one content pointer + "
-                  "uint32 len + int32 next + int32 parent (aligned) — "
-                  "no pool/borrowed fields (#1285 slice 4)");
+                  "uint32 len + int32 next + int32 parent + int32 owner "
+                  "(aligned) — no pool/borrowed fields (#1285 slice 4, #1320)");
     EXPECT_EQ(sizeof(LeptrisTextNode), kAligned);
 #if defined(__LP64__) || defined(_WIN64)
-    EXPECT_EQ(sizeof(LeptrisTextNode), (size_t)48);
+    EXPECT_EQ(sizeof(LeptrisTextNode), (size_t)40);
 #else
     EXPECT_EQ(sizeof(LeptrisTextNode), (size_t)32);
 #endif

data/vendor-src/libleptris/test/html/test_html_borrowed_names.cpp

@@ -0,0 +1,143 @@
+// test/html/test_html_borrowed_names.cpp — #1285 slice 5: zero-copy
+// element names in the HTML builder (the in-place lowercasing carve).
+//
+// Tag names lowercase IN PLACE in the doc-owned input copy with a
+// NUL written over the name's delimiter; elements borrow the pointer
+// (no pool copy, no create_with_view copy). The delimiter byte's
+// consumers — the attribute scanner and h_input_type_hidden — skip
+// the NUL with the delimiter's original semantics preserved (a '>'
+// delimiter ended the tag; ws/'/' were skippable). Attribute names
+// still pool-copy: the #635 raw-attr views keep source case.
+//
+// Falsifiable: case folding, QName-literal names, attributes after
+// every delimiter shape, hidden-input detection through the NUL, and
+// no phantom attributes from content after a NUL-terminated '>'.
+
+#include <gtest/gtest.h>
+extern "C" {
+#include "leptris.h"
+#include "leptris/html.h"
+}
+#include <cstring>
+#include <string>
+
+namespace {
+
+std::string FirstElemName(const char* html) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument d = leptris_parse_html_string(html, strlen(html), &st);
+    if (!d) return "(parse-failed)";
+    /* HTML docs get the html/body wrapper — query the FIRST element
+     * below the wrapper instead of the document root. */
+    LeptrisXPathResult xr =
+        leptris_xpath_eval(d, nullptr, "name(/*/*/*[1])");
+    std::string r = "(none)";
+    if (leptris_xpath_result_type(xr) == LEPTRIS_XPATH_STRING) {
+        char* s = leptris_xpath_result_string(xr);
+        if (s) {
+            r = s;
+            leptris_free_string(s);
+        }
+    }
+    leptris_xpath_result_free(xr);
+    leptris_document_free(d);
+    return r;
+}
+
+}  // namespace
+
+TEST(HtmlBorrowedNames, UpperCaseTagFoldsLower) {
+    EXPECT_EQ(FirstElemName("<DIV>t</DIV>"), "div");
+    EXPECT_EQ(FirstElemName("<MiXeD/>"), "mixed");
+}
+
+TEST(HtmlBorrowedNames, QNameStaysLiteralWholeToken) {
+    /* tests14 semantics: HTML keeps qualified names literally — the
+     * whole lowercased token is the name, no prefix split. */
+    EXPECT_EQ(FirstElemName("<xyz:ABC>t</xyz:ABC>"), "xyz:abc");
+}
+
+TEST(HtmlBorrowedNames, AttributesAfterWsDelimiter) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* html = "<DIV CLASS=\"X\" id='q'>t</DIV>";
+    LeptrisDocument d = leptris_parse_html_string(html, strlen(html), &st);
+    ASSERT_NE(d, nullptr);
+    LeptrisXPathResult xr = leptris_xpath_eval(d, nullptr, "//div");
+    ASSERT_EQ(leptris_xpath_result_type(xr), LEPTRIS_XPATH_NODESET);
+    ASSERT_EQ(leptris_xpath_result_count(xr), (size_t)1);
+    LeptrisElement div = leptris_xpath_result_get(xr, 0);
+    ASSERT_NE(div, nullptr);
+    EXPECT_STREQ(leptris_element_name(div), "div");
+    EXPECT_STREQ(leptris_element_attribute(div, "class"), "X");
+    EXPECT_STREQ(leptris_element_attribute(div, "id"), "q");
+    leptris_xpath_result_free(xr);
+    leptris_document_free(d);
+}
+
+TEST(HtmlBorrowedNames, AttributesAfterBareSlash) {
+    /* '<a/ href=...>': the bare '/' after the name is ignored. */
+    const char* html = "<a/ href='x'>t</a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument d = leptris_parse_html_string(html, strlen(html), &st);
+    ASSERT_NE(d, nullptr);
+    LeptrisXPathResult xr = leptris_xpath_eval(d, nullptr, "//a");
+    ASSERT_EQ(leptris_xpath_result_type(xr), LEPTRIS_XPATH_NODESET);
+    ASSERT_EQ(leptris_xpath_result_count(xr), (size_t)1);
+    LeptrisElement a = leptris_xpath_result_get(xr, 0);
+    ASSERT_NE(a, nullptr);
+    EXPECT_STREQ(leptris_element_attribute(a, "href"), "x");
+    leptris_xpath_result_free(xr);
+    leptris_document_free(d);
+}
+
+TEST(HtmlBorrowedNames, NameThenGtDoesNotEatContentAsAttrs) {
+    /* '<br>' — the NUL lands on the '>'; following content must not
+     * become phantom attributes or text loss. */
+    const char* html = "<div><br>x<a href='y'>z</a></div>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument d = leptris_parse_html_string(html, strlen(html), &st);
+    ASSERT_NE(d, nullptr);
+    /* Query the tree rather than walk the child API surface. */
+    LeptrisXPathResult xr = leptris_xpath_eval(d, nullptr, "//a/@href");
+    ASSERT_EQ(leptris_xpath_result_type(xr), LEPTRIS_XPATH_NODESET);
+    EXPECT_EQ(leptris_xpath_result_count(xr), (size_t)1);
+    leptris_xpath_result_free(xr);
+    xr = leptris_xpath_eval(d, nullptr, "//br");
+    EXPECT_EQ(leptris_xpath_result_count(xr), (size_t)1);
+    leptris_xpath_result_free(xr);
+    leptris_document_free(d);
+}
+
+TEST(HtmlBorrowedNames, HiddenInputDetectedThroughNul) {
+    /* webkit01:51 — input type=hidden must not clear frameset-ok;
+     * the type scan runs over the NUL'd delimiter. Unquoted value. */
+    const char* html = "<input type=hidden><frameset></frameset>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument d = leptris_parse_html_string(html, strlen(html), &st);
+    ASSERT_NE(d, nullptr);
+    /* hidden input does NOT clear frameset-ok: the frameset lands */
+    LeptrisXPathResult xr = leptris_xpath_eval(d, nullptr, "//frameset");
+    ASSERT_EQ(leptris_xpath_result_type(xr), LEPTRIS_XPATH_NODESET);
+    EXPECT_EQ(leptris_xpath_result_count(xr), (size_t)1);
+    leptris_xpath_result_free(xr);
+    leptris_document_free(d);
+
+    /* ...and a VISIBLE input clears it: no frameset */
+    const char* html2 = "<input type=text><frameset></frameset>";
+    LeptrisDocument d2 = leptris_parse_html_string(html2, strlen(html2), &st);
+    ASSERT_NE(d2, nullptr);
+    LeptrisXPathResult xr2 = leptris_xpath_eval(d2, nullptr, "//frameset");
+    EXPECT_EQ(leptris_xpath_result_count(xr2), (size_t)0);
+    leptris_xpath_result_free(xr2);
+    leptris_document_free(d2);
+}
+
+TEST(HtmlBorrowedNames, ImageRenamedImg) {
+    EXPECT_EQ(FirstElemName("<image src='x'>"), "img");
+}
+
+TEST(HtmlBorrowedNames, LongCustomTagName) {
+    std::string n(200, 'Q');
+    std::string html = "<" + n + ">t</" + n + ">";
+    EXPECT_EQ(FirstElemName(html.c_str()), std::string(200, 'q'));
+}

data/vendor-src/libleptris/test/parser/test_interleaved.cpp

@@ -55,8 +55,16 @@ const char* kBail[] = {
 };
 
 std::string parse_str(const char* xml, bool lane) {
-    if (lane) set_env("LEPTRIS_INTERLEAVED", "1");
-    else unset_env("LEPTRIS_INTERLEAVED");
+    if (lane) {
+        set_env("LEPTRIS_INTERLEAVED", "1");
+        /* #1258: fixtures are far below the 64KB default minimum —
+         * force the lane's floor to 1 byte so parity specs exercise
+         * the lane, never a silent classic fallback. */
+        set_env("LEPTRIS_IL_MIN", "1");
+    } else {
+        unset_env("LEPTRIS_INTERLEAVED");
+        unset_env("LEPTRIS_IL_MIN");
+    }
     LeptrisStatus st = LEPTRIS_OK;
     LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
     std::string out = d ? "" : "(null)";
@@ -128,6 +136,7 @@ TEST(InterleavedParity, BailFixturesByteIdentical) {
 TEST(InterleavedParity, AttrAndNameAccessIdentical) {
     const char* xml = "<r k='v' n='m'><child z='9'>tx</child></r>";
     set_env("LEPTRIS_INTERLEAVED", "1");
+    set_env("LEPTRIS_IL_MIN", "1");
     LeptrisStatus st = LEPTRIS_OK;
     LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
     ASSERT_NE(d, nullptr);
@@ -186,6 +195,7 @@ TEST(InterleavedParity, EngagementCanaryFiresOnlyWhenLaneRuns) {
     };
 
     set_env("LEPTRIS_INTERLEAVED", "1");
+    set_env("LEPTRIS_IL_MIN", "1");
     set_env("LEPTRIS_IL_STATS", "1");
     char lane[512] = {0};
     ssize_t n = capture(lane, sizeof(lane));
@@ -195,6 +205,7 @@ TEST(InterleavedParity, EngagementCanaryFiresOnlyWhenLaneRuns) {
     EXPECT_NE(strstr(lane, "attrs=1"), nullptr) << lane;
 
     unset_env("LEPTRIS_IL_STATS");
+    unset_env("LEPTRIS_IL_MIN");
     char classic[512] = {0};
     n = capture(classic, sizeof(classic));
     ASSERT_GE(n, 0);
@@ -216,8 +227,10 @@ TEST(InterleavedParity, XmlAttrNamespaceParity) {
     const char* xml = "<root><code xml:space='preserve'>t</code></root>";
     for (int lane = 0; lane <= 1; lane++) {
         SCOPED_TRACE(lane ? "interleaved" : "classic");
-        if (lane) set_env("LEPTRIS_INTERLEAVED", "1");
-        else unset_env("LEPTRIS_INTERLEAVED");
+        if (lane) { set_env("LEPTRIS_INTERLEAVED", "1");
+                    set_env("LEPTRIS_IL_MIN", "1"); }
+        else { unset_env("LEPTRIS_INTERLEAVED");
+               unset_env("LEPTRIS_IL_MIN"); }
         LeptrisStatus st = LEPTRIS_OK;
         LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
         ASSERT_NE(d, nullptr);
@@ -247,8 +260,10 @@ TEST(InterleavedParity, DeclaredPrefixNamespaceParity) {
     const char* xml = "<d xmlns:q='http://example/q' q:k='v'/>";
     for (int lane = 0; lane <= 1; lane++) {
         SCOPED_TRACE(lane ? "interleaved" : "classic");
-        if (lane) set_env("LEPTRIS_INTERLEAVED", "1");
-        else unset_env("LEPTRIS_INTERLEAVED");
+        if (lane) { set_env("LEPTRIS_INTERLEAVED", "1");
+                    set_env("LEPTRIS_IL_MIN", "1"); }
+        else { unset_env("LEPTRIS_INTERLEAVED");
+               unset_env("LEPTRIS_IL_MIN"); }
         LeptrisStatus st = LEPTRIS_OK;
         LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
         ASSERT_NE(d, nullptr);
@@ -266,8 +281,10 @@ TEST(InterleavedParity, DeclaredPrefixNamespaceParity) {
 TEST(InterleavedParity, DupAttrDiagnosticParity) {
     const char* xml = "<r a='1' a='2'/>";
     for (int lane = 0; lane <= 1; lane++) {
-        if (lane) set_env("LEPTRIS_INTERLEAVED", "1");
-        else unset_env("LEPTRIS_INTERLEAVED");
+        if (lane) { set_env("LEPTRIS_INTERLEAVED", "1");
+                    set_env("LEPTRIS_IL_MIN", "1"); }
+        else { unset_env("LEPTRIS_INTERLEAVED");
+               unset_env("LEPTRIS_IL_MIN"); }
         LeptrisStatus st = LEPTRIS_OK;
         LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
         ASSERT_NE(d, nullptr);
@@ -280,3 +297,52 @@ TEST(InterleavedParity, DupAttrDiagnosticParity) {
         unset_env("LEPTRIS_INTERLEAVED");
     }
 }
+
+
+#ifndef _WIN32
+/* #1258: the size floor. Below LEPTRIS_IL_MIN (default 64KB) the
+ * lane defers to the classic parser even when the gate is on —
+ * small documents cannot amortize the record pass (canon measured
+ * ~25% slower at 24KB). Forced floor (IL_MIN=1) restores engagement. */
+TEST(InterleavedParity, SizeFloorDefersSmallDocsToClassic) {
+    const char* xml = "<r><a x='1'>t</a></r>";
+    set_env("LEPTRIS_INTERLEAVED", "1");
+    set_env("LEPTRIS_IL_STATS", "1");
+    unset_env("LEPTRIS_IL_MIN");   /* default floor: 64KB */
+
+    /* stderr capture, same pipe discipline as the canary spec. */
+    auto capture_one = [&](char* buf, size_t bufsz) -> void {
+        int fds[2];
+        ASSERT_EQ(pipe(fds), 0);
+        int saved = dup(STDERR_FILENO);
+        fflush(stderr);
+        dup2(fds[1], STDERR_FILENO);
+        close(fds[1]);
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+        if (d) leptris_document_free(d);
+        fflush(stderr);
+        dup2(saved, STDERR_FILENO);
+        close(saved);
+        ssize_t n = read(fds[0], buf, bufsz - 1);
+        if (n >= 0) buf[n] = '\0';
+        close(fds[0]);
+    };
+
+    char small[512] = {0};
+    capture_one(small, sizeof(small));
+    EXPECT_EQ(strstr(small, "il: records="), nullptr)
+        << "small doc must NOT engage the lane under the default floor: "
+        << small;
+
+    set_env("LEPTRIS_IL_MIN", "1");
+    char forced[512] = {0};
+    capture_one(forced, sizeof(forced));
+    EXPECT_NE(strstr(forced, "il: records="), nullptr)
+        << "forced floor must restore engagement";
+
+    unset_env("LEPTRIS_IL_STATS");
+    unset_env("LEPTRIS_IL_MIN");
+    unset_env("LEPTRIS_INTERLEAVED");
+}
+#endif  /* !_WIN32: pipe/dup2 capture */

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.225",
+  "version": "1.9.228",
   "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.225.0
+  version: 1.9.228.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -823,6 +823,7 @@ files:
 - vendor-src/libleptris/test/html/nokogiri-tree-tests.dat
 - vendor-src/libleptris/test/html/test_html.cpp
 - vendor-src/libleptris/test/html/test_html5lib.cpp
+- vendor-src/libleptris/test/html/test_html_borrowed_names.cpp
 - vendor-src/libleptris/test/html/test_html_builder.cpp
 - vendor-src/libleptris/test/memory/test_arena.cpp
 - vendor-src/libleptris/test/memory/test_doc_block.cpp