RubyGems - dommy - Versions diffs - 0.9.0 → 0.10.0 - Mend

dommy 0.9.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

checksums.yaml +4 -4
data/lib/dommy/attr.rb +46 -8
data/lib/dommy/backend/makiri_adapter.rb +34 -0
data/lib/dommy/backend.rb +29 -0
data/lib/dommy/blob.rb +48 -6
data/lib/dommy/browser.rb +239 -36
data/lib/dommy/callable_invoker.rb +6 -2
data/lib/dommy/document.rb +525 -57
data/lib/dommy/element.rb +479 -239
data/lib/dommy/event.rb +296 -15
data/lib/dommy/fetch.rb +431 -25
data/lib/dommy/history.rb +24 -3
data/lib/dommy/html_collection.rb +145 -21
data/lib/dommy/html_elements.rb +1675 -266
data/lib/dommy/interaction/driver.rb +155 -14
data/lib/dommy/interaction/event_synthesis.rb +115 -7
data/lib/dommy/interaction/field_interactor.rb +60 -0
data/lib/dommy/internal/child_node.rb +199 -0
data/lib/dommy/internal/css/cascade.rb +44 -2
data/lib/dommy/internal/global_functions.rb +23 -10
data/lib/dommy/internal/mutation_coordinator.rb +27 -7
data/lib/dommy/internal/node_wrapper_cache.rb +56 -14
data/lib/dommy/internal/observer_manager.rb +6 -0
data/lib/dommy/internal/observer_matcher.rb +6 -8
data/lib/dommy/internal/parent_node.rb +37 -73
data/lib/dommy/internal/selector_matcher.rb +89 -0
data/lib/dommy/internal/selector_parser.rb +44 -7
data/lib/dommy/js/custom_element_bridge.rb +13 -2
data/lib/dommy/js/dom_interfaces.rb +19 -4
data/lib/dommy/js/host_bridge.rb +21 -0
data/lib/dommy/js/host_runtime.js +926 -64
data/lib/dommy/js/script_boot.rb +80 -0
data/lib/dommy/location.rb +76 -13
data/lib/dommy/mutation_observer.rb +3 -4
data/lib/dommy/navigation.rb +263 -0
data/lib/dommy/node.rb +180 -27
data/lib/dommy/range.rb +15 -3
data/lib/dommy/scheduler.rb +16 -0
data/lib/dommy/shadow_root.rb +33 -0
data/lib/dommy/storage.rb +61 -10
data/lib/dommy/tree_walker.rb +18 -36
data/lib/dommy/url.rb +4 -2
data/lib/dommy/version.rb +1 -1
data/lib/dommy/web_socket.rb +45 -2
data/lib/dommy/window.rb +126 -7
data/lib/dommy/xml_http_request.rb +30 -4
data/lib/dommy.rb +2 -0
metadata +6 -10

data/lib/dommy/document.rb CHANGED Viewed

@@ -14,20 +14,76 @@ module Dommy
   # DocumentType (`<!doctype html>`) — exposes name / publicId / systemId and
   # nodeType=10. HTML5 doctypes carry empty public/system IDs, but
   # `implementation.createDocumentType` can set them.
+  #
+  # Two modes:
+  #  * node-backed — wraps the Makiri DocumentType node of a parsed document
+  #    (`document.doctype`). Participates in the tree machinery
+  #    (compareDocumentPosition / getRootNode / sibling links) like any other
+  #    backend-backed node, via the shared Node mixin.
+  #  * synthetic — a standalone doctype (`implementation.createDocumentType`)
+  #    carrying just name/public/system id and an owner document. No backend node,
+  #    so it stays tree-DISCONNECTED per its detached nature.
   class DocumentType
     include Node
