leptris 1.9.317.1-arm-linux → 1.9.318.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2824d22f679e46bb0bcb8d79a163886812769ba8c9fe668e1243e27723cd0d7d
-  data.tar.gz: ab423424bd971f3dd6088ecae5ef9b2e15ab25b6ee64bcda617ab0cd19b7098b
+  metadata.gz: ee7babaf2291f4504600ca04e9ae6bc2ec2ae180b6ab7ebaae467ad175ed240e
+  data.tar.gz: 1be2ebb114b6f49629edd3c7200ac9cc56f4afe8e346d13731d83fe8f6bb1681
 SHA512:
-  metadata.gz: e355e20bc42352cf12697bcbb34b56b767fd6efa7ab82247bb57d89333d565d50fe1009a5c6b0dbd56aaf256f6c877970b95d6ea741c37d83140de432e9022ad
-  data.tar.gz: e04b01514ed223d2ef660c69cf9d2294f0903e3a12523e37c154bb61b18ba54458f8e6b5847c53077c0d4d94755ca767221b4f5997563240cbd6bf4c761feb5e
+  metadata.gz: a1fd9336ea9f80f28aa9768e387e8e7a1475de21a930ec4204047c9dc8d17f61812c97e74bf2c30b54f7c0b6fbfa7b49715b5e0a2c5be1c6ff860fe1cac6f175
+  data.tar.gz: baf8c3639dd59c27fa6a2a3bb5e1feb9449b6763a7fc221ca3cb00f5320a0ead3caf691f6c573fddaee99397d1b1679feb226bd28c97ba094a2a4627a93f8af6

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.317"
+LIBLEPTRIS_VERSION = "1.9.318"
 # 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.317.1"
+  VERSION = "1.9.318.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -157,6 +157,7 @@ module Leptris
       typedef :pointer, :leptris_xpath_ns_set
       typedef :pointer, :leptris_xpath_compiled
       typedef :pointer, :leptris_relaxng
+      typedef :pointer, :leptris_xsd_schema
       typedef :pointer, :leptris_xslt
       typedef :pointer, :leptris_xquery
       typedef :pointer, :leptris_schematron
@@ -1283,6 +1284,18 @@ attach_function :leptris_parse_string,
                :column, :int
       end
 
+      # XSD tier-1 (libleptris 1.9.318, #1075): compilation surface —
+      # compile a schema, count its top-level declarations, surface
+      # schema-level errors. Validation is a later tier.
+      attach_function :leptris_xsd_compile,
+        [:string, :size_t, :pointer], :leptris_xsd_schema
+      attach_function :leptris_xsd_free,
+        [:leptris_xsd_schema], :void
+      attach_function :leptris_xsd_declaration_count,
+        [:leptris_xsd_schema], :size_t
+      attach_function :leptris_xsd_error,
+        [:leptris_xsd_schema], UTF8_STRING
+
       attach_function :leptris_rng_parse,
         [:string, :size_t, :pointer], :leptris_relaxng
       attach_function :leptris_rng_parse_file,

data/lib/leptris/xml/xsd.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Leptris::XML::XSD
+  module_function
+
+  def compile(schema_xml)
+    Schema.compile(schema_xml)
+  end
+
+  # A compiled XSD schema (libleptris >= 1.9.318, #1075 tier-1):
+  # the compilation surface — a declaration census and schema-level
+  # error reporting. Validation is a later tier and not exposed yet.
+  #
+  #     schema = Leptris::XML::XSD.compile(xsd_text)
+  #     schema.declaration_count  # => top-level schema declarations
+  #     schema.error              # => nil, or the engine's message
+  #
+  class Schema
+    # GC-managed compiled handle.
+    class Handle < ::FFI::AutoPointer
+      def self.release(ptr)
+        Leptris::XML::FFI.leptris_xsd_free(ptr)
+      end
+    end
+
+    # Compile a schema from XML text. Raises Error when the text is
+    # not usable at all (not well-formed, no root); schema-level
+    # problems compile to a handle whose #error carries the detail
+    # — the tier-1 contract.
+    def self.compile(schema_xml)
+      xml = schema_xml.to_s
+      status = ::FFI::MemoryPointer.new(:int)
+      raw = Leptris::XML::FFI.leptris_xsd_compile(xml, xml.bytesize, status)
+      if raw.null?
+        raise Leptris::XML::Error,
+          "schema compile failed (status #{status.read_int}): " \
+          "#{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    # Number of top-level schema declarations the compiler
+    # recognized (elements, types, groups, ...).
+    def declaration_count
+      Leptris::XML::FFI.leptris_xsd_declaration_count(@handle)
+    end
+
+    # The engine's schema-level error message, or nil when the
+    # schema compiled cleanly.
+    def error
+      msg = Leptris::XML::FFI.leptris_xsd_error(@handle)
+      msg.nil? || msg.empty? ? nil : msg
+    end
+  end
+end

