leptris 1.9.318.0 → 1.9.320.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6c90b838dcbd3165155494321e171c57f470145b959ee40656f40dce4f84897
-  data.tar.gz: 6c7e1f5205388ca6a0f476378e04ca235f48134e02b25873392d59b013a77698
+  metadata.gz: 7e309fd6444a641db0b0f24f92aef96097860678c006a217a783724c499b7f50
+  data.tar.gz: d041122c9d4d1b366549b4dd2d81c8e6c8ee226cc8ddee62d30a6f9a7a582458
 SHA512:
-  metadata.gz: ba48e81789e2dfc95c4c4da2c1c11e7609f2b0f32c9449d65681150ceeb169696bc07a2af29cf12be6514231973a41f580307ec50300dd6b7669ba8489a282ba
-  data.tar.gz: 670b0d55d9fc1a1eb3e4ce595e8505fab58be7803618a39229adfba8ba5a4d7204bdb4b807888022b92ed3f00d93dd6374b73997b01368a1bd584212cc3bc027
+  metadata.gz: ae5b672a25949b41161419054c7ba635e2d234a5ea635a195ad5002d2aeaff4a4c18c3b0e98af5c23cb09c1fc7cec6967e4e866ea4b96c44031e0422fe1545fd
+  data.tar.gz: 6f454b0ad8bc92f31196fca9eb28369118cfe9ed81a7ccff3563a9dd903345ff145cdcb9549bcb6efc7d087718f143e1338704f4d6fdd63face059b74369f97f

data/CHANGELOG.md