-    attr_reader :name
+    # Mixed into a node-backed doctype only, so a synthetic one does NOT respond
+    # to `__dommy_backend_node__` — leaving the Node mixin's guards (which key off
+    # `respond_to?(:__dommy_backend_node__)`) to treat it as disconnected.
+    module NodeBacked
+      def __dommy_backend_node__ = @__node__
+    end
+    # `owner_document:` links a synthetic doctype to its document so the ChildNode
+    # methods can act on the tree; a standalone one has none, so those methods are
+    # no-ops per spec. `backend_node:` + `document:` build the node-backed variant
+    # (a parsed-tree doctype or the createDocumentType factory node), which reads
+    # name/publicId/systemId straight off the node (the factory preserves case).
+    def initialize(name = "", public_id = "", system_id = "", owner_document: nil, backend_node: nil, document: nil)
+      @__node__ = backend_node
+      if backend_node
+        @document = document
+        @owner_document = document
+        extend(NodeBacked)
+      else
+        @name = name.to_s
+        @public_id = public_id.to_s
+        @system_id = system_id.to_s
+        @owner_document = owner_document
+      end
+    end
+    # The document this doctype currently belongs to (nil for a detached
+    # synthetic doctype). Lets a cross-document appendChild/insert detect that
+    # the node must be adopted (re-created) into the destination backend.
+    def document
+      @document || @owner_document
+    end
+    def name
+      @__node__ ? @__node__.name : @name
+    end
+    # Makiri reports nil for an absent public/system id; DOM exposes "".
+    def public_id
+      @__node__ ? @__node__.public_id.to_s : @public_id
+    end
+    def system_id
+      @__node__ ? @__node__.system_id.to_s : @system_id
+    end
+    def parent_node
+      # wrap_node maps the backend document node (the doctype's parent) to the
+      # Dommy Document.
+      @__node__ && @__node__.parent && @document.wrap_node(@__node__.parent)
+    end
+    def next_sibling
+      @__node__ && @__node__.next && @document.wrap_node(@__node__.next)
+    end
-    # `owner_document:` links a live doctype (document.doctype) to its document so
-    # the ChildNode methods (remove/before/after/replaceWith) act on the tree; a
-    # standalone doctype (DOMImplementation.createDocumentType) has none, so those
-    # methods are no-ops per spec.
-    def initialize(name, public_id = "", system_id = "", owner_document: nil)
-      @name = name.to_s
-      @public_id = public_id.to_s
-      @system_id = system_id.to_s
-      @owner_document = owner_document
+    def previous_sibling
+      @__node__ && @__node__.previous && @document.wrap_node(@__node__.previous)
     end
     # ChildNode mixin — the doctype's parent is the document.
@@ -61,33 +117,70 @@ module Dommy
     def __js_get__(key)
       case key
       when "name"
-        @name
+        name
       when "nodeName"
         # WHATWG: a DocumentType's nodeName is its name.
-        @name
+        name
       when "nodeType"
         10
       when "publicId"
-        @public_id
+        public_id
       when "systemId"
-        @system_id
+        system_id
       when "ownerDocument"
         @owner_document
+      when "parentNode"
+        parent_node
+      when "parentElement"
+        nil
+      when "nextSibling"
+        next_sibling
+      when "previousSibling"
+        previous_sibling
+      when "childNodes"
+        NodeList.new
+      when "firstChild", "lastChild"
+        nil
       end
     end
     include EventTarget
     def __internal_event_parent__
-      nil
+      parent_node
+    end
+    # Node.cloneNode on a doctype: a detached copy with the same name/publicId/
+    # systemId (a doctype is a leaf, so `deep` is irrelevant). Node-backed when a
+    # backend factory is available, else synthetic — either reports the same
+    # values and isEqualNode-matches the original.
+    def clone_node(_deep = false)
+      if @__node__ && @document
+        node = begin
+          Backend.create_document_type(name, public_id, system_id, @document.backend_doc)
+        rescue StandardError
+          nil
+        end
+        return DocumentType.new(backend_node: node, document: @document) if node
+      end
+      DocumentType.new(name, public_id, system_id, owner_document: @owner_document)
     end
     include Bridge::Methods
     js_methods %w[isEqualNode isSameNode getRootNode hasChildNodes normalize compareDocumentPosition contains
-      appendChild insertBefore removeChild replaceChild before after replaceWith remove
+      cloneNode appendChild insertBefore removeChild replaceChild before after replaceWith remove
+      lookupNamespaceURI lookupPrefix isDefaultNamespace
       addEventListener removeEventListener dispatchEvent]
     def __js_call__(method, args)
       case method
+      when "lookupNamespaceURI"
+        lookup_namespace_uri(args[0])
+      when "lookupPrefix"
+        lookup_prefix(args[0])
+      when "isDefaultNamespace"
+        is_default_namespace(args[0])
+      when "cloneNode"
+        clone_node(args[0])
       when "hasChildNodes"
         false
       when "contains"
@@ -101,11 +194,13 @@ module Dommy
         get_root_node(args[0])
       when "compareDocumentPosition"
         compare_document_position(args[0])
-      when "appendChild", "insertBefore"
+      when "appendChild", "insertBefore", "replaceChild"
+        # Pre-insert / replace step 1 rejects a non-parent context node with
+        # HierarchyRequestError before the reference-child check.
         raise Bridge::TypeError, "Argument is not a Node." unless args[0].is_a?(Dommy::Node)
         raise DOMException::HierarchyRequestError, "a DocumentType may not have children"
-      when "removeChild", "replaceChild"
+      when "removeChild"
         raise Bridge::TypeError, "Argument is not a Node." unless args[0].is_a?(Dommy::Node)
         raise DOMException::NotFoundError, "the node to be removed is not a child of this node"
@@ -117,6 +212,7 @@ module Dommy
         replace_with(*args)
       when "remove"
         remove
+        Bridge::UNDEFINED # DocumentType (ChildNode)#remove is void -> JS undefined
       when "normalize"
         nil
       when "addEventListener"
@@ -135,11 +231,24 @@ module Dommy
       @document = document
     end
