leptris 1.9.390.3-aarch64-linux → 1.9.394.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9252734e5fd7fd06b182e3fa9e6edcc014dfe2f44d5b1c6a7a538c5fc91d22dc
-  data.tar.gz: d5a8563daa2c38f5f05d635c816e22a99a2bb9fa742e1761d3b4a3218198463d
+  metadata.gz: ca834bfba520ffac47a4d7e2a45ba9fc298683a2e3f733dfa001c52a69caba7b
+  data.tar.gz: 4595a965a4e09df9fb53e582149f1d6e2d05e94f0144b9324e6da5ba83fdbfac
 SHA512:
-  metadata.gz: 8a03fafce6f2b563f58a7f957c83095bb345be41bd15b44b3ee058be72836e10eb64e0b656b46957bded569465775754ff82706db1df224f4b3d825db737e434
-  data.tar.gz: e46ce41230a5be7d071c7dbfffcac8c887c9fc1388ad5014b422b750759c0e7880db1f4c71942bbe00e88be1e20a1b5d7d50feafbd8189e1c4fef57c6500cfb6
+  metadata.gz: c4aaaa1c101bf275dc2a45df3ea19f90ff0aa29f4afd25d99fc96cae412036085fb53d4640f35127b128aaad9af43b73a2b426ecdc2e57502f7cfc2b7baf1197
+  data.tar.gz: eef6a971ac77c4c9fe5860af6a6563d98d6cef91c925da6ba57c9643208428b58855b9420fe49827b1a81f68f36d01166f006028dcce6d943a370643ce1e784a

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.390"
+LIBLEPTRIS_VERSION = "1.9.394"
 # 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.390.3"
+  VERSION = "1.9.394.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.390
+- libleptris v1.9.394
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,106 @@
 ## [Unreleased]
 
