leptris 1.9.320.0-arm-linux → 1.9.321.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c9a0179ae0c076cfc42de6b88569425e0f424a43feb4507bd3f07855fed3ca7
-  data.tar.gz: c80d44187d6da051998ea400689ceded6e05f58948de49520f1e0f663f418801
+  metadata.gz: 302f2471b6341b7c0fb55a4e38abf332033d17a1f9050494a0b4f1131c3953cc
+  data.tar.gz: 7c84976af95b097ade4dc4229426b41b7d94660ae184796fbef70e606a5dcd20
 SHA512:
-  metadata.gz: 85e0932ed8e0b6a3e82631df9eb718efd1af051bc8c440e313ff116064c4dacb6bde417ae148a0768734f84dabe3523cc6e6e5e67d5bf776be3ed8af96ae2ddd
-  data.tar.gz: bf3fc27bce9fbbe7934e380ec4f80d60159fd5e84243b77173b608ac31245245c1eec83ecb0086d37f2bedb4c7a69fcf1a057844fa5677dbe8f8fb0db832c779
+  metadata.gz: abe70ccb890c3fbb4fd9fe262837b70615628043730987477c87c91a9da24ec9a80b47bd823abae831645d8163164d1ec798b9b7ece33850fe7d3a61ecaad593
+  data.tar.gz: b8ca3b96073cf922093da36e10f62af0e62814f4ff8b89b5cbb1a0a09b3c151471c5a4d0fed2dcc9d40982230516d7a8ab642a11184b7e00d4f1de07b49ebed7

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [1.9.321.0] - 2026-10-08
+
+### Added — engine sync (libleptris 1.9.321)
+
+- **XSD instance validation, slices 3-4 (#1075)**:
+  `Schema#valid?` walks the whole document — element declarations,
+  attribute rows (required + typed + lenient qualified spellings),
+  text lexical checks, child content models through a Thompson NFA
+  (linear in children x states, no backtracking blowup);
+  `Schema#validate_errors` enumerates every failure (the engine
+  replaces the list per run); `Schema#content_valid?` evaluates a
+  child sequence directly against a top-level declaration's model.
+  The -1 contract raises (unknown declaration never masquerades as
+  invalid input). Pins use the named-ref shape — the inline-
+  anonymous complexType capture gap is filed upstream
+  (leptris#1592).
+
 ## [1.9.320.0] - 2026-10-08
 
 ### Fixed — engine sync (libleptris 1.9.320)

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.320"
+LIBLEPTRIS_VERSION = "1.9.321"
 # 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.320.0"
+  VERSION = "1.9.321.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -1304,6 +1304,21 @@ attach_function :leptris_parse_string,
         [:string, :string], :int
       attach_function :leptris_xsd_simple_valid,
         [:leptris_xsd_schema, :string, :string], :int
+      # Slices 3-4 (libleptris 1.9.321, #1075): content models via
+      # Thompson NFA (linear in children x states) and whole-
+      # instance validation — element declarations, attribute rows
+      # (required + typed + lenient qualified spellings), text
+      # lexical checks, child content models. Failures enumerate
+      # behind error_count/_at (schema-owned; the next validate
+      # run replaces them).
+      attach_function :leptris_xsd_content_valid,
+        [:leptris_xsd_schema, :string, :pointer, :pointer, :size_t], :int
+      attach_function :leptris_xsd_validate,
+        [:leptris_xsd_schema, :leptris_document], :int
+      attach_function :leptris_xsd_error_count,
+        [:leptris_xsd_schema], :size_t
+      attach_function :leptris_xsd_error_at,
+        [:leptris_xsd_schema, :size_t], UTF8_STRING
 
       attach_function :leptris_rng_parse,
         [:string, :size_t, :pointer], :leptris_relaxng

data/lib/leptris/xml/xsd.rb

@@ -79,14 +79,66 @@ module Leptris::XML::XSD
     # name) — restriction chains validate every hop's facets,
     # cycle-guarded. Unknown type names raise (the -1 contract).
     def simple_valid?(type_name, lexical)
-      r = Leptris::XML::FFI.leptris_xsd_simple_valid(
-        @handle, type_name.to_s, lexical.to_s)
-      case r
+      tri_state(
+        Leptris::XML::FFI.leptris_xsd_simple_valid(
+          @handle, type_name.to_s, lexical.to_s),
+        "#{type_name.inspect} is not a simpleType in this schema")
+    end
+
+    # Slices 3-4 (libleptris 1.9.321, #1075): whole-instance
+    # validation — element declarations, attribute rows (required
+    # + typed + lenient qualified spellings), text lexical checks,
+    # and child content models through the Thompson NFA. Returns
+    # true/false.
+    def valid?(document)
+      tri_state(
+        Leptris::XML::FFI.leptris_xsd_validate(
+          @handle, document.c_ptr), "invalid document handle")
+    end
+
+    # The enumerated failure list of the last #validate run
+    # (empty when valid; the NEXT validate replaces the list).
+    def validate_errors(document)
+      valid?(document)
+      Leptris::XML::FFI.leptris_xsd_error_count(@handle).times.map do |i|
+        Leptris::XML::FFI.leptris_xsd_error_at(@handle, i)
+      end
+    end
+
+    # Slice 3 direct face: a child SEQUENCE against a top-level
+    # element declaration's compiled content model (occurrence
+    # bounds, xs:any wildcards). +children+ are child Nodes (name
+    # + effective namespace extracted per child). Unknown element
+    # declarations raise (the -1 contract).
+    def content_valid?(element_name, children)
+      kids = children.to_a
+      nb, na = Leptris::XML::CStringArray.to_c(
+        kids.map { |c| c.name.to_s })
+      ub, ua = Leptris::XML::CStringArray.to_c(
+        kids.map { |c| child_ns_uri(c) })
+      tri_state(
+        Leptris::XML::FFI.leptris_xsd_content_valid(
+          @handle, element_name.to_s, nb, ub, kids.size),
+        "#{element_name.inspect} is not a top-level element declaration")
+    end
+
+    private
+
+    # A child's effective namespace URI (nil = none) — read
+    # through its own c_ptr, so docless wrappers work.
+    def child_ns_uri(node)
+      uri = Leptris::XML::FFI.leptris_element_namespace(node.c_ptr)
+      uri.nil? || uri.empty? ? "" : uri
+    end
+
+    # The C faces' 1/0/-1 contract: true/false, with -1 raising —
+    # a silent false would mean "no such declaration/type", which
+    # callers must never confuse with "invalid input".
+    def tri_state(code, unknown_message)
+      case code
       when 1 then true
       when 0 then false
-      else
-        raise ArgumentError,
-          "#{type_name.inspect} is not a simpleType in this schema"
+      else raise ArgumentError, unknown_message
       end
     end
   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.320
+- libleptris v1.9.321
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [1.9.321] - 2026-10-08
+
+### Added
+
+- **XSD validation, tier 1, slices 3–4 (#1075, PRs #1589/#1590).**
+  Slice 3 — content models: the compiler captures top-level
+  `xs:element` declarations and named `xs:complexType` models
+  (sequence/choice/all, occurrence bounds incl. unbounded, element
+  name/ref particles, `xs:any` wildcards with the full
+  namespace-filter grammar); `leptris_xsd_content_valid` evaluates
+  a child sequence through a Thompson NFA — linear in children x
+  states, no backtracking blowup on nested choices. Slice 4 —
+  instance validation: `leptris_xsd_validate(schema, document)`
+  walks element declarations, complexType attribute rows
+  (required + typed + lenient qualified spellings), child content
+  models, and lexical text checks for simple-typed elements
+  (particles carry type refs); failures enumerate behind
+  `leptris_xsd_error_count/_at`. The libxml2 corpus gate holds at
+  163/163; full suite 1911/1911.
+
+
+
 ## [1.9.320] - 2026-10-08
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -29,6 +29,8 @@ set(LEPTRIS_SOURCES
     leptris/rng/parse.c
     leptris/xsd/compile.c
     leptris/xsd/datatypes.c
+    leptris/xsd/content_model.c
+    leptris/xsd/validate.c
     leptris/rng/rng_public.c
     leptris/rng/rng_regex.c
     leptris/rng/validate.c

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

@@ -920,6 +920,28 @@ LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
 LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
                                          const char* type_name,
                                          const char* lexical);
+/* Slice 3 — content models. Validates a child sequence against the
+ * compiled content model of a top-level element declaration (its
+ * type's sequence/choice/all with occurrence bounds and xs:any
+ * wildcards). 1 valid, 0 invalid, -1 unknown element. child_ns may
+ * be NULL (all children unqualified). */
+LEPTRIS_API int leptris_xsd_content_valid(
+    LeptrisXsdSchema schema, const char* element_name,
+    const char* const* child_names, const char* const* child_ns,
+    size_t child_count);
+/* Slice 4 — instance validation. Walks the document against the
+ * compiled schema: element declarations by name, attribute rows
+ * (required use + typed values, lenient qualified spellings),
+ * text lexical checks for simple-typed elements, child content
+ * models (slice 3). Returns 1 valid, 0 invalid, -1 bad args.
+ * Errors accumulate — leptris_xsd_error_count/_at enumerate them
+ * (schema-owned; the next validate run replaces them; freed with
+ * the schema). */
+LEPTRIS_API int leptris_xsd_validate(LeptrisXsdSchema schema,
+                                     LeptrisDocument doc);
+LEPTRIS_API size_t leptris_xsd_error_count(LeptrisXsdSchema schema);
+LEPTRIS_API const char* leptris_xsd_error_at(LeptrisXsdSchema schema,
+                                             size_t i);
 /* 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/xsd/compile.c

@@ -13,13 +13,122 @@
 #define XSD_NS "http://www.w3.org/2001/XMLSchema"
 
 extern int xsd_simple_valid(const XsdSimple* simple, const char* v);
+extern struct xsd_validator* xsd_validator_new(
+    struct leptris_xsd_schema* s);
+extern void xsd_validator_free(struct xsd_validator* v);
+extern int xsd_validator_run(struct xsd_validator* v, LeptrisDocument doc);
+extern size_t xsd_validator_error_count(struct xsd_validator* v);
+extern const char* xsd_validator_error_at(struct xsd_validator* v,
+                                          size_t i);
+
+extern int xsd_content_valid(struct leptris_xsd_schema* s, XsdCm* model,
+                             const char* target_ns,
+                             const char* const* names,
+                             const char* const* ns_uris, size_t count);
 
 struct leptris_xsd_schema {
     size_t declaration_count;
     XsdSimple* simple_types;
+    XsdElementDecl* elements;
+    XsdCm* complex_types; /* name-carrying model roots */
+    XsdTypeAttrs* type_attrs;
+    char* target_ns;
+    void* validator; /* slice-4 parked error list */
     char* error;
 };
 
+/* ---- slice 3: content-model capture ------------------------------ */
+
+static char* xsd_strdup(const char* s);
+
+static XsdCm* xsd_cm_new(XsdCmKind kind) {
+    XsdCm* cm = (XsdCm*)calloc(1, sizeof(*cm));
+    if (!cm) return NULL;
+    cm->kind = kind;
+    cm->min = 1;
+    cm->max = 1;
+    return cm;
+}
+
+static void xsd_cm_free(XsdCm* cm) {
+    while (cm) {
+        XsdCm* next = cm->next;
+        xsd_cm_free(cm->first_child);
+        free(cm->name);
+        free(cm->type);
+        free(cm->ns);
+        free(cm->any_ns);
+        free(cm);
+        cm = next;
+    }
+}
+
+static void xsd_cm_occurrence(XsdCm* cm, LeptrisElement e) {
+    const char* mn = leptris_element_attribute(e, "minOccurs");
+    if (mn) cm->min = (strcmp(mn, "unbounded") == 0) ? 0 : atoi(mn);
+    const char* mx = leptris_element_attribute(e, "maxOccurs");
+    if (mx) cm->max = (strcmp(mx, "unbounded") == 0) ? -1 : atoi(mx);
+}
+
+/* Recursive model build over sequence | choice | all | element |
+ * any children. Returns the child list head; *tail_out receives
+ * the list tail for sibling chaining. */
+static XsdCm* xsd_cm_parse(LeptrisElement group, XsdCm** tail_out) {
+    XsdCm* head = NULL;
+    XsdCm* tail = NULL;
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(group));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement e = (LeptrisElement)n;
+        const char* local = NULL, *prefix = NULL, *uri = NULL;
+        leptris_element_expanded_name(e, &local, &prefix, &uri);
+        if (!local || (uri && strcmp(uri, XSD_NS) != 0)) continue;
+
+        XsdCm* cm = NULL;
+        if (strcmp(local, "sequence") == 0 || strcmp(local, "choice") == 0 ||
+            strcmp(local, "all") == 0) {
+            cm = xsd_cm_new(strcmp(local, "sequence") == 0 ? XSD_CM_SEQ
+                            : strcmp(local, "choice") == 0 ? XSD_CM_CHOICE
+                                                           : XSD_CM_ALL);
+            if (cm) cm->first_child = xsd_cm_parse(e, NULL);
+        } else if (strcmp(local, "element") == 0) {
+            cm = xsd_cm_new(XSD_CM_ELEMENT);
+            if (cm) {
+                const char* nm =
+                    leptris_element_attribute(e, "name");
+                if (!nm) nm = leptris_element_attribute(e, "ref");
+                cm->name = xsd_strdup(nm);
+                cm->type = xsd_strdup(
+                    leptris_element_attribute(e, "type"));
+            }
+        } else if (strcmp(local, "any") == 0) {
+            cm = xsd_cm_new(XSD_CM_ANY);
+            if (cm) {
+                cm->any_ns = xsd_strdup(
+                    leptris_element_attribute(e, "namespace"));
+                const char* pc = leptris_element_attribute(
+                    e, "processContents");
+                cm->process_skip =
+                    (pc && (strcmp(pc, "skip") == 0 ||
+                            strcmp(pc, "lax") == 0)) ? 1 : 0;
+            }
+        } else {
+            continue; /* annotation & friends */
+        }
+        if (!cm) continue;
+        xsd_cm_occurrence(cm, e);
+        if (tail)
+            tail->next = cm;
+        else
+            head = cm;
+        tail = cm;
+    }
+    if (tail_out) *tail_out = tail;
+    return head;
+}
+
 static char* xsd_strdup(const char* s) {
     if (!s) return NULL;
     size_t n = strlen(s) + 1;
@@ -161,6 +270,9 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
         return NULL;
     }
 
