dommy 0.11.0 → 0.13.0

data/lib/dommy/document.rb

@@ -141,6 +141,12 @@ module Dommy
     end
     private :synthetic_insert
 
+    # A doctype is connected when its tree is a document's; a synthetic one is
+    # never in a tree at all.
+    def is_connected?
+      get_root_node.is_a?(Dommy::Document)
+    end
+
     def __js_get__(key)
       case key
       when "name"
@@ -168,6 +174,8 @@ module Dommy
         NodeList.new
       when "firstChild", "lastChild"
         nil
+      when "isConnected"
+        is_connected?
       end
     end
 
@@ -802,11 +810,11 @@ module Dommy
       href = base_el["href"].to_s
       return doc_url if href.empty?
 
-      begin
-        URI.join(doc_url.to_s.empty? ? "about:blank" : doc_url, href).to_s
-      rescue URI::InvalidURIError
-        doc_url
-      end
+      # HTML "document base URL": the frozen base URL is the href parsed
+      # against the document's URL; one that does not parse falls back.
+      URL.new(href, doc_url.to_s.empty? ? nil : doc_url).href
+    rescue Bridge::TypeError
+      doc_url
     end
 
     # `document.domain` — host portion of the URL. Real browsers
@@ -954,15 +962,7 @@ module Dommy
     # Ruby Proc, a JS-bridge callable, or an object with
     # `accept_node` / `acceptNode`.
     def create_tree_walker(root, what_to_show = NodeFilter::SHOW_ALL, filter = nil)
-      TreeWalker.new(require_node_root(root), what_to_show, filter)
-    end
-
-    # The `root` of a TreeWalker / NodeIterator is a non-nullable WebIDL `Node`:
-    # a null or non-Node argument is a TypeError before construction.
-    def require_node_root(root)
-      return root if root.is_a?(Dommy::Node)
-
-      raise Bridge::TypeError, "createTreeWalker/createNodeIterator root must be a Node"
+      TreeWalker.new(Internal::WebIDL.node!(root), what_to_show, filter)
     end
 
     # WebIDL `unsigned long whatToShow = 0xFFFFFFFF`: an omitted or `undefined`
@@ -988,6 +988,12 @@ module Dommy
     # wrapper is owned by `this`. Per spec, the source node is left
     # in place. `deep: true` copies the entire subtree.
     def import_node(node, deep = false)
+      # Step 1: "If node is a document or shadow root, throw a
+      # NotSupportedError." Neither has anywhere to go in another document.
+      if node.is_a?(Document) || node.is_a?(ShadowRoot)
+        raise DOMException::NotSupportedError, "a #{node.is_a?(Document) ? "document" : "shadow root"} cannot be imported"
+      end
+
       # An Attr is a Node but not a backend-tree node: it is copied by rebuilding
       # it here with the same qualified name, namespace, prefix and value, owned
       # by no element (importNode never attaches the copy to anything).
@@ -1105,7 +1111,11 @@ module Dommy
 
     alias has_focus has_focus?
 
+    # A document without a browsing context (one built by DOMParser or
+    # createHTMLDocument) has no selection.
     def get_selection
+      return nil unless @default_view
+
       @__selection ||= Selection.new(self)
     end
 
@@ -1147,7 +1157,7 @@ module Dommy
     # `document.createNodeIterator(root, whatToShow?, filter?)` —
     # flat depth-first iteration.
     def create_node_iterator(root, what_to_show = NodeFilter::SHOW_ALL, filter = nil)
-      root = require_node_root(root)
+      root = Internal::WebIDL.node!(root)
       iterator = NodeIterator.new(root, what_to_show, filter)
       # The "NodeIterator pre-removing steps" run for iterators whose root's node
       # document is the removed node's document. Track the iterator on the root's
@@ -1348,6 +1358,8 @@ module Dommy
     #
     # Spec: https://dom.spec.whatwg.org/#dom-parentnode-movebefore
     def move_before(node, child = nil)
+      Internal::WebIDL.node!(node)
+      Internal::WebIDL.nullable_node!(child)
       bn = move_backend_node(node)
       ref_bn = move_backend_node(child)
       ref_bn = ref_bn.next_sibling if ref_bn && bn && ref_bn == bn
