makiri 0.2.0 → 0.4.0

data/ext/makiri/xpath/{mkr_xpath_funcs.c → mkr_xpath_funcs_body.h}

@@ -14,48 +14,10 @@
  * functions are added in Phase 2.
  */
 
-/* Count Unicode code points in a UTF-8 string. XPath 1.0 string-length
- * and substring offsets are measured in characters, not bytes — Lexbor
- * exposes content as UTF-8 byte strings, so we walk and count leading
- * bytes (any byte that isn't a 10xxxxxx continuation). */
-static size_t
-utf8_char_count(const char *s)
-{
-  if (s == NULL) return 0;
-  size_t n = 0;
-  for (const unsigned char *p = (const unsigned char *)s; *p; ++p) {
-    if ((*p & 0xC0) != 0x80) ++n;
-  }
-  return n;
-}
-
-/* Step forward by n UTF-8 characters from s; returns byte pointer.
- * Returns the trailing NUL if n exceeds the string length. */
-static const char *
-utf8_advance(const char *s, size_t n)
-{
-  const unsigned char *p = (const unsigned char *)s;
-  while (n > 0 && *p) {
-    do { ++p; } while ((*p & 0xC0) == 0x80);
-    --n;
-  }
-  return (const char *)p;
-}
-
-static const char *
-mkr_text_find(const char *hay, size_t hay_len, const char *needle, size_t needle_len)
-{
-  if (hay == NULL || needle == NULL) return NULL;
-  if (needle_len == 0) return hay;
-  if (needle_len > hay_len) return NULL;
-  size_t last = hay_len - needle_len;
-  for (size_t i = 0; i <= last; ++i) {
-    if (hay[i] == needle[0] && memcmp(hay + i, needle, needle_len) == 0) {
-      return hay + i;
-    }
-  }
-  return NULL;
-}
+/* Character-counting (mkr_utf8_count_chars), character-advance
+ * (mkr_utf8_advance_chars) and substring search (mkr_bytes_find) are
+ * length-bounded core primitives - see core/mkr_utf8.h and core/mkr_span.h.
+ * The byte-equality compares below go through mkr_bytes_eq (core/mkr_span.h). */
 
 static int
 arity_check(size_t got, size_t want_min, size_t want_max, mkr_xpath_error_t *err, const char *name)
@@ -71,52 +33,71 @@ arity_check(size_t got, size_t want_min, size_t want_max, mkr_xpath_error_t *err
   return 0;
 }
 
+/* Require +arg+ to be a node-set; returns it, or NULL with a TYPE error naming
+ * +fname+. The single front for the "argument must be a node-set" check that
+ * count()/sum()/the name functions all share. */
+static const mkr_nodeset_t *
+require_nodeset(const mkr_val_t *arg, const char *fname, mkr_xpath_error_t *err)
+{
+  if (arg->type != MKR_XPATH_TYPE_NODESET) {
+    mkr_err_setf(err, MKR_XPATH_ERR_TYPE, "%s(): argument must be a node-set", fname);
+    return NULL;
+  }
+  return &arg->u.nodeset;
+}
+
+/* string-value of args[0], or of the context node when there is no argument -
+ * the "optional node-set arg defaults to self, as a string" idiom shared by
+ * string() / string-length() / normalize-space(). */
+static int
+fn_string_arg_or_self(MKR_DOM_NODE *self_node, const mkr_val_t *args, size_t nargs,
+                      mkr_xpath_limits_t *L, mkr_xpath_error_t *err, mkr_owned_text_t *out)
+{
+  return (nargs == 0)
+      ? mkr_node_to_owned_text_or_fail(self_node, L, err, out)
+      : mkr_val_to_owned_text_or_fail(&args[0], L, err, out);
+}
+
 static int
