makiri 0.2.0 → 0.4.0

data/ext/makiri/xpath/{mkr_xpath_eval.c → mkr_xpath_eval_body.h}

@@ -13,13 +13,13 @@
  * native context. Phase 1 implements: child / attribute / self /
  * descendant-or-self / parent axes; predicates with position; the
  * full set of XPath 1.0 binary operators (semantically); arithmetic;
- * and a small built-in function table (see mkr_xpath_funcs.c).
+ * and a small built-in function table (see mkr_xpath_funcs_body.h).
  */
 
 /* ---------- forward decls ---------- */
 
 static int eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
-                     lxb_dom_node_t *self_node, size_t self_pos, size_t self_size,
+                     const mkr_focus_t *focus,
                      mkr_val_t *out, mkr_xpath_error_t *err);
 
 /* ---------- node test ---------- */
@@ -29,49 +29,126 @@ static int eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
  * explicit namespace (LXB_NS__UNDEF). For other ids it looks up the URI
  * in the document's ns hash. */
 static mkr_borrowed_text_t
-node_ns_text(lxb_dom_node_t *node, lxb_dom_document_t *doc)
+node_ns_text(MKR_DOM_NODE *node, MKR_DOM_DOCUMENT *doc)
 {
-  if (node->ns == LXB_NS__UNDEF) return mkr_borrowed_text_lit("");
-  if (doc == NULL || doc->ns == NULL) return mkr_borrowed_text_lit("");
   size_t len = 0;
-  const lxb_char_t *uri = lxb_ns_by_id(doc->ns, node->ns, &len);
-  return uri ? mkr_borrowed_text((const char *)uri, len)
-             : mkr_borrowed_text_lit("");
+  const char *uri = MKR_NODE_NS_URI(node, doc, &len);
+  return uri ? mkr_borrowed_text(uri, len) : mkr_borrowed_text_lit("");
 }
 
+/* Host-specific element/attribute name-test match (§8.6). The principal-node-type
+ * filter has already passed (node is an element, or an attribute on the attribute
+ * axis); this decides whether its name and namespace match +test+.
+ *
+ * HTML uses the qualified-name model: an unprefixed test compares the node's
+ * qualified name (== local name for HTML, which has no element prefixes) and, in
+ * strict mode, restricts elements to the HTML/no namespace; a prefixed test
+ * compares the local name plus the namespace URI bound to the prefix. The XML
+ * instance defines MKR_HOST_XML and provides its own local-name + ns_uri match. */
+/* +have_pre+ supplies the prefix's already-resolved namespace URI (pre_uri /
+ * pre_uri_len), so a hot multi-node walk resolves the test prefix once in
+ * eval_step instead of per node. have_pre == 0 resolves it here as before. */
 static int
-node_principal_match(const mkr_nodetest_t *test, lxb_dom_node_t *node,
-                     mkr_axis_t axis, mkr_xpath_context_t *ctx)
+name_test_match(const mkr_nodetest_t *test, MKR_DOM_NODE *node,
+                mkr_axis_t axis, mkr_xpath_context_t *ctx,
+                const char *pre_uri, size_t pre_uri_len, int have_pre)
+{
+#ifdef MKR_HOST_XML
+  /* XML name match (local name + namespace URI). An unprefixed test matches a
+   * no-namespace node only (a prefixed or default-namespaced element needs a
+   * registered prefix, §8.6); a prefixed test matches the local name plus the
+   * URI bound to the prefix. There is no qualified-name buffer on the custom
+   * node, so the comparison is always against the local name. */
+  size_t got_len = 0;
+  const lxb_char_t *got = (axis == MKR_AXIS_ATTRIBUTE)
+                            ? MKR_ATTR_LOCAL_NAME(node, &got_len)
+                            : MKR_ELEM_LOCAL_NAME(node, &got_len);
+  if (got == NULL || test->local.ptr == NULL) return 0;
+  if (!mkr_borrowed_text_eq(mkr_borrowed_text_from_owned(test->local),
+                            mkr_borrowed_text((const char *)got, got_len))) return 0;
+
+  size_t node_uri_len = 0;
+  const char *node_uri = MKR_NODE_NS_URI(node, mkr_ctx_document(ctx), &node_uri_len);
+  if (test->prefix.ptr != NULL) {
+    size_t want_uri_len = pre_uri_len;
+    const char *want_uri = have_pre ? pre_uri
+        : mkr_ctx_lookup_ns(ctx, test->prefix.ptr, test->prefix.len, &want_uri_len);
+    if (want_uri == NULL) return 0;
+    if (!mkr_bytes_eq(want_uri, want_uri_len, node_uri, node_uri_len)) return 0;
+  } else if (node_uri_len != 0 && !mkr_ctx_unprefixed_lax(ctx)) {
+    /* unprefixed test, strict: the node must be in no namespace */
+    return 0;
+  }
+  return 1;
+#else
+  /* HTML name match (qualified-name model). */
+  size_t got_len = 0;
+  const lxb_char_t *got;
+  if (test->prefix.ptr != NULL) {
+    got = (axis == MKR_AXIS_ATTRIBUTE) ? MKR_ATTR_LOCAL_NAME(node, &got_len)
+                                       : MKR_ELEM_LOCAL_NAME(node, &got_len);
+  } else {
+    got = (axis == MKR_AXIS_ATTRIBUTE) ? MKR_ATTR_QUALIFIED_NAME(node, &got_len)
+                                       : MKR_ELEM_QUALIFIED_NAME(node, &got_len);
+  }
+  if (got == NULL || test->local.ptr == NULL) return 0;
+  if (!mkr_borrowed_text_eq(mkr_borrowed_text_from_owned(test->local),
+                            mkr_borrowed_text((const char *)got, got_len))) return 0;
+
+  if (test->prefix.ptr != NULL) {
+    size_t want_uri_len = pre_uri_len;
+    const char *want_uri = have_pre ? pre_uri
+        : mkr_ctx_lookup_ns(ctx, test->prefix.ptr, test->prefix.len, &want_uri_len);
+    if (want_uri == NULL) return 0; /* unknown prefix -> non-match (step driver reports) */
+    mkr_borrowed_text_t node_uri = node_ns_text(node, mkr_ctx_document(ctx));
+    if (!mkr_bytes_eq(want_uri, want_uri_len, node_uri.ptr, node_uri.len)) return 0;
+  } else if (!mkr_ctx_unprefixed_lax(ctx)
+             && axis != MKR_AXIS_ATTRIBUTE
+             && MKR_NODE_IS_FOREIGN_NS(node)) {
+    /* strict mode: unprefixed ELEMENT tests resolve in the HTML namespace, so a
+     * foreign (SVG/MathML) element needs a prefix. Attributes are exempt (an
+     * unprefixed attribute test matches by no-namespace local name; the
+     * qualified-name compare above already excludes prefixed foreign attrs). */
+    return 0;
+  }
+  return 1;
+#endif /* MKR_HOST_XML */
+}
+
+static int
+node_principal_match_pre(const mkr_nodetest_t *test, MKR_DOM_NODE *node,
+                         mkr_axis_t axis, mkr_xpath_context_t *ctx,
+                         const char *pre_uri, size_t pre_uri_len, int have_pre)
 {
   switch (test->kind) {
   case MKR_NT_NODE:
     /* XPath 1.0 §5 data model: only element, attribute, text,
      * namespace, processing-instruction, comment, and the root are
      * model nodes. Lexbor additionally exposes DOCUMENT_TYPE, ENTITY,
-     * ENTITY_REFERENCE, and NOTATION nodes — none belong in the
+     * ENTITY_REFERENCE, and NOTATION nodes - none belong in the
      * model, so node() must not match them. DocumentFragment IS
      * matched: it acts as the root for fragment-rooted contexts,
      * so '.' / 'self::node()' over a fragment has to see it. */
-    switch (node->type) {
-    case LXB_DOM_NODE_TYPE_DOCUMENT_TYPE:
-    case LXB_DOM_NODE_TYPE_ENTITY:
-    case LXB_DOM_NODE_TYPE_ENTITY_REFERENCE:
-    case LXB_DOM_NODE_TYPE_NOTATION:
+    switch (MKR_NODE_TYPE(node)) {
+    case MKR_NTYPE_DOCUMENT_TYPE:
+    case MKR_NTYPE_ENTITY:
+    case MKR_NTYPE_ENTITY_REFERENCE:
+    case MKR_NTYPE_NOTATION:
       return 0;
     default:
       return 1;
     }
   case MKR_NT_TEXT:
-    return node->type == LXB_DOM_NODE_TYPE_TEXT
-        || node->type == LXB_DOM_NODE_TYPE_CDATA_SECTION;
+    return MKR_NODE_TYPE(node) == MKR_NTYPE_TEXT
+        || MKR_NODE_TYPE(node) == MKR_NTYPE_CDATA_SECTION;
   case MKR_NT_COMMENT:
-    return node->type == LXB_DOM_NODE_TYPE_COMMENT;
+    return MKR_NODE_TYPE(node) == MKR_NTYPE_COMMENT;
   case MKR_NT_PI:
-    if (node->type != LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION) return 0;
+    if (MKR_NODE_TYPE(node) != MKR_NTYPE_PI) return 0;
     if (test->pi_target.ptr == NULL) return 1;
     {
       size_t nlen = 0;
-      const lxb_char_t *nm = lxb_dom_node_name(node, &nlen);
+      const lxb_char_t *nm = MKR_NODE_PI_NAME(node, &nlen);
       return mkr_borrowed_text_eq(mkr_borrowed_text_from_owned(test->pi_target),
                          mkr_borrowed_text((const char *)nm, nlen));
     }
@@ -80,183 +157,139 @@ node_principal_match(const mkr_nodetest_t *test, lxb_dom_node_t *node,
       return 0; /* see internal.h §6 */
     /* Principal node type. */
     if (axis == MKR_AXIS_ATTRIBUTE) {
-      if (node->type != LXB_DOM_NODE_TYPE_ATTRIBUTE) return 0;
-    } else if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
+      if (MKR_NODE_TYPE(node) != MKR_NTYPE_ATTRIBUTE) return 0;
+    } else if (MKR_NODE_TYPE(node) != MKR_NTYPE_ELEMENT) {
       return 0;
     }
     /* `*` matches any namespace; `prefix:*` matches only the namespace bound
      * to prefix (internal.h §5). Unknown prefix is reported up front by the
      * step driver; here it is a non-match. */
     if (test->prefix.ptr != NULL) {
-      size_t want_uri_len = 0;
-      const char *want_uri = mkr_ctx_lookup_ns(ctx, test->prefix.ptr, test->prefix.len, &want_uri_len);
+      size_t want_uri_len = pre_uri_len;
+      const char *want_uri = have_pre ? pre_uri
+          : mkr_ctx_lookup_ns(ctx, test->prefix.ptr, test->prefix.len, &want_uri_len);
       if (want_uri == NULL) return 0;
       mkr_borrowed_text_t node_uri = node_ns_text(node, mkr_ctx_document(ctx));
-      if (want_uri_len != node_uri.len || memcmp(want_uri, node_uri.ptr, want_uri_len) != 0) return 0;
+      if (!mkr_bytes_eq(want_uri, want_uri_len, node_uri.ptr, node_uri.len)) return 0;
     }
     return 1;
   }
-  case MKR_NT_NAME: {
+  case MKR_NT_NAME:
     /* Principal node type filter. */
     if (axis == MKR_AXIS_ATTRIBUTE) {
-      if (node->type != LXB_DOM_NODE_TYPE_ATTRIBUTE) return 0;
-    } else if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
-      return 0;
-    }
-
-    /* Local-name comparison. For prefixed tests we compare local names
-     * (no prefix); for unprefixed tests we compare against the
-     * qualified name, which for HTML is equivalent to the local name. */
-    size_t got_len = 0;
-    const lxb_char_t *got;
-    if (test->prefix.ptr != NULL) {
-      if (axis == MKR_AXIS_ATTRIBUTE) {
-        got = lxb_dom_attr_local_name((lxb_dom_attr_t *)node, &got_len);
-      } else {
-        got = lxb_dom_element_local_name((lxb_dom_element_t *)node, &got_len);
-      }
-    } else {
-      if (axis == MKR_AXIS_ATTRIBUTE) {
-        got = lxb_dom_attr_qualified_name((lxb_dom_attr_t *)node, &got_len);
-      } else {
-        got = mkr_dom_node_name_qualified(node, &got_len);
-      }
-    }
-    if (got == NULL) return 0;
-    if (test->local.ptr == NULL) return 0;
-    if (!mkr_borrowed_text_eq(mkr_borrowed_text_from_owned(test->local),
-                     mkr_borrowed_text((const char *)got, got_len))) return 0;
-
-    /* Namespace check (see internal.h §2–§4).
-     *   - Prefixed test: the node's namespace URI must equal the URI bound to
-     *     the prefix.
-     *   - Unprefixed test, strict (default, HTML5/WHATWG-faithful): the name
-     *     resolves in the HTML namespace, so it matches only HTML-namespace or
-     *     no-namespace nodes — foreign (SVG/MathML) content needs a prefix.
-     *     This mirrors browsers' document.evaluate and Nokogiri::HTML5.
-     *   - Unprefixed test, lax: namespace ignored (matched by local name
-     *     already), the HTML4 / Nokogiri::HTML-style convenience. */
-    if (test->prefix.ptr != NULL) {
-      size_t want_uri_len = 0;
-      const char *want_uri = mkr_ctx_lookup_ns(ctx, test->prefix.ptr, test->prefix.len, &want_uri_len);
-      if (want_uri == NULL) {
-        /* Unknown prefix: leave for the step driver to report so the
-         * error is uniform across all hit nodes. We treat it as
-         * non-match here; node_principal_match cannot raise on its own. */
-        return 0;
-      }
-      mkr_borrowed_text_t node_uri = node_ns_text(node, mkr_ctx_document(ctx));
-      if (want_uri_len != node_uri.len || memcmp(want_uri, node_uri.ptr, want_uri_len) != 0) return 0;
-    } else if (!mkr_ctx_unprefixed_lax(ctx)
-               && axis != MKR_AXIS_ATTRIBUTE
-               && node->ns != LXB_NS_HTML && node->ns != LXB_NS__UNDEF) {
-      /* Strict mode restricts ELEMENT name tests to the HTML namespace; foreign
-       * (SVG/MathML) elements need a prefix. Attributes are exempt: an
-       * unprefixed attribute test matches by no-namespace local name (the DOM
-       * model — `id` on an <svg> is still a null-namespace attribute), and the
-       * qualified-name comparison above already excludes prefixed foreign
-       * attributes like xlink:href. Lexbor tags attributes with their element's
-       * ns, which does not reflect the DOM, so we must not gate attributes on
-       * node->ns here. */
+      if (MKR_NODE_TYPE(node) != MKR_NTYPE_ATTRIBUTE) return 0;
+    } else if (MKR_NODE_TYPE(node) != MKR_NTYPE_ELEMENT) {
       return 0;
     }
-    return 1;
-  }
+    /* The local-name + namespace match for an element/attribute name test is
+     * host-specific (HTML's qualified-name model vs XML's local+namespace-URI
+     * model, §8.6), so it lives in name_test_match - defined per instance. */
+    return name_test_match(test, node, axis, ctx, pre_uri, pre_uri_len, have_pre);
   }
   return 0;
 }
 
