dommy 0.14.0 → 0.16.0

data/lib/dommy/bridge/values.rb

@@ -3,8 +3,8 @@
 module Dommy
   module Bridge
     # The Ruby shapes a JS value takes while it is on this side: an opaque
-    # reference, and the two byte buffers that cross as a typed array or a bare
-    # ArrayBuffer.
+    # reference (a Date one carrying its time value), and the two byte buffers
+    # that cross as a typed array or a bare ArrayBuffer.
 
     # An opaque handle to a JS-side value that Ruby only stores and hands back
     # (an AbortSignal's reason, a CustomEvent's detail). A non-plain JS object
@@ -35,6 +35,33 @@ module Dommy
       def inspect = "#<Dommy::Bridge::JSValue #{to_s}>"
     end
 
+    # A JS Date that crossed into Ruby. It is still an opaque reference, so
+    # handing it back returns the same Date, but it also carries its time value
+    # (ms since the epoch, NaN for an invalid date) — the one thing a host API
+    # taking a Date (`input.valueAsDate = d`) needs to read off it. A Date the
+    # host creates crosses from a Ruby ::Time instead.
+    class Date < JSValue
+      # The largest time value a JS Date can hold, either side of the epoch.
+      MAX_TIME_VALUE = 8_640_000_000_000_000
+
+      # The time value a JS Date made from `time` holds — ECMAScript's TimeClip:
+      # whole milliseconds truncated toward zero (0.1 ms before the epoch is 0,
+      # not -1), and NaN beyond MAX_TIME_VALUE.
+      def self.time_value_of(time)
+        ms = (time.to_r * 1000).truncate
+        ms.abs > MAX_TIME_VALUE ? ::Float::NAN : ms.to_f
+      end
+
+      attr_reader :time_value
+
+      def initialize(ref, time_value)
+        super(ref, nil, nil, "Date")
+        @time_value = time_value
+      end
+
+      def inspect = "#<Dommy::Bridge::Date #{time_value}>"
+    end
+
     # A byte buffer that crosses the JS boundary as a `Uint8Array` (rather than a
     # plain Array). Wrap a host method's byte-array result in this so JS sees a
     # real typed array — e.g. `TextEncoder#encode`, `Blob#arrayBuffer`. The

data/lib/dommy/bridge/wire_tags.rb

@@ -25,10 +25,6 @@ module Dommy
       # method set) instead of a `__rb_host_describe` round trip per new proxy —
       # the dominant overhead when JS traverses/builds many nodes.
       INTERFACE = "__rb_if"
-      # The custom-element tag of a handle whose node is a registered custom
-      # element (so makeProxy upgrades it), carried per-instance since it is the
-      # one part of a describe that is NOT per-interface.
-      CUSTOM_ELEMENT = "__rb_ce"
       # A live JS function that crossed into Ruby, referenced by callback id.
       CALLBACK = "__rb_callback"
       # An opaque JS value referenced by its id in the JS-side `jsRefs` table
@@ -58,6 +54,10 @@ module Dommy
       BYTES = "__rb_bytes"
       # A byte buffer crossing as a bare JS ArrayBuffer.
       ARRAY_BUFFER = "__rb_arraybuffer"
+      # A JS Date's time value (ms since the epoch). Host -> JS it builds a new
+      # Date; JS -> host it decorates a JS_REF, so the Date keeps its identity
+      # and the host can still read the time (see Dommy::Bridge::Date).
+      DATE = "__rb_date"
       # A host-raised DOMException/TypeError/RangeError, re-thrown JS-side.
       EXCEPTION = "__rb_exception__"
       # A host-created native JS error (TypeError/RangeError) crossing as a VALUE
@@ -68,6 +68,10 @@ module Dommy
       THROW = "__rb_throw__"
       # A callback whose JS invocation threw (the thrown value is carried here).
       CALLBACK_THREW = "__rb_cb_threw__"
