leptris 1.9.317.0 → 1.9.318.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f00da545382eef1ba06a526478752ab7f2fb16ecc609a60df9fd88f1cd46aa
-  data.tar.gz: bcc75b40350199bdb1db2dd502d1d6fa1f0398f499bbda57e2aaf4bfe1c4901f
+  metadata.gz: a6c90b838dcbd3165155494321e171c57f470145b959ee40656f40dce4f84897
+  data.tar.gz: 6c7e1f5205388ca6a0f476378e04ca235f48134e02b25873392d59b013a77698
 SHA512:
-  metadata.gz: 75b5e89df9de5a924bfdcce746668b6a2f81114d459de3ec9b8aae72c2acb11a6c1c26c1bd12b2a1227fc19d52873004badd77298ba9f4437877679a8dfa52c2
-  data.tar.gz: b1ed2f7fef77ba8900ab4a323cc1915ef501fd6cc11078b3912187349b7c62b13fb58766c623ad0db6f1a67ed71bcab19c9d5740785a951867769ea8b18d4852
+  metadata.gz: ba48e81789e2dfc95c4c4da2c1c11e7609f2b0f32c9449d65681150ceeb169696bc07a2af29cf12be6514231973a41f580307ec50300dd6b7669ba8489a282ba
+  data.tar.gz: 670b0d55d9fc1a1eb3e4ce595e8505fab58be7803618a39229adfba8ba5a4d7204bdb4b807888022b92ed3f00d93dd6374b73997b01368a1bd584212cc3bc027

data/CHANGELOG.md

