leptris 1.9.384.0-arm-linux → 1.9.386.0-arm-linux

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

@@ -1616,6 +1616,165 @@ LEPTRIS_API const char* leptris_element_namespace_decl_uri(
     return uri;
 }
 
+/* #1874: pre-order DFS over the subtree, one row per (element with
+ * declarations, declaration). The explicit stack (elements + the
+ * borrowed path-name chain) keeps arbitrarily deep trees off the C
+ * stack. First pass counts rows and blob bytes; the second fills —
+ * the two passes walk identically, so sizing and filling agree. */
+LEPTRIS_API size_t leptris_element_namespace_declarations_snapshot(
+    LeptrisElement elem,
+    leptris_ns_decl_row* rows, size_t rows_cap, size_t* out_row_count,
+    char* blob, size_t blob_cap, size_t* blob_used_out) {
+    size_t row_count = 0;
+    size_t blob_used = 0;
+
+    /* Dynamic DFS stack: element + depth. The path-name chain rides
+     * a parallel array of borrowed name pointers indexed by depth. */
+    struct dfs_entry {
+        LeptrisElement e;
+        uint32_t depth;
+    };
+    size_t stack_cap = 64, names_cap = 64;
+    struct dfs_entry* stack = (struct dfs_entry*)malloc(
+        stack_cap * sizeof(*stack));
+    const char** names = (const char**)malloc(names_cap * sizeof(*names));
+    if (!stack || !names) {
+        free(stack);
+        free(names);
+        if (out_row_count) *out_row_count = 0;
+        if (blob_used_out) *blob_used_out = 0;
+        return (size_t)-1;
+    }
+    size_t sp = 0;
+
+    if (elem) {
+        stack[sp].e = elem;
+        stack[sp].depth = 0;
+        sp++;
+    }
+
+    while (sp > 0) {
+        sp--;
+        LeptrisElement e = stack[sp].e;
+        uint32_t depth = stack[sp].depth;
+
+        /* Path name for this element (depth 0 writes nothing); DFS
+         * visits the parent first, so ancestors are recorded. */
+        if (depth > 0) {
+            if (depth >= names_cap) {
+                size_t nc = names_cap * 2;
+                while (nc <= depth) nc *= 2;
+                const char** grown = (const char**)realloc(
+                    names, nc * sizeof(*names));
+                if (!grown) goto oom;
+                names = grown;
+                names_cap = nc;
+            }
+            names[depth] = leptris_element_name(e);
+        }
+
+        /* Count (or emit) this element's declarations. */
+        size_t decls = leptris_element_namespace_count(e);
+        for (size_t i = 0; i < decls; i++) {
+            const char* prefix = NULL;
+            const char* uri = NULL;
+            element_namespace_decl_at(e, i, &prefix, &uri);
+            size_t prefix_len = prefix ? strlen(prefix) : 0;
+            size_t uri_len = uri ? strlen(uri) : 0;
+            /* Row bytes: the path names + prefix + href, the
+             * prefix/href NUL-terminated like the attributes_snapshot
+             * lane blobs (bindings read C strings straight out). */
+            size_t row_bytes = (prefix ? prefix_len + 1 : 0) +
+                uri_len + 1;
+            for (uint32_t d = 1; d <= depth; d++) {
+                const char* nm = names[d] ? names[d] : "";
+                row_bytes += strlen(nm) + 1;
+            }
+            if (rows) {
+                if (row_count >= rows_cap ||
+                    blob_used + row_bytes > blob_cap) {
+                    free(stack);
+                    free(names);
+                    return (size_t)-1;
+                }
+                leptris_ns_decl_row* r = &rows[row_count];
+                r->depth = depth;
+                r->name_count = depth;
+                /* Path names: depth components, ancestor-first,
+                 * each NUL-terminated. */
+                r->names_off = (uint32_t)blob_used;
+                for (uint32_t d = 1; d <= depth; d++) {
+                    const char* nm = names[d] ? names[d] : "";
+                    size_t nl = strlen(nm) + 1;
+                    memcpy(blob + blob_used, nm, nl);
+                    blob_used += nl;
+                }
+                if (prefix) {
+                    r->prefix_off = (uint32_t)blob_used;
+                    r->prefix_len = (uint32_t)prefix_len;
+                    memcpy(blob + blob_used, prefix, prefix_len);
+                    blob_used += prefix_len;
+                    blob[blob_used++] = '\0';
+                } else {
+                    r->prefix_off = 0xFFFFFFFFu;
+                    r->prefix_len = 0;
+                }
+                r->href_off = (uint32_t)blob_used;
+                r->href_len = (uint32_t)uri_len;
+                if (uri_len) {
+                    memcpy(blob + blob_used, uri, uri_len);
+                    blob_used += uri_len;
+                }
+                blob[blob_used++] = '\0';
+            } else {
+                /* Sizing pass: measure the same bytes the fill pass
+                 * writes (those advance blob_used inline). */
+                blob_used += row_bytes;
+            }
+            row_count++;
+        }
+
+        /* Push children in REVERSE so the pop order is document
+         * order. */
+        size_t nkids = 0;
+        for (LeptrisElement c = leptris_element_first_child_any(e); c;
+             c = leptris_element_next_sibling_any(c)) {
+            nkids++;
+        }
+        if (sp + nkids > stack_cap) {
+            size_t nc = stack_cap * 2;
+            while (nc < sp + nkids) nc *= 2;
+            struct dfs_entry* grown = (struct dfs_entry*)realloc(
+                stack, nc * sizeof(*stack));
+            if (!grown) goto oom;
+            stack = grown;
+            stack_cap = nc;
+        }
+        /* Collect children into the stack tail backwards. */
+        size_t w = sp + nkids;
+        for (LeptrisElement c = leptris_element_first_child_any(e); c;
+             c = leptris_element_next_sibling_any(c)) {
+            w--;
+            stack[w].e = c;
+            stack[w].depth = depth + 1;
+        }
+        sp += nkids;
+    }
+
+    free(stack);
+    free(names);
+    if (out_row_count) *out_row_count = row_count;
+    if (blob_used_out) *blob_used_out = blob_used;
+    return 0;
+
+oom:
+    free(stack);
+    free(names);
+    if (out_row_count) *out_row_count = 0;
+    if (blob_used_out) *blob_used_out = 0;
+    return (size_t)-1;
+}
+
 /* ============================================================================
  * Namespace mutation (issue #186).
  *
@@ -1790,3 +1949,45 @@ LEPTRIS_API size_t leptris_element_attributes_raw(
     }
     return written;
 }
+
+/* ---- #1855: address-Integer batch faces ------------------------------ */
+
+LEPTRIS_API size_t leptris_element_children_batch(
+    uintptr_t elem_addr,
+    uintptr_t* child_addrs, uint8_t* child_kinds, size_t cap) {
+    if (!elem_addr) return 0;
+    LeptrisElement e = (LeptrisElement)elem_addr;
+    size_t count = 0;
+    /* NODE-level walk: the batch carries every child kind (text,
+     * comment, PI, CDATA included) — first_child_any is
+     * element-only. */
+    for (LeptrisNode* c = leptris_node_first_child((LeptrisNode*)e); c;
+         c = leptris_node_next_sibling(c)) {
+        if (child_addrs && child_kinds && count < cap) {
+            child_addrs[count] = (uintptr_t)c;
+            child_kinds[count] = (uint8_t)c->type;
+        }
+        count++;
+    }
+    /* Undersized cap: write nothing and hand back the count so the
+     * caller sizes and retries (the snapshot-face discipline). */
+    if (count > cap) return count;
+    return count;
+}
+
+LEPTRIS_API int leptris_node_name_compare(uintptr_t node_addr,
+                                          const char* name, size_t len) {
+    if (!node_addr) return -2;
+    const char* node_name = "";
+    if (leptris_node_get_type((LeptrisNodeRef)node_addr) ==
+        LEPTRIS_NODE_TYPE_ELEMENT) {
+        node_name = leptris_element_get_name((LeptrisElement)node_addr);
+        if (!node_name) node_name = "";
+    }
+    size_t node_len = strlen(node_name);
+    size_t min = node_len < len ? node_len : len;
+    int rc = strncmp(node_name, name ? name : "", min);
+    if (rc != 0) return rc < 0 ? -1 : 1;
+    if (node_len == len) return 0;
+    return node_len < len ? -1 : 1;
+}

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