@@ -1,3 +1,51 @@
+## [1.9.320.0] - 2026-10-08
+
+### Fixed — engine sync (libleptris 1.9.320)
+
+- **Exact-URI child rows survive build-anchor GC (#1585)**: the
+  engine's plan build let child-row `ns_uri` ride a pointer into
+  the caller's build buffers instead of deep-copying — bindings
+  GC their anchors after build, so exact-URI child rows
+  deterministically stopped matching (uniword's
+  dc:title/dc:creator/dc:description hydrated nil). The engine
+  retains the URI; pinned with build + GC + walk.
+- **Plain attribute rows match any qualification (#1586)**:
+  ns-unset attr rows try the exact wire spelling first, then any
+  qualification by local name (#758 parity) — plain rows bind
+  `w:name`/`w:val` exactly as the interpretive path does, top
+  level and nested; exact-URI rows keep their #1486 precedence.
+  Pinned at both depths.
+
+## [1.9.319.0] - 2026-10-08
+
+### Added — engine sync (libleptris 1.9.319)
+
+- **XSD lexical validation, slice 2 (#1075)**:
+  `XSD.builtin_valid?` covers the tier-1 built-in table (string
+  family, token, boolean, decimal/integer ranges, float/double,
+  date/time with bounds, duration, hex/base64Binary) by the
+  "xs:NAME" reference spelling; `Schema#simple_valid?` resolves
+  user simpleTypes through cycle-guarded restriction chains
+  (pattern / enumeration / min-max / length / digits facets).
+  The C face's -1 (not-in-table / unknown type) raises — a silent
+  false would let misspelled types validate nothing forever.
+  (Slice 1's compile surface rode in the parallel 1.9.318.0.)
+
+### Fixed — engine sync (1.9.319)
+
+- **RELAX NG exact `{n}` quantifiers (PR #1583)**: the regex
+  engine's no-comma branch never set the hi bound — `[A-Z]{3}`
+  matched `ABCD`, so any schema using exact bounds silently
+  over-accepted. Pinned through the binding's datatype path
+  (accepts ABC, rejects ABCD).
+
+### Performance — engine sync (1.9.318)
+
+- Per-thread small-span arena recycle (#1436): the tiny-doc
+  create/destroy row drops ~15% (183→159 ns/doc quiet-hardware) —
+  engine-internal; the binding inherits it on every
+  Document.create cycle.
+
 ## [1.9.317.1] - 2026-10-08
 
 ### Fixed

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.318"
+LIBLEPTRIS_VERSION = "1.9.320"
 # 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.318.0"
+  VERSION = "1.9.320.0"
 end

data/lib/leptris/xml/ffi.rb

@@ -1295,6 +1295,15 @@ attach_function :leptris_parse_string,
         [:leptris_xsd_schema], :size_t
       attach_function :leptris_xsd_error,
         [:leptris_xsd_schema], UTF8_STRING
+      # Slice 2 (libleptris 1.9.319, #1075): lexical validation.
+      # Built-ins take the "xs:NAME" reference spelling; -1 = not
+      # in the tier-1 table. simple_valid resolves a user
+      # simpleType by local name through cycle-guarded restriction
+      # chains; -1 = unknown type.
+      attach_function :leptris_xsd_builtin_valid,
+        [:string, :string], :int
+      attach_function :leptris_xsd_simple_valid,
+        [:leptris_xsd_schema, :string, :string], :int
 
       attach_function :leptris_rng_parse,
         [:string, :size_t, :pointer], :leptris_relaxng

data/lib/leptris/xml/xsd.rb

@@ -9,6 +9,22 @@ module Leptris::XML::XSD
     Schema.compile(schema_xml)
   end
 
+  # Slice 2 (libleptris 1.9.319, #1075): built-in lexical table.
+  # +builtin+ takes the "xs:NAME" reference spelling. Returns
+  # true/false; an unknown table name raises — a silent false
+  # would let misspelled types validate nothing forever.
+  def builtin_valid?(builtin, lexical)
+    r = Leptris::XML::FFI.leptris_xsd_builtin_valid(
+      builtin.to_s, lexical.to_s)
+    case r
+    when 1 then true
+    when 0 then false
+    else
+      raise ArgumentError,
+        "#{builtin.inspect} is not in the tier-1 built-in table"
+    end
+  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.
@@ -57,5 +73,21 @@ module Leptris::XML::XSD
       msg = Leptris::XML::FFI.leptris_xsd_error(@handle)
       msg.nil? || msg.empty? ? nil : msg
     end
+
+    # Slice 2 (libleptris 1.9.319, #1075): lexical validation of
+    # +lexical+ against the user simpleType +type_name+ (local
+    # 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
+      when 1 then true
+      when 0 then false
+      else
+        raise ArgumentError,
+          "#{type_name.inspect} is not a simpleType in this schema"
+      end
+    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.318
+- libleptris v1.9.320
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,62 @@
 ## [Unreleased]
 
+## [1.9.320] - 2026-10-08
+
+### Fixed
+
+- **Descriptor: child-row exact-URI `ns_uri` retained at build
+  (#1585, PR #1587).** The build deep-copied child `ns_prefix` but
+  let `ns_uri` ride the struct copy — a pointer into the caller's
+  build buffers. Bindings GC their anchors (a warm walk plus one GC
+  makes it deterministic), after which exact-URI child rows
+  silently stopped matching and hydration answered nil (uniword's
+  `dc:title`/`dc:creator`/`dc:description`). The spec trashes the
+  caller's buffer after build and asserts the row still binds.
+- **Descriptor: plain attribute rows match any qualification
+  (#1586, PR #1587).** `dp_attr_value`'s ns-unset path now mirrors
+  #758 — the exact wire spelling first, then any qualification by
+  local name — so plain rows bind `w:name`/`w:val` exactly as the
+  interpretive path does, top level and nested. Exact-URI rows keep
+  their #1486 precedence. A NESTED row's binding also consults the
+  TARGET plan's `ns_lenient` now (the #1115-consistent authority)
+  instead of the outer plan's.
+
+
+
+## [1.9.319] - 2026-10-08
+
+### Added
+
+- **XSD validation, tier 1, slices 1–2 (#1075, PRs #1581/#1583).**
+  Slice 1: the `leptris_xsd_compile` surface (xs:schema identity
+  under any namespace spelling, top-level declaration enumeration,
+  error-carrying failure handles) plus the corpus gate — libxml2's
+  own `test/schemas` set (350 files, MIT) vendored at
+  `test/xsd/libxml2-cases`, **163/163 fixtures compiling** with a
+  pinned monotonic floor. Slice 2: `leptris_xsd_builtin_valid` —
+  the tier-1 built-in lexical table (string/Name family, token,
+  language, anyURI, QName, boolean, decimal, the integer-derivation
+  ranges, float/double, the date/time family with month/day bounds,
+  duration, hex/base64Binary) — and `leptris_xsd_simple_valid`:
+  named simpleTypes captured at compile (base + pattern /
+  enumeration / min-max inclusive-exclusive / length family /
+  total-fractionDigits facets), validated through cycle-guarded
+  restriction chains where every hop's facets bind.
+
+### Fixed
+
+- **Regex engine: `{n}` EXACT quantifiers parsed open-ended
+  (PR #1583).** The no-comma branch never set the hi bound, so
+  `[A-Z]{3}` matched `ABCD` — any RELAX NG schema using exact
+  quantifier bounds silently accepted longer runs. Root fix in the
+  quantifier parser plus a never-again spec on the direct engine
+  call; `rng_internal.h` gained C++ guards for test-side calls.
+- Amalgamated single-TU build: the XSD datatype statics now carry
+  the `xsd_` prefix (collision with the xpath lexer's same-named
+  statics — the #1217 class).
+
+
+
 ## [1.9.318] - 2026-10-08
 
 ### Performance

data/vendor-src/libleptris/CMakeLists.txt

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

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

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

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

@@ -909,6 +909,17 @@ 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);
+
+/* Slice 2 — lexical validation. Built-ins take the "xs:NAME"
+ * reference spelling; -1 = not in the tier-1 table. */
+LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
+                                          const char* lexical);
+/* A user simpleType compiled into the schema, by local name:
+ * 1 valid, 0 invalid, -1 unknown type. Restriction chains (local
+ * bases) validate every hop's facets, cycle-guarded. */
+LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
+                                         const char* type_name,
+                                         const char* lexical);
 /* 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/descriptor/plan.c

@@ -285,6 +285,7 @@ static void dp_plan_free(LeptrisPlan p) {
         for (uint32_t c = 0; c < d->child_count; c++) {
             free((char *)d->child_plans[c].wire_name);
             free((char *)d->child_plans[c].ns_prefix);
+            free((char *)d->child_plans[c].ns_uri);
             for (uint16_t pi = 0;
                  pi < d->child_plans[c].predicate_count; pi++) {
                 free((char*)d->child_plans[c]
@@ -481,6 +482,15 @@ LEPTRIS_API LeptrisPlan leptris_plan_build(const leptris_plan_spec* spec,
                     sc->ns_prefix ? dp_strdup(sc->ns_prefix) : NULL;
                 if (sc->ns_prefix && !d->child_plans[c].ns_prefix)
                     goto oom;
+                /* #1585: ns_uri rides the struct copy otherwise —
+                 * a dangling pointer into the caller's build
+                 * buffers once they are reclaimed (bindings GC
+                 * their anchors; the descriptor must outlive
+                 * them). Same retention as attr rows (#1486). */
+                d->child_plans[c].ns_uri =
+                    sc->ns_uri ? dp_strdup(sc->ns_uri) : NULL;
+                if (sc->ns_uri && !d->child_plans[c].ns_uri)
+                    goto oom;
                 uint16_t pc = sc->predicate_count;
                 if (pc) {
                     if (!sc->predicates) goto oom;
@@ -598,8 +608,25 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
  * namespace (XML namespaces §5.2) — EXACT never binds them. */
 static const char* dp_attr_value(LeptrisElement elem,
                                  const leptris_attr_plan* ap) {
-    if (!ap->ns_form)
-        return leptris_element_attribute(elem, ap->wire_name);
+    if (!ap->ns_form) {
+        /* #1586, the plan-path mirror of #758: the exact wire
+         * spelling first, then any qualification by local name —
+         * plain rows are lenient exactly like element rows under
+         * ns_lenient. Exact-URI rows keep their #1486 semantics. */
+        const char* exact =
+            leptris_element_attribute(elem, ap->wire_name);
+        if (exact) return exact;
+        for (LeptrisAttribute at = leptris_element_first_attribute(elem);
+             at; at = leptris_attribute_next(at)) {
+            const char* qn = leptris_attribute_get_name(at);
+            if (!qn) continue;
+            const char* colon = strchr(qn, ':');
+            const char* local = colon ? colon + 1 : qn;
+            if (strcmp(local, ap->wire_name) == 0)
+                return leptris_attribute_get_value(elem, at);
+        }
+        return NULL;
+    }
     for (LeptrisAttribute at = leptris_element_first_attribute(elem);
          at; at = leptris_attribute_next(at)) {
         const char* qn = leptris_attribute_get_name(at);
@@ -832,8 +859,13 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                 LeptrisElement child = (LeptrisElement)n;
                 if (!dp_wire_name_matches(child, row->wire_name))
                     continue;
+                /* The TARGET plan's form governs (#1115) — so its
+                 * lenient flag governs the leniency, not the outer
+                 * plan's (#1586: a namespaced child under a plan
+                 * that declares ns_lenient binds by local name). */
                 if (!dp_ns_binds(child, target->ns_form, target->ns_uri,
-                                 lenient))
+                                 (target->flags &
+                                  LEPTRIS_PLAN_FLAG_NS_LENIENT) != 0))
                     continue;
                 /* Claim the element against later same-wire rows
                  * (predicate partitioning). */

data/vendor-src/libleptris/src/leptris/rng/rng_internal.h

@@ -8,6 +8,10 @@
 #ifndef LEPTRIS_RNG_INTERNAL_H
 #define LEPTRIS_RNG_INTERNAL_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "../include/leptris.h"
 #include "../dom/diag.h"
 #include <stddef.h>
@@ -109,4 +113,8 @@ int rng_regex_matches(const char* pat, const char* text);
 void rng_pattern_free(RngPattern* p);
 void rng_grammar_free(RngGrammar* g);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/vendor-src/libleptris/src/leptris/rng/rng_regex.c

@@ -289,6 +289,10 @@ static RreNode* parse_piece(RreParser* ps) {
                     }
                 }
             }
+            /* {n} with no comma is EXACT — h must be l, not the
+             * -1 "unbounded" sentinel. The old code left h = -1,
+             * so [A-Z]{3} matched ABCD (open-ended {3,}). */
+            if (*q != ',' && h == -1) h = l;
             if (*q == '}' && l >= 0 && (h == -1 || h >= l)) {
                 lo = l;
                 hi = h;

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

@@ -8,14 +8,119 @@
 #include <string.h>
 
 #include "../../include/leptris.h"
+#include "xsd_internal.h"
 
 #define XSD_NS "http://www.w3.org/2001/XMLSchema"
 
+extern int xsd_simple_valid(const XsdSimple* simple, const char* v);
+
 struct leptris_xsd_schema {
     size_t declaration_count;
+    XsdSimple* simple_types;
     char* error;
 };
 
+static char* xsd_strdup(const char* s) {
+    if (!s) return NULL;
+    size_t n = strlen(s) + 1;
+    char* out = (char*)malloc(n);
+    if (out) memcpy(out, s, n);
+    return out;
+}
+
+/* Capture one xs:simpleType's restriction model (slice 2). */
+static XsdSimple* xsd_capture_simple(LeptrisElement st) {
+    const char* name = leptris_element_attribute(st, "name");
+    if (!name) return NULL; /* anonymous types ride their element */
+
+    XsdSimple* simple = (XsdSimple*)calloc(1, sizeof(*simple));
+    if (!simple) return NULL;
+    simple->name = xsd_strdup(name);
+    simple->length = simple->min_length = simple->max_length = -1;
+    simple->total_digits = simple->fraction_digits = -1;
+
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(st));
+         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 (uri && strcmp(uri, XSD_NS) != 0) continue;
+        if (!local) continue;
+        if (strcmp(local, "restriction") == 0) {
+            simple->base =
+                xsd_strdup(leptris_element_attribute(e, "base"));
+            for (LeptrisNodeRef f = leptris_node_first_child(
+                     leptris_element_as_node(e));
+                 f; f = leptris_node_next_sibling(f)) {
+                if (leptris_node_get_type(f) != LEPTRIS_NODE_TYPE_ELEMENT)
+                    continue;
+                LeptrisElement fe = (LeptrisElement)f;
+                const char* fl = NULL, *fp = NULL, *fu = NULL;
+                leptris_element_expanded_name(fe, &fl, &fp, &fu);
+                if (!fl || (fu && strcmp(fu, XSD_NS) != 0)) continue;
+                const char* val =
+                    leptris_element_attribute(fe, "value");
+                if (strcmp(fl, "pattern") == 0)
+                    simple->pattern = xsd_strdup(val);
+                else if (strcmp(fl, "enumeration") == 0) {
+                    XsdFacetValue* fv =
+                        (XsdFacetValue*)calloc(1, sizeof(*fv));
+                    if (fv) {
+                        fv->text = xsd_strdup(val);
+                        fv->next = simple->enum_values;
+                        simple->enum_values = fv;
+                        simple->enum_count++;
+                    }
+                } else if (strcmp(fl, "minInclusive") == 0)
+                    simple->min_inclusive = xsd_strdup(val);
+                else if (strcmp(fl, "minExclusive") == 0)
+                    simple->min_exclusive = xsd_strdup(val);
+                else if (strcmp(fl, "maxInclusive") == 0)
+                    simple->max_inclusive = xsd_strdup(val);
+                else if (strcmp(fl, "maxExclusive") == 0)
+                    simple->max_exclusive = xsd_strdup(val);
+                else if (strcmp(fl, "length") == 0)
+                    simple->length = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "minLength") == 0)
+                    simple->min_length = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "maxLength") == 0)
+                    simple->max_length = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "totalDigits") == 0)
+                    simple->total_digits = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "fractionDigits") == 0)
+                    simple->fraction_digits = val ? strtol(val, NULL, 10) : -1;
+                else if (strcmp(fl, "whiteSpace") == 0)
+                    simple->whitespace = xsd_strdup(val);
+            }
+        }
+    }
+
+    return simple;
+}
+
+/* Depth-capped local-base resolution with a cycle guard: the
+ * restriction chain walks to its built-in, facets of EVERY hop
+ * apply (XSD semantics). */
+static const XsdSimple* xsd_find_simple(struct leptris_xsd_schema* s,
+                                        const char* name) {
+    for (XsdSimple* t = s->simple_types; t; t = t->next)
+        if (strcmp(t->name, name) == 0) return t;
+    return NULL;
+}
+
+static int xsd_valid_chain(struct leptris_xsd_schema* s,
+                           const XsdSimple* t, const char* v, int depth) {
+    if (!t || depth > 32) return 0;
+    if (t->base && strncmp(t->base, "xs:", 3) != 0) {
+        const XsdSimple* next = xsd_find_simple(s, t->base);
+        if (next && !xsd_valid_chain(s, next, v, depth + 1)) return 0;
+    }
+    return xsd_simple_valid(t, v);
+}
+
 static void xsd_set_error(struct leptris_xsd_schema* s, const char* msg) {
     free(s->error);
     s->error = NULL;
@@ -88,8 +193,15 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
             continue;
         leptris_element_expanded_name((LeptrisElement)n, &local, &prefix,
                                       &uri);
-        if (xsd_is_declaration(local, uri))
-            s->declaration_count++;
+        if (!xsd_is_declaration(local, uri)) continue;
+        s->declaration_count++;
+        if (strcmp(local, "simpleType") == 0 && uri && !strcmp(uri, XSD_NS)) {
+            XsdSimple* captured = xsd_capture_simple((LeptrisElement)n);
+            if (captured) {
+                captured->next = s->simple_types;
+                s->simple_types = captured;
+            }
+        }
     }
 
     leptris_document_free(doc);