data/lib/leptris/xml.rb

@@ -35,6 +35,7 @@ module Leptris
     autoload :XSLT, "leptris/xml/xslt"
     autoload :XQuery, "leptris/xml/xquery"
     autoload :RelaxNG, "leptris/xml/relaxng"
+    autoload :XSD, "leptris/xml/xsd"
     autoload :DTD, "leptris/xml/dtd"
     autoload :Pull, "leptris/xml/pull"
     autoload :Iterparse, "leptris/xml/iterparse"

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [1.9.318] - 2026-10-08
+
+### Performance
+
+- **Per-thread small-span arena recycle — the tiny-doc fixed row
+  (#1436, PR #1580).** The global retain tier deliberately skipped
+  spans below 256 KB, so every small document paid full malloc/free
+  bookkeeping per create/destroy cycle; the quiet-hardware profile
+  named that cycle as the heart of the ~185 ns/doc tiny-doc row. A
+  per-thread LIFO cache inside the arena's retain seam hands the
+  previous document's span back with no allocator, no spinlock, and
+  no cross-thread traffic. Three standing contracts preserved:
+  exact-size take (the fail-fast capacity never silently widens),
+  custom-allocator stand-down (hooked accounting sees every
+  malloc/free pair), and ASAN bypass with thread-cleanup drain.
+  Measured on bench_doc_lifecycle (interleaved A/B, Release):
+  tight cycle 183/203/183 → 166/159/159 ns/doc (~15% off the
+  fixed row).
+
+
+
 ## [1.9.317] - 2026-10-07
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -27,6 +27,7 @@ set(LEPTRIS_SOURCES
     leptris/sch/schematron.c
     leptris/diff/diff.c
     leptris/rng/parse.c
+    leptris/xsd/compile.c
     leptris/rng/rng_public.c
     leptris/rng/rng_regex.c
     leptris/rng/validate.c

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

@@ -34,6 +34,8 @@ typedef struct leptris_doctype*      LeptrisDoctype;
 typedef const char*                 LeptrisNamespace;
 typedef struct leptris_xpath_result* LeptrisXPathResult;
 typedef struct leptris_relaxng*    LeptrisRelaxNG;
+/* #1075 XSD tier 1: opaque compiled W3C XML Schema handle. */
+typedef struct leptris_xsd_schema*  LeptrisXsdSchema;
 #endif
 
 /* ============================================================================

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

@@ -882,6 +882,33 @@ LEPTRIS_API LeptrisRelaxNG leptris_rng_parse(const char* schema,
 LEPTRIS_API LeptrisRelaxNG leptris_rng_parse_file(const char* path,
                                                   LeptrisStatus* status);
 LEPTRIS_API void leptris_rng_free(LeptrisRelaxNG rng);
+
+/* ============================================================================
+ * XSD (W3C XML Schema) — #1075 tier 1, slice 1: compilation.
+ *
+ * leptris_xsd_compile parses schema text and builds the top-level
+ * declaration model (xs:element / xs:attribute / xs:simpleType /
+ * xs:complexType / xs:group / xs:attributeGroup / xs:notation).
+ * Slices that follow add the datatype/facet machinery, content
+ * models, identity constraints, and instance validation.
+ *
+ * @param xsd_text schema bytes (UTF-8)
+ * @param len      byte length
+ * @param status   LEPTRIS_OK, or LEPTRIS_ERROR_PARSE (not
+ *                 well-formed, not an xs:schema document, or no
+ *                 recognized XML Schema namespace spelling)
+ * @return compiled schema; on failure an error-carrying handle
+ *         (leptris_xsd_error says why — free it the same way)
+ */
+LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
+                                                 size_t len,
+                                                 LeptrisStatus* status);
+LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema);
+/* Number of top-level schema declarations compiled (0 is valid). */
+LEPTRIS_API size_t leptris_xsd_declaration_count(LeptrisXsdSchema schema);
+/* Last compile error detail (NULL when the handle is valid).
+ * Schema-owned; lives until leptris_xsd_free. */
+LEPTRIS_API const char* leptris_xsd_error(LeptrisXsdSchema schema);
 /* Validate an instance document against the parsed schema
  * (phase-2 core subset: element/attribute/text/data/value/
  * choice/group/interleave/repeats/ref). Returns 1 valid; on 0,

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

@@ -29,6 +29,7 @@ typedef struct leptris_doctype*         LeptrisDoctype;
 typedef const char*                    LeptrisNamespace;
 typedef struct leptris_xpath_result*    LeptrisXPathResult;
 typedef struct leptris_relaxng* LeptrisRelaxNG;
+typedef struct leptris_xsd_schema* LeptrisXsdSchema;
 #endif
 
 #include "node.h"

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

@@ -3,6 +3,7 @@
  */
 #include "arena.h"
 