@@ -1356,7 +1368,7 @@ module Dommy
       old_parent = bn.parent
       old_previous = bn.previous_sibling
       old_next = bn.next_sibling
-      detach_node(bn)                                             # steps 10-11, 14
+      detach_node(bn, moving: true)                               # steps 10-11, 14
       ref_bn = nil if ref_bn && ref_bn.parent != @backend_doc
       __internal_ranges_will_insert__(@backend_doc, ref_bn, 1)    # step 16
       new_previous = ref_bn ? ref_bn.previous_sibling : @backend_doc.children.to_a.last
@@ -1365,11 +1377,12 @@ module Dommy
         notify_child_list_mutation(
           target_node: old_parent, added_nodes: [], removed_nodes: [bn],
           previous_sibling: old_previous && wrap_node(old_previous),
-          next_sibling: old_next && wrap_node(old_next)
+          next_sibling: old_next && wrap_node(old_next), moving: true
         )
       end
       notify_document_child_list(added: [bn], previous_sibling: new_previous && wrap_node(new_previous),
-                                 next_sibling: ref_bn && wrap_node(ref_bn))
+                                 next_sibling: ref_bn && wrap_node(ref_bn), moving: true)
+      __internal_notify_moved_subtree__(bn)                        # step 19.3, into a document
       nil
     end
 
@@ -1582,11 +1595,18 @@ module Dommy
       nil
     end
 
-    # `document.cloneNode(deep)` → a fresh Document over a (deep) copy of the
-    # Makiri tree, preserving the content type.
+    # `document.cloneNode(deep)` → a fresh Document of the same kind, keeping
+    # the content type. "Clone a single node" creates a document EMPTY, and a
+    # deep clone then copies the original's children into it — so nothing
+    # sprouts an html/head/body of its own, and a document with no children
+    # clones to one with no children.
     def clone_node(deep)
-      copy = deep ? Backend.clone_document(@backend_doc) : Backend.empty_document_like(@backend_doc)
-      Document.new(nil, backend_doc: copy).tap { |d| d.content_type = @content_type }
+      copy = Document.new(nil, backend_doc: Backend.empty_document_like(@backend_doc))
+      copy.content_type = @content_type
+      return copy unless deep
+
+      child_nodes.each { |child| copy.append_child(copy.import_node(child, true)) }
+      copy
     end
 
     def backend_node(node)
@@ -1987,9 +2007,7 @@ module Dommy
         document_remove_child(args[0])
       when "insertBefore"
         raise Bridge::TypeError, "insertBefore requires 2 arguments." if args.length < 2
-        unless args[1].nil? || args[1].equal?(Bridge::UNDEFINED) || args[1].is_a?(Dommy::Node)
-          raise Bridge::TypeError, "The reference child is not a Node."
-        end
+        Internal::WebIDL.nullable_node!(args[1])
 
         document_insert_before(args[0], args[1])
       when "replaceChild"
@@ -2002,7 +2020,7 @@ module Dommy
       when "cloneNode"
         clone_node(args[0])
       when "normalize"
-        nil # the document has no text children to merge
+        normalize
       when "writeln"
         write(*(args + ["\n"]))
       when "exitFullscreen"
@@ -2208,6 +2226,33 @@ module Dommy
       @shadow_registry.find_for_fragment(fragment_node)
     end
 
+    def __internal_shadow_root_for_host__(host_node)
+      @shadow_registry.find_for_host(host_node)
+    end
+
+    # Every element among `root`'s shadow-including inclusive descendants, as
+    # backend nodes, in shadow-including tree order: an element, then the shadow
+    # tree it hosts, then its children. The whole list, shadow trees included, is
+    # taken before the first element is yielded. Callbacks run synchronously here,
+    # and one that attaches a shadow root or inserts elements triggers those
+    # changes' own reactions; walking into them as well would run them twice.
+    def __internal_each_shadow_including_element__(root, &block)
+      shadow_including_elements(root).each(&block)
+      nil
+    end
+
+    def shadow_including_elements(root, list = [])
+      elements = root.respond_to?(:element?) && root.element? ? [root] : []
+      elements.concat(root.css("*").to_a) if root.respond_to?(:css)
+      elements.each do |element|
+        list << element
+        shadow = @shadow_registry.find_for_host(element)
+        shadow_including_elements(shadow.__dommy_backend_node__, list) if shadow
+      end
+      list
+    end
+    private :shadow_including_elements
+
     def __internal_shadow_root_containing__(node)
       @shadow_registry.find_enclosing(node)
     end
