leptris 1.9.333.0-arm-linux → 1.9.334.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7fb374110980f3dae43c0ee0d7f6dbf883db4e9e971c8bac8486f9da34f497b
-  data.tar.gz: ee1da2b6bda8ddf0265f1fa07e28ceedff83c40980193ffbeeebc718c4ceef84
+  metadata.gz: cd2cbe214147c78280cf50d20d970f9e66ab0d4348651327e75e3dbd8cfac964
+  data.tar.gz: 0ccd0d2b41ed6cec2f5af1bacdc944de14bca5a5a4b4dcdbd8729ae610d291ac
 SHA512:
-  metadata.gz: e705f7c8c5038486c32dc099d9867656b0283822c079822a045663202940d22b84c350d6c50564a1913332846d89e2da85207cfd58b547ad4eea7e9771c8e4c3
-  data.tar.gz: 1490690097937f74123198a36f011b740247ee1f2c2e7ce41bb635810e61fbb78ffd6c8d47dbcf3573f5f749928802eca88a83004b4a81b30f3333969767e5fb
+  metadata.gz: 41ee708352f94d4795bf2066961e335eb16e8d537b0afd5af1cc63785ae5d5c9735600677fee0fd609986d4c9f591c711233de345396999771fc59c27f90ab59
+  data.tar.gz: 82c5ddfa78c6051e4431a59f84f613d3320ec7bd30dfc3b168d8135dda25e58ca9ee107f8c9a0b03fb55df1808054080740c5990ae0a235ec3f8cc444550e489

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## [1.9.334.0] - 2026-10-10
+
+### Added — engine sync (libleptris 1.9.332-1.9.334)
+
+- **Descriptor#build_result — serialize-side construction
+  (#408's face)**: `leptris_plan_result_build` builds a result
+  tree from row ops (:element structural opens, :scalar nesting
+  inside its producing row's element implicitly, :attr by name,
+  :end closes) that `#serialize` renders — the reverse of #walk,
+  byte-identical round-trip pinned. `leptris_element_add_child_addr`
+  attached (the #408 address-based attach; sugar is #408's design
+  work). Audit 384/383.
+- **XSD 1.1 tier 2 (1.9.332)**: `xs:assert` on complexTypes
+  (XPath 2 lane, per-instance), `xs:assertion` on simpleTypes,
+  `xs:openContent` — `xs:assert` pinned.
+- **Completion wave (1.9.334)**: `xs:all` order-free with foreign
+  children rejected; strict validation of undeclared elements
+  and attributes — both pinned.
+
+### Fixed
+
+- **#1615 resolved as a malformed repro**: the well-formed mixed
+  union (memberTypes + inline member) validates correctly on
+  both paths — my filed schema was missing a `</xs:restriction>`
+  close. On 1.9.334 the malformed schema compiles to an
+  error-carrying handle ("schema document is not well-formed
+  XML") and fails validation CLOSED (it over-accepted silently
+  on 1.9.331 — the real defect, fixed engine-side by their
+  regression pin). Both behaviors spec-pinned; leptris#1615
+  closed with the correction.
+
 ## [1.9.331.0] - 2026-10-10
 
 ### Added — engine sync (libleptris 1.9.325-1.9.331)

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.333"
+LIBLEPTRIS_VERSION = "1.9.334"
 # 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
@@ -31,6 +31,22 @@ CMAKE_FLAGS = %w[
 require "tmpdir"
 
 desc "Build libleptris #{LIBLEPTRIS_VERSION} (+ utf8proc) from release tarballs into lib/"
+# leptris#1623: macOS 14's dyld intermittently SIGKILLs
+# linker-signed adhoc images at load ("CODESIGNING Invalid Page" —
+# the same kill the atomic-replace dance below already guards in
+# dev). The linker's implicit signature is the bare minimum; an
+# explicit codesign at package time writes a complete, deterministic
+# CodeDirectory that survives the gem pipeline (cp, packaging,
+# install). Re-sign every shipped darwin binary and verify it.
+def sign_darwin_binaries(*bins)
+  return unless RUBY_PLATFORM =~ /darwin/
+
+  bins.flatten.compact.each do |bin|
+    sh "codesign --force --sign - #{bin}"
+    sh "codesign --verify #{bin}"
+  end
+end
+
 task :compile do
   # GitHub tarball downloads intermittently return a non-gzip body
   # (rate-limit/redirect HTML) — the piped curl|tar form then fails
@@ -256,6 +272,7 @@ task :compile do
            Dir.glob("#{u8_prefix}/{lib,bin}/utf8proc.dll").first
   raise "utf8proc shared library not found after build" unless u8_lib
   cp(u8_lib, "lib/#{File.basename(u8_lib)}")
+  sign_darwin_binaries("lib/libleptris#{ext}", "lib/#{File.basename(u8_lib)}")
   puts "Vendored #{File.basename(lib)} + #{File.basename(u8_lib)} into lib/"
 
   # Opt-in native read layer ext (#185): built and vendored beside
@@ -319,6 +336,7 @@ task :compile do
       dest = "lib/leptris/xml/#{File.basename(bundle)}"
       cp(bundle, "#{dest}.new")
       mv("#{dest}.new", dest)
+      sign_darwin_binaries(dest)
       puts "Vendored native layer (#{File.basename(bundle)}) into lib/leptris/xml/"
     end
   end

data/lib/leptris/version.rb

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

data/lib/leptris/xml/descriptor.rb

@@ -347,6 +347,61 @@ class Leptris::XML::Descriptor
                                 owner: true, plans: @plans, plan: @plans[0])
   end
 
+  # Serialize-side construction (leptris_plan_result_build): a
+  # result tree from +ops+ — hashes of {kind: :element / :scalar /
+  # :attr / :end, plan_index:, row_index:, name:, value:} — that
+  # #serialize renders through this plan. Encoding: an :element op
+  # opens a structural element (row_index UINT32_MAX = the root);
+  # a :scalar op carries its PRODUCING row and nests inside that
+  # row's element implicitly; :attr attaches by name; :end closes.
+  # Returns a root-owned PlanValue.
+  ROW_OP_KINDS = {
+    scalar: Leptris::XML::FFI::PLAN_OP_SCALAR,
+    element: Leptris::XML::FFI::PLAN_OP_ELEMENT,
+    attr: Leptris::XML::FFI::PLAN_OP_ATTR,
+    end: Leptris::XML::FFI::PLAN_OP_END,
+  }.freeze
+  private_constant :ROW_OP_KINDS
+
+  def build_result(ops)
+    memory = ::FFI::MemoryPointer.new(Leptris::XML::FFI::PlanRowOp, ops.size)
+    anchors = [memory]
+    ops.each_with_index do |op, i|
+      row = Leptris::XML::FFI::PlanRowOp.new(memory[i])
+      kind = ROW_OP_KINDS.fetch(op.fetch(:kind)) do
+        raise ArgumentError,
+          "op kind must be one of #{ROW_OP_KINDS.keys.inspect}"
+      end
+      value = op[:value]
+      row[:kind] = kind
+      row[:plan_index] = op.fetch(:plan_index, 0)
+      row[:row_index] = op.fetch(:row_index, 0xFFFF_FFFF)
+      row[:name] =
+        if (n = op[:name])
+          anchors << (ptr = ::FFI::MemoryPointer.from_string(n.to_s))
+          ptr
+        end
+      if value.nil?
+        row[:value] = nil
+        row[:value_len] = 0
+      else
+        s = value.to_s
+        anchors << (ptr = ::FFI::MemoryPointer.from_string(s))
+        row[:value] = ptr
+        row[:value_len] = s.bytesize
+      end
+    end
+    status = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_plan_result_build(
+      @handle, memory, ops.size, status)
+    if raw.null?
+      raise Leptris::XML::Error,
+        "plan result build failed (status=#{status.read_int})"
+    end
+    Leptris::XML::PlanValue.new(ResultHandle.new(raw),
+                                owner: true, plans: @plans, plan: @plans[0])
+  end
+
   # libleptris 1.9.312 (#1551): serialize a walk result back to
   # XML guided by this plan — the plan supplies element wrappers
   # (row wire_name + ns_prefix), the result the content; children

data/lib/leptris/xml/ffi.rb

@@ -418,6 +418,26 @@ module Leptris
         :leptris_plan_result
       attach_function :leptris_plan_result_free,
         [:leptris_plan_result], :void
+      # libleptris 1.9.324+: construct a result tree from row ops
+      # (the serialize-side fast path — the reverse of the walk):
+      # ELEMENT opens under the current parent, SCALAR/ATTR carry
+      # values, END closes. Strings are copied at build; free with
+      # leptris_plan_result_free (the ResultHandle does).
+      class PlanRowOp < ::FFI::Struct
+        layout :kind, :int,
+               :plan_index, :uint32,
+               :row_index, :uint32,
+               :name, :pointer,
+               :value, :pointer,
+               :value_len, :size_t
+      end
+      PLAN_OP_SCALAR = 0
+      PLAN_OP_ELEMENT = 1
+      PLAN_OP_ATTR = 2
+      PLAN_OP_END = 3
+      attach_function :leptris_plan_result_build,
+        [:leptris_plan, :pointer, :size_t, :pointer], :leptris_plan_result
+
       # libleptris 1.9.312 (#1551): serialize a walk result back
       # to XML guided by its plan — the plan supplies element
       # wrappers (row wire_name + ns_prefix), the result the
@@ -858,6 +878,11 @@ attach_function :leptris_parse_string,
         [:leptris_element, :string], :leptris_status
       attach_function :leptris_element_append_child,
         [:leptris_element, :leptris_element], :leptris_status
+      # #408: address-based attach — bindings pass raw addresses
+      # and skip the per-node FFI pointer-wrapper mint. Same
+      # semantics and status contract as the pointer face.
+      attach_function :leptris_element_add_child_addr,
+        [:ulong_long, :ulong_long], :leptris_status
       # Fused create+append (libleptris 1.9.153): one document
       # resolution, identical tree semantics to the two-call pair.
       attach_function :leptris_element_create_child,

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.333
+- libleptris v1.9.334
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## [Unreleased]
 
+## [1.9.334] - 2026-10-10
+
+### Added
+
+- **XSD completion wave (#1075, PR #1620).** `xs:all` at the model
+  root is order-free now (counting check: each member at most
+  maxOccurs, minOccurs floors, foreign children rejected) — it
+  previously enforced declaration order. Strict validation:
+  undeclared elements (including the document root) and undeclared
+  attributes fail with `not declared (strict)`, unless the type
+  captures `xs:anyAttribute`, whose namespace grammar
+  (`##any`/`##other`/`##targetNamespace`/`##local`/URI list) is
+  enforced. Unresolved named types are loud — `type not found in
+  the schema` — closing the silent-accept class behind #1615.
+  `$value` binds typed: the simple type's numeric chain decides
+  number-vs-string, not the lexical's shape. Eight red-first
+  specs; zero fallout in existing pins.
+- **Native plan-result builder + address-based attach (leptris-
+  ruby#408 asks, PR #1621).** `leptris_plan_result_build` builds
+  the standalone result tree from a flat op program —
+  ELEMENT/SCALAR/ATTR/END, stamped exactly as a walk stamps it —
+  so `leptris_plan_serialize` serves standalone serialization with
+  zero DOM mint on the host (the to_xml → to_json-floor path).
+  `leptris_element_add_child_addr` attaches by raw addresses,
+  dropping the per-node FFI pointer-wrapper mint (~2 allocs/row).
+  The Ruby-side wiring rides the binding repo.
+
+
+
 ## [1.9.333] - 2026-10-10
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -259,6 +259,36 @@ LEPTRIS_API LeptrisPlanResult leptris_plan_walk(LeptrisDocument doc,
                                                 LeptrisStatus* status);
 LEPTRIS_API void leptris_plan_result_free(LeptrisPlanResult result);
 
+/* #408 ask 2: build a standalone result natively from a flat op
+ * program — the same tree a walk produces (wrappers, ns bindings,
+ * kid order), so leptris_plan_serialize serves standalone
+ * serialization with no DOM mint on the host side. ELEMENT ops
+ * reference the plan row that captured the member (plan_index +
+ * row_index; the walk root uses row_index = UINT32_MAX); SCALAR
+ * and ATTR carry the value; END pops the open element. Programs
+ * must balance (every ELEMENT closed; no END without an open
+ * element) and open with the root element op. Strings are copied.
+ * Memory: free with leptris_plan_result_free. */
+typedef enum {
+    LEPTRIS_PLAN_OP_SCALAR = 0,
+    LEPTRIS_PLAN_OP_ELEMENT = 1,
+    LEPTRIS_PLAN_OP_ATTR = 2,
+    LEPTRIS_PLAN_OP_END = 3
+} LeptrisPlanRowOpKind;
+
+typedef struct {
+    LeptrisPlanRowOpKind kind;
+    uint32_t plan_index;  /* ELEMENT: the plan whose row captured it */
+    uint32_t row_index;   /* producing row (UINT32_MAX = root) */
+    const char* name;     /* ATTR: attribute name */
+    const char* value;    /* SCALAR/ATTR: value (NULL = empty) */
+    size_t value_len;
+} leptris_plan_row_op;
+
+LEPTRIS_API LeptrisPlanResult leptris_plan_result_build(
+    LeptrisPlan plan, const leptris_plan_row_op* ops, size_t count,
+    LeptrisStatus* status);
+
 /* #1551: serialize a walk result back to XML, guided by its plan.
  * The plan supplies element wrappers (row wire_name + ns_prefix)
  * and the result supplies content; children emit in document order

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

@@ -2153,6 +2153,11 @@ LEPTRIS_API LeptrisStatus leptris_element_set_name(LeptrisElement elem, const ch
  * @param child Child element to append
  * @return LEPTRIS_OK on success, error code otherwise
  */
+/* #408: address-based attach — bindings pass raw addresses and
+ * skip the per-node FFI pointer-wrapper mint. Same semantics and
+ * status contract as leptris_element_append_child. */
+LEPTRIS_API LeptrisStatus leptris_element_add_child_addr(uintptr_t parent_addr,
+                                                        uintptr_t child_addr);
 LEPTRIS_API LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement child);
 
 /**

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -1530,6 +1530,150 @@ LEPTRIS_API char* leptris_plan_serialize(LeptrisPlan plan,
     return b.s;
 }
 
+LEPTRIS_API LeptrisPlanResult leptris_plan_result_build(
+    LeptrisPlan plan, const leptris_plan_row_op* ops, size_t count,
+    LeptrisStatus* status) {
+    if (status) *status = LEPTRIS_OK;
+    if (!plan || !ops || count == 0) {
+        if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+        return NULL;
+    }
+    const struct leptris_plan* pool =
+        (const struct leptris_plan*)plan;
+    /* op stack of open elements; depth is program-bounded */
+    struct leptris_plan_result** stack =
+        (struct leptris_plan_result**)calloc(count,
+                                             sizeof(*stack));
+    if (!stack) {
+        if (status) *status = LEPTRIS_ERROR_MEMORY;
+        return NULL;
+    }
+    int sp = 0;
+    struct leptris_plan_result* root = NULL;
+    for (size_t i = 0; i < count; i++) {
+        const leptris_plan_row_op* op = &ops[i];
+        if (op->kind == LEPTRIS_PLAN_OP_ELEMENT) {
+            if (op->plan_index >= pool->plan_count ||
+                (op->row_index != UINT32_MAX &&
+                 op->row_index >= pool->plans[op->plan_index]
+                                      .child_count)) {
+                free(stack);
+                if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+                return NULL;
+            }
+            struct leptris_plan_result* v = dp_value_new(
+                LEPTRIS_PLAN_VALUE_ELEMENT);
+            if (!v) goto oom;
+            const dp_plan* cp = &pool->plans[op->plan_index];
+            const char* wire =
+                op->row_index == UINT32_MAX
+                    ? cp->element_name
+                    : cp->child_plans[op->row_index].wire_name;
+            v->name = dp_strdup(wire);
+            v->container_plan = op->plan_index;
+            v->row_index = op->row_index;
+            if (op->row_index != UINT32_MAX) {
+                const leptris_child_plan* cr =
+                    &cp->child_plans[op->row_index];
+                v->ns_prefix = dp_strdup(cr->ns_prefix);
+                v->ns_uri = dp_strdup(cr->ns_uri);
+            }
+            if (sp == 0) {
+                if (root) { /* multiple roots */
+                    dp_result_free_rec(v);
+                    free(stack);
+                    if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+                    return NULL;
+                }
+                root = v;
+            } else if (!dp_value_push(stack[sp - 1], v)) {
+                dp_result_free_rec(v);
+                goto oom;
+            }
+            v->order_index = (uint32_t)
+                (sp == 0 ? 0 : stack[sp - 1]->kid_count);
+            stack[sp++] = v;
+        } else if (op->kind == LEPTRIS_PLAN_OP_SCALAR) {
+            if (sp == 0) {
+                free(stack);
+                if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+                return NULL;
+            }
+            struct leptris_plan_result* v =
+                dp_value_new(LEPTRIS_PLAN_VALUE_SCALAR);
+            if (!v) goto oom;
+            const dp_plan* cp = &pool->plans[op->plan_index];
+            if (op->row_index < cp->child_count)
+                v->name = dp_strdup(
+                    cp->child_plans[op->row_index].wire_name);
+            if (!dp_value_set_str(v, op->value ? op->value : "",
+                                  op->value ? op->value_len : 0))
+                dp_value_set_str(v, "", 0);
+            if (!dp_value_push(stack[sp - 1], v)) {
+                dp_result_free_rec(v);
+                goto oom;
+            }
+        } else if (op->kind == LEPTRIS_PLAN_OP_ATTR) {
+            if (sp == 0 || !op->name) {
+                free(stack);
+                if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+                return NULL;
+            }
+            struct leptris_plan_result* el = stack[sp - 1];
+            char** gn = (char**)realloc(
+                el->attr_names,
+                (el->attr_count + 1) * sizeof(char*));
+            char** gv = (char**)realloc(
+                el->attr_values,
+                (el->attr_count + 1) * sizeof(char*));
+            char** gp = (char**)realloc(
+                el->attr_ns_prefixes,
+                (el->attr_count + 1) * sizeof(char*));
+            char** gu = (char**)realloc(
+                el->attr_ns_uris,
+                (el->attr_count + 1) * sizeof(char*));
+            if (!gn || !gv || !gp || !gu) {
+                free(gn); free(gv); free(gp); free(gu);
+                goto oom;
+            }
+            el->attr_names = gn;
+            el->attr_values = gv;
+            el->attr_ns_prefixes = gp;
+            el->attr_ns_uris = gu;
+            gn[el->attr_count] = dp_strdup(op->name);
+            gv[el->attr_count] =
+                dp_strdup_n(op->value ? op->value : "",
+                            op->value ? op->value_len : 0);
+            gp[el->attr_count] = NULL;
+            gu[el->attr_count] = NULL;
+            if (!gn[el->attr_count] || !gv[el->attr_count])
+                goto oom;
+            el->attr_count++;
+        } else if (op->kind == LEPTRIS_PLAN_OP_END) {
+            if (sp == 0) {
+                free(stack);
+                if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+                return NULL;
+            }
+            sp--;
+        }
+    }
+    int balanced = (sp == 0 && root != NULL);
+    free(stack);
+    if (!balanced) {
+        dp_result_free_rec(root);
+        if (status) *status = LEPTRIS_ERROR_INVALID_ARG;
+        return NULL;
+    }
+    return (LeptrisPlanResult)root;
+
+oom:
+    if (root) dp_result_free_rec(root);
+    free(stack);
+    if (status) *status = LEPTRIS_ERROR_MEMORY;
+    return NULL;
+}
+
 LEPTRIS_API void leptris_plan_result_free(LeptrisPlanResult result) {
     dp_result_free_rec((struct leptris_plan_result*)result);
 }

data/vendor-src/libleptris/src/leptris/dom/element_modify.c

@@ -493,6 +493,13 @@ static LeptrisNode* adopt_for_splice(LeptrisNode* node,
     return copy ? (LeptrisNode*)copy : NULL;
 }
 
+LeptrisStatus leptris_element_add_child_addr(uintptr_t parent_addr,
+                                             uintptr_t child_addr) {
+    if (!parent_addr || !child_addr) return LEPTRIS_ERROR_NULL_ARG;
+    return leptris_element_append_child((LeptrisElement)parent_addr,
+                                        (LeptrisElement)child_addr);
+}
+
 LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement child) {
     if (!parent || !child) return LEPTRIS_ERROR_NULL_ARG;
 

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

@@ -79,13 +79,15 @@ static char* xsd_read_file(const char* path, size_t* out_len);
 static XsdAttrDecl* xsd_copy_attr_rows(const XsdAttrDecl* src);
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
-                                 const char* name);
+                                 const char* name,
+                                 char* any_attr_ns);
 static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                                         LeptrisElement ct,
                                         const char* name);
 static XsdAssert* xsd_capture_assert(struct leptris_xsd_schema* s,
                                      LeptrisElement e);
 static XsdCm* xsd_capture_any(LeptrisElement any_child);
