dommy 0.8.0 → 0.9.0

data/lib/dommy/scheduler.rb

@@ -4,10 +4,18 @@ module Dommy
   # Deterministic host-side scheduler for timers, rAF, and microtasks.
   # Time advances only when the host explicitly calls `advance_time`.
   class Scheduler
-    Timer = Struct.new(:id, :kind, :callback, :due_at, :interval_ms, :active)
+    Timer = Struct.new(:id, :kind, :callback, :due_at, :interval_ms, :active, :nesting)
 
     FRAME_MS = 16
 
+    # HTML timer initialization steps: once a timer is nested deeper than 5, a
+    # sub-4ms timeout is clamped to 4ms. Besides matching browsers, this is what
+    # stops a self-rescheduling setTimeout(0) / setInterval(0) from spinning
+    # forever at the same virtual instant (the clamp pushes it into a future
+    # frame, so `advance_time(0)`'s due-now loop terminates).
+    MAX_NESTING_BEFORE_CLAMP = 5
+    MIN_NESTED_DELAY_MS = 4
+
     # requestIdleCallback has no real idle period here; the callback always
     # sees a fixed budget and didTimeout: false.
     IDLE_DEADLINE = {"timeRemaining" => 50.0, "didTimeout" => false}.freeze
@@ -18,10 +26,40 @@ module Dommy
       @timers = {}
       @microtasks = []
       @native_microtask_scheduler = nil
+      @external_inbox = Thread::Queue.new
+      # The nesting level of the timer task currently running (0 at top level);
+      # a timer scheduled while it runs nests one deeper. Drives the 4ms clamp.
+      @nesting_level = 0
     end
 
     attr_reader :now_ms
 
+    # Post a completion to be run on the page (JS) thread the next time the event
+    # loop drains. THREAD-SAFE: this is the one place another thread may hand work
+    # back — e.g. a network worker delivering a response. It only enqueues a
+    # thunk; the thunk runs single-threaded with the DOM/JS (see #deliver_external),
+    # so workers never touch Dommy/QuickJS state. The thunk takes no arguments.
+    def post_external(&thunk)
+      @external_inbox << thunk
+      nil
+    end
+
+    # Run all externally-posted completions. PAGE THREAD ONLY — drained as part of
+    # advancing the event loop (see #advance_time).
+    def deliver_external
+      until @external_inbox.empty?
+        thunk = @external_inbox.pop(true)
+        CallableInvoker.invoke(thunk)
+      end
+      nil
+    rescue ThreadError
+      nil # raced empty between empty? and pop — nothing left to do
+    end
+
+    # True when a worker has handed back work not yet delivered. Lets the host
+    # keep the loop alive (ticking) until in-flight network responses are applied.
+    def external_pending? = !@external_inbox.empty?
+
     # An optional hook (set by a JS runtime) that enqueues a microtask onto the
     # engine's NATIVE promise-job queue. When present, `queue_microtask` routes
     # through it so host-side microtasks (e.g. MutationObserver delivery)
@@ -29,6 +67,28 @@ module Dommy
     # separate pass. Absent in vanilla CRuby use (falls back to `@microtasks`).
     attr_accessor :native_microtask_scheduler
 
+    # An optional hook (set by a JS runtime) invoked when a timer / rAF / idle
+    # callback raises. The host inspects the error and returns truthy to swallow
+    # it — e.g. a runtime execution-budget interrupt: a runaway callback the
+    # engine force-killed should be recorded and let browsing continue, not crash
+    # it (WHATWG: a timer callback's exception must not escape its dispatch). When
+    # swallowed, the offending timer is dropped so a self-rescheduling interval
+    # does not re-fire and re-stall every tick. Returning falsy (or no handler at
+    # all — vanilla CRuby use) re-raises, so genuine host bugs still surface.
+    attr_accessor :timer_error_handler
+
+    # An optional hook (set by a JS runtime) that drains the ENGINE's microtask
+    # (promise-job) queue — the other half of a microtask checkpoint. The
+    # scheduler owns only its own `@microtasks`; the real microtask queue lives
+    # in the JS engine, so a spec-compliant checkpoint must drain both. WHATWG
+    # §8.1.7.3: the event loop performs a microtask checkpoint after running each
+    # task. Without this the scheduler would run every due timer task back-to-back
+    # and only drain microtasks once at the end, which reorders a microtask queued
+    # by one task after the next task — breaking code (Apollo/RxJS link chains)
+    # that relies on the per-task checkpoint. Absent in vanilla CRuby use (then a
+    # checkpoint drains only `@microtasks`).
+    attr_accessor :microtask_checkpoint
+
     def set_timeout(callback, delay_ms)
       register_timer(:timeout, callback, delay_ms.to_i, nil)
     end