+## [1.9.394] - 2026-10-30
+
+### Fixed
+
+- **xs:override loads its base and replaces the overridden components
+  (leptris#1913, PR #1917).** `override` was absent from the
+  declaration gate and the include-family chase, so the base document
+  never loaded and the override body's nested declarations were never
+  captured — the compiled schema had an empty symbol space (decls=0,
+  every instance element "not declared"). Override now chases its
+  schemaLocation like include (same targetNamespace), then captures
+  its own declaration children as a pseudo-root AFTER the base so the
+  head-first lookup ladder sees the replacements; the attributeGroup
+  pre-pass honors a capture-force flag in that body, and the ref-check
+  declaration collector walks the override body too. Witness: base
+  `Doc` replaced by the override's `Doc` — `<doc><b>1</b></doc>`
+  validates, `<doc><a>x</a></doc>` is rejected.
+
+
+
+## [1.9.393] - 2026-10-30
+
+### Added
+
+- **Capability bit for entity-reference nodes (leptris#1904, PR #1915).**
+  `LEPTRIS_PARSE_KEEP_ENTITY_REFS` already parses references as
+  first-class `LEPTRIS_NODE_TYPE_ENTITY_REF` nodes — text segments
+  split around the five built-ins and custom named references
+  (numeric character references stay text, XML 1.0 §4.1) — but
+  nothing advertised it. `LEPTRIS_CAP_ENTITY_REF_NODES` lets a
+  binding probe once and parse with the flag instead of re-scanning
+  expanded text; a spec pins the DOM shape and the
+  string-value / serialization / XPath agreement.
+
+### Fixed
+
+- **XSD 1.1 was inert for every `vc:minVersion`-marked schema
+  (leptris#1910, leptris#1911, PR #1914).** The version detector
+  read only the root's plain `version` attribute; the W3C suite and
+  the binding ecosystem mark 1.1 with `vc:minVersion` in the
+  versioning namespace. With the capture gates off,
+  `xs:alternative` and `xs:assert` compiled to nothing —
+  conditional type assignment applied the declared base type's
+  model in both directions (false rejects and false accepts), and
+  asserts never attached to their types. The detector now honors
+  `version`, `vc:minVersion`, and a `vc:maxVersion="1.0"` pin, and
+  `xs:openContent` interleave/suffix semantics engage with it
+  (leptris#1912's repro validates clean).
+- **Value-comparison keywords accept name-test operands
+  (`w le h`).** The XPath `eq/ne/lt/le/gt/ge` operators only read
+  as operators when the right operand opened with a scalar, paren,
+  variable, or function call — an `xs:assert test="w le h"` failed
+  to compile. Adjacent name tokens are never a valid path
+  continuation, so a bare name-test follower is unambiguously an
+  operand; every path start is now admitted.
+
+
+
+## [1.9.392] - 2026-10-30
+
+### Added
+
+- **Capability descriptor face (leptris#1905, PR #1908).**
+  `leptris_capabilities()` returns a versioned bitset of every face
+  this installed engine serves — the engine-side half of the
+  moxml#504 capability report. Bindings OR it with their own wrapper
+  knowledge instead of maintaining scattered version-gate
+  constants; build-conditional faces (DUCET collation, utf8proc,
+  iconv, AVX2) follow the same `LEPTRIS_HAS_*` macros that gate the
+  sources, so the descriptor cannot drift from the binary it ships
+  in. Contract: bits append, never reorder; the descriptor version
+  gates shape changes. The spec anchors every unconditional bit to
+  its real face symbol — a bit without a linked face fails the
+  build, not the assertion.
+
+
+
+## [1.9.391] - 2026-10-30
+
+### Fixed
+
+- **XSD: resolve attributeGroup ref rows the pre-pass captured
+  before its imports (leptris-ruby#569, PR #1906).** The #1880
+  attributeGroup pre-pass captures each unit's group defs *before*
+  that unit's imports are chased, so an `<xs:attribute ref="r:embed"/>`
+  row whose declaration lives in a later-imported unit found no
+  global attribute and was silently dropped. Types were left
+  hole-punched (whole-instance validation then rejected `a:blip
+  @r:embed` with "not declared (strict)" on the OOXML `wml.xsd`
+  chain — clean on 1.9.368.1, regressed by the 386-390 wave) or
+  attribute-less, which skipped the strict attribute walk entirely
+  and false-validated foreign attributes. Unresolved ref rows are
+  now kept pending — with the ref's own `use=` override recorded —
+  and re-resolved against the merged top-level attribute table once
+  the whole capture has run; row copies carry the flag so referencing
+  types heal too. Witness: the real uniword `wml.xsd` (1826
+  declarations) compiles clean and a docx-style document with
+  `a:blip r:embed` validates 1.
+
+
+
 ## [1.9.390] - 2026-10-29
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/README.adoc

@@ -744,6 +744,43 @@ To pin enum values (bindings hard-code these):
 ctest --test-dir build -R HeaderHygiene
 ----
 
+=== Capability descriptor (one call: what does this engine serve?)
+
+Bindings and embedders stop maintaining scattered version-gate
+constants: one call returns a versioned bitset of every face this
+installed engine serves. Build-conditional faces (Unicode
+normalization, iconv, DUCET collation, AVX2) answer honestly for the
+exact library you linked. New capabilities APPEND bits — the
+descriptor version gates shape changes.
+
+[source,c]
+----
+LeptrisCapabilities c = leptris_capabilities();
+if (c.descriptor_version >= 1 && (c.caps & LEPTRIS_CAP_XSD)) {
+    /* xsd compile/validate faces are present */
+}
+----
+
+Entity references: parsing with `LEPTRIS_PARSE_KEEP_ENTITY_REFS`
+yields `LEPTRIS_NODE_TYPE_ENTITY_REF` nodes instead of pre-expanded
+text — segments split around the five built-ins and custom named
+references (numeric character references stay text, per XML 1.0
+§4.1). String-value, serialization, and XPath all see the expanded
+value. Probe `LEPTRIS_CAP_ENTITY_REF_NODES` before relying on the
+mode.
+
+The bits: `LEPTRIS_CAP_PARSE`, `LEPTRIS_CAP_DOM`, `LEPTRIS_CAP_XPATH`,
+`LEPTRIS_CAP_XQUERY`, `LEPTRIS_CAP_DTD`, `LEPTRIS_CAP_SAX`,
+`LEPTRIS_CAP_HTML`, `LEPTRIS_CAP_XINCLUDE`, `LEPTRIS_CAP_DIFF`,
+`LEPTRIS_CAP_DIGEST`, `LEPTRIS_CAP_XSD`, `LEPTRIS_CAP_XSD_SET`,
+`LEPTRIS_CAP_RELAXNG`, `LEPTRIS_CAP_SCHEMATRON`, `LEPTRIS_CAP_XSLT`,
+`LEPTRIS_CAP_DESCRIPTOR`, `LEPTRIS_CAP_NS_SNAPSHOT_BULK`,
+`LEPTRIS_CAP_CHILDREN_BATCH`, `LEPTRIS_CAP_NAME_COMPARE`,
+`LEPTRIS_CAP_VERSION`, and the build-conditional
+`LEPTRIS_CAP_COLLATION_DUCET`, `LEPTRIS_CAP_UNICODE_UTF8PROC`,
+`LEPTRIS_CAP_ENCODING_ICONV`, `LEPTRIS_CAP_SIMD_AVX2`,
+`LEPTRIS_CAP_ENTITY_REF_NODES`.
+
 [#FFI]
 == FFI design
 

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

@@ -447,6 +447,58 @@ typedef struct leptris_xpath_compiled* LeptrisXPathCompiled;
  * compiled — apply it to any number of documents, from any threads. */
 typedef struct leptris_xslt* LeptrisXslt;
 
+/* ============================================================================
+ * Capability Descriptor (leptris#1905)
+ * ============================================================================ */
+
+/* What this INSTALLED engine serves — one call, one versioned
+ * bitset. Contract: new capabilities APPEND bits; a bit is never
+ * removed, repurposed, or reordered — that is a descriptor-version
+ * bump. Build-conditional faces (utf8proc/iconv/DUCET/AVX2) answer
+ * honestly for the exact library a consumer linked. Bindings OR
+ * this with their own wrapper knowledge; consumers stop maintaining
+ * scattered version-gate constants. */
+enum {
+    LEPTRIS_CAP_PARSE = 1ULL << 0,
+    LEPTRIS_CAP_DOM = 1ULL << 1,
+    LEPTRIS_CAP_XPATH = 1ULL << 2,
+    LEPTRIS_CAP_XQUERY = 1ULL << 3,
+    LEPTRIS_CAP_DTD = 1ULL << 4,
+    LEPTRIS_CAP_SAX = 1ULL << 5,
+    LEPTRIS_CAP_HTML = 1ULL << 6,
+    LEPTRIS_CAP_XINCLUDE = 1ULL << 7,
+    LEPTRIS_CAP_DIFF = 1ULL << 8,
+    LEPTRIS_CAP_DIGEST = 1ULL << 9,
+    LEPTRIS_CAP_XSD = 1ULL << 10,
+    LEPTRIS_CAP_XSD_SET = 1ULL << 11,
+    LEPTRIS_CAP_RELAXNG = 1ULL << 12,
+    LEPTRIS_CAP_SCHEMATRON = 1ULL << 13,
+    LEPTRIS_CAP_XSLT = 1ULL << 14,
+    LEPTRIS_CAP_DESCRIPTOR = 1ULL << 15,
+    LEPTRIS_CAP_NS_SNAPSHOT_BULK = 1ULL << 16,
+    LEPTRIS_CAP_CHILDREN_BATCH = 1ULL << 17,
+    LEPTRIS_CAP_NAME_COMPARE = 1ULL << 18,
+    LEPTRIS_CAP_VERSION = 1ULL << 19,
+    /* build-conditional */
+    LEPTRIS_CAP_COLLATION_DUCET = 1ULL << 20,
+    LEPTRIS_CAP_UNICODE_UTF8PROC = 1ULL << 21,
+    LEPTRIS_CAP_ENCODING_ICONV = 1ULL << 22,
+    LEPTRIS_CAP_SIMD_AVX2 = 1ULL << 23,
+    /* LEPTRIS_PARSE_KEEP_ENTITY_REFS yields entity references as
+     * first-class ENTITY_REF nodes (segments split around the five
+     * built-ins and custom named references; leptris#1904). */
+    LEPTRIS_CAP_ENTITY_REF_NODES = 1ULL << 24
+};
+
+/* Descriptor shape version: 1. Bump when the STRUCT changes or a
+ * bit is retired (never expected — bits append). */
+#define LEPTRIS_CAPS_DESCRIPTOR_VERSION 1u
+
+typedef struct leptris_capabilities {
+    unsigned long long caps;
+    unsigned descriptor_version;
+} LeptrisCapabilities;
+
 /* ============================================================================
  * Memory Allocation Function Types
  * ============================================================================ */

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

@@ -4230,6 +4230,12 @@ LEPTRIS_API const char* leptris_version(void);
  */
 LEPTRIS_API void leptris_version_components(int* major, int* minor, int* patch);
 
+/* leptris#1905: the capability descriptor — what this installed
+ * engine serves, as a versioned bitset (LEPTRIS_CAP_*). Query once
+ * at attach; new capabilities append bits (the descriptor version
+ * gates shape changes). Thread-safe: pure, allocation-free. */
+LEPTRIS_API LeptrisCapabilities leptris_capabilities(void);
+
 /**
  * Release this thread's libleptris caches
  *

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

@@ -72,6 +72,37 @@ LEPTRIS_API void leptris_version_components(int* major, int* minor, int* patch)
     if (patch) *patch = LEPTRIS_VERSION_PATCH;
 }
 
+/* leptris#1905: the capability descriptor. Unconditional faces are
+ * always compiled into this library; the build-conditional bits
+ * follow the same macros the build system defines for the sources
+ * — the descriptor cannot drift from the binary it ships in. */
+LEPTRIS_API LeptrisCapabilities leptris_capabilities(void) {
+    LeptrisCapabilities c;
+    c.caps = LEPTRIS_CAP_PARSE | LEPTRIS_CAP_DOM | LEPTRIS_CAP_XPATH |
+             LEPTRIS_CAP_XQUERY | LEPTRIS_CAP_DTD | LEPTRIS_CAP_SAX |
+             LEPTRIS_CAP_HTML | LEPTRIS_CAP_XINCLUDE | LEPTRIS_CAP_DIFF |
+             LEPTRIS_CAP_DIGEST | LEPTRIS_CAP_XSD | LEPTRIS_CAP_XSD_SET |
+             LEPTRIS_CAP_RELAXNG | LEPTRIS_CAP_SCHEMATRON |
+             LEPTRIS_CAP_XSLT | LEPTRIS_CAP_DESCRIPTOR |
+             LEPTRIS_CAP_NS_SNAPSHOT_BULK | LEPTRIS_CAP_CHILDREN_BATCH |
+             LEPTRIS_CAP_NAME_COMPARE | LEPTRIS_CAP_VERSION |
+             LEPTRIS_CAP_ENTITY_REF_NODES;
+#if defined(LEPTRIS_HAS_DUCET)
+    c.caps |= LEPTRIS_CAP_COLLATION_DUCET;
+#endif
+#if defined(LEPTRIS_HAS_UTF8PROC)
+    c.caps |= LEPTRIS_CAP_UNICODE_UTF8PROC;
+#endif
+#if defined(LEPTRIS_HAS_ICONV)
+    c.caps |= LEPTRIS_CAP_ENCODING_ICONV;
+#endif
+#if defined(LEPTRIS_HAS_AVX2_BUILD)
+    c.caps |= LEPTRIS_CAP_SIMD_AVX2;
+#endif
+    c.descriptor_version = LEPTRIS_CAPS_DESCRIPTOR_VERSION;
+    return c;
+}
+
 LEPTRIS_API void leptris_thread_cleanup(void) {
     leptris_xpath_drain_thread_caches();
     leptris_root_doc_drain_thread_caches();

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

@@ -643,44 +643,26 @@ static XPathASTNode* parse_string_concat_expr(XPathParser* parser) {
 }
 
 /* True when the token AFTER a bare value-comparison keyword may
- * START an operand. The base list covers scalars/parens; an NCName
- * qualifies ONLY when it opens a function call — a bare NCName
- * follower stays a path step (XPath 1.0 name-test precedence). */
+ * START an operand. Scalars, parens, variables, and (leptris#1910)
+ * every path start: a bare NCName/QName is an element name test in
+ * operand position, and adjacent name tokens are never a valid
+ * path continuation, so the keyword reading is unambiguous
+ * (`w le h` in xs:assert/xs:alternative tests). */
 static int kw_operand_boundary(XPathParser* parser, XPathToken* nx) {
+    (void)parser;
     if (!nx) return 1;
     switch (nx->type) {
         case TOK_EOF: case TOK_RPAREN: case TOK_COMMA:
         case TOK_RBRACE: case TOK_LBRACE: case TOK_NUMBER:
         case TOK_STRING: case TOK_DOLLAR: case TOK_LPAREN:
         case TOK_MINUS: case TOK_PLUS:
+        case TOK_SLASH: case TOK_DOUBLE_SLASH: case TOK_AT:
+        case TOK_DOT: case TOK_DOUBLE_DOT: case TOK_STAR:
             return 1;
         case TOK_QNAME:
-            /* prefixed call: QName '(' — a lone QName stays a path
-             * step (name-test precedence, like NCName). */
-        case TOK_NCNAME: {
-            /* unprefixed call: name '(' ... prefixed call:
-             * name ':' name '(' (the QT3 corpus writes fn:year-...). */
-            XPathToken* nnx =
-                parser->token_pos + 2 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 2]
-                    : NULL;
-            if (nnx && nnx->type == TOK_LPAREN) return 1;
-            XPathToken* t3 =
-                parser->token_pos + 3 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 3]
-                    : NULL;
-            XPathToken* t4 =
-                parser->token_pos + 4 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 4]
-                    : NULL;
-            XPathToken* t5 =
-                parser->token_pos + 5 < parser->token_count
-                    ? &parser->tokens[parser->token_pos + 5]
-                    : NULL;
-            return nnx && nnx->type == TOK_COLON && t3 &&
-                   t3->type == TOK_NCNAME && t4 &&
-                   t4->type == TOK_LPAREN && t5;
-        }
+        case TOK_NCNAME:
+            /* name test, function call, or prefixed call */
+            return 1;
         default:
             return 0;
     }

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

@@ -51,7 +51,11 @@ struct leptris_xsd_schema {
     char* target_ns;
     int version_11;    /* xs:schema @version = "1.1" */
     char* base_dir;    /* schemaLocation resolution (file compile) */
-    int include_depth; /* include/import recursion guard */
+    int include_depth;
+    /* xs:override body capture replaces same-named components: the
+     * attributeGroup pre-pass must re-register defs the base
+     * already captured (leptris#1913). */
+    int capture_force; /* include/import recursion guard */
     /* leptris#1644: already-captured schema units (canonical
      * location per entry) — the include/import DAG is dense and
      * cyclic; without this set every DAG path re-parses and
@@ -100,6 +104,7 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                              LeptrisElement root);
 static char* xsd_read_file(const char* path, size_t* out_len);
 static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src);
+static void xsd_resolve_pending_attr_refs(struct leptris_xsd_schema* s);
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
                                  const char* name, char* any_attr_ns,
@@ -678,7 +683,7 @@ static int xsd_is_declaration(const char* local, const char* uri) {
         "element",    "attribute",    "simpleType", "complexType",
         "group",      "attributeGroup", "notation", "include",
         "defaultOpenContent",
-        "import",     "redefine",     NULL
+        "import",     "redefine",     "override", NULL
     };
     for (int i = 0; names[i]; i++)
         if (strcmp(local, names[i]) == 0) return 1;
@@ -1809,7 +1814,8 @@ static void xsd_collect_decls_doc(LeptrisElement root, const char* eff_tns,
         if (!l || !u || strcmp(u, XSD_NS) != 0)
             continue;
         int is_inc = (strcmp(l, "include") == 0 ||
-                      strcmp(l, "redefine") == 0);
+                      strcmp(l, "redefine") == 0 ||
+                      strcmp(l, "override") == 0);
         int is_imp = (strcmp(l, "import") == 0);
         if (!is_inc && !is_imp) continue;
         const char* loc = leptris_element_attribute(c, "schemaLocation");
@@ -1852,6 +1858,13 @@ static void xsd_collect_decls_doc(LeptrisElement root, const char* eff_tns,
             xsd_collect_decls_doc(subroot, eff, sub_base, decls, n, max,
                                   claimed, nclaimed, cmax, depth + 1);
         }
+        /* leptris#1913: an xs:override body's declarations belong
+         * to the symbol space too — walk the override element as a
+         * pseudo-root (it has no include/import children of its
+         * own). */
+        if (strcmp(l, "override") == 0)
+            xsd_collect_decls_doc(c, eff_tns, base_dir, decls, n, max,
+                                  claimed, nclaimed, cmax, depth + 1);
         leptris_document_free(sub);
     }
 }
@@ -1959,8 +1972,24 @@ static LeptrisXsdSchema xsd_compile_impl(const char* xsd_text,
     s->target_ns = xsd_strdup(
         leptris_element_attribute(root, "targetNamespace"));
     {
+        /* XSD 1.1 §4.3 schema versioning: the W3C suite and the
+         * binding ecosystem mark 1.1 with vc:minVersion (the
+         * versioning namespace); the plain version attribute is
+         * the other legal spelling. vc:maxVersion below 1.1 pins
+         * a 1.0 processor target regardless. leptris#1910/#1911:
+         * reading only @version silently compiled asserts and
+         * alternatives away for every vc-marked schema. */
         const char* ver = leptris_element_attribute(root, "version");
-        s->version_11 = (ver && strcmp(ver, "1.1") == 0);
+        const char* vmin = leptris_element_attribute_ns(
+            root, "http://www.w3.org/2001/XMLSchema-versioning",
+            "minVersion");
+        const char* vmax = leptris_element_attribute_ns(
+            root, "http://www.w3.org/2001/XMLSchema-versioning",
+            "maxVersion");
+        int is11 = (ver && strcmp(ver, "1.1") == 0) ||
+                   (vmin && strcmp(vmin, "1.1") == 0);
+        if (vmax && strcmp(vmax, "1.0") == 0) is11 = 0;
+        s->version_11 = is11;
     }
 
     const char* local = NULL;
@@ -2021,6 +2050,7 @@ static LeptrisXsdSchema xsd_compile_impl(const char* xsd_text,
 
     xsd_capture_root(s, root);
     xsd_resolve_extension_bases(s);
+    xsd_resolve_pending_attr_refs(s);
 
     leptris_document_free(doc);
     return s;
@@ -2245,7 +2275,8 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
 
         if (strcmp(local, "include") == 0 ||
             strcmp(local, "import") == 0 ||
-            strcmp(local, "redefine") == 0) {
+            strcmp(local, "redefine") == 0 ||
+            strcmp(local, "override") == 0) {
             const char* loc = leptris_element_attribute(
                 (LeptrisElement)n, "schemaLocation");
             if (loc && s->base_dir && s->include_depth < 16) {
@@ -2312,6 +2343,20 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                             if (sub_ns) free(sub_ns);
                             s->target_ns = saved_ns;
                         }
+                        /* leptris#1913 (XSD 1.1 §I.4): the override
+                         * element's OWN declaration children
+                         * replace same-named components of the base
+                         * just captured — capture them AFTER the
+                         * base so the lookup ladder (head-first)
+                         * sees the replacements. */
+                        if (subroot && same_ns &&
+                            strcmp(local, "override") == 0) {
+                            s->include_depth++;
+                            s->capture_force = 1;
+                            xsd_capture_root(s, (LeptrisElement)n);
+                            s->capture_force = 0;
+                            s->include_depth--;
+                        }
                         leptris_document_free(sub);
                     }
                     free(text);
@@ -2446,7 +2491,8 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
                 XsdAttrGroupDef* seen = s->attr_groups;
                 for (; seen; seen = seen->next)
                     if (strcmp(seen->name, nm) == 0) break;
-                if (!seen) xsd_capture_attr_group_def(s, (LeptrisElement)n, nm);
+                if (!seen || s->capture_force)
+                    xsd_capture_attr_group_def(s, (LeptrisElement)n, nm);
             }
         } else if (strcmp(local, "group") == 0 && uri && !strcmp(uri, XSD_NS)) {
             const char* nm =
@@ -3109,6 +3155,7 @@ static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src) {
         d->type = xsd_strdup(src->type);
         d->fixed = xsd_strdup(src->fixed);
         d->required = src->required;
+        d->pending_ref = src->pending_ref;
         if (tail)
             tail->next = d;
         else
@@ -3118,6 +3165,51 @@ static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src) {
     return head;
 }
 
+/* leptris-ruby#569: re-resolve the rows the #1880 attributeGroup
+ * pre-pass captured before the import chase had registered the
+ * referenced unit's top-level attributes. Idempotent; pending rows
+ * that never resolve keep declaring their name (untyped) — the
+ * compile-time ref check already rejects true danglers loudly. */
+#define XSD_PENDING_REF 1
+#define XSD_PENDING_USE 2
+static void xsd_resolve_pending_attr_refs(struct leptris_xsd_schema* s) {
+    if (!s) return;
+    int progressed = 1;
+    while (progressed) {
+        progressed = 0;
+        for (XsdAttrGroupDef* g = s->attr_groups; g; g = g->next)
+            for (XsdAttrDecl* a = g->attrs; a; a = a->next) {
+                if (!(a->pending_ref & XSD_PENDING_REF) || !a->name)
+                    continue;
+                const XsdAttrDecl* src = xsd_find_top_attr(s, a->name);
+                if (!src) continue;
+                free(a->type);
+                free(a->fixed);
+                a->type = xsd_strdup(src->type);
+                a->fixed = xsd_strdup(src->fixed);
+                if (!(a->pending_ref & XSD_PENDING_USE))
+                    a->required = src->required;
+                a->pending_ref &= ~XSD_PENDING_REF;
+                progressed = 1;
+            }
+        for (XsdTypeAttrs* t = s->type_attrs; t; t = t->next)
+            for (XsdAttrDecl* a = t->attrs; a; a = a->next) {
+                if (!(a->pending_ref & XSD_PENDING_REF) || !a->name)
+                    continue;
+                const XsdAttrDecl* src = xsd_find_top_attr(s, a->name);
+                if (!src) continue;
+                free(a->type);
+                free(a->fixed);
+                a->type = xsd_strdup(src->type);
+                a->fixed = xsd_strdup(src->fixed);
+                if (!(a->pending_ref & XSD_PENDING_USE))
+                    a->required = src->required;
+                a->pending_ref &= ~XSD_PENDING_REF;
+                progressed = 1;
+            }
+    }
+}
+
 /* Capture the attribute rows of a complexType or attributeGroup:
  * named rows, inline anonymous simpleTypes (synthesized slots),
  * refs to top-level attributes, and attributeGroup refs. */
@@ -3185,16 +3277,31 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
                     leptris_element_attribute(ae, "ref"));
                 const XsdAttrDecl* src =
                     ref ? xsd_find_top_attr(s, ref) : NULL;
-                if (!src) {
+                if (!src && !ref) {
                     free(d);
                     continue;
                 }
-                d->name = xsd_strdup(src->name);
-                d->type = xsd_strdup(src->type);
-                d->fixed = xsd_strdup(src->fixed);
-                d->required = use
-                                  ? (strcmp(use, "required") == 0)
-                                  : src->required;
+                if (!src) {
+                    /* leptris-ruby#569: the #1880 pre-pass captures
+                     * attributeGroup defs BEFORE the import chase
+                     * registers the referenced unit's globals — an
+                     * unresolved ref used to be silently DROPPED
+                     * here, hole-punching the type's rows (a:blip
+                     * @r:embed "not declared (strict)") or leaving
+                     * the type attribute-less so the strict walk
+                     * never ran. Keep the row pending; the
+                     * post-capture fixup resolves it. */
+                    d->name = xsd_strdup(xsd_local_name(ref));
+                    d->pending_ref = use ? 3 : 1;
+                    d->required = (use && strcmp(use, "required") == 0);
+                } else {
+                    d->name = xsd_strdup(src->name);
+                    d->type = xsd_strdup(src->type);
+                    d->fixed = xsd_strdup(src->fixed);
+                    d->required = use
+                                      ? (strcmp(use, "required") == 0)
+                                      : src->required;
+                }
             }
             if (tail)
                 tail->next = d;
@@ -3802,5 +3909,6 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile_set(
         s->base_dir = saved;
     }
     xsd_resolve_extension_bases(s);
+    xsd_resolve_pending_attr_refs(s);
     return s;
 }

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

@@ -197,6 +197,15 @@ typedef struct xsd_attr_decl {
     char* type;  /* builtin ref or local simpleType name (NULL=anySimple) */
     char* fixed; /* #FIXED value: present values must string-equal it */
     int required;
+    /* leptris-ruby#569: the row came from <xs:attribute ref=.../>
+     * whose global declaration was not yet captured (the #1880
+     * attributeGroup pre-pass runs before the import chase). The
+     * row is kept — never silently dropped — and xsd_compile_impl
+     * re-resolves it once the full merged capture has run
+     * (xsd_resolve_pending_attr_refs). bit 0 = ref unresolved,
+     * bit 1 = the ref carried its own use= (it overrides the
+     * declaration's). */
+    int pending_ref;
     struct xsd_attr_decl* next;
 } XsdAttrDecl;
 

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

@@ -120,11 +120,28 @@ leptris_add_test(test_large_docs parser/test_large_documents.cpp)
 leptris_add_test(test_encoding   parser/test_encoding.cpp)
 leptris_add_test(test_dom        dom/test_dom.cpp)
 leptris_add_test(test_element_children dom/test_element_children.cpp)
+leptris_add_test(test_entity_refs dom/test_entity_refs.cpp)
 leptris_add_test(test_namespace_cache dom/test_namespace_cache.cpp)
 leptris_add_test(test_map_lifecycle dom/test_map_lifecycle.cpp)
 leptris_add_test(test_simd_count parser/test_simd_count.cpp)
 leptris_add_test(test_ws_shape    parser/test_whitespace_shape.cpp)
 leptris_add_test(test_descriptor abi/test_descriptor.cpp)
+leptris_add_test(test_capabilities abi/test_capabilities.cpp)
+# The capability descriptor's build-conditional bits follow the
+# engine's PUBLIC macros, which do not flow through the object
+# aggregation (same mirror as test_qt3 below).
+if(LEPTRIS_ENABLE_DUCET)
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_DUCET=1)
+endif()
+if(LEPTRIS_ENABLE_UTF8PROC)
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_UTF8PROC=1)
+endif()
+if(LEPTRIS_ENABLE_ICONV)
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_ICONV=1)
+endif()
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|AMD64|i[3-6]86)")
+    target_compile_definitions(test_capabilities PRIVATE LEPTRIS_HAS_AVX2_BUILD=1)
+endif()
 leptris_add_test(test_document_children dom/test_document_children.cpp)
 leptris_add_test(test_vtable     dom/test_vtable.cpp)
 leptris_add_test(test_node_surface_parity dom/test_node_surface_parity.cpp)

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

