diff --git a/src/browser/frame/node_factory.zig b/src/browser/frame/node_factory.zig
index 9cd822889..6de08a90d 100644
--- a/src/browser/frame/node_factory.zig
+++ b/src/browser/frame/node_factory.zig
@@ -1087,10 +1087,25 @@ fn populateElementAttributes(frame: *Frame, element: *Element, list: anytype) !v
     var attributes = &element._attributes;
     try attributes.ensureTotalCapacity(count, frame);
     while (list.next()) |attr| {
-        try attributes.putNew(attr.name.local.slice(), attr.value.slice(), frame);
+        const name = try parserAttributeName(frame, attr.name);
+        try attributes.putNew(name, attr.value.slice(), frame);
     }
 }
 
+// Attributes are keyed by qualified name (no namespace model), so a prefixed
+// attribute (`xlink:href` in foreign content, `xml:id` in XML) must keep its
+// prefix — that is what `getAttribute("xlink:href")` and `Attr.name` see in
+// browsers. The joined name only has to outlive putNew, which canonicalizes
+// it into the frame arena. (Not frame.buf: name normalization writes there.)
+fn parserAttributeName(frame: *Frame, qname: Parser.QualName) ![]const u8 {
+    const local = qname.local.slice();
+    const prefix = (qname.prefix.unwrap() orelse return local).slice();
+    if (prefix.len == 0) {
+        return local;
+    }
+    return std.fmt.allocPrint(frame.local_arena, "{s}:{s}", .{ prefix, local });
+}
+
 // Called when `new MyElement()` is invoked directly in JS (not via the
 // customElements.define/upgrade path). `new_target` is the constructor
 // function that was used with `new`. We find the matching definition in the
diff --git a/src/browser/parser/Parser.zig b/src/browser/parser/Parser.zig
index 2bbe994cb..f735916ad 100644
--- a/src/browser/parser/Parser.zig
+++ b/src/browser/parser/Parser.zig
@@ -25,6 +25,7 @@ const Node = @import("../webapi/Node.zig");
 const Element = @import("../webapi/Element.zig");
 const CData = @import("../webapi/CData.zig");
 
+pub const QualName = h5e.QualName;
 pub const AttributeIterator = h5e.AttributeIterator;
 
 const Allocator = std.mem.Allocator;
@@ -453,7 +454,8 @@ fn createElementCallback(ctx: *anyopaque, data: *anyopaque, qname: h5e.QualName,
 }
 
 fn createXMLElementCallback(ctx: *anyopaque, data: *anyopaque, qname: h5e.QualName, attributes: h5e.AttributeIterator) callconv(.c) ?*anyopaque {
-    return _createElementCallbackWithDefaultnamespace(ctx, data, qname, attributes, .xml);
+    // An XML element outside any xmlns declaration is in no namespace (null namespace)
+    return _createElementCallbackWithDefaultnamespace(ctx, data, qname, attributes, .null);
 }
 
 // html5ever_parse_fragment materializes the fragment's context element through
diff --git a/src/browser/tests/domparser.html b/src/browser/tests/domparser.html
index 71640464e..9bb5ccde0 100644
--- a/src/browser/tests/domparser.html
+++ b/src/browser/tests/domparser.html
@@ -419,3 +419,26 @@
   testing.expectEqual(2, allElements.length);
 }
 </script>