@@ -49,7 +109,9 @@ module Dommy
     def request_animation_frame(callback)
       frames = ((@now_ms / FRAME_MS) + 1) * FRAME_MS
       id = next_id
-      @timers[id] = Timer.new(id, :raf, callback, frames, nil, true)
+      # rAF is frame-aligned (never the same instant twice), so it needs no
+      # nesting clamp; nesting 0.
+      @timers[id] = Timer.new(id, :raf, callback, frames, nil, true, 0)
       id
     end
 
@@ -85,16 +147,30 @@ module Dommy
       nil
     end
 
+    # A WHATWG microtask checkpoint: drain the scheduler's own microtask queue
+    # AND the engine's promise-job queue (via the runtime hook). Host-side
+    # microtasks route onto the engine queue when a runtime is wired, so in that
+    # mode `@microtasks` is usually empty and the engine drain does the work; in
+    # vanilla CRuby the engine hook is absent and only `@microtasks` drains.
+    def perform_microtask_checkpoint
+      drain_microtasks
+      @microtask_checkpoint&.call
+      nil
+    end
+
     def advance_time(delta_ms)
+      deliver_external # apply any responses that arrived since the last drain
       target = @now_ms + [delta_ms.to_i, 0].max
       while next_due_timer_at && next_due_timer_at <= target
         @now_ms = next_due_timer_at
         run_due_timers
-        drain_microtasks
+        perform_microtask_checkpoint
+        deliver_external
       end
 
       @now_ms = target
-      drain_microtasks
+      perform_microtask_checkpoint
+      deliver_external
       nil
     end
 
@@ -108,6 +184,14 @@ module Dommy
       @timers.values.select(&:active).map(&:due_at).min
     end
 
+    # The earliest due time among pending requestAnimationFrame callbacks, or
+    # nil when none are scheduled. Lets a host flush RAF (advancing to the next
+    # frame boundary) during a `settle` without jumping the clock past
+    # not-yet-due `setTimeout`s.
+    def next_animation_frame_at
+      @timers.values.select { |t| t.active && t.kind == :raf }.map(&:due_at).min
+    end
+
     private
 
     def next_id
@@ -118,39 +202,91 @@ module Dommy
 
     def register_timer(kind, callback, delay_ms, interval_ms)
       id = next_id
-      due_at = @now_ms + [delay_ms, 0].max
-      @timers[id] = Timer.new(id, kind, callback, due_at, interval_ms, true)
+      nesting = @nesting_level + 1
+      delay = clamp_nested_delay([delay_ms, 0].max, nesting)
+      due_at = @now_ms + delay
+      @timers[id] = Timer.new(id, kind, callback, due_at, interval_ms, true, nesting)
       id
     end
 
+    # HTML timer initialization step: a timer nested deeper than 5 with a sub-4ms
+    # timeout is clamped to 4ms.
+    def clamp_nested_delay(delay, nesting)
+      nesting > MAX_NESTING_BEFORE_CLAMP && delay < MIN_NESTED_DELAY_MS ? MIN_NESTED_DELAY_MS : delay
+    end
+
     def cancel_timer(id)
-      timer = @timers[id.to_i]
+      # WHATWG: clearTimeout/clearInterval with a missing or non-numeric handle
+      # (e.g. `clearTimeout(undefined)`, which React's scheduler emits) is a
+      # silent no-op rather than an error.
+      return unless id.respond_to?(:to_i)
+
+      key = id.to_i
+      timer = @timers[key]
       timer.active = false if timer
-      @timers.delete(id.to_i)
+      @timers.delete(key)
       nil
     end
 
     def run_due_timers
       due = @timers.values.select { |timer| timer.active && timer.due_at <= @now_ms }
       due.sort_by!(&:id)
+      # Each ordinary timer task is followed by a microtask checkpoint (WHATWG
+      # §8.1.7.3). The animation-frame callbacks of one rendering update are an
+      # exception: they run consecutively and share a single checkpoint after the
+      # batch (a microtask queued by one rAF must not run before the next rAF in
+      # the same frame), so they are checkpointed once at the end.
+      raf_ran = false
       due.each do |timer|
         next unless timer.active
 
         case timer.kind
         when :raf
           @timers.delete(timer.id)