+    /* target namespace (xs:any ##other/##targetNamespace filters) */
+    s->target_ns = NULL;
+
     LeptrisDocument doc = leptris_parse_string(xsd_text, len, status);
     if (!doc) {
         xsd_set_error(s, "schema document is not well-formed XML");
@@ -172,6 +284,8 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
         xsd_set_error(s, "schema document has no root element");
         goto fail;
     }
+    s->target_ns = xsd_strdup(
+        leptris_element_attribute(root, "targetNamespace"));
 
     const char* local = NULL;
     const char* prefix = NULL;
@@ -195,7 +309,77 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
                                       &uri);
         if (!xsd_is_declaration(local, uri)) continue;
         s->declaration_count++;
-        if (strcmp(local, "simpleType") == 0 && uri && !strcmp(uri, XSD_NS)) {
+        if (strcmp(local, "element") == 0 && uri && !strcmp(uri, XSD_NS)) {
+            const char* nm = leptris_element_attribute((LeptrisElement)n,
+                                                       "name");
+            const char* ty = leptris_element_attribute((LeptrisElement)n,
+                                                       "type");
+            if (nm && ty) {
+                XsdElementDecl* d =
+                    (XsdElementDecl*)calloc(1, sizeof(*d));
+                if (d) {
+                    d->name = xsd_strdup(nm);
+                    d->type = xsd_strdup(ty);
+                    d->next = s->elements;
+                    s->elements = d;
+                }
+            }
+        } else if (strcmp(local, "complexType") == 0 && uri &&
+                   !strcmp(uri, XSD_NS)) {
+            const char* nm =
+                leptris_element_attribute((LeptrisElement)n, "name");
+            if (nm) {
+                XsdCm* root =
+                    xsd_cm_new(XSD_CM_SEQ); /* wrapper keeps the name */
+                if (root) {
+                    root->name = xsd_strdup(nm);
+                    root->first_child =
+                        xsd_cm_parse((LeptrisElement)n, NULL);
+                    root->next = s->complex_types;
+                    s->complex_types = root;
+                }
+                /* slice 4: attribute declarations of the type */
+                XsdAttrDecl* head = NULL;
+                XsdAttrDecl* tail = NULL;
+                for (LeptrisNodeRef ac = leptris_node_first_child(
+                         leptris_element_as_node((LeptrisElement)n));
+                     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, *ap = NULL, *au = NULL;
+                    leptris_element_expanded_name(ae, &al, &ap, &au);
+                    if (!al || (au && strcmp(au, XSD_NS) != 0)) continue;
+                    if (strcmp(al, "attribute") != 0) continue;
+                    const char* an = leptris_element_attribute(ae, "name");
+                    if (!an) continue; /* ref forms: slice 5 */
+                    XsdAttrDecl* d = (XsdAttrDecl*)calloc(1, sizeof(*d));
+                    if (!d) continue;
+                    d->name = xsd_strdup(an);
+                    d->type = xsd_strdup(
+                        leptris_element_attribute(ae, "type"));
+                    const char* use =
+                        leptris_element_attribute(ae, "use");
+                    d->required = (use && strcmp(use, "required") == 0);
+                    if (tail)
+                        tail->next = d;
+                    else
+                        head = d;
+                    tail = d;
+                }
+                if (head) {
+                    XsdTypeAttrs* ta =
+                        (XsdTypeAttrs*)calloc(1, sizeof(*ta));
+                    if (ta) {
+                        ta->type_name = xsd_strdup(nm);
+                        ta->attrs = head;
+                        ta->next = s->type_attrs;
+                        s->type_attrs = ta;
+                    }
+                }
+            }
+        } else if (strcmp(local, "simpleType") == 0 && uri && !strcmp(uri, XSD_NS)) {
             XsdSimple* captured = xsd_capture_simple((LeptrisElement)n);
             if (captured) {
                 captured->next = s->simple_types;
@@ -218,6 +402,33 @@ fail:
 LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
     struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
     if (!s) return;
+    xsd_cm_free(s->complex_types);
+    XsdTypeAttrs* ta = s->type_attrs;
+    while (ta) {
+        XsdTypeAttrs* tn = ta->next;
+        XsdAttrDecl* a = ta->attrs;
+        while (a) {
+            XsdAttrDecl* an = a->next;
+            free(a->name);
+            free(a->type);
+            free(a);
+            a = an;
+        }
+        free(ta->type_name);
+        free(ta);
+        ta = tn;
+    }
+    XsdElementDecl* d = s->elements;
+    while (d) {
+        XsdElementDecl* dn = d->next;
+        free(d->name);
+        free(d->type);
+        free(d);
+        d = dn;
+    }
+    free(s->target_ns);
+    if (s->validator)
+        xsd_validator_free((struct xsd_validator*)s->validator);
     XsdSimple* t = s->simple_types;
     while (t) {
         XsdSimple* next = t->next;
@@ -261,6 +472,103 @@ LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
     return xsd_valid_chain(s, t, lexical, 0);
 }
 
+/* ---- validator accessors (validate.c) --------------------------- */
+
+const XsdElementDecl* xsd_find_element(struct leptris_xsd_schema* s,
+                                       const char* name) {
+    if (!s || !name) return NULL;
+    for (XsdElementDecl* d = s->elements; d; d = d->next)
+        if (strcmp(d->name, name) == 0) return d;
+    return NULL;
+}
+
+XsdCm* xsd_find_complex(struct leptris_xsd_schema* s,
+                        const char* type_name) {
+    if (!s || !type_name) return NULL;
+    for (XsdCm* c = s->complex_types; c; c = c->next)
+        if (strcmp(c->name, type_name) == 0) return c;
+    return NULL;
+}
+
+const XsdSimple* xsd_find_simple_pub(struct leptris_xsd_schema* s,
+                                     const char* name) {
+    return xsd_find_simple(s, name);
+}
+
+const char* xsd_target_ns(struct leptris_xsd_schema* s) {
+    return s ? s->target_ns : NULL;
+}
+
+const XsdTypeAttrs* xsd_find_type_attrs(struct leptris_xsd_schema* s,
+                                        const char* type_name) {
+    if (!s || !type_name) return NULL;
+    for (XsdTypeAttrs* t = s->type_attrs; t; t = t->next)
+        if (strcmp(t->type_name, type_name) == 0) return t;
+    return NULL;
+}
+
+/* ---- slice 4: instance validation (validate.c engine) ------------ */
+
+LEPTRIS_API int leptris_xsd_validate(LeptrisXsdSchema schema,
+                                     LeptrisDocument doc) {
+    struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
+    if (!s || !doc) return -1;
+    struct xsd_validator* v = xsd_validator_new(s);
+    if (!v) return -1;
+    int r = xsd_validator_run(v, doc);
+    /* park the run's errors on the schema for the accessors; a new
+     * validate run replaces them. */
+    struct xsd_validator* prev = (struct xsd_validator*)s->validator;
+    if (prev) xsd_validator_free(prev);
+    s->validator = v;
+    return r;
+}
+
+LEPTRIS_API size_t leptris_xsd_error_count(LeptrisXsdSchema schema) {
+    struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
+    if (!s) return 0;
+    return xsd_validator_error_count(
+        (struct xsd_validator*)s->validator);
+}
+
+LEPTRIS_API const char* leptris_xsd_error_at(LeptrisXsdSchema schema,
+                                             size_t i) {
+    struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
+    if (!s) return NULL;
+    return xsd_validator_error_at((struct xsd_validator*)s->validator,
+                                  i);
+}
+
+LEPTRIS_API int leptris_xsd_content_valid(
+    LeptrisXsdSchema schema, const char* element_name,
+    const char* const* child_names, const char* const* child_ns,
+    size_t child_count) {
+    struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
+    if (!s || !element_name) return -1;
+
+    const XsdElementDecl* d = s->elements;
+    while (d && strcmp(d->name, element_name) != 0) d = d->next;
+    if (!d) return -1; /* unknown element */
+
+    if (!d->type) return 1; /* no type attr: anyType accepts all */
+
+    /* built-in or simpleType ref: element content is text-only —
+     * any element child fails */
+    if (strncmp(d->type, "xs:", 3) == 0 ||
+        xsd_find_simple(s, d->type))
+        return child_count == 0;
+
+    XsdCm* ct = s->complex_types;
+    while (ct && strcmp(ct->name, d->type) != 0) ct = ct->next;
+    if (!ct) return child_count == 0; /* unknown type: accept-empty */
+
+    XsdCm* model = ct->first_child;
+    if (!model) return child_count == 0;
+
+    return xsd_content_valid(s, model, s->target_ns, child_names,
+                             child_ns, child_count);
+}
+
 LEPTRIS_API size_t leptris_xsd_declaration_count(LeptrisXsdSchema schema) {
     if (!schema) return 0;
     return ((struct leptris_xsd_schema*)schema)->declaration_count;