+      # A structured-serialization record the JS realm holds (by id), crossing
+      # as an opaque Dommy::Js::SerializedRecord (see host_runtime.js
+      # serializedTag).
+      SERIALIZED = "__rb_serialized"
     end
   end
 end

data/lib/dommy/browser.rb

@@ -71,21 +71,50 @@ module Dommy
       @console = []
       @disposed = false
       @pending_navigations = []
+      @popups = []
       @runtime = nil
+      # One browsing session: every window it shows (and their frames) shares
+      # localStorage per origin and sessionStorage per origin.
+      @storage_provider = StorageProvider.new
+      # One cookie store for the session: document.cookie, cookieStore, and
+      # the Cookie / Set-Cookie of every request it sends through resources.
+      @cookie_jar = CookieJar.new
+      @before_unload_handler = nil
 
       @window = Dommy.parse(html)
       @window.location.__internal_set_url__(url) if url
-      install_runtime(@window)
+      @window.storage_provider = @storage_provider
+      @window.cookie_jar = @cookie_jar
 
       if navigable
-        @fetcher = Navigation::Fetcher.new(@resources, same_origin: @same_origin)
+        @fetcher = navigation_fetcher
         @history = Navigation::JointHistory.new
         @window.navigation_delegate = self
         @history.push(current_url, window: @window, windex: @window.history.__internal_index__)
+        install_history_sync(@window)
       end
+      install_runtime(@window)
       check_js_errors!
     end
 
+    # The provider of this browser's Web Storage areas (shared by every window
+    # it shows); see Dommy::StorageProvider.
+    attr_reader :storage_provider
+
+    # This browser's cookies (a Dommy::CookieJar): the one store its pages'
+    # document.cookie and cookieStore use and its requests send and fill.
+    attr_reader :cookie_jar
+
+    # Install a handler for a page that asks to confirm leaving it (a canceled
+    # `beforeunload`, or one whose returnValue is set): called with the window
+    # and the BeforeUnloadEvent, its truthy answer lets the navigation proceed.
+    # Without one the navigation always proceeds — a headless page has no sticky
+    # user activation, so a browser would not prompt either.
+    def on_before_unload(&block)
+      @before_unload_handler = block
+      self
+    end
+
     def document = @window.document
 
     # Current document HTML (serialized).
@@ -117,8 +146,8 @@ module Dommy
     # Move back / forward one entry in the joint history. A same-document target
     # (the entry's window is still live) traverses in place (popstate); a
     # document-boundary target is re-fetched (no bfcache — D2).
-    def back = traverse(-1)
-    def forward = traverse(1)
+    def back = traverse_now(-1)
+    def forward = traverse_now(1)
 
     # --- NavigationDelegate port (see Dommy::Navigation) ---
 
@@ -138,7 +167,7 @@ module Dommy
         navigate_frame(frame,
           {method: method, url: url, params: params, body: body, enctype: enctype, headers: headers},
           resolve_against_current(url.to_s))
-        @window.scheduler.queue_microtask(proc { frame.dispatch_event(Dommy::Event.new("load")) })
+        @window.scheduler.queue_microtask(proc { frame.__internal_run_iframe_load_event_steps__ })
         return nil
       end
 
@@ -164,6 +193,109 @@ module Dommy
       end
 
       def traverse(_delta) = nil
