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

data/vendor-src/libleptris/src/leptris/xquery/xquery.c

@@ -0,0 +1,2641 @@
+/* xquery.c — XQuery 1.0 core (TODO.xslt-full/11, #684-A).
+ *
+ * An orchestration layer over the XPath engine (SSOT): the prolog
+ * binds into the evaluation context, FLWOR clauses drive the same
+ * FOR/LET binding discipline the XPath 2.0+ forms use, and results
+ * reuse the XPath result model. No second evaluator.
+ *
+ * Ground truth: Saxon-HE 12.7 net.sf.saxon.Query (/tmp/probe9/xq).
+ */
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../include/leptris.h"
+#include "../../include/leptris/xquery/xquery.h"
+#include "../leptris_internal.h"
+#include "../xpath/evaluator.h"
+#include "../xpath/evaluator_internal.h"
+#include "../xpath/functions.h"
+#include "../xpath/parser.h"
+#include "../xpath/xpath_variables.h"
+
+extern struct leptris_xpath_result* evaluate_expr(XPathContext*,
+                                                  XPathASTNode*);
+extern struct leptris_xpath_result* xpath_call_function_item(
+    XPathContext* ctx, const char* cc, char** argv, size_t argc);
+extern XPathNodeSet* xpath_nodeset_deep_copy(const XPathNodeSet* src);
+
+/* ---- query model ---- */
+
+typedef enum { XQ_DECL_VAR, XQ_DECL_NS, XQ_DECL_FN } XqDeclKind;
+
+typedef struct {
+    XqDeclKind kind;
+    char* name;        /* var name (bare), ns prefix, or fn qname */
+    char* uri;         /* XQ_DECL_NS */
+    char* params;      /* XQ_DECL_FN: '\x01'-joined param names */
+    size_t arity;
+    XPathASTNode* ast; /* var initializer / fn body */
+    int external;      /* XQ_DECL_VAR: `declare variable $x
+                        * external [:= default]` — ast is default */
+} XqDecl;
+
+typedef struct {
+    int sliding;                     /* 0 = tumbling */
+    char* win_var;
+    char* s_var, *s_pos_var;
+    XPathASTNode* s_when;
+    char* e_var, *e_pos_var;
+    XPathASTNode* e_when;
+    XPathASTNode* domain;
+} XqWindow;
+
+typedef struct {
+    int is_for;        /* 0 = let; 2 = window */
+    char* var;
+    char* pos_var;     /* XQuery `for $x at $i` — NULL if none */
+    XPathASTNode* expr;
+    XqWindow win;
+} XqClause;
+
+typedef struct {
+    XPathASTNode* key;
+    int descending;
+} XqOrderKey;
+
+struct LeptrisXQueryInternal {
+    XqDecl* decls;
+    size_t ndecls;
+    XqClause* clauses;
+    size_t nclauses;
+    XPathASTNode* where_ast;
+    XqOrderKey* keys;
+    size_t nkeys;
+    char* group_var;        /* group by $k := Expr (12) */
+    XPathASTNode* group_key;
+    XPathASTNode* return_ast;
+};
+
+/* ---- scanning helpers ---- */
+
+typedef struct {
+    const char* p;
+    const char* end;
+} Scan;
+
+static void scan_ws(Scan* s) {
+    for (;;) {
+        while (s->p < s->end && isspace((unsigned char)*s->p)) s->p++;
+        /* XQuery comments (: ... :) — nestable. */
+        if (s->p + 1 < s->end && s->p[0] == ':' && s->p[1] == '(') {
+            int depth = 1;
+            s->p += 2;
+            while (s->p < s->end && depth > 0) {
+                if (s->p + 1 < s->end && s->p[0] == ':' &&
+                    s->p[1] == '(') {
+                    depth++;
+                    s->p += 2;
+                } else if (s->p + 1 < s->end && s->p[0] == ')' &&
+                           s->p[1] == ':') {
+                    depth--;
+                    s->p += 2;
+                } else {
+                    s->p++;
+                }
+            }
+            continue;
+        }
+        return;
+    }
+}
+
+/* Word at the cursor: [A-Za-z_][A-Za-z0-9.-]* (NCName set). */
+static size_t scan_word(Scan* s, const char** out) {
+    *out = s->p;
+    if (s->p >= s->end ||
+        !(isalpha((unsigned char)*s->p) || *s->p == '_'))
+        return 0;
+    const char* q = s->p;
+    while (q < s->end &&
+           (isalnum((unsigned char)*q) || *q == '_' || *q == '-' ||
+            *q == '.'))
+        q++;
+    return (size_t)(q - s->p);
+}
+
+static int word_is(const char* w, size_t len, const char* kw) {
+    return strlen(kw) == len && strncmp(w, kw, len) == 0;
+}
+
+/* Skip a quoted string ('...' / "..." with doubled-quote escapes). */
+static void scan_string(Scan* s) {
+    char q = *s->p;
+    s->p++;
+    while (s->p < s->end) {
+        if (*s->p == q) {
+            if (s->p + 1 < s->end && s->p[1] == q) {
+                s->p += 2;
+                continue;
+            }
+            s->p++;
+            return;
+        }
+        s->p++;
+    }
+}
+
+static int is_clause_word(const char* w, size_t len) {
+    return word_is(w, len, "for") || word_is(w, len, "let") ||
+           word_is(w, len, "where") || word_is(w, len, "order") ||
+           word_is(w, len, "by") || word_is(w, len, "return") ||
+           word_is(w, len, "stable") || word_is(w, len, "ascending") ||
+           word_is(w, len, "descending") || word_is(w, len, "group") ||
+           word_is(w, len, "tumbling") || word_is(w, len, "sliding") ||
+           word_is(w, len, "window") || word_is(w, len, "start") ||
+           word_is(w, len, "end") || word_is(w, len, "when") ||
+           word_is(w, len, "at");
+}
+
+/* Advance over one FLWOR expression segment: stops before a clause
+ * keyword at nesting depth 0 (a bare word delimited by whitespace
+ * or segment end). */
+static void scan_expr_segment(Scan* s, int stop_at_comma) {
+    int depth = 0;
+    while (s->p < s->end) {
+        char c = *s->p;
+        if (c == '\'' || c == '"') {
+            scan_string(s);
+            continue;
+        }
+        if (c == '`') {
+            s->p++;
+            while (s->p < s->end && *s->p != '`') s->p++;
+            if (s->p < s->end) s->p++;
+            continue;
+        }
+        if (c == '(' || c == '[' || c == '{') depth++;
+        else if (c == ')' || c == ']' || c == '}') {
+            if (depth == 0) return;   /* segment boundary */
+            depth--;
+        } else if (c == ',' && depth == 0 && stop_at_comma) {
+            return;
+        } else if (depth == 0 &&
+                   (isalpha((unsigned char)c) || c == '_')) {
+            const char* w;
+            size_t wl = scan_word(s, &w);
+            if (wl && is_clause_word(w, wl)) {
+                /* A clause keyword only at a word boundary followed
+                 * by whitespace/segment end. scan_word does not
+                 * advance the cursor — look past the word. */
+                const char* after = w + wl;
+                if (after >= s->end || isspace((unsigned char)*after))
+                    return;
+            }
+            s->p += wl ? wl : 1;
+            continue;
+        }
+        s->p++;
+    }
+}
+
+typedef struct { char* s; size_t len, cap; } Buf;
+static void buf_put(Buf* b, const char* s, size_t n);
+static void xq_expand_span(const char* a, const char* b, Buf* out);
+static const char* xq_expr_close(const char* p, const char* cb);
+static const char* xq_ctor_end(const char* ca, const char* cb);
+static void buf_str(Buf* b, const char* s);
+static const char* xq_translate_element(const char* p, const char* e,
+                                        Buf* out);
+static void xq_translate_content(const char* s, const char* e, Buf* out);
+static int xq_is_name_start(char c);
+
+/* Splice rewriter (#684): an expression span keeps its text
+ * verbatim; every DIRECT element constructor inside it is replaced
+ * by its computed form. Content-translating the whole span (the old
+ * approach) mangled expressions that merely CONTAIN a constructor —
+ * `count(document { <a/> }//b)` turned into text items. Adjacent
+ * constructors join with ", " (a top-level multi-ctor sequence). */
+static char* xq_splice_ctors(const char* a, const char* b) {
+    Buf tb = {0};
+    const char* p = a;
+    int prev_ctor = 0;
+    while (p < b) {
+        if (*p == '\'' || *p == '"') {
+            const char* q = p + 1;
+            while (q < b && *q != *p) q++;
+            buf_put(&tb, p, (size_t)((q < b ? q + 1 : b) - p));
+            p = (q < b) ? q + 1 : b;
+            prev_ctor = 0;
+            continue;
+        }
+        if (*p == '<' && p + 1 < b && xq_is_name_start(p[1])) {
+            if (prev_ctor && tb.len) buf_str(&tb, ", ");
+            /* Parenthesize: the computed form is a primary, and a
+             * following path step (`<a/>//x`) is only legal over a
+             * parenthesized primary. */
+            buf_str(&tb, "(");
+            const char* end = xq_translate_element(p, b, &tb);
+            buf_str(&tb, ")");
+            p = end ? end : p + 1;
+            prev_ctor = 1;
+            continue;
+        }
+        if (!isspace((unsigned char)*p)) prev_ctor = 0;
+        buf_put(&tb, p, 1);
+        p++;
+    }
+    if (!tb.s) {
+        tb.s = (char*)calloc(1, 1);
+        return tb.s;
+    }
+    tb.s[tb.len] = 0;
+    return tb.s;
+}
+
+/* String-constructor rewriter (#692 tail, XQuery 3.1):
+ * `lit {expr} lit` expands to concat("lit", string(EXPR), "lit").
+ * Doubled braces are literal braces; enclosed expressions are
+ * brace-matched with quote and nested-ctor awareness. Expansion MUST
+ * run before the direct-constructor splice — `<a/>` inside backticks
+ * is a STRING, and once quoted the splice pass skips it. */
+static const char* xq_skip_quoted(const char* q, const char* b) {
+    char qt = *q;
+    q++;
+    while (q < b) {
+        if (*q == qt && q + 1 < b && q[1] == qt) { q += 2; continue; }
+        if (*q == qt) return q + 1;
+        q++;
+    }
+    return b;
+}
+
+/* Closing backtick of a ctor whose content starts at ca, or NULL. */
+static const char* xq_ctor_end(const char* ca, const char* cb) {
+    const char* p = ca;
+    while (p < cb) {
+        if (*p == '`') return p;
+        if (*p == '{' && p + 1 < cb && p[1] == '{') { p += 2; continue; }
+        if (*p == '}' && p + 1 < cb && p[1] == '}') { p += 2; continue; }
+        if (*p == '{') {
+            const char* e = xq_expr_close(p, cb);
+            if (!e) return NULL;
+            p = e + 1;
+            continue;
+        }
+        p++;
+    }
+    return NULL;
+}
+
+/* Matching '}' for the '{' at p, or NULL. Skips quoted strings and
+ * nested string constructors inside the expression. */
+static const char* xq_expr_close(const char* p, const char* cb) {
+    int depth = 1;
+    const char* q = p + 1;
+    while (q < cb && depth > 0) {
+        if (*q == '\'' || *q == '"') {
+            q = xq_skip_quoted(q, cb);
+        } else if (*q == '`') {
+            const char* e = xq_ctor_end(q + 1, cb);
+            if (!e) return NULL;
+            q = e + 1;
+        } else {
+            if (*q == '{') depth++;
+            else if (*q == '}') depth--;
+            q++;
+        }
+    }
+    return depth == 0 ? q - 1 : NULL;
+}
+
+/* Append a literal chunk as one or more quoted XPath string args.
+ * The XPath 1.0 lexer has NO escape: a literal ends at the first
+ * matching quote. So runs go out double-quoted (split at "), and a
+ * lone " goes out as the one-char literal '"'. Segments rejoin via
+ * concat(), which the caller wraps once chunks >= 2. */
+static void xq_emit_quoted(Buf* args, const char* s, size_t n, int* nch) {
+    size_t i = 0;
+    while (i < n) {
+        size_t j = i;
+        if (s[j] != '"') {
+            while (j < n && s[j] != '"') j++;
+            if (*nch) buf_str(args, ", ");
+            buf_put(args, "\"", 1);
+            buf_put(args, s + i, j - i);
+            buf_put(args, "\"", 1);
+        } else {
+            if (*nch) buf_str(args, ", ");
+            buf_str(args, "'\"'");
+            j++;
+        }
+        (*nch)++;
+        i = j;
+    }
+}
+
+/* Expand ctor content [ca,cb) into out as ONE expression. */
+static void xq_emit_str_ctor(const char* ca, const char* cb, Buf* out) {
+    Buf args = {0}, lit = {0};
+    int nch = 0;
+    const char* p = ca;
+    while (p < cb) {
+        if (*p == '{' && p + 1 < cb && p[1] == '{') {
+            buf_put(&lit, "{", 1);
+            p += 2;
+            continue;
+        }
+        if (*p == '}' && p + 1 < cb && p[1] == '}') {
+            buf_put(&lit, "}", 1);
+            p += 2;
+            continue;
+        }
+        if (*p == '{') {
+            const char* e = xq_expr_close(p, cb);
+            if (!e) break;
+            xq_emit_quoted(&args, lit.s, lit.len, &nch);
+            lit.len = 0;
+            if (e > p + 1) {  /* empty {} contributes nothing */
+                if (nch) buf_str(&args, ", ");
+                buf_str(&args, "string(");
+                Buf inner = {0};
+                xq_expand_span(p + 1, e, &inner);
+                buf_put(&args, inner.s ? inner.s : "",
+                        inner.s ? inner.len : 0);
+                free(inner.s);
+                buf_str(&args, ")");
+                nch++;
+            }
+            p = e + 1;
+            continue;
+        }
+        buf_put(&lit, p, 1);
+        p++;
+    }
+    xq_emit_quoted(&args, lit.s, lit.len, &nch);
+    free(lit.s);
+    if (nch == 0) {
+        buf_str(out, "\"\"");
+    } else if (nch == 1) {
+        buf_put(out, args.s, args.len);
+    } else {
+        buf_str(out, "concat(");
+        buf_put(out, args.s, args.len);
+        buf_str(out, ")");
+    }
+    free(args.s);
+}
+
+/* Copy span verbatim, expanding every string constructor in it. */
+static void xq_expand_span(const char* a, const char* b, Buf* out) {
+    const char* p = a;
+    while (p < b) {
+        if (*p == '\'' || *p == '"') {
+            const char* q = xq_skip_quoted(p, b);
+            buf_put(out, p, (size_t)(q - p));
+            p = q;
+            continue;
+        }
+        if (*p == '`') {
+            const char* e = xq_ctor_end(p + 1, b);
+            if (!e) {
+                buf_put(out, p, (size_t)(b - p));
+                return;
+            }
+            xq_emit_str_ctor(p + 1, e, out);
+            p = e + 1;
+            continue;
+        }
+        buf_put(out, p, 1);
+        p++;
+    }
+}
+
+/* Whole-span entry: NULL when no backtick (caller keeps the text). */
+static char* xq_rewrite_str_ctors(const char* a, const char* b) {
+    int has = 0;
+    for (const char* q = a; q < b && !has; q++)
+        if (*q == '`') has = 1;
+    if (!has) return NULL;
+    Buf tb = {0};
+    xq_expand_span(a, b, &tb);
+    if (!tb.s) {
+        tb.s = (char*)calloc(1, 1);
+        return tb.s;
+    }
+    tb.s[tb.len] = 0;
+    return tb.s;
+}
+
+static XPathASTNode* parse_expr_span(const char* a, const char* b) {
+    if (a >= b) return NULL;
+    char* rewritten = xq_rewrite_str_ctors(a, b);
+    if (rewritten) {
+        a = rewritten;
+        b = rewritten + strlen(rewritten);
+    }
+    int has_ctor = 0;
+    for (const char* q = a; q + 1 < b && !has_ctor; q++)
+        if (*q == '<' && xq_is_name_start(q[1])) has_ctor = 1;
+    char* translated = NULL;
+    if (has_ctor) {
+        translated = xq_splice_ctors(a, b);
+        if (!translated) { free(rewritten); return NULL; }
+        a = translated;
+        b = translated + strlen(translated);
+    }
+    XPathParser* parser = xpath_parser_new(a, (size_t)(b - a));
+    if (!parser) { free(translated); free(rewritten); return NULL; }
+    XPathASTNode* ast = xpath_parse(parser);
+    xpath_parser_free(parser);
+    free(translated);
+    free(rewritten);
+    return ast;
+}
+
+static char* span_dup(const char* a, const char* b) {
+    size_t n = (size_t)(b - a);
+    char* s = (char*)malloc(n + 1);
+    if (!s) return NULL;
+    memcpy(s, a, n);
+    s[n] = 0;
+    return s;
+}
+
+/* ---- parse ---- */
+
+static void xq_free(struct LeptrisXQueryInternal* q) {
+    if (!q) return;
+    for (size_t i = 0; i < q->ndecls; i++) {
+        free(q->decls[i].name);
+        free(q->decls[i].uri);
+        free(q->decls[i].params);
+        if (q->decls[i].ast) ast_node_free(q->decls[i].ast);
+    }
+    free(q->decls);
+    for (size_t i = 0; i < q->nclauses; i++) {
+        free(q->clauses[i].var);
+        free(q->clauses[i].pos_var);
+        if (q->clauses[i].expr) ast_node_free(q->clauses[i].expr);
+        if (q->clauses[i].is_for == 2) {
+            XqWindow* w = &q->clauses[i].win;
+            free(w->win_var);
+            free(w->s_var);
+            free(w->s_pos_var);
+            free(w->e_var);
+            free(w->e_pos_var);
+            if (w->s_when) ast_node_free(w->s_when);
+            if (w->e_when) ast_node_free(w->e_when);
+            if (w->domain) ast_node_free(w->domain);
+        }
+    }
+    free(q->clauses);
+    if (q->where_ast) ast_node_free(q->where_ast);
+    for (size_t i = 0; i < q->nkeys; i++)
+        if (q->keys[i].key) ast_node_free(q->keys[i].key);
+    free(q->keys);
+    free(q->group_var);
+    if (q->group_key) ast_node_free(q->group_key);
+    if (q->return_ast) ast_node_free(q->return_ast);
+    free(q);
+}
+
+static void xq_clause_partial_free(XqClause* c) {
+    if (c->is_for != 2) {
+        free(c->var);
+        free(c->pos_var);
+        if (c->expr) ast_node_free(c->expr);
+        return;
+    }
+    XqWindow* w = &c->win;
+    free(w->win_var);
+    free(w->s_var);
+    free(w->s_pos_var);
+    free(w->e_var);
+    free(w->e_pos_var);
+    if (w->s_when) ast_node_free(w->s_when);
+    if (w->e_when) ast_node_free(w->e_when);
+    if (w->domain) ast_node_free(w->domain);
+}
+
+/* Parse one `$name` reference; returns the bare name (malloc). */
+static char* parse_dollar_name(Scan* s) {
+    scan_ws(s);
+    if (s->p >= s->end || *s->p != '$') return NULL;
+    s->p++;
+    /* Variable names are QNames — include ':' ($p:weight). */
+    const char* w = s->p;
+    while (s->p < s->end &&
+           (isalnum((unsigned char)*s->p) || *s->p == '_' ||
+            *s->p == '-' || *s->p == '.' || *s->p == ':'))
+        s->p++;
+    if (s->p == w) return NULL;
+    return span_dup(w, s->p);
+}
+
+static int parse_decl(struct LeptrisXQueryInternal* q, Scan* s,
+                      XqDecl* out) {
+    memset(out, 0, sizeof(*out));
+    scan_ws(s);
+    const char* w;
+    size_t wl = scan_word(s, &w);
+    s->p = w + wl;
+    if (word_is(w, wl, "variable")) {
+        char* name = parse_dollar_name(s);
+        if (!name) return 0;
+        scan_ws(s);
+        /* Optional `as SequenceType` — skipped textually: walk to
+         * `external` or `:=` at depth 0 before the ';'. */
+        {
+            Scan at = *s;
+            const char* aw;
+            size_t awl = scan_word(&at, &aw);
+            if (awl && word_is(aw, awl, "as")) {
+                const char* p = aw + awl;
+                int depth = 0;
+                const char* stop = NULL;
+                while (p < s->end) {
+                    char c = *p;
+                    if (c == '\'' || c == '"') {
+                        const char* q = p + 1;
+                        while (q < s->end && *q != c) q++;
+                        p = (q < s->end) ? q + 1 : s->end;
+                        continue;
+                    }
+                    if (c == '(' || c == '[' || c == '{') depth++;
+                    else if (c == ')' || c == ']' || c == '}') depth--;
+                    else if (c == ';' && depth == 0) break;
+                    else if (depth == 0 && p + 1 < s->end &&
+                             p[0] == ':' && p[1] == '=') {
+                        stop = p;
+                        break;
+                    } else if (depth == 0 &&
+                               (isalpha((unsigned char)c) || c == '_')) {
+                        const char* ww;
+                        size_t wwl = scan_word(&((Scan){p, s->end}), &ww);
+                        if (wwl && word_is(ww, wwl, "external")) {
+                            stop = ww;
+                            break;
+                        }
+                        p += wwl ? wwl : 1;
+                        continue;
+                    }
+                    p++;
+                }
+                if (!stop) {
+                    free(name);
+                    return 0;
+                }
+                s->p = stop;
+                scan_ws(s);
+            }
+        }
+        {
+            Scan t = *s;
+            const char* ew;
+            size_t ewl = scan_word(&t, &ew);
+            if (ewl && word_is(ew, ewl, "external")) {
+                s->p = ew + ewl;
+                scan_ws(s);
+                out->kind = XQ_DECL_VAR;
+                out->name = name;
+                out->external = 1;
+                if (s->p + 1 < s->end &&
+                    s->p[0] == ':' && s->p[1] == '=') {
+                    s->p += 2;
+                    Scan e = *s;
+                    {
+                        int depth = 0;
+                        while (e.p < e.end) {
+                            char c = *e.p;
+                            if (c == '\'' || c == '"') {
+                                scan_string(&e);
+                                continue;
+                            }
+                            if (c == '(' || c == '[' || c == '{') depth++;
+                            else if (c == ')' || c == ']' || c == '}') depth--;
+                            else if (c == ';' && depth == 0) break;
+                            e.p++;
+                        }
+                    }
+                    out->ast = parse_expr_span(s->p, e.p);
+                    if (!out->ast) {
+                        return 0;
+                    }
+                    s->p = (e.p < e.end) ? e.p + 1 : e.end;
+                } else if (s->p < s->end && *s->p == ';') {
+                    s->p++;
+                }
+                return 1;
+            }
+        }
+        if (s->p + 1 >= s->end || s->p[0] != ':' || s->p[1] != '=') {
+            free(name);
+            return 0;
+        }
+        s->p += 2;
+        /* initializer runs to the terminating ';' at depth 0 */
+        Scan e = *s;
+        {
+            int depth = 0;
+            while (e.p < e.end) {
+                char c = *e.p;
+                if (c == '\'' || c == '"') {
+                    scan_string(&e);
+                    continue;
+                }
+                if (c == '(' || c == '[' || c == '{') depth++;
+                else if (c == ')' || c == ']' || c == '}') depth--;
+                else if (c == ';' && depth == 0) break;
+                e.p++;
+            }
+        }
+        out->kind = XQ_DECL_VAR;
+        out->name = name;
+        out->ast = parse_expr_span(s->p, e.p);
+        if (!out->ast) return 0;
+        s->p = (e.p < e.end) ? e.p + 1 : e.end;   /* ';' */
+        return 1;
+    }
+    if (word_is(w, wl, "namespace")) {
+        scan_ws(s);
+        wl = scan_word(s, &w);
+        if (!wl) return 0;
+        s->p = w + wl;
+        char* prefix = span_dup(w, w + wl);
+        scan_ws(s);
+        if (s->p >= s->end || *s->p != '=') {
+            free(prefix);
+            return 0;
+        }
+        s->p++;
+        scan_ws(s);
+        if (s->p >= s->end || (*s->p != '"' && *s->p != '\'')) {
+            free(prefix);
+            return 0;
+        }
+        const char* qs = s->p;
+        scan_string(s);
+        out->kind = XQ_DECL_NS;
+        out->name = prefix;
+        out->uri = span_dup(qs + 1, s->p - 1);
+        scan_ws(s);
+        if (s->p < s->end && *s->p == ';') s->p++;
+        return out->uri != NULL;
+    }
+    if (word_is(w, wl, "function")) {
+        scan_ws(s);
+        /* function names are QNames — include ':' */
+        {
+            const char* q = s->p;
+            while (q < s->end &&
+                   (isalnum((unsigned char)*q) || *q == '_' ||
+                    *q == '-' || *q == '.' || *q == ':'))
+                q++;
+            wl = (size_t)(q - s->p);
+            w = s->p;
+        }
+        if (!wl) return 0;
+        s->p = w + wl;
+        char* fname = span_dup(w, w + wl);
+        scan_ws(s);
+        if (s->p >= s->end || *s->p != '(') {
+            free(fname);
+            return 0;
+        }
+        s->p++;
+        /* parameters */
+        char params[256];
+        size_t plen = 0;
+        params[0] = 0;
+        size_t arity = 0;
+        for (;;) {
+            scan_ws(s);
+            if (s->p < s->end && *s->p == ')') {
+                s->p++;
+                break;
+            }
+            char* pn = parse_dollar_name(s);
+            if (!pn) {
+                free(fname);
+                return 0;
+            }
+            arity++;
+            size_t pnlen = strlen(pn);
+            if (plen && plen + 1 < sizeof(params))
+                params[plen++] = '\x01';
+            if (plen + pnlen < sizeof(params)) {
+                memcpy(params + plen, pn, pnlen);
+                plen += pnlen;
+            }
+            params[plen] = 0;
+            free(pn);
+            scan_ws(s);
+            /* optional `as SequenceType` — skip to , or ) */
+            while (s->p < s->end && *s->p != ',' && *s->p != ')') s->p++;
+            if (s->p < s->end && *s->p == ',') s->p++;
+        }
+        /* optional `as SequenceType` — skip to '{' */
+        scan_ws(s);
+        while (s->p < s->end && *s->p != '{') s->p++;
+        if (s->p >= s->end) {
+            free(fname);
+            return 0;
+        }
+        s->p++;   /* '{' */
+        /* body: to the matching '}' */
+        int depth = 1;
+        const char* body = s->p;
+        while (s->p < s->end && depth > 0) {
+            char c = *s->p;
+            if (c == '\'' || c == '"') {
+                scan_string(s);
+                continue;
+            }
+            if (c == '{') depth++;
+            else if (c == '}') depth--;
+            if (depth == 0) break;
+            s->p++;
+        }
+        out->kind = XQ_DECL_FN;
+        out->name = fname;
+        out->params = span_dup(params, params + plen);
+        out->arity = arity;
+        out->ast = parse_expr_span(body, s->p);
+        if (s->p < s->end) s->p++;   /* '}' */
+        scan_ws(s);
+        if (s->p < s->end && *s->p == ';') s->p++;
+        return out->ast != NULL && out->params != NULL;
+    }
+    return 0;   /* import / option / default / base-uri */
+}
+
+LEPTRIS_API LeptrisXQuery leptris_xquery_parse(const char* query,
+                                               size_t len) {
+    if (!query || !len) return NULL;
+    struct LeptrisXQueryInternal* q =
+        (struct LeptrisXQueryInternal*)calloc(1, sizeof(*q));
+    if (!q) return NULL;
+
+    Scan s = {query, query + len};
+
+    /* Prolog. */
+    scan_ws(&s);
+    for (;;) {
+        /* XQuery version declaration: `xquery version 'X';`
+         * (+ optional `encoding "enc";`) — accepted and skipped
+         * (the engine's semantics are version-independent; #684). */
+        {
+            Scan t = s;
+            const char* w;
+            size_t wl = scan_word(&t, &w);
+            if (wl && word_is(w, wl, "xquery")) {
+                t.p = w + wl;
+                scan_ws(&t);
+                wl = scan_word(&t, &w);
+                if (wl && word_is(w, wl, "version")) {
+                    t.p = w + wl;
+                    scan_ws(&t);
+                    if (t.p < t.end &&
+                        (*t.p == '"' || *t.p == '\'')) {
+                        scan_string(&t);
+                        scan_ws(&t);
+                        /* optional encoding decl */
+                        {
+                            Scan e = t;
+                            const char* ew;
+                            size_t ewl = scan_word(&e, &ew);
+                            if (ewl && word_is(ew, ewl, "encoding")) {
+                                e.p = ew + ewl;
+                                scan_ws(&e);
+                                if (e.p < e.end &&
+                                    (*e.p == '"' || *e.p == '\'')) {
+                                    scan_string(&e);
+                                    t = e;
+                                    scan_ws(&t);
+                                }
+                            }
+                        }
+                        if (t.p < t.end && *t.p == ';') {
+                            t.p++;
+                            s = t;
+                            scan_ws(&s);
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        const char* w;
+        Scan t = s;
+        size_t wl = scan_word(&t, &w);
+        if (!wl || !word_is(w, wl, "declare")) break;
+        t.p = w + wl;
+        XqDecl d;
+        if (!parse_decl(q, &t, &d)) {
+            xq_free(q);
+            return NULL;
+        }
+        XqDecl* grown = (XqDecl*)realloc(q->decls,
+                                         (q->ndecls + 1) * sizeof(XqDecl));
+        if (!grown) {
+            xq_free(q);
+            return NULL;
+        }
+        q->decls = grown;
+        q->decls[q->ndecls++] = d;
+        s = t;
+        scan_ws(&s);
+    }
+
+    /* Body. */
+    scan_ws(&s);
+    {
+        const char* w;
+        Scan t = s;
+        size_t wl = scan_word(&t, &w);
+        if (wl && (word_is(w, wl, "for") || word_is(w, wl, "let"))) {
+            /* FLWOR */
+            for (;;) {
+                scan_ws(&s);
+                const char* kw;
+                size_t kwl = scan_word(&s, &kw);
+                if (!kwl) {
+                    xq_free(q);
+                    return NULL;
+                }
+                s.p = kw + kwl;
+                if (word_is(kw, kwl, "stable")) continue;
+                if (word_is(kw, kwl, "for") || word_is(kw, kwl, "let")) {
+                    int is_for = word_is(kw, kwl, "for");
+                    /* window clause: for tumbling|sliding window
+                     * $w in D start ... end ... (TODO 12) */
+                    {
+                        Scan wk = s;
+                        scan_ws(&wk);
+                        const char* wword;
+                        size_t wwl = scan_word(&wk, &wword);
+                        if (is_for && wwl &&
+                            (word_is(wword, wwl, "tumbling") ||
+                             word_is(wword, wwl, "sliding"))) {
+                            int sliding =
+                                word_is(wword, wwl, "sliding");
+                            s.p = wword + wwl;
+                            scan_ws(&s);
+                            const char* kw2;
+                            size_t k2 = scan_word(&s, &kw2);
+                            if (!k2 || !word_is(kw2, k2, "window")) {
+                                xq_free(q);
+                                return NULL;
+                            }
+                            s.p = kw2 + k2;
+                            XqClause wc;
+                            memset(&wc, 0, sizeof(wc));
+                            wc.is_for = 2;
+                            wc.win.sliding = sliding;
+                            wc.win.win_var = parse_dollar_name(&s);
+                            if (!wc.win.win_var) {
+                                xq_free(q);
+                                return NULL;
+                            }
+                            scan_ws(&s);
+                            const char* iw;
+                            size_t iwl = scan_word(&s, &iw);
+                            if (!iwl || !word_is(iw, iwl, "in")) {
+                                xq_clause_partial_free(&wc);
+                                xq_free(q);
+                                return NULL;
+                            }
+                            s.p = iw + iwl;
+                            Scan e = s;
+                            scan_expr_segment(&e, 0);
+                            wc.win.domain = parse_expr_span(s.p, e.p);
+                            if (!wc.win.domain) {
+                                xq_clause_partial_free(&wc);
+                                xq_free(q);
+                                return NULL;
+                            }
+                            s = e;
+                            /* start clause */
+                            scan_ws(&s);
+                            const char* sw;
+                            size_t swl = scan_word(&s, &sw);
+                            if (!swl || !word_is(sw, swl, "start")) {
+                                xq_clause_partial_free(&wc);
+                                xq_free(q);
+                                return NULL;
+                            }
+                            s.p = sw + swl;
+                            scan_ws(&s);
+                            if (s.p < s.end && *s.p == '$') {
+                                wc.win.s_var = parse_dollar_name(&s);
+                                if (!wc.win.s_var) {
+                                    xq_clause_partial_free(&wc);
+                                    xq_free(q);
+                                    return NULL;
+                                }
+                                scan_ws(&s);
+                                const char* aw;
+                                size_t awl = scan_word(&s, &aw);
+                                if (awl && word_is(aw, awl, "at")) {
+                                    s.p = aw + awl;
+                                    wc.win.s_pos_var =
+                                        parse_dollar_name(&s);
+                                    if (!wc.win.s_pos_var) {
+                                        xq_clause_partial_free(&wc);
+                                        xq_free(q);
+                                        return NULL;
+                                    }
+                                    scan_ws(&s);
+                                }
+                            }
+                            {
+                                const char* ww;
+                                size_t wwl2 = scan_word(&s, &ww);
+                                if (wwl2 && word_is(ww, wwl2, "when")) {
+                                    s.p = ww + wwl2;
+                                    Scan se = s;
+                                    scan_expr_segment(&se, 0);
+                                    wc.win.s_when =
+                                        parse_expr_span(s.p, se.p);
+                                    if (!wc.win.s_when) {
+                                        xq_clause_partial_free(&wc);
+                                        xq_free(q);
+                                        return NULL;
+                                    }
+                                    s = se;
+                                }
+                            }
+                            /* optional end clause */
+                            scan_ws(&s);
+                            {
+                                const char* ew;
+                                size_t ewl = scan_word(&s, &ew);
+                                if (ewl && word_is(ew, ewl, "end")) {
+                                    s.p = ew + ewl;
+                                    scan_ws(&s);
+                                    if (s.p < s.end && *s.p == '$') {
+                                        wc.win.e_var =
+                                            parse_dollar_name(&s);
+                                        if (!wc.win.e_var) {
+                                            xq_clause_partial_free(&wc);
+                                            xq_free(q);
+                                            return NULL;
+                                        }
+                                        scan_ws(&s);
+                                        const char* aw;
+                                        size_t awl = scan_word(&s, &aw);
+                                        if (awl &&
+                                            word_is(aw, awl, "at")) {
+                                            s.p = aw + awl;
+                                            wc.win.e_pos_var =
+                                                parse_dollar_name(&s);
+                                            if (!wc.win.e_pos_var) {
+                                                xq_clause_partial_free(
+                                                    &wc);
+                                                xq_free(q);
+                                                return NULL;
+                                            }
+                                            scan_ws(&s);
+                                        }
+                                    }
+                                    const char* ww;
+                                    size_t wwl2 = scan_word(&s, &ww);
+                                    if (wwl2 && word_is(ww, wwl2, "when")) {
+                                        s.p = ww + wwl2;
+                                        Scan ee = s;
+                                        scan_expr_segment(&ee, 0);
+                                        wc.win.e_when =
+                                            parse_expr_span(s.p, ee.p);
+                                        if (!wc.win.e_when) {
+                                            xq_clause_partial_free(&wc);
+                                            xq_free(q);
+                                            return NULL;
+                                        }
+                                        s = ee;
+                                    }
+                                }
+                            }
+                            XqClause* grown =
+                                (XqClause*)realloc(
+                                    q->clauses, (q->nclauses + 1) *
+                                                    sizeof(XqClause));
+                            if (!grown) {
+                                xq_clause_partial_free(&wc);
+                                xq_free(q);
+                                return NULL;
+                            }
+                            q->clauses = grown;
+                            q->clauses[q->nclauses++] = wc;
+                            continue;
+                        }
+                    }
+                    /* Binding list: one clause binds
+                     * VAR (:=|in) ExprSingle ("," VAR ...)*. */
+                    for (;;) {
+                        char* var = parse_dollar_name(&s);
+                        if (!var) {
+                            xq_free(q);
+                            return NULL;
+                        }
+                        char* pos_var = NULL;
+                        scan_ws(&s);
+                        if (is_for) {
+                            /* positional: for $x at $i in ... */
+                            Scan at = s;
+                            const char* aw;
+                            size_t awl = scan_word(&at, &aw);
+                            if (awl && word_is(aw, awl, "at") &&
+                                aw + awl < s.end) {
+                                s.p = aw + awl;
+                                pos_var = parse_dollar_name(&s);
+                                if (!pos_var) {
+                                    free(var);
+                                    xq_free(q);
+                                    return NULL;
+                                }
+                                scan_ws(&s);
+                            }
+                            const char* iw;
+                            size_t iwl = scan_word(&s, &iw);
+                            if (!iwl || !word_is(iw, iwl, "in")) {
+                                free(var);
+                                xq_free(q);
+                                return NULL;
+                            }
+                            s.p = iw + iwl;
+                        } else {
+                            if (s.p + 1 >= s.end || s.p[0] != ':' ||
+                                s.p[1] != '=') {
+                                free(var);
+                                xq_free(q);
+                                return NULL;
+                            }
+                            s.p += 2;
+                        }
+                        Scan e = s;
+                        scan_expr_segment(&e, 1);
+                        XPathASTNode* expr = parse_expr_span(s.p, e.p);
+                        if (!expr) {
+                            free(var);
+                            xq_free(q);
+                            return NULL;
+                        }
+                        XqClause* grown = (XqClause*)realloc(
+                            q->clauses,
+                            (q->nclauses + 1) * sizeof(XqClause));
+                        if (!grown) {
+                            free(var);
+                            ast_node_free(expr);
+                            xq_free(q);
+                            return NULL;
+                        }
+                        q->clauses = grown;
+                        q->clauses[q->nclauses].is_for = is_for;
+                        q->clauses[q->nclauses].var = var;
+                        q->clauses[q->nclauses].pos_var = pos_var;
+                        q->clauses[q->nclauses].expr = expr;
+                        q->nclauses++;
+                        s = e;
+                        scan_ws(&s);
+                        if (s.p < s.end && *s.p == ',') {
+                            s.p++;
+                            scan_ws(&s);
+                            continue;
+                        }
+                        break;
+                    }
+                } else if (word_is(kw, kwl, "where")) {
+                    Scan e = s;
+                    scan_expr_segment(&e, 0);
+                    q->where_ast = parse_expr_span(s.p, e.p);
+                    if (!q->where_ast) {
+                        xq_free(q);
+                        return NULL;
+                    }
+                    s = e;
+                } else if (word_is(kw, kwl, "group")) {
+                    scan_ws(&s);
+                    const char* bw;
+                    size_t bwl = scan_word(&s, &bw);
+                    if (!bwl || !word_is(bw, bwl, "by")) {
+                        xq_free(q);
+                        return NULL;
+                    }
+                    s.p = bw + bwl;
+                    char* gvar = parse_dollar_name(&s);
+                    if (!gvar) {
+                        xq_free(q);
+                        return NULL;
+                    }
+                    scan_ws(&s);
+                    if (s.p + 1 >= s.end || s.p[0] != ':' ||
+                        s.p[1] != '=') {
+                        free(gvar);
+                        xq_free(q);
+                        return NULL;
+                    }
+                    s.p += 2;
+                    Scan e = s;
+                    scan_expr_segment(&e, 0);
+                    XPathASTNode* gk = parse_expr_span(s.p, e.p);
+                    if (!gk) {
+                        free(gvar);
+                        xq_free(q);
+                        return NULL;
+                    }
+                    q->group_var = gvar;
+                    q->group_key = gk;
+                    s = e;
+                } else if (word_is(kw, kwl, "order")) {
+                    scan_ws(&s);
+                    const char* bw;
+                    size_t bwl = scan_word(&s, &bw);
+                    if (!bwl || !word_is(bw, bwl, "by")) {
+                        xq_free(q);
+                        return NULL;
+                    }
+                    s.p = bw + bwl;
+                    for (;;) {
+                        scan_ws(&s);
+                        Scan e = s;
+                        scan_expr_segment(&e, 1);   /* stop at ',' */
+                        XPathASTNode* key = parse_expr_span(s.p, e.p);
+                        if (!key) {
+                            xq_free(q);
+                            return NULL;
+                        }
+                        int desc = 0;
+                        s = e;
+                        scan_ws(&s);
+                        const char* dw;
+                        Scan dt = s;
+                        size_t dwl = scan_word(&dt, &dw);
+                        if (dwl && (word_is(dw, dwl, "descending"))) {
+                            desc = 1;
+                            s.p = dw + dwl;
+                        } else if (dwl &&
+                                   word_is(dw, dwl, "ascending")) {
+                            s.p = dw + dwl;
+                        }
+                        XqOrderKey* grown = (XqOrderKey*)realloc(
+                            q->keys, (q->nkeys + 1) * sizeof(XqOrderKey));
+                        if (!grown) {
+                            ast_node_free(key);
+                            xq_free(q);
+                            return NULL;
+                        }
+                        q->keys = grown;
+                        q->keys[q->nkeys].key = key;
+                        q->keys[q->nkeys].descending = desc;
+                        q->nkeys++;
+                        scan_ws(&s);
+                        if (s.p < s.end && *s.p == ',') {
+                            s.p++;
+                            continue;
+                        }
+                        break;
+                    }
+                } else if (word_is(kw, kwl, "return")) {
+                    q->return_ast = parse_expr_span(s.p, s.end);
+                    if (!q->return_ast) {
+                        xq_free(q);
+                        return NULL;
+                    }
+                    return q;
+                } else {
+                    xq_free(q);
+                    return NULL;
+                }
+            }
+        }
+    }
+
+    /* Plain XPath expression body. */
+    q->return_ast = parse_expr_span(s.p, s.end);
+    if (!q->return_ast) {
+        xq_free(q);
+        return NULL;
+    }
+    return q;
+}
+
+static LeptrisXPathResult xq_eval_impl(
+    LeptrisXQuery query, LeptrisDocument doc, LeptrisElement context_node,
+    const char* const* param_names, const char* const* param_selects,
+    size_t nparams);
+
+LEPTRIS_API LeptrisXPathResult leptris_xquery_eval(LeptrisXQuery query,
+                                                   LeptrisDocument doc,
+                                                   LeptrisElement context_node) {
+    return xq_eval_impl(query, doc, context_node, NULL, NULL, 0);
+}
+
+LEPTRIS_API LeptrisXPathResult leptris_xquery_eval_params(
+    LeptrisXQuery query, LeptrisDocument doc, LeptrisElement context_node,
+    const char* const* names, const char* const* selects, size_t count) {
+    if (count && (!names || !selects)) return NULL;
+    return xq_eval_impl(query, doc, context_node, names, selects, count);
+}
+
+LEPTRIS_API void leptris_xquery_free(LeptrisXQuery query) {
+    xq_free((struct LeptrisXQueryInternal*)query);
+}
+
+/* ---- evaluation ---- */
+
+/* local:function thunk: user_data = "\x03FN..." closure content. */
+static struct leptris_xpath_result* xq_fn_thunk(XPathContext* ctx,
+                                                XPathASTNode** args,
+                                                size_t arg_count) {
+    const char* cc = (const char*)ctx->current_fn_user_data;
+    if (!cc) return NULL;
+    char** argv = NULL;
+    if (arg_count) {
+        argv = (char**)calloc(arg_count, sizeof(char*));
+        if (!argv) return NULL;
+    }
+    struct leptris_xpath_result* out = NULL;
+    int ok = 1;
+    for (size_t i = 0; i < arg_count; i++) {
+        struct leptris_xpath_result* r = evaluate_expr(ctx, args[i]);
+        char* v = r ? xpath_to_string(r) : NULL;
+        if (r) xpath_result_free(r);
+        argv[i] = v ? v : strdup("");
+        if (!argv[i]) ok = 0;
+    }
+    if (ok) out = xpath_call_function_item(ctx, cc, argv, arg_count);
+    for (size_t i = 0; i < arg_count; i++) free(argv[i]);
+    free(argv);
+    return out;
+}
+
+/* Bind a variable to an evaluated result (FOR/LET/prolog): nodeset
+ * results deep-copy synthetic members; scalars ride one synthetic
+ * member (numeric-marker discipline). */
+static int xq_bind(XPathContext* ctx, const char* name,
+                   struct leptris_xpath_result* v) {
+    XPathNodeSet* one;
+    if (v->type == XPATH_RESULT_NODESET && v->value.nodeset_value) {
+        one = xpath_nodeset_deep_copy(v->value.nodeset_value);
+    } else {
+        one = xpath_nodeset_new();
+        if (one) {
+            one->owns_synthetic_text = 1;
+            if (v->type == XPATH_RESULT_NUMBER) {
+                char* s = xpath_to_string(v);
+                size_t sl = s ? strlen(s) : 0;
+                char* marked = (char*)malloc(sl + 3);
+                if (marked) {
+                    marked[0] = '\x03';
+                    marked[1] = 'N';
+                    if (sl) memcpy(marked + 2, s, sl);
+                    marked[2 + sl] = 0;
+                    XPathTextNode* tn =
+                        xpath_synth_text(marked, sl + 2);
+                    free(marked);
+                    if (tn) xpath_nodeset_add(one, tn);
+                }
+                free(s);
+            } else {
+                char* s = xpath_to_string(v);
+                XPathTextNode* tn =
+                    xpath_synth_text(s ? s : "", s ? strlen(s) : 0);
+                free(s);
+                if (tn) xpath_nodeset_add(one, tn);
+            }
+        }
+    }
+    if (!one) return 0;
+    XPathVariable* var = xpath_variable_set_add(
+        (XPathVariableSet*)ctx->variable_set, name,
+        XPATH_VAR_TYPE_NODE_SET);
+    if (!var) {
+        xpath_nodeset_free(one);
+        return 0;
+    }
+    xpath_variable_set_nodeset(var, one);   /* var owns it */
+    return 1;
+}
+
+/* Tuple snapshot: per var, a LIST of members (nodes or raw
+ * synthetic contents) — group by rebinds vars to whole-group
+ * sequences. */
+typedef struct {
+    char** names;
+    char*** contents;  /* contents[i][j]; NULL member = node */
+    void*** nodes;
+    size_t* counts;
+    size_t n;
+    char** keys;       /* order-key strings */
+    size_t nkeys;
+} XqTuple;
+
+static void xq_tuple_free(XqTuple* t) {
+    for (size_t i = 0; i < t->n; i++) {
+        free(t->names[i]);
+        for (size_t j = 0; j < t->counts[i]; j++) {
+            if (t->contents[i]) free(t->contents[i][j]);
+        }
+        free(t->contents[i]);
+        free(t->nodes[i]);
+    }
+    free(t->names);
+    free(t->contents);
+    free(t->nodes);
+    free(t->counts);
+    for (size_t i = 0; i < t->nkeys; i++) free(t->keys[i]);
+    free(t->keys);
+}
+
+static void xq_unbind_all(XPathContext* ctx, XqClause* clauses,
+                          size_t n) {
+    for (size_t i = 0; i < n; i++) {
+        if (clauses[i].is_for == 2) {
+            XqWindow* w = &clauses[i].win;
+            if (w->win_var)
+                xpath_variable_set_remove(
+                    (XPathVariableSet*)ctx->variable_set,
+                    w->win_var);
+            if (w->s_var)
+                xpath_variable_set_remove(
+                    (XPathVariableSet*)ctx->variable_set, w->s_var);
+            if (w->s_pos_var)
+                xpath_variable_set_remove(
+                    (XPathVariableSet*)ctx->variable_set,
+                    w->s_pos_var);
+            if (w->e_var)
+                xpath_variable_set_remove(
+                    (XPathVariableSet*)ctx->variable_set, w->e_var);
+            if (w->e_pos_var)
+                xpath_variable_set_remove(
+                    (XPathVariableSet*)ctx->variable_set,
+                    w->e_pos_var);
+            continue;
+        }
+        xpath_variable_set_remove((XPathVariableSet*)ctx->variable_set,
+                                  clauses[i].var);
+        if (clauses[i].pos_var)
+            xpath_variable_set_remove(
+                (XPathVariableSet*)ctx->variable_set,
+                clauses[i].pos_var);
+    }
+}
+
+/* Snapshot the current clause bindings. */
+static int xq_snapshot(XPathContext* ctx, XqClause* clauses, size_t n,
+                       XqTuple* t) {
+    /* var + optional pos var per clause; windows carry up to 5 */
+    t->names = (char**)calloc(6 * n + 1, sizeof(char*));
+    t->contents = (char***)calloc(6 * n + 1, sizeof(char**));
+    t->nodes = (void***)calloc(6 * n + 1, sizeof(void**));
+    t->counts = (size_t*)calloc(6 * n + 1, sizeof(size_t));
+    t->n = 0;
+    t->keys = NULL;
+    t->nkeys = 0;
+    if (!t->names || !t->contents || !t->nodes || !t->counts)
+        return 0;
+    for (size_t i = 0; i < n; i++) {
+        if (clauses[i].is_for == 2) {
+            /* window: $w is the whole member list; the boundary
+             * vars are single members. */
+            XqWindow* w = &clauses[i].win;
+            const char* singles[4];
+            singles[0] = w->s_var;
+            singles[1] = w->s_pos_var;
+            singles[2] = w->e_var;
+            singles[3] = w->e_pos_var;
+            if (w->win_var) {
+                XPathVariable* var = xpath_variable_set_get(
+                    (XPathVariableSet*)ctx->variable_set, w->win_var);
+                if (var && var->value.v.nodeset_value) {
+                    XPathNodeSet* ns = var->value.v.nodeset_value;
+                    t->names[t->n] = strdup(w->win_var);
+                    t->contents[t->n] = (char**)calloc(
+                        ns->count ? ns->count : 1, sizeof(char*));
+                    t->nodes[t->n] = (void**)calloc(
+                        ns->count ? ns->count : 1, sizeof(void*));
+                    t->counts[t->n] = ns->count;
+                    if (!t->contents[t->n] || !t->nodes[t->n])
+                        return 0;
+                    for (size_t m = 0; m < ns->count; m++) {
+                        void* node = ns->nodes[m];
+                        if (node &&
+                            XPATH_NODE_TYPE(node) != LEPTRIS_NODE_TEXT) {
+                            t->nodes[t->n][m] = node;
+                            t->contents[t->n][m] = NULL;
+                        } else if (node) {
+                            const char* c =
+                                ((XPathTextNode*)node)->content;
+                            t->contents[t->n][m] = strdup(c ? c : "");
+                            t->nodes[t->n][m] = NULL;
+                        }
+                    }
+                    t->n++;
+                }
+            }
+            for (int k = 0; k < 4; k++) {
+                if (!singles[k]) continue;
+                XPathVariable* var = xpath_variable_set_get(
+                    (XPathVariableSet*)ctx->variable_set, singles[k]);
+                if (!var) continue;
+                XPathNodeSet* ns = var->value.v.nodeset_value;
+                void* node = (ns && ns->count) ? ns->nodes[0] : NULL;
+                t->names[t->n] = strdup(singles[k]);
+                t->contents[t->n] = (char**)calloc(1, sizeof(char*));
+                t->nodes[t->n] = (void**)calloc(1, sizeof(void*));
+                t->counts[t->n] = 1;
+                if (!t->contents[t->n] || !t->nodes[t->n]) return 0;
+                if (node &&
+                    XPATH_NODE_TYPE(node) != LEPTRIS_NODE_TEXT) {
+                    t->nodes[t->n][0] = node;
+                    t->contents[t->n][0] = NULL;
+                } else if (node) {
+                    const char* c = ((XPathTextNode*)node)->content;
+                    t->contents[t->n][0] = strdup(c ? c : "");
+                    t->nodes[t->n][0] = NULL;
+                }
+                t->n++;
+            }
+            continue;
+        }
+        const char* names[2];
+        names[0] = clauses[i].var;
+        names[1] = clauses[i].pos_var;
+        for (int k = 0; k < 2; k++) {
+            if (!names[k]) continue;
+            if (t->n >= 6 * n) break;
+            XPathVariable* var = xpath_variable_set_get(
+                (XPathVariableSet*)ctx->variable_set, names[k]);
+            if (!var) continue;
+            XPathNodeSet* ns = var->value.v.nodeset_value;
+            if (clauses[i].is_for == 0 && k == 0 && ns && ns->count) {
+                /* LET: the binding is the whole sequence, not the
+                 * first member (group semantics reuse this list
+                 * form). */
+                size_t cnt = ns->count;
+                t->names[t->n] = strdup(names[k]);
+                t->contents[t->n] = (char**)calloc(cnt, sizeof(char*));
+                t->nodes[t->n] = (void**)calloc(cnt, sizeof(void*));
+                t->counts[t->n] = cnt;
+                if (!t->contents[t->n] || !t->nodes[t->n]) return 0;
+                for (size_t m = 0; m < cnt; m++) {
+                    void* nd = ns->nodes[m];
+                    if (nd && XPATH_NODE_TYPE(nd) != LEPTRIS_NODE_TEXT) {
+                        t->nodes[t->n][m] = nd;
+                        t->contents[t->n][m] = NULL;
+                    } else if (nd) {
+                        const char* c = ((XPathTextNode*)nd)->content;
+                        t->contents[t->n][m] = strdup(c ? c : "");
+                        t->nodes[t->n][m] = NULL;
+                    }
+                }
+                t->n++;
+                continue;
+            }
+            void* node = (ns && ns->count) ? ns->nodes[0] : NULL;
+            t->names[t->n] = strdup(names[k]);
+            t->contents[t->n] = (char**)calloc(1, sizeof(char*));
+            t->nodes[t->n] = (void**)calloc(1, sizeof(void*));
+            t->counts[t->n] = 1;
+            if (!t->contents[t->n] || !t->nodes[t->n]) return 0;
+            if (node && XPATH_NODE_TYPE(node) != LEPTRIS_NODE_TEXT) {
+                t->nodes[t->n][0] = node;
+                t->contents[t->n][0] = NULL;
+            } else if (node) {
+                const char* c = ((XPathTextNode*)node)->content;
+                t->contents[t->n][0] = strdup(c ? c : "");
+                t->nodes[t->n][0] = NULL;
+            }
+            t->n++;
+        }
+    }
+    return 1;
+}
+
+/* Rebind a snapshot into the context (member lists join as one
+ * nodeset — group sequences included). */
+static int xq_rebind(XPathContext* ctx, const XqTuple* t) {
+    for (size_t i = 0; i < t->n; i++) {
+        XPathNodeSet* one = xpath_nodeset_new();
+        if (!one) return 0;
+        for (size_t j = 0; j < t->counts[i]; j++) {
+            if (t->nodes[i][j]) {
+                xpath_nodeset_add(one, t->nodes[i][j]);
+            } else if (t->contents[i][j]) {
+                XPathTextNode* tn = xpath_synth_text(
+                    t->contents[i][j], strlen(t->contents[i][j]));
+                if (tn) xpath_nodeset_add(one, tn);
+            }
+        }
+        /* nodeset_free frees only synthetic-text members; document
+         * nodes are skipped by the kind dispatch — safe for mixed
+         * group sequences. */
+        one->owns_synthetic_text = 1;
+        XPathVariable* var = xpath_variable_set_add(
+            (XPathVariableSet*)ctx->variable_set, t->names[i],
+            XPATH_VAR_TYPE_NODE_SET);
+        if (!var) {
+            xpath_nodeset_free(one);
+            return 0;
+        }
+        xpath_variable_set_nodeset(var, one);
+    }
+    return 1;
+}
+
+static void xq_window_bind(XPathContext* ctx, XqWindow* w,
+                           XPathNodeSet* ns, size_t start,
+                           size_t n) {
+    (void)n;
+    if (w->s_var) {
+        XPathNodeSet* one = xpath_nodeset_new();
+        if (one) {
+            xpath_nodeset_add(one, ns->nodes[start]);
+            XPathVariable* var = xpath_variable_set_add(
+                (XPathVariableSet*)ctx->variable_set, w->s_var,
+                XPATH_VAR_TYPE_NODE_SET);
+            if (var) xpath_variable_set_nodeset(var, one);
+            else xpath_nodeset_free(one);
+        }
+    }
+    if (w->s_pos_var) {
+        char nb[24];
+        int nl = snprintf(nb, sizeof(nb), "\x03N%zu", start + 1);
+        XPathNodeSet* pone = xpath_nodeset_new();
+        if (pone) {
+            pone->owns_synthetic_text = 1;
+            XPathTextNode* ptn = xpath_synth_text(nb, (size_t)nl);
+            if (ptn) xpath_nodeset_add(pone, ptn);
+            XPathVariable* var = xpath_variable_set_add(
+                (XPathVariableSet*)ctx->variable_set,
+                w->s_pos_var, XPATH_VAR_TYPE_NODE_SET);
+            if (var) xpath_variable_set_nodeset(var, pone);
+            else xpath_nodeset_free(pone);
+        }
+    }
+}
+
+static void xq_window_unbind(XPathContext* ctx, XqWindow* w) {
+    if (w->s_var)
+        xpath_variable_set_remove(
+            (XPathVariableSet*)ctx->variable_set, w->s_var);
+    if (w->s_pos_var)
+        xpath_variable_set_remove(
+            (XPathVariableSet*)ctx->variable_set, w->s_pos_var);
+    if (w->e_var)
+        xpath_variable_set_remove(
+            (XPathVariableSet*)ctx->variable_set, w->e_var);
+    if (w->e_pos_var)
+        xpath_variable_set_remove(
+            (XPathVariableSet*)ctx->variable_set, w->e_pos_var);
+}
+
+static int key_cmp(const char* a, const char* b) {
+    char *ea = NULL, *eb = NULL;
+    double va = strtod(a, &ea);
+    double vb = strtod(b, &eb);
+    int na = ea && *ea == '\0' && ea != a;
+    int nb = eb && *eb == '\0' && eb != b;
+    if (na && nb) return (va < vb) ? -1 : (va > vb) ? 1 : 0;
+    return strcmp(a, b);
+}
+
+/* Enumerate tuples (phase 1): recursive clause walker. */
+static int xq_enumerate(struct LeptrisXQueryInternal* q, XPathContext* ctx,
+                        size_t idx, XqTuple** out, size_t* out_n,
+                        size_t* out_cap) {
+    if (idx == q->nclauses) {
+        if (q->where_ast) {
+            struct leptris_xpath_result* w =
+                evaluate_expr(ctx, q->where_ast);
+            int truth = w ? xpath_to_boolean(w) : 0;
+            if (w) xpath_result_free(w);
+            if (!truth) return 1;   /* filtered out, not an error */
+        }
+        if (*out_n == *out_cap) {
+            *out_cap = *out_cap ? *out_cap * 2 : 8;
+            *out = (XqTuple*)realloc(*out, *out_cap * sizeof(XqTuple));
+            if (!*out) return 0;
+        }
+        XqTuple* t = &(*out)[(*out_n)++];
+        memset(t, 0, sizeof(*t));
+        if (!xq_snapshot(ctx, q->clauses, q->nclauses, t)) return 0;
+        /* Order keys are evaluated at the EVAL phase — after
+         * group by, they see the grouped bindings (Saxon). */
+        return 1;
+    }
+
+    XqClause* c = &q->clauses[idx];
+    if (c->is_for == 2) {
+        /* Window clause (TODO 12): enumerate windows, each binding
+         * $w to the member list and the boundary vars. */
+        XqWindow* w = &c->win;
+        struct leptris_xpath_result* domain =
+            evaluate_expr(ctx, w->domain);
+        if (!domain) return 0;
+        int ok = 1;
+        if (domain->type != XPATH_RESULT_NODESET ||
+            !domain->value.nodeset_value) {
+            xpath_result_free(domain);
+            return 1;   /* empty/atomic domain: no windows */
+        }
+        XPathNodeSet* ns = domain->value.nodeset_value;
+        size_t n = ns->count;
+        size_t start = 0;
+        while (start < n && ok) {
+            /* start condition */
+            int starts = 1;
+            if (w->s_when) {
+                xq_window_unbind(ctx, w);
+                xq_window_bind(ctx, w, ns, start, n);
+                struct leptris_xpath_result* r =
+                    evaluate_expr(ctx, w->s_when);
+                starts = r ? xpath_to_boolean(r) : 0;
+                if (r) xpath_result_free(r);
+            }
+            if (!starts) {
+                start++;
+                continue;
+            }
+            /* end: first position >= start whose condition holds
+             * (default: the last item). */
+            size_t end = n - 1;
+            if (w->e_when) {
+                end = 0;
+                for (size_t p = start + 1; p < n; p++) {
+                    xq_window_unbind(ctx, w);
+                    xq_window_bind(ctx, w, ns, start, n);
+                    /* candidate end at p */
+                    if (w->e_var) {
+                        XPathNodeSet* one = xpath_nodeset_new();
+                        if (one) {
+                            xpath_nodeset_add(one, ns->nodes[p]);
+                            XPathVariable* var = xpath_variable_set_add(
+                                (XPathVariableSet*)ctx->variable_set,
+                                w->e_var, XPATH_VAR_TYPE_NODE_SET);
+                            if (var)
+                                xpath_variable_set_nodeset(var, one);
+                            else
+                                xpath_nodeset_free(one);
+                        }
+                    }
+                    if (w->e_pos_var) {
+                        char nb[24];
+                        int nl2 = snprintf(nb, sizeof(nb),
+                                           "\x03N%zu", p + 1);
+                        XPathNodeSet* pone = xpath_nodeset_new();
+                        if (pone) {
+                            pone->owns_synthetic_text = 1;
+                            XPathTextNode* ptn =
+                                xpath_synth_text(nb, (size_t)nl2);
+                            if (ptn) xpath_nodeset_add(pone, ptn);
+                            XPathVariable* var =
+                                xpath_variable_set_add(
+                                    (XPathVariableSet*)
+                                        ctx->variable_set,
+                                    w->e_pos_var,
+                                    XPATH_VAR_TYPE_NODE_SET);
+                            if (var)
+                                xpath_variable_set_nodeset(var, pone);
+                            else
+                                xpath_nodeset_free(pone);
+                        }
+                    }
+                    struct leptris_xpath_result* r =
+                        evaluate_expr(ctx, w->e_when);
+                    int ends = r ? xpath_to_boolean(r) : 0;
+                    if (r) xpath_result_free(r);
+                    if (ends) {
+                        end = p;
+                        break;
+                    }
+                }
+                if (end == 0 && start + 1 <= n - 1 && n > 0) {
+                    /* no end matched: window runs to the end */
+                    end = n - 1;
+                } else if (end == 0) {
+                    end = n - 1;
+                }
+            }
+            /* bind the window vars and recurse */
+            xq_window_unbind(ctx, w);
+            {
+                /* $w = member list */
+                XPathNodeSet* all = xpath_nodeset_new();
+                if (!all) { ok = 0; break; }
+                for (size_t k = start; k <= end; k++)
+                    xpath_nodeset_add(all, ns->nodes[k]);
+                /* members are BORROWED from the domain nodeset —
+                 * claiming ownership would free them on unbind
+                 * while the domain still uses them. */
+                all->owns_synthetic_text = 0;
+                XPathVariable* var = xpath_variable_set_add(
+                    (XPathVariableSet*)ctx->variable_set,
+                    w->win_var, XPATH_VAR_TYPE_NODE_SET);
+                if (var) xpath_variable_set_nodeset(var, all);
+                else { xpath_nodeset_free(all); ok = 0; break; }
+            }
+            xq_window_bind(ctx, w, ns, start, n);
+            if (w->e_var || w->e_pos_var) {
+                if (w->e_var) {
+                    XPathNodeSet* one = xpath_nodeset_new();
+                    if (one) {
+                        xpath_nodeset_add(one, ns->nodes[end]);
+                        XPathVariable* var = xpath_variable_set_add(
+                            (XPathVariableSet*)ctx->variable_set,
+                            w->e_var, XPATH_VAR_TYPE_NODE_SET);
+                        if (var)
+                            xpath_variable_set_nodeset(var, one);
+                        else xpath_nodeset_free(one);
+                    }
+                }
+                if (w->e_pos_var) {
+                    char nb[24];
+                    int nl3 = snprintf(nb, sizeof(nb),
+                                       "\x03N%zu", end + 1);
+                    XPathNodeSet* pone = xpath_nodeset_new();
+                    if (pone) {
+                        pone->owns_synthetic_text = 1;
+                        XPathTextNode* ptn =
+                            xpath_synth_text(nb, (size_t)nl3);
+                        if (ptn) xpath_nodeset_add(pone, ptn);
+                        XPathVariable* var = xpath_variable_set_add(
+                            (XPathVariableSet*)ctx->variable_set,
+                            w->e_pos_var,
+                            XPATH_VAR_TYPE_NODE_SET);
+                        if (var)
+                            xpath_variable_set_nodeset(var, pone);
+                        else xpath_nodeset_free(pone);
+                    }
+                }
+            }
+            ok = xq_enumerate(q, ctx, idx + 1, out, out_n, out_cap);
+            xq_window_unbind(ctx, w);
+            xpath_variable_set_remove(
+                (XPathVariableSet*)ctx->variable_set, w->win_var);
+            if (!w->sliding)
+                start = end + 1;   /* tumbling: next after the end */
+            else
+                start++;
+        }
+        xpath_result_free(domain);
+        return ok;
+    }
+    if (!c->is_for) {
+        /* LET: evaluated per enclosing-FOR tuple — later clause
+         * domains may reference it. */
+        struct leptris_xpath_result* v = evaluate_expr(ctx, c->expr);
+        if (!v) return 0;
+        int ok = xq_bind(ctx, c->var, v);
+        xpath_result_free(v);
+        if (!ok) return 0;
+        int r = xq_enumerate(q, ctx, idx + 1, out, out_n, out_cap);
+        xpath_variable_set_remove((XPathVariableSet*)ctx->variable_set,
+                                  c->var);
+        return r;
+    }
+
+    struct leptris_xpath_result* domain = evaluate_expr(ctx, c->expr);
+    if (!domain) return 0;
+    int ok = 1;
+    if (domain->type == XPATH_RESULT_NODESET &&
+        domain->value.nodeset_value) {
+        XPathNodeSet* ns = domain->value.nodeset_value;
+        for (size_t i = 0; i < ns->count && ok; i++) {
+            XPathNodeSet* one = xpath_nodeset_new();
+            if (!one) {
+                ok = 0;
+                break;
+            }
+            xpath_nodeset_add(one, ns->nodes[i]);
+            XPathVariable* var = xpath_variable_set_add(
+                (XPathVariableSet*)ctx->variable_set, c->var,
+                XPATH_VAR_TYPE_NODE_SET);
+            if (!var) {
+                xpath_nodeset_free(one);
+                ok = 0;
+                break;
+            }
+            xpath_variable_set_nodeset(var, one);
+            /* positional `at $i` — 1-based, numeric-marker member */
+            if (c->pos_var) {
+                char nb[24];
+                int nl = snprintf(nb, sizeof(nb), "\x03N%zu", i + 1);
+                XPathNodeSet* pone = xpath_nodeset_new();
+                if (pone) {
+                    pone->owns_synthetic_text = 1;
+                    XPathTextNode* ptn = xpath_synth_text(nb, (size_t)nl);
+                    if (ptn) xpath_nodeset_add(pone, ptn);
+                    XPathVariable* pvar = xpath_variable_set_add(
+                        (XPathVariableSet*)ctx->variable_set,
+                        c->pos_var, XPATH_VAR_TYPE_NODE_SET);
+                    if (pvar) xpath_variable_set_nodeset(pvar, pone);
+                    else xpath_nodeset_free(pone);
+                }
+            }
+            ok = xq_enumerate(q, ctx, idx + 1, out, out_n, out_cap);
+            if (c->pos_var)
+                xpath_variable_set_remove(
+                    (XPathVariableSet*)ctx->variable_set, c->pos_var);
+            xpath_variable_set_remove(
+                (XPathVariableSet*)ctx->variable_set, c->var);
+        }
+    } else {
+        ok = xq_bind(ctx, c->var, domain) &&
+             xq_enumerate(q, ctx, idx + 1, out, out_n, out_cap);
+        xpath_variable_set_remove((XPathVariableSet*)ctx->variable_set,
+                                  c->var);
+    }
+    xpath_result_free(domain);
+    return ok;
+}
+
+/* A param select evaluates in its own context over the document
+ * (QT3: external-variable values are computed independently of
+ * the query's own bindings). */
+static struct leptris_xpath_result* xq_eval_param(
+    struct leptris_document* doc, LeptrisElement root, const char* sel) {
+    XPathASTNode* ast = parse_expr_span(sel, sel + strlen(sel));
+    if (!ast) return NULL;
+    XPathContext pc;
+    xpath_context_init(&pc, doc, root);
+    struct leptris_xpath_result* v = evaluate_expr(&pc, ast);
+    ast_node_free(ast);
+    xpath_context_cleanup(&pc);
+    return v;
+}
+
+static LeptrisXPathResult xq_eval_impl(
+    LeptrisXQuery query, LeptrisDocument doc, LeptrisElement context_node,
+    const char* const* param_names, const char* const* param_selects,
+    size_t nparams) {
+    struct LeptrisXQueryInternal* q = (struct LeptrisXQueryInternal*)query;
+    if (!q || !doc) return NULL;
+
+    LeptrisElement ctx_elem =
+        context_node ? context_node : leptris_document_root(doc);
+    if (!ctx_elem) return NULL;
+
+    XPathContext ctx_storage;
+    XPathContext* ctx = &ctx_storage;
+    xpath_context_init(ctx, (struct leptris_document*)doc, ctx_elem);
+
+    /* local: functions: merged registry over the standard library.
+     * Closure contents live for the eval; the registry itself is
+     * freed by context cleanup. */
+    char** fn_contents = NULL;
+    size_t n_fn_contents = 0;
+    int has_fn = 0;
+    for (size_t i = 0; i < q->ndecls; i++)
+        if (q->decls[i].kind == XQ_DECL_FN) {
+            has_fn = 1;
+            break;
+        }
+    if (has_fn) {
+        XPathFunctionRegistry* reg = xpath_function_registry_new();
+        if (reg) {
+            xpath_function_registry_init_standard(reg);
+            fn_contents = (char**)calloc(q->ndecls, sizeof(char*));
+            for (size_t i = 0; i < q->ndecls; i++) {
+                XqDecl* d = &q->decls[i];
+                if (d->kind != XQ_DECL_FN) continue;
+                size_t plen = d->params ? strlen(d->params) : 0;
+                char* cc = (char*)malloc(plen + 24);
+                if (!cc) continue;
+                memcpy(cc, "\x03" "FN\x02", 4);
+                size_t len = 4;
+                if (plen) {
+                    memcpy(cc + len, d->params, plen);
+                    len += plen;
+                }
+                cc[len++] = '\x02';
+                len += (size_t)snprintf(cc + len, 17, "%016llx",
+                                        (unsigned long long)(uintptr_t)d->ast);
+                fn_contents[n_fn_contents++] = cc;
+                xpath_function_registry_register(reg, d->name,
+                                                 xq_fn_thunk,
+                                                 (int)d->arity,
+                                                 (int)d->arity);
+                if (reg->count > 0)
+                    reg->functions[reg->count - 1].user_data = cc;
+            }
+            ctx->function_registry = reg;
+        }
+    }
+
+    /* xpath_context_cleanup treats variable_set as caller-borrowed
+     * — the scratch set is ours to free (with every binding still
+     * in it; set_free releases the owned nodesets). */
+    XPathVariableSet* scratch_vs = NULL;
+    if (!ctx->variable_set) {
+        scratch_vs = xpath_variable_set_new();
+        if (!scratch_vs) {
+            xpath_context_cleanup(ctx);
+            return NULL;
+        }
+        ctx->variable_set = scratch_vs;
+    }
+
+    /* Prolog in order: namespaces, then variables/functions as
+     * declared (each sees the earlier ones). */
+    int err = 0;
+    for (size_t i = 0; i < q->ndecls && !err; i++) {
+        XqDecl* d = &q->decls[i];
+        if (d->kind == XQ_DECL_NS) {
+            if (ctx->namespace_count == ctx->namespace_capacity) {
+                ctx->namespace_capacity =
+                    ctx->namespace_capacity ? ctx->namespace_capacity * 2 : 8;
+                ctx->namespace_mappings = (XPathNamespaceMapping*)realloc(
+                    ctx->namespace_mappings,
+                    ctx->namespace_capacity * sizeof(XPathNamespaceMapping));
+            }
+            if (!ctx->namespace_mappings) {
+                err = 1;
+                break;
+            }
+            /* cleanup frees these with LEPTRIS_FREE — allocate
+             * through the matching channel. */
+            {
+                size_t pn = strlen(d->name), un = strlen(d->uri);
+                char* pfx = (char*)LEPTRIS_ALLOC_N(char, pn + 1);
+                char* uri = (char*)LEPTRIS_ALLOC_N(char, un + 1);
+                if (pfx) { memcpy(pfx, d->name, pn); pfx[pn] = 0; }
+                if (uri) { memcpy(uri, d->uri, un); uri[un] = 0; }
+                ctx->namespace_mappings[ctx->namespace_count].prefix = pfx;
+                ctx->namespace_mappings[ctx->namespace_count].uri = uri;
+            }
+            ctx->namespace_count++;
+            ctx->namespaces_collected = 1;   /* keep ours */
+        } else if (d->kind == XQ_DECL_VAR) {
+            struct leptris_xpath_result* v = NULL;
+            if (d->external) {
+                size_t pi = nparams;
+                for (size_t i = 0; i < nparams; i++) {
+                    if (param_names[i] &&
+                        strcmp(param_names[i], d->name) == 0) {
+                        pi = i;
+                        break;
+                    }
+                }
+                if (pi < nparams) {
+                    v = xq_eval_param((struct leptris_document*)doc,
+                                      ctx_elem, param_selects[pi]);
+                } else if (d->ast) {
+                    v = evaluate_expr(ctx, d->ast);
+                } else {
+                    snprintf(ctx->error_msg, sizeof(ctx->error_msg),
+                            "unbound external variable $%s", d->name);
+                }
+            } else {
+                v = evaluate_expr(ctx, d->ast);
+            }
+            if (!v) {
+                err = 1;
+                break;
+            }
+            int ok = xq_bind(ctx, d->name, v);
+            xpath_result_free(v);
+            if (!ok) {
+                err = 1;
+                break;
+            }
+        }
+    }
+
+    struct leptris_xpath_result* result = NULL;
+    if (!err) {
+        if (q->nclauses == 0) {
+            result = evaluate_expr(ctx, q->return_ast);
+        } else {
+            /* Phase 1: tuples. */
+            XqTuple* tuples = NULL;
+            size_t n_tuples = 0, cap = 0;
+            if (!xq_enumerate(q, ctx, 0, &tuples, &n_tuples, &cap)) {
+                err = 1;
+            } else if (q->group_var) {
+                /* group by (12): partition on the key value in
+                 * first-appearance order; every clause var is
+                 * rebound to the group's member list, and the
+                 * group var carries the key. */
+                char** gkeys = NULL;
+                size_t** gmembers = NULL;   /* per group: tuple indices */
+                size_t* gcounts = NULL;
+                size_t n_groups = 0;
+                XqTuple* grouped = NULL;
+                size_t n_grouped = 0;
+                int gerr = 0;
+                gkeys = (char**)calloc(n_tuples ? n_tuples : 1,
+                                       sizeof(char*));
+                gmembers = (size_t**)calloc(n_tuples ? n_tuples : 1,
+                                            sizeof(size_t*));
+                gcounts = (size_t*)calloc(n_tuples ? n_tuples : 1,
+                                          sizeof(size_t));
+                grouped = (XqTuple*)calloc(n_tuples ? n_tuples : 1,
+                                           sizeof(XqTuple));
+                if (!gkeys || !gmembers || !gcounts || !grouped)
+                    gerr = 1;
+                for (size_t ti = 0; ti < n_tuples && !gerr; ti++) {
+                    xq_unbind_all(ctx, q->clauses, q->nclauses);
+                    if (!xq_rebind(ctx, &tuples[ti])) {
+                        gerr = 1;
+                        break;
+                    }
+                    struct leptris_xpath_result* kr =
+                        evaluate_expr(ctx, q->group_key);
+                    char* key = kr ? xpath_to_string(kr) : NULL;
+                    if (kr) xpath_result_free(kr);
+                    if (!key) key = strdup("");
+                    size_t g = n_groups;
+                    for (size_t x = 0; x < n_groups; x++) {
+                        if (strcmp(gkeys[x], key) == 0) {
+                            g = x;
+                            break;
+                        }
+                    }
+                    if (g == n_groups) {
+                        gkeys[g] = key;
+                        gcounts[g] = 0;
+                        gmembers[g] = (size_t*)calloc(
+                            n_tuples, sizeof(size_t));
+                        if (!gmembers[g]) {
+                            gerr = 1;
+                            free(key);
+                            break;
+                        }
+                        n_groups++;
+                    } else {
+                        free(key);
+                    }
+                    gmembers[g][gcounts[g]++] = ti;
+                }
+                for (size_t g = 0; g < n_groups && !gerr; g++) {
+                    /* Build the group tuple from the first member's
+                     * shape, aggregating every member's values. */
+                    XqTuple* first = &tuples[gmembers[g][0]];
+                    XqTuple* gt = &grouped[n_grouped];
+                    memset(gt, 0, sizeof(*gt));
+                    gt->names = (char**)calloc(first->n + 1,
+                                               sizeof(char*));
+                    gt->contents = (char***)calloc(
+                        first->n + 1, sizeof(char**));
+                    gt->nodes = (void***)calloc(first->n + 1,
+                                                sizeof(void**));
+                    gt->counts = (size_t*)calloc(first->n + 1,
+                                                 sizeof(size_t));
+                    if (!gt->names || !gt->contents || !gt->nodes ||
+                        !gt->counts) {
+                        gerr = 1;
+                        break;
+                    }
+                    gt->n = 0;
+                    for (size_t v = 0; v < first->n; v++) {
+                        gt->names[gt->n] = strdup(first->names[v]);
+                        size_t total = 0;
+                        for (size_t m = 0; m < gcounts[g]; m++)
+                            total += tuples[gmembers[g][m]].counts[v];
+                        gt->contents[gt->n] = (char**)calloc(
+                            total ? total : 1, sizeof(char*));
+                        gt->nodes[gt->n] = (void**)calloc(
+                            total ? total : 1, sizeof(void*));
+                        if (!gt->contents[gt->n] || !gt->nodes[gt->n]) {
+                            gerr = 1;
+                            break;
+                        }
+                        size_t w = 0;
+                        for (size_t m = 0; m < gcounts[g]; m++) {
+                            XqTuple* mt = &tuples[gmembers[g][m]];
+                            for (size_t j = 0; j < mt->counts[v];
+                                 j++) {
+                                if (mt->nodes[v][j]) {
+                                    gt->nodes[gt->n][w] =
+                                        mt->nodes[v][j];
+                                } else {
+                                    gt->contents[gt->n][w] = strdup(
+                                        mt->contents[v][j]);
+                                }
+                                w++;
+                            }
+                        }
+                        gt->counts[gt->n] = total;
+                        gt->n++;
+                    }
+                    if (gerr) break;
+                    /* the group variable carries the key */
+                    gt->names[gt->n] = strdup(q->group_var);
+                    gt->contents[gt->n] = (char**)calloc(
+                        1, sizeof(char*));
+                    gt->nodes[gt->n] = (void**)calloc(1, sizeof(void*));
+                    if (!gt->names[gt->n] || !gt->contents[gt->n] ||
+                        !gt->nodes[gt->n]) {
+                        gerr = 1;
+                        break;
+                    }
+                    gt->contents[gt->n][0] = strdup(gkeys[g]);
+                    gt->counts[gt->n] = 1;
+                    gt->n++;
+                    n_grouped++;
+                }
+                for (size_t g = 0; g < n_groups; g++) {
+                    free(gkeys[g]);
+                    free(gmembers[g]);
+                }
+                free(gkeys);
+                free(gmembers);
+                free(gcounts);
+                for (size_t ti = 0; ti < n_tuples; ti++)
+                    xq_tuple_free(&tuples[ti]);
+                free(tuples);
+                if (gerr) {
+                    for (size_t gi = 0; gi < n_grouped; gi++)
+                        xq_tuple_free(&grouped[gi]);
+                    free(grouped);
+                    err = 1;
+                } else {
+                    tuples = grouped;
+                    n_tuples = n_grouped;
+                }
+            }
+            if (!err) {
+                /* Order keys: evaluated against the (possibly
+                 * grouped) bindings. */
+                for (size_t ti = 0; ti < n_tuples && !err; ti++) {
+                    xq_unbind_all(ctx, q->clauses, q->nclauses);
+                    if (q->group_var)
+                        xpath_variable_set_remove(
+                            (XPathVariableSet*)ctx->variable_set,
+                            q->group_var);
+                    if (!xq_rebind(ctx, &tuples[ti])) {
+                        err = 1;
+                        break;
+                    }
+                    if (q->nkeys) {
+                        tuples[ti].keys = (char**)calloc(
+                            q->nkeys, sizeof(char*));
+                        if (!tuples[ti].keys) {
+                            err = 1;
+                            break;
+                        }
+                        tuples[ti].nkeys = q->nkeys;
+                        for (size_t k = 0; k < q->nkeys; k++) {
+                            struct leptris_xpath_result* r =
+                                evaluate_expr(ctx, q->keys[k].key);
+                            char* ks = r ? xpath_to_string(r) : NULL;
+                            xpath_result_free(r);
+                            tuples[ti].keys[k] = ks ? ks : strdup("");
+                        }
+                    }
+                }
+            }
+            if (!err) {
+                /* Stable order-by: insertion sort over key lists. */
+                for (size_t i = 1; i < n_tuples; i++) {
+                    XqTuple tmp = tuples[i];
+                    size_t j = i;
+                    while (j > 0) {
+                        int cmp = 0;
+                        for (size_t k = 0; k < q->nkeys && !cmp; k++) {
+                            int c = key_cmp(tuples[j - 1].keys[k],
+                                            tmp.keys[k]);
+                            cmp = q->keys[k].descending ? -c : c;
+                        }
+                        if (cmp > 0) {
+                            tuples[j] = tuples[j - 1];
+                            j--;
+                        } else {
+                            break;
+                        }
+                    }
+                    tuples[j] = tmp;
+                }
+
+                /* Phase 2: rebind in output order, evaluate return. */
+                XPathNodeSet* out = xpath_nodeset_new();
+                result = xpath_result_new(XPATH_RESULT_NODESET);
+                if (!out || !result) {
+                    xpath_nodeset_free(out);
+                    if (result) {
+                        xpath_result_free(result);
+                        result = NULL;
+                    }
+                    err = 1;
+                } else {
+                    out->owns_synthetic_text = 1;
+                    out->is_sequence = 1;
+                    int adopted = 0;
+                    for (size_t ti = 0; ti < n_tuples; ti++) {
+                        /* xpath_variable_set_nodeset overwrites
+                         * without freeing — clear the key-loop
+                         * bindings before rebinding. */
+                        xq_unbind_all(ctx, q->clauses, q->nclauses);
+                        if (q->group_var)
+                            xpath_variable_set_remove(
+                                (XPathVariableSet*)ctx->variable_set,
+                                q->group_var);
+                        xq_rebind(ctx, &tuples[ti]);
+                        struct leptris_xpath_result* r =
+                            evaluate_expr(ctx, q->return_ast);
+                        if (r) {
+                            /* A single tuple's atomic return IS
+                             * the value: a false boolean must stay
+                             * falsy at the boundary (a one-member
+                             * text nodeset reads true). */
+                            if (!adopted && n_tuples == 1 &&
+                                r->type != XPATH_RESULT_NODESET) {
+                                xpath_result_free(result);
+                                result = r;
+                                adopted = 1;
+                            } else {
+                                char* s = xpath_to_string(r);
+                                XPathTextNode* tn = xpath_synth_text(
+                                    s ? s : "", s ? strlen(s) : 0);
+                                free(s);
+                                if (tn) xpath_nodeset_add(out, tn);
+                                xpath_result_free(r);
+                            }
+                        }
+                        xq_unbind_all(ctx, q->clauses, q->nclauses);
+                    }
+                    if (adopted)
+                        xpath_nodeset_free(out);
+                    else
+                        result->value.nodeset_value = out;
+                }
+            }
+            for (size_t ti = 0; ti < n_tuples; ti++)
+                xq_tuple_free(&tuples[ti]);
+            free(tuples);
+        }
+    }
+
+    for (size_t i = 0; i < n_fn_contents; i++) free(fn_contents[i]);
+    free(fn_contents);
+    if (scratch_vs) {
+        ctx->variable_set = NULL;
+        xpath_variable_set_free(scratch_vs);
+    }
+    xpath_context_cleanup(ctx);
+    return result;
+}
+
+/* ---- direct element constructors (TODO 11 slice B) ----
+ *
+ * Translated to the computed form before the XPath parser sees a
+ * span: <n a="{E}">{C}</n> becomes
+ * element n { attribute a { ...AVT... }, text { "..." }, (C) }.
+ * Purely textual — balanced-tag scans that respect quotes. */
+
+static void buf_put(Buf* b, const char* s, size_t n) {
+    if (b->len + n + 1 > b->cap) {
+        b->cap = b->cap ? b->cap * 2 : 64;
+        while (b->len + n + 1 > b->cap) b->cap *= 2;
+        b->s = (char*)realloc(b->s, b->cap);
+    }
+    if (!b->s) return;
+    memcpy(b->s + b->len, s, n);
+    b->len += n;
+    b->s[b->len] = 0;
+}
+
+static void buf_str(Buf* b, const char* s) {
+    buf_put(b, s, strlen(s));
+}
+
+/* Emit a text run as an XPath string literal (choosing the quote
+ * character that does not occur in the run; both occurring is
+ * split across a concat). */
+static void buf_lit(Buf* b, const char* s, size_t n) {
+    int sq = 0, dq = 0;
+    for (size_t i = 0; i < n; i++) {
+        if (s[i] == '\'') sq = 1;
+        else if (s[i] == '"') dq = 1;
+    }
+    if (!sq) {
+        buf_put(b, "'", 1);
+        buf_put(b, s, n);
+        buf_put(b, "'", 1);
+    } else if (!dq) {
+        buf_put(b, "\"", 1);
+        buf_put(b, s, n);
+        buf_put(b, "\"", 1);
+    } else {
+        buf_str(b, "concat(");
+        for (size_t i = 0; i < n; i++) {
+            if (i) buf_str(b, ", ");
+            buf_put(b, s[i] == '\'' ? "\"" : "'", 1);
+            buf_put(b, s + i, 1);
+            buf_put(b, s[i] == '\'' ? "\"" : "'", 1);
+        }
+        buf_str(b, ")");
+    }
+}
+
+static int xq_is_name_start(char c) {
+    return isalpha((unsigned char)c) || c == '_' || c == ':';
+}
+static int xq_is_name_char(char c) {
+    return isalnum((unsigned char)c) || c == '_' || c == '-' ||
+           c == '.' || c == ':';
+}
+
+/* Emit an attribute value template: pre{E}post —> concat pieces. */
+static void buf_avt(Buf* b, const char* s, size_t n) {
+    int any = 0;
+    int n_pieces = 0;
+    Buf pieces = {0};
+    size_t i = 0, lit = 0;
+    while (i < n) {
+        if (s[i] == '{') {
+            if (i > lit) { buf_str(&pieces, any ? ", " : ""); buf_lit(&pieces, s + lit, i - lit); any = 1; }
+            size_t j = i + 1;
+            int depth = 1;
+            while (j < n && depth) {
+                if (s[j] == '{') depth++;
+                else if (s[j] == '}') depth--;
+                else if (s[j] == '\'' || s[j] == '"') {
+                    char q = s[j++];
+                    while (j < n && s[j] != q) j++;
+                }
+                if (depth) j++;
+            }
+            buf_str(&pieces, any ? ", " : "");
+            buf_put(&pieces, "(", 1);
+            buf_put(&pieces, s + i + 1, j > i + 1 ? j - (i + 1) : 0);
+            buf_put(&pieces, ")", 1);
+            any = 1;
+            n_pieces++;
+            i = j + 1;
+            lit = i;
+        } else i++;
+    }
+    if (lit < n) { buf_str(&pieces, any ? ", " : ""); buf_lit(&pieces, s + lit, n - lit); any = 1; n_pieces++; }
+    if (!any) buf_str(b, "''");
+    else if (n_pieces == 1) {
+        buf_put(b, pieces.s, pieces.len);
+    } else {
+        /* concat needs >= 2 args (arity 2..n) */
+        buf_str(b, "concat(");
+        buf_put(b, pieces.s, pieces.len);
+        buf_str(b, ", '')");
+    }
+    free(pieces.s);
+}
+
+static const char* xq_translate_element(const char* p, const char* e,
+                                        Buf* out);
+
+static void xq_translate_content(const char* s, const char* e, Buf* out);
+
+static const char* xq_translate_element(const char* p, const char* e,
+                                        Buf* out) {
+    /* p at '<', tag name follows. */
+    const char* tag = p + 1;
+    const char* q = tag;
+    while (q < e && xq_is_name_char(*q)) q++;
+    size_t tnlen = (size_t)(q - tag);
+    if (!tnlen) { buf_put(out, p, 1); return p + 1; }
+    const char* gt = q;
+    while (gt < e && *gt != '>') {
+        if (*gt == '"' || *gt == '\'') {
+            char qc = *gt++;
+            while (gt < e && *gt != qc) gt++;
+        }
+        if (gt < e && *gt != '>') gt++;
+    }
+    if (gt >= e) { buf_put(out, p, (size_t)(e - p)); return e; }
+    int self_closing = gt[-1] == '/';
+    const char* attr_end = self_closing ? gt - 1 : gt;
+
+    Buf ab = {0};
+    const char* ap = q;
+    while (ap < attr_end) {
+        while (ap < attr_end && isspace((unsigned char)*ap)) ap++;
+        if (ap >= attr_end) break;
+        const char* an = ap;
+        while (ap < attr_end && xq_is_name_char(*ap)) ap++;
+        size_t anlen = (size_t)(ap - an);
+        while (ap < attr_end && isspace((unsigned char)*ap)) ap++;
+        if (ap >= attr_end || *ap != '=' || anlen == 0) continue;
+        ap++;
+        while (ap < attr_end && isspace((unsigned char)*ap)) ap++;
+        if (ap >= attr_end || (*ap != '"' && *ap != '\'')) continue;
+        char qc = *ap++;
+        const char* av = ap;
+        while (ap < attr_end && *ap != qc) ap++;
+        if (ab.len) buf_str(&ab, ", ");
+        buf_str(&ab, "attribute ");
+        buf_put(&ab, an, anlen);
+        buf_str(&ab, " { ");
+        buf_avt(&ab, av, (size_t)(ap - av));
+        buf_str(&ab, " }");
+        ap++;
+    }
+
+    Buf cb = {0};
+    const char* end;
+    if (self_closing) {
+        end = gt + 1;
+    } else {
+        const char* body = gt + 1;
+        const char* close = body;
+        int depth = 1;
+        while (close < e) {
+            if (*close == '<') {
+                if (close + 1 < e && close[1] == '/' &&
+                    (size_t)(e - close) > tnlen + 2 &&
+                    strncmp(close + 2, tag, tnlen) == 0 &&
+                    close[2 + tnlen] == '>') {
+                    depth--;
+                    if (!depth) break;
+                } else if (close + 1 < e && xq_is_name_start(close[1])) {
+                    const char* nq = close + 1;
+                    while (nq < e && xq_is_name_char(*nq)) nq++;
+                    if ((size_t)(nq - close - 1) == tnlen &&
+                        strncmp(close + 1, tag, tnlen) == 0)
+                        depth++;
+                }
+            } else if (*close == '"' || *close == '\'') {
+                char qc = *close++;
+                while (close < e && *close != qc) close++;
+            }
+            close++;
+        }
+        if (close >= e) {
+            buf_put(out, p, (size_t)(e - p));
+            free(ab.s);
+            free(cb.s);
+            return e;
+        }
+        xq_translate_content(body, close, &cb);
+        end = close + 2 + tnlen + 1;   /* past </name> */
+    }
+
+    buf_str(out, "element ");
+    buf_put(out, tag, tnlen);
+    buf_str(out, " { ");
+    if (ab.len) {
+        buf_put(out, ab.s, ab.len);
+        if (cb.len) buf_str(out, ", ");
+    }
+    if (cb.len) buf_put(out, cb.s, cb.len);
+    buf_str(out, " }");
+    free(ab.s);
+    free(cb.s);
+    return end;
+}
+
+/* Whitespace-only text strips in direct constructors (XQuery
+ * default boundary-space handling). */
+static int xq_ws_only(const char* s, size_t n) {
+    for (size_t i = 0; i < n; i++)
+        if (!isspace((unsigned char)s[i])) return 0;
+    return 1;
+}
+
+static void xq_translate_content(const char* s, const char* e, Buf* out) {
+    const char* ts = s, *p = s;
+    while (p < e) {
+        if (*p == '{') {
+            if (p > ts && !xq_ws_only(ts, (size_t)(p - ts))) {
+                if (out->len) buf_str(out, ", ");
+                buf_str(out, "text { ");
+                buf_lit(out, ts, (size_t)(p - ts));
+                buf_str(out, " }");
+            }
+            const char* j = p + 1;
+            int depth = 1;
+            while (j < e && depth) {
+                if (*j == '{') depth++;
+                else if (*j == '}') depth--;
+                else if (*j == '\'' || *j == '"') {
+                    char qc = *j++;
+                    while (j < e && *j != qc) j++;
+                }
+                if (depth) j++;
+            }
+            if (out->len) buf_str(out, ", ");
+            buf_put(out, "(", 1);
+            buf_put(out, p + 1, j > p + 1 ? (size_t)(j - (p + 1)) : 0);
+            buf_put(out, ")", 1);
+            p = j + 1;
+            ts = p;
+        } else if (*p == '<' && p + 1 < e && xq_is_name_start(p[1])) {
+            if (p > ts && !xq_ws_only(ts, (size_t)(p - ts))) {
+                if (out->len) buf_str(out, ", ");
+                buf_str(out, "text { ");
+                buf_lit(out, ts, (size_t)(p - ts));
+                buf_str(out, " }");
+            }
+            if (out->len) buf_str(out, ", ");
+            p = xq_translate_element(p, e, out);
+            ts = p;
+        } else if (xq_is_name_start(*p)) {
+            /* Computed-ctor keyword followed by '{' (document {
+             * ... }, text { ... }) or a name+'{' (element n { ... },
+             * attribute n { ... }): pass the keyword verbatim and
+             * recurse into the brace content so DIRECT constructors
+             * inside it translate too (#684 — `document { <a/> }`
+             * used to mangle into text). */
+            const char* w = p;
+            while (w < e && (xq_is_name_start(*w) ||
+                             isalnum((unsigned char)*w) || *w == '-' ||
+                             *w == '_' || *w == '.' || *w == ':'))
+                w++;
+            const char* gap = w;
+            while (gap < e && isspace((unsigned char)*gap)) gap++;
+            if (w < e && gap < e && *gap == '{' &&
+                (((size_t)(w - p) == 8 &&
+                  strncmp(p, "document", 8) == 0) ||
+                 ((size_t)(w - p) == 4 &&
+                  strncmp(p, "text", 4) == 0))) {
+                if (p > ts && !xq_ws_only(ts, (size_t)(p - ts))) {
+                    if (out->len) buf_str(out, ", ");
+                    buf_str(out, "text { ");
+                    buf_lit(out, ts, (size_t)(p - ts));
+                    buf_str(out, " }");
+                }
+                if (out->len) buf_str(out, ", ");
+                buf_put(out, p, (size_t)(w - p));
+                buf_str(out, " { ");
+                /* matching close brace, respecting nesting+quotes */
+                const char* j = gap + 1;
+                int depth = 1;
+                while (j < e && depth) {
+                    if (*j == '{') depth++;
+                    else if (*j == '}') depth--;
+                    else if (*j == '\'' || *j == '"') {
+                        char qc = *j++;
+                        while (j < e && *j != qc) j++;
+                    }
+                    if (depth) j++;
+                }
+                /* Fresh sub-buffer: the recursive translator emits
+                 * its own leading separators against out->len. */
+                Buf sub = {0};
+                xq_translate_content(gap + 1, j, &sub);
+                if (sub.len) buf_put(out, sub.s, sub.len);
+                free(sub.s);
+                buf_str(out, " }");
+                p = (j < e) ? j + 1 : e;
+                ts = p;
+            } else if (w < e && gap < e && *gap == '{' &&
+                       (((size_t)(w - p) == 7 &&
+                             strncmp(p, "element", 7) == 0) ||
+                        ((size_t)(w - p) == 9 &&
+                         strncmp(p, "attribute", 9) == 0)) &&
+                       gap != w /* a NAME must sit between */) {
+                /* element NAME { ... } / attribute NAME { ... }:
+                 * copy keyword+name, recurse the braces. */
+                const char* nm = w;
+                while (nm < e && (isalnum((unsigned char)*nm) ||
+                                  *nm == '_' || *nm == '-' ||
+                                  *nm == '.' || *nm == ':'))
+                    nm++;
+                const char* gap2 = nm;
+                while (gap2 < e && isspace((unsigned char)*gap2)) gap2++;
+                if (gap2 < e && *gap2 == '{' && nm > w) {
+                    if (p > ts && !xq_ws_only(ts, (size_t)(p - ts))) {
+                        if (out->len) buf_str(out, ", ");
+                        buf_str(out, "text { ");
+                        buf_lit(out, ts, (size_t)(p - ts));
+                        buf_str(out, " }");
+                    }
+                    if (out->len) buf_str(out, ", ");
+                    buf_put(out, p, (size_t)(nm - p));
+                    buf_str(out, " { ");
+                    const char* j = gap2 + 1;
+                    int depth = 1;
+                    while (j < e && depth) {
+                        if (*j == '{') depth++;
+                        else if (*j == '}') depth--;
+                        else if (*j == '\'' || *j == '"') {
+                            char qc = *j++;
+                            while (j < e && *j != qc) j++;
+                        }
+                        if (depth) j++;
+                    }
+                    Buf sub = {0};
+                    xq_translate_content(gap2 + 1, j, &sub);
+                    if (sub.len) buf_put(out, sub.s, sub.len);
+                    free(sub.s);
+                    buf_str(out, " }");
+                    p = (j < e) ? j + 1 : e;
+                    ts = p;
+                } else {
+                    p++;
+                }
+            } else {
+                p++;
+            }
+        } else {
+            p++;
+        }
+    }
+    if (e > ts && !xq_ws_only(ts, (size_t)(e - ts))) {
+        if (out->len) buf_str(out, ", ");
+        buf_str(out, "text { ");
+        buf_lit(out, ts, (size_t)(e - ts));
+        buf_str(out, " }");
+    }
+}