+#include "../common/port.h" /* LEPTRIS_THREAD_LOCAL */
 #include <stdint.h> /* uintptr_t: was transitive via glibc's mman graph */
 #include <stdlib.h>
 #include <string.h>
@@ -16,6 +17,7 @@
  * every byte the library takes. */
 void* leptris_alloc_hook(size_t size);
 void leptris_free_hook(void* ptr);
+int leptris_custom_allocator_active(void);
 
 #define ARENA_ALIGNMENT 8u
 
@@ -92,11 +94,78 @@ static void retain_lock(void) {
 static void retain_unlock(void) { __sync_lock_release(&g_retain_lock); }
 #endif
 
+/* ---- Small-span TLS recycle (#1436 tiny-doc fixed row) ---------
+ * The global retain deliberately skips spans below ARENA_RETAIN_MIN
+ * ("libc zone-reuses them"), but the per-document fixed-cost profile
+ * names arena create+destroy as the heart of the ~185 ns/doc
+ * tiny-doc row: even zone-recycled, malloc/free pay bookkeeping per
+ * span, and the batched-GC shape pays first-touch faults when a
+ * batch's spans outrun the zone cache. A per-thread LIFO of small
+ * spans hands the previous document's span back with no allocator,
+ * no global spinlock, and no cross-thread traffic. Same contract as
+ * the global tier: NOT zeroed, callers memset what they need. */
+#define ARENA_TLS_SPANS 8u
+#define ARENA_TLS_MAX_BYTES (2u * 1024u * 1024u)
+
+typedef struct {
+    char* base[ARENA_TLS_SPANS];
+    size_t size[ARENA_TLS_SPANS];
+    size_t count;
+    size_t bytes;
+} ArenaSmallCache;
+
+static LEPTRIS_THREAD_LOCAL ArenaSmallCache g_small;
+
+/* LIFO take, EXACT size only: a reused span must report exactly the
+ * requested capacity (same as a fresh malloc), or the fail-fast
+ * bound silently widens for whoever sized a span to its budget —
+ * the exhaustion specs pin that. Small spans are near-homogeneous
+ * per workload (a 64 KB-doc stream recycles 64 KB spans), so
+ * exact-match still catches the hot case. */
+static char* small_take(size_t request, size_t* capacity) {
+    if (request >= ARENA_RETAIN_MIN) return NULL;
+    /* Stands down under custom allocators, same as the pool
+     * recycler: hooked accounting must see every malloc/free pair. */
+    if (leptris_custom_allocator_active()) return NULL;
+    for (size_t i = g_small.count; i > 0; i--) {
+        size_t idx = i - 1;
+        if (g_small.size[idx] == request) {
+            char* found = g_small.base[idx];
+            *capacity = g_small.size[idx];
+            g_small.bytes -= g_small.size[idx];
+            g_small.base[idx] = g_small.base[g_small.count - 1];
+            g_small.size[idx] = g_small.size[g_small.count - 1];
+            g_small.count--;
+            return found;
+        }
+    }
+    return NULL;
+}
+
+/* Returns 1 when the span was parked, 0 when the cache is full or
+ * the size belongs to the global tier — the caller frees then. */
+static int small_give(char* base, size_t size) {
+    if (size >= ARENA_RETAIN_MIN) return 0;
+    if (leptris_custom_allocator_active()) return 0;
+    if (g_small.count >= ARENA_TLS_SPANS ||
+        g_small.bytes + size > ARENA_TLS_MAX_BYTES)
+        return 0;
+    g_small.base[g_small.count] = base;
+    g_small.size[g_small.count] = size;
+    g_small.count++;
+    g_small.bytes += size;
+    return 1;
+}
+
 /* Best fit: the smallest retained block that covers the request, so
  * oversized blocks aren't burned on small documents. Returns the
- * block and reports its true capacity; NULL when nothing fits (or
- * the request is below the retain threshold — malloc territory). */
+ * block and reports its true capacity; NULL when nothing fits. */
 static char* retain_take(size_t request, size_t* capacity) {
+    /* 'parked', never 'small' — MSVC's headers #define small (the
+     * OLE `#define small char`) and turn the local into a type
+     * token (C2059). */
+    char* parked = small_take(request, capacity);
+    if (parked) return parked;
     if (request < ARENA_RETAIN_MIN) return NULL;
     char* found = NULL;
     size_t found_size = 0;
@@ -128,7 +197,8 @@ static void retain_give(char* base, size_t size) {
     return;
 #endif
     if (size < ARENA_RETAIN_MIN) {
-        leptris_free_hook(base);
+        if (!small_give(base, size))
+            leptris_free_hook(base);
         return;
     }
     retain_lock();
@@ -149,6 +219,16 @@ static void retain_give(char* base, size_t size) {
  * blocks are process-lifetime parking by design; release them so
  * embedded hosts and leak checkers see a clean exit. */
 void leptris_arena_retain_drain(void) {
+    /* The small tier drains the CALLING thread's cache — the shape
+     * leptris_thread_cleanup serves. Other threads' cached spans
+     * stay reachable through their TLS slots and die with the
+     * process (the same still-reachable parking as the global
+     * tier). */
+    for (size_t i = 0; i < g_small.count; i++)
+        leptris_free_hook(g_small.base[i]);
+    g_small.count = 0;
+    g_small.bytes = 0;
+
     retain_lock();
     for (size_t i = 0; i < g_retain.count; i++)
         leptris_free_hook(g_retain.base[i]);

data/vendor-src/libleptris/src/leptris/xpath/evaluator.h

@@ -25,6 +25,7 @@ typedef struct leptris_doctype*         LeptrisDoctype;
 typedef const char*                    LeptrisNamespace;
 typedef struct leptris_xpath_result*    LeptrisXPathResult;
 typedef struct leptris_relaxng* LeptrisRelaxNG;
+typedef struct leptris_xsd_schema* LeptrisXsdSchema;
 #endif
 
 /* ============================================================================

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

@@ -0,0 +1,121 @@
+/* lib/src/leptris/xsd/compile.c — #1075 XSD tier 1, slice 1: the
+ * compilation surface. Parses schema text through the standard XML
+ * parser and models the top-level declaration set. Later slices
+ * grow the model (datatypes, facets, content models, identity
+ * constraints) — this slice's contract is the API shape, the
+ * xs:schema identity check, and the declaration enumeration. */
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../include/leptris.h"
+
+#define XSD_NS "http://www.w3.org/2001/XMLSchema"
+
+struct leptris_xsd_schema {
+    size_t declaration_count;
+    char* error;
+};
+
+static void xsd_set_error(struct leptris_xsd_schema* s, const char* msg) {
+    free(s->error);
+    s->error = NULL;
+    if (msg) {
+        size_t n = strlen(msg) + 1;
+        s->error = (char*)malloc(n);
+        if (s->error) memcpy(s->error, msg, n);
+    }
+}
+
+/* A top-level schema-language declaration component. */
+static int xsd_is_declaration(const char* local, const char* uri) {
+    if (uri && strcmp(uri, XSD_NS) != 0) return 0;
+    if (!local) return 0;
+    static const char* names[] = {
+        "element",    "attribute",    "simpleType", "complexType",
+        "group",      "attributeGroup", "notation", "include",
+        "import",     "redefine",     NULL
+    };
+    for (int i = 0; names[i]; i++)
+        if (strcmp(local, names[i]) == 0) return 1;
+    return 0;
+}
+
+LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
+                                                 size_t len,
+                                                 LeptrisStatus* status) {
+    if (status) *status = LEPTRIS_OK;
+    if (!xsd_text || len == 0) {
+        if (status) *status = LEPTRIS_ERROR_PARSE;
+        return NULL;
+    }
+
+    struct leptris_xsd_schema* s =
+        (struct leptris_xsd_schema*)calloc(1, sizeof(*s));
+    if (!s) {
+        if (status) *status = LEPTRIS_ERROR_MEMORY;
+        return NULL;
+    }
+
+    LeptrisDocument doc = leptris_parse_string(xsd_text, len, status);
+    if (!doc) {
+        xsd_set_error(s, "schema document is not well-formed XML");
+        goto fail;
+    }
+
+    LeptrisElement root = leptris_document_root(doc);
+    if (!root) {
+        xsd_set_error(s, "schema document has no root element");
+        goto fail;
+    }
+
+    const char* local = NULL;
+    const char* prefix = NULL;
+    const char* uri = NULL;
+    leptris_element_expanded_name(root, &local, &prefix, &uri);
+    /* Accept the XML Schema namespace under any prefix, and the
+     * unprefixed spelling libxml2 fixtures use without a default
+     * xmlns (compilation is namespace-driven from here on). */
+    if (!local || strcmp(local, "schema") != 0 ||
+        (uri && strcmp(uri, XSD_NS) != 0)) {
+        xsd_set_error(s, "root element is not xs:schema");
+        goto fail;
+    }
+
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(root));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        leptris_element_expanded_name((LeptrisElement)n, &local, &prefix,
+                                      &uri);
+        if (xsd_is_declaration(local, uri))
+            s->declaration_count++;
+    }
+
+    leptris_document_free(doc);
+    return s;
+
+fail:
+    if (doc) leptris_document_free(doc);
+    if (status) *status = LEPTRIS_ERROR_PARSE;
+    /* Failure returns an error-carrying handle (the documented
+     * contract): leptris_xsd_error says why, free it the same way. */
+    return (LeptrisXsdSchema)s;
+}
+
+LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
+    struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
+    if (!s) return;
+    free(s->error);
+    free(s);
+}
+
+LEPTRIS_API size_t leptris_xsd_declaration_count(LeptrisXsdSchema schema) {
+    if (!schema) return 0;
+    return ((struct leptris_xsd_schema*)schema)->declaration_count;
+}
+
+LEPTRIS_API const char* leptris_xsd_error(LeptrisXsdSchema schema) {
+    if (!schema) return NULL;
+    return ((struct leptris_xsd_schema*)schema)->error;
+}

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

@@ -116,6 +116,9 @@ leptris_add_test(test_text_borrowed dom/test_text_borrowed.cpp)
 leptris_add_test(test_compact    dom/test_compact.cpp)
 leptris_add_test(test_digest     dom/test_digest.cpp)
 leptris_add_test(test_rng        rng/test_rng.cpp)
+leptris_add_test(test_xsd_compile xsd/test_xsd_compile.cpp)
+target_compile_definitions(test_xsd_compile PRIVATE
+    LEPTRIS_XSD_CASES_DIR="${CMAKE_CURRENT_SOURCE_DIR}/xsd/libxml2-cases")
 target_compile_definitions(test_rng PRIVATE
     LEPTRIS_RNG_INCLUDE_DIR="${CMAKE_CURRENT_SOURCE_DIR}/rng/include-cases")
 leptris_add_test(test_rng_corpus rng/test_rng_corpus.cpp)

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

@@ -1837,3 +1837,129 @@ TEST(Plan1560, UnqualifiedNsFormBindsNoPrefixSpellings) {
     }
     leptris_plan_free(plan);
 }