@@ -0,0 +1,112 @@
+// leptris#1905: one call answering what this installed engine
+// serves. The descriptor is a versioned bitset — new capabilities
+// APPEND bits, never reorder or repack (a reorder bumps
+// LEPTRIS_CAPS_DESCRIPTOR_VERSION).
+#include <leptris.h>
+#include <leptris/descriptor.h>
+#include <leptris/dtd.h>
+#include <leptris/html.h>
+#include <leptris/sax/sax.h>
+#include <leptris/xpath/xpath.h>
+#include <leptris/xquery/xquery.h>
+
+#include <gtest/gtest.h>
+
+// Anchor law: each unconditional bit's face symbol is REFERENCED
+// here — a descriptor bit without a real, linked face fails the
+// BUILD of this test, not just the assertion.
+namespace caps_anchors {
+void* const kParse = (void*)&leptris_parse_string;
+void* const kDom = (void*)&leptris_document_root;
+void* const kXpath = (void*)&leptris_xpath_eval;
+void* const kXquery = (void*)&leptris_xquery_eval;
+void* const kDtd = (void*)&leptris_dtd_parse;
+void* const kSax = (void*)&leptris_sax_parse;
+void* const kHtml = (void*)&leptris_parse_html_string;
+void* const kXinclude = (void*)&leptris_xinclude_process;
+void* const kDiff = (void*)&leptris_diff;
+void* const kDigest = (void*)&leptris_node_digest;
+void* const kXsd = (void*)&leptris_xsd_compile;
+void* const kXsdSet = (void*)&leptris_xsd_compile_set;
+void* const kRelaxng = (void*)&leptris_rng_parse;
+void* const kSchematron = (void*)&leptris_schematron_parse;
+void* const kXslt = (void*)&leptris_xslt_parse;
+void* const kDescriptor = (void*)&leptris_plan_result_build_packed;
+void* const kNsSnapshot = (void*)&leptris_element_namespace_declarations_snapshot;
+void* const kChildrenBatch = (void*)&leptris_element_children_batch;
+void* const kNameCompare = (void*)&leptris_node_name_compare;
+void* const kVersion = (void*)&leptris_version;
+void* const kEntityRefs = (void*)&leptris_entity_ref_node_name;
+}  // namespace caps_anchors
+
+TEST(LeptrisCapabilities, DescriptorVersionIsCurrent) {
+    LeptrisCapabilities c = leptris_capabilities();
+    EXPECT_EQ(c.descriptor_version, LEPTRIS_CAPS_DESCRIPTOR_VERSION);
+}
+
+TEST(LeptrisCapabilities, UnconditionalFacesAreSet) {
+    LeptrisCapabilities c = leptris_capabilities();
+    EXPECT_NE(c.caps & LEPTRIS_CAP_PARSE, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DOM, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XPATH, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XQUERY, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DTD, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_SAX, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_HTML, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XINCLUDE, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DIFF, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DIGEST, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XSD, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XSD_SET, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_RELAXNG, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_SCHEMATRON, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_XSLT, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_DESCRIPTOR, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_NS_SNAPSHOT_BULK, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_CHILDREN_BATCH, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_NAME_COMPARE, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_VERSION, 0ULL);
+    EXPECT_NE(c.caps & LEPTRIS_CAP_ENTITY_REF_NODES, 0ULL);
+}
+
+TEST(LeptrisCapabilities, BuildConditionalBitsMatchTheBuild) {
+    LeptrisCapabilities c = leptris_capabilities();
+#if defined(LEPTRIS_HAS_DUCET)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_COLLATION_DUCET, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_COLLATION_DUCET, 0ULL);
+#endif
+#if defined(LEPTRIS_HAS_UTF8PROC)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_UNICODE_UTF8PROC, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_UNICODE_UTF8PROC, 0ULL);
+#endif
+#if defined(LEPTRIS_HAS_ICONV)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_ENCODING_ICONV, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_ENCODING_ICONV, 0ULL);
+#endif
+#if defined(LEPTRIS_HAS_AVX2_BUILD)
+    EXPECT_NE(c.caps & LEPTRIS_CAP_SIMD_AVX2, 0ULL);
+#else
+    EXPECT_EQ(c.caps & LEPTRIS_CAP_SIMD_AVX2, 0ULL);
+#endif
+}
+
+TEST(LeptrisCapabilities, NoUnknownBits) {
+    LeptrisCapabilities c = leptris_capabilities();
+    constexpr unsigned long long kKnown =
+        LEPTRIS_CAP_PARSE | LEPTRIS_CAP_DOM | LEPTRIS_CAP_XPATH |
+        LEPTRIS_CAP_XQUERY | LEPTRIS_CAP_DTD | LEPTRIS_CAP_SAX |
+        LEPTRIS_CAP_HTML | LEPTRIS_CAP_XINCLUDE | LEPTRIS_CAP_DIFF |
+        LEPTRIS_CAP_DIGEST | LEPTRIS_CAP_XSD | LEPTRIS_CAP_XSD_SET |
+        LEPTRIS_CAP_RELAXNG | LEPTRIS_CAP_SCHEMATRON | LEPTRIS_CAP_XSLT |
+        LEPTRIS_CAP_DESCRIPTOR | LEPTRIS_CAP_NS_SNAPSHOT_BULK |
+        LEPTRIS_CAP_CHILDREN_BATCH | LEPTRIS_CAP_NAME_COMPARE |
+        LEPTRIS_CAP_VERSION | LEPTRIS_CAP_COLLATION_DUCET |
+        LEPTRIS_CAP_UNICODE_UTF8PROC | LEPTRIS_CAP_ENCODING_ICONV |
+        LEPTRIS_CAP_SIMD_AVX2 | LEPTRIS_CAP_ENTITY_REF_NODES;
+    EXPECT_EQ(c.caps & ~kKnown, 0ULL)
+        << "an unknown bit is set — the descriptor grew without "
+           "bumping LEPTRIS_CAPS_DESCRIPTOR_VERSION";
+}

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