-          CallableInvoker.invoke(timer.callback, @now_ms.to_f)
+          invoke_timer(timer, @now_ms.to_f)
+          raf_ran = true
         when :interval
-          CallableInvoker.invoke(timer.callback)
-          timer.due_at = @now_ms + timer.interval_ms if timer.active
+          invoke_timer(timer)
+          if timer.active
+            # Each interval iteration nests one deeper, so a setInterval(0) is
+            # clamped to 4ms once past the nesting threshold (HTML timer steps).
+            timer.nesting += 1
+            timer.due_at = @now_ms + clamp_nested_delay(timer.interval_ms, timer.nesting)
+          end
+          perform_microtask_checkpoint
         when :idle
           @timers.delete(timer.id)
-          CallableInvoker.invoke(timer.callback, IDLE_DEADLINE.dup)
+          invoke_timer(timer, IDLE_DEADLINE.dup)
+          perform_microtask_checkpoint
         else
           @timers.delete(timer.id)
-          CallableInvoker.invoke(timer.callback)
+          invoke_timer(timer)
+          perform_microtask_checkpoint
         end
       end
+      perform_microtask_checkpoint if raf_ran
+    end
+
+
+    # Run a single timer's callback. A raised error is offered to
+    # `timer_error_handler` (set by the JS runtime); if it swallows the error the
+    # timer is dropped (so a runaway interval cannot re-stall every tick) and
+    # browsing continues. With no handler — or one that declines — the error
+    # propagates, preserving the default crash-on-bug behavior.
+    def invoke_timer(timer, *args)
+      # Run the callback at this timer's nesting level, so a timer it schedules
+      # nests one deeper (driving the 4ms clamp). Restored even if it throws.
+      prev_nesting = @nesting_level
+      @nesting_level = timer.nesting || 0
+      CallableInvoker.invoke(timer.callback, *args)
+    rescue StandardError => e
+      raise unless @timer_error_handler&.call(e, timer)
+
+      timer.active = false
+      @timers.delete(timer.id)
+      nil
+    ensure
+      @nesting_level = prev_nesting
     end
   end
 end

data/lib/dommy/screen.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `window.screen` — the Screen interface. A headless browser has no physical
+  # display, so the screen reports the (approximate) viewport size, with standard
+  # desktop colour depth and an orientation derived from the aspect ratio.
+  #
+  # `window.screen` is always present in a real browser, and `screen.width` /
+  # `screen.height` are routinely read *unguarded* (analytics, responsive logic),
+  # so a missing `screen` makes them throw "cannot read property 'width' of
+  # undefined" — which is exactly what real sites hit when Dommy lacked it.
+  class Screen
+    def initialize(window)
+      @window = window
+    end
+
+    def __js_get__(key)
+      case key
+      when "width", "availWidth"
+        @window.inner_width
+      when "height", "availHeight"
+        @window.inner_height
+      when "availLeft", "availTop"
+        0
+      when "colorDepth", "pixelDepth"
+        24
+      when "isExtended"
+        false
+      when "orientation"
+        @orientation ||= ScreenOrientation.new(@window)
+      else
+        # Anything else is genuinely absent (JS `undefined`, `"x" in screen`
+        # false) so feature detection takes the not-supported path.
+        Bridge::ABSENT
+      end
+    end
+
+    def __js_set__(_key, _value)
+      Bridge::UNHANDLED
+    end
+
+    include Bridge::Methods
+    # Screen is an EventTarget; Dommy never fires screen events, so a listener is
+    # accepted and simply never invoked.
+    js_methods %w[addEventListener removeEventListener dispatchEvent]
+    def __js_call__(method, _args)
+      case method
+      when "addEventListener", "removeEventListener" then nil
+      when "dispatchEvent" then true
+      end
+    end
+  end
+
+  # `screen.orientation` — the ScreenOrientation interface. Reports a fixed
+  # orientation from the viewport aspect ratio; `lock`/`unlock` are no-ops (a
+  # headless browser cannot rotate), `lock` still returning a resolved Promise so
+  # callers that `await screen.orientation.lock(...)` proceed.
+  class ScreenOrientation
+    def initialize(window)
+      @window = window
+    end
+
+    def __js_get__(key)
+      case key
+      when "type"
+        @window.inner_width >= @window.inner_height ? "landscape-primary" : "portrait-primary"
+      when "angle"
+        0
+      else
+        Bridge::ABSENT
+      end
+    end
+
+    def __js_set__(_key, _value)
+      Bridge::UNHANDLED
+    end
+
+    include Bridge::Methods
+    js_methods %w[lock unlock addEventListener removeEventListener dispatchEvent]
+    def __js_call__(method, _args)
+      case method
+      when "lock"
+        PromiseValue.resolve(@window, nil)
+      when "unlock", "addEventListener", "removeEventListener"
+        nil
+      when "dispatchEvent"
+        true
+      end
+    end
+  end
+end