+
+      def history_length = @browser.history_length
+
+      # The frames of the document loaded into this frame load the same way.
+      def load_frame(frame, **nav) = @browser.load_frame(frame, **nav)
+
+      # A popup opened from inside the frame is the browser's too.
+      def open_window(**opts) = @browser.open_window(**opts)
+    end
+
+    # The navigation delegate of an auxiliary window this browser opened
+    # (window.open): its navigations load into it, keeping the Window the
+    # opener holds (Dommy has no WindowProxy, so the document is swapped
+    # under it), and its close() closes it.
+    class PopupDelegate
+      def initialize(browser, popup)
+        @browser = browser
+        @popup = popup
+      end
+
+      def navigate(url:, source:, method: "GET", body: nil, params: nil, enctype: nil, target: nil, headers: {}, replace: false)
+        @browser.__internal_load_popup__(@popup, {url: url, method: method, body: body, params: params,
+                                                  enctype: enctype, headers: headers})
+      end
+
+      def traverse(_delta) = nil
+
+      def close_window = @browser.__internal_close_popup__(@popup)
+
+      def find_window(name) = @browser.find_window(name)
+
+      def load_frame(frame, **nav) = @browser.load_frame(frame, **nav)
+
+      def open_window(**opts) = @browser.open_window(**opts)
+    end
+
+    # The auxiliary windows the page opened with window.open and has not
+    # closed, oldest first.
+    def popups = @popups.dup
+
+    # NavigationDelegate `open_window`: window.open asked for a new top-level
+    # browsing context. It is created at once with the initial about:blank
+    # (whose origin is the opener's) and navigated to `url` from a task; it
+    # shares this browser's cookies and localStorage, and starts its
+    # sessionStorage as a copy of this one's. Window#window_open sets its
+    # opener and name.
+    def open_window(url:, target:, features: "")
+      return nil if @disposed
+
+      popup = Dommy.parse(Internal::ChildNavigable::BLANK_HTML)
+      popup.location.__internal_set_url__("about:blank")
+      popup.__internal_initial_about_blank__ = true
+      popup.storage_provider = @storage_provider.new_session
+      popup.cookie_jar = @cookie_jar
+      popup.navigation_delegate = PopupDelegate.new(self, popup)
+      @popups << popup
+      unless Internal::ChildNavigable.matches_about_blank?(url)
+        @window.scheduler.set_timeout(proc { __internal_load_popup__(popup, {url: url, method: "GET"}) }, 0)
+      end
+      popup
+    end
+
+    # Load a navigation into a popup: fetch it, give the popup's Window the
+    # document, and fire its load. Nothing happens when nothing serves it.
+    def __internal_load_popup__(popup, nav)
+      return nil if @disposed || @resources.nil? || !@popups.include?(popup)
+
+      url = nav[:url].to_s
+      @fetcher ||= navigation_fetcher
+      response, final_url = begin
+        @fetcher.request(method: nav[:method] || "GET", url: url, params: nav[:params],
+                         body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {})
+      rescue StandardError
+        [nil, url]
+      end
+      return nil unless response && document_response?(response)
+
+      loaded = Internal::ChildNavigable.window_for_response(response.body, response_header(response, "content-type"), final_url)
+      popup.__internal_adopt_document_of__(loaded)
+      popup.navigation_delegate = PopupDelegate.new(self, popup)
+      document = popup.document
+      document.__internal_update_readiness__("loading")
+      document.__internal_finish_loading__
+      nil
+    end
+
+    # NavigationDelegate `find_window`: the top-level window (this browser's
+    # page or a popup) or a frame in one, whose target name is `name`.
+    def find_window(name)
+      ([@window] + @popups).each do |top|
+        return top if top.name == name
+
+        found = top.__internal_find_descendant_window__(name)
+        return found if found
+      end
+      nil
+    end
+
+    # A popup's close(): it leaves the browser, closed.
+    def __internal_close_popup__(popup)
+      @popups.delete(popup)
+      popup.__internal_discard__
+      nil
     end
 
     def frame_navigation_delegate(frame) = FrameNavigationDelegate.new(self, frame)
@@ -179,26 +311,49 @@ module Dommy
         nav[:url].to_s
       end
       navigate_frame(frame, nav, resolved)
-      frame.dispatch_event(Dommy::Event.new("load"))
+      frame.__internal_run_iframe_load_event_steps__
       nil
     end
 