@@ -2235,6 +2280,12 @@ module Dommy
       @mutation_coordinator.notify_connected_subtree(nk)
     end
 
+    # The custom element reactions of a move (moveBefore), for a node that ended
+    # up connected.
+    def __internal_notify_moved_subtree__(nk)
+      @mutation_coordinator.notify_moved_subtree(nk)
+    end
+
     def __internal_notify_disconnected_subtree__(nk)
       @mutation_coordinator.notify_disconnected_subtree(nk)
     end
@@ -2260,14 +2311,16 @@ module Dommy
       added_nodes:,
       removed_nodes:,
       previous_sibling: nil,
-      next_sibling: nil
+      next_sibling: nil,
+      moving: false
     )
       @mutation_coordinator.notify_child_list_mutation(
         target_node: target_node,
         added_nodes: added_nodes,
         removed_nodes: removed_nodes,
         previous_sibling: previous_sibling,
-        next_sibling: next_sibling
+        next_sibling: next_sibling,
+        moving: moving
       )
     end
 
@@ -2302,13 +2355,14 @@ module Dommy
       node && wrap_node(node)
     end
 
-    def notify_document_child_list(added: [], removed: [], previous_sibling: nil, next_sibling: nil)
+    def notify_document_child_list(added: [], removed: [], previous_sibling: nil, next_sibling: nil, moving: false)
       notify_child_list_mutation(
         target_node: @backend_doc,
         added_nodes: added,
         removed_nodes: removed,
         previous_sibling: previous_sibling,
-        next_sibling: next_sibling
+        next_sibling: next_sibling,
+        moving: moving
       )
     end
 
@@ -2316,10 +2370,18 @@ module Dommy
     # batch several removals into one childList record (replaceChildren,
     # textContent=, replaceChild) use this and queue the record themselves;
     # `remove_node_with_notify` is this plus a per-node record.
-    def detach_node(node)
+    #
+    # `moving:` marks the first half of the "move" primitive (moveBefore). A
+    # move takes the node out of its old parent's children only to put it
+    # straight back into the same shadow-including tree: it never leaves the
+    # document, so nothing that reacts to a removal from the document may run.
+    def detach_node(node, moving: false)
       pre_remove_node(node)
       add_transient_observers_for(node)
       node.unlink
+      # A removal can take a shadow tree, and a selection range in it, out of
+      # the document without moving the range; the selection lets go of it.
+      @__selection&.__internal_node_removed__ unless moving
       node
     end
 
@@ -2455,6 +2517,73 @@ module Dommy
       end
     end
 