data/lib/dommy/shadow_root.rb

@@ -9,7 +9,9 @@ module Dommy
   #
   # Tree manipulation works the same as a normal Element/Fragment;
   # the boundary is enforced only on outer queries and event
-  # composition. CSS scoping (`:host`, `::slotted`) is out of scope.
+  # composition. CSS scoping (`:host` / `::slotted` / `::part`, and this
+  # tree's `<style>` rules) is handled by the cascade — see
+  # `internal/css/rule_index.rb` and css-cascade.md.
   class ShadowRoot
     include EventTarget
     include Node
@@ -25,7 +27,7 @@ module Dommy
       @delegates_focus = !!delegates_focus
       @slot_assignment = slot_assignment.to_s
       @document = host.document
-      @__node__ = @document.nokogiri_doc.fragment("")
+      @__node__ = @document.backend_doc.fragment("")
       @document.__internal_register_shadow_fragment__(@__node__, self)
     end
 
@@ -38,7 +40,7 @@ module Dommy
     def inner_html=(html)
       removed = @__node__.children.to_a
       removed.each(&:unlink)
-      fragment = Parser.fragment(html.to_s, owner_doc: @document.nokogiri_doc)
+      fragment = Parser.fragment(html.to_s, owner_doc: @document.backend_doc)
       added = fragment.children.to_a
       added.each { |n| @__node__.add_child(n) }
       notify_child_list(added: added, removed: removed)
@@ -51,7 +53,7 @@ module Dommy
 
     def text_content=(value)
       @__node__.children.each(&:unlink)
-      @__node__.add_child(Backend.create_text(value.to_s, @document.nokogiri_doc))
+      @__node__.add_child(Backend.create_text(value.to_s, @document.backend_doc))
     end
 
     def children
@@ -83,26 +85,73 @@ module Dommy
     end
 
     def query_selector(selector)
-      return nil if selector.nil? || selector.to_s.empty?
+      return nil if selector.nil?
 
-      @document.wrap_node(@__node__.at_css(selector.to_s))
+      ast = Internal::SelectorParser.parse!(selector)
+      Internal::SelectorMatcher.query_first(self, ast, scope: self)
     end
 
     def query_selector_all(selector)
-      return NodeList.new if selector.nil? || selector.to_s.empty?
+      return NodeList.new if selector.nil?
 
-      NodeList.new(@__node__.css(selector.to_s).map { |n| @document.wrap_node(n) }.compact)
+      ast = Internal::SelectorParser.parse!(selector)
+      NodeList.new(Internal::SelectorMatcher.query(self, ast, scope: self))
     end
 
     def get_element_by_id(id)
-      return nil if id.nil?
+      return nil if id.nil? || id.to_s.empty?
 
-      @document.wrap_node(@__node__.at_css("##{id}"))
+      # getElementById matches the `id` attribute literally, not as a CSS
+      # selector, so escape special characters (e.g. React `useId` `:rjm:`) to a
+      # valid id-selector ident — a raw "##{id}" would be an invalid selector.
+      @document.wrap_node(@__node__.at_css("##{Dommy::CSSNamespace.escape(id)}"))
     end
 