+
+// ---- #1563: nested attr parity -------------------------------------
+// The report: a two-level plan whose root carries one exact-URI
+// attribute row drops the CHILD's attribute capture — the child's
+// PlanValue answers attribute("name") nil for a prefixed w:name
+// while the same child plan compiled as ROOT binds it. This is the
+// A/B discriminator: one child plan (plain unset-form attr row, the
+// reporter's shape; ANY-form as the binding control), walked BOTH
+// ways. Whatever the outcome, the two paths must AGREE.
+TEST(Plan1563, PlainAttrRowAgreesNestedVsRoot) {
+    LeptrisStatus st = LEPTRIS_OK;
+
+    leptris_attr_plan root_attrs[1] = {};
+    root_attrs[0].wire_name = "Ignorable";
+    root_attrs[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    root_attrs[0].type_tag = 1;
+    root_attrs[0].ns_form = LEPTRIS_PLAN_NS_EXACT;
+    root_attrs[0].ns_uri = "urn:mc";
+    root_attrs[0].ns_prefix = "mc";
+
+    leptris_child_plan font_row[1] = {};
+    font_row[0].wire_name = "font";
+    font_row[0].kind = LEPTRIS_PLAN_KIND_NESTED;
+    font_row[0].child_plan_index = 1;
+    font_row[0].ns_form = LEPTRIS_PLAN_NS_EXACT;
+    font_row[0].ns_uri = "urn:w";
+    font_row[0].ns_prefix = "w";
+
+    /* The reporter's child row: PLAIN wire_name, unset ns_form. */
+    leptris_attr_plan font_attrs_plain[1] = {};
+    font_attrs_plain[0].wire_name = "name";
+    font_attrs_plain[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    font_attrs_plain[0].type_tag = 1;
+
+    /* Control: ANY form with the LOCAL name must bind w:name. */
+    leptris_attr_plan font_attrs_any[1] = {};
+    font_attrs_any[0].wire_name = "name";
+    font_attrs_any[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    font_attrs_any[0].type_tag = 1;
+    font_attrs_any[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    font_attrs_any[0].pad_ns = 1;
+
+    leptris_element_plan nested_plans[2] = {};
+    nested_plans[0].element_name = "fonts";
+    nested_plans[0].attribute_count = 1;
+    nested_plans[0].attribute_plans = root_attrs;
+    nested_plans[0].child_count = 1;
+    nested_plans[0].child_plans = font_row;
+    nested_plans[0].ns_form = LEPTRIS_PLAN_NS_EXACT;
+    nested_plans[0].ns_uri = "urn:w";
+    nested_plans[0].ns_prefix = "w";
+    nested_plans[1].element_name = "font";
+    nested_plans[1].attribute_count = 1;
+    nested_plans[1].attribute_plans = font_attrs_plain;
+    nested_plans[1].ns_form = LEPTRIS_PLAN_NS_EXACT;
+    nested_plans[1].ns_uri = "urn:w";
+    nested_plans[1].ns_prefix = "w";
+
+    leptris_plan_spec nested_spec = {};
+    nested_spec.abi_version = leptris_plan_abi_version();
+    nested_spec.plan_count = 2;
+    nested_spec.plans = nested_plans;
+    LeptrisPlan nested_plan = leptris_plan_build(&nested_spec, &st);
+    ASSERT_NE(nested_plan, nullptr);
+
+    /* Root walk of the SAME child plan (reporter's standalone doc). */
+    leptris_element_plan root_plans[1] = {};
+    root_plans[0] = nested_plans[1];
+    leptris_plan_spec root_spec = {};
+    root_spec.abi_version = leptris_plan_abi_version();
+    root_spec.plan_count = 1;
+    root_spec.plans = root_plans;
+    LeptrisPlan root_plan = leptris_plan_build(&root_spec, &st);
+    ASSERT_NE(root_plan, nullptr);
+
+    const char* nested_xml =
+        "<w:fonts xmlns:w=\"urn:w\" xmlns:mc=\"urn:mc\""
+        " mc:Ignorable=\"w14\"><w:font w:name=\"Arial\"/></w:fonts>";
+    const char* root_xml =
+        "<w:font xmlns:w=\"urn:w\" w:name=\"Arial\"/>";
+
+    LeptrisDocument doc = leptris_parse_string(nested_xml, strlen(nested_xml), &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisPlanResult r = leptris_plan_walk(doc, leptris_document_root(doc), nested_plan, &st);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(leptris_plan_value_count(r), 1u);
+    LeptrisPlanResult font_nested = leptris_plan_value_at(r, 0);
+    ASSERT_NE(font_nested, nullptr);
+    const char* nested_plain = leptris_plan_value_attribute(font_nested, "name");
+    leptris_plan_result_free(r);
+    leptris_document_free(doc);
+
+    LeptrisDocument doc2 = leptris_parse_string(root_xml, strlen(root_xml), &st);
+    ASSERT_NE(doc2, nullptr);
+    LeptrisPlanResult r2 = leptris_plan_walk(doc2, leptris_document_root(doc2), root_plan, &st);
+    ASSERT_NE(r2, nullptr);
+    /* The walk root carries no row stamp — its attrs answer through
+     * the plan's rows. */
+    const char* root_plain = leptris_plan_value_attribute(r2, "name");
+    leptris_plan_result_free(r2);
+    leptris_document_free(doc2);
+
+    RecordProperty("nested_plain_nil", nested_plain ? "0" : "1");
+    RecordProperty("root_plain_nil", root_plain ? "0" : "1");
+    /* The two paths must agree, whichever semantic that is. */
+    ASSERT_EQ(nested_plain == nullptr, root_plain == nullptr)
+        << "nested=" << (nested_plain ? nested_plain : "(nil)")
+        << " root=" << (root_plain ? root_plain : "(nil)");
+
+    /* Control: ANY-form rows bind w:name BOTH ways. */
+    nested_plans[1].attribute_plans = font_attrs_any;
+    LeptrisPlan nested_any = leptris_plan_build(&nested_spec, &st);
+    ASSERT_NE(nested_any, nullptr);
+    LeptrisDocument doc3 = leptris_parse_string(nested_xml, strlen(nested_xml), &st);
+    ASSERT_NE(doc3, nullptr);
+    LeptrisPlanResult r3 = leptris_plan_walk(doc3, leptris_document_root(doc3), nested_any, &st);
+    ASSERT_NE(r3, nullptr);
+    LeptrisPlanResult font_any = leptris_plan_value_at(r3, 0);
+    ASSERT_NE(font_any, nullptr);
+    EXPECT_STREQ(leptris_plan_value_attribute(font_any, "name"), "Arial");
+    leptris_plan_result_free(r3);
+    leptris_document_free(doc3);
+    leptris_plan_free(nested_any);
+    leptris_plan_free(root_plan);
+    leptris_plan_free(nested_plan);
+}