leptris 1.9.331.0-ppc64le-linux → 1.9.334.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fee2111577d248ca3532241fe8809e68918bbd72d336b58a426344e2bd1fa399
-  data.tar.gz: bc71727942c68d0f44ef2a7a1295b5499d4f54e2e7ad6795c9cf7ce78a58708e
+  metadata.gz: 4c687c6b5c09c8f7ec7bd48a26c197318f6f2a396680075a39f2cbfe445eb9c8
+  data.tar.gz: 458aac071ab017d4bc2192bb9e1ac2c2c003edf631a058a16eb5446d1051e4f1
 SHA512:
-  metadata.gz: 591c7925eaae4994e25c4511f917e8a0e4a673b09d63902325e92135b772710e203c0d0bfda0e6a75c2870e442da589c04763afcdc8423f684e9cef4b290f683
-  data.tar.gz: 3e5efaef0690b4b96826e21dd8c6065a0437ba6f544f39bcf72afb50a76369f82a94f34f6c7e1a8d8d5c4dbd7692e11144143a33359a0ff8a6907549511b339c
+  metadata.gz: f3cacf66947185632eda797cc645d036978912e5acb10726a83c615db019ced9ffe6146411321ee47ffdb521f64d25f7f9789af7dd1938c2d7809bbf260a522d
+  data.tar.gz: 4efeebf09318e7c65ef475fc3fc05c44fa7597226fd8f087f26acac28d50b3a79c76fc574ff2937aa2436d2c16ac30aa5f9769813358e005f3a757701afd9c46

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.331"
+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.331.0"
+  VERSION = "1.9.334.0"
 end

data/lib/leptris/xml/cdata.rb

@@ -31,4 +31,8 @@ class Leptris::XML::CDATA < Leptris::XML::Text
       Leptris::XML::FFI.leptris_cdata_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    "<![CDATA[#{content}]]>"
+  end
 end

data/lib/leptris/xml/comment.rb

@@ -31,4 +31,8 @@ class Leptris::XML::Comment < Leptris::XML::Node
       Leptris::XML::FFI.leptris_comment_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    "<!--#{content}-->"
+  end
 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/entity_reference.rb

@@ -10,4 +10,8 @@ class Leptris::XML::EntityReference < Leptris::XML::Node
     Leptris::XML::FFI.leptris_entity_ref_node_name(c_ptr)
   end
   alias_method :node_name, :name
+
+  def to_s
+    "&#{name};"
+  end
 end

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/lib/leptris/xml/node.rb

@@ -8,6 +8,7 @@ class Leptris::XML::Node
     @c_ptr ||= ::FFI::Pointer.new(@c_address)
   end
 
+
   # The Integer twin of #c_ptr — reading it never materializes a
   # Pointer (the native faces take addresses).
   def c_address

data/lib/leptris/xml/processing_instruction.rb

@@ -50,6 +50,10 @@ class Leptris::XML::ProcessingInstruction < Leptris::XML::Node
     new_data
   end
 
+  def to_s
+    content.to_s.empty? ? "<?#{name}?>" : "<?#{name} #{content}?>"
+  end
+
   # Document-level PIs have no tree parent for leptris_node_unlink
   # — route through the document-level removal (libleptris 1.9.9,
   # #612), identity-matched by index so the right same-target PI

data/lib/leptris/xml/text.rb

@@ -36,4 +36,8 @@ class Leptris::XML::Text < Leptris::XML::Node
       Leptris::XML::FFI.leptris_text_node_set_content(c_ptr, new_content.to_s))
     new_content
   end
+
+  def to_s
+    Leptris::XML::Serialization.escape_text(content)
+  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.331
+- libleptris v1.9.334
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,70 @@
 ## [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
+
+- **Regression pin: union `memberTypes` + inline anonymous members
+  (#1615, PR #1618).** The reported over-acceptance was not
+  reproducible on any engine artifact (main, the v1.9.331 tag,
+  every published gem binary — including through the full Ruby
+  binding path). The exact schema now asserts in CI through both
+  `leptris_xsd_simple_valid` and instance validation, so the
+  mixed-member semantics are verifiable binary-independent of any
+  binding environment.
+
+
+## [1.9.332] - 2026-10-09
+
+### Added
+
+- **XSD 1.1 — tier 2 (#1075, PR #1616).** Gated on
+  `xs:schema @version="1.1"`: `xs:assert` on complexTypes (direct
+  and derivation-nested; compiled once, evaluated per instance
+  through the engine's XPath 2 lane; evaluation errors are
+  failures); `xs:assertion` on simpleTypes (`$value` binds the
+  lexical, element context); `xs:openContent` interleave/suffix
+  (wildcard self-loops at the Thompson NFA's junction states;
+  `xs:defaultOpenContent` schema-wide with `appliesToEmpty`) and
+  `xs:alternative` conditional type assignment (first passing
+  test types the instance, declared type as fallback). Ten
+  red-first specs; ctest 1951/1951; 1.0 schemas unaffected.
+
+### Fixed
+
+- free the defaultOpenContent wildcard with the schema (xsd)
+
+
+
 ## [1.9.331] - 2026-10-09
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.331
+    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;