+/* Behaviour-preserving wrapper: resolve the prefix per call, as before. Used by
+ * the first-match path and the //tag index re-check (not hot enough to pre-
+ * resolve); the hot step walk calls node_principal_match_pre directly. */
+static int
+node_principal_match(const mkr_nodetest_t *test, MKR_DOM_NODE *node,
+                     mkr_axis_t axis, mkr_xpath_context_t *ctx)
+{
+  return node_principal_match_pre(test, node, axis, ctx, NULL, 0, 0);
+}
+
 /* ---------- axis walkers ---------- */
 
 static int
-walk_axis(mkr_axis_t axis, lxb_dom_node_t *context,
-          int (*visit)(lxb_dom_node_t *n, void *u), void *u)
+walk_axis(mkr_axis_t axis, MKR_DOM_NODE *context,
+          int (*visit)(MKR_DOM_NODE *n, void *u), void *u)
 {
   switch (axis) {
   case MKR_AXIS_SELF:
     if (visit(context, u)) return 1;
     return 0;
   case MKR_AXIS_PARENT: {
-    lxb_dom_node_t *p = context->parent;
+    MKR_DOM_NODE *p = MKR_NODE_PARENT(context);
     if (p && visit(p, u)) return 1;
     return 0;
   }
   case MKR_AXIS_CHILD:
-    for (lxb_dom_node_t *c = context->first_child; c != NULL; c = c->next) {
+    for (MKR_DOM_NODE *c = MKR_NODE_FIRST_CHILD(context); c != NULL; c = MKR_NODE_NEXT(c)) {
       if (visit(c, u)) return 1;
     }
     return 0;
   case MKR_AXIS_ATTRIBUTE: {
-    if (context->type != LXB_DOM_NODE_TYPE_ELEMENT) return 0;
-    lxb_dom_element_t *el = (lxb_dom_element_t *)context;
-    for (lxb_dom_attr_t *a = el->first_attr; a != NULL; a = a->next) {
-      if (visit((lxb_dom_node_t *)a, u)) return 1;
+    if (MKR_NODE_TYPE(context) != MKR_NTYPE_ELEMENT) return 0;
+    MKR_DOM_ELEMENT *el = (MKR_DOM_ELEMENT *)context;
+    for (MKR_DOM_ATTR *a = MKR_ELEM_FIRST_ATTR(el); a != NULL; a = MKR_ATTR_NEXT(a)) {
+      if (visit((MKR_DOM_NODE *)a, u)) return 1;
     }
     return 0;
   }
   case MKR_AXIS_DESCENDANT_OR_SELF: {
     /* DFS pre-order. */
     if (visit(context, u)) return 1;
-    lxb_dom_node_t *n = context->first_child;
+    MKR_DOM_NODE *n = MKR_NODE_FIRST_CHILD(context);
     while (n != NULL && n != context) {
       if (visit(n, u)) return 1;
-      if (n->first_child) {
-        n = n->first_child;
+      if (MKR_NODE_FIRST_CHILD(n)) {
+        n = MKR_NODE_FIRST_CHILD(n);
       } else {
-        while (n != context && n->next == NULL) n = n->parent;
+        while (n != context && MKR_NODE_NEXT(n) == NULL) n = MKR_NODE_PARENT(n);
         if (n == context) break;
-        n = n->next;
+        n = MKR_NODE_NEXT(n);
       }
     }
     return 0;
   }
   case MKR_AXIS_DESCENDANT: {
-    lxb_dom_node_t *n = context->first_child;
+    MKR_DOM_NODE *n = MKR_NODE_FIRST_CHILD(context);
     while (n != NULL && n != context) {
       if (visit(n, u)) return 1;
-      if (n->first_child) {
-        n = n->first_child;
+      if (MKR_NODE_FIRST_CHILD(n)) {
+        n = MKR_NODE_FIRST_CHILD(n);
       } else {
-        while (n != context && n->next == NULL) n = n->parent;
+        while (n != context && MKR_NODE_NEXT(n) == NULL) n = MKR_NODE_PARENT(n);
         if (n == context) break;
-        n = n->next;
+        n = MKR_NODE_NEXT(n);
       }
     }
     return 0;
   }
   case MKR_AXIS_ANCESTOR:
-    for (lxb_dom_node_t *p = context->parent; p != NULL; p = p->parent) {
+    for (MKR_DOM_NODE *p = MKR_NODE_PARENT(context); p != NULL; p = MKR_NODE_PARENT(p)) {
       if (visit(p, u)) return 1;
     }
     return 0;
   case MKR_AXIS_ANCESTOR_OR_SELF:
-    for (lxb_dom_node_t *p = context; p != NULL; p = p->parent) {
+    for (MKR_DOM_NODE *p = context; p != NULL; p = MKR_NODE_PARENT(p)) {
       if (visit(p, u)) return 1;
     }
     return 0;
   case MKR_AXIS_FOLLOWING_SIBLING:
-    for (lxb_dom_node_t *s = context->next; s != NULL; s = s->next) {
+    for (MKR_DOM_NODE *s = MKR_NODE_NEXT(context); s != NULL; s = MKR_NODE_NEXT(s)) {
       if (visit(s, u)) return 1;
     }
     return 0;
   case MKR_AXIS_PRECEDING_SIBLING:
-    for (lxb_dom_node_t *s = context->prev; s != NULL; s = s->prev) {
+    for (MKR_DOM_NODE *s = MKR_NODE_PREV(context); s != NULL; s = MKR_NODE_PREV(s)) {
       if (visit(s, u)) return 1;
     }
     return 0;
   case MKR_AXIS_FOLLOWING: {
     /* Start at the next node in doc order after context's subtree. */
-    lxb_dom_node_t *cur = context;
-    while (cur != NULL && cur->next == NULL) cur = cur->parent;
+    MKR_DOM_NODE *cur = context;
+    while (cur != NULL && MKR_NODE_NEXT(cur) == NULL) cur = MKR_NODE_PARENT(cur);
     if (cur == NULL) return 0;
-    cur = cur->next;
+    cur = MKR_NODE_NEXT(cur);
     while (cur != NULL) {
       if (visit(cur, u)) return 1;
-      if (cur->first_child) {
-        cur = cur->first_child;
+      if (MKR_NODE_FIRST_CHILD(cur)) {
+        cur = MKR_NODE_FIRST_CHILD(cur);
       } else {
-        while (cur != NULL && cur->next == NULL) cur = cur->parent;
-        if (cur != NULL) cur = cur->next;
+        while (cur != NULL && MKR_NODE_NEXT(cur) == NULL) cur = MKR_NODE_PARENT(cur);
+        if (cur != NULL) cur = MKR_NODE_NEXT(cur);
       }
     }
     return 0;
@@ -269,18 +302,18 @@ walk_axis(mkr_axis_t axis, lxb_dom_node_t *context,
      * ancestor of context: it's an ancestor only when we're climbing
      * the chain from context itself, not when we're climbing back out
      * of a preceding sibling's subtree. */
-    lxb_dom_node_t *cur = context;
+    MKR_DOM_NODE *cur = context;
     while (cur != NULL) {
-      if (cur->prev) {
-        cur = cur->prev;
-        while (cur->last_child) cur = cur->last_child;
+      if (MKR_NODE_PREV(cur)) {
+        cur = MKR_NODE_PREV(cur);
+        while (MKR_NODE_LAST_CHILD(cur)) cur = MKR_NODE_LAST_CHILD(cur);
         if (visit(cur, u)) return 1;
       } else {
-        cur = cur->parent;
+        cur = MKR_NODE_PARENT(cur);
         if (cur == NULL) return 0;
         /* Is cur an ancestor of the original context? */
         int is_ancestor = 0;
-        for (lxb_dom_node_t *p = context->parent; p != NULL; p = p->parent) {
+        for (MKR_DOM_NODE *p = MKR_NODE_PARENT(context); p != NULL; p = MKR_NODE_PARENT(p)) {
           if (p == cur) { is_ancestor = 1; break; }
         }
         if (!is_ancestor) {
@@ -308,7 +341,7 @@ walk_axis(mkr_axis_t axis, lxb_dom_node_t *context,
  * throwaway node-set (malloc/free) per context node for the attribute path plus
  * a string-cache insert; recognising the shape lets us filter with a direct
  * attribute lookup instead. Both shapes are boolean (no position dependence),
- * so this is a pure per-node filter — identical result to the generic path.
+ * so this is a pure per-node filter - identical result to the generic path.
  */
 typedef struct {
   const char *name;
@@ -319,7 +352,7 @@ typedef struct {
 } mkr_attr_pred_t;
 
 /* Shape A: a relative path that is a single unprefixed attribute name test with
- * no predicates — i.e. `@name`. Fills name/name_len; returns 1 on match. */
+ * no predicates - i.e. `@name`. Fills name/name_len; returns 1 on match. */
 static int
 mkr_match_attr_step(const mkr_node_t *n, const char **name, size_t *name_len)
 {
@@ -371,23 +404,43 @@ mkr_match_attr_pred(const mkr_node_t *p, mkr_attr_pred_t *out)
 /* Find an element's attribute whose qualified name equals +name+ exactly
  * (case-SENSITIVE), or NULL. We scan rather than calling
  * lxb_dom_element_get_attribute, because that does an HTML case-INsensitive
- * lookup — which would make `[@Id]` match `id`, diverging from XPath 1.0, from
+ * lookup - which would make `[@Id]` match `id`, diverging from XPath 1.0, from
  * Nokogiri::HTML5, AND from Makiri's own case-sensitive attribute-axis name
  * test (node_principal_match compares the qualified name byte-for-byte). The
  * fast path only handles unprefixed names, matching that comparison. */
-static lxb_dom_attr_t *
-mkr_attr_by_qualified_name(lxb_dom_element_t *el, const char *name, size_t name_len)
+static MKR_DOM_ATTR *
+mkr_attr_by_qualified_name(MKR_DOM_ELEMENT *el, const char *name, size_t name_len)
 {
-  for (lxb_dom_attr_t *a = el->first_attr; a != NULL; a = a->next) {
+  for (MKR_DOM_ATTR *a = MKR_ELEM_FIRST_ATTR(el); a != NULL; a = MKR_ATTR_NEXT(a)) {
     size_t qlen = 0;
-    const lxb_char_t *q = lxb_dom_attr_qualified_name(a, &qlen);
-    if (q != NULL && qlen == name_len && memcmp(q, name, name_len) == 0) {
+    const lxb_char_t *q = MKR_ATTR_QUALIFIED_NAME(a, &qlen);
+    if (q != NULL && mkr_bytes_eq(q, qlen, name, name_len)) {
       return a;
     }
   }
   return NULL;
 }
 
+/* Does element node +n+ satisfy the recognised attribute predicate +ap+
+ * ([@name] or [@name='value'])? This is THE single per-node test - shared by
+ * the predicate filter (mkr_filter_attr_pred) and the at_xpath first-match path
+ * (mkr_first_node_ok) so the two stay byte-identical by construction rather than
+ * by a hand-kept copy. Position-independent (no context size/position), matching
+ * the recogniser's "boolean predicate only" contract. */
+static int
+mkr_attr_pred_matches_node(const mkr_attr_pred_t *ap, MKR_DOM_NODE *n)
+{
+  if (MKR_NODE_TYPE(n) != MKR_NTYPE_ELEMENT) return 0;
+  MKR_DOM_ATTR *a =
+      mkr_attr_by_qualified_name(MKR_NODE_AS_ELEMENT(n), ap->name, ap->name_len);
+  if (a == NULL) return 0;
+  if (!ap->has_value) return 1;
+  size_t got_len = 0;
+  const lxb_char_t *got = MKR_ATTR_VALUE(a, &got_len);
+  if (got == NULL) got_len = 0;
+  return mkr_bytes_eq(got, got_len, ap->value, ap->value_len);
+}
+
 /* Filter `inout` by a recognised attribute predicate into `kept`. */
 static int
 mkr_filter_attr_pred(mkr_xpath_context_t *ctx, const mkr_attr_pred_t *ap,
@@ -395,27 +448,13 @@ mkr_filter_attr_pred(mkr_xpath_context_t *ctx, const mkr_attr_pred_t *ap,
                      mkr_xpath_error_t *err)
 {
   for (size_t i = 0; i < inout->count; ++i) {
-    lxb_dom_node_t *n = inout->items[i];
-    int keep = 0;
-    if (n->type == LXB_DOM_NODE_TYPE_ELEMENT) {
-      lxb_dom_attr_t *a =
-          mkr_attr_by_qualified_name(lxb_dom_interface_element(n), ap->name, ap->name_len);
-      if (a != NULL) {
-        if (!ap->has_value) {
-          keep = 1;
-        } else {
-          size_t got_len = 0;
-          const lxb_char_t *got = lxb_dom_attr_value(a, &got_len);
-          if (got == NULL) {
-            got_len = 0;
-          }
-          keep = (got_len == ap->value_len
-                  && (ap->value_len == 0
-                      || memcmp(got, ap->value, ap->value_len) == 0));
-        }
-      }
-    }
-    if (keep && mkr_nodeset_push(kept, n, mkr_ctx_limits(ctx), err) != 0) {
+    /* Per-candidate op charge: this fast path replaces a per-node generic
+     * predicate eval (which would tick via eval_node), so tick here too to keep
+     * the [@a]/[@a='v'] filter under the same budget as the path it shortcuts. */
+    if (mkr_limit_eval_op(mkr_ctx_limits(ctx), err) != 0) return -1;
+    MKR_DOM_NODE *n = inout->items[i];
+    if (mkr_attr_pred_matches_node(ap, n)
+        && mkr_nodeset_push(kept, n, mkr_ctx_limits(ctx), err) != 0) {
       return -1;
     }
   }
@@ -432,7 +471,7 @@ apply_predicates(mkr_xpath_context_t *ctx,
     mkr_nodeset_t kept;
     mkr_nodeset_init(&kept);
 
-    /* Specialise [@name] / [@name='lit'] — a position-independent filter, so
+    /* Specialise [@name] / [@name='lit'] - a position-independent filter, so
      * applying it per predicate (even amid others) matches the generic path. */
     mkr_attr_pred_t ap;
     if (mkr_match_attr_pred(preds[p], &ap)) {
@@ -448,7 +487,8 @@ apply_predicates(mkr_xpath_context_t *ctx,
     size_t size = inout->count;
     for (size_t i = 0; i < size; ++i) {
       mkr_val_t v = {0};
-      if (eval_node(ctx, preds[p], inout->items[i], i + 1, size, &v, err) != 0) {
+      mkr_focus_t pf = { inout->items[i], i + 1, size };
+      if (eval_node(ctx, preds[p], &pf, &v, err) != 0) {
         mkr_nodeset_clear(&kept);
         return -1;
       }
@@ -483,13 +523,31 @@ typedef struct {
   int                 aborted; /* set when push or match failed; the walk
                                 * is short-circuited and the step driver
                                 * propagates the error. */
+  /* The name test's prefix resolved once by eval_step (see have_pre), so a
+   * multi-node walk does not re-resolve it per node. */
+  const char         *pre_uri;
+  size_t              pre_uri_len;
+  int                 have_pre;
 } step_visit_t;
 
 static int
-step_visit_cb(lxb_dom_node_t *n, void *u)
+step_visit_cb(MKR_DOM_NODE *n, void *u)
 {
   step_visit_t *st = (step_visit_t *)u;
-  if (node_principal_match(&st->step->test, n, st->step->axis, st->ctx)) {
+  /* Charge every visited node to the op budget. The axis walk is the dominant
+   * work of a step, and a low-selectivity walk visits (and name-tests) many
+   * nodes while pushing few or none - so without this the node-set cap (which
+   * only bounds the matched/pushed nodes) leaves the walk itself bounded only
+   * by document size, defeating max_eval_ops on a descendant walk that matches
+   * nothing. The index/first-match fast paths already tick per node; this
+   * brings the general walk to parity. On overrun we abort the walk exactly
+   * like a push failure. */
+  if (mkr_limit_eval_op(mkr_ctx_limits(st->ctx), st->err) != 0) {
+    st->aborted = 1;
+    return 1;
+  }
+  if (node_principal_match_pre(&st->step->test, n, st->step->axis, st->ctx,
+                               st->pre_uri, st->pre_uri_len, st->have_pre)) {
     if (mkr_nodeset_push(st->out, n, mkr_ctx_limits(st->ctx), st->err) != 0) {
       st->aborted = 1;
       return 1; /* stop the walk; eval_step inspects st.aborted */
@@ -527,7 +585,7 @@ axis_can_alias(mkr_axis_t a)
 }
 
 /*
- * 13 axes — Phase 2b adds the remaining six. The namespace axis stays
+ * 13 axes - Phase 2b adds the remaining six. The namespace axis stays
  * unimplemented for now (spec section 6 in mkr_xpath_internal.h).
  */
 static int
@@ -590,7 +648,7 @@ is_reverse_axis(mkr_axis_t a)
 }
 
 /*
- * Fast path for `//tag` — a descendant, unprefixed, predicate-free name-test
+ * Fast path for `//tag` - a descendant, unprefixed, predicate-free name-test
  * whose context is exactly the document node. `descendant::tag` from the
  * document is precisely "every element whose name is tag", which the
  * document's element index already groups by tag id in document order, so we
@@ -600,12 +658,13 @@ is_reverse_axis(mkr_axis_t a)
  * context does not qualify (caller falls back to the walk), -1 on error.
  *
  * Correctness: only taken for pure-HTML documents (mkr_element_index_has_foreign
- * is false) — in foreign content an element's qualified name need not equal its
+ * is false) - in foreign content an element's qualified name need not equal its
  * tag's canonical name, so a match could live in another tag bucket. Each
  * candidate is still re-checked with node_principal_match, so the result is
  * byte-identical to the walk (this also makes case/normalization quirks in the
  * tag-name lookup harmless: a non-matching candidate is simply dropped).
  */
+#ifndef MKR_HOST_XML
 static int
 try_descendant_tag_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
                          const mkr_nodeset_t *context_set, mkr_nodeset_t *result,
@@ -616,7 +675,7 @@ try_descendant_tag_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
       || step->test.prefix.ptr != NULL
       || step->test.local.ptr == NULL
       || context_set->count != 1
-      || context_set->items[0] != (lxb_dom_node_t *)mkr_ctx_document(ctx)) {
+      || context_set->items[0] != (MKR_DOM_NODE *)mkr_ctx_document(ctx)) {
     return 0;
   }
   void *eidx = mkr_ctx_element_index(ctx);
@@ -625,13 +684,12 @@ try_descendant_tag_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
   if (eidx == NULL || lookup == NULL || has_foreign == NULL || has_foreign(eidx)) {
     return 0;
   }
-  lxb_dom_document_t *doc = mkr_ctx_document(ctx);
+  MKR_DOM_DOCUMENT *doc = mkr_ctx_document(ctx);
   if (doc == NULL) {
     return 0;
   }
-  lxb_tag_id_t tag = lxb_tag_id_by_name(doc->tags,
-                                        (const lxb_char_t *)step->test.local.ptr,
-                                        step->test.local.len);
+  lxb_tag_id_t tag = MKR_DOC_TAG_ID_BY_NAME(doc, step->test.local.ptr,
+                                            step->test.local.len);
   /* The index covers only Lexbor's static tag-id range; a custom element's tag
    * id is a (huge) pointer value and is not indexed. For such a name, fall back
    * to the tree walk so those elements are still found. */
@@ -639,9 +697,13 @@ try_descendant_tag_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
     return 0;
   }
   size_t cnt = 0;
-  lxb_dom_node_t *const *bucket = lookup(eidx, tag, &cnt);
+  /* The element index is HTML-only (the lookup hook is typed for lxb_dom); this
+   * whole fast path is unreachable for XML (its element index is NULL), but the
+   * cast keeps the shared body warning-clean under the XML instantiation. */
+  MKR_DOM_NODE *const *bucket = (MKR_DOM_NODE *const *)lookup(eidx, tag, &cnt);
   for (size_t i = 0; i < cnt; ++i) {
-    lxb_dom_node_t *n = bucket[i];
+    if (mkr_limit_eval_op(mkr_ctx_limits(ctx), err) != 0) return -1;
+    MKR_DOM_NODE *n = bucket[i];
     if (node_principal_match(&step->test, n, step->axis, ctx)) {
       if (mkr_nodeset_push(result, n, mkr_ctx_limits(ctx), err) != 0) {
         return -1;
@@ -650,6 +712,60 @@ try_descendant_tag_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
   }
   return 1;
 }
+#else  /* MKR_HOST_XML */
+/*
+ * XML analogue of the //tag fast path: a document-rooted, predicate-free
+ * descendant name test answered from the element-name index (mkr_xml_index.c)
+ * instead of walking. The index is keyed by (local name + namespace URI), so it
+ * serves a prefixed test (resolved URI) and an unprefixed strict test (the
+ * no-namespace bucket); an unprefixed LAX test means "any namespace", which a
+ * single bucket cannot express, so it falls back to the walk. The bucket already
+ * holds exactly the matching elements in document order, so they are pushed
+ * directly. Returns 1 (filled), 0 (does not qualify -> walk), -1 (error).
+ */
+static int
+try_descendant_name_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
+                          const mkr_nodeset_t *context_set, mkr_nodeset_t *result,
+                          const char *pre_uri, size_t pre_uri_len, int have_pre,
+                          mkr_xpath_error_t *err)
+{
+  if (step->axis != MKR_AXIS_DESCENDANT
+      || step->test.kind != MKR_NT_NAME
+      || step->test.local.ptr == NULL
+      || context_set->count != 1
+      || context_set->items[0] != (MKR_DOM_NODE *)mkr_ctx_document(ctx)) {
+    return 0;
+  }
+
+  const char *ns_uri; size_t ns_uri_len;
+  if (step->test.prefix.ptr != NULL) {
+    if (!have_pre) return 0;             /* should not happen: eval_step pre-resolves */
+    ns_uri = pre_uri; ns_uri_len = pre_uri_len;
+  } else if (mkr_ctx_unprefixed_lax(ctx)) {
+    return 0;                            /* "any namespace" - not a single bucket */
+  } else {
+    ns_uri = ""; ns_uri_len = 0;          /* strict unprefixed -> no namespace */
+  }
+
+  void                    *owner  = mkr_ctx_name_index_owner(ctx);
+  mkr_name_index_get_t     get    = mkr_ctx_name_index_get(ctx);
+  mkr_name_index_lookup_t  lookup = mkr_ctx_name_index_lookup(ctx);
+  if (owner == NULL || get == NULL || lookup == NULL) return 0;
+  void *idx = get(owner);                /* lazily builds + caches; NULL on OOM */
+  if (idx == NULL) return 0;
+
+  size_t cnt = 0;
+  void *const *bucket = lookup(idx, step->test.local.ptr, step->test.local.len,
+                               ns_uri, ns_uri_len, &cnt);
+  for (size_t i = 0; i < cnt; ++i) {
+    if (mkr_limit_eval_op(mkr_ctx_limits(ctx), err) != 0) return -1;
+    if (mkr_nodeset_push(result, (MKR_DOM_NODE *)bucket[i], mkr_ctx_limits(ctx), err) != 0) {
+      return -1;
+    }
+  }
+  return 1;
+}
+#endif /* MKR_HOST_XML */
 
 /* ---------------------------------------------------------------------------
  * at_xpath() first-match short-circuit (Node#at_xpath / Node#at).
@@ -657,7 +773,7 @@ try_descendant_tag_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
  * Node#at_xpath wants only the first node in document order; today it builds the
  * whole node-set and takes [0]. For the common "find a descendant by name (plus
  * a simple attribute predicate)" shapes we can instead walk the subtree in
- * document order and stop at the first match — the XPath-side analogue of
+ * document order and stop at the first match - the XPath-side analogue of
  * at_css's lxb_selectors MATCH_FIRST.
  *
  * Recognised shapes (after the parser's // peephole, see mkr_apply_peephole):
@@ -668,7 +784,7 @@ try_descendant_tag_index(mkr_xpath_context_t *ctx, const mkr_step_t *step,
  * position-independent [@name] / [@name='lit'] (exactly mkr_match_attr_pred's
  * shape). Each denotes "the strict descendants of <start> matching the
  * test+predicates, in document order", so the first node the pre-order walk
- * reaches IS node-set[0] of the full evaluation — byte-identical, just without
+ * reaches IS node-set[0] of the full evaluation - byte-identical, just without
  * building the rest. Anything else (positional predicates, functions/variables,
  * reverse axes, unions, prefixes, longer paths) returns 0 and the caller falls
  * back to the full evaluator.
@@ -691,9 +807,11 @@ mkr_first_recognise(const mkr_node_t *ast, const mkr_step_t **out_step)
   } else {
     return 0;
   }
-  /* A prefixed name test needs the step driver's "unknown prefix -> RUNTIME
-   * error" semantics, which this path does not reproduce; fall back. */
-  if (nt->test.prefix.ptr != NULL) return 0;
+  /* A prefixed name test is allowed; mkr_try_first_match reproduces the step
+   * driver's "unknown prefix -> RUNTIME error" before walking, and
+   * node_principal_match resolves the prefix to a URI exactly as the full
+   * evaluator does. (Prefixed ATTRIBUTE predicates still fall back: their
+   * mkr_match_attr_step requires an unprefixed @name.) */
   /* Every predicate must be a position-independent attribute predicate (no
    * position()/last()/numeric, no function/variable -> no handler involvement). */
   for (size_t p = 0; p < nt->npredicates; p++) {
@@ -705,26 +823,15 @@ mkr_first_recognise(const mkr_node_t *ast, const mkr_step_t **out_step)
 }
 
 /* Does +n+ satisfy every (already-recognised) attribute predicate of +step+?
- * Mirrors mkr_filter_attr_pred's per-node test so the result is identical. */
+ * Uses the shared mkr_attr_pred_matches_node so it is identical to the
+ * predicate filter's per-node test by construction. */
 static int
-mkr_first_node_ok(const mkr_step_t *step, lxb_dom_node_t *n)
+mkr_first_node_ok(const mkr_step_t *step, MKR_DOM_NODE *n)
 {
   for (size_t p = 0; p < step->npredicates; p++) {
     mkr_attr_pred_t ap;
     (void)mkr_match_attr_pred(step->predicates[p], &ap); /* recogniser ensured it matches */
-    if (n->type != LXB_DOM_NODE_TYPE_ELEMENT) return 0;
-    lxb_dom_attr_t *a =
-        mkr_attr_by_qualified_name(lxb_dom_interface_element(n), ap.name, ap.name_len);
-    if (a == NULL) return 0;
-    if (ap.has_value) {
-      size_t got_len = 0;
-      const lxb_char_t *got = lxb_dom_attr_value(a, &got_len);
-      if (got == NULL) got_len = 0;
-      if (got_len != ap.value_len
-          || (ap.value_len != 0 && memcmp(got, ap.value, ap.value_len) != 0)) {
-        return 0;
-      }
-    }
+    if (!mkr_attr_pred_matches_node(&ap, n)) return 0;
   }
   return 1;
 }
@@ -732,31 +839,49 @@ mkr_first_node_ok(const mkr_step_t *step, lxb_dom_node_t *n)
 /* If +ast+ is a recognised at_xpath() first-match shape, walk <start>'s strict
  * descendants in document order and set *out_node to the first match (NULL if
  * none). Returns 1 when handled (caller skips the full evaluator), 0 when the
- * shape is not recognised. Never raises (the recognised shape cannot error). */
+ * shape is not recognised, and -1 when the per-evaluate op budget is exceeded
+ * during the walk (*err filled with MKR_XPATH_ERR_LIMIT). Every visited node is
+ * charged to max_eval_ops, so a huge late-/no-match document fails closed here
+ * exactly as it would in the full evaluator instead of bypassing the budget. */
 int
 mkr_try_first_match(mkr_xpath_context_t *ctx, const mkr_node_t *ast,
-                    lxb_dom_node_t **out_node)
+                    MKR_DOM_NODE **out_node, mkr_xpath_error_t *err)
 {
   const mkr_step_t *step;
   if (out_node == NULL || !mkr_first_recognise(ast, &step)) return 0;
   *out_node = NULL;
 
-  lxb_dom_node_t *start = ast->u.path.absolute
-      ? (lxb_dom_node_t *)mkr_ctx_document(ctx)
+  /* Reproduce the step driver's namespace-prefix validation: a prefixed name
+   * test with an unbound prefix is a RUNTIME error, not a silently empty match,
+   * so the fast path stays byte-identical to the full evaluator (incl. errors). */
+  if (step->test.prefix.ptr != NULL
+      && mkr_ctx_lookup_ns(ctx, step->test.prefix.ptr, step->test.prefix.len, NULL) == NULL) {
+    mkr_err_setf(err, MKR_XPATH_ERR_RUNTIME,
+                 "unknown namespace prefix '%s' in name test", step->test.prefix.ptr);
+    return -1;
+  }
+
+  MKR_DOM_NODE *start = ast->u.path.absolute
+      ? (MKR_DOM_NODE *)mkr_ctx_document(ctx)
       : mkr_ctx_node(ctx);
   if (start == NULL) return 1; /* recognised; no context -> no match */
 
+  mkr_xpath_limits_t *limits = mkr_ctx_limits(ctx);
+
   /* Iterative pre-order (document order) over STRICT descendants of start. */
-  for (lxb_dom_node_t *n = start->first_child; n != NULL; ) {
+  for (MKR_DOM_NODE *n = MKR_NODE_FIRST_CHILD(start); n != NULL; ) {
+    /* Charge each visited node to the per-evaluate op budget so this fast path
+     * is bounded by max_eval_ops just like the full evaluator (fail-closed). */
+    if (mkr_limit_eval_op(limits, err) != 0) return -1;
     if (node_principal_match(&step->test, n, step->axis, ctx)
         && mkr_first_node_ok(step, n)) {
       *out_node = n;
       return 1;
     }
-    if (n->first_child != NULL) { n = n->first_child; continue; }
-    while (n != start && n->next == NULL) n = n->parent;
+    if (MKR_NODE_FIRST_CHILD(n) != NULL) { n = MKR_NODE_FIRST_CHILD(n); continue; }
+    while (n != start && MKR_NODE_NEXT(n) == NULL) n = MKR_NODE_PARENT(n);
     if (n == start) break;
-    n = n->next;
+    n = MKR_NODE_NEXT(n);
   }
   return 1; /* recognised; *out_node is the first match or NULL */
 }
@@ -772,15 +897,20 @@ eval_step(mkr_xpath_context_t *ctx, const mkr_step_t *step,
                 axis_name_str(step->axis));
     return -1;
   }
-  /* Validate the namespace prefix once up front so we get a uniform
-   * RUNTIME error instead of a silently empty match. Covers both `prefix:local`
-   * (MKR_NT_NAME) and `prefix:*` (MKR_NT_WILDCARD). */
-  if (step->test.prefix.ptr != NULL
-      && mkr_ctx_lookup_ns(ctx, step->test.prefix.ptr, step->test.prefix.len, NULL) == NULL) {
-    mkr_err_setf(err, MKR_XPATH_ERR_RUNTIME,
-                "unknown namespace prefix '%s' in name test",
-                step->test.prefix.ptr);
-    return -1;
+  /* Resolve the namespace prefix once up front (covers `prefix:local` and
+   * `prefix:*`): a uniform RUNTIME error instead of a silently empty match, and
+   * the resolved URI is then handed to every per-node match via step_visit_t so
+   * the walk does not re-resolve it per node. */
+  const char *pre_uri = NULL; size_t pre_uri_len = 0; int have_pre = 0;
+  if (step->test.prefix.ptr != NULL) {
+    pre_uri = mkr_ctx_lookup_ns(ctx, step->test.prefix.ptr, step->test.prefix.len, &pre_uri_len);
+    if (pre_uri == NULL) {
+      mkr_err_setf(err, MKR_XPATH_ERR_RUNTIME,
+                  "unknown namespace prefix '%s' in name test",
+                  step->test.prefix.ptr);
+      return -1;
+    }
+    have_pre = 1;
   }
 
   /* Post-pass = sort to doc order, then optional adjacent-dedup. We
@@ -792,7 +922,7 @@ eval_step(mkr_xpath_context_t *ctx, const mkr_step_t *step,
    *   3. The axis does NOT aliase but multiple contexts can still
    *      produce results that interleave in doc order. child is the
    *      canonical case: html's children include head and body, and
-   *      head's children include title — concatenated naively gives
+   *      head's children include title - concatenated naively gives
    *      [head, body, title, ...] but doc order is [head, title, body,
    *      ...]. Only SELF and ATTRIBUTE are safe to concatenate without
    *      sorting (their outputs stay in doc order when inputs are). */
@@ -806,9 +936,14 @@ eval_step(mkr_xpath_context_t *ctx, const mkr_step_t *step,
   mkr_nodeset_init(&result);
 
   if (step->npredicates == 0) {
-    /* `//tag` from the document: serve from the element index, skipping the
-     * tree walk entirely. */
+    /* A document-rooted descendant name test served from the element index,
+     * skipping the tree walk entirely (HTML: tag-id index; XML: name index). */
+#ifdef MKR_HOST_XML
+    int fp = try_descendant_name_index(ctx, step, context_set, &result,
+                                       pre_uri, pre_uri_len, have_pre, err);
+#else
     int fp = try_descendant_tag_index(ctx, step, context_set, &result, err);
+#endif
     if (fp < 0) {
       mkr_nodeset_clear(&result);
       return -1;
@@ -820,7 +955,8 @@ eval_step(mkr_xpath_context_t *ctx, const mkr_step_t *step,
      * path needs. Big win for //h3/parent::*, //h3/ancestor::div, and
      * other multi-context reverse-axis sweeps where every context
      * produces a single result. */
-    step_visit_t st = { .out = &result, .step = step, .ctx = ctx, .err = err, .aborted = 0 };
+    step_visit_t st = { .out = &result, .step = step, .ctx = ctx, .err = err, .aborted = 0,
+                        .pre_uri = pre_uri, .pre_uri_len = pre_uri_len, .have_pre = have_pre };
     for (size_t ci = 0; ci < context_set->count; ++ci) {
       walk_axis(step->axis, context_set->items[ci], step_visit_cb, &st);
       if (st.aborted) {
@@ -832,14 +968,15 @@ eval_step(mkr_xpath_context_t *ctx, const mkr_step_t *step,
   } else {
     /* Predicate path: position() / last() are per-context, so we have
      * to materialise each context's fragment before filtering. Reuse
-     * a single fragment buffer across iterations — its items[] grows
+     * a single fragment buffer across iterations - its items[] grows
      * to the largest single-context cardinality once instead of
      * malloc/freeing on every iteration. */
     mkr_nodeset_t fragment;
     mkr_nodeset_init(&fragment);
     for (size_t ci = 0; ci < context_set->count; ++ci) {
       fragment.count = 0;
-      step_visit_t st = { .out = &fragment, .step = step, .ctx = ctx, .err = err, .aborted = 0 };
+      step_visit_t st = { .out = &fragment, .step = step, .ctx = ctx, .err = err, .aborted = 0,
+                          .pre_uri = pre_uri, .pre_uri_len = pre_uri_len, .have_pre = have_pre };
       walk_axis(step->axis, context_set->items[ci], step_visit_cb, &st);
       if (st.aborted) {
         mkr_nodeset_clear(&fragment);
@@ -883,13 +1020,175 @@ eval_step(mkr_xpath_context_t *ctx, const mkr_step_t *step,
   return 0;
 }
 
+/* --- `//name[N]` index fast path (shared shape + per-parent emit) -----------
+ *
+ * `//name[N]` (the two leading steps `descendant-or-self::node()` /
+ * `child::name[N]`, N a positive integer literal, rooted at the document)
+ * selects, for every node c, c's Nth name-child - i.e. every name element that
+ * is the Nth name-child of its parent. This is NOT `(//name)[N]` nor
+ * `descendant::name[N]`. Both hosts answer it from their element index (XML: the
+ * name index; HTML: the tag-id index) with per-parent counting, instead of the
+ * descendant-or-self full-tree walk: the index lists matching elements in
+ * document order, so a parent's name-children appear among them in child order;
+ * one sweep with a pointer-keyed parent->count map emits exactly those whose
+ * running count reaches N, already in document order (no sort/dedup). The bucket
+ * retrieval is host-specific; the shape check and the count loop are shared. */
+
+/* Host-neutral shape check: sets *need = N. 1 = matches, 0 = no. */
+static int
+nth_shape(mkr_xpath_context_t *ctx, const mkr_step_t *s0, const mkr_step_t *s1,
+          const mkr_nodeset_t *seed, size_t *need)
+{
+  if (s0->axis != MKR_AXIS_DESCENDANT_OR_SELF || s0->test.kind != MKR_NT_NODE
+      || s0->test.prefix.ptr != NULL || s0->npredicates != 0)
+    return 0;
+  if (s1->axis != MKR_AXIS_CHILD || s1->test.kind != MKR_NT_NAME
+      || s1->test.local.ptr == NULL || s1->npredicates != 1)
+    return 0;
+  /* The sole predicate must be a bare positive-integer literal `[N]` (= position()
+   * == N). `[position()=N]`, `[last()]`, etc. are binops/calls -> fall back. */
+  const mkr_node_t *pred = s1->predicates[0];
+  if (pred == NULL || pred->kind != MKR_NK_LITERAL_NUM) return 0;
+  double dn = pred->u.literal_num;
+  if (!(dn >= 1.0) || dn != (double)(size_t)dn) return 0;
+  /* Context must be exactly the document node (the index's scope). */
+  if (seed->count != 1 || seed->items[0] != (MKR_DOM_NODE *)mkr_ctx_document(ctx))
+    return 0;
+  *need = (size_t)dn;
+  return 1;
+}
+
+/* Emit, in document order, each bucket element that is the +need+th of its
+ * parent. When +test+ != NULL only elements matching it count (the HTML tag
+ * bucket may include tag-id-quirk non-matches; node_principal_match re-checks).
+ * The op budget is charged per element. Returns 0, -1 (OOM/limit), or -2
+ * (cap-sizer overflow -> caller falls back to the generic evaluator). */
+static int
+emit_nth_per_parent(mkr_xpath_context_t *ctx, MKR_DOM_NODE *const *bucket, size_t cnt,
+                    size_t need, const mkr_nodetest_t *test, mkr_axis_t axis,
+                    mkr_nodeset_t *result, mkr_xpath_error_t *err)
+{
+  if (cnt == 0) return 0;
+  size_t cap;
+  if (!mkr_pow2_ceil(cnt + (cnt >> 1) + 1, &cap)) return -2;
+  struct nth_slot { const void *parent; size_t count; } *tab =
+      mkr_callocarray(cap, sizeof(*tab));
+  if (tab == NULL) { mkr_err_set(err, MKR_XPATH_ERR_OOM, "out of memory (//name[N])"); return -1; }
+  const size_t mask = cap - 1;
+  mkr_xpath_limits_t *limits = mkr_ctx_limits(ctx);
+  int rc = 0;
+  for (size_t i = 0; i < cnt; ++i) {
+    if (mkr_limit_eval_op(limits, err) != 0) { rc = -1; break; } /* same budget as the walk */
+    MKR_DOM_NODE *e = bucket[i];
+    if (test != NULL && !node_principal_match(test, e, axis, ctx)) continue;
+    const void *par = (const void *)MKR_NODE_PARENT(e);
+    size_t h = (size_t)mkr_ptr_hash(par) & mask;
+    while (tab[h].parent != NULL && tab[h].parent != par) h = (h + 1) & mask;
+    if (tab[h].parent == NULL) { tab[h].parent = par; tab[h].count = 0; }
+    if (++tab[h].count == need) {           /* e is the Nth name-child of its parent */
+      if (mkr_nodeset_push(result, e, limits, err) != 0) { rc = -1; break; }
+    }
+  }
+  free(tab);
+  return rc;
+}
+
+/* Returns 1 (filled *result; the caller consumes the two leading steps),
+ * 0 (not eligible -> caller evaluates normally), -1 (error). */
+#ifdef MKR_HOST_XML
+static int
+try_descendant_index_nth(mkr_xpath_context_t *ctx,
+                         const mkr_step_t *s0, const mkr_step_t *s1,
+                         const mkr_nodeset_t *seed,
+                         mkr_nodeset_t *result, mkr_xpath_error_t *err)
+{
+  size_t need;
+  if (!nth_shape(ctx, s0, s1, seed, &need)) return 0;
+
+  /* Resolve the name test's namespace, mirroring try_descendant_name_index. */
+  const char *ns_uri; size_t ns_uri_len;
+  if (s1->test.prefix.ptr != NULL) {
+    ns_uri = mkr_ctx_lookup_ns(ctx, s1->test.prefix.ptr, s1->test.prefix.len, &ns_uri_len);
+    if (ns_uri == NULL) {
+      mkr_err_setf(err, MKR_XPATH_ERR_RUNTIME,
+                   "unknown namespace prefix '%s' in name test", s1->test.prefix.ptr);
+      return -1;
+    }
+  } else if (mkr_ctx_unprefixed_lax(ctx)) {
+    return 0;                              /* any namespace -> not a single bucket */
+  } else {
+    ns_uri = ""; ns_uri_len = 0;            /* strict unprefixed -> no namespace */
+  }
+
+  void                    *owner  = mkr_ctx_name_index_owner(ctx);
+  mkr_name_index_get_t     get    = mkr_ctx_name_index_get(ctx);
+  mkr_name_index_lookup_t  lookup = mkr_ctx_name_index_lookup(ctx);
+  if (owner == NULL || get == NULL || lookup == NULL) return 0;
+  void *idx = get(owner);
+  if (idx == NULL) return 0;
+
+  size_t cnt = 0;
+  void *const *bucket = lookup(idx, s1->test.local.ptr, s1->test.local.len,
+                               ns_uri, ns_uri_len, &cnt);
+  /* The name-index bucket already holds exactly the matches, so no re-check. */
+  int rc = emit_nth_per_parent(ctx, (MKR_DOM_NODE *const *)bucket, cnt, need,
+                               NULL, s1->axis, result, err);
+  return rc == -2 ? 0 : (rc < 0 ? -1 : 1);
+}
+#else  /* HTML: tag-id index analogue (unprefixed, pure-HTML, static tag range) */
+static int
+try_descendant_index_nth(mkr_xpath_context_t *ctx,
+                         const mkr_step_t *s0, const mkr_step_t *s1,
+                         const mkr_nodeset_t *seed,
+                         mkr_nodeset_t *result, mkr_xpath_error_t *err)
+{
+  size_t need;
+  if (!nth_shape(ctx, s0, s1, seed, &need)) return 0;
+  if (s1->test.prefix.ptr != NULL) return 0;   /* the tag index is unprefixed-only */
+
+  void                    *eidx        = mkr_ctx_element_index(ctx);
+  mkr_tag_index_lookup_t   lookup      = mkr_ctx_tag_lookup(ctx);
+  mkr_tag_index_foreign_t  has_foreign = mkr_ctx_tag_has_foreign(ctx);
+  if (eidx == NULL || lookup == NULL || has_foreign == NULL || has_foreign(eidx)) return 0;
+  MKR_DOM_DOCUMENT *doc = mkr_ctx_document(ctx);
+  if (doc == NULL) return 0;
+  lxb_tag_id_t tag = MKR_DOC_TAG_ID_BY_NAME(doc, s1->test.local.ptr, s1->test.local.len);
+  if (tag == LXB_TAG__UNDEF || (uintptr_t)tag >= LXB_TAG__LAST_ENTRY) return 0;
+
+  size_t cnt = 0;
+  MKR_DOM_NODE *const *bucket = (MKR_DOM_NODE *const *)lookup(eidx, tag, &cnt);
+  /* Re-check each candidate (tag-name lookup can have case/normalization quirks),
+   * so the per-parent count is over the actual matches - byte-identical to the
+   * walk, exactly as try_descendant_tag_index does for the no-predicate case. */
+  int rc = emit_nth_per_parent(ctx, bucket, cnt, need, &s1->test, s1->axis, result, err);
+  return rc == -2 ? 0 : (rc < 0 ? -1 : 1);
+}
+#endif
+
 static int
 eval_steps(mkr_xpath_context_t *ctx, mkr_step_t *steps, size_t nsteps,
            mkr_nodeset_t *seed, mkr_val_t *out, mkr_xpath_error_t *err)
 {
   mkr_nodeset_t current = *seed;  /* take ownership */
   memset(seed, 0, sizeof(*seed));
-  for (size_t s = 0; s < nsteps; ++s) {
+  size_t s_start = 0;
+  /* `//name[N]` (descendant-or-self::node()/child::name[N]) from the document:
+   * serve the two leading steps from the element index (XML: name index; HTML:
+   * tag-id index) with per-parent counting instead of the full-tree walk. */
+  if (nsteps >= 2) {
+    mkr_nodeset_t nth;
+    mkr_nodeset_init(&nth);
+    int fp = try_descendant_index_nth(ctx, &steps[0], &steps[1], &current, &nth, err);
+    if (fp < 0) { mkr_nodeset_clear(&nth); mkr_nodeset_clear(&current); return -1; }
+    if (fp == 1) {
+      mkr_nodeset_clear(&current);
+      current = nth;            /* result of //name[N]; continue from the 3rd step */
+      s_start = 2;
+    } else {
+      mkr_nodeset_clear(&nth);
+    }
+  }
+  for (size_t s = s_start; s < nsteps; ++s) {
     mkr_nodeset_t next;
     mkr_nodeset_init(&next);
     if (eval_step(ctx, &steps[s], &current, &next, err) != 0) {
@@ -923,13 +1222,17 @@ compare_eq(mkr_xpath_context_t *ctx, const mkr_val_t *l, const mkr_val_t *r,
     /* All node string-values go through the per-eval cache. For an
      * M-by-N nodeset comparison this turns O(M*N) computations into
      * at most O(M+N). */
-    (void)L;
+    /* O(M*N) pair scan: string-value CONSTRUCTION is O(M+N) via the cache, but
+     * the comparison loop itself is M*N, so charge each pair to the op budget -
+     * otherwise an all-pairs node-set equality drives up to ~1e14 memcmps as a
+     * handful of ops. */
     for (size_t i = 0; i < l->u.nodeset.count; ++i) {
       mkr_borrowed_text_t ls;
       if (mkr_get_cached_node_text(ctx, l->u.nodeset.items[i], &ls, err) != 0) {
         return -1;
       }
       for (size_t j = 0; j < r->u.nodeset.count; ++j) {
+        if (mkr_limit_eval_op(L, err) != 0) return -1;
         mkr_borrowed_text_t rs;
         if (mkr_get_cached_node_text(ctx, r->u.nodeset.items[j], &rs, err) != 0) {
           return -1;
@@ -949,6 +1252,7 @@ compare_eq(mkr_xpath_context_t *ctx, const mkr_val_t *l, const mkr_val_t *r,
     if (sc->type == MKR_XPATH_TYPE_NUMBER) {
       double target = sc->u.number;
       for (size_t i = 0; i < ns->u.nodeset.count; ++i) {
+        if (mkr_limit_eval_op(L, err) != 0) return -1;
         mkr_borrowed_text_t s;
         if (mkr_get_cached_node_text(ctx, ns->u.nodeset.items[i], &s, err) != 0) {
           return -1;
@@ -969,6 +1273,7 @@ compare_eq(mkr_xpath_context_t *ctx, const mkr_val_t *l, const mkr_val_t *r,
     mkr_owned_text_t target;
     if (mkr_val_to_owned_text_or_fail(sc, L, err, &target) != 0) return -1;
     for (size_t i = 0; i < ns->u.nodeset.count; ++i) {
+      if (mkr_limit_eval_op(L, err) != 0) { mkr_owned_text_clear(&target); return -1; }
       mkr_borrowed_text_t s;
       if (mkr_get_cached_node_text(ctx, ns->u.nodeset.items[i], &s, err) != 0) {
         mkr_owned_text_clear(&target); return -1;
@@ -989,7 +1294,7 @@ compare_eq(mkr_xpath_context_t *ctx, const mkr_val_t *l, const mkr_val_t *r,
   }
   if (l->type == MKR_XPATH_TYPE_NUMBER || r->type == MKR_XPATH_TYPE_NUMBER) {
     /* Both operands are non-nodeset (the nodeset case is handled
-     * above); _unchecked is the right entry — no allocation possible. */
+     * above); _unchecked is the right entry - no allocation possible. */
     double a = mkr_val_to_number_unchecked(l);
     double b = mkr_val_to_number_unchecked(r);
     int eq = (a == b);
@@ -1025,11 +1330,13 @@ compare_rel(mkr_xpath_context_t *ctx, const mkr_val_t *l, const mkr_val_t *r,
 {
   mkr_xpath_limits_t *L = mkr_ctx_limits(ctx);
 
-  /* node-set vs node-set (XPath 1.0 §3.4): true iff SOME pair of nodes — one
-   * from each set — satisfies the relation on their numeric string-values.
+  /* node-set vs node-set (XPath 1.0 §3.4): true iff SOME pair of nodes - one
+   * from each set - satisfies the relation on their numeric string-values.
    * Must compare every pair, not just the first node of each side. */
   if (l->type == MKR_XPATH_TYPE_NODESET && r->type == MKR_XPATH_TYPE_NODESET) {
-    (void)L;
+    /* O(M*N) pair scan (see compare_eq): charge each pair to the op budget so
+     * an all-pairs relational compare cannot drive M*N number conversions as a
+     * handful of ops. */
     for (size_t i = 0; i < l->u.nodeset.count; ++i) {
       mkr_borrowed_text_t ls;
       if (mkr_get_cached_node_text(ctx, l->u.nodeset.items[i], &ls, err) != 0) {
@@ -1037,6 +1344,7 @@ compare_rel(mkr_xpath_context_t *ctx, const mkr_val_t *l, const mkr_val_t *r,
       }
       double a = mkr_borrowed_text_to_number(ls);
       for (size_t j = 0; j < r->u.nodeset.count; ++j) {
+        if (mkr_limit_eval_op(L, err) != 0) return -1;
         mkr_borrowed_text_t rs;
         if (mkr_get_cached_node_text(ctx, r->u.nodeset.items[j], &rs, err) != 0) {
           return -1;
@@ -1058,6 +1366,7 @@ compare_rel(mkr_xpath_context_t *ctx, const mkr_val_t *l, const mkr_val_t *r,
     double scn;
     if (mkr_val_to_number_or_fail(sc, L, err, &scn) != 0) return -1;
     for (size_t i = 0; i < ns->u.nodeset.count; ++i) {
+      if (mkr_limit_eval_op(L, err) != 0) return -1;
       mkr_borrowed_text_t s;
       if (mkr_get_cached_node_text(ctx, ns->u.nodeset.items[i], &s, err) != 0) {
         return -1;
@@ -1095,7 +1404,7 @@ union_nodeset(mkr_xpath_context_t *ctx, mkr_val_t *l, mkr_val_t *r, mkr_val_t *o
   }
   /* Push both sides without per-insert deduplication (the old contains()
    * loop was O(n^2)). Sort once at the end and collapse adjacent
-   * duplicates — total cost is O(n log n) plus a single linear pass. */
+   * duplicates - total cost is O(n log n) plus a single linear pass. */
   mkr_nodeset_t merged;
   mkr_nodeset_init(&merged);
   for (size_t i = 0; i < l->u.nodeset.count; ++i) {
@@ -1122,13 +1431,13 @@ union_nodeset(mkr_xpath_context_t *ctx, mkr_val_t *l, mkr_val_t *r, mkr_val_t *o
 
 static int
 eval_path(mkr_xpath_context_t *ctx, const mkr_node_t *n,
-          lxb_dom_node_t *self_node,
+          MKR_DOM_NODE *self_node,
           mkr_val_t *out, mkr_xpath_error_t *err)
 {
   mkr_nodeset_t seed;
   mkr_nodeset_init(&seed);
   if (n->u.path.absolute) {
-    lxb_dom_node_t *root = (lxb_dom_node_t *)mkr_ctx_document(ctx);
+    MKR_DOM_NODE *root = (MKR_DOM_NODE *)mkr_ctx_document(ctx);
     if (root == NULL) {
       mkr_err_set(err, MKR_XPATH_ERR_RUNTIME, "absolute path with no document");
       return -1;
@@ -1148,11 +1457,11 @@ eval_path(mkr_xpath_context_t *ctx, const mkr_node_t *n,
 
 static int
 eval_filter(mkr_xpath_context_t *ctx, const mkr_node_t *n,
-            lxb_dom_node_t *self_node, size_t self_pos, size_t self_size,
+            const mkr_focus_t *focus,
             mkr_val_t *out, mkr_xpath_error_t *err)
 {
   mkr_val_t primary = {0};
-  if (eval_node(ctx, n->u.filter.expr, self_node, self_pos, self_size, &primary, err) != 0) return -1;
+  if (eval_node(ctx, n->u.filter.expr, focus, &primary, err) != 0) return -1;
   if (n->u.filter.npreds > 0) {
     if (primary.type != MKR_XPATH_TYPE_NODESET) {
       mkr_val_clear(&primary);
@@ -1181,11 +1490,12 @@ eval_filter(mkr_xpath_context_t *ctx, const mkr_node_t *n,
 
 /* ---------- function library bridge ---------- */
 
-extern mkr_func_impl_t mkr_lookup_function(const char *ns_uri, const char *local_name);
+/* mkr_lookup_function is the file-static function table, defined earlier in this
+ * merged engine TU (mkr_xpath_funcs_body.h, included before this body). */
 
 static int
 eval_fncall(mkr_xpath_context_t *ctx, const mkr_node_t *n,
-            lxb_dom_node_t *self_node, size_t self_pos, size_t self_size,
+            const mkr_focus_t *focus,
             mkr_val_t *out, mkr_xpath_error_t *err)
 {
   const char *ns_uri = NULL;
@@ -1208,7 +1518,7 @@ eval_fncall(mkr_xpath_context_t *ctx, const mkr_node_t *n,
       return -1;
     }
     for (size_t i = 0; i < nargs; ++i) {
-      if (eval_node(ctx, n->u.fncall.args[i], self_node, self_pos, self_size, &args[i], err) != 0) {
+      if (eval_node(ctx, n->u.fncall.args[i], focus, &args[i], err) != 0) {
         for (size_t j = 0; j <= i; ++j) mkr_val_clear(&args[j]);
         free(args);
         return -1;
@@ -1218,7 +1528,7 @@ eval_fncall(mkr_xpath_context_t *ctx, const mkr_node_t *n,
 
   int rc;
   if (fn != NULL) {
-    rc = fn(ctx, self_node, self_pos, self_size, args, nargs, out, err);
+    rc = fn(ctx, focus, args, nargs, out, err);
   } else {
     /* No built-in match. Delegate to the per-call resolver (the Ruby
      * handler bridge installs one for the duration of evaluate()). */
@@ -1226,7 +1536,7 @@ eval_fncall(mkr_xpath_context_t *ctx, const mkr_node_t *n,
     int resolved = 1; /* not found by default */
     if (resolver != NULL) {
       resolved = resolver(mkr_xpath_get_user_data(ctx),
-                          ctx, (void *)self_node, self_pos, self_size,
+                          ctx, (void *)focus->node, focus->pos, focus->size,
                           ns_uri, n->u.fncall.name.ptr,
                           (void *)args, nargs, (void *)out, err);
     }
@@ -1248,13 +1558,13 @@ eval_fncall(mkr_xpath_context_t *ctx, const mkr_node_t *n,
 
 static int
 eval_binop(mkr_xpath_context_t *ctx, const mkr_node_t *n,
-           lxb_dom_node_t *self_node, size_t self_pos, size_t self_size,
+           const mkr_focus_t *focus,
            mkr_val_t *out, mkr_xpath_error_t *err)
 {
   /* AND/OR short-circuit. */
   if (n->u.binop.op == MKR_OP_OR || n->u.binop.op == MKR_OP_AND) {
     mkr_val_t l = {0};
-    if (eval_node(ctx, n->u.binop.lhs, self_node, self_pos, self_size, &l, err) != 0) return -1;
+    if (eval_node(ctx, n->u.binop.lhs, focus, &l, err) != 0) return -1;
     int lb = mkr_val_to_boolean(&l);
     mkr_val_clear(&l);
     if (n->u.binop.op == MKR_OP_OR && lb) {
@@ -1264,7 +1574,7 @@ eval_binop(mkr_xpath_context_t *ctx, const mkr_node_t *n,
       out->type = MKR_XPATH_TYPE_BOOLEAN; out->u.boolean = 0; return 0;
     }
     mkr_val_t r = {0};
-    if (eval_node(ctx, n->u.binop.rhs, self_node, self_pos, self_size, &r, err) != 0) return -1;
+    if (eval_node(ctx, n->u.binop.rhs, focus, &r, err) != 0) return -1;
     int rb = mkr_val_to_boolean(&r);
     mkr_val_clear(&r);
     out->type = MKR_XPATH_TYPE_BOOLEAN; out->u.boolean = rb;
@@ -1272,8 +1582,8 @@ eval_binop(mkr_xpath_context_t *ctx, const mkr_node_t *n,
   }
 
   mkr_val_t l = {0}, r = {0};
-  if (eval_node(ctx, n->u.binop.lhs, self_node, self_pos, self_size, &l, err) != 0) return -1;
-  if (eval_node(ctx, n->u.binop.rhs, self_node, self_pos, self_size, &r, err) != 0) {
+  if (eval_node(ctx, n->u.binop.lhs, focus, &l, err) != 0) return -1;
+  if (eval_node(ctx, n->u.binop.rhs, focus, &r, err) != 0) {
     mkr_val_clear(&l); return -1;
   }
   int rc = 0;
@@ -1342,7 +1652,7 @@ eval_binop(mkr_xpath_context_t *ctx, const mkr_node_t *n,
 
 static int
 eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
-          lxb_dom_node_t *self_node, size_t self_pos, size_t self_size,
+          const mkr_focus_t *focus,
           mkr_val_t *out, mkr_xpath_error_t *err)
 {
   /* Budget + recursion bookkeeping. Every AST node visit counts as one
@@ -1354,7 +1664,7 @@ eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
 
   /* Hoisting fast path: a CI subtree that's already been computed in
    * this evaluate is returned as a clone. The clone keeps ownership
-   * semantics clean — mkr_val_clear on either copy is safe. */
+   * semantics clean - mkr_val_clear on either copy is safe. */
   if (n->is_context_independent && n->memoized) {
     int rc = mkr_val_clone(&n->memo_value, out, err);
     mkr_limit_recurse_leave(L);
@@ -1399,11 +1709,11 @@ eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
     break;
   }
   case MKR_NK_FNCALL:
-    rc = eval_fncall(ctx, n, self_node, self_pos, self_size, out, err);
+    rc = eval_fncall(ctx, n, focus, out, err);
     break;
   case MKR_NK_UNARY: {
     mkr_val_t v = {0};
-    if (eval_node(ctx, n->u.unary.expr, self_node, self_pos, self_size, &v, err) != 0) {
+    if (eval_node(ctx, n->u.unary.expr, focus, &v, err) != 0) {
       rc = -1;
       break;
     }
@@ -1420,13 +1730,13 @@ eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
     break;
   }
   case MKR_NK_BINOP:
-    rc = eval_binop(ctx, n, self_node, self_pos, self_size, out, err);
+    rc = eval_binop(ctx, n, focus, out, err);
     break;
   case MKR_NK_PATH:
-    rc = eval_path(ctx, n, self_node, out, err);
+    rc = eval_path(ctx, n, focus->node, out, err);
     break;
   case MKR_NK_FILTER:
-    rc = eval_filter(ctx, n, self_node, self_pos, self_size, out, err);
+    rc = eval_filter(ctx, n, focus, out, err);
     break;
   default:
     mkr_err_set(err, MKR_XPATH_ERR_INTERNAL, "unknown AST node");
@@ -1435,7 +1745,7 @@ eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
   }
 
   /* Memoize on success when the subtree is CI. The clone keeps the
-   * caller's out value independent of the cached one — important
+   * caller's out value independent of the cached one - important
    * because the caller is free to consume/modify their copy. */
   if (rc == 0 && n->is_context_independent && !n->memoized) {
     mkr_val_t memo = {0};
@@ -1446,7 +1756,7 @@ eval_node(mkr_xpath_context_t *ctx, const mkr_node_t *n,
       mut->memo_value = memo;
       mut->memoized   = 1;
     } else {
-      /* OOM during clone — the caller's `out` is still valid. We
+      /* OOM during clone - the caller's `out` is still valid. We
        * leave the node unmemoized and surface the error. */
       rc = -1;
     }
@@ -1460,6 +1770,6 @@ int
 mkr_eval_ast(mkr_xpath_context_t *ctx, const mkr_node_t *ast,
             mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  lxb_dom_node_t *self_node = mkr_ctx_node(ctx);
-  return eval_node(ctx, ast, self_node, 1, 1, out, err);
+  mkr_focus_t focus = { mkr_ctx_node(ctx), 1, 1 };
+  return eval_node(ctx, ast, &focus, out, err);
 }