@@ -340,6 +340,33 @@ LeptrisMemoryPool* leptris_pool_create_with_page_size(size_t page_size) {
     return pool;
 }
 
+int leptris_pool_contains(const LeptrisMemoryPool* pool,
+                          const void* addr) {
+    if (!pool || !addr) return 0;
+    for (const MemoryPage* p = pool->first_page; p; p = p->next) {
+        if (p->busy_size <= sizeof(struct memory_page)) continue;
+        const char* lo = p->data;
+        const char* hi =
+            p->data + (p->busy_size - sizeof(struct memory_page));
+        if ((const char*)addr >= lo && (const char*)addr < hi) return 1;
+    }
+    /* Post-parse growth (arena extensions, oversized requests) lives
+     * in tracked malloc blocks outside the span — still pool-owned,
+     * still freed by leptris_pool_destroy. Callers use this predicate
+     * to answer "did this pointer die with the document?"
+     * (leptris#1866). */
+    for (const LeptrisBigAlloc* b = pool->first_big_alloc; b; b = b->next) {
+        if ((const char*)addr >= (const char*)b->ptr &&
+            (const char*)addr < (const char*)b->ptr + b->size) return 1;
+    }
+    if (pool->arena && pool->arena->base) {
+        if ((const char*)addr >= pool->arena->base &&
+            (const char*)addr < pool->arena->base + pool->arena->used)
+            return 1;
+    }
+    return 0;
+}
+
 void leptris_pool_destroy(LeptrisMemoryPool* pool) {
     if (!pool) return;
 

data/vendor-src/libleptris/src/leptris/memory/pool.h

@@ -172,6 +172,11 @@ int leptris_pool_is_arena_backed(const LeptrisMemoryPool* pool);
  * @param pool Pool to destroy (NULL is safe)
  */
 void leptris_pool_destroy(LeptrisMemoryPool* pool);
+/* leptris#1866: nonzero when addr lies within the pool's handed-out
+ * memory — any page's live span, the arena bump region, or a tracked
+ * extension block (freed with the pool like the rest). */
+int leptris_pool_contains(const LeptrisMemoryPool* pool,
+                          const void* addr);
 
 /* Release this thread's recycler pages back to the global pool
  * (leptris_thread_cleanup). */

data/vendor-src/libleptris/src/leptris/xpath/evaluator_axes.c

@@ -755,6 +755,21 @@ XPathNodeSet* apply_axis(XPathContext* ctx, LeptrisNode* node,
         return xpath_nodeset_new();
     }
 
+    /* Attribute inputs: the parent axis resolves through the OWNER
+     * element (XPath 1.0 §2.2 — `./@id/..` names the attribute's
+     * element). The element-typed dispatch below would read the
+     * parent field in element form off the attribute struct and
+     * return empty (leptris#1866, the standoc svg-uniqueids face). */
+    if (axis_id == XPATH_AXIS_PARENT && node && node->type == LEPTRIS_NODE_ATTRIBUTE) {
+        LeptrisElement owner = ((LeptrisAttributeNode*)node)->owner;
+        XPathNodeSet* result = xpath_nodeset_new();
+        if (!result) return result;
+        if (owner && matches_node_test(ctx, (LeptrisNode*)owner, test)) {
+            xpath_nodeset_add(result, owner);
+        }
+        return result;
+    }
+
     LeptrisElement elem = (LeptrisElement)node;
     switch (axis_id) {
         case XPATH_AXIS_DESCENDANT:

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

@@ -20,7 +20,7 @@
 void xsd_capture_ics(struct leptris_xsd_schema* s,
                      LeptrisElement elem, const char* element_name);
 extern int xsd_simple_valid(const XsdSimple* simple, const char* v,
-                            const char* terminal_base);
+                            const char* terminal_base, int chain_is_list);
 extern struct xsd_validator* xsd_validator_new(
     struct leptris_xsd_schema* s);
 extern void xsd_validator_free(struct xsd_validator* v);
@@ -179,6 +179,7 @@ static void xsd_cm_free(XsdCm* cm) {
         free(cm->type);
         free(cm->ns);
         free(cm->ext_base);
+        free(cm->ext_base_ns);
         free(cm->any_ns);
         free(cm->not_qname);
         free(cm->any_unit_tns);
@@ -292,6 +293,9 @@ static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
                 cm->process_skip =
                     (pc && (strcmp(pc, "skip") == 0 ||
                             strcmp(pc, "lax") == 0)) ? 1 : 0;
+                cm->pc_level =
+                    (pc && strcmp(pc, "skip") == 0) ? 2
+                    : (pc && strcmp(pc, "lax") == 0) ? 1 : 0;
             }
         } else {
             continue; /* annotation & friends */
@@ -565,6 +569,25 @@ static int xsd_item_valid(struct leptris_xsd_schema* s,
     return 1;
 }
 
+/* #1882: does the base chain resolve to a LIST type? A restriction
+ * OF a list keeps deriv RESTRICT, but its length facets still count
+ * items — the value space is the list's. */
+static int xsd_chain_is_list(struct leptris_xsd_schema* s,
+                             const XsdSimple* t) {
+    int depth = 0;
+    while (t && depth < 32) {
+        if (t->deriv == XSD_SIMPLE_LIST) return 1;
+        if (!t->base) return 0;
+        if (strncmp(t->base, "xs:", 3) == 0)
+            return strcmp(t->base, "xs:IDREFS") == 0 ||
+                   strcmp(t->base, "xs:NMTOKENS") == 0 ||
+                   strcmp(t->base, "xs:ENTITIES") == 0;
+        t = xsd_find_simple(s, t->base);
+        depth++;
+    }
+    return 0;
+}
+
 /* The chain's terminal builtin (NULL = none resolved): the length
  * family needs it to count octets for the binary bases
  * (leptris-ruby#434). */
@@ -621,7 +644,7 @@ static int xsd_deriv_valid(struct leptris_xsd_schema* s,
                 return 1;
         return 0;
     }
-    return xsd_simple_valid(t, v, xsd_chain_terminal(s, t));
+    return xsd_simple_valid(t, v, xsd_chain_terminal(s, t), 0);
 }
 
 static int xsd_valid_chain(struct leptris_xsd_schema* s,
@@ -633,7 +656,8 @@ static int xsd_valid_chain(struct leptris_xsd_schema* s,
     }
     if (t->deriv != XSD_SIMPLE_RESTRICT)
         return xsd_deriv_valid(s, t, v, depth);
-    return xsd_simple_valid(t, v, xsd_chain_terminal(s, t));
+    return xsd_simple_valid(t, v, xsd_chain_terminal(s, t),
+                            xsd_chain_is_list(s, t));
 }
 
 static void xsd_set_error(struct leptris_xsd_schema* s, const char* msg) {
@@ -2030,7 +2054,13 @@ static void xsd_resolve_extension_bases(struct leptris_xsd_schema* s) {
         progressed = 0;
         for (XsdCm* c = s->complex_types; c; c = c->next) {
             if (!c->ext_base) continue;
-            XsdCm* base = xsd_find_complex_ns(s, c->ext_base, c->ns);
+            /* #1881: the fold resolves in the BASE's namespace —
+             * recorded at capture from the base QName's prefix —
+             * falling back to the deriver's ns (same-unit refs,
+             * where the old behavior lives). */
+            const char* bns = c->ext_base_ns ? c->ext_base_ns : c->ns;
+            XsdCm* base = xsd_find_complex_ns(s, c->ext_base, bns);
+            if (!base) base = xsd_find_complex_ns(s, c->ext_base, c->ns);
             if (!base || base->ext_base) continue;
             XsdCm* copied = xsd_cm_copy_list(base->first_child);
             if (copied) {
@@ -2050,7 +2080,9 @@ static void xsd_resolve_extension_bases(struct leptris_xsd_schema* s) {
                 }
             }
             const XsdTypeAttrs* bt =
-                xsd_find_type_attrs_ns(s, c->ext_base, c->ns);
+                xsd_find_type_attrs_ns(s, c->ext_base, bns);
+            if (!bt)
+                bt = xsd_find_type_attrs_ns(s, c->ext_base, c->ns);
             if (bt) {
                 XsdTypeAttrs* mine = NULL;
                 for (XsdTypeAttrs* t = s->type_attrs; t; t = t->next)
@@ -2094,6 +2126,8 @@ static void xsd_resolve_extension_bases(struct leptris_xsd_schema* s) {
             }
             free(c->ext_base);
             c->ext_base = NULL;
+            free(c->ext_base_ns);
+            c->ext_base_ns = NULL;
             progressed = 1;
         }
     }
@@ -2159,8 +2193,43 @@ static void xsd_visited_add(struct leptris_xsd_schema* s,
     s->visited[s->visited_len++] = dup;
 }
 
+static XsdAttrDecl* xsd_capture_attr_rows(
+    struct leptris_xsd_schema* s, LeptrisElement container, int depth);
+/* #1880: top-level attributeGroup definitions are captured in a
+ * PRE-PASS — the symbol space is order-free, but the ref expansion
+ * in xsd_capture_attr_rows looks up s->attr_groups at capture time,
+ * so a group declared AFTER the referencing type used to vanish. */
+static void xsd_capture_attr_group_def(struct leptris_xsd_schema* s,
+                                       LeptrisElement n,
+                                       const char* nm) {
+    XsdAttrGroupDef* g = (XsdAttrGroupDef*)calloc(1, sizeof(*g));
+    if (!g) return;
+    g->name = xsd_strdup(nm);
+    g->attrs = xsd_capture_attr_rows(s, n, 0);
+    g->next = s->attr_groups;
+    s->attr_groups = g;
+}
+
 static void xsd_capture_root(struct leptris_xsd_schema* s,
                              LeptrisElement root) {
+    /* pre-pass: every top-level attributeGroup def, document order */
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(root));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        const char* local = NULL;
+        const char* uri = NULL;
+        leptris_element_expanded_name((LeptrisElement)n, &local,
+                                      NULL, &uri);
+        if (!local || strcmp(local, "attributeGroup") != 0 ||
+            !uri || strcmp(uri, XSD_NS) != 0)
+            continue;
+        const char* nm = leptris_element_attribute((LeptrisElement)n,
+                                                   "name");
+        if (!nm) continue;
+        xsd_capture_attr_group_def(s, (LeptrisElement)n, nm);
+    }
     for (LeptrisNodeRef n =
              leptris_node_first_child(leptris_element_as_node(root));
          n; n = leptris_node_next_sibling(n)) {
@@ -2371,16 +2440,13 @@ static void xsd_capture_root(struct leptris_xsd_schema* s,
         } else if (strcmp(local, "attributeGroup") == 0 && uri && !strcmp(uri, XSD_NS)) {
             const char* nm =
                 leptris_element_attribute((LeptrisElement)n, "name");
+            /* the #1880 pre-pass already captured it — a second
+             * registration would shadow the first */
             if (nm) {
-                XsdAttrGroupDef* g =
-                    (XsdAttrGroupDef*)calloc(1, sizeof(*g));
-                if (g) {
-                    g->name = xsd_strdup(nm);
-                    g->attrs = xsd_capture_attr_rows(
-                        s, (LeptrisElement)n, 0);
-                    g->next = s->attr_groups;
-                    s->attr_groups = g;
-                }
+                XsdAttrGroupDef* seen = s->attr_groups;
+                for (; seen; seen = seen->next)
+                    if (strcmp(seen->name, nm) == 0) break;
+                if (!seen) xsd_capture_attr_group_def(s, (LeptrisElement)n, nm);
             }
         } else if (strcmp(local, "group") == 0 && uri && !strcmp(uri, XSD_NS)) {
             const char* nm =
@@ -2569,6 +2635,7 @@ static XsdCm* xsd_cm_copy_list(const XsdCm* head) {
         d->any_ns = xsd_strdup(src->any_ns);
         d->any_unit_tns = xsd_strdup(src->any_unit_tns);
         d->process_skip = src->process_skip;
+        d->pc_level = src->pc_level;
         d->min = src->min;
         d->max = src->max;
         d->first_child = xsd_cm_copy_list(src->first_child);
@@ -2662,6 +2729,8 @@ static XsdCm* xsd_capture_any(LeptrisElement any_child) {
         (pc && (strcmp(pc, "skip") == 0 || strcmp(pc, "lax") == 0))
             ? 1
             : 0;
+    w->pc_level = (pc && strcmp(pc, "skip") == 0) ? 2
+                  : (pc && strcmp(pc, "lax") == 0) ? 1 : 0;
     w->min = 0;
     w->max = -1;
     return w;
@@ -2746,7 +2815,21 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                     continue;
                 const char* base_raw =
                     leptris_element_attribute(dq, "base");
-                const char* base = xsd_local_name(base_raw);
+                /* #1881: resolve the base QName against the
+                 * extension element's in-scope declarations — the
+                 * resolved namespace rides the deferral so the
+                 * post-capture fold can cross units (g:foo1 extends
+                 * f:foo). */
+                char buri[256], blocal[256];
+                buri[0] = 0;
+                blocal[0] = 0;
+                if (base_raw)
+                    xsd_resolve_qname(dq, base_raw, buri, sizeof(buri),
+                                      blocal, sizeof(blocal));
+                const char* base =
+                    base_raw ? (blocal[0] ? blocal
+                                          : xsd_local_name(base_raw))
+                             : NULL;
                 XsdCm* base_root =
                     (base && strncmp(base, "xs:", 3) != 0)
                         ? xsd_find_complex_ns(s, base, s->target_ns)
@@ -2771,6 +2854,9 @@ static XsdCm* xsd_capture_complex_model(struct leptris_xsd_schema* s,
                     strcmp(dl, "extension") == 0) {
                     free(root->ext_base);
                     root->ext_base = xsd_strdup(base);
+                    free(root->ext_base_ns);
+                    root->ext_base_ns =
+                        buri[0] ? xsd_strdup(buri) : NULL;
                 }
                 if (strcmp(dl, "extension") == 0) {
                     /* base content first, derived content after */
@@ -3578,3 +3664,134 @@ LEPTRIS_API const char* leptris_xsd_error(LeptrisXsdSchema schema) {
     if (!schema) return NULL;
     return ((struct leptris_xsd_schema*)schema)->error;
 }
+
+/* leptris#1881: schema-set compilation — every listed document's
+ * declarations merge into ONE schema. The per-document pipeline is
+ * the single-compile one (checks, per-unit tns, capture); the
+ * visited-set is seeded with every member path first so an import
+ * chain back to a set member does not recapture it, and extension
+ * bases resolve ONCE after all units are in (type references
+ * resolve against the whole schema, the leptris-ruby#440 law). */
+LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile_set(
+    const char* const* paths, size_t count, LeptrisStatus* status) {
+    if (status) *status = LEPTRIS_OK;
+    if (!paths || count == 0) {
+        if (status) *status = LEPTRIS_ERROR_PARSE;
+        return NULL;
+    }
+    struct leptris_xsd_schema* s =
+        (struct leptris_xsd_schema*)calloc(1, sizeof(*s));
+    if (!s) {
+        if (status) *status = LEPTRIS_ERROR_MEMORY;
+        return NULL;
+    }
+    const char* main_tns = NULL;
+    for (size_t i = 0; i < count; i++) {
+        const char* path = paths[i];
+        if (!path || !*path) {
+            xsd_set_error(s, "schema set member path is empty");
+            if (status) *status = LEPTRIS_ERROR_PARSE;
+            return s;
+        }
+        size_t len = 0;
+        char* text = xsd_read_file(path, &len);
+        if (!text) {
+            xsd_set_error(s, "schema set member cannot be read");
+            if (status) *status = LEPTRIS_ERROR_PARSE;
+            return s;
+        }
+        const char* slash = strrchr(path, '/');
+        const char* bslash = strrchr(path, '\\');
+        if (bslash && (!slash || bslash > slash)) slash = bslash;
+        char* base_dir = NULL;
+        if (slash) {
+            size_t n = (size_t)(slash - path);
+            if (n == 0) n = 1;
+            base_dir = (char*)malloc(n + 1);
+            if (base_dir) {
+                memcpy(base_dir, path, n);
+                base_dir[n] = 0;
+            }
+        } else {
+            base_dir = xsd_strdup(".");
+        }
+
+        LeptrisDocument doc =
+            leptris_parse_string(text, len, status);
+        free(text);
+        if (!doc) {
+            xsd_set_error(s,
+                          "schema set member is not well-formed XML");
+            free(base_dir);
+            if (status) *status = LEPTRIS_ERROR_PARSE;
+            return s;
+        }
+        LeptrisElement root = leptris_document_root(doc);
+        if (!root) {
+            xsd_set_error(s, "schema set member has no root element");
+            leptris_document_free(doc);
+            free(base_dir);
+            if (status) *status = LEPTRIS_ERROR_PARSE;
+            return s;
+        }
+        const char* local = NULL;
+        const char* uri = NULL;
+        leptris_element_expanded_name(root, &local, NULL, &uri);
+        if (!local || strcmp(local, "schema") != 0 ||
+            (uri && strcmp(uri, XSD_NS) != 0)) {
+            xsd_set_error(s, "schema set member root is not xs:schema");
+            leptris_document_free(doc);
+            free(base_dir);
+            if (status) *status = LEPTRIS_ERROR_PARSE;
+            return s;
+        }
+        const char* doc_tns =
+            leptris_element_attribute(root, "targetNamespace");
+        char* saved = s->base_dir;
+        s->base_dir = base_dir;
+        if (i == 0) {
+            main_tns = doc_tns;
+            s->target_ns = xsd_strdup(doc_tns);
+        }
+        /* Per-unit tns during checks + capture; the visited-set
+         * seeds each member so import chains close (the import in
+         * g.xsd would otherwise re-capture f.xsd mid-set). */
+        {
+            char* saved_ns = s->target_ns;
+            s->target_ns = xsd_strdup(doc_tns);
+            char canon[4096];
+            xsd_path_normalize(path, canon, sizeof(canon));
+            /* An earlier member's import may have captured this
+             * document already (order [importer, imported]) — the
+             * visited check keeps each unit to one capture. */
+            if (xsd_visited_has(s, canon)) {
+                free(s->target_ns);
+                s->target_ns = saved_ns;
+                leptris_document_free(doc);
+                free(base_dir);
+                s->base_dir = saved;
+                continue;
+            }
+            xsd_visited_add(s, canon);
+            int bad = xsd_check_structure(s, root, 0) != 0 ||
+                      xsd_check_derivation(s, root) != 0 ||
+                      xsd_check_refs(s, root) != 0 ||
+                      xsd_check_upa(s, root) != 0 ||
+                      xsd_check_include_tns(s, root) != 0;
+            if (!bad) xsd_capture_root(s, root);
+            free(s->target_ns);
+            s->target_ns = saved_ns;
+            if (bad) {
+                leptris_document_free(doc);
+                free(base_dir);
+                if (status) *status = LEPTRIS_ERROR_PARSE;
+                return s;
+            }
+        }
+        leptris_document_free(doc);
+        free(base_dir);
+        s->base_dir = saved;
+    }
+    xsd_resolve_extension_bases(s);
+    return s;
+}