+
+<script id=xml-namespaces>
+{
+  const doc = new DOMParser().parseFromString(
+    '<r xmlns:a="urn:a" a:b="1" xml:lang="en" c="2"><a:k/><k/></r>', 'text/xml');
+  const r = doc.documentElement;
+
+  // Elements outside any xmlns declaration are in no namespace
+  testing.expectEqual(null, r.namespaceURI);
+  testing.expectEqual(1, doc.getElementsByTagNameNS('', 'r').length);
+  testing.expectEqual(1, doc.getElementsByTagNameNS(null, 'k').length);
+
+  // Prefixed attributes keep their qualified name. (Not asserted: browsers
+  // also list xmlns:a as an attribute; xml5ever consumes the declaration.)
+  testing.expectEqual(true, Array.from(r.attributes).some(a => a.name === 'a:b'));
+  testing.expectEqual(false, Array.from(r.attributes).some(a => a.name === 'b'));
+  testing.expectEqual('1', r.getAttribute('a:b'));
+  testing.expectEqual('en', r.getAttribute('xml:lang'));
+  testing.expectEqual(null, r.getAttribute('lang'));
+  testing.expectEqual('en', r.getAttributeNS('http://www.w3.org/XML/1998/namespace', 'lang'));
+  testing.expectEqual(true, r.hasAttributeNS('http://www.w3.org/XML/1998/namespace', 'lang'));
+}
+</script>
diff --git a/src/browser/tests/element/svg/animated_string.html b/src/browser/tests/element/svg/animated_string.html
index 7a8520eca..21b3833aa 100644
--- a/src/browser/tests/element/svg/animated_string.html
+++ b/src/browser/tests/element/svg/animated_string.html
@@ -34,35 +34,34 @@
 
 <script id=href>
 {
-  // The parser stores xlink:href under its local name, href.
+  // The parser keeps the xlink: prefix; href reflects href, else xlink:href.
   const use1 = $('#use1');
   testing.expectEqual(true, use1.href instanceof SVGAnimatedString);
   testing.expectEqual('#icon', use1.href.baseVal);
   testing.expectEqual('#icon', use1.href.animVal);
   testing.expectEqual(true, use1.href === use1.href);
   testing.expectEqual('#modern', $('#use2').href.baseVal);
+  testing.expectEqual('#icon', use1.getAttribute('xlink:href'));
+  testing.expectEqual(null, use1.getAttribute('href'));
+  testing.expectEqual('#icon', use1.getAttributeNS('http://www.w3.org/1999/xlink', 'href'));
 
-  // Writes land in xlink:href in browsers (it's the attribute that's set)
-  // but in href for us since the parser stored it there; assert the common
-  // observable.
+  // Only xlink:href present: the write lands in the xlink attribute, not in
+  // a new href. (Firefox drops the prefix on that write, so only assert the
+  // namespaced lookup.)
   use1.href.baseVal = '#other';
   testing.expectEqual('#other', use1.href.baseVal);
+  testing.expectEqual('#other', use1.getAttributeNS('http://www.w3.org/1999/xlink', 'href'));
+  testing.expectEqual(false, use1.hasAttributeNS(null, 'href'));
 
-  // setAttributeNS stores under the local name, so a runtime xlink:href
-  // lands in href and reflects like the parsed variant. (Browsers keep the
-  // xlink:href attribute but reflect it the same way.)
+  // Runtime setAttributeNS keeps the qualified name and reflects the same way.
   const use3 = document.createElementNS('http://www.w3.org/2000/svg', 'use');
   use3.setAttributeNS('http://www.w3.org/1999/xlink', 'xlink:href', '#runtime');
   testing.expectEqual('#runtime', use3.href.baseVal);
+  testing.expectEqual('#runtime', use3.getAttribute('xlink:href'));
 
-  // A namespace-less setAttribute('xlink:href') is a literal attribute in no
-  // namespace: not reflected, in browsers or here.
-  const use4 = document.createElementNS('http://www.w3.org/2000/svg', 'use');
-  use4.setAttribute('xlink:href', '#literal');
-  testing.expectEqual('', use4.href.baseVal);
-  use4.href.baseVal = '#written';
-  testing.expectEqual('#written', use4.getAttribute('href'));
-  testing.expectEqual(true, use4.hasAttribute('xlink:href'));
+  // Not asserted: a namespace-less setAttribute('xlink:href') is a literal
+  // attribute browsers don't reflect, but attributes here have no namespace
+  // so it is indistinguishable from the xlink one and does reflect.
 
   // No href attribute at all: set writes to href.
   const link = $('#link1');
diff --git a/src/browser/tests/xpath/document_evaluate.html b/src/browser/tests/xpath/document_evaluate.html
index 2c4fdc588..e9db60c58 100644
--- a/src/browser/tests/xpath/document_evaluate.html
+++ b/src/browser/tests/xpath/document_evaluate.html
@@ -111,6 +111,24 @@
 {
   const resolver = document.createNSResolver(document);
   testing.expectEqual(document, resolver);
+
+  // The Node it returns must be accepted back as the resolver argument
+  const r = document.evaluate("//p", document, resolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+  testing.expectEqual(3, r.snapshotLength);
+  const expr = document.createExpression("//p", resolver);
+  testing.expectEqual(3, expr.evaluate(document, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null).snapshotLength);
+}
+</script>
+
+<script id=prefixed_attribute_in_xml>
+{
+  const doc = new DOMParser().parseFromString(
+    '<mu xml:id="id1"><rho xml:lang="en-GB"/><rho xml:lang="no"/></mu>', 'text/xml');
+  const root = doc.documentElement;
+  const r = doc.evaluate('//mu[@xml:id="id1"]/rho[@xml:lang="en-GB"]', root,
+    doc.createNSResolver(root), XPathResult.ANY_TYPE, null);
+  testing.expectEqual(root.firstChild, r.iterateNext());
+  testing.expectEqual(null, r.iterateNext());
 }
 </script>
 
diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zig
index a1e4364be..a90c7d14a 100644
--- a/src/browser/webapi/Document.zig
+++ b/src/browser/webapi/Document.zig
@@ -674,7 +674,7 @@ pub fn evaluate(
     self: *Document,
     expression: []const u8,
     context_node: ?*Node,
-    resolver: ?js.Function,
+    resolver: ?js.Value,
     result_type: ?u16,
     result: ?*XPathResult,
     frame: *Frame,
@@ -697,7 +697,7 @@ pub fn evaluate(
 pub fn createExpression(
     _: *const Document,
     expression: []const u8,
-    resolver: ?js.Function,
+    resolver: ?js.Value,
     frame: *Frame,
 ) !*XPathExpression {
     _ = resolver;
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index a11caf0b9..30cc3927b 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -114,6 +114,9 @@ pub const Namespace = enum(u8) {
 
     pub fn parse(namespace_: ?[]const u8) Namespace {
         const namespace = namespace_ orelse return .null;
+        if (namespace.len == 0) {
+            return .null;
+        }
         if (namespace.len == "http://www.w3.org/1999/xhtml".len) {
             // Common case, avoid the string comparison. Recklessly
             @branchHint(.likely);
@@ -652,22 +655,40 @@ pub fn getAttribute(self: *const Element, name: String, frame: *Frame) !?String
     return self._attributes.get(name, frame);
 }
 
-/// For simplicity, the namespace is currently ignored and only the local name is used.
 pub fn getAttributeNS(
     self: *const Element,
-    maybe_namespace: ?[]const u8,
+    namespace_: ?[]const u8,
     local_name: String,
     frame: *Frame,
 ) !?String {
-    if (maybe_namespace) |namespace| {
-        if (!std.mem.eql(u8, namespace, "http://www.w3.org/1999/xhtml")) {
-            log.warn(.not_implemented, "Element.getAttributeNS", .{ .namespace = namespace });
+    if (namespace_) |namespace| {
+        // we don't really support namespaces, but if the namespace has a fixed
+        // prefix, we can try to fetch the attribute with it
+        if (try prefixedAttributeName(namespace, local_name.str(), frame)) |prefixed| {
+            if (try self.getAttribute(.wrap(prefixed), frame)) |value| {
+                return value;
+            }
         }
     }
-
     return self.getAttribute(local_name, frame);
 }
 
+fn prefixedAttributeName(namespace: []const u8, local_name: []const u8, frame: *Frame) !?[]const u8 {
+    const prefix = blk: {
+        if (std.mem.eql(u8, namespace, "http://www.w3.org/1999/xlink")) {
+            break :blk "xlink";
+        }
+        if (std.mem.eql(u8, namespace, "http://www.w3.org/XML/1998/namespace")) {
+            break :blk "xml";
+        }
+        if (std.mem.eql(u8, namespace, "http://www.w3.org/2000/xmlns/")) {
+            break :blk "xmlns";
+        }
+        return null;
+    };
+    return try std.fmt.allocPrint(frame.local_arena, "{s}:{s}", .{ prefix, local_name });
+}
+
 pub fn getAttributeSafe(self: *const Element, name: String) ?[]const u8 {
     return self._attributes.getSafe(name);
 }
@@ -677,20 +698,13 @@ pub fn hasAttribute(self: *const Element, name: String, frame: *Frame) !bool {
     return value != null;
 }
 
-/// Like getAttributeNS, the namespace is currently ignored.
 pub fn hasAttributeNS(
     self: *const Element,
-    maybe_namespace: ?[]const u8,
+    namespace_: ?[]const u8,
     local_name: String,
     frame: *Frame,
 ) !bool {
-    if (maybe_namespace) |namespace| {
-        if (!std.mem.eql(u8, namespace, "http://www.w3.org/1999/xhtml")) {
-            log.warn(.not_implemented, "Element.hasAttributeNS", .{ .namespace = namespace });
-        }
-    }
-
-    return self.hasAttribute(local_name, frame);
+    return try self.getAttributeNS(namespace_, local_name, frame) != null;
 }
 
 pub fn hasAttributeSafe(self: *const Element, name: String) bool {
@@ -769,30 +783,24 @@ pub fn setAttribute(self: *Element, name: String, value: String, frame: *Frame)
 
 pub fn setAttributeNS(
     self: *Element,
-    maybe_namespace: ?[]const u8,
+    namespace_: ?[]const u8,
     qualified_name: []const u8,
     value: String,
     frame: *Frame,
 ) !void {
-    const attr_name = if (maybe_namespace) |namespace| blk: {
-        // For xmlns namespace, store the full qualified name (e.g. "xmlns:bar")
-        // so lookupNamespaceURI can find namespace declarations.
-        if (std.mem.eql(u8, namespace, "http://www.w3.org/2000/xmlns/")) {
-            break :blk qualified_name;
+    const local_start = if (std.mem.indexOfScalarPos(u8, qualified_name, 0, ':')) |idx| blk: {
+        if (idx == 0 or idx == qualified_name.len - 1) {
+            // cannot be at the start or end of the qname
+            return error.InvalidCharacterError;
         }
-        if (!std.mem.eql(u8, namespace, "http://www.w3.org/1999/xhtml")) {
-            log.warn(.not_implemented, "Element.setAttributeNS", .{ .namespace = namespace });
+        if (std.mem.indexOfScalarPos(u8, qualified_name, idx + 1, ':') != null) {
+            // and can only have one
+            return error.InvalidCharacterError;
         }
-        break :blk if (std.mem.indexOfScalarPos(u8, qualified_name, 0, ':')) |idx|
-            qualified_name[idx + 1 ..]
-        else
-            qualified_name;
-    } else blk: {
-        break :blk if (std.mem.indexOfScalarPos(u8, qualified_name, 0, ':')) |idx|
-            qualified_name[idx + 1 ..]
-        else
-            qualified_name;
-    };
+        break :blk idx + 1;
+    } else 0;
+
+    const attr_name = if (namespace_ != null) qualified_name else qualified_name[local_start..];
     return self.setAttribute(.wrap(attr_name), value, frame);
 }
 
diff --git a/src/browser/webapi/XPathEvaluator.zig b/src/browser/webapi/XPathEvaluator.zig
index c35a58178..5a5f28fcf 100644
--- a/src/browser/webapi/XPathEvaluator.zig
+++ b/src/browser/webapi/XPathEvaluator.zig
@@ -43,7 +43,7 @@ pub fn evaluate(
     _: *const XPathEvaluator,
     expression: []const u8,
     context_node: *Node,
-    resolver: ?js.Function,
+    resolver: ?js.Value,
     requested_type: ?u16,
     result: ?*XPathResult,
     frame: *Frame,
@@ -59,7 +59,7 @@ pub fn evaluate(
 pub fn createExpression(
     _: *const XPathEvaluator,
     expression: []const u8,
-    resolver: ?js.Function,
+    resolver: ?js.Value,
     frame: *Frame,
 ) !*XPathExpression {
     _ = resolver;
diff --git a/src/browser/webapi/element/Svg.zig b/src/browser/webapi/element/Svg.zig
index 39960ec0b..70abc8412 100644
--- a/src/browser/webapi/element/Svg.zig
+++ b/src/browser/webapi/element/Svg.zig
@@ -194,6 +194,5 @@ pub const JsApi = struct {
 
 const testing = @import("../../../testing.zig");
 test "WebApi: Svg" {
-    testing.expectLog(&.{ .not_implemented, .not_implemented });
     try testing.htmlRunner("element/svg", .{});
 }
diff --git a/src/browser/webapi/svg/AnimatedString.zig b/src/browser/webapi/svg/AnimatedString.zig
index d53de59bc..2ad187d58 100644
--- a/src/browser/webapi/svg/AnimatedString.zig
+++ b/src/browser/webapi/svg/AnimatedString.zig
@@ -67,8 +67,20 @@ pub fn getAnimVal(self: *const AnimatedString) []const u8 {
 
 fn attributeName(self: *const AnimatedString) String {
     return switch (self._kind) {
-        .href => comptime .wrap("href"),
         .class => comptime .wrap("class"),
+        .href => {
+            const href: String = comptime .wrap("href");
+            if (self._element.hasAttributeSafe(href)) {
+                return href;
+            }
+
+            const xlink_href: String = comptime .wrap("xlink:href");
+            if (self._element.hasAttributeSafe(xlink_href)) {
+                // legacy attribute, returned if it exists and href doens't
+                return xlink_href;
+            }
+            return href;
+        },
     };
 }