-    # A cross-document history traversal. Ruby-initiated (back / forward), so it
-    # runs immediately: a same-document target (its window is still live)
-    # traverses in place (popstate); a document-boundary target is re-fetched.
+    # NavigationDelegate `load_frame`: an iframe's child navigable is navigating
+    # to `url` (its `src`, or a navigation from inside it) — fetch it through
+    # this browser's resources and answer the document's Window, or nil when
+    # nothing serves it (the frame then keeps its document). The frame installs
+    # it and fires its own `load`.
+    def load_frame(frame, url:, method: "GET", body: nil, params: nil, enctype: nil, headers: {}, **)
+      return nil if @disposed || @resources.nil?
+
+      frame_window_for(frame, {url: url, method: method, body: body, params: params, enctype: enctype, headers: headers}, url.to_s)
+    end
+
+    # A history traversal by `delta` that the PAGE asked for (`history.go(n)`
+    # past its own document's entries): like a navigation it is a task, so it
+    # is recorded and performed at the next drain boundary.
     def traverse(delta)
-      return self unless @navigable
+      @pending_navigations << {traverse: delta.to_i} if @navigable
+      nil
+    end
 
-      entry = delta.negative? ? @history.back : @history.forward
-      return self unless entry
+    # `history.length`: the joint session history's size (nil when this
+    # browser keeps none).
+    def history_length = (@history.length if @navigable)
 
-      if entry.window && entry.window.equal?(@window)
-        @window.history.__internal_go_to__(entry.windex)
-        @runtime.drain_microtasks
-        check_js_errors!
-      else
-        perform_navigation!({url: entry.url, method: "GET", source: :traverse}, rebind: true)
-      end
+    # `window.stop()`: drop the navigations the page asked for and that have not
+    # been performed yet.
+    def stop
+      @pending_navigations.clear
+      nil
+    end
+
+    # A Ruby-initiated traversal (back / forward) runs immediately: a
+    # same-document target (its window is still live) traverses in place
+    # (popstate); a document-boundary target is re-fetched.
+    def traverse_now(delta)
+      return self unless @navigable
+
+      perform_traversal!(delta)
+      @runtime.drain_microtasks
+      check_js_errors!
       self
     end
 
@@ -221,6 +376,7 @@ module Dommy
     # `setTimeout(300)` — use `advance_time(300)` for debounce/throttle.
     def settle
       @runtime.settle
+      drive_popups(0)
       flush_navigation!
       check_js_errors!
       self
@@ -229,6 +385,7 @@ module Dommy
     # Advance virtual time by `ms`, running timers that come due, then settle.
     def advance_time(ms)
       @window.scheduler.advance_time(ms)
+      drive_popups(ms)
       @runtime.drain_microtasks
       flush_navigation!
       check_js_errors!
@@ -240,6 +397,7 @@ module Dommy
     # land before the next line, then enforce strict mode.
     def after_interaction
       @runtime.drain_microtasks
+      drive_popups(0)
       flush_navigation!
       check_js_errors!
     end
@@ -298,7 +456,7 @@ module Dommy
       @runtime&.dispose
       # The JS engine is pluggable: `@backend` selects a registered runtime
       # (nil → the configured default, QuickJS when dommy-js-quickjs is loaded).
-      runtime = Js.build_runtime(@backend)
+      runtime = Js::ModulePreload.build_runtime(window.document, @backend)
       # Every uncaught error the page produces goes through the window's
       # "report an exception" / "notify about rejected promises" funnel, and only
       # what the page left unhandled lands here. A page that installs its own
@@ -319,7 +477,10 @@ module Dommy
       # Opt-in WPT scaffolding (common/sab.js derives SharedArrayBuffer through
       # WebAssembly.Memory); off by default so real pages don't see the shim.
       runtime.install_wasm_memory_shim if @wasm_memory_shim && runtime.respond_to?(:install_wasm_memory_shim)
-      window.globals["__fetch_handler__"] = Resources::FetchHandler.new(@resources) if @resources
+      if @resources
+        window.globals["__fetch_handler__"] =
+          Resources::FetchHandler.new(@resources, cookie_jar: @cookie_jar, origin: -> { window.origin })
+      end
       @runtime = runtime
       doc = window.document
       # An `on*` attribute that arrived after boot (a cloned template, an
