leptris 1.9.418.0 → 1.9.419.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 602afb776ae5cbc4da725de682f9b2ecaaa468203a7a08ebd282001c49abc5e1
-  data.tar.gz: 2c76c6063b0256865991082653d8cda99aa6dac330ccdd4378f108c5d5511810
+  metadata.gz: af2b87b2aaec36ee96f0572566b19678f06da068a2bd8fac00b086585a69dbd3
+  data.tar.gz: f0be350c456f6097e500488ade498cd5a14454461f3cb7476c79a19e5d4b8e30
 SHA512:
-  metadata.gz: 1e8e56d54bf1c223a62eef03612dab63d0bf1b44929ba3f8aa50f037738cc91f4e048593d1af87eeaa2421401e26e36bb3b891ec105a020d2d0c59fcd981e2ab
-  data.tar.gz: f1b83a111189aa6b620d0bf60deb5e871fd1ea1e8122c7d87e052b39e348a8f59081b5cb9c95cb9248e46a18ed85e6e9ecf170dbf1800fe61f9509e5ab87fd03
+  metadata.gz: edb18348f5b49be7967e570f50b88a5038d6b3525734a4f8f8e86929546663c53b1b73386168f089c040fe7757906ba9174144469d5f88af032a3103911ba7cb
+  data.tar.gz: 91d9cc505d079ade08cd8b0c68bcee95b5f7f26413dd5a7b753acf3707662634a17f03cb79d03b9d1bad33412fe3657eb7632ecaa79a93fa8d92975c1c5fbbd4

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.418"
+LIBLEPTRIS_VERSION = "1.9.419"
 # 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/TODO.perf/39-hot-c-reads-or-hydrated-walk.md