@@ -0,0 +1,111 @@
+// leptris#1904: LEPTRIS_PARSE_KEEP_ENTITY_REFS yields entity
+// references as FIRST-CLASS nodes — segments split around the five
+// built-ins and custom named references, numeric character
+// references folded into text (they are character references, not
+// entity references, per XML 1.0 §4.1). The DOM the binding
+// consumes: text / entity-ref / text / ... with string-value,
+// serialization, and XPath walking the expanded value.
+#include <gtest/gtest.h>
+#include <leptris.h>
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace {
+
+struct ChildInfo {
+    int type;
+    std::string text;
+    std::string name;
+};
+
+std::vector<ChildInfo> children_of(LeptrisElement e) {
+    std::vector<ChildInfo> rows;
+    for (LeptrisNodeRef c = leptris_node_first_child(
+             leptris_element_as_node(e));
+         c; c = leptris_node_next_sibling(c)) {
+        ChildInfo row;
+        row.type = (int)leptris_node_get_type(c);
+        if (row.type == LEPTRIS_NODE_TYPE_TEXT)
+            row.text = leptris_text_node_get_content(c);
+        if (row.type == LEPTRIS_NODE_TYPE_ENTITY_REF)
+            row.name = leptris_entity_ref_node_name(c);
+        rows.push_back(row);
+    }
+    return rows;
+}
+
+}  // namespace
+
+TEST(EntityRefNodes, BuiltinsBecomeNodes) {
+    const char* xml = "<a>x&amp;y&lt;z&gt;w</a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement a = leptris_document_root(doc);
+    std::vector<ChildInfo> kids = children_of(a);
+    ASSERT_EQ(kids.size(), 7u);
+    EXPECT_EQ(kids[0].type, (int)LEPTRIS_NODE_TYPE_TEXT);
+    EXPECT_EQ(kids[0].text, "x");
+    EXPECT_EQ(kids[1].type, (int)LEPTRIS_NODE_TYPE_ENTITY_REF);
+    EXPECT_EQ(kids[1].name, "amp");
+    EXPECT_EQ(kids[2].text, "y");
+    EXPECT_EQ(kids[3].name, "lt");
+    EXPECT_EQ(kids[4].text, "z");
+    EXPECT_EQ(kids[5].name, "gt");
+    EXPECT_EQ(kids[6].text, "w");
+    leptris_document_free(doc);
+}
+
+TEST(EntityRefNodes, NumericCharacterRefsStayText) {
+    /* XML 1.0 §4.1: character references are NOT entity references. */
+    const char* xml = "<a>&#65;&#x42;</a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement a = leptris_document_root(doc);
+    std::vector<ChildInfo> kids = children_of(a);
+    ASSERT_EQ(kids.size(), 1u);
+    EXPECT_EQ(kids[0].type, (int)LEPTRIS_NODE_TYPE_TEXT);
+    EXPECT_EQ(kids[0].text, "AB");
+    leptris_document_free(doc);
+}
+
+TEST(EntityRefNodes, StringValueSerializationAndXPathAgree) {
+    const char* xml = "<a>x&amp;y&lt;z</a>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement a = leptris_document_root(doc);
+    EXPECT_STREQ(leptris_element_text(a), "x&y<z");
+    char* ser = leptris_document_serialize(doc, NULL);
+    ASSERT_NE(ser, nullptr);
+    EXPECT_STREQ(ser, "<a>x&amp;y&lt;z</a>");
+    leptris_free_string(ser);
+    LeptrisXPathResult r = leptris_xpath_eval(doc, NULL, "string(/a)");
+    ASSERT_NE(r, nullptr);
+    char* sv = leptris_xpath_result_string(r);
+    EXPECT_STREQ(sv, "x&y<z");
+    leptris_free_string(sv);
+    leptris_xpath_result_free(r);
+    leptris_document_free(doc);
+}
+
+TEST(EntityRefNodes, CustomNamedRefsAreNodes) {
+    const char* xml =
+        "<!DOCTYPE r [<!ENTITY foo \"x\">]><r>a&foo;b</r>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string_flags(
+        xml, strlen(xml), LEPTRIS_PARSE_KEEP_ENTITY_REFS, &st);
+    ASSERT_NE(doc, (LeptrisDocument)0);
+    LeptrisElement r = leptris_document_root(doc);
+    std::vector<ChildInfo> kids = children_of(r);
+    ASSERT_EQ(kids.size(), 3u);
+    EXPECT_EQ(kids[1].type, (int)LEPTRIS_NODE_TYPE_ENTITY_REF);
+    EXPECT_EQ(kids[1].name, "foo");
+    EXPECT_STREQ(leptris_element_text(r), "axb");
+    leptris_document_free(doc);
+}

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