@@ -327,7 +488,7 @@ module Dommy
       # Installed whenever a runtime is attached — an embedder that drives script
       # boot itself (`execute_scripts: false`) still needs inline handlers wired.
       doc.inline_handler_wirer = lambda do
-        Js::ScriptBoot.wire_inline_handlers(runtime, on_error: ->(e) { @error_log.record(e) })
+        Js::ScriptBoot.wire_inline_handlers(runtime, document: doc, on_error: ->(e) { @error_log.record(e) })
       end
       return unless @execute_scripts
 
@@ -348,6 +509,16 @@ module Dommy
       runtime.settle if @settle_after_boot
     end
 
+    # A popup has no realm of its own; the tasks queued on its window (a
+    # close(), its timers) run as the browser's time moves.
+    def drive_popups(ms)
+      @popups.dup.each { |popup| popup.scheduler.advance_time(ms) }
+    end
+
+    def navigation_fetcher
+      Navigation::Fetcher.new(@resources, same_origin: @same_origin, cookie_jar: @cookie_jar)
+    end
+
     # Route an unhandled promise rejection through the page's own
     # `unhandledrejection` handling first. The engine decides WHEN a rejection
     # counts as unhandled (see Window#__internal_report_rejection__).
@@ -371,22 +542,31 @@ module Dommy
       frame = resolve_target_frame(nav[:target])
       return navigate_frame(frame, nav, resolved) if frame
 
+      # The outgoing page may ask to confirm leaving (beforeunload).
+      return unless unloading_allowed?(@window)
+
       response, final_url = @fetcher.request(
         method: nav[:method] || "GET", url: resolved, params: nav[:params],
         body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {}
       )
       return unless response&.success? && document_response?(response)
 
+      old_window = @window
+      referrer = referrer_for(nav[:source], old_window.location.href, final_url)
       # Fire the outgoing document's unload sequence while its realm is still
       # alive, then surface any of its errors before the realm is torn down.
-      fire_unload(@window)
+      fire_unload(old_window)
       check_js_errors!
 
-      new_window = Dommy.parse(response.body)
+      new_window = Dommy.parse(Encodings.decode_document(response.body, response_header(response, "content-type")))
       new_window.location.__internal_set_url__(final_url)
+      new_window.document.__internal_set_last_modified__(response_header(response, "last-modified"))
+      new_window.document.__internal_referrer__ = referrer if referrer
       new_window.navigation_delegate = self
+      new_window.storage_provider = @storage_provider
+      new_window.cookie_jar = @cookie_jar
+      old_window.__internal_discard__
       @window = new_window
-      install_runtime(new_window)
 
       windex = new_window.history.__internal_index__
       if rebind || nav[:replace]
@@ -394,10 +574,82 @@ module Dommy
       else
         @history.push(final_url, window: new_window, windex: windex)
       end
+      # The joint history knows the new page before its scripts boot, so a
+      # pushState / history.length during boot sees the right session.
+      install_history_sync(new_window)
+      install_runtime(new_window)
 
       follow_meta_refresh!(refresh_depth)
     end
 