+    # Node.normalize() on the document: every Text run in the tree.
+    def normalize
+      __internal_normalize__(@backend_doc)
+    end
+
+    # Node#normalize — merge each run of adjacent exclusive Text descendants
+    # into its first node (preserving that node's identity, so a JS reference
+    # to it survives) and drop empty Text nodes. Recurses the whole subtree,
+    # so it serves Element, DocumentFragment, ShadowRoot and the Document alike.
+    #
+    # A run is merged one sibling at a time: append the sibling's data to the
+    # survivor (a characterData record), hand its live range boundaries over,
+    # remove it (a childList record), then the next. Read literally, the spec
+    # concatenates every sibling's data first (steps 3-4, one "replace data")
+    # and removes them afterwards (step 7), which would queue ONE
+    # characterData record per run. Every shipping engine merges pairwise
+    # instead — Blink, WebCore and Gecko all answer [characterData, childList,
+    # characterData, childList, …] for a run of four text nodes, confirmed by
+    # running the same script in Chromium 141, WebKitGTK 2.52.6 and Firefox —
+    # and the WPT suite fixes only the childList side, so the records follow
+    # the engines. The tree and every live range boundary end up exactly where
+    # the spec's steps put them: a boundary in a later sibling (or on the
+    # parent, pointing at one) is shifted down by each earlier removal and
+    # then handed over at the survivor's length of that moment, which is the
+    # same offset the batch steps compute up front.
+    # https://github.com/takahashim/dommy/issues/24
+    def __internal_normalize__(root)
+      text_nodes = []
+      root.traverse { |node| text_nodes << node if node.respond_to?(:text?) && node.text? }
+
+      text_nodes.each do |node|
+        next unless node.parent # already removed as part of an earlier run
+
+        if node.content.to_s.empty?
+          remove_node_with_notify(node)
+          next
+        end
+
+        sib = node.next
+        while sib.respond_to?(:text?) && sib.text?
+          following = sib.next
+          data = sib.content.to_s
+          # The offset the sibling's data lands at inside the survivor — the
+          # length of what it already holds, measured before the append.
+          length = wrap_node(node).length
+          # An empty sibling has nothing to append: the engines skip the data
+          # step for it (Gecko checks the length, Blink and WebCore behave the
+          # same), so it is removed without a characterData record. Its range
+          # boundaries still move to the survivor's join.
+          unless data.empty?
+            old = node.content.to_s
+            node.content = old + data
+            notify_character_data_mutation(target_node: node, old_value: old)
+          end
+          # WHATWG normalize() step 6: the merged-away sibling hands its live
+          # range boundaries to the survivor at that offset BEFORE it is
+          # removed, or the plain removing steps would strand them on the
+          # parent.
+          __internal_ranges_normalize_merge__(node, sib, length)
+          remove_node_with_notify(sib)
+          sib = following
+        end
+      end
+
+      nil
+    end
+
     def __internal_ranges_replaced_data__(node, offset, count, new_length)
       return unless live_ranges?
 
@@ -2574,40 +2703,105 @@ module Dommy
     # `deep: true` recurses into children. Used by importNode and
     # adoptNode for cross-document transfer.
     def clone_into_doc(source, deep, source_document = self)
-      copy = if source.element?
-        new_el = Backend.create_element(source.name, @backend_doc)
-        Backend.attribute_nodes(source).each { |a| new_el[a.name] = a.value }
-        new_el
+      copy = clone_single_node_into_doc(source, source_document)
+
+      if source.element? && source.name == "template"
+        # A <template>'s contents live in a separate content fragment, not its
+        # child list, so the generic deep pass over `children` misses them.
+        clone_template_content(source, copy, source_document) if deep
+      elsif deep && source.respond_to?(:children)
+        source.children.each do |child|
+          copy.add_child(clone_into_doc(child, true, source_document))
+        end
+      end
+
+      copy
+    end
+
+    # "Clone a single node" (§4.4): the copy implements the SAME interface as
+    # the original — a ProcessingInstruction clones to one, not to the comment
+    # its serialization looks like — and carries the same data. Elements are
+    # cloned by #clone_element_into_doc; children are the caller's business.
+    def clone_single_node_into_doc(source, source_document)
+      if source.element?
+        clone_element_into_doc(source, source_document)
+      elsif (cdata = Backend.cdata_class) && source.is_a?(cdata)
+        # CDATA is a Text subtype in the backend, so ask about it first.
+        Backend.create_cdata(source.content, @backend_doc)
       elsif source.text?
         Backend.create_text(source.content, @backend_doc)
       elsif source.is_a?(Backend.comment_class)
         Backend.create_comment(source.content, @backend_doc)
+      elsif source.is_a?(Backend.processing_instruction_class)
+        Backend.create_processing_instruction(source.target, source.content, @backend_doc)
       elsif source.is_a?(Backend.document_fragment_class)
         # A DocumentFragment clones to a fragment (its children are appended by
-        # the deep pass below), NOT to its first child — `importNode(<template>
+        # the deep pass), NOT to its first child — `importNode(<template>
         # .content, true)` must return a fragment so `.firstElementChild` works
         # (Vue/Alpine x-for clone template content this way). Built via the
         # document's own `fragment` (as TemplateContentRegistry does) rather than
         # `document_fragment_class.new`, so it works on backends whose fragment
         # class isn't directly instantiable (Makiri).
         Parser.fragment("", owner_doc: @backend_doc)