-    # `getRootNode()` returns the ShadowRoot itself (closed-shadow
-    # semantics; `composed: true` callers go through the Event path).
-    def get_root_node(_options = nil)
+    # Node-level child mutations the spec exposes on a DocumentFragment (and so
+    # on a ShadowRoot). lit-html drives rendering through `insertBefore` /
+    # `removeChild` / `replaceChild` against the render root, so a shadow root
+    # must support them — not just appendChild.
+    def insert_before(node, ref)
+      nodes = detach_dom_nodes(node)
+      ref_bn = ref.respond_to?(:__dommy_backend_node__) ? ref.__dommy_backend_node__ : nil
+      if ref_bn && ref_bn.parent == @__node__
+        nodes.each { |n| ref_bn.add_previous_sibling(n) }
+      else
+        nodes.each { |n| @__node__.add_child(n) }
+      end
+      notify_child_list(added: nodes)
+      node
+    end
+
+    def remove_child(node)
+      bn = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__ : nil
+      raise DOMException::NotFoundError, "node is not a child of this shadow root" unless bn && bn.parent == @__node__
+
+      bn.unlink
+      notify_child_list(removed: [bn])
+      node
+    end
+
+    def replace_child(new_child, old_child)
+      old_bn = old_child.respond_to?(:__dommy_backend_node__) ? old_child.__dommy_backend_node__ : nil
+      raise DOMException::NotFoundError, "node is not a child of this shadow root" unless old_bn && old_bn.parent == @__node__
+
+      added = detach_dom_nodes(new_child)
+      added.each { |n| old_bn.add_previous_sibling(n) }
+      old_bn.unlink
+      notify_child_list(added: added, removed: [old_bn])
+      old_child
+    end
+
+    # `getRootNode()` returns the ShadowRoot itself; `getRootNode({composed:
+    # true})` crosses the shadow boundary and returns the root of the host's
+    # tree (the document, or an outer shadow root for nested shadows).
+    def get_root_node(options = nil)
+      composed = options.is_a?(Hash) &&
+        EventTarget.js_truthy?(options.key?("composed") ? options["composed"] : options[:composed])
+      return self unless composed
+      return @host.root_node({"composed" => true}) if @host.respond_to?(:root_node)
+
       self
     end
 
@@ -154,6 +203,13 @@ module Dommy
         last_element_child
       when "nodeType"
         11
+      when "nodeName"
+        "#document-fragment"
+      else
+        # Any unknown key (incl. framework-private `_`/`$` expandos like
+        # lit-html's `_$litPart$`, which it probes with `=== undefined`) is
+        # genuinely absent: JS `undefined`, `in` false — matching Element.
+        Bridge::ABSENT
       end
     end
 
@@ -173,6 +229,7 @@ module Dommy
     include Bridge::Methods
     js_methods %w[
       querySelector querySelectorAll getElementById append prepend replaceChildren appendChild
+      insertBefore removeChild replaceChild
       getRootNode contains addEventListener removeEventListener dispatchEvent
       isEqualNode isSameNode hasChildNodes normalize compareDocumentPosition
     ]
@@ -202,6 +259,12 @@ module Dommy
         replace_children(*args)
       when "appendChild"
         append_child(args[0])
+      when "insertBefore"
+        insert_before(args[0], args[1])
+      when "removeChild"
+        remove_child(args[0])
+      when "replaceChild"
+        replace_child(args[0], args[1])
       when "getRootNode"
         get_root_node(args[0])
       when "contains"

data/lib/dommy/storage.rb

@@ -83,7 +83,8 @@ module Dommy
       when "length"
         @store.size
       else
-        @store[key.to_s]
+        # A named-property miss is JS `undefined` (and `"k" in storage` false).
+        @store.key?(key.to_s) ? @store[key.to_s] : Bridge::ABSENT
       end
     end
 

data/lib/dommy/streams.rb

@@ -99,6 +99,8 @@ module Dommy
       case key
       when "locked"
         locked
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -244,6 +246,8 @@ module Dommy
       case key
       when "locked"
         locked
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -340,6 +344,8 @@ module Dommy
         @readable
       when "writable"
         @writable
+      else
+        Bridge::ABSENT
       end
     end
   end

data/lib/dommy/text_codec.rb

@@ -19,7 +19,7 @@ module Dommy
     end
 
     def __js_get__(key)
-      key == "encoding" ? encoding : nil
+      key == "encoding" ? encoding : Bridge::ABSENT
     end
 
     include Bridge::Methods
@@ -76,6 +76,8 @@ module Dommy
       when "encoding" then @encoding
       when "fatal" then @fatal
       when "ignoreBOM" then @ignore_bom
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -289,6 +291,8 @@ module Dommy
         @writable
       when "encoding"
         encoding
+      else
+        Bridge::ABSENT
       end
     end
   end
@@ -322,6 +326,8 @@ module Dommy
         @writable
       when "encoding"
         @encoding
+      else
+        Bridge::ABSENT
       end
     end
   end