@@ -1,3 +1,49 @@
+## [1.9.317.1] - 2026-10-08
+
+### Fixed
+
+- **The published 1.9.317.0 gem predates PR #395**: a parallel
+  release race published 1.9.317.0 from the carrier-folds ride
+  (bd81bdf) before the `:unqualified` ns form merged — this patch
+  release carries the #1560 `ns: :unqualified` DSL (element rows
+  bind the unwritten spelling under both namespace-less and
+  default-xmlns documents; the serialize→re-parse→re-walk
+  round-trip agrees) and the #1565 nested-capture serialization
+  pin to the published artifact line. Main already carried both
+  (PR #395); only the gem lagged.
+
+## [1.9.317.0] - 2026-10-08
+
+### Added — engine sync (libleptris 1.9.315-1.9.317)
+
+- **Unqualified-only ns form for child rows (1.9.317, #1560)**:
+  `ns: :unqualified` matches the UNWRITTEN spelling — an
+  unprefixed child binds under both a namespace-less document and
+  a default-`xmlns` document, and prefixed spellings never bind
+  (the `NS_ANY` superset lutaml-model#932 had to settle for). The
+  form keys on the spelling, not the URI, so
+  serialize→re-parse→re-walk round-trips agree: a default-ns child
+  serializes bare and still re-binds. Element-row only (attributes
+  have no unprefixed namespace by XML rules). `PLAN_NS_UNQUALIFIED
+  = 3` attached; all three shapes + the round-trip spec-pinned.
+
+### Fixed — engine sync (1.9.316)
+
+- **Nested captures emit their own rows (#1565)**: a captured
+  child's rows resolve against the CAPTURING row's
+  `child_plan_index` plan, so a child bound by a nested row (the
+  `w:font`-in-`w:fonts` shape) serializes its own attribute and
+  child rows instead of silently vanishing — pinned through
+  `Descriptor#serialize`.
+
+### Engine sync (1.9.315)
+
+- Carrier-by-pointer node identity for the higher-order argument
+  channel (QT3 fold-left-009/016): element members keep their node
+  pointer, `intersect` dedups by node, single-element results ride
+  the carrier. Engine-internal to the XQuery engine — the binding
+  contract is unchanged (suite carries it).
+
 ## [1.9.314.0] - 2026-10-07
 
 ### Changed — engine sync (libleptris 1.9.314)

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.317"
+LIBLEPTRIS_VERSION = "1.9.318"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.317.0"
+  VERSION = "1.9.318.0"
 end

data/lib/leptris/xml/descriptor.rb

@@ -175,11 +175,15 @@ class Leptris::XML::Descriptor
         case ns
         when nil, :none then [Leptris::XML::FFI::PLAN_NS_NONE, nil]
         when :any then [Leptris::XML::FFI::PLAN_NS_ANY, nil]
+        when :unqualified
+          # libleptris 1.9.317 (#1560): the UNWRITTEN spelling.
+          [Leptris::XML::FFI::PLAN_NS_UNQUALIFIED, nil]
         when Hash
           [Leptris::XML::FFI::PLAN_NS_EXACT,
            anchor_string(anchors, ns.fetch(:exact))]
         else
-          raise ArgumentError, "ns must be :none, :any, or {exact: uri}"
+          raise ArgumentError,
+            "ns must be :none, :any, :unqualified, or {exact: uri}"
         end
       ep[:ns_form] = ns_form
       ep[:ns_uri] = ns_uri
@@ -230,10 +234,14 @@ class Leptris::XML::Descriptor
         # defaults to NONE for backward compatibility. WILDCARD
         # rows (#1552) read an explicit :ns through pad0 (an
         # explicit :none filters no-namespace remainder alone;
-        # unset stays the catch-all ANY default).
+        # unset stays the catch-all ANY default). :unqualified
+        # (libleptris 1.9.317, #1560) matches the unwritten
+        # spelling on element rows — element-row only (attributes
+        # have no unprefixed namespace by XML rules).
         cp[:ns_form] =
           case row[:ns]
           when :any then Leptris::XML::FFI::PLAN_NS_ANY
+          when :unqualified then Leptris::XML::FFI::PLAN_NS_UNQUALIFIED
           when Hash  then Leptris::XML::FFI::PLAN_NS_EXACT
           else         Leptris::XML::FFI::PLAN_NS_NONE
           end

data/lib/leptris/xml/ffi.rb

@@ -157,6 +157,7 @@ module Leptris
       typedef :pointer, :leptris_xpath_ns_set
       typedef :pointer, :leptris_xpath_compiled
       typedef :pointer, :leptris_relaxng
+      typedef :pointer, :leptris_xsd_schema
       typedef :pointer, :leptris_xslt
       typedef :pointer, :leptris_xquery
       typedef :pointer, :leptris_schematron
@@ -380,6 +381,13 @@ module Leptris
       PLAN_NS_NONE = 0
       PLAN_NS_EXACT = 1
       PLAN_NS_ANY = 2
+      # libleptris 1.9.317 (#1560): matches the UNWRITTEN spelling
+      # on element rows — no written prefix, regardless of the
+      # effective namespace URI (binds under both a namespace-less
+      # and a default-xmlns document; prefixed spellings never
+      # bind). Attributes have no unprefixed namespace by XML
+      # rules, so the form is element-row only.
+      PLAN_NS_UNQUALIFIED = 3
 
       PLAN_VALUE_ELEMENT = 0
       PLAN_VALUE_SCALAR = 1
@@ -1276,6 +1284,18 @@ attach_function :leptris_parse_string,
                :column, :int
       end
 
+      # XSD tier-1 (libleptris 1.9.318, #1075): compilation surface —
+      # compile a schema, count its top-level declarations, surface
+      # schema-level errors. Validation is a later tier.
+      attach_function :leptris_xsd_compile,
+        [:string, :size_t, :pointer], :leptris_xsd_schema
+      attach_function :leptris_xsd_free,
+        [:leptris_xsd_schema], :void
+      attach_function :leptris_xsd_declaration_count,
+        [:leptris_xsd_schema], :size_t
+      attach_function :leptris_xsd_error,
+        [:leptris_xsd_schema], UTF8_STRING
+
       attach_function :leptris_rng_parse,
         [:string, :size_t, :pointer], :leptris_relaxng
       attach_function :leptris_rng_parse_file,

data/lib/leptris/xml/xsd.rb

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

data/lib/leptris/xml.rb

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

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.317
+- libleptris v1.9.318
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

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

data/vendor-src/libleptris/CMakeLists.txt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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