-    # A created DocumentType's node document is the implementation's document.
-    # (Qualified-name validation against the QName production is not enforced —
-    # a couple of invalid-name WPT cases stay as documented gaps.)
+    # A created DocumentType's node document is the implementation's document. When
+    # the backend ships a doctype factory (the HTML backend) and accepts the name,
+    # the result is a real, node-backed (but detached) DocumentType that can join
+    # the tree; otherwise it falls back to a synthetic one. (Qualified-name QName
+    # validation isn't enforced — createDocumentType is permissive, so the factory's
+    # stricter name check is bypassed via the synthetic fallback rather than
+    # raising; a couple of invalid-name WPT cases stay documented gaps.)
     def create_document_type(qualified_name, public_id, system_id)
-      DocumentType.new(qualified_name, public_id, system_id, owner_document: @document)
+      qn = qualified_name.to_s
+      pub = public_id.to_s
+      sys = system_id.to_s
+      node =
+        begin
+          Backend.create_document_type(qn, pub, sys, @document.backend_doc)
+        rescue ArgumentError
+          nil
+        end
+      node ? DocumentType.new(backend_node: node, document: @document) : DocumentType.new(qn, pub, sys, owner_document: @document)
     end
     # `hasFeature()` is a no-op that always returns true (DOM Standard).
@@ -147,11 +256,10 @@ module Dommy
       true
     end
-    # createDocument(namespace, qualifiedName, doctype?) — a fresh XML document,
-    # with a document element (namespace, qualifiedName) when qualifiedName is
-    # non-empty. (The doctype argument is accepted but not stored, as document
-    # equality compares only structure that survives wrap_node.)
-    def create_document(namespace, qualified_name, _doctype = nil)
+    # createDocument(namespace, qualifiedName, doctype?) — a fresh XML document
+    # with, in tree order, the doctype (when given) then a document element
+    # (namespace, qualifiedName) when qualifiedName is non-empty.
+    def create_document(namespace, qualified_name, doctype = nil)
       doc = Document.new(nil, backend_doc: Backend.empty_xml_document)
       # createDocument's content type is keyed off the namespace. None is
       # "text/html", so tagName keeps its case; xhtml+xml still routes
@@ -168,9 +276,37 @@ module Dommy
         el = doc.send(:create_element_ns, namespace, qualified_name)
         Backend.set_document_root(doc.backend_doc, el.__dommy_backend_node__)
       end
+      adopt_doctype_into(doc, doctype)
       doc
     end
+    private
+    # Place `doctype` (a DocumentType passed to createDocument) as `doc`'s first
+    # child. Makiri can't move a node between documents, so — like adoption — the
+    # doctype is re-created in `doc`'s backend from its name/publicId/systemId.
+    # No-op for nil/undefined, a non-DocumentType, a backend without an XML doctype
+    # factory, or a public/system id the backend rejects (createDocument itself
+    # doesn't validate those — only XML *serialization* would — so a rejection just
+    # leaves the doctype unplaced rather than throwing).
+    def adopt_doctype_into(doc, doctype)
+      return if doctype.nil? || doctype.equal?(Bridge::UNDEFINED)
+      return unless doctype.is_a?(DocumentType)
+      node =
+        begin
+          Backend.create_document_type(doctype.name, doctype.public_id, doctype.system_id, doc.backend_doc)
+        rescue StandardError
+          nil
+        end
+      return unless node
+      root = doc.backend_doc.root
+      root ? root.add_previous_sibling(node) : doc.backend_doc.add_child(node)
+    end
+    public
     # createHTMLDocument(title?) — a fresh HTML document (doctype + html > head,
     # body), with an optional <title>.
     def create_html_document(title = nil)
@@ -190,7 +326,13 @@ module Dommy
       when "createDocument"
         create_document(args[0], args[1], args[2])
       when "createHTMLDocument"
-        create_html_document(args[0])
+        # title is an OPTIONAL DOMString: a missing or undefined argument leaves
+        # the document title-less, but an explicit null coerces to "null".
+        if args.empty? || args[0].equal?(Bridge::UNDEFINED)
+          create_html_document
+        else
+          create_html_document(args[0].nil? ? "null" : args[0])
+        end
       when "hasFeature"
         has_feature
       end
@@ -341,6 +483,10 @@ module Dommy
     # public/system identifier) is no-quirks. (The full quirks algorithm keys off
     # specific legacy public ids; this covers the common cases.)
     def compat_mode
+      # Only HTML documents can be in quirks mode; an XML document
+      # (createDocument / DOMParser XML) is always no-quirks.
+      return "CSS1Compat" unless html_document?
       dt = @backend_doc.internal_subset
       return "BackCompat" unless dt
       return "CSS1Compat" if dt.name.to_s.downcase == "html" && dt.external_id.nil?
@@ -364,7 +510,16 @@ module Dommy
     end
     def head