+static char* xsd_capture_any_attr_ns(LeptrisElement container);
 static void xsd_capture_alternatives(struct leptris_xsd_schema* s,
                                      LeptrisElement decl_elem,
                                      XsdElementDecl* d);
@@ -900,6 +902,7 @@ LEPTRIS_API void leptris_xsd_free(LeptrisXsdSchema schema) {
             a = an;
         }
         free(ta->type_name);
+        free(ta->any_attr_ns);
         free(ta);
         ta = tn;
     }
@@ -998,19 +1001,23 @@ static XsdCm* xsd_cm_copy_list(const XsdCm* head) {
 
 static void xsd_register_complex(struct leptris_xsd_schema* s,
                                  XsdCm* root, XsdAttrDecl* attrs,
-                                 const char* name) {
+                                 const char* name,
+                                 char* any_attr_ns) {
     if (!root) return;
     root->name = xsd_strdup(name);
     root->next = s->complex_types;
     s->complex_types = root;
-    if (attrs) {
+    if (attrs || any_attr_ns) {
         XsdTypeAttrs* ta = (XsdTypeAttrs*)calloc(1, sizeof(*ta));
         if (ta) {
             ta->type_name = xsd_strdup(name);
             ta->attrs = attrs;
+            ta->any_attr_ns = any_attr_ns;
             ta->next = s->type_attrs;
             s->type_attrs = ta;
         }
+    } else if (any_attr_ns) {
+        free(any_attr_ns);
     }
 }
 
@@ -1108,6 +1115,7 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
     XsdCm* root = xsd_cm_new(XSD_CM_SEQ); /* wrapper keeps the name */
     if (!root) return NULL;
     XsdAttrDecl* attrs = NULL;
+    char* any_attr_ns = NULL;
 
     for (LeptrisNodeRef n =
              leptris_node_first_child(leptris_element_as_node(ct));
@@ -1175,6 +1183,8 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                 /* XSD 1.1: asserts nested under the derivation */
                 if (s->version_11)
                     xsd_capture_assert_children(s, dq, root);
+                if (!any_attr_ns)
+                    any_attr_ns = xsd_capture_any_attr_ns(dq);
             }
         } else if (strcmp(local, "simpleContent") == 0) {
             for (LeptrisNodeRef q = leptris_node_first_child(
@@ -1241,6 +1251,7 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
          * re-capturing would orphan those rows. */
         root->first_child = xsd_cm_parse(s, ct, NULL);
         if (!attrs) attrs = xsd_capture_attr_rows(s, ct, 0);
+        if (!any_attr_ns) any_attr_ns = xsd_capture_any_attr_ns(ct);
     }
     /* XSD 1.1: openContent on the type, else the schema default */
     if (s->version_11) {
@@ -1308,7 +1319,7 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
         xsd_cm_free(root->open_any);
         root->open_any = NULL;
     }
-    xsd_register_complex(s, root, attrs, name);
+    xsd_register_complex(s, root, attrs, name, any_attr_ns);
     return root;
 }
 
@@ -1474,6 +1485,23 @@ static XsdAttrDecl* xsd_capture_attr_rows(struct leptris_xsd_schema* s,
     return head;
 }
 
+/* One container's xs:anyAttribute grammar (NULL when absent). */
+static char* xsd_capture_any_attr_ns(LeptrisElement container) {
+    for (LeptrisNodeRef ac = leptris_node_first_child(
+             leptris_element_as_node(container));
+         ac; ac = leptris_node_next_sibling(ac)) {
+        if (leptris_node_get_type(ac) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement ae = (LeptrisElement)ac;
+        const char* al = NULL;
+        leptris_element_expanded_name(ae, &al, NULL, NULL);
+        if (al && strcmp(al, "anyAttribute") == 0)
+            return xsd_strdup(
+                leptris_element_attribute(ae, "namespace"));
+    }
+    return NULL;
+}
+
 LEPTRIS_API int leptris_xsd_builtin_valid(const char* builtin,
                                           const char* lexical) {
     extern int xsd_builtin_valid(const char* type, const char* v);

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

@@ -208,10 +208,45 @@ static void ss_close(StateSet* ss, CmNfa* n) {
     }
 }
 
+/* XSD xs:all at the model root: order-free, each particle at
+ * most maxOccurs times, minOccurs floors — a counting check over
+ * the particle list (XSD 1.0 restricts xs:all to the model root,
+ * each child a particle, maxOccurs <= 1). */
+static int all_root_valid(XsdCm* all, const char* target_ns,
+                          const char* const* names,
+                          const char* const* ns_uris, size_t count) {
+    for (XsdCm* p = all->first_child; p; p = p->next) {
+        size_t hits = 0;
+        for (size_t i = 0; i < count; i++) {
+            const char* uri = ns_uris ? ns_uris[i] : NULL;
+            if (p->name && strcmp(p->name, names[i]) == 0 &&
+                (!p->ns || (uri && strcmp(uri, p->ns) == 0)))
+                hits++;
+        }
+        if ((long)hits < p->min) return 0;
+        if (p->max >= 0 && (long)hits > p->max) return 0;
+    }
+    /* every instance child must belong to a particle */
+    for (size_t i = 0; i < count; i++) {
+        int matched = 0;
+        const char* uri = ns_uris ? ns_uris[i] : NULL;
+        for (XsdCm* p = all->first_child; p && !matched; p = p->next) {
+            if (p->name && strcmp(p->name, names[i]) == 0 &&
+                (!p->ns || (uri && strcmp(uri, p->ns) == 0)))
+                matched = 1;
+        }
+        if (!matched) return 0;
+    }
+    (void)target_ns;
+    return 1;
+}
+
 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) {
     if (!model) return -1;
+    if (model->kind == XSD_CM_ALL && model->first_child)
+        return all_root_valid(model, target_ns, names, ns_uris, count);
     CmNfa n;
     memset(&n, 0, sizeof(n));
     n.s = s;

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

@@ -88,6 +88,9 @@ static void verrf(struct xsd_validator* v, const char* what,
 
 /* ---- lexical helpers ---------------------------------------------- */
 
+static int simple_is_numeric(struct leptris_xsd_schema* s,
+                             const XsdSimple* st);
+
 static int text_valid(struct xsd_validator* v,
                       struct leptris_xsd_schema* s, const char* type,
                       const char* lexical, const char* what,
@@ -128,12 +131,10 @@ static int text_valid(struct xsd_validator* v,
         }
         if (mut->assertion_q) {
             char sel[256];
-            int numeric = 1;
-            for (const char* p = lexical; *p; p++)
-                if (!isdigit((unsigned char)*p) && *p != '.' &&
-                    *p != '-' && *p != '+' && *p != 'e' && *p != 'E')
-                    numeric = 0;
-            if (numeric && *lexical)
+            int numeric =
+                simple_is_numeric(s, st) && *lexical &&
+                strspn(lexical, "0123456789.+-eE") == strlen(lexical);
+            if (numeric)
                 snprintf(sel, sizeof(sel), "%s", lexical);
             else {
                 size_t w = 0;
@@ -259,6 +260,59 @@ static void validate_children(struct xsd_validator* v,
     }
 }
 
+/* $value binds typed: a numeric-derived simple type binds the
+ * lexical as a number literal, everything else as a string — the
+ * TYPE decides, not the lexical's shape ("5" under xs:string is
+ * the string '5'). */
+static int numeric_builtin(const char* b) {
+    static const char* nums[] = {
+        "xs:integer",  "xs:decimal",     "xs:double", "xs:float",
+        "xs:int",      "xs:long",        "xs:short",  "xs:byte",
+        "xs:nonNegativeInteger", "xs:positiveInteger",
+        "xs:negativeInteger",    "xs:nonPositiveInteger",
+        "xs:unsignedLong",       "xs:unsignedInt",
+        "xs:unsignedShort",      "xs:unsignedByte", NULL};
+    for (int i = 0; nums[i]; i++)
+        if (strcmp(b, nums[i]) == 0) return 1;
+    return 0;
+}
+
+static int simple_is_numeric(struct leptris_xsd_schema* s,
+                             const XsdSimple* st) {
+    for (int d = 0; st && d < 32; d++) {
+        if (!st->base) return 0;
+        if (strncmp(st->base, "xs:", 3) == 0)
+            return numeric_builtin(st->base);
+        st = xsd_find_simple_pub(s, st->base);
+    }
+    return 0;
+}
+
+/* xs:anyAttribute grammar: ##any (or an absent attribute),
+ * ##other, ##targetNamespace, ##local, or a space-separated URI
+ * list. */
+static int any_attr_matches(const char* grammar, const char* uri,
+                            const char* target_ns) {
+    if (!grammar || strcmp(grammar, "##any") == 0) return 1;
+    if (strcmp(grammar, "##other") == 0)
+        return uri && target_ns && strcmp(uri, target_ns) != 0;
+    if (strcmp(grammar, "##targetNamespace") == 0)
+        return uri && target_ns && strcmp(uri, target_ns) == 0;
+    if (strcmp(grammar, "##local") == 0) return uri == NULL;
+    /* URI list */
+    const char* p = grammar;
+    while (*p) {
+        while (*p == ' ' || *p == '\t') p++;
+        if (!*p) break;
+        const char* start = p;
+        while (*p && *p != ' ' && *p != '\t') p++;
+        size_t len = (size_t)(p - start);
+        if (uri && strlen(uri) == len && strncmp(uri, start, len) == 0)
+            return 1;
+    }
+    return 0;
+}
+
 static void validate_attributes(struct xsd_validator* v,
                                 struct leptris_xsd_schema* s,
                                 LeptrisElement elem,
@@ -294,6 +348,32 @@ static void validate_attributes(struct xsd_validator* v,
             verrf(v, "attribute", a->name,
                   "value does not match the fixed value");
     }
+    /* strict: every instance attribute must be declared (or pass
+     * the type's xs:anyAttribute grammar). Namespace declarations
+     * are not attributes. */
+    for (LeptrisAttribute at = leptris_element_first_attribute(elem);
+         at; at = leptris_attribute_next(at)) {
+        const char* qn = leptris_attribute_get_name(at);
+        if (!qn || strncmp(qn, "xmlns", 5) == 0) continue;
+        const char* colon = strchr(qn, ':');
+        const char* local = colon ? colon + 1 : qn;
+        int declared = 0;
+        for (XsdAttrDecl* a = ta->attrs; a && !declared; a = a->next)
+            if (strcmp(a->name, local) == 0 ||
+                strcmp(a->name, qn) == 0)
+                declared = 1;
+        if (declared) continue;
+        if (ta->any_attr_ns) {
+            /* namespace of the attribute: engine-side attributes
+             * carry their uri through the expanded form */
+            const char* auri =
+                leptris_attribute_namespace_uri(at);
+            if (any_attr_matches(ta->any_attr_ns, auri,
+                                 xsd_target_ns(s)))
+                continue;
+        }
+        verrf(v, "attribute", local, "not declared (strict)");
+    }
 }
 
 static void validate_element(struct xsd_validator* v,
@@ -304,7 +384,12 @@ static void validate_element(struct xsd_validator* v,
     leptris_element_expanded_name(elem, &local, &prefix, &uri);
     if (!local) return;
     const XsdElementDecl* d = xsd_find_element(s, local);
-    if (!d) return; /* undeclared: lax at this depth (strict later) */
+    if (!d) {
+        /* strict: the instance uses an element the schema never
+         * declared (a local particle would have typed it) */
+        verrf(v, "element", local, "not declared (strict)");
+        return;
+    }
 
     /* XSD 1.1: the first alternative whose test passes types the
      * element for this instance (context = the element). */
@@ -377,7 +462,11 @@ static void validate_local(struct xsd_validator* v,
         const char* text = leptris_element_text(elem);
         if (text && *text)
             text_valid(v, s, type, text, "element", local, elem);
+        return;
     }
+    /* neither complex nor simple nor builtin: the schema is
+     * incomplete — loud, never a silent accept (#1615 class) */
+    verrf(v, "element", local, "type not found in the schema");
 }
 
 /* ---- slice 6: identity constraints -------------------------------- */

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

@@ -190,6 +190,7 @@ typedef struct xsd_attrgroup_def {
 
 typedef struct xsd_type_attrs {
     char* type_name;
+    char* any_attr_ns; /* xs:anyAttribute grammar (NULL = absent) */
     XsdAttrDecl* attrs;
     struct xsd_type_attrs* next;
 } XsdTypeAttrs;

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

@@ -2131,3 +2131,98 @@ TEST(Plan1586, ExactUriRowStillWinsAndUnqualifiedStillBinds) {
     leptris_document_free(doc);
     leptris_plan_free(plan);
 }
+
+// ---- #408: native result builder + address attach -------------------
+namespace {
+
+/* leptris_plan_result_build: a flat op program produces the same
+ * standalone result tree a walk would — wrappers, ns bindings, kid
+ * order — so leptris_plan_serialize serves standalone
+ * serialization with no DOM mint on the host side. */
+TEST(Plan408, ResultBuildFeedsSerialize) {
+    LeptrisStatus st = LEPTRIS_OK;
+    leptris_child_plan kids[1] = {};
+    kids[0].wire_name = "p";
+    kids[0].kind = LEPTRIS_PLAN_KIND_SCALAR;
+    kids[0].type_tag = 1;
+    kids[0].child_plan_index = -1;
+    leptris_element_plan plans[1] = {};
+    plans[0].element_name = "b";
+    plans[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[0].child_count = 1;
+    plans[0].child_plans = kids;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 1;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+
+    /* a SCALAR op IS the row's value (name and binding come from
+     * the plan row) — no ELEMENT wrapper needed for scalar rows */
+    leptris_plan_row_op ops[] = {
+        {LEPTRIS_PLAN_OP_ELEMENT, 0, UINT32_MAX, NULL, NULL, 0},
+        {LEPTRIS_PLAN_OP_ATTR, 0, UINT32_MAX, "id", "7", 1},
+        {LEPTRIS_PLAN_OP_SCALAR, 0, 0, NULL, "first", 5},
+        {LEPTRIS_PLAN_OP_END, 0, UINT32_MAX, NULL, NULL, 0},
+    };
+    LeptrisPlanResult r =
+        leptris_plan_result_build(plan, ops, 4, &st);
+    ASSERT_NE(r, nullptr);
+    char* out = leptris_plan_serialize(plan, r, &st);
+    ASSERT_NE(out, nullptr);
+    EXPECT_STREQ(out, "<b id=\"7\"><p>first</p></b>");
+    leptris_free_string(out);
+    leptris_plan_result_free(r);
+    leptris_plan_free(plan);
+}
+
+TEST(Plan408, ResultBuildRejectsBadPrograms) {
+    LeptrisStatus st = LEPTRIS_OK;
+    leptris_element_plan plans[1] = {};
+    plans[0].element_name = "b";
+    plans[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 1;
+    spec.plans = plans;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+
+    /* END without an open element */
+    leptris_plan_row_op bad1[] = {
+        {LEPTRIS_PLAN_OP_END, 0, UINT32_MAX, NULL, NULL, 0}};
+    EXPECT_EQ(leptris_plan_result_build(plan, bad1, 1, &st), nullptr);
+    /* unclosed element */
+    leptris_plan_row_op bad2[] = {
+        {LEPTRIS_PLAN_OP_ELEMENT, 0, UINT32_MAX, NULL, NULL, 0}};
+    EXPECT_EQ(leptris_plan_result_build(plan, bad2, 1, &st), nullptr);
+    /* NULL/empty args */
+    EXPECT_EQ(leptris_plan_result_build(NULL, bad2, 1, &st), nullptr);
+    EXPECT_EQ(leptris_plan_result_build(plan, NULL, 0, &st), nullptr);
+    leptris_plan_free(plan);
+}
+
+/* leptris_element_add_child_addr: attach by raw addresses — the
+ * binding's per-node FFI::Pointer mint (#408 ask 1) disappears. */
+TEST(Plan408, AddChildByAddress) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement parent = leptris_document_root(doc);
+    LeptrisElement child = leptris_element_create(doc, "c");
+    ASSERT_NE(child, nullptr);
+    EXPECT_EQ(leptris_element_add_child_addr(
+                  (uintptr_t)parent, (uintptr_t)child),
+              LEPTRIS_OK);
+    EXPECT_EQ(leptris_element_child_count(parent), 1u);
+    LeptrisElement got = leptris_element_first_child_any(parent);
+    ASSERT_NE(got, nullptr);
+    EXPECT_STREQ(leptris_element_name(got), "c");
+    /* NULL-shaped addresses are clean errors */
+    EXPECT_NE(leptris_element_add_child_addr(0, (uintptr_t)child),
+              LEPTRIS_OK);
+    leptris_document_free(doc);
+}
+
+}  // namespace

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

@@ -1396,3 +1396,106 @@ TEST(XsdDatatypes, UnionMixesNamedAndInlineMembers) {
     EXPECT_EQ(validate_doc(x, "<v>42</v>"), 1);
     EXPECT_EQ(validate_doc(x, "<v>auto</v>"), 1);
 }
+
+// ---- completion wave: xs:all order-free semantics ------------------
+namespace {
+
+const char* k_all_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+    "<xs:complexType name=\"aT\">"
+    "<xs:all>"
+    "<xs:element name=\"x\" type=\"xs:token\"/>"
+    "<xs:element name=\"y\" type=\"xs:token\" minOccurs=\"0\"/>"
+    "</xs:all>"
+    "</xs:complexType>"
+    "<xs:element name=\"r\" type=\"aT\"/>"
+    "</xs:schema>";
+
+TEST(XsdContent, AllGroupIsOrderFree) {
+    /* declaration order */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x><y>2</y></r>"), 1);
+    /* reversed order: xs:all is order-free */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><y>2</y><x>1</x></r>"), 1);
+    /* optional member absent */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x></r>"), 1);
+    /* a member appears twice: at most once in xs:all */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x><x>1</x></r>"), 0);
+    /* required member missing */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><y>2</y></r>"), 0);
+    /* undeclared child inside xs:all */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x><z/></r>"), 0);
+}
+
+}  // namespace
+
+// ---- completion wave: loud unresolved types ------------------------
+namespace {
+
+TEST(XsdValidate, UnresolvedTypeIsALoudFailure) {
+    /* the schema references a type that does not exist — the
+     * instance must not silently validate (the #1615 symptom
+     * class: stale engines accepted unresolved types) */
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"v\" type=\"noSuchType\"/>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x, "<v>anything</v>"), 0);
+}
+
+}  // namespace
+
+// ---- completion wave: strict undeclared elements/attributes -------
+namespace {
+
+TEST(XsdValidate, UndeclaredElementIsStrict) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"r\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence></xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x, "<r><a>1</a></r>"), 1);
+    /* a child the schema never declared */
+    EXPECT_EQ(validate_doc(x, "<r><a>1</a><ghost/></r>"), 0);
+    /* an element outside the sequence */
+    EXPECT_EQ(validate_doc(x, "<r><ghost/><a>1</a></r>"), 0);
+    /* an undeclared ROOT element */
+    EXPECT_EQ(validate_doc(x, "<ghost/>"), 0);
+}
+
+TEST(XsdValidate, UndeclaredAttributeIsStrictUnlessAnyAttribute) {
+    const char* strict =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"r\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "<xs:attribute name=\"id\" type=\"xs:integer\"/>"
+        "</xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(strict, "<r id=\"1\"><a>x</a></r>"), 1);
+    /* an attribute the schema never declared */
+    EXPECT_EQ(validate_doc(strict, "<r id=\"1\" note=\"hi\"><a>x</a></r>"),
+              0);
+
+    /* xs:anyAttribute opens the wildcard: undeclared attrs pass */
+    const char* open_attrs =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"r\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "<xs:attribute name=\"id\" type=\"xs:integer\"/>"
+        "<xs:anyAttribute namespace=\"##any\" processContents=\"lax\"/>"
+        "</xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(open_attrs,
+                           "<r id=\"1\" note=\"hi\" tag=\"x\"><a>x</a></r>"),
+              1);
+}
+
+}  // namespace

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.333.0
+  version: 1.9.334.0
 platform: arm-linux
 authors:
 - Ribose Inc.