@@ -106,10 +218,49 @@ fail:
 LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
     struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
     if (!s) return;
+    XsdSimple* t = s->simple_types;
+    while (t) {
+        XsdSimple* next = t->next;
+        free(t->name);
+        free(t->base);
+        free(t->pattern);
+        XsdFacetValue* fv = t->enum_values;
+        while (fv) {
+            XsdFacetValue* fn = fv->next;
+            free(fv->text);
+            free(fv);
+            fv = fn;
+        }
+        free(t->min_inclusive);
+        free(t->min_exclusive);
+        free(t->max_inclusive);
+        free(t->max_exclusive);
+        free(t->whitespace);
+        free(t);
+        t = next;
+    }
     free(s->error);
     free(s);
 }
 
+/* ---- slice 2: lexical validation --------------------------------- */
+
+LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
+                                          const char* lexical) {
+    extern int xsd_builtin_valid(const char* type, const char* v);
+    return xsd_builtin_valid(builtin, lexical);
+}
+
+LEPTRIS_API int leptris_xsd_simple_valid(LeptrisXsdSchema schema,
+                                         const char* type_name,
+                                         const char* lexical) {
+    struct leptris_xsd_schema* s = (struct leptris_xsd_schema*)schema;
+    if (!s || !type_name || !lexical) return 0;
+    const XsdSimple* t = xsd_find_simple(s, type_name);
+    if (!t) return -1; /* unknown type */
+    return xsd_valid_chain(s, t, lexical, 0);
+}
+
 LEPTRIS_API size_t leptris_xsd_declaration_count(LeptrisXsdSchema schema) {
     if (!schema) return 0;
     return ((struct leptris_xsd_schema*)schema)->declaration_count;