-      wrap_node(@backend_doc.at_css("head"))
+      # The first `head` element child of the document element in the HTML
+      # namespace (readonly — assignment is a no-op, see __js_set__). Not just
+      # `at_css("head")`, which searches the whole tree and ignores namespace.
+      root = document_element
+      return nil unless root
+      root.child_nodes.to_a.find do |c|
+        c.respond_to?(:local_name) && c.local_name == "head" &&
+          c.respond_to?(:namespace_uri) && c.namespace_uri == "http://www.w3.org/1999/xhtml"
+      end
     end
     # Resolve `body` fresh from the tree (not memoized) so it tracks a swapped
@@ -404,10 +559,12 @@ module Dommy
     end
     # `document.URL` / `documentURI` — both return location.href in
-    # real browsers (legacy aliases of the same field).
+    # real browsers (legacy aliases of the same field). A document with no
+    # browsing context (createDocument / new Document / DOMParser) has the URL
+    # "about:blank", not the empty string.
     def url
       view = @default_view
-      view&.location ? view.location.href : ""
+      view&.location ? view.location.href : "about:blank"
     end
     alias document_uri url
@@ -524,8 +681,12 @@ module Dommy
       return true if other.equal?(self)
       return false unless other.respond_to?(:__dommy_backend_node__)
+      # Walk parents up to the backend document node. (The backend's #ancestors
+      # stops below the document, so it can't test document membership; the
+      # doctype in particular reports an empty ancestor list.)
       node = other.__dommy_backend_node__
-      node.document == @backend_doc && node.ancestors.include?(@backend_doc)
+      node = node.parent while node && !node.equal?(@backend_doc)
+      !node.nil?
     end
     def __internal_set_active_element__(el)
@@ -608,6 +769,9 @@ module Dommy
     def import_node(node, deep = false)
       return nil unless node.respond_to?(:__dommy_backend_node__)
+      # WebIDL `optional boolean deep = false`: a missing / undefined argument
+      # is the default (false / shallow), not a truthy sentinel.
+      deep = false if deep.nil? || deep.equal?(Bridge::UNDEFINED)
       copy = clone_into_doc(node.__dommy_backend_node__, deep)
       wrap_node(copy)
     end
@@ -616,6 +780,10 @@ module Dommy
     # node is detached from its previous owner and its ownerDocument
     # becomes this. Returns the (possibly re-wrapped) node.
     def adopt_node(node)
+      # WHATWG adopt: a Document can't be adopted into another document.
+      if node.is_a?(Dommy::Document)
+        raise DOMException::NotSupportedError, "A Document node cannot be adopted."
+      end
       return nil unless node.respond_to?(:__dommy_backend_node__)
       src = node.__dommy_backend_node__
@@ -624,6 +792,27 @@ module Dommy
       # Same document: just return the wrapper after the detach above.
       return wrap_node(src) if src.document == @backend_doc
+      # Cross-document DocumentType: Makiri can't import a doctype node between
+      # arenas, so re-create it in this document's backend from its public
+      # name / publicId / systemId (as createDocument does), then reseat the
+      # caller's wrapper onto the new node so JS identity survives the move.
+      if node.is_a?(DocumentType)
+        adopted = begin
+          Backend.create_document_type(node.name, node.public_id, node.system_id, @backend_doc)
+        rescue StandardError
+          nil
+        end
+        return node unless adopted
+        src_doc_wrapper = node.instance_variable_get(:@document)
+        src_doc_wrapper.__internal_reset_wrapper__(src) if src_doc_wrapper.respond_to?(:__internal_reset_wrapper__)
+        node.instance_variable_set(:@document, self)
+        node.instance_variable_set(:@owner_document, self)
+        node.instance_variable_set(:@__node__, adopted)
+        @node_wrapper_cache.register(adopted, node)
+        return node
+      end
       # Cross-document: hand the detached source to the backend, which
       # returns the node now owned by this document — an imported copy for
       # Makiri (a node can't move between arenas). Drop the stale source
@@ -638,9 +827,69 @@ module Dommy
       node.instance_variable_set(:@document, self)
       node.instance_variable_set(:@__node__, adopted)
       @node_wrapper_cache.register(adopted, node)
+      # A deep adopt imports a fresh copy of the whole subtree, so any live
+      # descendant wrapper (held by page script, e.g. an aria element reference)
+      # must be reseated onto its corresponding copy — otherwise it stays bound to
+      # the old document. Import preserves document order, so walk both subtrees in
+      # lockstep.
+      reseat_descendant_wrappers(src, adopted, src_doc_wrapper)
       node
     end