+    # Fire `beforeunload` at the outgoing window; a page that cancels it (or
+    # sets returnValue) is asked about through the on_before_unload handler, if
+    # one is installed.
+    def unloading_allowed?(window)
+      event = BeforeUnloadEvent.new("beforeunload", "cancelable" => true).__internal_mark_trusted__
+      not_canceled = window.dispatch_event(event)
+      return true if not_canceled && event.return_value.to_s.empty?
+      return true unless @before_unload_handler
+
+      @before_unload_handler.call(window, event) ? true : false
+    end
+
+    # The `document.referrer` a navigation hands the new document: the page
+    # that started it (links, forms, script), under the default
+    # strict-origin-when-cross-origin policy — the full URL (without fragment
+    # or credentials) within an origin, only the origin across origins, nothing
+    # on an https -> http downgrade. Ruby-initiated visits and traversals carry
+    # none.
+    def referrer_for(source, from_url, to_url)
+      return nil unless %i[link form location window_open].include?(source)
+
+      from = URL.new(from_url.to_s)
+      to = URL.new(to_url.to_s)
+      return nil unless %w[http: https:].include?(from.protocol)
+      return "" if from.protocol == "https:" && to.protocol == "http:"
+      return "#{from.origin}/" unless from.origin == to.origin
+
+      from.hash = ""
+      from.username = ""
+      from.password = ""
+      from.href
+    rescue StandardError
+      nil
+    end
+
+    # A traversal by `delta` of the joint history: within the live window's own
+    # entries it moves that window's history (popstate); across a document
+    # boundary the target entry's URL is re-fetched (no bfcache).
+    def perform_traversal!(delta)
+      entry = @history.go(delta)
+      return unless entry
+
+      if entry.window && entry.window.equal?(@window)
+        @window.history.__internal_go_to__(entry.windex)
+      else
+        perform_navigation!({url: entry.url, method: "GET", source: :traverse}, rebind: true)
+      end
+    end
+
+    # Mirror the page's same-document history changes (pushState, fragment
+    # navigations, its own back/forward within the document) into the joint
+    # history, so Browser#back and history.length see them. Guarded against a
+    # navigated-away window.
+    def install_history_sync(window)
+      window.history.__internal_on_change__ = lambda do |kind, url|
+        next unless window.equal?(@window)
+
+        case kind
+        when :push
+          @history.push(url, window: window, windex: window.history.__internal_index__)
+        when :replace
+          @history.rebind_current(url: url, window: window, windex: window.history.__internal_index__)
+        when :traverse
+          @history.sync_to(window, window.history.__internal_index__)
+        end
+      end
+    end
+
     # The reserved browsing-context keywords; anything else names an iframe.
     RESERVED_TARGETS = %w[_self _top _parent _blank].freeze
 
@@ -409,7 +661,7 @@ module Dommy
       return nil if name.empty? || RESERVED_TARGETS.include?(name.downcase)
 
       @window.document.query_selector_all("iframe").find do |frame|
-        frame.get_attribute("name").to_s == name
+        frame.__internal_attribute_value__("name").to_s == name
       end
     end
 
@@ -417,32 +669,43 @@ module Dommy
     # it, install the response document as the frame's content, and fire the
     # frame's `load`. The top-level window and joint history are left alone.
     def navigate_frame(frame, nav, resolved_url)
-      response, final_url = @fetcher.request(
-        method: nav[:method] || "GET", url: resolved_url, params: nav[:params],
-        body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {}
-      )
-      return unless response&.success?
+      # The frame makes about:, data: and blob: documents itself and asks
+      # this browser (#load_frame) for the rest.
+      sub_window = frame.__internal_child_document_for__(resolved_url, nil, nav.except(:url))
+      return nil unless sub_window
 
-      sub_window = frame_document_for(response)
-      sub_window.location.__internal_set_url__(final_url)
       # A navigation from inside the loaded frame also stays in that frame.
-      sub_window.navigation_delegate = frame_navigation_delegate(frame)
-      # A nested realm needs the seeded constructors to run the response's
-      # scripts; a runtime that cannot expose them simply runs without them.
-      @runtime.expose_constructors_on(sub_window) if @runtime.respond_to?(:expose_constructors_on)
+      sub_window.navigation_delegate = frame_navigation_delegate(frame) if sub_window.navigation_delegate.is_a?(Navigation::NullDelegate)
       frame.__internal_set_content_document__(sub_window.document)
       nil
     end
 