+      elsif (doctype = Backend.document_type_class) && source.is_a?(doctype)
+        wrapper = source_document.wrap_node(source)
+        Backend.create_document_type(wrapper.name, wrapper.public_id, wrapper.system_id, @backend_doc)
       else
-        # Fallback: serialize + reparse via fragment for unusual types.
-        fragment = Parser.fragment(source.to_html, owner_doc: @backend_doc)
-        fragment.children.first || Backend.create_text("", @backend_doc)
+        Backend.create_text("", @backend_doc)
       end
+    end
 
-      if source.element? && source.name == "template"
-        # A <template>'s contents live in a separate content fragment, not its
-        # child list, so the generic deep pass over `children` misses them.
-        clone_template_content(source, copy, source_document) if deep
-      elsif deep && source.respond_to?(:children)
-        source.children.each do |child|
-          copy.add_child(clone_into_doc(child, true, source_document))
+    # An element's copy keeps its namespace, its prefix and the exact spelling
+    # of its local name. None of that is on the backend node — the HTML backend
+    # tracks no namespace for an element script created, and createElementNS's
+    # case lives on the wrapper — so the original is read through its wrapper
+    # and the copy is given the same metadata.
+    def clone_element_into_doc(source, source_document)
+      wrapper = source_document.wrap_node(source)
+      namespace, prefix, local, qualified = clone_name_parts(wrapper, source)
+      copy = Backend.create_element_loose(qualified, prefix, local, namespace, @backend_doc) ||
+        Backend.create_element(source.name, @backend_doc)
+      copy_attributes_into(source, copy)
+      note_cloned_element_namespace(copy, namespace, prefix, local, qualified)
+      copy
+    end
+
+    # The four parts of the original's name — namespace, prefix, local name and
+    # qualified name. The wrapper's own metadata has them whenever there is
+    # anything to carry (createElementNS's case and prefix, an XML document's,
+    # the HTML parser's SVG names); otherwise the element is an unprefixed one
+    # whose namespace the backend knows.
+    def clone_name_parts(wrapper, source)
+      meta = wrapper.__internal_namespace_metadata__ if wrapper.respond_to?(:__internal_namespace_metadata__)
+      return meta if meta
+
+      local = wrapper ? wrapper.local_name.to_s : source.name
+      [wrapper&.namespace_uri, nil, local, local]
+    end
+
+    # "Clone a single node" step 2.1 clones the attributes one by one, so each
+    # keeps its own namespace and prefix — an `xml:b` must not flatten into an
+    # attribute whose local name is the qualified string "xml:b".
+    def copy_attributes_into(source, copy)
+      Backend.attribute_nodes(source).each do |attr|
+        info = Backend.attribute_ns_info(attr)
+        if info[:namespace_uri]
+          Backend.set_attribute_ns(copy, info[:namespace_uri], info[:prefix], info[:local_name],
+            info[:qualified_name], info[:value])
+        else
+          copy[info[:qualified_name]] = info[:value]
         end
       end
+      nil
+    end
 
-      copy
+    # Give the copy's wrapper the namespace metadata whenever the backend node
+    # alone would report something else (see #clone_element_into_doc).
+    def note_cloned_element_namespace(copy, namespace, prefix, local, qualified)
+      derived = Backend.namespace_of(copy)&.href || (html_document? ? Element::HTML_NAMESPACE : nil)
+      return if derived == namespace && prefix.nil? && local == copy.name
+
+      wrap_cloned_element_ns(copy, namespace, prefix, local, qualified)
     end
 
     # Clone a <template>'s content into a fragment registered as `copy`'s

data/lib/dommy/element.rb

@@ -21,6 +21,19 @@ module Dommy
 
     # Public Ruby API (DocumentFragment surface)
 
+    # Node.cloneNode: a fresh, empty fragment, and — when `deep` — a clone of
+    # each child appended in tree order ("clone a node" step 5). Cloning the
+    # children one by one rather than re-parsing the fragment's serialization
+    # keeps each of them its own interface: a comment stays a comment, and a
+    # processing instruction does not come back as one.
+    def clone_node(deep = false)
+      copy = @document.create_document_fragment
+      return copy unless deep
+
+      child_nodes.each { |child| copy.append_child(child.clone_node(true)) }
+      copy
+    end
+
     def children
       element_children
     end