-fn_last(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-        size_t self_pos, size_t self_size,
+fn_last(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
         mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_node; (void)self_pos; (void)args;
+  (void)ctx; (void)args;
   if (arity_check(nargs, 0, 0, err, "last") != 0) return -1;
   out->type = MKR_XPATH_TYPE_NUMBER;
-  out->u.number = (double)self_size;
+  out->u.number = (double)focus->size;
   return 0;
 }
 
 static int
-fn_position(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-            size_t self_pos, size_t self_size,
+fn_position(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
             mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_node; (void)self_size; (void)args;
+  (void)ctx; (void)args;
   if (arity_check(nargs, 0, 0, err, "position") != 0) return -1;
   out->type = MKR_XPATH_TYPE_NUMBER;
-  out->u.number = (double)self_pos;
+  out->u.number = (double)focus->pos;
   return 0;
 }
 
 static int
-fn_count(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-         size_t self_pos, size_t self_size,
+fn_count(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
          mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_node; (void)self_pos; (void)self_size;
+  (void)ctx; (void)focus;
   if (arity_check(nargs, 1, 1, err, "count") != 0) return -1;
-  if (args[0].type != MKR_XPATH_TYPE_NODESET) {
-    mkr_err_set(err, MKR_XPATH_ERR_TYPE, "count(): argument must be a node-set");
-    return -1;
-  }
+  const mkr_nodeset_t *ns = require_nodeset(&args[0], "count", err);
+  if (ns == NULL) return -1;
   out->type = MKR_XPATH_TYPE_NUMBER;
-  out->u.number = (double)args[0].u.nodeset.count;
+  out->u.number = (double)ns->count;
   return 0;
 }
 
 static int
-fn_not(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-       size_t self_pos, size_t self_size,
+fn_not(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
        mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_node; (void)self_pos; (void)self_size;
+  (void)ctx; (void)focus;
   if (arity_check(nargs, 1, 1, err, "not") != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
   out->u.boolean = !mkr_val_to_boolean(&args[0]);
@@ -124,11 +105,10 @@ fn_not(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_true(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-        size_t self_pos, size_t self_size,
+fn_true(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
         mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_node; (void)self_pos; (void)self_size; (void)args;
+  (void)ctx; (void)focus; (void)args;
   if (arity_check(nargs, 0, 0, err, "true") != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
   out->u.boolean = 1;
@@ -136,91 +116,113 @@ fn_true(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_false(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-         size_t self_pos, size_t self_size,
+fn_false(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
          mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_node; (void)self_pos; (void)self_size; (void)args;
+  (void)ctx; (void)focus; (void)args;
   if (arity_check(nargs, 0, 0, err, "false") != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
   out->u.boolean = 0;
   return 0;
 }
 
-/* id(string|nodeset) — looks up by HTML id attribute. */
-static lxb_dom_node_t *
-find_by_id(lxb_dom_node_t *root, const char *id, size_t id_len)
+#ifndef MKR_HOST_XML
+/* id() helpers are HTML-only: the XML instance's id() is the empty node-set
+ * (no DTD-declared IDs, §8.6), so it never walks the tree by id attribute.
+ * Guarded so the XML engine TU does not carry (and warn about) dead code. */
+
+/* id(string|nodeset) - looks up by HTML id attribute. Walks the whole tree per
+ * token, so it charges each visited node to the op budget and fails closed on
+ * overrun (returns -1, *out untouched-meaningful); a hit sets *out, a miss
+ * leaves *out NULL. Without this, id() over a large node-set (a token per node,
+ * a tree walk per token) drives O(nodes^2) work as ~0 ops. */
+static int
+find_by_id(MKR_DOM_NODE *root, const char *id, size_t id_len,
+           mkr_xpath_limits_t *L, mkr_xpath_error_t *err, MKR_DOM_NODE **out)
 {
-  if (root == NULL || id == NULL || id_len == 0) return NULL;
-  lxb_dom_node_t *n = root;
+  *out = NULL;
+  if (root == NULL || id == NULL || id_len == 0) return 0;
+  MKR_DOM_NODE *n = root;
   while (n) {
-    if (n->type == LXB_DOM_NODE_TYPE_ELEMENT) {
-      lxb_dom_element_t *el = (lxb_dom_element_t *)n;
+    if (mkr_limit_eval_op(L, err) != 0) return -1;
+    if (MKR_NODE_TYPE(n) == MKR_NTYPE_ELEMENT) {
+      MKR_DOM_ELEMENT *el = MKR_NODE_AS_ELEMENT(n);
       size_t vlen = 0;
-      const lxb_char_t *v = lxb_dom_element_get_attribute(el, (const lxb_char_t *)"id", 2, &vlen);
-      if (v && vlen == id_len && memcmp(v, id, id_len) == 0) {
-        return n;
+      const lxb_char_t *v = MKR_ELEM_GET_ATTRIBUTE(el, "id", 2, &vlen);
+      if (v && mkr_bytes_eq(v, vlen, id, id_len)) {
+        *out = n;
+        return 0;
       }
     }
-    if (n->first_child) {
-      n = n->first_child;
+    if (MKR_NODE_FIRST_CHILD(n)) {
+      n = MKR_NODE_FIRST_CHILD(n);
     } else {
-      while (n && n != root && n->next == NULL) n = n->parent;
+      while (n && n != root && MKR_NODE_NEXT(n) == NULL) n = MKR_NODE_PARENT(n);
       if (n == root || n == NULL) break;
-      n = n->next;
+      n = MKR_NODE_NEXT(n);
     }
   }
-  return NULL;
+  return 0;
 }
 
 /*
- * Look up each whitespace-separated token in 's' (mutated) and push
- * every hit into 'out'. Duplicates are pushed unconditionally — the
- * caller (fn_id) deduplicates the entire result via sort + adjacent
- * pass after all tokens have been processed, which is O(n log n)
- * versus O(n^2) per-insert contains() checks.
+ * Look up each whitespace-separated token in the borrowed text 's' and push
+ * every hit into 'out'. Duplicates are pushed unconditionally - the caller (fn_id) deduplicates
+ * the entire result via sort + adjacent pass after all tokens have been
+ * processed, which is O(n log n) versus O(n^2) per-insert contains() checks.
+ *
+ * Length-bounded over an mkr_span_t: each token is captured as a borrowed slice
+ * (mark/since) and handed to find_by_id by ptr+len, so the buffer is never
+ * mutated (the earlier temp-NUL splice was vestigial - find_by_id already
+ * compares by explicit length, never as a C string).
  */
 static int
-id_collect_from_string(char *s, lxb_dom_node_t *root, mkr_nodeset_t *out,
-                       mkr_xpath_context_t *ctx, mkr_xpath_error_t *err)
+id_collect_from_string(mkr_borrowed_text_t s, MKR_DOM_NODE *root,
+                       mkr_nodeset_t *out, mkr_xpath_context_t *ctx,
+                       mkr_xpath_error_t *err)
 {
-  if (s == NULL) return 0;
-  char *p = s;
-  while (*p) {
-    while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') p++;
-    if (*p == '\0') break;
-    char *tok = p;
-    while (*p && *p != ' ' && *p != '\t' && *p != '\n' && *p != '\r') p++;
-    size_t tok_len = (size_t)(p - tok);
-    char saved = *p;
-    *p = '\0';
-    lxb_dom_node_t *hit = find_by_id(root, tok, tok_len);
-    if (hit) {
-      if (mkr_nodeset_push(out, hit, mkr_ctx_limits(ctx), err) != 0) {
-        return -1;
-      }
+  mkr_span_t sp = mkr_span(s.ptr, s.len);
+  for (;;) {
+    mkr_span_skip_xpath_ws(&sp);
+    if (mkr_span_peek(&sp) < 0) break;
+    const char *tok = mkr_span_mark(&sp);
+    while (mkr_span_peek(&sp) >= 0 && !mkr_xpath_is_ws(mkr_span_peek(&sp)))
+      mkr_span_skip(&sp, 1);
+    size_t tok_len = mkr_span_since(&sp, tok);
+    MKR_DOM_NODE *hit;
+    if (find_by_id(root, tok, tok_len, mkr_ctx_limits(ctx), err, &hit) != 0) {
+      return -1;
+    }
+    if (hit && mkr_nodeset_push(out, hit, mkr_ctx_limits(ctx), err) != 0) {
+      return -1;
     }
-    if (saved == '\0') break;
-    *p++ = saved;
   }
   return 0;
 }
+#endif /* !MKR_HOST_XML */
 
 static int
-fn_id(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-      size_t self_pos, size_t self_size,
+fn_id(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
       mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 1, 1, err, "id") != 0) return -1;
   out->type = MKR_XPATH_TYPE_NODESET;
   mkr_nodeset_init(&out->u.nodeset);
 
-  lxb_dom_node_t *root = (lxb_dom_node_t *)mkr_ctx_document(ctx);
+#ifdef MKR_HOST_XML
+  /* Host policy (§8.6): in XML an ID is an attribute DECLARED ID-typed by the
+   * DTD/schema - not any attribute named "id". DTDs are rejected at parse
+   * (§9.4), so a document read here carries no ID-typed attributes and id() is
+   * the empty node-set. (xml:id is a separate, optional spec, not implemented.) */
+  (void)ctx; (void)args;
+  return 0;
+#else
+  MKR_DOM_NODE *root = (MKR_DOM_NODE *)mkr_ctx_document(ctx);
   if (root == NULL) return 0;
 
   /* XPath 1.0 §4.1: id() argument may be a node-set; in that case each
-   * node's string-value is treated as IDREFS — whitespace-separated tokens.
+   * node's string-value is treated as IDREFS - whitespace-separated tokens.
    * For non-node-set, the value is converted to string and split likewise. */
   if (args[0].type == MKR_XPATH_TYPE_NODESET) {
     for (size_t i = 0; i < args[0].u.nodeset.count; ++i) {
@@ -229,7 +231,7 @@ fn_id(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
         mkr_nodeset_clear(&out->u.nodeset);
         return -1;
       }
-      int rc = id_collect_from_string(text.ptr, root, &out->u.nodeset, ctx, err);
+      int rc = id_collect_from_string(mkr_borrowed_text_from_owned(text), root, &out->u.nodeset, ctx, err);
       mkr_owned_text_clear(&text);
       if (rc != 0) { mkr_nodeset_clear(&out->u.nodeset); return -1; }
     }
@@ -239,13 +241,14 @@ fn_id(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
       mkr_nodeset_clear(&out->u.nodeset);
       return -1;
     }
-    int rc = id_collect_from_string(text.ptr, root, &out->u.nodeset, ctx, err);
+    int rc = id_collect_from_string(mkr_borrowed_text_from_owned(text), root, &out->u.nodeset, ctx, err);
     mkr_owned_text_clear(&text);
     if (rc != 0) { mkr_nodeset_clear(&out->u.nodeset); return -1; }
   }
   /* Result is in document order with duplicates removed (XPath 1.0 §4.1). */
   mkr_nodeset_unique_sorted(ctx, &out->u.nodeset);
   return 0;
+#endif /* MKR_HOST_XML */
 }
 
 /* Forward decl for two_owned_texts() defined later. */
@@ -256,69 +259,68 @@ static int two_owned_texts(mkr_xpath_context_t *ctx, mkr_val_t *args,
 /* ---------- nokogiri-builtin namespace ---------- */
 
 /*
- * css-class(haystack, needle) — true iff 'needle' is a whitespace-
+ * css-class(haystack, needle) - true iff 'needle' is a whitespace-
  * separated token of 'haystack'. The libxml2 version of this function
  * ships in nl_xpath_context.c (builtin_css_class); we keep behavior
  * identical.
  */
 static int
-ws_token_match(const char *str, const char *val, size_t val_len)
+ws_token_match(mkr_borrowed_text_t hay, mkr_borrowed_text_t val)
 {
-  if (str == NULL || val == NULL) return 0;
-  if (val_len == 0) return 1; /* libxml2 returns non-NULL for empty val */
-
-  const char *p = str;
-  while (*p) {
-    const char *tok = p;
-    while (*p && !(*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++;
-    size_t tok_len = (size_t)(p - tok);
-    if (tok_len == val_len && tok_len > 0 && tok[0] == val[0]
-        && memcmp(tok, val, val_len) == 0) {
+  /* NULL ordering preserved from the original: a NULL haystack/needle is a
+   * non-match BEFORE the empty-needle short-circuit (so empty val + NULL hay
+   * stays 0, not 1). */
+  if (hay.ptr == NULL || val.ptr == NULL) return 0;
+  if (val.len == 0) return 1; /* libxml2 returns non-NULL for empty val */
+
+  mkr_span_t sp = mkr_span(hay.ptr, hay.len);
+  while (mkr_span_peek(&sp) >= 0) {
+    const char *tok = mkr_span_mark(&sp);
+    while (mkr_span_peek(&sp) >= 0 && !mkr_xpath_is_ws(mkr_span_peek(&sp)))
+      mkr_span_skip(&sp, 1);
+    if (mkr_bytes_eq(tok, mkr_span_since(&sp, tok), val.ptr, val.len)) {
       return 1;
     }
-    /* skip whitespace */
-    while (*p && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) p++;
+    mkr_span_skip_xpath_ws(&sp);
   }
   return 0;
 }
 
 static int
-fn_nokogiri_css_class(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-                     size_t self_pos, size_t self_size,
+fn_nokogiri_css_class(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                      mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 2, 2, err, "nokogiri-builtin:css-class") != 0) return -1;
   mkr_owned_text_t hay, needle;
   if (two_owned_texts(ctx, args, &hay, &needle, err) != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
-  out->u.boolean = ws_token_match(hay.ptr, needle.ptr, needle.len);
+  out->u.boolean = ws_token_match(mkr_borrowed_text_from_owned(hay),
+                                 mkr_borrowed_text_from_owned(needle));
   mkr_owned_text_clear(&hay);
   mkr_owned_text_clear(&needle);
   return 0;
 }
 
 /*
- * local-name-is(elementName) — true iff the context node's qualified
+ * local-name-is(elementName) - true iff the context node's qualified
  * name (for HTML this is the lowercase local name) equals the argument.
  */
 static int
-fn_nokogiri_local_name_is(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-                          size_t self_pos, size_t self_size,
+fn_nokogiri_local_name_is(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                           mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_pos; (void)self_size;
   if (arity_check(nargs, 1, 1, err, "nokogiri-builtin:local-name-is") != 0) return -1;
   mkr_owned_text_t want;
   if (mkr_val_to_owned_text_or_fail(&args[0], mkr_ctx_limits(ctx), err, &want) != 0) return -1;
 
   out->type = MKR_XPATH_TYPE_BOOLEAN;
   out->u.boolean = 0;
-  if (self_node != NULL) {
+  if (focus->node != NULL) {
     size_t got_len = 0;
-    const lxb_char_t *got = mkr_dom_node_name_qualified(self_node, &got_len);
+    const lxb_char_t *got = MKR_ELEM_QUALIFIED_NAME(focus->node, &got_len);
     if (got != NULL) {
-      out->u.boolean = (got_len == want.len && memcmp(got, want.ptr, want.len) == 0);
+      out->u.boolean = mkr_bytes_eq(got, got_len, want.ptr, want.len);
     }
   }
   mkr_owned_text_clear(&want);
@@ -336,12 +338,65 @@ static const fn_entry_t fn_table_nokogiri_builtin[] = {
   { NULL,            NULL                      },
 };
 
+#ifdef MKR_HOST_XML
+/* ---------- internal: untyped :*-of-type position (XML, CSS-only) ---------- *
+ * Two elements are the same "type" iff they share an expanded name (local name
+ * + namespace URI). These back the CSS-lowered untyped of-type pseudo-classes;
+ * see MKR_FN_OF_TYPE_POS in mkr_xpath_internal.h for why they cannot be a pure
+ * XPath expression. focus->node is the context element being filtered. */
 static int
-fn_boolean(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-           size_t self_pos, size_t self_size,
+mkr_xml_same_type(MKR_DOM_NODE *a, MKR_DOM_NODE *b)
+{
+  size_t al = 0, bl = 0;
+  const lxb_char_t *an = MKR_ELEM_LOCAL_NAME(a, &al);
+  const lxb_char_t *bn = MKR_ELEM_LOCAL_NAME(b, &bl);
+  if (!mkr_bytes_eq(an, al, bn, bl)) return 0;
+  size_t au = 0, bu = 0;
+  const char *ap = MKR_NODE_NS_URI(a, NULL, &au);
+  const char *bp = MKR_NODE_NS_URI(b, NULL, &bu);
+  return mkr_bytes_eq(ap, au, bp, bu);
+}
+
+/* 1-based position of +self+ among its same-type element siblings; forward walks
+ * preceding siblings (position from the start), else following (from the end). */
+static double
+mkr_xml_of_type_pos(MKR_DOM_NODE *self, int forward)
+{
+  if (self == NULL || MKR_NODE_TYPE(self) != MKR_NTYPE_ELEMENT) return 0.0;
+  long pos = 1;
+  for (MKR_DOM_NODE *s = forward ? MKR_NODE_PREV(self) : MKR_NODE_NEXT(self);
+       s != NULL; s = forward ? MKR_NODE_PREV(s) : MKR_NODE_NEXT(s)) {
+    if (MKR_NODE_TYPE(s) == MKR_NTYPE_ELEMENT && mkr_xml_same_type(self, s)) pos++;
+  }
+  return (double)pos;
+}
+
+static int
+fn_xml_of_type_pos(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
+                   mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
+{
+  (void)ctx; (void)args; (void)nargs; (void)err;
+  out->type = MKR_XPATH_TYPE_NUMBER;
+  out->u.number = mkr_xml_of_type_pos(focus->node, 1);
+  return 0;
+}
+
+static int
+fn_xml_of_type_pos_last(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
+                        mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
+{
+  (void)ctx; (void)args; (void)nargs; (void)err;
+  out->type = MKR_XPATH_TYPE_NUMBER;
+  out->u.number = mkr_xml_of_type_pos(focus->node, 0);
+  return 0;
+}
+#endif /* MKR_HOST_XML */
+
+static int
+fn_boolean(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
            mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_node; (void)self_pos; (void)self_size;
+  (void)ctx; (void)focus;
   if (arity_check(nargs, 1, 1, err, "boolean") != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
   out->u.boolean = mkr_val_to_boolean(&args[0]);
@@ -351,29 +406,22 @@ fn_boolean(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 /* ---------- string functions ---------- */
 
 static int
-fn_string(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-          size_t self_pos, size_t self_size,
+fn_string(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
           mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_pos; (void)self_size;
   if (arity_check(nargs, 0, 1, err, "string") != 0) return -1;
   out->type = MKR_XPATH_TYPE_STRING;
   mkr_owned_text_t text;
-  if (nargs == 0) {
-    if (mkr_node_to_owned_text_or_fail(self_node, mkr_ctx_limits(ctx), err, &text) != 0) return -1;
-  } else {
-    if (mkr_val_to_owned_text_or_fail(&args[0], mkr_ctx_limits(ctx), err, &text) != 0) return -1;
-  }
+  if (fn_string_arg_or_self(focus->node, args, nargs, mkr_ctx_limits(ctx), err, &text) != 0) return -1;
   mkr_val_set_owned_text(out, text);
   return 0;
 }
 
 static int
-fn_concat(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-          size_t self_pos, size_t self_size,
+fn_concat(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
           mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (nargs < 2) {
     mkr_err_set(err, MKR_XPATH_ERR_RUNTIME, "concat(): expected at least 2 arguments");
     return -1;
@@ -439,48 +487,49 @@ two_owned_texts(mkr_xpath_context_t *ctx, mkr_val_t *args,
 }
 
 static int
-fn_starts_with(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-               size_t self_pos, size_t self_size,
+fn_starts_with(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 2, 2, err, "starts-with") != 0) return -1;
   mkr_owned_text_t s, t;
   if (two_owned_texts(ctx, args, &s, &t, err) != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
-  out->u.boolean = (s.len >= t.len && memcmp(s.ptr, t.ptr, t.len) == 0);
+  mkr_span_t ss = mkr_span(s.ptr, s.len);
+  out->u.boolean = mkr_span_starts(&ss, t.ptr, t.len);
   mkr_owned_text_clear(&s);
   mkr_owned_text_clear(&t);
   return 0;
 }
 
 static int
-fn_contains(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-            size_t self_pos, size_t self_size,
+fn_contains(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
             mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 2, 2, err, "contains") != 0) return -1;
   mkr_owned_text_t s, t;
   if (two_owned_texts(ctx, args, &s, &t, err) != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
-  out->u.boolean = (mkr_text_find(s.ptr, s.len, t.ptr, t.len) != NULL);
+  size_t idx;
+  out->u.boolean = mkr_bytes_find(s.ptr, s.len, t.ptr, t.len, &idx);
   mkr_owned_text_clear(&s);
   mkr_owned_text_clear(&t);
   return 0;
 }
 
 static int
-fn_substring_before(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-                    size_t self_pos, size_t self_size,
+fn_substring_before(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                     mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 2, 2, err, "substring-before") != 0) return -1;
   mkr_owned_text_t s, t;
   if (two_owned_texts(ctx, args, &s, &t, err) != 0) return -1;
-  const char *found = (t.len == 0) ? NULL : mkr_text_find(s.ptr, s.len, t.ptr, t.len);
-  size_t n = (found != NULL) ? (size_t)(found - s.ptr) : 0;
+  /* substring-before(s, t): bytes of s up to the first occurrence of t, or ""
+   * when t is empty or absent. */
+  size_t n = 0, idx;
+  if (t.len != 0 && mkr_bytes_find(s.ptr, s.len, t.ptr, t.len, &idx)) n = idx;
   char *p = mkr_strndup(s.ptr, n); /* n == 0 yields an owned "" */
   mkr_owned_text_clear(&s);
   mkr_owned_text_clear(&t);
@@ -493,11 +542,10 @@ fn_substring_before(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_substring_after(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-                   size_t self_pos, size_t self_size,
+fn_substring_after(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                    mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 2, 2, err, "substring-after") != 0) return -1;
   mkr_owned_text_t s, t;
   if (two_owned_texts(ctx, args, &s, &t, err) != 0) return -1;
@@ -507,9 +555,14 @@ fn_substring_after(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
     out_len = s.len;
     p = mkr_strndup(s.ptr, s.len);
   } else {
-    const char *found = mkr_text_find(s.ptr, s.len, t.ptr, t.len);
-    out_len = found ? s.len - (size_t)((found + t.len) - s.ptr) : 0;
-    p = found ? mkr_strndup(found + t.len, out_len) : mkr_strdup("");
+    size_t idx;
+    if (mkr_bytes_find(s.ptr, s.len, t.ptr, t.len, &idx)) {
+      out_len = s.len - (idx + t.len);
+      p = mkr_strndup(s.ptr + idx + t.len, out_len);
+    } else {
+      out_len = 0;
+      p = mkr_strdup("");
+    }
   }
   mkr_owned_text_clear(&s);
   mkr_owned_text_clear(&t);
@@ -521,21 +574,20 @@ fn_substring_after(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
   return 0;
 }
 
-/* substring(s, start[, length]) — XPath positions are 1-based and round
+/* substring(s, start[, length]) - XPath positions are 1-based and round
  * to nearest; out-of-range positions clip to the string. */
 static int
-fn_substring(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-             size_t self_pos, size_t self_size,
+fn_substring(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
              mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 2, 3, err, "substring") != 0) return -1;
   mkr_xpath_limits_t *L = mkr_ctx_limits(ctx);
   mkr_owned_text_t s;
   if (mkr_val_to_owned_text_or_fail(&args[0], L, err, &s) != 0) return -1;
   double start_d, end_d;
   if (mkr_val_to_number_or_fail(&args[1], L, err, &start_d) != 0) { mkr_owned_text_clear(&s); return -1; }
-  size_t s_chars = utf8_char_count(s.ptr);
+  size_t s_chars = mkr_utf8_count_chars(s.ptr, s.len);
   if (nargs == 3) {
     double len_d;
     if (mkr_val_to_number_or_fail(&args[2], L, err, &len_d) != 0) { mkr_owned_text_clear(&s); return -1; }
@@ -567,10 +619,12 @@ fn_substring(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
     if (end <= start) {
       p = mkr_strdup("");
     } else {
-      const char *byte_start = utf8_advance(s.ptr, (size_t)(start - 1));
-      const char *byte_end   = utf8_advance(byte_start, (size_t)(end - start));
-      out_len = (size_t)(byte_end - byte_start);
-      p = mkr_strndup(byte_start, out_len);
+      size_t start_off = mkr_utf8_advance_chars(s.ptr, s.len, (size_t)(start - 1));
+      size_t end_off   = start_off + mkr_utf8_advance_chars(s.ptr + start_off,
+                                                            s.len - start_off,
+                                                            (size_t)(end - start));
+      out_len = end_off - start_off;
+      p = mkr_strndup(s.ptr + start_off, out_len);
     }
   }
   mkr_owned_text_clear(&s);
@@ -583,38 +637,26 @@ fn_substring(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_string_length(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-                 size_t self_pos, size_t self_size,
+fn_string_length(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                  mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_pos; (void)self_size;
   if (arity_check(nargs, 0, 1, err, "string-length") != 0) return -1;
-  mkr_xpath_limits_t *L = mkr_ctx_limits(ctx);
   mkr_owned_text_t s;
-  int rc = (nargs == 0)
-              ? mkr_node_to_owned_text_or_fail(self_node, L, err, &s)
-              : mkr_val_to_owned_text_or_fail(&args[0], L, err, &s);
-  if (rc != 0) return -1;
+  if (fn_string_arg_or_self(focus->node, args, nargs, mkr_ctx_limits(ctx), err, &s) != 0) return -1;
   out->type = MKR_XPATH_TYPE_NUMBER;
-  out->u.number = (double)utf8_char_count(s.ptr);
+  out->u.number = (double)mkr_utf8_count_chars(s.ptr, s.len);
   mkr_owned_text_clear(&s);
   return 0;
 }
 
 /* normalize-space: collapse runs of whitespace, trim leading/trailing */
 static int
-fn_normalize_space(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-                   size_t self_pos, size_t self_size,
+fn_normalize_space(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                    mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_pos; (void)self_size;
   if (arity_check(nargs, 0, 1, err, "normalize-space") != 0) return -1;
-  mkr_xpath_limits_t *L = mkr_ctx_limits(ctx);
   mkr_owned_text_t s;
-  int rc = (nargs == 0)
-              ? mkr_node_to_owned_text_or_fail(self_node, L, err, &s)
-              : mkr_val_to_owned_text_or_fail(&args[0], L, err, &s);
-  if (rc != 0) return -1;
+  if (fn_string_arg_or_self(focus->node, args, nargs, mkr_ctx_limits(ctx), err, &s) != 0) return -1;
   char  *buf = mkr_str_alloc(s.len);
   if (buf == NULL) { mkr_owned_text_clear(&s); mkr_err_set(err, MKR_XPATH_ERR_OOM, "out of memory in normalize-space"); return -1; }
   size_t out_i = 0;
@@ -638,11 +680,10 @@ fn_normalize_space(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_translate(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-             size_t self_pos, size_t self_size,
+fn_translate(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
              mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 3, 3, err, "translate") != 0) return -1;
   mkr_xpath_limits_t *L = mkr_ctx_limits(ctx);
   mkr_owned_text_t s, from, to;
@@ -675,7 +716,7 @@ fn_translate(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
   }
 
   /* The string-literal lexer validates UTF-8 and DOM string-values are valid
-   * UTF-8, so a decode error here should not happen — but if it does, fail
+   * UTF-8, so a decode error here should not happen - but if it does, fail
    * closed (RUNTIME error) rather than silently truncating the result. */
   size_t from_n = 0;
   for (const lxb_char_t *p = (const lxb_char_t *)from.ptr, *e = p + from.len; p < e;) {
@@ -750,18 +791,16 @@ decode_fail:
 /* ---------- number functions ---------- */
 
 static int
-fn_number(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-          size_t self_pos, size_t self_size,
+fn_number(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
           mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_pos; (void)self_size;
   if (arity_check(nargs, 0, 1, err, "number") != 0) return -1;
   out->type = MKR_XPATH_TYPE_NUMBER;
   mkr_xpath_limits_t *L = mkr_ctx_limits(ctx);
   if (nargs == 0) {
     mkr_val_t self_v = { .type = MKR_XPATH_TYPE_NODESET };
     mkr_nodeset_init(&self_v.u.nodeset);
-    if (self_node && mkr_nodeset_push(&self_v.u.nodeset, self_node, L, err) != 0) {
+    if (focus->node && mkr_nodeset_push(&self_v.u.nodeset, focus->node, L, err) != 0) {
       mkr_nodeset_clear(&self_v.u.nodeset);
       return -1;
     }
@@ -773,22 +812,20 @@ fn_number(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_sum(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-       size_t self_pos, size_t self_size,
+fn_sum(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
        mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 1, 1, err, "sum") != 0) return -1;
-  if (args[0].type != MKR_XPATH_TYPE_NODESET) {
-    mkr_err_set(err, MKR_XPATH_ERR_TYPE, "sum(): argument must be a node-set");
-    return -1;
-  }
+  const mkr_nodeset_t *ns = require_nodeset(&args[0], "sum", err);
+  if (ns == NULL) return -1;
   /* mkr_get_cached_node_text consults ctx->limits internally for the
    * cache-miss path; no need to thread max_string_bytes here. */
   double total = 0.0;
-  for (size_t i = 0; i < args[0].u.nodeset.count; ++i) {
+  for (size_t i = 0; i < ns->count; ++i) {
+    if (mkr_limit_eval_op(mkr_ctx_limits(ctx), err) != 0) return -1;
     mkr_borrowed_text_t s;
-    if (mkr_get_cached_node_text(ctx, args[0].u.nodeset.items[i], &s, err) != 0) {
+    if (mkr_get_cached_node_text(ctx, ns->items[i], &s, err) != 0) {
       return -1;
     }
     total += mkr_borrowed_text_to_number(s);
@@ -799,11 +836,10 @@ fn_sum(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_floor(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-         size_t self_pos, size_t self_size,
+fn_floor(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
          mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 1, 1, err, "floor") != 0) return -1;
   double d;
   if (mkr_val_to_number_or_fail(&args[0], mkr_ctx_limits(ctx), err, &d) != 0) return -1;
@@ -813,11 +849,10 @@ fn_floor(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 }
 
 static int
-fn_ceiling(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-           size_t self_pos, size_t self_size,
+fn_ceiling(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
            mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 1, 1, err, "ceiling") != 0) return -1;
   double d;
   if (mkr_val_to_number_or_fail(&args[0], mkr_ctx_limits(ctx), err, &d) != 0) return -1;
@@ -828,11 +863,10 @@ fn_ceiling(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 
 /* XPath 1.0 round(): round to nearest integer, .5 rounds toward +inf. */
 static int
-fn_round(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-         size_t self_pos, size_t self_size,
+fn_round(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
          mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_node; (void)self_pos; (void)self_size;
+  (void)focus;
   if (arity_check(nargs, 1, 1, err, "round") != 0) return -1;
   double d;
   if (mkr_val_to_number_or_fail(&args[0], mkr_ctx_limits(ctx), err, &d) != 0) return -1;
@@ -846,16 +880,14 @@ fn_round(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 
 /* Helper: pull the first node of a nodeset arg, or the self node when
  * the arg list is empty. */
-static lxb_dom_node_t *
-name_func_target(mkr_val_t *args, size_t nargs, lxb_dom_node_t *self_node, mkr_xpath_error_t *err, const char *fname)
+static MKR_DOM_NODE *
+name_func_target(mkr_val_t *args, size_t nargs, MKR_DOM_NODE *self_node, mkr_xpath_error_t *err, const char *fname)
 {
   if (nargs == 0) return self_node;
-  if (args[0].type != MKR_XPATH_TYPE_NODESET) {
-    mkr_err_setf(err, MKR_XPATH_ERR_TYPE, "%s(): argument must be a node-set", fname);
-    return NULL;
-  }
-  if (args[0].u.nodeset.count == 0) return NULL;
-  return args[0].u.nodeset.items[0];
+  const mkr_nodeset_t *ns = require_nodeset(&args[0], fname, err);
+  if (ns == NULL) return NULL;
+  if (ns->count == 0) return NULL;
+  return ns->items[0];
 }
 
 /* Set out to an empty string and report OOM if strdup fails. */
@@ -889,82 +921,79 @@ set_bytes_string(mkr_val_t *out, const lxb_char_t *src, size_t len,
 }
 
 static int
-fn_local_name(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-              size_t self_pos, size_t self_size,
+fn_local_name(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
               mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_pos; (void)self_size;
+  (void)ctx;
   if (arity_check(nargs, 0, 1, err, "local-name") != 0) return -1;
   /* Every return path below sets out via set_empty_string / set_bytes_string;
    * an error return leaves the caller's zero-initialised (clearable) out. */
-  lxb_dom_node_t *n = name_func_target(args, nargs, self_node, err, "local-name");
+  MKR_DOM_NODE *n = name_func_target(args, nargs, focus->node, err, "local-name");
   if (err->status != MKR_XPATH_OK) return -1;
   if (n == NULL ||
-      (n->type != LXB_DOM_NODE_TYPE_ELEMENT &&
-       n->type != LXB_DOM_NODE_TYPE_ATTRIBUTE &&
-       n->type != LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION)) {
+      (MKR_NODE_TYPE(n) != MKR_NTYPE_ELEMENT &&
+       MKR_NODE_TYPE(n) != MKR_NTYPE_ATTRIBUTE &&
+       MKR_NODE_TYPE(n) != MKR_NTYPE_PI)) {
     return set_empty_string(out, err, "local-name");
   }
   size_t len = 0;
   const lxb_char_t *name;
-  if (n->type == LXB_DOM_NODE_TYPE_ATTRIBUTE) {
-    name = lxb_dom_attr_local_name((lxb_dom_attr_t *)n, &len);
-  } else if (n->type == LXB_DOM_NODE_TYPE_ELEMENT) {
-    name = lxb_dom_element_local_name((lxb_dom_element_t *)n, &len);
+  if (MKR_NODE_TYPE(n) == MKR_NTYPE_ATTRIBUTE) {
+    name = MKR_ATTR_LOCAL_NAME(n, &len);
+  } else if (MKR_NODE_TYPE(n) == MKR_NTYPE_ELEMENT) {
+    name = MKR_ELEM_LOCAL_NAME(n, &len);
   } else {
-    name = lxb_dom_node_name(n, &len);
+    name = MKR_NODE_PI_NAME(n, &len);
   }
   return set_bytes_string(out, name, len, err, "local-name");
 }
 
 static int
-fn_namespace_uri(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-                 size_t self_pos, size_t self_size,
+fn_namespace_uri(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
                  mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)self_pos; (void)self_size;
   if (arity_check(nargs, 0, 1, err, "namespace-uri") != 0) return -1;
-  lxb_dom_node_t *n = name_func_target(args, nargs, self_node, err, "namespace-uri");
+  MKR_DOM_NODE *n = name_func_target(args, nargs, focus->node, err, "namespace-uri");
   if (err->status != MKR_XPATH_OK) return -1;
   if (n == NULL ||
-      (n->type != LXB_DOM_NODE_TYPE_ELEMENT && n->type != LXB_DOM_NODE_TYPE_ATTRIBUTE)) {
+      (MKR_NODE_TYPE(n) != MKR_NTYPE_ELEMENT && MKR_NODE_TYPE(n) != MKR_NTYPE_ATTRIBUTE)) {
     return set_empty_string(out, err, "namespace-uri");
   }
-  if (n->ns == 0) {
+  if (MKR_NODE_NS_ID(n) == 0) {
     return set_empty_string(out, err, "namespace-uri");
   }
-  lxb_dom_document_t *doc = mkr_ctx_document(ctx);
-  if (doc == NULL || doc->ns == NULL) {
+  size_t len = 0;
+  const char *uri = MKR_NODE_NS_URI(n, mkr_ctx_document(ctx), &len);
+  if (uri == NULL) {
     return set_empty_string(out, err, "namespace-uri");
   }
-  size_t len = 0;
-  const lxb_char_t *uri = lxb_ns_by_id(doc->ns, n->ns, &len);
-  return set_bytes_string(out, uri, len, err, "namespace-uri");
+  return set_bytes_string(out, (const lxb_char_t *)uri, len, err, "namespace-uri");
 }
 
 static int
-fn_name(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-        size_t self_pos, size_t self_size,
+fn_name(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
         mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_pos; (void)self_size;
+  (void)ctx;
   if (arity_check(nargs, 0, 1, err, "name") != 0) return -1;
-  lxb_dom_node_t *n = name_func_target(args, nargs, self_node, err, "name");
+  MKR_DOM_NODE *n = name_func_target(args, nargs, focus->node, err, "name");
   if (err->status != MKR_XPATH_OK) return -1;
   if (n == NULL ||
-      (n->type != LXB_DOM_NODE_TYPE_ELEMENT &&
-       n->type != LXB_DOM_NODE_TYPE_ATTRIBUTE &&
-       n->type != LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION)) {
+      (MKR_NODE_TYPE(n) != MKR_NTYPE_ELEMENT &&
+       MKR_NODE_TYPE(n) != MKR_NTYPE_ATTRIBUTE &&
+       MKR_NODE_TYPE(n) != MKR_NTYPE_PI)) {
     return set_empty_string(out, err, "name");
   }
   /* In HTML the qualified name matches the local name; this also avoids
    * surfacing the LXB_NS_HTML prefix that would otherwise confuse users. */
   size_t len = 0;
   const lxb_char_t *name;
-  if (n->type == LXB_DOM_NODE_TYPE_ATTRIBUTE) {
-    name = lxb_dom_attr_qualified_name((lxb_dom_attr_t *)n, &len);
+  if (MKR_NODE_TYPE(n) == MKR_NTYPE_ATTRIBUTE) {
+    name = MKR_ATTR_QUALIFIED_NAME(n, &len);
+  } else if (MKR_NODE_TYPE(n) == MKR_NTYPE_ELEMENT) {
+    name = MKR_ELEM_QUALIFIED_NAME(n, &len);
   } else {
-    name = mkr_dom_node_name_qualified(n, &len);
+    name = MKR_NODE_PI_NAME(n, &len);   /* a PI's expanded-name is (null, target) */
   }
   return set_bytes_string(out, name, len, err, "name");
 }
@@ -972,25 +1001,30 @@ fn_name(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
 /* ---------- boolean / language ---------- */
 
 static int
-fn_lang(mkr_xpath_context_t *ctx, lxb_dom_node_t *self_node,
-        size_t self_pos, size_t self_size,
+fn_lang(mkr_xpath_context_t *ctx, const mkr_focus_t *focus,
         mkr_val_t *args, size_t nargs, mkr_val_t *out, mkr_xpath_error_t *err)
 {
-  (void)ctx; (void)self_pos; (void)self_size;
+  (void)ctx;
   if (arity_check(nargs, 1, 1, err, "lang") != 0) return -1;
   mkr_owned_text_t want;
   if (mkr_val_to_owned_text_or_fail(&args[0], mkr_ctx_limits(ctx), err, &want) != 0) return -1;
   out->type = MKR_XPATH_TYPE_BOOLEAN;
   out->u.boolean = 0;
-  /* Walk up the ancestor chain looking for an @xml:lang or @lang. */
-  for (lxb_dom_node_t *p = self_node; p != NULL; p = p->parent) {
-    if (p->type != LXB_DOM_NODE_TYPE_ELEMENT) continue;
-    lxb_dom_element_t *el = (lxb_dom_element_t *)p;
+  /* Walk up the ancestor chain looking for the host's language attribute.
+     Host policy (§8.6): XPath 1.0 lang() is xml:lang based; HTML uses the `lang`
+     attribute (with xml:lang accepted as a fallback). */
+  for (MKR_DOM_NODE *p = focus->node; p != NULL; p = MKR_NODE_PARENT(p)) {
+    if (MKR_NODE_TYPE(p) != MKR_NTYPE_ELEMENT) continue;
+    MKR_DOM_ELEMENT *el = MKR_NODE_AS_ELEMENT(p);
     size_t vlen = 0;
-    const lxb_char_t *v = lxb_dom_element_get_attribute(el, (const lxb_char_t *)"lang", 4, &vlen);
+#ifdef MKR_HOST_XML
+    const lxb_char_t *v = MKR_ELEM_GET_ATTRIBUTE(el, "xml:lang", 8, &vlen);
+#else
+    const lxb_char_t *v = MKR_ELEM_GET_ATTRIBUTE(el, "lang", 4, &vlen);
     if (v == NULL) {
-      v = lxb_dom_element_get_attribute(el, (const lxb_char_t *)"xml:lang", 8, &vlen);
+      v = MKR_ELEM_GET_ATTRIBUTE(el, "xml:lang", 8, &vlen);
     }
+#endif /* MKR_HOST_XML */
     if (v == NULL) continue;
     /* Compare prefix (case-insensitive) up to '-'. */
     if (vlen >= want.len) {
@@ -1043,16 +1077,24 @@ static const fn_entry_t fn_table[] = {
   { "floor",            fn_floor            },
   { "ceiling",          fn_ceiling          },
   { "round",            fn_round            },
+#ifdef MKR_HOST_XML
+  /* CSS-only internal hooks for untyped :*-of-type; the \x01-prefixed names are
+   * unreachable from a user XPath expression (the lexer cannot produce them). */
+  { MKR_FN_OF_TYPE_POS,      fn_xml_of_type_pos      },
+  { MKR_FN_OF_TYPE_POS_LAST, fn_xml_of_type_pos_last },
+#endif
   { NULL,               NULL                },
 };
 
-mkr_func_impl_t
+/* File-static: the function table is engine-internal. eval_fncall (later in the
+ * merged engine TU) resolves through it; nothing outside the engine does. */
+static mkr_func_impl_t
 mkr_lookup_function(const char *ns_uri, const char *local_name)
 {
   if (local_name == NULL) return NULL;
   if (ns_uri != NULL) {
     /* Nokogiri-compatible builtins live in MKR_NS_NOKOGIRI_BUILTIN_URI.
-     * Other registered namespaces resolve to user-defined functions —
+     * Other registered namespaces resolve to user-defined functions -
      * not yet implemented (Phase 3 TODO: custom function registry). */
     if (strcmp(ns_uri, MKR_NS_NOKOGIRI_BUILTIN_URI) == 0) {
       for (size_t i = 0; fn_table_nokogiri_builtin[i].name; ++i) {
@@ -1063,7 +1105,7 @@ mkr_lookup_function(const char *ns_uri, const char *local_name)
     }
     return NULL;
   }
-  /* Default namespace — XPath 1.0 standard library. */
+  /* Default namespace - XPath 1.0 standard library. */
   for (size_t i = 0; fn_table[i].name; ++i) {
     if (strcmp(fn_table[i].name, local_name) == 0) return fn_table[i].fn;
   }