leptris 1.9.201.0-arm-linux → 1.9.201.2-arm-linux

data/vendor-src/libleptris/src/leptris/xslt/xslt_parse.c

@@ -0,0 +1,2418 @@
+/* xslt/xslt_parse.c — stylesheet compilation (TODO.transform 02/03).
+ *
+ * Parses an XSLT 1.0 stylesheet (an XML document) into the
+ * instruction forest: every select/test/name is compiled ONCE via
+ * leptris_xpath_compile; literal result elements carry their
+ * qualified name + namespace. xsl:include is inlined; xsl:import
+ * becomes a higher import_rank (lower precedence). Whitespace-only
+ * text in the STYLESHEET is dropped (§4.8 stripping) outside
+ * xsl:text.
+ *
+ * Multi-file loading: import/include resolve `href` via
+ * leptris_parse_file (v1 base = CWD); a depth guard prevents
+ * cycles. Includes keep the same import_rank; imports increment
+ * it. Variables have a per-parse name table for duplicate marking.
+ */
+#include "xslt_internal.h"
+#include "../dom/text.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+#define XSLT_INCLUDE_DEPTH_MAX 64
+
+typedef struct {
+    char** paths;
+    size_t len, cap;
+} XsltImportChain;
+
+static int chain_has(XsltImportChain* c, const char* p);
+static int chain_push(XsltImportChain* c, const char* p);
+static void chain_pop(XsltImportChain* c);
+
+/* Text content of a node child (TEXT/CDATA). */
+static const char* leptris_node_text(LeptrisNodeRef n) {
+    if (!n) return NULL;
+    if (leptris_node_get_type(n) == LEPTRIS_NODE_TYPE_TEXT ||
+        leptris_node_get_type(n) == LEPTRIS_NODE_TYPE_CDATA) {
+        return leptris_text_get_content((LeptrisTextNode*)n);
+    }
+    return NULL;
+}
+
+#define XSLT_NS "http://www.w3.org/1999/XSL/Transform"
+
+typedef struct {
+    LeptrisDocument doc;
+    XsltStylesheet* sheet;
+    int import_rank;
+    int errors;             /* any compile failure fails the sheet */
+    XsltImportChain chain;  /* paths seen so far for cycle detection */
+} SheetParser;
+
+static int chain_has(XsltImportChain* c, const char* p) {
+    for (size_t i = 0; i < c->len; i++)
+        if (strcmp(c->paths[i], p) == 0) return 1;
+    return 0;
+}
+static int chain_push(XsltImportChain* c, const char* p) {
+    if (c->len == c->cap) {
+        size_t nc = c->cap ? c->cap * 2 : 8;
+        char** np = (char**)realloc(c->paths, nc * sizeof(char*));
+        if (!np) return 0;
+        c->paths = np; c->cap = nc;
+    }
+    c->paths[c->len] = leptris_strdup(p);
+    if (!c->paths[c->len]) return 0;
+    c->len++;
+    return 1;
+}
+static void chain_pop(XsltImportChain* c) {
+    if (c->len) { free(c->paths[--c->len]); c->paths[c->len] = NULL; }
+}
+
+static int node_is_xsl(LeptrisElement e, const char* local) {
+    if (!e) return 0;
+    const char* pfx = leptris_element_prefix(e);
+    if (!pfx || strcmp(pfx, "xsl") != 0) {
+        /* Also accept default-namespaced stylesheets. */
+        const char* uri = leptris_element_get_namespace_uri(e);
+        if (!uri || strcmp(uri, XSLT_NS) != 0) return 0;
+    } else {
+        const char* uri = leptris_element_get_namespace_uri(e);
+        if (uri && strcmp(uri, XSLT_NS) != 0) return 0;
+    }
+    const char* n = leptris_element_get_name(e);
+    if (!n) return 0;
+    const char* colon = strchr(n, ':');
+    const char* local_n = colon ? colon + 1 : n;
+    return strcmp(local_n, local) == 0;
+}
+
+#define EXSLT_FUNCTIONS_NS "http://exslt.org/functions"
+
+/* EXSLT func module element (any prefix bound to the functions ns). */
+static int node_is_exslt_func(LeptrisElement e, const char* local) {
+    if (!e) return 0;
+    const char* uri = leptris_element_get_namespace_uri(e);
+    if (!uri || strcmp(uri, EXSLT_FUNCTIONS_NS) != 0) return 0;
+    const char* n = leptris_element_get_name(e);
+    if (!n) return 0;
+    const char* colon = strchr(n, ':');
+    const char* local_n = colon ? colon + 1 : n;
+    return strcmp(local_n, local) == 0;
+}
+
+static LeptrisXPathCompiled compile_attr_sp(SheetParser* sp,
+                                             LeptrisElement e,
+                                             const char* attr) {
+    const char* v = leptris_element_attribute(e, attr);
+    if (!v || !v[0]) return NULL;
+    /* XQuery-only brace syntax must fail loudly (#692: some brace
+     * shapes phantom-compiled to silent empty). The compiler runs
+     * FIRST; braces are real tokens (TOK_LBRACE/TOK_COLON) accepted
+     * ONLY by the map-constructor grammar, so any other brace shape
+     * fails the parse right here — loud by construction. (The old
+     * post-compile brace backstop was retired when map constructors
+     * made brace-bearing selects legitimate.) */
+    LeptrisXPathCompiled c = leptris_xpath_compile(v);
+    if (!c) {
+        if (sp) sp->errors = 1;
+        return NULL;
+    }
+    return c;
+}
+
+
+/* Portable, reentrant tokenizer (strtok_r is POSIX-only; the
+ * import/include recursion also makes plain strtok unsafe). */
+static char* xslt_strtok(char* s, const char* delims, char** save) {
+    char* p = s ? s : *save;
+    if (!p) return NULL;
+    while (*p) {
+        const char* d = delims;
+        int hit = 0;
+        while (*d) { if (*p == *d) { hit = 1; break; } d++; }
+        if (!hit) break;
+        p++;
+    }
+    if (!*p) { *save = p; return NULL; }
+    char* tok = p;
+    while (*p) {
+        const char* d = delims;
+        int hit = 0;
+        while (*d) { if (*p == *d) { hit = 1; break; } d++; }
+        if (hit) break;
+        p++;
+    }
+    if (*p) { *p = 0; *save = p + 1; }
+    else *save = p;
+    return tok;
+}
+
+
+static XsltInstr* instr_new(XsltInstrKind k) {
+    XsltInstr* in = (XsltInstr*)calloc(1, sizeof(*in));
+    if (in) in->kind = k;
+    return in;
+}
+
+static void instr_append(XsltInstr** list, XsltInstr* in) {
+    if (!in) return;
+    if (!*list) { *list = in; return; }
+    XsltInstr* t = *list;
+    while (t->next) t = t->next;
+    t->next = in;
+}
+
+static char* resolve_set_uri(LeptrisElement e, const char* qname);
+
+/* Collect use-attribute-sets into name list (comma-separated,
+ * whitespace ignored). Stores copy of each name on the
+ * instruction. Returns count. */
+static size_t collect_attr_sets(XsltInstr* in, LeptrisElement e) {
+    const char* v = leptris_element_attribute(e, "use-attribute-sets");
+    if (!v || !*v)
+        v = leptris_element_attribute(e, "xsl:use-attribute-sets");
+    if (!v || !*v) return 0;
+    char* dup = leptris_strdup(v);
+    if (!dup) return 0;
+    size_t cap = 0, cnt = 0;
+    char** arr = NULL;
+    char** uris = NULL;
+    char* save = NULL;
+    for (char* tok = xslt_strtok(dup, " \t\n,", &save); tok;
+         tok = xslt_strtok(NULL, " \t\n,", &save)) {
+        if (cnt == cap) {
+            cap = cap ? cap * 2 : 4;
+            char** na = (char**)realloc(arr, cap * sizeof(char*));
+            char** nu = (char**)realloc(uris, cap * sizeof(char*));
+            if (!na || !nu) { free(na); free(nu); break; }
+            arr = na; uris = nu;
+        }
+        arr[cnt] = leptris_strdup(tok);
+        uris[cnt] = resolve_set_uri(e, tok);
+        cnt++;
+    }
+    free(dup);
+    in->attr_set_names = arr;
+    in->attr_set_uris = uris;
+    in->attr_set_count = cnt;
+    return cnt;
+}
+
+static XsltSort* parse_sorts(SheetParser* sp, LeptrisElement parent) {
+    XsltSort* head = NULL;
+    XsltSort** tail = &head;
+    for (LeptrisElement c = leptris_element_first_child_any(parent); c;
+         c = leptris_element_next_sibling_any(c)) {
+        if (!node_is_xsl(c, "sort")) continue;
+        XsltSort* s = (XsltSort*)calloc(1, sizeof(*s));
+        if (!s) continue;
+        s->select = compile_attr_sp(sp, c, "select");
+        const char* dt = leptris_element_attribute(c, "data-type");
+        s->numeric = dt && strcmp(dt, "number") == 0;
+        const char* od = leptris_element_attribute(c, "order");
+        s->descending = od && strcmp(od, "descending") == 0;
+        const char* co = leptris_element_attribute(c, "case-order");
+        s->case_upper_first = co ? strcmp(co, "upper-first") == 0 : -1;
+        *tail = s;
+        tail = &s->next;
+    }
+    return head;
+}
+
+/* Forward: the instruction compiler and the content compiler. */
+static XsltInstr* parse_instruction(SheetParser* sp, LeptrisElement e);
+static XsltInstr* parse_content_ws(SheetParser* sp, LeptrisElement list,
+                                   int preserve_ws);
+#define parse_content(sp, list) parse_content_ws(sp, list, 0)
+
+
+/* §4/§5.3: collect the in-scope namespace bindings for a stylesheet
+ * element (its own xmlns decls plus every ancestor's, innermost
+ * wins). Returns NULL when nothing is declared — the hot path. */
+static LeptrisXPathNsSet build_ns_context(LeptrisElement e) {
+    LeptrisXPathNsSet set = NULL;
+    for (LeptrisElement a = e; a;
+         a = leptris_node_parent((LeptrisNodeRef)a)) {
+        for (int i = 0;; i++) {
+            const char* pfx = leptris_element_namespace_decl_prefix(a, i);
+            const char* uri = leptris_element_namespace_decl_uri(a, i);
+            /* A NULL PREFIX is the default namespace declaration —
+             * it does NOT end the list (only a missing URI does);
+             * bug-50-: the default on the stylesheet root stopped
+             * the walk before later prefixes (tst) were seen. */
+            if (!uri) break;
+            if (!pfx || !*pfx) continue;
+            if (!set) set = leptris_xpath_ns_set_new();
+            if (set) leptris_xpath_ns_set_add(set, pfx, uri);
+        }
+    }
+    return set;
+}
+
+/* Expanded-name URI for a prefixed attribute-set reference (NULL
+ * when unprefixed or unbound) — declarations and references may
+ * spell different prefixes for the same URI (bug-190). */
+static char* resolve_set_uri(LeptrisElement e, const char* qname) {
+    const char* colon = strchr(qname, ':');
+    if (!colon || colon == qname) return NULL;
+    LeptrisXPathNsSet ns = build_ns_context(e);
+    if (!ns) return NULL;
+    const char* u = leptris_xpath_ns_lookup(
+        (const struct leptris_xpath_ns_map*)ns, qname,
+        (size_t)(colon - qname));
+    char* r = u ? leptris_strdup(u) : NULL;
+    leptris_xpath_ns_set_free(ns);
+    return r;
+}
+
+
+/* §7.1.1: the namespace declarations a literal result element
+ * copies into the result — its in-scope bindings minus the XSLT
+ * namespace (and the xsl prefix). Innermost binding wins per
+ * prefix; the default namespace (if any) is returned separately. */
+
+static int xs_ns_strcmp(const char* a, const char* b) {
+    return strcmp(a ? a : "", b ? b : "");
+}
+static int prefix_excluded(SheetParser* sp, LeptrisElement e,
+                           const char* pfx) {
+    /* Sheet-wide exclude-result-prefixes / extension-element-
+     * prefixes, plus any xsl:exclude-result-prefixes on the
+     * instruction element itself (v1: not the full ancestor walk). */
+    for (size_t i = 0; i < sp->sheet->exclude_count; i++)
+
+if (xs_ns_strcmp(sp->sheet->exclude_pfx[i], pfx) == 0) return 1;
+    const char* loc = leptris_element_attribute(e,
+                                                "xsl:exclude-result-"
+                                                "prefixes");
+    if (!loc || !*loc)
+        loc = leptris_element_attribute(e, "exclude-result-prefixes");
+    if (loc && *loc) {
+        char* dup = leptris_strdup(loc);
+        if (dup) {
+            char* save = NULL;
+            for (char* tok = xslt_strtok(dup, " \t\n,", &save); tok;
+                 tok = xslt_strtok(NULL, " \t\n,", &save)) {
+                if (xs_ns_strcmp(tok, pfx) == 0) { free(dup); return 1; }
+            }
+            free(dup);
+        }
+    }
+    return 0;
+}
+
+static void build_ns_copy(SheetParser* sp, LeptrisElement e,
+                          char*** out_pfx, char*** out_uri,
+                          size_t* out_count, char** out_default,
+                          size_t* out_default_pos) {
+    *out_pfx = NULL; *out_uri = NULL; *out_count = 0; *out_default = NULL;
+    *out_default_pos = (size_t)-1;
+    char** pfx = NULL;
+    char** uri = NULL;
+    size_t cnt = 0, cap = 0;
+    char* deflt = NULL;
+    size_t dpos = (size_t)-1;
+        for (LeptrisElement a = e; a;
+         a = leptris_node_parent((LeptrisNodeRef)a)) {
+        for (int i = 0;; i++) {
+            const char* p = leptris_element_namespace_decl_prefix(a, i);
+            const char* u = leptris_element_namespace_decl_uri(a, i);
+            /* End of declarations: accessor returns no URI. A NULL
+             * PREFIX is the default namespace. */
+            if (!u) break;
+            if (xs_ns_strcmp(u, XSLT_NS) == 0) continue;   /* never copy XSLT */
+            if (prefix_excluded(sp, a, p)) continue;
+            if (!p || !*p) {
+                if (!deflt) {
+                    deflt = leptris_strdup(u);
+                    /* Source position: how many prefixed entries
+                     * precede it decides its emission slot. */
+                    dpos = cnt;
+                }
+                continue;
+            }
+            int have = 0;
+            for (size_t k = 0; k < cnt; k++)
+                if (xs_ns_strcmp(pfx[k], p) == 0) {
+                    have = 1; break;
+                }
+            if (have) continue;
+            if (cnt == cap) {
+                cap = cap ? cap * 2 : 4;
+                pfx = (char**)realloc(pfx, cap * sizeof(char*));
+                uri = (char**)realloc(uri, cap * sizeof(char*));
+            }
+            pfx[cnt] = leptris_strdup(p);
+            uri[cnt] = leptris_strdup(u);
+            cnt++;
+        }
+    }
+    if (cnt || deflt) {
+        *out_pfx = pfx; *out_uri = uri; *out_count = cnt;
+        *out_default = deflt;
+        *out_default_pos = dpos;
+    } else {
+        free(pfx); free(uri);
+    }
+}
+
+static XsltInstr* parse_instruction(SheetParser* sp, LeptrisElement e) {
+    const char* name = leptris_element_get_name(e);
+    const char* colon = name ? strchr(name, ':') : NULL;
+    const char* local = colon ? colon + 1 : name;
+    int is_xsl = node_is_xsl(e, local ? local : "");
+
+    if (!is_xsl) {
+        /* EXSLT func:result: the user-function yield instruction. */
+        if (node_is_exslt_func(e, "result")) {
+            XsltInstr* in = instr_new(XSLT_INSTR_FUNC_RESULT);
+            if (!in) return NULL;
+            in->select = compile_attr_sp(sp, e, "select");
+            /* The select resolves with the ENCLOSING function's
+             * in-scope bindings (bug-225: exsl:node-set's prefix
+             * otherwise has no ns_set at eval time). */
+            in->ns = build_ns_context((LeptrisElement)e);
+            in->child = parse_content(sp, e);
+            return in;
+        }
+        /* EXSLT func:param: a VARIABLE with template-parameter
+         * semantics — the call binds the argument; the walker skips
+         * it (is_param) like xsl:param. */
+        if (node_is_exslt_func(e, "param")) {
+            XsltInstr* in = instr_new(XSLT_INSTR_VARIABLE);
+            if (!in) return NULL;
+            const char* pn = leptris_element_attribute(e, "name");
+            in->name = leptris_strdup(pn);
+            in->select = compile_attr_sp(sp, e, "select");
+            in->ns = build_ns_context((LeptrisElement)e);
+            in->is_param = 1;
+            return in;
+        }
+        /* §15: an element in an extension namespace is an unknown
+         * extension element — compile to its xsl:fallback children
+         * only (bug-220); the element itself and non-fallback
+         * children are dropped. */
+        {
+            const char* epfx = leptris_element_prefix(e);
+            if (epfx && *epfx && sp->sheet->ext_count) {
+                int is_ext = 0;
+                for (size_t i = 0; i < sp->sheet->ext_count; i++)
+                    if (strcmp(sp->sheet->ext_pfx[i], epfx) == 0) {
+                        is_ext = 1; break;
+                    }
+                if (is_ext) {
+                    XsltInstr* fin = instr_new(XSLT_INSTR_UNKNOWN_XSL);
+                    if (!fin) return NULL;
+                    fin->name = leptris_strdup(name);
+                    XsltInstr** ftail = &fin->child;
+                    for (LeptrisElement c =
+                             leptris_element_first_child_any(e); c;
+                         c = leptris_element_next_sibling_any(c)) {
+                        if (!node_is_xsl(c, "fallback")) continue;
+                        XsltInstr* content = parse_content(sp, c);
+                        if (!content) continue;
+                        *ftail = content;
+                        while (*ftail) ftail = &(*ftail)->next;
+                    }
+                    return fin;
+                }
+            }
+        }
+        /* Literal result element. The stored name is the FULL QName
+         * (prefix:local) — element_name() yields only the local
+         * part, and xsl:namespace-alias + namespace output need the
+         * prefix. */
+        XsltInstr* in = instr_new(XSLT_INSTR_RESULT_ELEM);
+        if (!in) return NULL;
+        const char* pfx = leptris_element_prefix(e);
+        char qname[256];
+        if (pfx && pfx[0])
+            snprintf(qname, sizeof(qname), "%s:%s", pfx,
+                     name ? name : "");
+        else
+            snprintf(qname, sizeof(qname), "%s", name ? name : "");
+        in->name = leptris_strdup(qname);
+        in->ns_uri = leptris_strdup(
+            leptris_element_get_namespace_uri(e) ? leptris_element_get_namespace_uri(e) : "");
+        XsltLAttr** atail = &in->attrs;
+        size_t na = leptris_element_attribute_count(e);
+        for (size_t i = 0; i < na; i++) {
+            const char* an = leptris_element_attribute_name_at(e, i);
+            const char* av = leptris_element_attribute_value_at(e, i);
+            if (!an || !av) continue;
+            if (strcmp(an, "xmlns") == 0 ||
+                strncmp(an, "xmlns:", 6) == 0) continue;
+            /* Attributes in the XSLT namespace are directives
+             * (xsl:use-attribute-sets, xsl:version, xsl:exclude-,
+             * xsl:extension-element-prefixes) — never literal
+             * output. The unprefixed spelling is tolerated too
+             * (read by collect_attr_sets). */
+            if (strncmp(an, "xsl:", 4) == 0 ||
+                strcmp(an, "use-attribute-sets") == 0) continue;
+            XsltLAttr* la = (XsltLAttr*)calloc(1, sizeof(*la));
+            if (!la) continue;
+            la->name = leptris_strdup(an);
+            la->value = leptris_strdup(av);
+            *atail = la;
+            atail = &la->next;
+        }
+        collect_attr_sets(in, e);
+        /* §7.1.1: namespace declarations copied into the result. */
+        build_ns_copy(sp, e, &in->ns_out_pfx, &in->ns_out_uri,
+                      &in->ns_out_count, &in->ns_out_default,
+                      &in->ns_out_default_pos);
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "namespace") == 0) {
+        /* §11.7 (2.0): construct a namespace node on the pending
+         * parent — @name prefix, content = URI. */
+        XsltInstr* in = instr_new(XSLT_INSTR_NAMESPACE);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "document") == 0) {
+        /* §11.8 (2.0): content becomes children of the pending
+         * parent (a document constructor in sequence content is
+         * the content itself). */
+        XsltInstr* in = instr_new(XSLT_INSTR_DOCUMENT);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "on-completion") == 0) {
+        /* 3.0 §12.5: runs after xsl:iterate completes without
+         * xsl:break. */
+        XsltInstr* in = instr_new(XSLT_INSTR_ON_COMPLETION);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "merge") == 0) {
+        /* 3.0 §14.3: children are merge-source* + one merge-action. */
+        XsltInstr* in = instr_new(XSLT_INSTR_MERGE);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "merge-source") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_MERGE_SOURCE);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        in->select = compile_attr_sp(sp, e, "select");
+        /* Children are merge-key declarations. */
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "merge-key") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_MERGE_KEY);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        /* @order="descending" flips the sort; reused field (v1
+         * honors the FIRST key's order across the composite). */
+        const char* od = leptris_element_attribute(e, "order");
+        in->num_start_at = (od && strcmp(od, "descending") == 0);
+        return in;
+    }
+    if (strcmp(local, "merge-action") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_MERGE_ACTION);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "result-document") == 0) {
+        /* 2.0/3.0 §11.8: content is serialized to the href FILE
+         * (v1: static href, xml method); the principal result is
+         * unchanged. */
+        XsltInstr* in = instr_new(XSLT_INSTR_RESULT_DOCUMENT);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "href"));
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "map") == 0) {
+        /* 3.0 §18: children are xsl:map-entry declarations. */
+        XsltInstr* in = instr_new(XSLT_INSTR_MAP);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "map-entry") == 0) {
+        /* §18: @key is an EXPRESSION (Saxon-HE 12.7 verified:
+         * key="'k'" — a bare name would be a path). Value: @select
+         * or the content. */
+        XsltInstr* in = instr_new(XSLT_INSTR_MAP_ENTRY);
+        if (!in) return NULL;
+        in->test = compile_attr_sp(sp, e, "key");
+        in->select = compile_attr_sp(sp, e, "select");
+        in->child = parse_content(sp, e);
+        return in;
+    }
+
+    if (strcmp(local, "text") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_TEXT);
+        if (!in) return NULL;
+        const char* t = leptris_element_child_value(e);
+        in->text = leptris_strdup(t ? t : "");
+        in->tvt = sp->sheet->expand_text && strchr(in->text, '{') != NULL;
+        const char* doe = leptris_element_attribute(e, "disable-output-escaping");
+        in->doe = doe && strcmp(doe, "yes") == 0;
+        return in;
+    }
+    if (strcmp(local, "sequence") == 0 ||
+        strcmp(local, "perform-sort") == 0) {
+        /* 3.0 §12.7/§14: one instruction — perform-sort is the
+         * sequence with xsl:sort children applied. */
+        XsltInstr* in = instr_new(XSLT_INSTR_SEQUENCE);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        in->sorts = parse_sorts(sp, e);
+        return in;
+    }
+    if (strcmp(local, "value-of") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_VALUE_OF);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        /* select="." fast path (#682): the string-value of the
+         * context node needs no evaluation — flag it at parse
+         * time. Whitespace around the dot is legal XPath; a '{'
+         * means the 3.0 attribute is a value template, never a
+         * bare dot. */
+        const char* sel = leptris_element_attribute(e, "select");
+        if (sel) {
+            while (*sel == ' ' || *sel == '\t' || *sel == '\r' ||
+                   *sel == '\n') sel++;
+            const char* end = sel;
+            while (*end) end++;
+            while (end > sel && (end[-1] == ' ' || end[-1] == '\t' ||
+                                 end[-1] == '\r' || end[-1] == '\n'))
+                end--;
+            in->select_is_dot = end - sel == 1 && *sel == '.' &&
+                                !strchr(sel, '{');
+            /* select="@name" fast path (#682): a single unprefixed
+             * attribute step — leptris_element_attribute's bare-name
+             * rule (no-namespace only, #542) is exactly the XPath
+             * unprefixed attribute name test. Prefixed names keep
+             * the full path (prefix-error semantics differ). */
+            if (end - sel >= 2 && *sel == '@' && !strchr(sel, '{')) {
+                const char* nm = sel + 1;
+                int ok = (*nm == '_' || (*nm >= 'a' && *nm <= 'z') ||
+                          (*nm >= 'A' && *nm <= 'Z'));
+                for (const char* c = nm + ok; ok && c < end; c++) {
+                    if (*c == ':' || *c == '{') { ok = 0; break; }
+                    if (!(*c == '_' || *c == '-' || *c == '.' ||
+                          (*c >= 'a' && *c <= 'z') ||
+                          (*c >= 'A' && *c <= 'Z') ||
+                          (*c >= '0' && *c <= '9')))
+                        { ok = 0; break; }
+                }
+                if (ok) in->select_attr_name = nm;
+            }
+        }
+        const char* doe = leptris_element_attribute(e, "disable-output-escaping");
+        in->doe = doe && strcmp(doe, "yes") == 0;
+        return in;
+    }
+    if (strcmp(local, "for-each") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_FOR_EACH);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        in->sorts = parse_sorts(sp, e);
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "iterate") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_ITERATE);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        /* Leading xsl:param children are the iteration state; the
+         * walker skips is_param VARIABLEs, so the body plays straight
+         * from in->child. */
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "for-each-group") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_FOR_EACH_GROUP);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        in->group_by = compile_attr_sp(sp, e, "group-by");
+        if (!in->group_by) {
+            in->group_by = compile_attr_sp(sp, e, "group-adjacent");
+            in->group_adjacent = (in->group_by != NULL);
+        }
+        /* Single-alternative patterns; the standard matcher does the
+         * per-item match. */
+        const char* gsw =
+            leptris_element_attribute(e, "group-starting-with");
+        const char* gew =
+            leptris_element_attribute(e, "group-ending-with");
+        for (int pi = 0; pi < 2; pi++) {
+            const char* src = pi == 0 ? gsw : gew;
+            if (!src || !*src) continue;
+            XsltPattern* p = (XsltPattern*)calloc(1, sizeof(*p));
+            if (p) {
+                p->expr = leptris_xpath_compile(src);
+                if (p->expr) {
+                    xslt_pattern_compile_steps(p, src);
+                    if (pi == 0) in->group_starting = p;
+                    else in->group_ending = p;
+                } else {
+                    free(p);
+                }
+            }
+        }
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "evaluate") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_EVALUATE);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "xpath");
+        in->context_item = compile_attr_sp(sp, e, "context-item");
+        /* Children are xsl:with-param for the dynamic phase. */
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "analyze-string") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_ANALYZE_STRING);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        const char* rx = leptris_element_attribute(e, "regex");
+        if (rx) in->regex = leptris_strdup(rx);
+        const char* rf = leptris_element_attribute(e, "regex-flags");
+        if (rf) in->regex_flags = leptris_strdup(rf);
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "matching-substring") == 0 ||
+        strcmp(local, "non-matching-substring") == 0) {
+        XsltInstr* in = instr_new(
+            local[0] == 'm' ? XSLT_INSTR_MATCHING_SUBSTRING
+                            : XSLT_INSTR_NONMATCHING_SUBSTRING);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "try") == 0 || strcmp(local, "catch") == 0) {
+        /* §17: xsl:catch is only valid as a CHILD of xsl:try. A
+         * misplaced catch is a static error (Saxon: XTSE0010) —
+         * silently skipping it turned a catchable error into an
+         * unexplained NULL transform (issue #669). */
+        if (local[0] == 'c') {
+            LeptrisElement parent =
+                leptris_node_parent((LeptrisNodeRef)e);
+            if (!parent || !node_is_xsl(parent, "try")) {
+                sp->errors = 1;
+                return NULL;
+            }
+        }
+        XsltInstr* in = instr_new(
+            local[0] == 't' ? XSLT_INSTR_TRY : XSLT_INSTR_CATCH);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "on-empty") == 0 ||
+        strcmp(local, "on-non-empty") == 0 ||
+        strcmp(local, "where-populated") == 0) {
+        XsltInstr* in = instr_new(
+            strcmp(local, "on-empty") == 0 ? XSLT_INSTR_ON_EMPTY
+            : strcmp(local, "on-non-empty") == 0
+                ? XSLT_INSTR_ON_NON_EMPTY : XSLT_INSTR_WHERE_POPULATED);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "fork") == 0) {
+        /* 3.0 §14: non-streaming fork = the child sequences run
+         * sequentially into the same destination (Saxon-HE). */
+        XsltInstr* in = instr_new(XSLT_INSTR_FORK);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "next-match") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_NEXT_MATCH);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);   /* with-params */
+        return in;
+    }
+    if (strcmp(local, "next-iteration") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_NEXT_ITERATION);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);   /* xsl:with-param rebinds */
+        return in;
+    }
+    if (strcmp(local, "break") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_BREAK);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);   /* processed, then loop ends */
+        return in;
+    }
+    if (strcmp(local, "if") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_IF);
+        if (!in) return NULL;
+        in->test = compile_attr_sp(sp, e, "test");
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "choose") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_CHOOSE);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);   /* WHEN/OTHERWISE arms */
+        return in;
+    }
+    if (strcmp(local, "when") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_WHEN);
+        if (!in) return NULL;
+        in->test = compile_attr_sp(sp, e, "test");
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "otherwise") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_OTHERWISE);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "variable") == 0 || strcmp(local, "param") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_VARIABLE);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        in->select = compile_attr_sp(sp, e, "select");
+        in->is_param = (local[0] == 'p');   /* xsl:param (§11.6) */
+        const char* tu = leptris_element_attribute(e, "tunnel");
+        in->tunnel = in->is_param && tu && strcmp(tu, "yes") == 0;
+        if (in->is_param) {
+            /* 4.0 @default: evaluated when no with-param binds
+             * (takes precedence over the sequence constructor). */
+            in->num_count = compile_attr_sp(sp, e, "default");
+        }
+        /* §11.1: the select resolves with the DECLARING element's
+         * in-scope bindings — top-level variables of included
+         * sheets carry their own (bug-36-). */
+        in->ns = build_ns_context((LeptrisElement)e);
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "apply-imports") == 0) {
+        return instr_new(XSLT_INSTR_APPLY_IMPORTS);
+    }
+    if (strcmp(local, "with-param") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_WITH_PARAM);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        in->select = compile_attr_sp(sp, e, "select");
+        const char* tu = leptris_element_attribute(e, "tunnel");
+        in->tunnel = tu && strcmp(tu, "yes") == 0;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "call-template") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_CALL_TEMPLATE);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        in->child = parse_content(sp, e);   /* with-params */
+        return in;
+    }
+    if (strcmp(local, "apply-templates") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_APPLY_TEMPLATES);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        in->name = leptris_strdup(leptris_element_attribute(e, "mode"));
+        in->sorts = parse_sorts(sp, e);
+        in->child = parse_content(sp, e);   /* with-params */
+        return in;
+    }
+    if (strcmp(local, "copy-of") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_COPY_OF);
+        if (!in) return NULL;
+        in->select = compile_attr_sp(sp, e, "select");
+        return in;
+    }
+    if (strcmp(local, "copy") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_COPY);
+        if (!in) return NULL;
+        collect_attr_sets(in, e);
+        /* §7.1.1: namespace declarations copied into the result. */
+        build_ns_copy(sp, e, &in->ns_out_pfx, &in->ns_out_uri,
+                      &in->ns_out_count, &in->ns_out_default,
+                      &in->ns_out_default_pos);
+        /* 3.0 §9.9: copy/@select deep-copies the selected nodes
+         * (the node-kind copy semantics apply per item). */
+        in->select = compile_attr_sp(sp, e, "select");
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "element") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_ELEMENT);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        {
+            const char* ns = leptris_element_attribute(e, "namespace");
+            if (!ns || !*ns) {
+                /* libxslt honors a default xmlns= declaration on the
+                 * xsl:element instruction (stored as a ns decl, not
+                 * an attribute). */
+                for (int i = 0;; i++) {
+                    const char* p =
+                        leptris_element_namespace_decl_prefix(e, i);
+                    const char* u =
+                        leptris_element_namespace_decl_uri(e, i);
+                    if (!u) break;
+                    if (!p || !*p) { ns = u; break; }
+                }
+            }
+            in->ns_uri = leptris_strdup(ns ? ns : "");
+        }
+        collect_attr_sets(in, e);
+        /* §7.1.1: namespace declarations copied into the result. */
+        build_ns_copy(sp, e, &in->ns_out_pfx, &in->ns_out_uri,
+                      &in->ns_out_count, &in->ns_out_default,
+                      &in->ns_out_default_pos);
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "attribute") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_ATTRIBUTE);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        /* §7.1.3: the namespace attribute (an AVT at exec time). */
+        in->ns_uri = leptris_strdup(
+            leptris_element_attribute(e, "namespace"));
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "comment") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_COMMENT);
+        if (!in) return NULL;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "processing-instruction") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_PI);
+        if (!in) return NULL;
+        in->name = leptris_strdup(leptris_element_attribute(e, "name"));
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "message") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_MESSAGE);
+        if (!in) return NULL;
+        const char* term = leptris_element_attribute(e, "terminate");
+        in->terminate = term && strcmp(term, "yes") == 0;
+        in->child = parse_content(sp, e);
+        return in;
+    }
+    if (strcmp(local, "number") == 0) {
+        XsltInstr* in = instr_new(XSLT_INSTR_NUMBER);
+        if (!in) return NULL;
+        const char* lvl = leptris_element_attribute(e, "level");
+        in->num_level = (lvl && strcmp(lvl, "multiple") == 0) ? 1
+                       : (lvl && strcmp(lvl, "any") == 0) ? 2 : 0;
+        in->num_value = compile_attr_sp(sp, e, "value");
+        in->num_count = compile_attr_sp(sp, e, "count");
+        in->num_from = compile_attr_sp(sp, e, "from");
+        in->num_format = leptris_strdup(
+            leptris_element_attribute(e, "format")
+                ? leptris_element_attribute(e, "format") : "1");
+        const char* gs = leptris_element_attribute(e, "grouping-size");
+        in->num_group_size = gs ? atoi(gs) : 0;
+        const char* gp = leptris_element_attribute(e, "grouping-separator");
+        in->num_group_sep = gp ? gp[0] : 0;
+        const char* lv = leptris_element_attribute(e, "letter-value");
+        in->letter_value = lv ? leptris_strdup(lv) : NULL;
+        const char* sa = leptris_element_attribute(e, "start-at");
+        in->num_start_at = sa ? atol(sa) : 0;
+        return in;
+    }
+    /* Unknown xsl: instruction (§2.5/§15): a fallback container.
+     * Any xsl:fallback children execute when the element is
+     * instantiated; without them it is a no-op (forward-compatible
+     * processing — an error only when the element is actually
+     * selected, which the container materializes). */
+    XsltInstr* in = instr_new(XSLT_INSTR_UNKNOWN_XSL);
+    if (!in) return NULL;
+    in->name = leptris_strdup(name);
+    /* Merge every xsl:fallback child's content into one sequence;
+     * op_unknown_xsl executes it directly. */
+    XsltInstr** tail = &in->child;
+    for (LeptrisElement c = leptris_element_first_child_any(e); c;
+         c = leptris_element_next_sibling_any(c)) {
+        if (!node_is_xsl(c, "fallback")) continue;
+        XsltInstr* content = parse_content(sp, c);
+        if (!content) continue;
+        *tail = content;
+        while (*tail) tail = &(*tail)->next;
+    }
+    return in;
+}
+
+
+static XsltInstr* parse_content_ws(SheetParser* sp, LeptrisElement list,
+                                   int preserve_ws) {
+    XsltInstr* out = NULL;
+    /* §2.4: an xml:space="preserve" ancestor overrides stripping. */
+    if (!preserve_ws)
+        for (LeptrisElement a = list; a;
+             a = leptris_node_parent((LeptrisNodeRef)a)) {
+            const char* xs = leptris_element_attribute(a, "xml:space");
+            if (xs && strcmp(xs, "preserve") == 0) { preserve_ws = 1; break; }
+            if (xs && strcmp(xs, "default") == 0) break;
+        }
+    /* Is the CONTAINING element a literal result element? Blank
+     * nodes at its edges survive (indentation) when no xsl
+     * instruction neighbors them. */
+    for (LeptrisNodeRef n = leptris_node_first_child(leptris_element_as_node(list));
+         n; n = leptris_node_next_sibling(n)) {
+        int type = leptris_node_get_type(n);
+        if (type == LEPTRIS_NODE_TYPE_TEXT) {
+            /* §4.8: stylesheet whitespace-only text is stripped. */
+            const char* t = leptris_node_text(n);
+            if (!t) continue;
+            if (!preserve_ws) {
+                int ws_only = 1;
+                for (const char* p = t; *p; p++) {
+                    if (*p != ' ' && *p != '\t' && *p != '\n' &&
+                        *p != '\r') {
+                        ws_only = 0;
+                        break;
+                    }
+                }
+                if (ws_only) {
+                    /* §2.4 (xsltproc-verified): whitespace-only text
+                     * nodes in the stylesheet are ALWAYS stripped —
+                     * inside literal result elements too (indentation
+                     * does not survive); xsl:text passes
+                     * preserve_ws, and xml:space=preserve parents
+                     * keep theirs. */
+                    if (!preserve_ws) continue;
+                }
+            }
+            XsltInstr* in = instr_new(XSLT_INSTR_TEXT);
+            if (in) {
+                in->text = leptris_strdup(t);
+                in->tvt = sp->sheet->expand_text &&
+                          strchr(in->text, '{') != NULL;
+            }
+            instr_append(&out, in);
+        } else if (type == LEPTRIS_NODE_TYPE_ELEMENT) {
+            XsltInstr* in = parse_instruction(sp, (LeptrisElement)n);
+            if (in && !in->ns && sp->sheet->sheet_has_ns)
+                in->ns = build_ns_context((LeptrisElement)n);
+            instr_append(&out, in);
+        }
+        /* Literal comment/PI nodes in template content are DROPPED
+         * (xsltproc-verified): only xsl:comment/xsl:processing-
+         * instruction emit them (§7.4). */
+    }
+    return out;
+}
+
+/* Default pattern priority — the exact §5.5 table:
+ *   QName (or processing-instruction(Literal)) preceded by an axis
+ *       specifier .......................................... 0
+ *   NCName:* preceded by an axis specifier ............. -0.25
+ *   otherwise, a bare NodeTest (* / node() /
+ *       processing-instruction()) with an axis ........... -0.5
+ *   otherwise (paths, predicates, ...) .................... 0.5
+ * The caller computes per-alternative values (split on '|'). */
+static double default_priority(const char* pattern) {
+    if (!pattern || !*pattern) return 0.5;
+    /* Multi-step or any predicate → 0.5. */
+    if (strchr(pattern, '/') || strchr(pattern, '[')) return 0.5;
+
+    /* Single step: strip leading axis specifiers. */
+    const char* p = pattern;
+    while (*p == ' ') p++;
+    if (strncmp(p, "child::", 7) == 0) p += 7;
+    else if (strncmp(p, "attribute::", 11) == 0) p += 11;
+    else if (*p == '@') p++;
+    while (*p == ' ') p++;
+
+    if (strncmp(p, "processing-instruction(", 23) == 0) {
+        const char* arg = p + 23;
+        /* literal present? ' " ... */
+        return (*arg == '\'' || *arg == '"') ? 0.0 : -0.5;
+    }
+    size_t len = strlen(p);
+    while (len > 0 && p[len-1] == ' ') len--;
+    char leaf[128];
+    if (len >= sizeof(leaf)) return 0.5;
+    memcpy(leaf, p, len); leaf[len] = 0;
+
+    /* NCName:* → -0.25. */
+    char* colon = strchr(leaf, ':');
+    if (colon && strcmp(colon, ":*") == 0) return -0.25;
+    /* Bare NodeTests. */
+    if (strcmp(leaf, "*") == 0 || strcmp(leaf, "node()") == 0 ||
+        strcmp(leaf, "comment()") == 0 || strcmp(leaf, "text()") == 0)
+        return -0.5;
+    if (strncmp(leaf, "processing-instruction", 22) == 0) return -0.5;
+    /* Function-call patterns (id(...), key(...)) fall to the
+     * "otherwise" row — NOT the bare-QName 0.0 (bug-113). */
+    if (strchr(leaf, '(')) return 0.5;
+    /* QName (possibly prefixed). */
+    return 0.0;
+}
+
+/* Split "a|b|c" into alternatives (respecting brackets — v1 splits
+ * on top-level '|' outside [] and ()). */
+static char** split_alternatives(const char* pattern, size_t* count) {
+    size_t n = 1;
+    int depth = 0;
+    for (const char* p = pattern; *p; p++) {
+        if (*p == '[' || *p == '(') depth++;
+        else if (*p == ']' || *p == ')') depth--;
+        else if (*p == '|' && depth == 0) n++;
+    }
+    char** parts = (char**)calloc(n, sizeof(char*));
+    if (!parts) return NULL;
+    const char* start = pattern;
+    size_t i = 0;
+    depth = 0;
+    for (const char* p = pattern;; p++) {
+        if (*p == '[' || *p == '(') depth++;
+        else if (*p == ']' || *p == ')') depth--;
+        if ((*p == '|' && depth == 0) || *p == '\0') {
+            size_t len = (size_t)(p - start);
+            while (len > 0 && (start[len-1] == ' ')) len--;
+            char* part = (char*)malloc(len + 1);
+            if (part) {
+                memcpy(part, start, len);
+                part[len] = '\0';
+                parts[i++] = part;
+            }
+            if (*p == '\0') break;
+            start = p + 1;
+        }
+    }
+    *count = i;
+    return parts;
+}
+
+static void add_template(SheetParser* sp, LeptrisElement e) {
+    const char* match = leptris_element_attribute(e, "match");
+    const char* name = leptris_element_attribute(e, "name");
+    const char* mode = leptris_element_attribute(e, "mode");
+    if (!match && !name) return;
+
+    XsltTemplate* t = (XsltTemplate*)calloc(1, sizeof(*t));
+    if (!t) return;
+    t->name = name ? leptris_strdup(name) : NULL;
+    t->mode = mode ? leptris_strdup(mode) : NULL;
+    t->import_rank = sp->import_rank;
+    t->ns = build_ns_context(e);   /* §5.3 pattern prefix resolution */
+    t->body = parse_content(sp, e);
+
+    /* §5.4: an explicit priority replaces the §5.5 default for
+     * EVERY alternative of the union (bug-157). */
+    double pri_val = 0;
+    int has_priority = 0;
+    const char* pris = leptris_element_attribute(e, "priority");
+    if (pris && *pris) {
+        char* end = NULL;
+        pri_val = strtod(pris, &end);
+        if (end != pris) has_priority = 1;
+    }
+
+    if (match) {
+        if (!*match) { sp->errors = 1; free(t); return; }
+        size_t nalt = 0;
+        char** alts = split_alternatives(match, &nalt);
+        XsltPattern** tail = &t->matches;
+        for (size_t i = 0; i < nalt; i++) {
+            char* trimmed = alts[i];
+            while (*trimmed == ' ') trimmed++;
+            if (!*trimmed) continue;
+            XsltPattern* p = (XsltPattern*)calloc(1, sizeof(*p));
+            if (!p) continue;
+            p->expr = leptris_xpath_compile(trimmed);
+            if (!p->expr) {
+                /* Bad pattern: fail the whole stylesheet. */
+                sp->errors = 1;
+                free(p);
+                free(alts[i]);
+                continue;
+            }
+            xslt_pattern_compile_steps(p, trimmed);
+            p->priority = has_priority ? pri_val
+                                       : default_priority(trimmed);
+            /* Bare-name fast path for the root element — ONLY for
+             * single-step patterns: a child-step pattern (star slash
+             * star, or name slash star) must not match the root,
+             * whose parent is the document node (bug-186). */
+            const char* last = strrchr(trimmed, '/');
+            const char* leaf = last ? last + 1 : trimmed;
+            int simple = !last;
+            for (const char* q = leaf; *q; q++) {
+                if (*q == '[' || *q == '(' || *q == '@' || *q == ':') simple = 0;
+            }
+            if (simple && strlen(leaf) < sizeof(p->expr_name)) {
+                strcpy(p->expr_name, leaf);
+                p->expr_name_only = 1;
+            }
+            /* #866: the leaf's Name test even under predicates —
+             * everything before the first '[' / '@' / '(' in a
+             * single-step, unprefixed, non-wildcard leaf. */
+            {
+                size_t nl = 0;
+                while (leaf[nl] && leaf[nl] != '[' && leaf[nl] != '@' &&
+                       leaf[nl] != '(' && leaf[nl] != ':')
+                    nl++;
+                /* Only a genuine Name test: the remainder after the
+                 * name must be empty or a predicate ('[', '@') — a
+                 * '(' means a node-type test (text(), node(),
+                 * processing-instruction()) or a function call
+                 * (id('x')), which matches by kind, not name. */
+                if (nl && nl < sizeof(p->leaf_name) &&
+                    !(nl == 1 && leaf[0] == '*') && !last &&
+                    (leaf[nl] == 0 || leaf[nl] == '[' || leaf[nl] == '@')) {
+                    memcpy(p->leaf_name, leaf, nl);
+                    p->leaf_name[nl] = 0;
+                    p->leaf_named = 1;
+                    /* Literal @attr='value' predicate: [@a='v'] or
+                     * [@a="v"] and nothing else. */
+                    if (leaf[nl] == '[') {
+                        const char* q = leaf + nl + 1;
+                        if (*q == '@') {
+                            size_t al = 1;
+                            while (q[al] && q[al] != '=') al++;
+                            size_t an = al - 1;
+                            if (q[al] == '=' &&
+                                (q[al + 1] == '\'' || q[al + 1] == '"')) {
+                                char term = q[al + 1];
+                                size_t v0 = al + 2;
+                                size_t vl = v0;
+                                while (q[vl] && q[vl] != term) vl++;
+                                if (q[vl] == term && q[vl + 1] == ']' &&
+                                    q[vl + 2] == 0 && an > 0 &&
+                                    an < sizeof(p->pred_attr) &&
+                                    vl - v0 < sizeof(p->pred_val)) {
+                                    memcpy(p->pred_attr, q + 1, an);
+                                    p->pred_attr[an] = 0;
+                                    memcpy(p->pred_val, q + v0, vl - v0);
+                                    p->pred_val[vl - v0] = 0;
+                                    p->pred_literal = 1;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            *tail = p;
+            tail = &p->next;
+            free(alts[i]);
+        }
+        free(alts);
+    }
+
+    /* Append (imported templates were added FIRST by construction —
+     * xsl:import is processed before the body). */
+    t->order = sp->sheet->template_count;
+    if (!sp->sheet->templates) {
+        sp->sheet->templates = t;
+    } else {
+        XsltTemplate* x = sp->sheet->templates;
+        while (x->next) x = x->next;
+        x->next = t;
+    }
+    sp->sheet->template_count++;
+}
+
+static void parse_top_level(SheetParser* sp, LeptrisElement root) {
+    /* EXSLT func pre-scan: the function namespaces are excluded from
+     * LRE ns-copy (EXSLT: they never reach the result), and the
+     * exclusion must be in place BEFORE any template's literal
+     * result elements compile. */
+    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;
+        LeptrisElement e = (LeptrisElement)n;
+        if (!node_is_exslt_func(e, "function")) continue;
+        const char* fn = leptris_element_attribute(e, "name");
+        if (!fn || !*fn) continue;
+        const char* colon = strchr(fn, ':');
+        if (!colon || colon == fn) continue;
+        char** grown = (char**)realloc(
+            sp->sheet->exclude_pfx,
+            (sp->sheet->exclude_count + 1) * sizeof(char*));
+        if (!grown) continue;
+        sp->sheet->exclude_pfx = grown;
+        sp->sheet->exclude_pfx[sp->sheet->exclude_count] =
+            (char*)malloc((size_t)(colon - fn) + 1);
+        if (sp->sheet->exclude_pfx[sp->sheet->exclude_count]) {
+            memcpy(sp->sheet->exclude_pfx[sp->sheet->exclude_count],
+                   fn, (size_t)(colon - fn));
+            sp->sheet->exclude_pfx[sp->sheet->exclude_count][colon - fn] = 0;
+            sp->sheet->exclude_count++;
+        }
+    }
+    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;
+        LeptrisElement e = (LeptrisElement)n;
+        if (node_is_xsl(e, "import")) {
+            const char* href = leptris_element_attribute(e, "href");
+            if (href && *href && !chain_has(&sp->chain, href) &&
+                sp->chain.len < XSLT_INCLUDE_DEPTH_MAX) {
+                LeptrisDocument d =
+                    leptris_parse_file(href, NULL);
+                if (!d) { sp->errors = 1; continue; }
+                sp->import_rank++;
+                chain_push(&sp->chain, href);
+                LeptrisElement r2 = leptris_document_root(d);
+                if (r2) parse_top_level(sp, r2);
+                chain_pop(&sp->chain);
+                sp->import_rank--;
+                leptris_document_free(d);
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "include")) {
+            const char* href = leptris_element_attribute(e, "href");
+            if (href && *href && !chain_has(&sp->chain, href) &&
+                sp->chain.len < XSLT_INCLUDE_DEPTH_MAX) {
+                LeptrisDocument d =
+                    leptris_parse_file(href, NULL);
+                if (!d) { sp->errors = 1; continue; }
+                chain_push(&sp->chain, href);
+                /* Include keeps the same import_rank — declared in
+                 * the including sheet's position. */
+                LeptrisElement r2 = leptris_document_root(d);
+                if (r2) parse_top_level(sp, r2);
+                chain_pop(&sp->chain);
+                leptris_document_free(d);
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "template")) {
+            add_template(sp, e);
+            continue;
+        }
+        /* EXSLT func:function: a stylesheet-defined XPath function. */
+        if (node_is_exslt_func(e, "function")) {
+            const char* fn = leptris_element_attribute(e, "name");
+            if (fn && *fn) {
+                XsltUserFunc* f = (XsltUserFunc*)calloc(1, sizeof(*f));
+                if (f) {
+                    f->name = leptris_strdup(fn);
+                    f->body = parse_content(sp, e);
+                    XsltUserFunc** tail = &sp->sheet->funcs;
+                    while (*tail) tail = &(*tail)->next;
+                    *tail = f;
+                }
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "variable") || node_is_xsl(e, "param")) {
+            XsltInstr* in = parse_instruction(sp, e);
+            if (in) instr_append(&sp->sheet->globals, in);
+            continue;
+        }
+        if (node_is_xsl(e, "key")) {
+            XsltKeyDef* k = (XsltKeyDef*)calloc(1, sizeof(*k));
+            if (!k) continue;
+            k->name = leptris_strdup(leptris_element_attribute(e, "name"));
+            k->pat.expr = compile_attr_sp(sp, e, "match");
+            k->use = compile_attr_sp(sp, e, "use");
+            const char* mt = leptris_element_attribute(e, "match");
+            if (mt && *mt && k->pat.expr)
+                xslt_pattern_compile_steps(&k->pat, mt);
+            XsltKeyDef** tail = &sp->sheet->keys;
+            while (*tail) tail = &(*tail)->next;
+            *tail = k;
+            continue;
+        }
+        /* xsl:accumulator (3.0 §18.2): declaration + ordered rules.
+         * initial-value/@select attributes only — sequence-constructor
+         * bodies (both attributes and rules) are not compiled yet. */
+        if (node_is_xsl(e, "accumulator")) {
+            const char* an = leptris_element_attribute(e, "name");
+            if (!an || !*an) continue;
+            XsltAccumulator* a = (XsltAccumulator*)calloc(1, sizeof(*a));
+            if (!a) continue;
+            a->name = leptris_strdup(an);
+            a->initial = compile_attr_sp(sp, e, "initial-value");
+            XsltAccRule** tail = &a->rules;
+            for (LeptrisElement c = leptris_element_first_child_any(e); c;
+                 c = leptris_element_next_sibling_any(c)) {
+                if (!node_is_xsl(c, "accumulator-rule")) continue;
+                XsltAccRule* r = (XsltAccRule*)calloc(1, sizeof(*r));
+                if (!r) continue;
+                r->match = compile_attr_sp(sp, c, "match");
+                r->select = compile_attr_sp(sp, c, "select");
+                const char* ph = leptris_element_attribute(c, "phase");
+                r->phase_end = ph && strcmp(ph, "end") == 0;
+                *tail = r;
+                tail = &r->next;
+            }
+            XsltAccumulator** at = &sp->sheet->accs;
+            while (*at) at = &(*at)->next;
+            *at = a;
+            continue;
+        }
+        /* xsl:mode (3.0 §10): only the unnamed mode's
+         * use-accumulators is captured (§18.2.2 applicability gate).
+         * The other attributes (on-no-match, warning/on-no-match,
+         * typed, visibility) land with full xsl:mode support. */
+        if (node_is_xsl(e, "mode")) {
+            const char* mn = leptris_element_attribute(e, "name");
+            const char* ua = leptris_element_attribute(e, "use-accumulators");
+            if ((!mn || !*mn) && ua && *ua) {
+                if (strcmp(ua, "#all") == 0) {
+                    sp->sheet->mode_acc_all = 1;
+                } else {
+                    char* dup = leptris_strdup(ua);
+                    if (dup) {
+                        char* save = NULL;
+                        for (char* tok = xslt_strtok(dup, " \t\n,", &save);
+                             tok; tok = xslt_strtok(NULL, " \t\n,", &save)) {
+                            char** grown = (char**)realloc(
+                                sp->sheet->mode_acc_names,
+                                (sp->sheet->mode_acc_count + 1) *
+                                    sizeof(char*));
+                            if (!grown) break;
+                            sp->sheet->mode_acc_names = grown;
+                            sp->sheet->mode_acc_names[
+                                sp->sheet->mode_acc_count++] =
+                                leptris_strdup(tok);
+                        }
+                        free(dup);
+                    }
+                }
+            }
+            /* §6.7 on-no-match for the unnamed mode: 1 unspecified
+             * (runtime resolves by version — 3.0 default is
+             * shallow-copy, 1.0 keeps the text built-in), 2
+             * deep-copy, 3 shallow-copy, 4 shallow-skip, 5
+             * deep-skip, 6 text-only-copy, 7 fail. */
+            if (!mn || !*mn) {
+                const char* onm =
+                    leptris_element_attribute(e, "on-no-match");
+                if (onm && *onm) {
+                    if (strcmp(onm, "deep-copy") == 0)
+                        sp->sheet->mode_on_no_match = 2;
+                    else if (strcmp(onm, "shallow-copy") == 0)
+                        sp->sheet->mode_on_no_match = 3;
+                    else if (strcmp(onm, "shallow-skip") == 0)
+                        sp->sheet->mode_on_no_match = 4;
+                    else if (strcmp(onm, "deep-skip") == 0)
+                        sp->sheet->mode_on_no_match = 5;
+                    else if (strcmp(onm, "text-only-copy") == 0)
+                        sp->sheet->mode_on_no_match = 6;
+                    else if (strcmp(onm, "fail") == 0)
+                        sp->sheet->mode_on_no_match = 7;
+                }
+            }
+            continue;
+        }
+        /* xsl:global-context-item (3.0 §10): the transform always
+         * runs with the source document as its global context item,
+         * so the declaration is accepted as a no-op (as/use-when
+         * ride along; the no-context error path cannot occur —
+         * #690 audit). */
+        if (node_is_xsl(e, "global-context-item")) {
+            continue;
+        }
+        if (node_is_xsl(e, "output")) {
+            const char* m = leptris_element_attribute(e, "method");
+            sp->sheet->out_method_text = m && strcmp(m, "text") == 0;
+            sp->sheet->out_method_html = m && strcmp(m, "html") == 0;
+            sp->sheet->out_method_set = m && *m;
+            const char* ind = leptris_element_attribute(e, "indent");
+            if (ind) sp->sheet->out_indent = strcmp(ind, "yes") == 0;
+            /* §16.1 cdata-section-elements: space-separated QNames. */
+            const char* cda =
+                leptris_element_attribute(e, "cdata-section-elements");
+            if (cda && *cda) {
+                char* dup = leptris_strdup(cda);
+                if (dup) {
+                    char* save = NULL;
+                    for (char* tok = xslt_strtok(dup, " \t\n,", &save);
+                         tok; tok = xslt_strtok(NULL, " \t\n,", &save)) {
+                        char** grown = (char**)realloc(
+                            sp->sheet->out_cdata,
+                            (sp->sheet->out_cdata_count + 1) *
+                                sizeof(char*));
+                        if (!grown) break;
+                        sp->sheet->out_cdata = grown;
+                        sp->sheet->out_cdata[
+                            sp->sheet->out_cdata_count++] =
+                            leptris_strdup(tok);
+                    }
+                    free(dup);
+                }
+            }
+            const char* od = leptris_element_attribute(e, "omit-xml-declaration");
+            sp->sheet->out_omit_decl = od && strcmp(od, "yes") == 0;
+            const char* enc = leptris_element_attribute(e, "encoding");
+            sp->sheet->out_encoding = enc ? leptris_strdup(enc) : NULL;
+            const char* ver = leptris_element_attribute(e, "version");
+            sp->sheet->out_version = ver ? leptris_strdup(ver) : NULL;
+            const char* sa = leptris_element_attribute(e, "standalone");
+            if (sa && *sa)
+                sp->sheet->out_standalone =
+                    strcmp(sa, "yes") == 0 ? 1 : 0;
+            const char* mt = leptris_element_attribute(e, "media-type");
+            if (mt && *mt) {
+                free((void*)sp->sheet->out_media_type);
+                sp->sheet->out_media_type = leptris_strdup(mt);
+            }
+            const char* ds = leptris_element_attribute(e, "doctype-system");
+            if (ds) { free((void*)sp->sheet->out_doctype_system);
+                      sp->sheet->out_doctype_system = leptris_strdup(ds); }
+            const char* dp = leptris_element_attribute(e, "doctype-public");
+            if (dp) { free((void*)sp->sheet->out_doctype_public);
+                      sp->sheet->out_doctype_public = leptris_strdup(dp); }
+            const char* cs = leptris_element_attribute(e, "cdata-section-elements");
+            if (cs) {
+                /* Trim + split on whitespace. */
+                char* tmp = leptris_strdup(cs);
+                if (tmp) {
+                    if (sp->sheet->out_cdata_elems) {
+                        for (size_t i = 0; sp->sheet->out_cdata_elems[i]; i++)
+                            free(sp->sheet->out_cdata_elems[i]);
+                        free(sp->sheet->out_cdata_elems);
+                    }
+                    size_t cap = 4, cnt = 0;
+                    char** arr = (char**)malloc(cap * sizeof(char*));
+                    char* save = NULL;
+                    char* tok = xslt_strtok(tmp, " \t\n,", &save);
+                    while (tok) {
+                        if (cnt + 1 >= cap) { cap *= 2;
+                            arr = (char**)realloc(arr, cap * sizeof(char*)); }
+                        arr[cnt++] = leptris_strdup(tok);
+                        arr[cnt] = NULL;
+                        tok = xslt_strtok(NULL, " \t\n,", &save);
+                    }
+                    free(tmp);
+                    sp->sheet->out_cdata_elems = arr;
+                }
+            }
+            /* §16.1 use-character-maps: whitespace-separated names of
+             * xsl:character-map declarations activated at output. */
+            const char* ucm =
+                leptris_element_attribute(e, "use-character-maps");
+            if (ucm && *ucm) {
+                char* tmp = leptris_strdup(ucm);
+                if (tmp) {
+                    char* save = NULL;
+                    char* tok = xslt_strtok(tmp, " \t\n,", &save);
+                    while (tok) {
+                        char** grown = (char**)realloc(
+                            sp->sheet->out_charmap_names,
+                            (sp->sheet->out_charmap_name_count + 1) *
+                                sizeof(char*));
+                        if (!grown) break;
+                        sp->sheet->out_charmap_names = grown;
+                        sp->sheet->out_charmap_names[
+                            sp->sheet->out_charmap_name_count++] =
+                            leptris_strdup(tok);
+                        tok = xslt_strtok(NULL, " \t\n,", &save);
+                    }
+                    free(tmp);
+                }
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "character-map")) {
+            /* §16.1: table of character → replacement-string pairs;
+             * activated by name from xsl:output/@use-character-maps. */
+            const char* cname = leptris_element_attribute(e, "name");
+            if (cname && *cname) {
+                XsltCharMap* grown = (XsltCharMap*)realloc(
+                    sp->sheet->charmaps,
+                    (sp->sheet->charmap_count + 1) * sizeof(*grown));
+                if (grown) {
+                    XsltCharMap* cm = &grown[sp->sheet->charmap_count++];
+                    memset(cm, 0, sizeof(*cm));
+                    cm->name = leptris_strdup(cname);
+                    sp->sheet->charmaps = grown;
+                    for (LeptrisElement c = leptris_element_first_child_any(e);
+                         c; c = leptris_element_next_sibling_any(c)) {
+                        if (!node_is_xsl(c, "output-character")) continue;
+                        const char* ch =
+                            leptris_element_attribute(c, "character");
+                        const char* rs =
+                            leptris_element_attribute(c, "string");
+                        if (!ch || !*ch) continue;
+                        char** ng = (char**)realloc(
+                            cm->chars, (cm->count + 1) * sizeof(char*));
+                        char** nr = (char**)realloc(
+                            cm->repls, (cm->count + 1) * sizeof(char*));
+                        if (!ng || !nr) {
+                            if (ng) { cm->chars = ng; }
+                            else free(nr);
+                            if (nr) { cm->repls = nr; }
+                            else free(ng);
+                            break;
+                        }
+                        cm->chars = ng;
+                        cm->repls = nr;
+                        cm->chars[cm->count] = leptris_strdup(ch);
+                        cm->repls[cm->count] = leptris_strdup(rs ? rs : "");
+                        cm->count++;
+                    }
+                }
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "strip-space") ||
+            node_is_xsl(e, "preserve-space")) {
+            /* §3.4 source whitespace handling: both lists are
+             * whitespace-split name lists. */
+            const char* els = leptris_element_attribute(e, "elements");
+            if (els && *els) {
+                char* tmp = leptris_strdup(els);
+                if (tmp) {
+                    char** arr = NULL; size_t cnt = 0, cap = 0;
+                    char* save = NULL;
+                    for (char* tok = xslt_strtok(tmp, " \t\n", &save); tok;
+                         tok = xslt_strtok(NULL, " \t\n", &save)) {
+                        if (cnt + 1 >= cap) {
+                            cap = cap ? cap * 2 : 4;
+                            arr = (char**)realloc(arr, cap * sizeof(char*));
+                        }
+                        arr[cnt++] = leptris_strdup(tok);
+                    }
+                    free(tmp);
+                    arr = (char**)realloc(arr, (cnt + 1) * sizeof(char*));
+                    arr[cnt] = NULL;
+                    /* Record into the ORDERED rules list (3.4: the
+                     * last matching declaration wins). */
+                    int is_pres = !node_is_xsl(e, "strip-space");
+                    for (size_t k = 0; k < cnt; k++) {
+                        char** gr = (char**)realloc(
+                            sp->sheet->ws_rules,
+                            (sp->sheet->ws_rule_count + 1) *
+                                sizeof(char*));
+                        unsigned char* gp = (unsigned char*)realloc(
+                            sp->sheet->ws_rule_preserve,
+                            (sp->sheet->ws_rule_count + 1) * 1);
+                        if (!gr || !gp) { free(gr); free(gp); break; }
+                        sp->sheet->ws_rules = gr;
+                        sp->sheet->ws_rule_preserve = gp;
+                        sp->sheet->ws_rules[sp->sheet->ws_rule_count] =
+                            arr[k];
+                        sp->sheet->ws_rule_preserve[
+                            sp->sheet->ws_rule_count] =
+                            (unsigned char)is_pres;
+                        sp->sheet->ws_rule_count++;
+                    }
+                    if (node_is_xsl(e, "strip-space")) {
+                        sp->sheet->ws_strip = arr;
+                    } else {
+                        sp->sheet->ws_preserve = arr;
+                    }
+                }
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "namespace-alias")) {
+            const char* spx = leptris_element_attribute(e, "stylesheet-prefix");
+            const char* rpx = leptris_element_attribute(e, "result-prefix");
+            XsltNsAlias* na = (XsltNsAlias*)calloc(1, sizeof(*na));
+            if (na) {
+                na->stylesheet_prefix =
+                    (spx && strcmp(spx, "#default") != 0)
+                        ? leptris_strdup(spx) : NULL;
+                na->result_prefix =
+                    (rpx && strcmp(rpx, "#default") != 0)
+                        ? leptris_strdup(rpx) : NULL;
+                na->next = sp->sheet->ns_alias;
+                sp->sheet->ns_alias = na;
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "fallback")) {
+            continue;   /* only meaningful inside unknown elements */
+        }
+        if (node_is_xsl(e, "decimal-format")) {
+            /* Find/create by name (NULL = default). */
+            const char* name = leptris_element_attribute(e, "name");
+            /* Resolve the declaration's qname so same-literal names
+             * in DIFFERENT namespaces stay distinct entries. */
+            const char* duri = NULL;
+            const char* dlocal = name;
+            if (name) {
+                const char* dc = strchr(name, ':');
+                if (dc) {
+                    dlocal = dc + 1;
+                    char dp[64];
+                    size_t dl = (size_t)(dc - name);
+                    if (dl < sizeof(dp)) {
+                        memcpy(dp, name, dl);
+                        dp[dl] = 0;
+                        duri = leptris_element_namespace_for_prefix(
+                            e, dp);
+                    }
+                }
+            }
+            XsltDecimalFormat* df = NULL;
+            for (XsltDecimalFormat* d = sp->sheet->decformats; d; d = d->next) {
+                if (!name || !d->name) {
+                    if (!name && !d->name) { df = d; break; }
+                    continue;
+                }
+                if (strcmp(name, d->name) != 0) continue;
+                const char* euri = d->uri ? d->uri : "";
+                const char* curi = duri ? duri : "";
+                if (strcmp(euri, curi) == 0) { df = d; break; }
+            }
+            if (!df) {
+                df = (XsltDecimalFormat*)calloc(1, sizeof(*df));
+                if (!df) continue;
+                df->decimal_sep = leptris_strdup(".");
+                df->grouping_sep = leptris_strdup(",");
+                df->minus_sign = '-';
+                df->percent = '%';
+                df->per_mille = '%';
+                df->zero_digit = '0';
+                df->infinity = leptris_strdup("Infinity");
+                df->nan = leptris_strdup("NaN");
+                df->name = name ? leptris_strdup(name) : NULL;
+                df->uri = duri ? leptris_strdup(duri) : NULL;
+                df->local = dlocal ? leptris_strdup(dlocal) : NULL;
+                /* Defaults slot at the head; named at the tail. */
+                if (!name) {
+                    df->next = sp->sheet->decformats;
+                    sp->sheet->decformats = df;
+                } else {
+                    XsltDecimalFormat** t = &sp->sheet->decformats;
+                    while (*t) t = &(*t)->next;
+                    *t = df;
+                }
+            }
+            const char* av;
+            if ((av = leptris_element_attribute(e, "decimal-separator")) && *av) {
+                if (df->decimal_sep) free((void*)df->decimal_sep);
+                df->decimal_sep = leptris_strdup(av);
+            }
+            if ((av = leptris_element_attribute(e, "grouping-separator")) && *av) {
+                if (df->grouping_sep) free((void*)df->grouping_sep);
+                df->grouping_sep = leptris_strdup(av);
+            }
+            if ((av = leptris_element_attribute(e, "minus-sign")) && *av)
+                df->minus_sign = av[0];
+            if ((av = leptris_element_attribute(e, "percent")) && *av)
+                df->percent = av[0];
+            if ((av = leptris_element_attribute(e, "per-mille")) && *av)
+                df->per_mille = av[0];
+            if ((av = leptris_element_attribute(e, "zero-digit")) && *av)
+                df->zero_digit = av[0];
+            if ((av = leptris_element_attribute(e, "infinity")) && *av) {
+                if (df->infinity) free((void*)df->infinity);
+                df->infinity = leptris_strdup(av);
+            }
+            if ((av = leptris_element_attribute(e, "NaN")) && *av) {
+                if (df->nan) free((void*)df->nan);
+                df->nan = leptris_strdup(av);
+            }
+            continue;
+        }
+        if (node_is_xsl(e, "attribute-set")) {
+            const char* nm = leptris_element_attribute(e, "name");
+            if (!nm || !*nm) continue;
+            XsltAttrSet* s = (XsltAttrSet*)calloc(1, sizeof(*s));
+            if (!s) continue;
+            s->name = leptris_strdup(nm);
+            s->name_uri = resolve_set_uri(e, nm);
+            s->import_rank = sp->import_rank;
+            /* Prepend to the set list so later use-attribute-sets
+             * applies later sets FIRST (winning conflicts). */
+            s->next = sp->sheet->attrsets;
+            sp->sheet->attrsets = s;
+            for (LeptrisElement c =
+                     leptris_element_first_child_any(e); c;
+                 c = leptris_element_next_sibling_any(c)) {
+                if (!node_is_xsl(c, "attribute")) continue;
+                XsltLAttr* la = (XsltLAttr*)calloc(1, sizeof(*la));
+                if (!la) continue;
+                la->name = leptris_strdup(
+                    leptris_element_attribute(c, "name"));
+                const char* v = leptris_element_child_value(c);
+                la->value = leptris_strdup(v ? v : "");
+                la->next = s->attrs;
+                s->attrs = la;   /* newer first, but apply later-staged
+                                    sets first because head-of-list is
+                                    the most-recently-declared set */
+            }
+            /* Chained sets (use-attribute-sets on the definition)
+             * are recorded, not snapshotted — §12.1.4 semantics
+             * need use-time resolution with import precedence. */
+            const char* uas = leptris_element_attribute(e, "use-attribute-sets");
+            if (uas && *uas) {
+                char* dup = leptris_strdup(uas);
+                if (dup) {
+                    char* save = NULL;
+                    for (char* tok = xslt_strtok(dup, " \t\n,", &save);
+                         tok; tok = xslt_strtok(NULL, " \t\n,", &save)) {
+                        char** grown = (char**)realloc(
+                            s->use_names,
+                            (s->use_count + 1) * sizeof(char*));
+                        if (!grown) break;
+                        s->use_names = grown;
+                        char** growu = (char**)realloc(
+                            s->use_uris,
+                            (s->use_count + 1) * sizeof(char*));
+                        if (!growu) break;
+                        s->use_uris = growu;
+                        s->use_uris[s->use_count] =
+                            resolve_set_uri(e, tok);
+                        s->use_names[s->use_count++] =
+                            leptris_strdup(tok);
+                    }
+                    free(dup);
+                }
+            }
+            continue;
+        }
+    }
+}
+
+/* ---- Public compilation ---- */
+
+static void free_instr_list(XsltInstr* list);
+
+static void free_instr(XsltInstr* in) {
+    if (!in) return;
+    free_instr_list(in->child);
+    if (in->test) leptris_xpath_compiled_free(in->test);
+    if (in->select) leptris_xpath_compiled_free(in->select);
+    if (in->group_by) leptris_xpath_compiled_free(in->group_by);
+    if (in->context_item) leptris_xpath_compiled_free(in->context_item);
+    if (in->group_starting) {
+        leptris_xpath_compiled_free(in->group_starting->expr);
+        xslt_pattern_steps_free(in->group_starting);
+        free(in->group_starting);
+    }
+    if (in->group_ending) {
+        leptris_xpath_compiled_free(in->group_ending->expr);
+        xslt_pattern_steps_free(in->group_ending);
+        free(in->group_ending);
+    }
+    if (in->num_value) leptris_xpath_compiled_free(in->num_value);
+    if (in->num_count) leptris_xpath_compiled_free(in->num_count);
+    if (in->num_from) leptris_xpath_compiled_free(in->num_from);
+    free((void*)in->name);
+    free((void*)in->ns_uri);
+    free((void*)in->text);
+    free((void*)in->num_format);
+    free((void*)in->letter_value);
+    free((void*)in->regex);
+    free((void*)in->regex_flags);
+    while (in->sorts) {
+        XsltSort* s = in->sorts;
+        in->sorts = s->next;
+        if (s->select) leptris_xpath_compiled_free(s->select);
+        free(s);
+    }
+    while (in->attrs) {
+        XsltLAttr* a = in->attrs;
+        in->attrs = a->next;
+        free((void*)a->name);
+        free((void*)a->value);
+        free(a);
+    }
+    if (in->attr_set_names) {
+        for (size_t i = 0; i < in->attr_set_count; i++)
+            free(in->attr_set_names[i]);
+        free(in->attr_set_names);
+    }
+    if (in->attr_set_uris) {
+        for (size_t i = 0; i < in->attr_set_count; i++)
+            free(in->attr_set_uris[i]);
+        free(in->attr_set_uris);
+    }
+    if (in->ns) leptris_xpath_ns_set_free(in->ns);
+    for (size_t i = 0; i < in->ns_out_count; i++) {
+        free(in->ns_out_pfx[i]);
+        free(in->ns_out_uri[i]);
+    }
+    free(in->ns_out_pfx);
+    free(in->ns_out_uri);
+    free(in->ns_out_default);
+    free(in);
+}
+
+static void free_instr_list(XsltInstr* list) {
+    while (list) {
+        XsltInstr* n = list->next;
+        free_instr(list);
+        list = n;
+    }
+}
+
+/* ---- dispatch indexes (#682) ----
+ *
+ * Named lookup: open-addressed FNV-1a map. Inserts walk the list in
+ * sheet order and overwrite on the same name, so the surviving
+ * entry is the LAST declaration — the §11.6 winner the previous
+ * full linear scan produced. Mode buckets: candidate arrays per
+ * distinct mode, preserving sheet order. */
+static size_t tpl_name_hash(const char* s) {
+    size_t h = 1469598103934665603ull;
+    while (*s) { h ^= (unsigned char)*s++; h *= 1099511628211ull; }
+    return h;
+}
+
+void xslt_sheet_build_dispatch(XsltStylesheet* sheet) {
+    if (!sheet) return;
+    size_t n = sheet->template_count;
+    if (n && !sheet->named_slot) {
+        size_t cap = 8;
+        while (cap < n * 2) cap <<= 1;
+        sheet->named_slot =
+            (XsltTemplate**)calloc(cap, sizeof(XsltTemplate*));
+        if (sheet->named_slot) {
+            sheet->named_cap = cap;
+            for (XsltTemplate* t = sheet->templates; t; t = t->next) {
+                if (!t->name) continue;
+                size_t i = tpl_name_hash(t->name) & (cap - 1);
+                while (sheet->named_slot[i] &&
+                       strcmp(sheet->named_slot[i]->name, t->name) != 0)
+                    i = (i + 1) & (cap - 1);
+                sheet->named_slot[i] = t;   /* last declaration wins */
+            }
+        }
+    }
+    /* #866 value-index sizing: one slot per literal-predicate
+     * pattern across the sheet (distinct keys only shrink that),
+     * doubled for open addressing. Growth replaces the old fixed
+     * 128-slot/96-entry cliff that silently degraded to full scans
+     * past 96 predicate patterns (#682: 7.6x on the 120-template
+     * dispatch bench). */
+    size_t npred = 0;
+    for (XsltTemplate* t = sheet->templates; t; t = t->next)
+        for (const XsltPattern* pa = t->matches; pa; pa = pa->next)
+            if (pa->pred_literal) npred++;
+    size_t pkey_cap = 16;
+    while (pkey_cap < npred * 2) pkey_cap <<= 1;
+
+    if (!sheet->modes && n) {
+        /* Single pass: the bucket array is sized to the match-
+         * template count (an upper bound on distinct modes); each
+         * new mode claims the next slot, candidates append in
+         * sheet order. */
+        XsltModeBucket* modes =
+            (XsltModeBucket*)calloc(n, sizeof(XsltModeBucket));
+        if (modes) {
+            size_t mm = 0;
+            for (XsltTemplate* t = sheet->templates; t; t = t->next) {
+                if (!t->matches) continue;
+                if (!t->matches->next && t->matches->expr_name_only) {
+                    t->fast_name = t->matches->expr_name;
+                    t->fast_pri = t->matches->priority;
+                }
+                XsltModeBucket* b = NULL;
+                for (size_t i = 0; i < mm; i++)
+                    if ((modes[i].mode == NULL && t->mode == NULL) ||
+                        (modes[i].mode && t->mode &&
+                         strcmp(modes[i].mode, t->mode) == 0)) {
+                        b = &modes[i]; break;
+                    }
+                if (!b) {
+                    b = &modes[mm++];
+                    b->mode = t->mode;
+                    b->list =
+                        (XsltTemplate**)malloc(n * sizeof(XsltTemplate*));
+                    if (!b->list) { mm--; continue; }
+                }
+                b->list[b->n++] = t;
+                /* #866 name keys: every alternative that names an
+                 * element links the template under that name; any
+                 * other-shaped alternative also lands in the
+                 * any-element remainder. */
+                int has_other = 0;
+                for (const XsltPattern* pa = t->matches; pa; pa = pa->next) {
+                    if (!pa->leaf_named) { has_other = 1; continue; }
+                    if (pa->pred_literal) {
+                        /* Value-index candidate — NOT in the plain
+                         * name list (that is the point: 120
+                         * item[@k='N'] templates must not all
+                         * evaluate their predicates). */
+                        char kb[64 + 48 + 96 + 8];
+                        int kl = snprintf(kb, sizeof(kb), "%s\x1f%s\x1f%s",
+                                          pa->leaf_name, pa->pred_attr,
+                                          pa->pred_val);
+                        if (kl <= 0 || (size_t)kl >= sizeof(kb)) continue;
+                        size_t kh2 = tpl_name_hash(kb) & (pkey_cap - 1);
+                        struct xslt_pkey* k2 = NULL;
+                        while (b->pkeys && kh2 < b->pkeycap &&
+                               b->pkeys[kh2].key) {
+                            if (strcmp(b->pkeys[kh2].key, kb) == 0) {
+                                k2 = &b->pkeys[kh2]; break;
+                            }
+                            kh2 = (kh2 + 1) & (pkey_cap - 1);
+                        }
+                        if (!k2) {
+                            if (!b->pkeys) {
+                                b->pkeys = (struct xslt_pkey*)calloc(
+                                    pkey_cap, sizeof(struct xslt_pkey));
+                                if (!b->pkeys) continue;
+                                b->pkeycap = pkey_cap;
+                            }
+                            /* #875: a table at its load ceiling must
+                             * not make the pattern unreachable — route
+                             * it to the scanned remainder so it still
+                             * fires. Unreachable in practice: pkey_cap
+                             * covers every literal pattern in the
+                             * sheet at a <=50% load. */
+                            if (b->npkeys >= pkey_cap - pkey_cap / 4) {
+                                has_other = 1;
+                                continue;
+                            }
+                            k2 = &b->pkeys[kh2];
+                            k2->key = leptris_strdup(kb);
+                            if (!k2->key) continue;
+                            b->npkeys++;
+                        }
+                        if (!k2->list) {
+                            k2->list = (XsltTemplate**)malloc(
+                                n * sizeof(XsltTemplate*));
+                            if (!k2->list) continue;
+                        }
+                        k2->list[k2->n++] = t;
+                        continue;
+                    }
+                    size_t kh = tpl_name_hash(pa->leaf_name) & 63;
+                    XsltNameKey* k = NULL;
+                    while (b->keys && kh < b->keycap && b->keys[kh].name) {
+                        if (strcmp(b->keys[kh].name, pa->leaf_name) == 0) {
+                            k = &b->keys[kh]; break;
+                        }
+                        kh = (kh + 1) & 63;
+                    }
+                    if (!k) {
+                        if (!b->keys) {
+                            b->keys = (XsltNameKey*)calloc(
+                                64, sizeof(XsltNameKey));
+                            if (!b->keys) continue;
+                            b->keycap = 64;
+                        }
+                        /* #875: same routing on the name-key
+                         * table's near-full bound. */
+                        if (b->nkeys >= 48) { has_other = 1; continue; }
+                        k = &b->keys[kh];
+                        k->name = pa->leaf_name;
+                        b->nkeys++;
+                    }
+                    if (!k->list) {
+                        k->list = (XsltTemplate**)malloc(
+                            n * sizeof(XsltTemplate*));
+                        if (!k->list) continue;
+                    }
+                    k->list[k->n++] = t;
+                }
+                if (has_other) {
+                    if (!b->other) {
+                        b->other = (XsltTemplate**)malloc(
+                            n * sizeof(XsltTemplate*));
+                        if (!b->other) continue;
+                    }
+                    b->other[b->n_other++] = t;
+                }
+            }
+            sheet->modes = modes;
+            sheet->mode_count = mm;
+        }
+    }
+}
+
+XsltTemplate* xslt_sheet_named(const XsltStylesheet* sheet,
+                               const char* name) {
+    if (!sheet || !name || !sheet->named_slot) return NULL;
+    size_t cap = sheet->named_cap;
+    size_t i = tpl_name_hash(name) & (cap - 1);
+    while (sheet->named_slot[i]) {
+        if (strcmp(sheet->named_slot[i]->name, name) == 0)
+            return sheet->named_slot[i];
+        i = (i + 1) & (cap - 1);
+    }
+    return NULL;
+}
+
+const struct xslt_pkey* xslt_bucket_pred_key(
+        const XsltModeBucket* b, const char* elem, const char* attr,
+        const char* val) {
+    if (!b || !b->pkeys || !elem || !attr || !val) return NULL;
+    char kb[64 + 48 + 96 + 8];
+    int kl = snprintf(kb, sizeof(kb), "%s\x1f%s\x1f%s", elem, attr, val);
+    if (kl <= 0 || (size_t)kl >= sizeof(kb)) return NULL;
+    size_t kh = tpl_name_hash(kb) & (b->pkeycap - 1);
+    while (b->pkeys[kh].key) {
+        if (strcmp(b->pkeys[kh].key, kb) == 0) return &b->pkeys[kh];
+        kh = (kh + 1) & (b->pkeycap - 1);
+    }
+    return NULL;
+}
+
+const XsltNameKey* xslt_bucket_name_key(const XsltModeBucket* b,
+                                        const char* name) {
+    if (!b || !b->keys || !name) return NULL;
+    size_t kh = tpl_name_hash(name) & 63;
+    while (b->keys[kh].name) {
+        if (strcmp(b->keys[kh].name, name) == 0) return &b->keys[kh];
+        kh = (kh + 1) & 63;
+    }
+    return NULL;
+}
+
+const XsltModeBucket* xslt_sheet_mode(const XsltStylesheet* sheet,
+                                      const char* mode) {
+    if (!sheet) return NULL;
+    for (size_t i = 0; i < sheet->mode_count; i++) {
+        const XsltModeBucket* b = &sheet->modes[i];
+        if ((b->mode == NULL && mode == NULL) ||
+            (b->mode && mode && strcmp(b->mode, mode) == 0))
+            return b;
+    }
+    return NULL;
+}
+
+void xslt_stylesheet_free(XsltStylesheet* sheet) {
+    if (!sheet) return;
+    free(sheet->named_slot);
+    for (size_t i = 0; i < sheet->mode_count; i++) {
+        if (sheet->modes[i].keys) {
+            for (size_t k = 0; k < sheet->modes[i].keycap; k++)
+                free(sheet->modes[i].keys[k].list);
+            free(sheet->modes[i].keys);
+        }
+        if (sheet->modes[i].pkeys) {
+            for (size_t k = 0; k < sheet->modes[i].pkeycap; k++) {
+                free(sheet->modes[i].pkeys[k].key);
+                free(sheet->modes[i].pkeys[k].list);
+            }
+            free(sheet->modes[i].pkeys);
+        }
+        free(sheet->modes[i].other);
+        free(sheet->modes[i].list);
+    }
+    free(sheet->modes);
+    XsltTemplate* t = sheet->templates;
+    while (t) {
+        XsltTemplate* n = t->next;
+        XsltPattern* p = t->matches;
+        while (p) {
+            XsltPattern* pn = p->next;
+            if (p->expr) leptris_xpath_compiled_free(p->expr);
+            xslt_pattern_steps_free(p);
+            free(p);
+            p = pn;
+        }
+        free_instr_list(t->body);
+        if (t->ns) leptris_xpath_ns_set_free(t->ns);
+        free((void*)t->name);
+        free((void*)t->mode);
+        free(t);
+        t = n;
+    }
+    while (sheet->keys) {
+        XsltKeyDef* k = sheet->keys;
+        sheet->keys = k->next;
+        if (k->pat.expr) leptris_xpath_compiled_free(k->pat.expr);
+        xslt_pattern_steps_free(&k->pat);
+        if (k->use) leptris_xpath_compiled_free(k->use);
+        free((void*)k->name);
+        free(k);
+    }
+    while (sheet->accs) {
+        XsltAccumulator* a = sheet->accs;
+        sheet->accs = a->next;
+        while (a->rules) {
+            XsltAccRule* r = a->rules;
+            a->rules = r->next;
+            if (r->match) leptris_xpath_compiled_free(r->match);
+            if (r->select) leptris_xpath_compiled_free(r->select);
+            free(r);
+        }
+        if (a->initial) leptris_xpath_compiled_free(a->initial);
+        free((void*)a->name);
+        free(a);
+    }
+    if (sheet->mode_acc_names) {
+        for (size_t i = 0; i < sheet->mode_acc_count; i++)
+            free(sheet->mode_acc_names[i]);
+        free(sheet->mode_acc_names);
+    }
+    while (sheet->funcs) {
+        XsltUserFunc* f = sheet->funcs;
+        sheet->funcs = f->next;
+        free((void*)f->name);
+        free_instr_list(f->body);
+        free(f);
+    }
+    free_instr_list(sheet->globals);
+    free((void*)sheet->out_encoding);
+    free((void*)sheet->out_version);
+    free((void*)sheet->out_doctype_system);
+    free((void*)sheet->out_doctype_public);
+    if (sheet->out_cdata_elems) {
+        for (size_t i = 0; sheet->out_cdata_elems[i]; i++)
+            free(sheet->out_cdata_elems[i]);
+        free(sheet->out_cdata_elems);
+    }
+    while (sheet->attrsets) {
+        XsltAttrSet* s = sheet->attrsets;
+        sheet->attrsets = s->next;
+        free((void*)s->name);
+        free((void*)s->name_uri);
+        for (size_t i = 0; i < s->use_count; i++)
+            free(s->use_uris ? s->use_uris[i] : NULL);
+        free(s->use_uris);
+        while (s->attrs) {
+            XsltLAttr* a = s->attrs; s->attrs = a->next;
+            free((void*)a->name); free((void*)a->value); free(a);
+        }
+        free(s);
+    }
+    if (sheet->ws_strip) {
+        for (size_t i = 0; sheet->ws_strip[i]; i++) free(sheet->ws_strip[i]);
+        free(sheet->ws_strip);
+    }
+    if (sheet->ws_preserve) {
+        for (size_t i = 0; sheet->ws_preserve[i]; i++)
+            free(sheet->ws_preserve[i]);
+        free(sheet->ws_preserve);
+    }
+    /* ws_rules entries alias ws_strip/ws_preserve strings — the
+     * containers alone are freed here. */
+    free(sheet->ws_rules);
+    free(sheet->ws_rule_preserve);
+    while (sheet->ns_alias) {
+        XsltNsAlias* na = sheet->ns_alias;
+        sheet->ns_alias = na->next;
+        free((void*)na->stylesheet_prefix);
+        free((void*)na->result_prefix);
+        free(na);
+    }
+    free((void*)sheet->out_media_type);
+    /* §16.1 cdata-section-elements list (Linux LSan: the array and
+     * its entries had no teardown). */
+    for (size_t i = 0; i < sheet->out_cdata_count; i++)
+        free(sheet->out_cdata[i]);
+    free(sheet->out_cdata);
+    /* §16.1 character maps + the active name list. */
+    for (size_t i = 0; i < sheet->charmap_count; i++) {
+        for (size_t k = 0; k < sheet->charmaps[i].count; k++) {
+            free(sheet->charmaps[i].chars[k]);
+            free(sheet->charmaps[i].repls[k]);
+        }
+        free(sheet->charmaps[i].name);
+        free(sheet->charmaps[i].chars);
+        free(sheet->charmaps[i].repls);
+    }
+    free(sheet->charmaps);
+    for (size_t i = 0; i < sheet->out_charmap_name_count; i++)
+        free(sheet->out_charmap_names[i]);
+    free(sheet->out_charmap_names);
+    for (size_t i = 0; i < sheet->exclude_count; i++)
+        free(sheet->exclude_pfx[i]);
+    free(sheet->exclude_pfx);
+    for (size_t i = 0; i < sheet->ext_count; i++)
+        free(sheet->ext_pfx[i]);
+    free(sheet->ext_pfx);
+    while (sheet->decformats) {
+        XsltDecimalFormat* d = sheet->decformats;
+        sheet->decformats = d->next;
+        free((void*)d->name);
+        free((void*)d->uri);
+        free((void*)d->local);
+        free((void*)d->decimal_sep);
+        free((void*)d->grouping_sep);
+        free((void*)d->infinity);
+        free((void*)d->nan);
+        free(d);
+    }
+    free(sheet);
+}
+
+/* ---- #682 stream gate -------------------------------------------------
+ * Conservative instruction scan: only shapes the stream emitters
+ * reproduce byte-exactly. Anything tree-building, post-hoc, or
+ * namespace-bearing keeps the result-tree path. */
+static int stream_indent_on(const XsltStylesheet* sheet) {
+    return sheet->out_indent == 1;   /* xml default is no (−1) */
+}
+
+static int stream_instrs_ok(const XsltInstr* in) {
+    for (; in; in = in->next) {
+        switch (in->kind) {
+            case XSLT_INSTR_RESULT_ELEM:
+                if ((in->ns_uri && in->ns_uri[0]) ||
+                    in->ns_out_count || in->ns_out_default ||
+                    in->attr_set_count)
+                    return 0;
+                for (XsltLAttr* a = in->attrs; a; a = a->next)
+                    if (strchr(a->name, ':')) return 0;
+                break;
+            case XSLT_INSTR_TEXT:
+            case XSLT_INSTR_VALUE_OF:
+                if (in->doe) return 0;
+                break;
+            case XSLT_INSTR_COMMENT:
+            case XSLT_INSTR_PI:
+                if (in->child) return 0;
+                break;
+            case XSLT_INSTR_VARIABLE:
+            case XSLT_INSTR_WITH_PARAM:
+                if (in->child) return 0;   /* content form builds RTFs */
+                break;
+            case XSLT_INSTR_FOR_EACH:
+            case XSLT_INSTR_IF:
+            case XSLT_INSTR_CHOOSE:
+            case XSLT_INSTR_WHEN:
+            case XSLT_INSTR_OTHERWISE:
+            case XSLT_INSTR_CALL_TEMPLATE:
+            case XSLT_INSTR_APPLY_TEMPLATES:
+            case XSLT_INSTR_MESSAGE:
+            case XSLT_INSTR_NUMBER:
+            case XSLT_INSTR_APPLY_IMPORTS:
+            case XSLT_INSTR_ITERATE:
+            case XSLT_INSTR_NEXT_ITERATION:
+            case XSLT_INSTR_BREAK:
+            case XSLT_INSTR_FOR_EACH_GROUP:
+            case XSLT_INSTR_EVALUATE:
+            case XSLT_INSTR_ANALYZE_STRING:
+            case XSLT_INSTR_MATCHING_SUBSTRING:
+            case XSLT_INSTR_NONMATCHING_SUBSTRING:
+            case XSLT_INSTR_TRY:
+            case XSLT_INSTR_CATCH:
+            case XSLT_INSTR_ON_EMPTY:
+            case XSLT_INSTR_ON_NON_EMPTY:
+            case XSLT_INSTR_NEXT_MATCH:
+                break;
+            default:
+                return 0;   /* COPY/COPY_OF/ELEMENT/ATTRIBUTE/SEQUENCE/
+                             * NAMESPACE/DOCUMENT/FORK/ATTR_SET_REF/
+                             * WHERE_POPULATED/FUNC_RESULT/... */
+        }
+        if (in->child && !stream_instrs_ok(in->child)) return 0;
+    }
+    return 1;
+}
+
+XsltStylesheet* xslt_stylesheet_parse(LeptrisDocument doc) {
+    if (!doc) return NULL;
+    return xslt_stylesheet_parse_root(doc, leptris_document_root(doc));
+}
+
+XsltStylesheet* xslt_stylesheet_parse_root(LeptrisDocument doc,
+                                           LeptrisElement root) {
+    if (!doc || !root) return NULL;
+    if (!node_is_xsl(root, "stylesheet") && !node_is_xsl(root, "transform")) {
+        return NULL;
+    }
+
+    XsltStylesheet* sheet = (XsltStylesheet*)calloc(1, sizeof(*sheet));
+    if (!sheet) return NULL;
+    sheet->out_standalone = -1;
+    sheet->out_indent = -1;
+    SheetParser sp;
+    sp.doc = doc; sp.sheet = sheet; sp.import_rank = 0; sp.errors = 0;
+    sp.chain.paths = NULL; sp.chain.len = 0; sp.chain.cap = 0;
+    /* §2.5: a version other than 1.0 enables forwards-compatible
+     * processing (unknown top-level elements ignored; unknown
+     * instructions fall back per §15). */
+    const char* ver = leptris_element_attribute(root, "version");
+    if (ver && strcmp(ver, "1.0") != 0) sheet->forwards_compat = 1;
+    sheet->version_major = 1;
+    if (ver) {
+        int maj = 0;
+        for (const char* p = ver; *p >= '0' && *p <= '9'; p++)
+            maj = maj * 10 + (*p - '0');
+        if (maj > 0) sheet->version_major = maj;
+    }
+    /* 3.0 §10.4.2: text value templates on literal text. */
+    {
+        const char* et = leptris_element_attribute(root, "expand-text");
+        if (et && strcmp(et, "yes") == 0 && sheet->version_major >= 3)
+            sheet->expand_text = 1;
+    }
+    /* Any namespace declaration in the sheet (beyond xsl) means
+     * expressions may use prefixed tests — parse-time ns contexts. */
+    if (leptris_element_namespace_decl_prefix(root, 0))
+        sheet->sheet_has_ns = 1;
+    /* §7.1.1/§14.1 excluded prefixes: exclude-result-prefixes +
+     * extension-element-prefixes on the stylesheet root. */
+    {
+        const char* lists[2] = {
+            leptris_element_attribute(root, "exclude-result-prefixes"),
+            leptris_element_attribute(root, "extension-element-prefixes"),
+        };
+        for (int li = 0; li < 2; li++) {
+            const char* v = lists[li];
+            if (!v || !*v) continue;
+            char* dup = leptris_strdup(v);
+            if (!dup) continue;
+            char* save = NULL;
+            for (char* tok = xslt_strtok(dup, " \t\n,", &save); tok;
+                 tok = xslt_strtok(NULL, " \t\n,", &save)) {
+                if (strcmp(tok, "#all") == 0) continue;   /* v1 */
+                sheet->exclude_pfx = (char**)realloc(
+                    sheet->exclude_pfx,
+                    (sheet->exclude_count + 1) * sizeof(char*));
+                sheet->exclude_pfx[sheet->exclude_count++] =
+                    leptris_strdup(tok);
+                if (li == 1) {
+                    /* extension-element-prefixes: also an extension
+                     * list (§15 fallback semantics). */
+                    sheet->ext_pfx = (char**)realloc(
+                        sheet->ext_pfx,
+                        (sheet->ext_count + 1) * sizeof(char*));
+                    sheet->ext_pfx[sheet->ext_count++] =
+                        leptris_strdup(tok);
+                }
+            }
+            free(dup);
+        }
+    }
+    /* Default xsl:decimal-format (always present; named formats
+     * append later). */
+    XsltDecimalFormat* df = (XsltDecimalFormat*)calloc(1, sizeof(*df));
+    if (df) {
+        df->decimal_sep = leptris_strdup(".");
+        df->grouping_sep = leptris_strdup(",");
+        df->minus_sign = '-'; df->percent = '%'; df->per_mille = '%';
+        df->zero_digit = '0';
+        df->infinity = leptris_strdup("Infinity");
+        df->nan = leptris_strdup("NaN");
+        df->next = sheet->decformats;
+        sheet->decformats = df;
+    }
+    parse_top_level(&sp, root);
+    while (sp.chain.len) chain_pop(&sp.chain);
+    free(sp.chain.paths);
+    if (sp.errors) {
+        xslt_stylesheet_free(sheet);
+        return NULL;
+    }
+    xslt_sheet_build_dispatch(sheet);
+
+    /* #682 parity gate: admit only the result shapes the stream
+     * emitters cover byte-exactly. Every instruction in every
+     * template (and the globals) must be stream-safe; any tree-
+     * building or post-hoc op keeps the sheet on the result-tree
+     * path. Conservative by construction — unknown kinds reject. */
+    sheet->can_stream = !sheet->out_method_text && !sheet->out_method_html &&
+        !stream_indent_on(sheet) && sheet->out_cdata_count == 0 &&
+        sheet->charmap_count == 0 && sheet->out_standalone < 0 &&
+        !sheet->out_doctype_system && !sheet->out_doctype_public &&
+        sheet->version_major < 3 &&
+        (sheet->mode_on_no_match == 1 || sheet->mode_on_no_match == 6) &&
+        stream_instrs_ok(sheet->globals);
+    for (size_t i = 0; sheet->can_stream && i < sheet->mode_count; i++) {
+        for (size_t t = 0; sheet->can_stream && t < sheet->modes[i].n; t++) {
+            sheet->can_stream =
+                stream_instrs_ok(sheet->modes[i].list[t]->body);
+        }
+    }
+    return sheet;
+}