@@ -152,9 +165,7 @@ module Dommy
       when "isDefaultNamespace"
         is_default_namespace(args[0])
       when "cloneNode"
-        deep = args.empty? ? false : !!args[0]
-        deep ? @document.wrap_node(Parser.fragment(@__node__.to_html, owner_doc: @document.backend_doc)) : @document
-          .wrap_node(Parser.fragment("", owner_doc: @document.backend_doc))
+        clone_node(args.first)
       when "querySelector"
         query_selector(Internal.css_query_arg!(args))
       when "querySelectorAll"
@@ -227,7 +238,7 @@ module Dommy
     end
 
     def insert_before(node, ref)
-      coerce_node_argument!(node)
+      Internal::WebIDL.node!(node)
       ensure_pre_insertion_validity!(node, ref)
       ref_bn = ref.respond_to?(:__dommy_backend_node__) ? ref.__dommy_backend_node__ : nil
       ref_bn = nil unless ref_bn && ref_bn.parent == @__node__
@@ -250,7 +261,7 @@ module Dommy
     end
 
     def replace_child(new_child, old_child)
-      coerce_node_argument!(new_child)
+      Internal::WebIDL.node!(new_child)
       # WHATWG "replace" step 1 runs the full ensure-pre-insertion-validity,
       # whose step 2 (node is an inclusive ancestor of parent — a cycle) comes
       # BEFORE step 3 (the reference child's parentage). So
@@ -726,12 +737,20 @@ module Dommy
       super
     end
 
+    # Node.cloneNode. CharacterData has no children, so `deep` decides nothing:
+    # the copy is a new node of the SAME interface carrying the same data, owned
+    # by this node's document. Each subclass builds its own kind — a CDATASection
+    # that cloned to a Text would be the wrong node.
+    def clone_node(_deep = false)
+      @document.create_text_node(@__node__.text)
+    end
+
     # Own __js_call__ methods, on top of CharacterDataNode's.
     js_methods %w[cloneNode]
     def __js_call__(method, args)
       case method
       when "cloneNode"
-        @document.create_text_node(@__node__.text)
+        clone_node(args.first)
       else
         super
       end
@@ -744,6 +763,10 @@ module Dommy
     def node_type
       4
     end
+
+    def clone_node(_deep = false)
+      @document.create_cdata_section(@__node__.content)
+    end
   end
 
   class CommentNode < CharacterDataNode
@@ -751,12 +774,16 @@ module Dommy
       8
     end
 
+    def clone_node(_deep = false)
+      @document.create_comment(@__node__.content)
+    end
+
     # Own __js_call__ methods, on top of CharacterDataNode's.
     js_methods %w[cloneNode]
     def __js_call__(method, args)
       case method
       when "cloneNode"
-        @document.create_comment(@__node__.content)
+        clone_node(args.first)
       else
         super
       end
@@ -791,12 +818,16 @@ module Dommy
       end
     end
 
+    def clone_node(_deep = false)
+      @document.create_processing_instruction(@__node__.target, @__node__.content)
+    end
+
     # Own __js_call__ methods, on top of CharacterDataNode's.
     js_methods %w[cloneNode]
     def __js_call__(method, args)
       case method
       when "cloneNode"
-        @document.create_processing_instruction(@__node__.target, @__node__.content)
+        clone_node(args.first)
       else
         super
       end
@@ -1688,7 +1719,7 @@ module Dommy
     # inside a shadow tree, returns that ShadowRoot. Otherwise walks
     # until we hit the Nokogiri Document (then returns the Document).
     def root_node(options = nil)
-      composed = options.is_a?(Hash) && EventTarget.js_truthy?(options.key?("composed") ? options["composed"] : options[:composed])
+      composed = Node.composed_option?(options)
       sr = @document.__internal_shadow_root_containing__(@__node__)
       if sr
         # Default: the shadow root is the root. `composed: true` is
@@ -1786,8 +1817,24 @@ module Dommy
       attributes.set_named_item(attr)
     end
 