@@ -7,6 +7,7 @@
 #include <gtest/gtest.h>
 
 #include <cstdio>
+#include <fstream>
 #include <cstring>
 #include <string>
 #include <algorithm>
@@ -3680,3 +3681,325 @@ TEST(XsdContent, Issue1894ReproStaysUnderCapAndCorrect) {
     EXPECT_EQ(leptris_xsd_error_count(s), 0u);
     leptris_xsd_free(s);
 }
+
+
+/* leptris-ruby#569 family: cross-namespace references into an
+ * IMPORTED unit. The importing schema must declare xmlns="urn:a"
+ * as the DEFAULT namespace — unprefixed ref QNames resolve to
+ * no-namespace otherwise (spec behavior, the #1901 repro lesson). */
+TEST(XsdCrossNs, AttributeRefIntoImportedUnitResolves) {
+    const char* rel =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:r\" elementFormDefault=\"qualified\">"
+        "<xs:simpleType name=\"ST_RelId\">"
+        "<xs:restriction base=\"xs:string\"/></xs:simpleType>"
+        "<xs:attribute name=\"embed\" type=\"ST_RelId\"/>"
+        "</xs:schema>";
+    const char* main =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:r=\"urn:r\" xmlns=\"urn:a\" targetNamespace=\"urn:a\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:import namespace=\"urn:r\" schemaLocation=\"blip_repro_rel.xsd\"/>"
+        "<xs:attributeGroup name=\"AG_Blob\">"
+        "<xs:attribute ref=\"r:embed\" use=\"optional\"/>"
+        "</xs:attributeGroup>"
+        "<xs:complexType name=\"CT_Blip\">"
+        "<xs:sequence><xs:element name=\"e\" type=\"xs:string\""
+        " minOccurs=\"0\"/></xs:sequence>"
+        "<xs:attributeGroup ref=\"AG_Blob\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"blip\" type=\"CT_Blip\"/>"
+        "</xs:schema>";
+
+    const char* dir = std::getenv("TMPDIR");
+    std::string base = dir ? dir : "/tmp";
+    std::string rel_path = base + "/blip_repro_rel.xsd";
+    std::string main_path = base + "/blip_repro_main.xsd";
+    {
+        std::ofstream f(rel_path);
+        f << rel;
+    }
+    {
+        std::ofstream f(main_path);
+        f << main;
+    }
+    const char* paths[2] = {rel_path.c_str(), main_path.c_str()};
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_set(paths, 2, &st);
+    if (st != LEPTRIS_OK || s == (LeptrisXsdSchema)0) {
+        const char* err = s ? leptris_xsd_error(s) : "(no handle)";
+        GTEST_FAIL() << "compile_set failed st=" << (int)st
+                     << " err=" << (err ? err : "(null)");
+    }
+
+    EXPECT_EQ(validate_compiled(s,
+                "<a:blip xmlns:a=\"urn:a\" xmlns:r=\"urn:r\""
+                " r:embed=\"rId2\"><e>x</e></a:blip>"),
+              1)
+        << "cross-unit attribute ref must resolve: "
+        << leptris_xsd_error(s);
+    std::remove(rel_path.c_str());
+    std::remove(main_path.c_str());
+    leptris_xsd_free(s);
+}
+
+/* Same shape through the single-document import chase. */
+TEST(XsdCrossNs, SingleDocImportChaseResolves) {
+    const char* rel =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:r\" elementFormDefault=\"qualified\">"
+        "<xs:simpleType name=\"ST_RelId\">"
+        "<xs:restriction base=\"xs:string\"/></xs:simpleType>"
+        "<xs:attribute name=\"embed\" type=\"ST_RelId\"/>"
+        "</xs:schema>";
+    const char* main =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:r=\"urn:r\" xmlns=\"urn:a\" targetNamespace=\"urn:a\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:import namespace=\"urn:r\""
+        " schemaLocation=\"blip_repro_rel.xsd\"/>"
+        "<xs:attributeGroup name=\"AG_Blob\">"
+        "<xs:attribute ref=\"r:embed\" use=\"optional\"/>"
+        "</xs:attributeGroup>"
+        "<xs:complexType name=\"CT_Blip\">"
+        "<xs:sequence><xs:element name=\"e\" type=\"xs:string\""
+        " minOccurs=\"0\"/></xs:sequence>"
+        "<xs:attributeGroup ref=\"AG_Blob\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"blip\" type=\"CT_Blip\"/>"
+        "</xs:schema>";
+
+    const char* dir = std::getenv("TMPDIR");
+    std::string base = dir ? dir : "/tmp";
+    std::string rel_path = base + "/blip_repro_rel.xsd";
+    std::string main_path = base + "/blip_repro_main.xsd";
+    {
+        std::ofstream f(rel_path);
+        f << rel;
+    }
+    {
+        std::ofstream f(main_path);
+        f << main;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file(main_path.c_str(), &st);
+    if (st != LEPTRIS_OK || s == (LeptrisXsdSchema)0) {
+        const char* err = s ? leptris_xsd_error(s) : "(no handle)";
+        GTEST_FAIL() << "single-doc compile failed st=" << (int)st
+                     << " err=" << (err ? err : "(null)");
+    }
+
+    EXPECT_EQ(validate_compiled(s,
+                "<a:blip xmlns:a=\"urn:a\" xmlns:r=\"urn:r\""
+                " r:embed=\"rId2\"><e>x</e></a:blip>"),
+              1)
+        << "import-chase attribute ref must resolve: "
+        << leptris_xsd_error(s);
+    std::remove(rel_path.c_str());
+    std::remove(main_path.c_str());
+    leptris_xsd_free(s);
+}
+
+/* The #569 regression itself: the #1880 attributeGroup pre-pass
+ * captured AG_Blob and resolved its <xs:attribute ref="r:embed"/>
+ * row BEFORE the import chase registered the referenced unit's
+ * r:embed — the row used to be silently dropped, so whole-instance
+ * validation then rejected every a:blip @r:embed ("not declared
+ * (strict)") on the real DrawingML chain. The row must survive as
+ * pending and resolve once the full capture has run. */
+TEST(XsdCrossNs, AttrGroupRefRowResolvedAfterImportChase) {
+    const char* rel =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:r\" elementFormDefault=\"qualified\">"
+        "<xs:attribute name=\"embed\" type=\"xs:string\"/>"
+        "</xs:schema>";
+    const char* main =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " xmlns:r=\"urn:r\" xmlns=\"urn:a\" targetNamespace=\"urn:a\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:import namespace=\"urn:r\" schemaLocation=\"ag569_rel.xsd\"/>"
+        "<xs:attributeGroup name=\"AG_Blob\">"
+        "<xs:attribute ref=\"r:embed\"/>"
+        "</xs:attributeGroup>"
+        "<xs:complexType name=\"CT_Blip\">"
+        "<xs:sequence><xs:element name=\"e\" type=\"xs:string\""
+        " minOccurs=\"0\"/></xs:sequence>"
+        "<xs:attributeGroup ref=\"AG_Blob\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"blip\" type=\"CT_Blip\"/>"
+        "</xs:schema>";
+
+    const char* dir = std::getenv("TMPDIR");
+    std::string base = dir ? dir : "/tmp";
+    std::string rel_path = base + "/ag569_rel.xsd";
+    std::string main_path = base + "/ag569_main.xsd";
+    {
+        std::ofstream f(rel_path);
+        f << rel;
+    }
+    {
+        std::ofstream f(main_path);
+        f << main;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile_file(main_path.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* err = leptris_xsd_error(s);
+    ASSERT_EQ(st, LEPTRIS_OK)
+        << "compile failed: " << (err ? err : "(null)");
+
+    EXPECT_EQ(validate_compiled(s,
+                "<a:blip xmlns:a=\"urn:a\" xmlns:r=\"urn:r\""
+                " r:embed=\"rId2\"><e>x</e></a:blip>"),
+              1)
+        << "pre-pass ref row must resolve after the import chase: "
+        << leptris_xsd_error(s);
+    std::remove(rel_path.c_str());
+    std::remove(main_path.c_str());
+    leptris_xsd_free(s);
+}
+
+/* leptris-ruby#569: compiling the REAL wml.xsd (ISO transitional,
+ * 790 element decls, import chain to the drawing units) must yield
+ * a cleanly compiled schema — a missing import file poisons the
+ * graph (the '{mce}Ignorable' class), and the merged capture must
+ * carry every unit. The schema set is bundled at $BLIP_CHAIN_DIR
+ * in dev; CI skips when the fixture is absent so the suite stays
+ * hermetic. */
+TEST(XsdCrossNs, RealWmlChainCompilesDeclarations) {
+    const char* dir = std::getenv("BLIP_CHAIN_DIR");
+    if (!dir || *dir == '\0') {
+        GTEST_SKIP() << "BLIP_CHAIN_DIR not set";
+    }
+    std::string wml = std::string(dir) + "/wml.xsd";
+    std::ifstream f(wml);
+    ASSERT_TRUE(f.good()) << wml;
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(wml.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* err = leptris_xsd_error(s);
+    EXPECT_EQ(st, LEPTRIS_OK)
+        << "compile status " << (int)st
+        << " decls=" << leptris_xsd_declaration_count(s)
+        << " err=" << (err ? err : "(clean)");
+    leptris_xsd_free(s);
+}
+
+/* leptris#1911: vc:minVersion="1.1" marks the schema as XSD 1.1
+ * (the W3C suite and moxml both use the versioning namespace; the
+ * plain version attribute is the other legal spelling). The
+ * alternative's test selects the type — validation must run the
+ * SELECTED type's content model, in both directions. */
+TEST(Xsd11Gate, CtaSelectsAlternativeType) {
+    const char xsd[] =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " vc:minVersion=\"1.1\""
+        " xmlns:vc=\"http://www.w3.org/2001/XMLSchema-versioning\">"
+        "<xs:element name=\"shape\" type=\"Shape\">"
+        "<xs:alternative test=\"@kind='circle'\" type=\"Circle\"/>"
+        "</xs:element>"
+        "<xs:complexType name=\"Shape\" abstract=\"true\">"
+        "<xs:attribute name=\"kind\" type=\"xs:string\"/>"
+        "</xs:complexType>"
+        "<xs:complexType name=\"Circle\">"
+        "<xs:complexContent><xs:extension base=\"Shape\">"
+        "<xs:sequence><xs:element name=\"r\" type=\"xs:integer\"/>"
+        "</xs:sequence></xs:extension></xs:complexContent>"
+        "</xs:complexType></xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_STREQ(leptris_xsd_version(s), "1.1")
+        << "vc:minVersion must gate the 1.1 feature set";
+    EXPECT_EQ(validate_compiled(s,
+                "<shape kind=\"circle\"><r>4</r></shape>"),
+              1)
+        << "the selected Circle type admits <r>: "
+        << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<shape kind=\"circle\"/>"), 0)
+        << "the selected Circle type REQUIRES <r>";
+    leptris_xsd_free(s);
+}
+
+/* leptris#1910: an xs:assert in a vc:minVersion="1.1" schema must
+ * be evaluated — a violating instance produces an assertion row. */
+TEST(Xsd11Gate, AssertIsEvaluated) {
+    const char xsd[] =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " vc:minVersion=\"1.1\""
+        " xmlns:vc=\"http://www.w3.org/2001/XMLSchema-versioning\">"
+        "<xs:element name=\"size\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"w\" type=\"xs:integer\"/>"
+        "<xs:element name=\"h\" type=\"xs:integer\"/>"
+        "</xs:sequence><xs:assert test=\"w le h\"/></xs:complexType>"
+        "</xs:element></xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<size><w>3</w><h>5</h></size>"), 1)
+        << "satisfying assert must stay valid: "
+        << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<size><w>9</w><h>5</h></size>"), 0)
+        << "violating assert must produce a finding";
+    leptris_xsd_free(s);
+}
+
+/* leptris#1913: xs:override (XSD 1.1 Structures §I.4) — the base
+ * document's declarations load (xs:override is an include-family
+ * chase), then the override body's same-named declarations REPLACE
+ * them. Previously override was absent from the chase condition:
+ * the base never loaded and the body's nested declarations were
+ * never captured — an empty symbol space (decls=0). */
+TEST(Xsd11Gate, OverrideLoadsBaseAndReplacesComponents) {
+    const char* base =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:b\" xmlns=\"urn:b\""
+        " elementFormDefault=\"qualified\">"
+        "<xs:element name=\"doc\" type=\"Doc\"/>"
+        "<xs:complexType name=\"Doc\">"
+        "<xs:sequence><xs:element name=\"a\" type=\"xs:string\"/>"
+        "</xs:sequence></xs:complexType></xs:schema>";
+    const char* ovr =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"urn:b\" xmlns=\"urn:b\""
+        " elementFormDefault=\"qualified\" vc:minVersion=\"1.1\""
+        " xmlns:vc=\"http://www.w3.org/2001/XMLSchema-versioning\">"
+        "<xs:override schemaLocation=\"ovr1913_base.xsd\">"
+        "<xs:complexType name=\"Doc\">"
+        "<xs:sequence><xs:element name=\"b\" type=\"xs:integer\"/>"
+        "</xs:sequence></xs:complexType>"
+        "</xs:override></xs:schema>";
+    const char* dir = std::getenv("TMPDIR");
+    std::string tmp = dir ? dir : "/tmp";
+    std::string base_path = tmp + "/ovr1913_base.xsd";
+    std::string ovr_path = tmp + "/ovr1913_ovr.xsd";
+    {
+        std::ofstream f(base_path);
+        f << base;
+    }
+    {
+        std::ofstream f(ovr_path);
+        f << ovr;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(ovr_path.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_GT(leptris_xsd_declaration_count(s), 0u)
+        << "override must not produce an empty symbol space";
+    EXPECT_EQ(validate_compiled(s, "<doc xmlns=\"urn:b\"><b>1</b></doc>"),
+              1)
+        << "the overridden Doc admits <b>: " << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, "<doc xmlns=\"urn:b\"><a>x</a></doc>"),
+              0)
+        << "the overridden Doc no longer admits <a>";
+    std::remove(base_path.c_str());
+    std::remove(ovr_path.c_str());
+    leptris_xsd_free(s);
+}

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.390",
+  "version": "1.9.394",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.390.3
+  version: 1.9.394.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-29 00:00:00.000000000 Z
+date: 2026-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -744,6 +744,7 @@ files:
 - vendor-src/libleptris/src/man/libleptris.5.adoc
 - vendor-src/libleptris/test/CMakeLists.txt
 - vendor-src/libleptris/test/README.md
+- vendor-src/libleptris/test/abi/test_capabilities.cpp
 - vendor-src/libleptris/test/abi/test_descriptor.cpp
 - vendor-src/libleptris/test/abi/test_doctype_api.cpp
 - vendor-src/libleptris/test/abi/test_dom_deep_copy.cpp
@@ -782,6 +783,7 @@ files:
 - vendor-src/libleptris/test/dom/test_document_children.cpp
 - vendor-src/libleptris/test/dom/test_dom.cpp
 - vendor-src/libleptris/test/dom/test_element_children.cpp
+- vendor-src/libleptris/test/dom/test_entity_refs.cpp
 - vendor-src/libleptris/test/dom/test_map_lifecycle.cpp
 - vendor-src/libleptris/test/dom/test_namespace_cache.cpp
 - vendor-src/libleptris/test/dom/test_node_surface_parity.cpp