+    # Move each live wrapper for a descendant of `src_root` onto the matching node
+    # in `dst_root` (the imported copy), pruning it from the source document.
+    def reseat_descendant_wrappers(src_root, dst_root, src_doc)
+      return unless src_doc.respond_to?(:__internal_peek_wrapper__)
+      src_nodes = collect_subtree_nodes(src_root)
+      dst_nodes = collect_subtree_nodes(dst_root)
+      return unless src_nodes.length == dst_nodes.length
+      src_nodes.zip(dst_nodes).each do |orig, copy|
+        next if orig.equal?(src_root) # the root wrapper is reseated by the caller
+        wrapper = src_doc.__internal_peek_wrapper__(orig)
+        next unless wrapper
+        src_doc.__internal_reset_wrapper__(orig)
+        wrapper.instance_variable_set(:@document, self)
+        wrapper.instance_variable_set(:@__node__, copy)
+        @node_wrapper_cache.register(copy, wrapper)
+      end
+    end
+    # HTML "cloning steps": a cloned node copies interface-specific live state
+    # that the content attributes don't capture — an input's dirty value and
+    # checkedness, a textarea's dirty value, etc. Dommy keeps that state on the
+    # Ruby wrapper (not the backend node), and a deep backend clone never calls
+    # the descendants' clone_node, so walk the original and cloned subtrees in
+    # lockstep and copy each live wrapper's cloning state onto its copy. `deep`
+    # false processes only the root (a shallow clone has no children).
+    def __internal_apply_cloning_steps__(src_root_bn, clone_root_bn, deep)
+      src_nodes = deep ? collect_subtree_nodes(src_root_bn) : [src_root_bn]
+      clone_nodes = deep ? collect_subtree_nodes(clone_root_bn) : [clone_root_bn]
+      return unless src_nodes.length == clone_nodes.length
+      src_nodes.zip(clone_nodes).each do |orig, copy|
+        wrapper = @node_wrapper_cache.peek(orig)
+        next unless wrapper.respond_to?(:__cloning_state__)
+        state = wrapper.__cloning_state__
+        next if state.nil?
+        @node_wrapper_cache.wrap(copy).__apply_cloning_state__(state)
+      end
+    end
+    # A subtree's nodes in document (depth-first) order — the order Backend.adopt
+    # preserves — so a source node and its imported copy line up by index.
+    def collect_subtree_nodes(root)
+      nodes = [root]
+      root.children.each { |child| nodes.concat(collect_subtree_nodes(child)) } if root.respond_to?(:children)
+      nodes
+    end
     # Legacy `document.createEvent("EventName")` factory. Returns an
     # Event subclass instance whose init still has to be called
     # (`event.initEvent(type, bubbles, cancelable)`). Matches the
@@ -738,14 +987,13 @@ module Dommy
       @node_iterators << iterator
     end
-    # Minimal DocumentType — represents the `<!doctype html>` line.
-    # Always present in HTML5 documents we parse, so we synthesize a
-    # stub object whose only useful field is `name`. Tests just need
-    # `nodeType == 10`.
+    # `document.doctype` — the node-backed DocumentType wrapping the parsed
+    # `<!DOCTYPE …>` node, or nil when the document declares none (or the doctype
+    # was removed, which unlinks the backend node). Shares wrapper identity with
+    # the same node in `childNodes`, since both wrap the same backend node.
     def doctype
-      return nil if @doctype_removed
-      @doctype ||= DocumentType.new("html", owner_document: self)
+      node = Backend.internal_subset(@backend_doc)
+      node ? wrap_node(node) : nil
     end
     def implementation
@@ -756,9 +1004,88 @@ module Dommy
       @node_wrapper_cache.create_processing_instruction(target, data)
     end