data/lib/dommy/tree_walker.rb

@@ -42,9 +42,13 @@ module Dommy
     private
 
     # Returns FILTER_ACCEPT / FILTER_REJECT / FILTER_SKIP for the
-    # given wrapped node.
+    # given wrapped node. Per WHATWG "filter", the active-flag re-entrancy
+    # check comes first: a NodeFilter that re-enters its own walker/iterator
+    # (calls nextNode etc. while the filter is still running) is an
+    # InvalidStateError.
     def accept(node)
       return NodeFilter::FILTER_REJECT unless node
+      raise DOMException::InvalidStateError, "NodeFilter is already active" if @active
       return NodeFilter::FILTER_SKIP if (NodeFilter.bitmask_for(node) & @what_to_show) == 0
 
       result = invoke_filter(node)
@@ -58,11 +62,25 @@ module Dommy
       # A non-null filter with no callable acceptNode is a TypeError when invoked.
       raise Bridge::TypeError, "NodeFilter is not callable" unless cb
 
-      result = if cb.respond_to?(:__js_call__)
-        cb.__js_call__("call", [node])
-      else
-        cb.call(node)
-      end
+      # The active flag is set around the user callback only; a re-entrant
+      # traversal during this window trips the guard in `accept`. It must be
+      # cleared even when the callback throws so the walker stays usable.
+      @active = true
+      result =
+        begin
+          # A NodeFilter's exception must propagate out of the traversal method,
+          # so use the raising invocation when the callback supports it (a JS
+          # function); a Ruby callable propagates naturally.
+          if cb.respond_to?(:__js_call_with_raise__)
+            cb.__js_call_with_raise__([node])
+          elsif cb.respond_to?(:__js_call__)
+            cb.__js_call__("call", [node])
+          else
+            cb.call(node)
+          end
+        ensure
+          @active = false
+        end
       # WebIDL coerces the filter return (an `unsigned short`): booleans and
       # null become 0/1, everything else ToInteger.
       return 1 if result == true
@@ -200,6 +218,8 @@ module Dommy
         @filter
       when "currentNode"
         @current_node
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -345,13 +365,13 @@ module Dommy
     end
 
     # The Nokogiri node backing a wrapper — an element's `__dommy_backend_node__`
-    # or, for a Document (which isn't a wrapped node), its `nokogiri_doc`. Lets a
+    # or, for a Document (which isn't a wrapped node), its `backend_doc`. Lets a
     # walker rooted at the document descend into its children.
     def backend_node_of(node)
       if node.respond_to?(:__dommy_backend_node__)
         node.__dommy_backend_node__
-      elsif node.respond_to?(:nokogiri_doc)
-        node.nokogiri_doc
+      elsif node.respond_to?(:backend_doc)
+        node.backend_doc
       end
     end
 
@@ -372,7 +392,8 @@ module Dommy
 
     def last_wrapped_child(node)
       bn = backend_node_of(node)
-      bn ? first_wrappable(bn.children.reverse, node) : nil
+      # `.to_a` first: Nokogiri's NodeSet has `#reverse`, Makiri's does not.
+      bn ? first_wrappable(bn.children.to_a.reverse, node) : nil
     end
 
     def next_sibling_wrapped(node)
@@ -490,6 +511,8 @@ module Dommy
         @reference_node
       when "pointerBeforeReferenceNode"
         @pointer_before_reference
+      else
+        Bridge::ABSENT
       end
     end
 

data/lib/dommy/url.rb

@@ -260,6 +260,8 @@ module Dommy
     when "username" then username
     when "password" then password
     when "searchParams" then @search_params
+    else
+      Bridge::ABSENT
     end
   end
 
@@ -461,6 +463,8 @@ module Dommy
       case key
       when "size", "length"
         size
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -517,7 +521,15 @@ module Dommy
     def parse(input)
       case input
       when Array
-        input.map { |k, v| [k.to_s, v.to_s] }
+        # A sequence init is a sequence of [name, value] pairs: each inner element
+        # must itself be a 2-element sequence, else the constructor throws.
+        input.map do |pair|
+          unless pair.is_a?(Array) && pair.length == 2
+            raise Bridge::TypeError, "Failed to construct 'URLSearchParams': each pair must have exactly two elements"
+          end
+
+          [pair[0].to_s, pair[1].to_s]
+        end
       when Hash
         input.map { |k, v| [k.to_s, v.to_s] }
       else