+    # setAttributeNodeNS is defined as the very same steps as setAttributeNode
+    # ("set an attribute"): the namespace is the Attr's own, so there is nothing
+    # left for the NS form to do differently. The JS bridge already routed it
+    # here; this is the Ruby caller's way in.
+    def set_attribute_node_ns(attr)
+      set_attribute_node(attr)
+    end
+
+    # removeAttributeNode step 1: "If this's attribute list does not contain
+    # attr, throw a NotFoundError." What counts is the Attr itself, not its
+    # name — one that belongs to another element, or to none, is not in this
+    # list even when this element has an attribute of the same name.
     def remove_attribute_node(attr)
-      return nil unless attr.respond_to?(:name)
+      owner = attr.owner_element if attr.respond_to?(:owner_element)
+      unless owner.equal?(self)
+        raise DOMException::NotFoundError,
+          "the attribute #{attr.respond_to?(:name) ? attr.name.inspect : attr.inspect} is not this element's"
+      end
 
       attributes.remove_named_item(attr.name)
     end
@@ -1982,7 +2029,7 @@ module Dommy
         raise DOMException::NotSupportedError, "<#{tag}> cannot host a shadow root"
       end
 
-      raise DOMException::NotSupportedError, "Shadow root already attached" if @__shadow_root
+      raise DOMException::NotSupportedError, "Shadow root already attached" if __internal_shadow_root__
 
       opts = options.is_a?(Hash) ? options : {}
       mode_raw = opts.key?("mode") ? opts["mode"] : opts[:mode]
@@ -2007,16 +2054,18 @@ module Dommy
     # `el.shadowRoot` — returns the attached ShadowRoot only when
     # mode is "open"; closed shadows are hidden from external code.
     def shadow_root
-      return nil unless @__shadow_root
-      return nil if @__shadow_root.mode == "closed"
+      root = __internal_shadow_root__
+      return nil if root.nil? || root.mode == "closed"
 
-      @__shadow_root
+      root
     end
 
     # Internal — gives access to the shadow root regardless of mode.
-    # Used by event composition / `composedPath()`.
+    # Used by event composition / `composedPath()`. The document's registry
+    # answers for a wrapper that is not the one attachShadow ran on: a custom
+    # element upgrade replaces the host's wrapper, not its shadow root.
     def __internal_shadow_root__
-      @__shadow_root
+      @__shadow_root ||= @document.__internal_shadow_root_for_host__(@__node__)
     end
 
     # `el.insertAdjacentElement(position, element)` — DOM spec positions:
@@ -2574,9 +2623,8 @@ module Dommy
     # so `a.href = "http://example.org/?ä"` reads back percent-encoded — which is
     # what the URL parser produces and what `URI.join` does not.
     def resolve_url(raw)
-      win = @document.default_view
-      base = win&.location ? win.location.href : ""
-      base = nil if base.to_s.empty?
+      base = @document.base_uri.to_s
+      base = nil if base.empty?
       Internal::UrlParser.serialize(Internal::UrlParser.parse(raw.to_s, base))
     rescue Internal::UrlParser::Failure
       raw.to_s
@@ -3261,7 +3309,7 @@ module Dommy
     end
 
     def insert_before(child, reference)
-      coerce_node_argument!(child)
+      Internal::WebIDL.node!(child)
       # WHATWG pre-insert validates the reference the CALLER gave (step 1), and
       # only then, in step 3, replaces it with the node's next sibling when it is
       # the node being inserted — so "insert x before x" doesn't move x. Doing
@@ -3299,7 +3347,7 @@ module Dommy
     end
 
     def remove_child(child)
-      coerce_node_argument!(child)
+      Internal::WebIDL.node!(child)
       node = unwrap_dom_node(child)
       unless node&.parent == @__node__
         raise DOMException::NotFoundError, "node is not a child of this element"
@@ -3315,8 +3363,8 @@ module Dommy
     # MutationObserver of both changes in one record so observers
     # see the swap atomically.
     def replace_child(new_child, old_child)
-      coerce_node_argument!(new_child)
-      coerce_node_argument!(old_child)
+      Internal::WebIDL.node!(new_child)
+      Internal::WebIDL.node!(old_child)
       # replaceChild shares the pre-insertion checks (ancestor, node type,
       # doctype placement); the reference child here is old_child, so step 3
       # also enforces that it is actually a child (NotFoundError otherwise).