+    # WHATWG "ensure pre-insertion validity", step 6 — the Document-parent
+    # constraints an element-like parent doesn't have. `args` is the set of nodes
+    # (and DOMStrings) being inserted; per "converting nodes into a node" they're
+    # summed as one insertion. `child_bn` is the backend reference child (nil for
+    # append). `ignore_existing` (replaceChildren) drops the current children
+    # from the counts, since replace-all removes them first. `exclude` (replace)
+    # is a current child to disregard. Raises HierarchyRequestError on violation.
+    def ensure_document_insertion_validity!(args, child_bn, ignore_existing: false, exclude: nil)
+      elements = 0
+      doctypes = 0
+      has_text = false
+      args.each do |arg|
+        case arg
+        when String
+          has_text = true
+        when Dommy::Fragment
+          arg.child_nodes.each do |c|
+            if c.is_a?(Dommy::Element) then elements += 1
+            elsif c.is_a?(Dommy::DocumentType) then doctypes += 1
+            elsif c.is_a?(Dommy::TextNode) then has_text = true
+            end
+          end
+        when Dommy::DocumentType then doctypes += 1
+        when Dommy::Element then elements += 1
+        when Dommy::CharacterDataNode
+          # Comment (8) / PI (7) are valid document children; Text (3) is not.
+          has_text = true if arg.node_type == 3
+        when Dommy::Node
+          # A Document / Attr / anything else is not an insertable node type.
+          raise DOMException::HierarchyRequestError, "This node type cannot be inserted here."
+        end
+      end
+      # `existing` (with positions) drives the "doctype following / element
+      # preceding child" checks; those use the FULL child list, since `child`
+      # (the reference / node being replaced) is still in the tree. The
+      # "already has an element/doctype child" checks, however, disregard the
+      # node being replaced (`exclude`) — WHATWG replace's "...child that is not
+      # child" wording.
+      existing = ignore_existing ? [] : @backend_doc.children.to_a
+      has_element = existing.any? { |c| c.node_type == 1 && !(exclude && c == exclude) }
+      has_doctype = existing.any? { |c| c.node_type == 10 && !(exclude && c == exclude) }
+      # Step 6, Text/DocumentFragment-with-text: no text under a document.
+      raise DOMException::HierarchyRequestError, "A Text node cannot be a child of a document." if has_text
+      if doctypes.positive?
+        if doctypes > 1 || elements.positive? || has_doctype ||
+           element_before_child?(existing, child_bn) ||
+           (child_bn.nil? && has_element)
+          raise DOMException::HierarchyRequestError, "A doctype cannot be inserted here."
+        end
+      end
+      if elements > 1
+        raise DOMException::HierarchyRequestError, "Only one element may be a child of a document."
+      elsif elements == 1 &&
+            (has_element || (child_bn && child_bn.node_type == 10) || doctype_after_child?(existing, child_bn))
+        raise DOMException::HierarchyRequestError, "An element cannot be inserted here."
+      end
+    end
+    # Whether any element child precedes `child_bn` in the document's child list.
+    def element_before_child?(existing, child_bn)
+      idx = child_bn && existing.index { |c| c == child_bn }
+      return false unless idx
+      existing[0...idx].any? { |c| c.node_type == 1 }
+    end
+    # Whether any doctype child follows `child_bn` in the document's child list.
+    def doctype_after_child?(existing, child_bn)
+      idx = child_bn && existing.index { |c| c == child_bn }
+      return false unless idx
+      existing[idx..].any? { |c| c.node_type == 10 }
+    end
     # Append a node as a child of the document itself (e.g. a comment alongside
     # the document element). Adopts the node into this document.
     def append_child(node)
+      ensure_document_insertion_validity!([node], nil)
       return node unless node.respond_to?(:__dommy_backend_node__)
       # appendChild adopts a node from another document (per spec). Only needed on
@@ -773,7 +1100,9 @@ module Dommy
     # ParentNode / Node mutation on the document's direct children (the doctype
     # and the document element).
     def document_insert(args, prepend:)
-      nodes = args.filter_map { |a| backend_node(a) }
+      ref_bn = prepend ? @backend_doc.children.first : nil
+      ensure_document_insertion_validity!(args, ref_bn)
+      nodes = args.filter_map { |a| adopted_backend_node(a) }
       if prepend && (first = @backend_doc.children.first)
         nodes.reverse_each { |n| first.add_previous_sibling(n) }
       else
@@ -783,8 +1112,11 @@ module Dommy
     end
     def document_replace_children(args)
+      # replaceChildren removes the current children first, so the validity
+      # checks ignore them (whatwg/dom#1045).
+      ensure_document_insertion_validity!(args, nil, ignore_existing: true)
       @backend_doc.children.each(&:unlink)
-      args.filter_map { |a| backend_node(a) }.each { |n| @backend_doc.add_child(n) }
+      args.filter_map { |a| adopted_backend_node(a) }.each { |n| @backend_doc.add_child(n) }
       nil
     end
@@ -794,12 +1126,23 @@ module Dommy
       bn = backend_node(node)
       raise DOMException::NotFoundError, "node is not a child of this document" unless bn && bn.parent == @backend_doc
+      run_node_iterator_pre_remove(bn)
       bn.unlink
       node
     end
     def document_insert_before(node, ref)
-      bn = backend_node(node)
+      # WHATWG pre-insert order: the reference child must be a child of the
+      # parent (step 3, NotFoundError) BEFORE the node-type / document-hierarchy
+      # checks (steps 4-6).
+      ref_present = !(ref.nil? || (defined?(Bridge::UNDEFINED) && ref.equal?(Bridge::UNDEFINED)))
+      ref_bn = ref_present ? backend_node(ref) : nil
+      if ref_present && !(ref_bn && ref_bn.parent == @backend_doc)
+        raise DOMException::NotFoundError, "The reference child is not a child of this document."
+      end
+      ensure_document_insertion_validity!([node], ref_bn)
+      bn = adopted_backend_node(node)
       return node unless bn
       ref_node = ref && backend_node(ref)
@@ -815,17 +1158,33 @@ module Dommy
       old_bn = backend_node(old_child)
       raise DOMException::NotFoundError, "node is not a child of this document" unless old_bn && old_bn.parent == @backend_doc