@@ -0,0 +1,35 @@
+# 39 — Hot reads: C-defined parameterized readers, or the hydrated columnar walk
+
+Status: QUEUED (leptris-ruby#622, ask 1)
+
+Source: the moxml-on-leptris facade's structural-row losses, all at
+the per-read/per-mint Ruby floor. Facade reads sit at ~331ns because
+every read is an `UnboundMethod#bind_call` (one Ruby frame). The
+proven budgets (TODO.perf/32, clean host): native `[]` 71ns, binding
+memo seam ~160ns. The 2x-reads finish line needs the last Ruby frame
+gone. Two acceptable shapes — the owner picks:
+
+- **(a)** a binding-side C API that defines hot instance methods on
+  arbitrary receiver classes, operating on the receiver's TypedData
+  struct — the shape #204's closure sketched ("C-defined hot methods
+  parameterized by subclass"). moxml's Identity classes (subclass
+  NativeNode, klass-injected via `NativeNode.from`) get C
+  `[]`/`name`/`content`/`attribute` readers; the platform matrix
+  stays on the leptris dependency (moxml remains pure-Ruby).
+- **(b)** extend `walk_columnar` (TODO.perf/32's face) to a
+  **hydrated** walk: the same single crossing returns, per row, the
+  flat attr packet + text content alongside names/handles/depths.
+  The consumer pipeline (walk + attribute + text reads) then pays
+  zero per-read calls — the reads ride the walk crossing.
+
+Unlocks: walk+read (warm) 0.67x, walk+read (cold) 0.37x, children
+recursion (cold) 0.46x of raw nokogiri.
+
+## Evidence
+
+- lutaml/moxml scoreboard baseline (v0.5.166-era, clean host,
+  interleaved A/B per the published protocol).
+- TODO.perf/32's clean-host floor table: `[]` 71ns native / 160ns
+  binding seam.
+- leptris-ruby#527's verdict: the engine line is flat — the cold-row
+  cost is binding/facade, not an engine regression.

data/TODO.perf/40-nodeset-c-mint.md

@@ -0,0 +1,10 @@
+# 40 — NodeSet.from_result: klass-injected result materialization
+
+Status: QUEUED (leptris-ruby#622, ask 2 — the #204 ask, refiled)
+
+`xpath_result_rows_bulk` crosses once but still mints wrappers in a
+Ruby loop (~1.4us/query ask from #204). Mint the result rows in C
+with klass injection so consumers receive their wrapper classes
+directly.
+
+Unlocks: xpath `//field` (each) 0.59x of raw nokogiri.

data/TODO.perf/41-c-set-attribute-entry.md

@@ -0,0 +1,11 @@
+# 41 — C set-attribute entry (the write floor)
+
+Status: QUEUED (leptris-ruby#622, ask 3)
+
+`set_binding_text` landed (adopted behind a face probe); attribute-set
+has no C entry — post-build `set_attribute` pays the binding-layer
+crossing per attribute. `add_element_full` (TODO.sota/04) covers
+build-time attrs only.
+
+Unlocks: mutation-heavy/builder lanes (the build add_element row is
+at 0.975x and rides on this for the post-hoc shape).

data/ext/leptris/native/native.c

@@ -1681,6 +1681,42 @@ static VALUE nn_set_root(VALUE klass, VALUE document, VALUE element)
     return element;
 }
 
+/* TODO.perf/39(a) (leptris-ruby#622 ask 1): hot readers
+ * parameterized by subclass. Consumers whose wrapper classes SUBCLASS
+ * NativeNode (klass injection, #340) shadow these C methods with
+ * included Ruby modules — every shadowed read pays an
+ * UnboundMethod#bind_call frame (~the whole difference between the
+ * facade's ~331ns reads and the binding's ~160ns seam). This entry
+ * defines the SAME C functions (same bodies, same walk-memos, same
+ * TypedData type) DIRECTLY on the consumer's subclass, so lookup
+ * answers in C with no module shadow in the chain.
+ *
+ * The consumer decides which classes get the hot surface: a
+ * per-document klass map (#340) can route entity-bearing documents
+ * to contract classes and clean documents to hot classes, keeping
+ * any Ruby-side value post-processing exactly where it is still
+ * needed.
+ *
+ * Re-defining a method that already exists on the class replaces it
+ * (Ruby semantics); calling twice is harmless. The class must be the
+ * consumer's NativeNode subclass or NativeNode itself — a non-
+ * TypedData class would crash on first read, so the type is checked
+ * here against the registry. */
+static VALUE nf_define_hot_readers(VALUE self, VALUE klass)
+{
+    (void)self;
+    if (!RB_TYPE_P(klass, T_CLASS))
+        rb_raise(rb_eTypeError, "expected a class");
+    if (klass != c_native_node &&
+        rb_class_inherited_p(klass, c_native_node) != Qtrue)
+        rb_raise(rb_eTypeError,
+                 "the class must subclass Leptris::XML::NativeNode");
+    rb_define_method(klass, "name", nn_name, 0);
+    rb_define_method(klass, "content", nn_content, 0);
+    rb_define_method(klass, "attribute", nn_attribute, 1);
+    return Qtrue;
+}
+
 /* NativeNode surface completion (TODO.perf/05): bulk attribute
  * hash (name => value, one C walk, no per-attr Ruby frames) and
  * the position readers. */
@@ -4350,6 +4386,8 @@ static void leptris_native_setup(void)
                               nf_append_binding_child, 3);
     rb_define_module_function(m_native, "set_binding_attribute",
                               nf_set_binding_attribute, 4);
+    rb_define_module_function(m_native, "define_hot_readers",
+                              nf_define_hot_readers, 1);
     rb_define_module_function(m_native, "insert_binding_child",
                               nf_insert_binding_child, 4);
     rb_define_module_function(m_native, "at_xpath_first",

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.418.0"
+  VERSION = "1.9.419.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.418
+- libleptris v1.9.419
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [1.9.419] - 2026-11-12
+### Fixed
+
+- **xsd: wildcards ride attributeGroup refs across units** (leptris-rs#72, W3C wildZ013b/c). The #1964 deep capture left two holes: the extension branch still scanned shallow, so a wildcard living inside a REFERENCED attributeGroup under the extension element was invisible (strict admission rejected attributes the composed union admits); and a wildcard found in a group from ANOTHER unit (a namespace-less import) resolved against the CONSUMING schema's targetNamespace instead of its declaring unit's — `##other` flipped meaning across the boundary and the union collapsed to admitting only half the instance's attribute namespaces. The capture now follows refs in the extension branch and carries the declaring group's own unit tns (absent for the import).
+
+- **xsd: a bare `<xs:anyAttribute />` is a live ##any wildcard** (leptris-rs#73, W3C attZ014a/b). Absent @namespace means ##any (the moxml#460 posture) — the capture mapped it to NULL, an invisible wildcard, so wildcard-admitted attributes fell to strict rejection for the wrong reason. With admission live, XSD 1.0's one-ID-per-element rule fires: an element assessed with more than one ID-typed attribute (declared rows AND wildcard-admitted names whose global declaration is ID-derived) is invalid; XSD 1.1 lifted the constraint and reads the same shape valid. The rule is version-gated (`xsd_schema_version_11`).
+
+## Tests
+
+- wildZ013b/c + attZ014a/b fixtures vendored from w3c/xsdtests (msData/wildcards, msData/attribute); attZ014a also pinned under `@version="1.1"` (valid). Falsified: an always-false ID test failed exactly the two 1.0 pins and passed the 1.1 reading.
+
+
+
 ## [1.9.418] - 2026-11-12
 ## Fixed
 

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/TODO.max-perf/15-c-face-vs-pugixml.md

@@ -405,3 +405,76 @@ the loop-body surgery slice — it inherits the region-wrap probe
 
 RANKED CUT #1 therefore moves to the loop-surgery slice with the
 scan-merge as its first step. Nothing ships from the kernel alone.
+
+## Track D addendum 9 — the inline text-scan cut REJECTED by CI (PR #2018, closed)
+
+The ranked-#1 cut (inline 32-byte scalar prefix scan for short text
+runs, kernel for the remainder) went through the full gate: round 1
+caught the restart-at-run-start flaw (the kernel rescanned the
+scalar prefix — every leg regressed), round 2 fixed that (kernel
+from the prefix end) and STILL regressed on all three legs vs the
+A3d baselines (macos -39-46%, ubuntu-arm -26-27%, ubuntu-x86 -37-45%
+vs its AVX2 run). Cause: the bench-class run lengths (33-64B) sit
+exactly where the cut loses — 32 branchy scalar bytes plus a kernel
+pass over a 1-32B remainder exceeds the kernel alone, and runs
+<=32B are too few in these shapes to carry it.
+
+THE MISSING DATUM: the run-length distribution of the real fixtures
+and the scoreboard corpus. The next session's opening instrument =
+a run-length histogram (one counting pass per fixture, reusable),
+which decides whether the scan-merge has a paying window at all —
+and at what threshold. Until then the kernel stands unchanged; the
+PR closed with the full data (three legs, two rounds, CI artifacts).
+
+## Track D addendum 10 — the scan-merge slice CLOSED (PR #2020, closed unmerged)
+
+The 64-byte window (histogram-driven) went through the full gate and
+regressed WORSE than the 32-byte attempt: macos -45/-39/-46%, arm
+-32/-32/-29%, x86 -53/-53/-50% (vs the AVX2 run) — even for runs
+fully inside the window. THE VERDICT: the branchy scalar loop
+(~3-5 ops/byte) loses to the SIMD kernel (~1 op/byte) at every run
+length on every platform; the kernel's per-run fixed cost is small
+next to its per-byte advantage. The scan-merge slice is structurally
+dead — two windows, two full CI runs, one consistent verdict.
+
+THE TEXT-ROW LEVER REDIRECTS to the kernel's own per-byte
+throughput: the text_scan_run NEON kernel processes ~1 byte/op
+while pugixml's scanner sustains 2.1-2.7 GB/s — the Track A scanner
+class. The next concrete candidate: process 32B chunks (NEON
+registers ×2) per iteration instead of 16B, halving the reduction
+frequency; and the parser's text-branch call overhead already
+measures separably (the scalar wrapper at 2.2%).
+
+The histogram instrument (probe/run-histogram) remains in the repo
+history on probe/run-histogram; both rejected cut branches carry
+their full data.
+
+## Track D addendum 11 — the 32B kernel window measured-NEGATIVE (PR #2022, closed unmerged)
+
+The addendum-10 candidate (NEON text_scan_run at 32B windows — two
+uint8x16 registers, term masks OR-combined before ONE vmaxvq, halving
+the horizontal-reduction frequency) passed the full CI suite but the
+CI split was poisoned by fleet variance (x86 +31% on code the diff
+does not touch). The decisive instrument was a same-machine
+interleaved A/B on Apple silicon (Release+LTO, 3 rounds ABBA, pugixml
+side flat ~2370/1800 MB/s across rounds — machine verified stable):
+
+| shape | 16B (main) | 32B (PR) | delta |
+|-------|-----------|----------|-------|
+| 1.5MB | ~1341 MB/s | ~1144 MB/s | −15% |
+| 5MB   | ~1332 MB/s | ~1135 MB/s | −15% |
+| 13MB  | ~1029 MB/s | ~913 MB/s  | −11% |
+
+THE INVARIANT: horizontal-reduction frequency is NOT the binding term
+in text_scan_run on M-series. The accumulator chain is — two extra
+cmpeq+orr per register per window lengthen the dependency chain and
+raise live-register pressure (9+ Q registers) without removing any
+real per-byte work. Widening the window cannot pay; the kernel's
+per-byte op count is already minimal for its contract (first-term
+scan + f1/f2 seen-flags).
+
+TEXT-ROW STATUS after three measured closures (scan-merge 32B,
+scan-merge 64B, kernel-width 32B): the kernel is at its floor. The
+remaining text-row gap to pugixml is the parser's text-branch call
+overhead (the scalar wrapper measures separably at 2.2% — the only
+untried lever in this class), not the kernel.

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

@@ -128,9 +128,9 @@ static char* xsd_capture_unit_tns(LeptrisElement e);
 static void xsd_resolve_qname(LeptrisElement e, const char* qname,
                               char* uri, size_t urisz, char* local,
                               size_t localsz);
-static char* xsd_capture_any_attr_ns(LeptrisElement container);
 static char* xsd_capture_any_attr_ns_deep(
-    struct leptris_xsd_schema* s, LeptrisElement container, int depth);
+    struct leptris_xsd_schema* s, LeptrisElement container, int depth,
+    char** out_unit);
 static char* xsd_capture_any_attr_not_qname(LeptrisElement container);
 
 /* #1626: prefixed QName refs (type="w:CT_Border") resolve by local
@@ -3257,13 +3257,26 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                 /* XSD 1.1: asserts nested under the derivation */
                 if (s->version_11)
                     xsd_capture_assert_children(s, dq, root);
-                if (!any_attr_ns)
+                if (!any_attr_ns) {
                     if (!any_attr_unit_ns)
                         any_attr_unit_ns = xsd_capture_unit_tns(dq);
-                    any_attr_ns = xsd_capture_any_attr_ns(dq);
+                    /* leptris-rs#72: the extension's wildcard rides
+                     * attributeGroup refs too — the shallow scan
+                     * misses attgD019/wildZ013 shapes. Cross-unit
+                     * found-groups carry their own tns. */
+                    char* deep_unit = NULL;
+                    any_attr_ns = xsd_capture_any_attr_ns_deep(
+                        s, dq, 0, &deep_unit);
+                    if (any_attr_ns && deep_unit) {
+                        free(any_attr_unit_ns);
+                        any_attr_unit_ns = deep_unit;
+                    } else {
+                        free(deep_unit);
+                    }
                     if (!any_attr_not_qname)
                         any_attr_not_qname =
                             xsd_capture_any_attr_not_qname(dq);
+                }
             }
         } else if (strcmp(local, "simpleContent") == 0) {
             for (LeptrisNodeRef q = leptris_node_first_child(
@@ -3344,8 +3357,19 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
         if (!attrs) attrs = xsd_capture_attr_rows(s, ct, 0);
         if (!any_attr_unit_ns)
             any_attr_unit_ns = xsd_capture_unit_tns(ct);
-        if (!any_attr_ns)
-            any_attr_ns = xsd_capture_any_attr_ns_deep(s, ct, 0);
+        if (!any_attr_ns) {
+            char* deep_unit = NULL;
+            any_attr_ns = xsd_capture_any_attr_ns_deep(s, ct, 0,
+                                                       &deep_unit);
+            if (any_attr_ns && deep_unit) {
+                /* the wildcard lives in a REFERENCED group from
+                 * another unit — its declaring tns wins */
+                free(any_attr_unit_ns);
+                any_attr_unit_ns = deep_unit;
+            } else {
+                free(deep_unit);
+            }
+        }
         if (!any_attr_not_qname)
             any_attr_not_qname = xsd_capture_any_attr_not_qname(ct);
     }
@@ -3455,7 +3479,9 @@ XsdGroupDef* xsd_find_group(struct leptris_xsd_schema* s,
     return NULL;
 }
 
-static const XsdAttrDecl* xsd_find_top_attr(
+/* leptris-rs#73: the global attribute declaration for a local name
+ * (the ID-count pass resolves wildcard-admitted names against it). */
+const XsdAttrDecl* xsd_find_top_attr(
     struct leptris_xsd_schema* s, const char* name) {
     if (!s || !name) return NULL;
     for (XsdAttrDecl* a = s->top_attrs; a; a = a->next)
@@ -3686,7 +3712,7 @@ static char* xsd_capture_unit_tns(LeptrisElement e) {
  * (depth-bounded); the group's OWN element is the walk root. */
 static char* xsd_capture_any_attr_ns_deep(
     struct leptris_xsd_schema* s, LeptrisElement container,
-    int depth) {
+    int depth, char** out_unit) {
     if (depth > 8) return NULL;
     for (LeptrisNodeRef ac = leptris_node_first_child(
              leptris_element_as_node(container));
@@ -3697,9 +3723,14 @@ static char* xsd_capture_any_attr_ns_deep(
         const char* al = NULL, *au = NULL;
         leptris_element_expanded_name(ae, &al, NULL, &au);
         if (!al || (au && strcmp(au, XSD_NS) != 0)) continue;
-        if (strcmp(al, "anyAttribute") == 0)
-            return xsd_strdup(
-                leptris_element_attribute(ae, "namespace"));
+        if (strcmp(al, "anyAttribute") == 0) {
+            /* leptris-rs#73: absent @namespace means ##any — a
+             * bare <xs:anyAttribute /> is a live wildcard, not an
+             * invisible one. */
+            const char* ns =
+                leptris_element_attribute(ae, "namespace");
+            return xsd_strdup(ns ? ns : "##any");
+        }
         if (strcmp(al, "attributeGroup") == 0) {
             const char* ref = xsd_local_name(
                 leptris_element_attribute(ae, "ref"));
@@ -3708,31 +3739,26 @@ static char* xsd_capture_any_attr_ns_deep(
             for (; g; g = g->next)
                 if (strcmp(g->name, ref) == 0) break;
             if (g && g->elem) {
-                char* r = xsd_capture_any_attr_ns_deep(s, g->elem,
-                                                       depth + 1);
-                if (r) return r;
+                char* inner_unit = NULL;
+                char* r = xsd_capture_any_attr_ns_deep(
+                    s, g->elem, depth + 1, &inner_unit);
+                if (r) {
+                    /* leptris-rs#72: the wildcard resolves against
+                     * its DECLARING unit's tns — the group's own
+                     * unit ("" for a namespace-less import), which
+                     * may differ from the consuming type's. */
+                    if (out_unit)
+                        *out_unit = inner_unit
+                                        ? inner_unit
+                                        : xsd_capture_unit_tns(g->elem);
+                    return r;
+                }
             }
         }
     }
     return NULL;
 }
 
-static char* xsd_capture_any_attr_ns(LeptrisElement container) {
-    for (LeptrisNodeRef ac = leptris_node_first_child(
-             leptris_element_as_node(container));
-         ac; ac = leptris_node_next_sibling(ac)) {
-        if (leptris_node_get_type(ac) != LEPTRIS_NODE_TYPE_ELEMENT)
-            continue;
-        LeptrisElement ae = (LeptrisElement)ac;
-        const char* al = NULL;
-        leptris_element_expanded_name(ae, &al, NULL, NULL);
-        if (al && strcmp(al, "anyAttribute") == 0)
-            return xsd_strdup(
-                leptris_element_attribute(ae, "namespace"));
-    }
-    return NULL;
-}
-
 /* moxml#460: the anyAttribute's XSD 1.1 @notQName (same walk as the
  * namespace capture). NULL when absent. */
 static char* xsd_capture_any_attr_not_qname(LeptrisElement container) {

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

@@ -832,6 +832,11 @@ static int attr_fixed_matches(struct leptris_xsd_schema* s,
     return strcmp(norm_v, norm_f) == 0;
 }
 
+/* leptris-rs#73: xs:ID itself or a user simpleType whose restriction
+ * chain roots at xs:ID. */
+static int attr_type_is_id(struct leptris_xsd_schema* s,
+                           const char* type);
+
 static void validate_attributes(struct xsd_validator* v,
                                 struct leptris_xsd_schema* s,
                                 LeptrisElement elem,
@@ -962,6 +967,73 @@ static void validate_attributes(struct xsd_validator* v,
         verrf_atk(v, elem, "attribute-use", local, "attribute", local,
                   "not declared (strict)");
     }
+    /* leptris-rs#73 (W3C attZ014, XSD 1.0): an element assessed with
+     * more than one ID-typed attribute is invalid — declared rows
+     * AND wildcard-admitted attributes whose GLOBAL declaration is
+     * ID-derived both count. 1.1 lifted the constraint. */
+    if (!xsd_schema_version_11(s)) {
+        int id_count = 0;
+        for (XsdAttrDecl* a = ta->attrs; a; a = a->next)
+            if (attr_type_is_id(s, a->type)) id_count++;
+        for (LeptrisAttribute at = leptris_element_first_attribute(elem);
+             at && id_count < 2; at = leptris_attribute_next(at)) {
+            const char* qn = leptris_attribute_get_name(at);
+            if (!qn || strncmp(qn, "xmlns", 5) == 0) continue;
+            const char* colon = strchr(qn, ':');
+            const char* local = colon ? colon + 1 : qn;
+            int declared = 0;
+            for (XsdAttrDecl* a = ta->attrs; a && !declared; a = a->next)
+                if (strcmp(a->name, local) == 0 ||
+                    strcmp(a->name, qn) == 0)
+                    declared = 1;
+            if (declared) continue;
+            const char* auri = leptris_attribute_namespace_uri(at);
+            if (auri && strcmp(auri,
+                               "http://www.w3.org/2001/XMLSchema-instance")
+                    == 0)
+                continue;
+            if (ta->any_attr_not_qname &&
+                attr_not_qname_hits(ta->any_attr_not_qname, s, local))
+                continue;
+            int admitted =
+                ((ta->any_attr_ns || ta->any_attr_not_qname) &&
+                 any_attr_matches(ta->any_attr_ns, auri,
+                                  ta->any_attr_unit_ns
+                                      ? ta->any_attr_unit_ns
+                                      : xsd_target_ns(s))) ||
+                (ta->any_attr_base_ns &&
+                 any_attr_matches(ta->any_attr_base_ns, auri,
+                                  ta->any_attr_base_unit_ns
+                                      ? ta->any_attr_base_unit_ns
+                                      : xsd_target_ns(s)));
+            if (!admitted) continue;
+            const XsdAttrDecl* g =
+                xsd_find_top_attr(s, local);
+            if (g && attr_type_is_id(s, g->type)) id_count++;
+        }
+        if (id_count > 1)
+            verrf_atk(v, elem, "attribute-use", "ID", "attribute",
+                      "ID",
+                      "more than one ID-typed attribute (XSD 1.0 "
+                      "one-ID-per-element)");
+    }
+}
+
+/* leptris-rs#73: xs:ID itself or a user simpleType whose restriction
+ * chain roots at xs:ID. */
+static int attr_type_is_id(struct leptris_xsd_schema* s,
+                           const char* type) {
+    if (!type) return 0;
+    if (strcmp(type, "xs:ID") == 0 || strcmp(type, "xsd:ID") == 0)
+        return 1;
+    const XsdSimple* st = xsd_find_simple_ns_pub(s, type, NULL);
+    for (int hops = 0; st && st->base && hops < 8; hops++) {
+        if (strcmp(st->base, "xs:ID") == 0 ||
+            strcmp(st->base, "xsd:ID") == 0)
+            return 1;
+        st = xsd_find_simple_pub(s, st->base);
+    }
+    return 0;
 }
 
 static void validate_element(struct xsd_validator* v,

data/vendor-src/libleptris/src/leptris/xsd/xsd_internal.h

@@ -87,6 +87,9 @@ int xsd_element_name_defined(struct leptris_xsd_schema* s,
                              const char* local, const char* uri);
 int xsd_attr_name_defined(struct leptris_xsd_schema* s,
                           const char* local);
+struct xsd_attr_decl;
+const struct xsd_attr_decl* xsd_find_top_attr(
+    struct leptris_xsd_schema* s, const char* local);
 
 /* One validation finding (slice 4). text is malloc'd; kind and
  * component are BORROWED (static names / schema-owned component

data/vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014a-11.xsd

@@ -0,0 +1,16 @@
+<xsd:schema version="1.1" elementFormDefault="qualified" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+<xsd:complexType name="base">
+	 <xsd:attribute name="att1" type="xsd:string"/>
+	 <xsd:attribute name="att2" type="xsd:string"/>
+	 <xsd:anyAttribute />
+</xsd:complexType>
+
+<xsd:simpleType name="st">
+	<xsd:restriction base="xsd:ID"/>
+</xsd:simpleType>
+
+<xsd:element name="doc" type="base" />
+
+<xsd:attribute name="a" type="xsd:ID"/>
+<xsd:attribute name="b"  type="st"/>
+</xsd:schema>

data/vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014a.xml

@@ -0,0 +1 @@
+<doc att1="a" att2="a" a="a" b="b"/>

data/vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014a.xsd

@@ -0,0 +1,16 @@
+<xsd:schema elementFormDefault="qualified" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+<xsd:complexType name="base">
+	 <xsd:attribute name="att1" type="xsd:string"/>
+	 <xsd:attribute name="att2" type="xsd:string"/>
+	 <xsd:anyAttribute />
+</xsd:complexType>
+
+<xsd:simpleType name="st">
+	<xsd:restriction base="xsd:ID"/>
+</xsd:simpleType>
+
+<xsd:element name="doc" type="base" />
+
+<xsd:attribute name="a" type="xsd:ID"/>
+<xsd:attribute name="b"  type="st"/>
+</xsd:schema>

data/vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014b.xml

@@ -0,0 +1 @@
+<doc att1="a" att2="a" b="b"/>

data/vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014b.xsd

@@ -0,0 +1,16 @@
+<xsd:schema elementFormDefault="qualified" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+<xsd:complexType name="base">
+	 <xsd:attribute name="att1" type="xsd:string"/>
+	 <xsd:attribute name="att2" type="xsd:ID"/>
+	 <xsd:anyAttribute />
+</xsd:complexType>
+
+<xsd:simpleType name="st">
+	<xsd:restriction base="xsd:ID"/>
+</xsd:simpleType>
+
+<xsd:element name="doc" type="base" />
+
+<xsd:attribute name="a" type="xsd:ID"/>
+<xsd:attribute name="b"  type="st"/>
+</xsd:schema>

data/vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873.xsd

@@ -0,0 +1,122 @@
+<xs:schema elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="a" xmlns:a="a" xmlns:b="b">
+ <xs:import schemaLocation="test328873_imp.xsd"/>
+
+ <xs:element name="doc" type="a:derived"/>
+ <xs:element name="sub" type="a:derived2" />
+ <xs:element name="sub2" type="a:derived3" />
+ <xs:element name="sub3" type="a:derived4" />
+ <xs:element name="sub4" type="a:derived5" />
+ <xs:element name="sub5" type="a:intersection1" />
+ <xs:element name="sub6" type="a:intersection2" />
+ <xs:complexType name="base">
+     <xs:sequence>
+	<xs:element name="sub" type="a:derived2" minOccurs="0"/>
+	<xs:element name="sub2" type="a:derived3" minOccurs="0"/>
+	<xs:element name="sub3" type="a:derived4" minOccurs="0"/>
+	<xs:element name="sub4" type="a:derived5" minOccurs="0"/>
+	<xs:element name="sub5" type="a:intersection1" minOccurs="0"/>
+	<xs:element name="sub6" type="a:intersection2" minOccurs="0"/>
+     </xs:sequence>
+     <xs:attributeGroup ref="a:attG-a1"/>
+ </xs:complexType>
+
+ <xs:complexType name="derived">
+    <xs:complexContent>
+	<xs:extension base="a:base">
+     <xs:sequence />
+     <xs:attributeGroup ref="a:attG-a2"/>
+	</xs:extension>
+    </xs:complexContent>
+ </xs:complexType>
+
+<xs:complexType name="base2">
+     <xs:sequence />
+     <xs:attributeGroup ref="a:attG1-54"/>
+ </xs:complexType>
+
+ <xs:complexType name="derived2">
+    <xs:complexContent>
+	<xs:extension base="a:base2">
+     <xs:sequence />
+     <xs:attributeGroup ref="a:attG2-54"/>
+	</xs:extension>
+    </xs:complexContent>
+ </xs:complexType>
+
+<xs:complexType name="base3">
+     <xs:sequence />
+     <xs:attributeGroup ref="a:attG1-51"/>
+ </xs:complexType>
+
+ <xs:complexType name="derived3">
+    <xs:complexContent>
+	<xs:extension base="a:base3">
+     <xs:sequence />
+     <xs:attributeGroup ref="a:attG2-51"/>
+	</xs:extension>
+    </xs:complexContent>
+ </xs:complexType>
+
+<xs:complexType name="base4">
+     <xs:sequence />
+     <xs:attributeGroup ref="attG1-61"/>
+ </xs:complexType>
+
+ <xs:complexType name="derived4">
+    <xs:complexContent>
+	<xs:extension base="a:base4">
+     <xs:sequence />
+     <xs:attributeGroup ref="attG2-61"/> <!-- resultant wildcard is any -->
+	</xs:extension>
+    </xs:complexContent>
+ </xs:complexType>
+
+ <xs:complexType name="derived5">
+    <xs:complexContent>
+	<xs:extension base="a:base4">
+     <xs:sequence />
+     <xs:attributeGroup ref="attG3-61"/> <!-- resultant wildcard is not(absent) -->
+	</xs:extension>
+    </xs:complexContent>
+ </xs:complexType>
+
+ <xs:complexType name="intersection1">
+     <xs:attributeGroup ref="a:attG-a1"/> 
+     <xs:attributeGroup ref="a:attG2-3"/> <!-- resultant wildcard is set(b, c) -->
+ </xs:complexType>
+
+ <xs:complexType name="intersection2">
+     <xs:attributeGroup ref="a:attG-a1"/> 
+     <xs:attributeGroup ref="attG1-61"/> <!-- resultant wildcard is not(a) -->
+ </xs:complexType>
+
+ <xs:attribute name="attA"/>
+ <xs:attributeGroup name="attG-a1">
+     <xs:anyAttribute namespace="##other" processContents="lax"/>
+ </xs:attributeGroup>
+
+ <xs:attributeGroup name="attG2-3">
+     <xs:anyAttribute namespace="##local b c" processContents="lax"/>
+ </xs:attributeGroup>
+
+ <xs:attributeGroup name="attG-a2">
+     <xs:anyAttribute namespace="##targetNamespace b c" processContents="lax"/>
+ </xs:attributeGroup>
+
+<xs:attributeGroup name="attG1-54">
+     <xs:anyAttribute namespace="##other" processContents="lax"/>
+ </xs:attributeGroup>
+
+ <xs:attributeGroup name="attG2-54">
+     <xs:anyAttribute namespace="b c" processContents="lax"/>
+ </xs:attributeGroup>
+
+<xs:attributeGroup name="attG1-51">
+     <xs:anyAttribute namespace="##other" processContents="lax"/>
+ </xs:attributeGroup>
+
+ <xs:attributeGroup name="attG2-51">
+     <xs:anyAttribute namespace="##targetNamespace ##local b c" processContents="lax"/>
+ </xs:attributeGroup>
+
+</xs:schema>

data/vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873_imp.xsd

@@ -0,0 +1,15 @@
+<xs:schema elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+ <xs:attributeGroup name="attG1-61">
+     <xs:anyAttribute namespace="##other" processContents="lax"/> <!-- not(absent) -->
+ </xs:attributeGroup>
+
+ <xs:attributeGroup name="attG2-61">
+     <xs:anyAttribute namespace="##local b c" processContents="lax"/> 
+ </xs:attributeGroup>
+
+ <xs:attributeGroup name="attG3-61">
+     <xs:anyAttribute namespace="b c" processContents="lax"/> 
+ </xs:attributeGroup>
+
+</xs:schema>

data/vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873b.xml

@@ -0,0 +1,3 @@
+<a:sub2 a:att1="abc" att2="bc" b:att3="foo" x:att4="val" att="a" xmlns:a="a" xmlns:b="b" xmlns:x="x"/> <!-- resultant wildcard is ##any -->
+
+

data/vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873c.xml

@@ -0,0 +1,3 @@
+<a:sub3 a:att1="abc" att2="bc" b:att3="foo" x:att4="val" att="a" xmlns:a="a" xmlns:b="b" xmlns:x="x"/> <!-- resultant wildcard is ##any -->
+
+

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -1331,6 +1331,101 @@ TEST(XsdValidate, SchG2RoundtripUnitAAlone) {
     leptris_xsd_free(s);
 }
 
+// leptris-rs#72 (W3C wildZ013b, msData/wildcards, expected VALID):
+// the extension's wildcard lives inside a REFERENCED attributeGroup
+// (attG2-51 under the extension element) — the deep capture must
+// ride group refs in the extension branch too. The composed union
+// (base ##other ∪ extension ##targetNamespace ##local b c) admits
+// all five instance attribute namespaces.
+TEST(XsdValidate, WildZ013bExtensionGroupRefWildcardValid) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(
+        LEPTRIS_XSD_CASES_DIR "/wildZ013-set/test328873.xsd", &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    LeptrisDocument d = leptris_parse_file(
+        LEPTRIS_XSD_CASES_DIR "/wildZ013-set/test328873b.xml", &st);
+    ASSERT_NE(d, nullptr) << "status " << (int)st;
+    EXPECT_EQ(leptris_xsd_validate(s, d), 1)
+        << leptris_xsd_error_at(s, 0);
+    for (size_t i = 0; i < leptris_xsd_error_count(s); i++)
+        ADD_FAILURE() << leptris_xsd_error_at(s, i);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+// leptris-rs#72 (W3C wildZ013c): BOTH wildcards live in the
+// namespace-less IMPORT (attG1-61/attG2-61). Each resolves against
+// its DECLARING unit's tns (absent), not the consuming schema's —
+// ##other@absent ∪ {absent, b, c}@absent = ##any.
+TEST(XsdValidate, WildZ013cCrossUnitImportUnionValid) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(
+        LEPTRIS_XSD_CASES_DIR "/wildZ013-set/test328873.xsd", &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    LeptrisDocument d = leptris_parse_file(
+        LEPTRIS_XSD_CASES_DIR "/wildZ013-set/test328873c.xml", &st);
+    ASSERT_NE(d, nullptr) << "status " << (int)st;
+    EXPECT_EQ(leptris_xsd_validate(s, d), 1)
+        << leptris_xsd_error_at(s, 0);
+    for (size_t i = 0; i < leptris_xsd_error_count(s); i++)
+        ADD_FAILURE() << leptris_xsd_error_at(s, i);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+// leptris-rs#73 (W3C attZ014a, version-contested): <xs:anyAttribute />
+// without @namespace is a LIVE ##any (absent @namespace means ##any,
+// the moxml#460 posture) — a and b admit through it and resolve
+// against their global ID-typed declarations. XSD 1.0's
+// one-ID-per-element rule then makes the instance INVALID (two
+// ID-typed attributes on one element); XSD 1.1 lifted the rule.
+TEST(XsdValidate, AttZ014aIdCountInvalid10) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(
+        LEPTRIS_XSD_CASES_DIR "/attZ014-set/attZ014a.xsd", &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    LeptrisDocument d = leptris_parse_file(
+        LEPTRIS_XSD_CASES_DIR "/attZ014-set/attZ014a.xml", &st);
+    ASSERT_NE(d, nullptr) << "status " << (int)st;
+    EXPECT_EQ(leptris_xsd_validate(s, d), 0);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+// leptris-rs#73 (attZ014b): the declared att2 row is xs:ID and the
+// wildcard-admitted b resolves to a global restriction of xs:ID —
+// still two ID-typed attributes on the element. INVALID in 1.0.
+TEST(XsdValidate, AttZ014bDeclaredAndAdmittedIdInvalid10) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(
+        LEPTRIS_XSD_CASES_DIR "/attZ014-set/attZ014b.xsd", &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    LeptrisDocument d = leptris_parse_file(
+        LEPTRIS_XSD_CASES_DIR "/attZ014-set/attZ014b.xml", &st);
+    ASSERT_NE(d, nullptr) << "status " << (int)st;
+    EXPECT_EQ(leptris_xsd_validate(s, d), 0);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
+// leptris-rs#73 (1.1 reading): the same shape under @version="1.1"
+// is VALID — 1.1 lifted the one-ID-per-element constraint.
+TEST(XsdValidate, AttZ014aVersion11ReadingIsValid) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(
+        LEPTRIS_XSD_CASES_DIR "/attZ014-set/attZ014a-11.xsd", &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0) << "status " << (int)st;
+    LeptrisDocument d = leptris_parse_file(
+        LEPTRIS_XSD_CASES_DIR "/attZ014-set/attZ014a.xml", &st);
+    ASSERT_NE(d, nullptr) << "status " << (int)st;
+    EXPECT_EQ(leptris_xsd_validate(s, d), 1)
+        << leptris_xsd_error_at(s, 0);
+    for (size_t i = 0; i < leptris_xsd_error_count(s); i++)
+        ADD_FAILURE() << leptris_xsd_error_at(s, i);
+    leptris_document_free(d);
+    leptris_xsd_free(s);
+}
+
 TEST(XsdValidate, ValidDocumentPasses) {
     EXPECT_EQ(validate_doc(k_v_schema,
                            "<rows version=\"2\" status=\"ok\">"

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.418",
+  "version": "1.9.419",
   "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.418.0
+  version: 1.9.419.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -109,6 +109,9 @@ files:
 - TODO.perf/36-raise-in-c-serializer-encoding.md
 - TODO.perf/37-document-lazy-pointer.md
 - TODO.perf/38-bulk-walk-and-bench-gate.md
+- TODO.perf/39-hot-c-reads-or-hydrated-walk.md
+- TODO.perf/40-nodeset-c-mint.md
+- TODO.perf/41-c-set-attribute-entry.md
 - TODO.restructure/01-constraint-compliance-audit.md
 - TODO.restructure/02-deep-copy-seam.md
 - TODO.restructure/03-evaluation-context-seam.md
@@ -1282,6 +1285,11 @@ files:
 - vendor-src/libleptris/test/xsd/libxml2-cases/anyAttr.importB.1_0.xsd
 - vendor-src/libleptris/test/xsd/libxml2-cases/anyAttr1_0.xml
 - vendor-src/libleptris/test/xsd/libxml2-cases/anyAttr1_0.xsd
+- vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014a-11.xsd
+- vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014a.xml
+- vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014a.xsd
+- vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014b.xml
+- vendor-src/libleptris/test/xsd/libxml2-cases/attZ014-set/attZ014b.xsd
 - vendor-src/libleptris/test/xsd/libxml2-cases/attgD019-set/attgD019.xsd
 - vendor-src/libleptris/test/xsd/libxml2-cases/attgD019-set/attgD019a.xsd
 - vendor-src/libleptris/test/xsd/libxml2-cases/attr0_0.xml
@@ -1627,6 +1635,10 @@ files:
 - vendor-src/libleptris/test/xsd/libxml2-cases/vdv-first5_0.xml
 - vendor-src/libleptris/test/xsd/libxml2-cases/vdv-first5_0.xsd
 - vendor-src/libleptris/test/xsd/libxml2-cases/vdv-simpleTypes.xsd
+- vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873.xsd
+- vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873_imp.xsd
+- vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873b.xml
+- vendor-src/libleptris/test/xsd/libxml2-cases/wildZ013-set/test328873c.xml
 - vendor-src/libleptris/test/xsd/libxml2-cases/xml.xsd
 - vendor-src/libleptris/test/xsd/libxml2-cases/xns_type_refs/main.xsd
 - vendor-src/libleptris/test/xsd/libxml2-cases/xns_type_refs/root.xsd