-    # The document a frame shows for a response: HTML/XML is parsed as-is; a
-    # non-document response (e.g. text/plain from an echo endpoint) is displayed
-    # as text, so the frame gets a document whose body holds it.
-    def frame_document_for(response)
-      return Dommy.parse(response.body) if document_response?(response)
+    # Fetch a frame navigation and build the Window of the document it
+    # answers. nil when nothing (successful) serves the URL.
+    def frame_window_for(frame, nav, resolved_url)
+      @fetcher ||= navigation_fetcher
+      response, final_url = begin
+        @fetcher.request(
+          method: nav[:method] || "GET", url: resolved_url, params: nav[:params],
+          body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {}
+        )
+      rescue StandardError
+        # A resources adapter that cannot serve the request at all fails the
+        # navigation like a network error.
+        [nil, resolved_url]
+      end
+      # Nothing answered: a network error, which shows an error page (and
+      # still fires the frame's load). A response of any status is a document.
+      return Internal::ChildNavigable.error_window(final_url || resolved_url) unless response
 
-      win = Dommy.parse("<!doctype html><html><head></head><body></body></html>")
-      win.document.body.text_content = response.body.to_s.dup.force_encoding(Encoding::UTF_8)
-      win
+      sub_window = Internal::ChildNavigable.window_for_response(
+        response.body, response_header(response, "content-type"), final_url
+      )
+      sub_window.document.__internal_set_last_modified__(response_header(response, "last-modified"))
+      # A nested realm needs the seeded constructors to run the response's
+      # scripts; a runtime that cannot expose them simply runs without them.
+      @runtime.expose_constructors_on(sub_window) if @runtime.respond_to?(:expose_constructors_on)
+      sub_window
     end
 
     # If the freshly loaded document asks for an immediate `<meta http-equiv=
@@ -463,9 +726,9 @@ module Dommy
     # reloads and is left alone to avoid a busy loop).
     def meta_refresh_target(document)
       document.query_selector_all("meta").each do |meta|
-        next unless meta.get_attribute("http-equiv").to_s.casecmp?("refresh")
+        next unless meta.__internal_attribute_value__("http-equiv").to_s.casecmp?("refresh")
 
-        _delay, separator, rest = meta.get_attribute("content").to_s.partition(";")
+        _delay, separator, rest = meta.__internal_attribute_value__("content").to_s.partition(";")
         next if separator.empty?
 
         url = rest.strip.sub(/\Aurl\s*=\s*/i, "").gsub(/\A["']|["']\z/, "").strip
@@ -489,24 +752,36 @@ module Dommy
 
       navs = @pending_navigations
       @pending_navigations = []
-      navs.each { |nav| perform_navigation!(nav) }
+      navs.each do |nav|
+        nav.key?(:traverse) ? perform_traversal!(nav[:traverse]) : perform_navigation!(nav)
+      end
     end
 
+    # Unload the outgoing document: `pagehide` (a PageTransitionEvent, persisted
+    # false), then `unload` — both trusted and targeted at the document.
     def fire_unload(window)
-      window.dispatch_event(Dommy::Event.new("pagehide"))
-      window.dispatch_event(Dommy::Event.new("unload"))
+      document = window.document
+      window.dispatch_event(document.__internal_page_transition_event__("pagehide"))
+      unload = Dommy::Event.new("unload")
+      unload.__internal_set_target__(document)
+      window.dispatch_event(unload.__internal_mark_trusted__)
     end
 
     # Only HTML/XML responses replace the document; other content types (a JSON
     # API hit, an image) leave the current page. A response with no Content-Type
     # is treated as a document (fixtures commonly omit it).
     def document_response?(response)
-      headers = response.headers || {}
-      key = headers.keys.find { |k| k.to_s.casecmp?("content-type") }
-      content_type = key ? headers[key].to_s.downcase : ""
+      content_type = response_header(response, "content-type").to_s.downcase
       content_type.empty? || content_type.include?("html") || content_type.include?("xml")
     end
 
+    # A response header's value by case-insensitive name, or nil.
+    def response_header(response, name)
+      headers = response.headers || {}
+      key = headers.keys.find { |k| k.to_s.casecmp?(name) }
+      key && headers[key]
+    end
+
     def submit_button?(button)
       if button.tag_name == "BUTTON"
         button.type == "submit"