-      new_bn = backend_node(new_child)
-      old_bn.add_previous_sibling(new_bn) if new_bn
+      # replaceChild's validity disregards the node being replaced when counting
+      # the document's existing element / doctype children.
+      ensure_document_insertion_validity!([new_child], old_bn, exclude: old_bn)
+      # Remove old FIRST, then adopt the incoming node. A cross-document doctype
+      # is re-created in this backend, and Makiri's fail-closed guard refuses a
+      # second doctype — so the old one must be gone before the new is made.
+      ref = old_bn.next
       old_bn.unlink
+      if !Backend.moves_nodes_across_documents? && new_child.respond_to?(:document) && !new_child.document.equal?(self)
+        new_child = adopt_node(new_child)
+      end
+      new_bn = backend_node(new_child)
+      if new_bn
+        ref && ref.parent == @backend_doc ? ref.add_previous_sibling(new_bn) : @backend_doc.add_child(new_bn)
+      end
       old_child
     end
-    # Called by DocumentType#remove — the doctype is synthesized from the DTD, so
-    # remove the internal subset and mark it gone.
-    def __internal_remove_doctype__(_doctype)
-      @doctype_removed = true
-      @backend_doc.internal_subset&.unlink
+    # Called by DocumentType#remove — unlink the backend doctype node so the tree
+    # (and `document.doctype`, which re-derives from the tree) no longer sees it.
+    def __internal_remove_doctype__(doctype)
+      node = backend_node(doctype) || Backend.internal_subset(@backend_doc)
+      return nil unless node
+      run_node_iterator_pre_remove(node)
+      node.unlink
       nil
     end
@@ -854,6 +1213,21 @@ module Dommy
       node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__ : nil
     end
+    # Like `backend_node`, but first adopts a node that belongs to another
+    # document (per the insert steps) — the document-child insert paths
+    # (append / prepend / replaceChildren / insertBefore) need this exactly as
+    # `append_child` does, otherwise a cross-document node's backend node comes
+    # from a foreign arena and the insertion silently drops it on a backend that
+    # can't move nodes across documents (Makiri).
+    def adopted_backend_node(node)
+      return nil unless node.respond_to?(:__dommy_backend_node__)
+      if !Backend.moves_nodes_across_documents? && node.respond_to?(:document) && !node.document.equal?(self)
+        node = adopt_node(node)
+      end
+      node.__dommy_backend_node__
+    end
     # Delegate to CookieJar
     def cookie
@@ -916,7 +1290,8 @@ module Dommy
     # Create a Comment node. Wraps the Makiri comment so it flows
     # through the same wrap_node identity machinery as Element / TextNode.
     def create_comment(text)
-      @node_wrapper_cache.create_comment(text)
+      # WebIDL DOMString: JS null coerces to "null" (undefined -> "undefined").
+      @node_wrapper_cache.create_comment(text.nil? ? "null" : text)
     end
     def create_cdata_section(text)
@@ -966,6 +1341,10 @@ module Dommy
         cookie
       when "nodeType"
         9
+      when "nodeValue", "textContent"
+        # A Document's nodeValue and textContent are null (not the concatenated
+        # descendant text) per the DOM.
+        nil
       when "activeElement"
         active_element
       when "URL", "documentURI"
@@ -1050,10 +1429,65 @@ module Dommy
       when "nodeName"
         "#document"
       else
-        Bridge::ABSENT # unknown property: JS undefined, `in` reports absent
+        # WebIDL named getter: `document.someName` exposes a named embed / form /
+        # iframe / img / object element (or an img/object by id). Unknown
+        # otherwise → JS undefined.
+        named = document_named_property(key.to_s)
+        named.nil? ? Bridge::ABSENT : named
+      end
+    end
+    # The document's supported property names (for `"name" in document`): the
+    # `name` of each exposed element, plus the `id` of id-exposed img/object.
+    def __js_named_props__
+      names = []
+      named_getter_nodes.each do |node|
+        n = node["name"].to_s
+        names << n unless n.empty?
+        id = node["id"].to_s
+        names << id if !id.empty? && %w[img object].include?(node.name.to_s.downcase) && !n.empty?
       end
+      names.uniq
+    end
+    # Resolve a document named-getter property: nil when unsupported, a single
+    # element (a named iframe yields its content window), or an HTMLCollection
+    # when several elements share the name.
+    def document_named_property(name)
+      return nil if name.empty?
+      matches = named_getter_nodes.select do |node|
+        node["name"] == name ||
+          (node["id"] == name && %w[img object].include?(node.name.to_s.downcase) && !node["name"].to_s.empty?)
+      end
+      wrapped = matches.map { |node| wrap_node(node) }.compact
+      return nil if wrapped.empty?
+      if wrapped.length == 1
+        el = wrapped.first
+        cw = el.respond_to?(:content_window) ? el.content_window : nil
+        cw || el
+      else
+        HTMLCollection.new { document_named_property_nodes(name) }
+      end
+    end
+    private
+    # Elements the document's named getter exposes, in tree order.
+    def named_getter_nodes
+      @backend_doc.css("embed, form, iframe, img, object")
+    end
+    def document_named_property_nodes(name)
+      named_getter_nodes.select do |node|
+        node["name"] == name ||
+          (node["id"] == name && %w[img object].include?(node.name.to_s.downcase) && !node["name"].to_s.empty?)
+      end.map { |node| wrap_node(node) }.compact
     end
+    public
     def __js_set__(key, value)
       case key
       when "title"
@@ -1070,6 +1504,10 @@ module Dommy
         # `document.location = url` navigates, same as `location.href = url`.
         loc = @default_view&.__js_get__("location")
         loc&.__js_set__("href", value)
+      when "head", "documentElement"
+        # Readonly attributes: assignment is a silent no-op. Handle it here so the
+        # bridge doesn't store a JS-side expando that would shadow the getter.
+        nil
       else
         return Bridge::UNHANDLED
       end
@@ -1084,12 +1522,19 @@ module Dommy
       getElementsByClassName getElementsByTagName getElementsByTagNameNS getElementsByName createAttribute
       createAttributeNS createTreeWalker createNodeIterator createRange createEvent importNode
       adoptNode hasFocus getSelection elementFromPoint queryCommandSupported addEventListener
-      removeEventListener dispatchEvent write writeln open close isEqualNode appendChild
+      removeEventListener dispatchEvent write writeln open close isEqualNode isSameNode appendChild
       hasChildNodes contains append prepend replaceChildren removeChild insertBefore replaceChild
       cloneNode normalize compareDocumentPosition getRootNode
+      lookupNamespaceURI lookupPrefix isDefaultNamespace
     ]
     def __js_call__(method, args)
       case method
+      when "lookupNamespaceURI"
+        lookup_namespace_uri(args[0])
+      when "lookupPrefix"
+        lookup_prefix(args[0])
+      when "isDefaultNamespace"
+        is_default_namespace(args[0])
       when "getRootNode"
         # A document is its own root (no shadow tree above it), for any options.
         # Exposing this is load-bearing: React's resource hoisting computes its
@@ -1104,6 +1549,8 @@ module Dommy
         contains?(args[0])
       when "isEqualNode"
         is_equal_node(args[0])
+      when "isSameNode"
+        is_same_node(args[0])
       when "appendChild"
         append_child(args[0])
       when "append"
@@ -1115,6 +1562,11 @@ module Dommy
       when "removeChild"
         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
         document_insert_before(args[0], args[1])
       when "replaceChild"
         document_replace_child(args[0], args[1])
@@ -1246,6 +1698,10 @@ module Dommy
       @node_wrapper_cache.wrap(node)
     end
+    def wrap_cloned_element_ns(node, namespace, prefix, local, qualified_name)
+      @node_wrapper_cache.wrap_cloned_element_ns(node, namespace, prefix, local, qualified_name)
+    end
     # Clear the cached wrapper so the next `wrap_node` creates a new
     # one. Used by `customElements.define` to upgrade nodes that were
     # constructed before the registration landed.
@@ -1253,6 +1709,10 @@ module Dommy
       @node_wrapper_cache.reset_wrapper(nokogiri_node)
     end
+    def __internal_peek_wrapper__(nokogiri_node)
+      @node_wrapper_cache.peek(nokogiri_node)
+    end
     # ShadowRoot identity registry: map a Nokogiri DocumentFragment
     # (the shadow tree's backing node) to the wrapping ShadowRoot so
     # slot assignment and event composition can walk from any inner
@@ -1380,7 +1840,8 @@ module Dommy
     end
     def create_text_node(text)
-      @node_wrapper_cache.create_text_node(text)
+      # WebIDL DOMString: JS null coerces to "null" (undefined -> "undefined").
+      @node_wrapper_cache.create_text_node(text.nil? ? "null" : text)
     end
     def query_selector(selector)
@@ -1402,7 +1863,9 @@ module Dommy
     end
     def get_element_by_id(id)
-      @node_wrapper_cache.get_element_by_id(id)
+      # WebIDL DOMString: a null argument coerces to "null" (so it can match an
+      # element with id="null"); undefined already stringifies to "undefined".
+      @node_wrapper_cache.get_element_by_id(id.nil? ? "null" : id)
     end
     # ----- template content helpers (called from Element) -----
@@ -1485,9 +1948,14 @@ module Dommy
     end
     def read_title
-      head = @backend_doc.at_css("head")
-      title = head&.at_css("title")
-      title ? title.text : ""
+      # The first title element in tree order (usually the head's), with its
+      # child text content stripped and collapsed of ASCII whitespace per WHATWG.
+      # ASCII whitespace is exactly tab/LF/FF/CR/space — NOT Ruby's String#strip
+      # set, which also removes U+000B (vertical tab) and must be left intact.
+      title = @backend_doc.at_css("title")
+      return "" unless title
+      title.text.gsub(/[\t\n\f\r ]+/, " ").gsub(/\A[\t\n\f\r ]+|[\t\n\f\r ]+\z/, "")
     end
     def write_title(value)