dommy 0.12.0 → 0.13.0

data/lib/dommy/js/script_boot.rb

@@ -17,10 +17,12 @@ module Dommy
     # in the document (e.g. a Nuxt entry module placed above the inline
     # `window.__NUXT__ = {...}` bootstrap it depends on). Running everything in
     # one document-order pass would execute the module against half-initialized
-    # globals. A failed fetch or a throwing script is isolated; `on_error` is
-    # notified (the Browser collects it for strict mode, the Capybara adapter
-    # ignores it) so the rest of the page still loads. Shared by `Dommy::Browser`
-    # and the Capybara driver so script boot lives in one place.
+    # globals. A failed fetch or a throwing script is isolated so the rest of the
+    # page still loads: a throwing script's exception is REPORTED at the window
+    # (WHATWG "report an exception", so `window.onerror` sees it and the host
+    # hears only what the page left unhandled), while `on_error` stays the
+    # fallback for a windowless document. Shared by `Dommy::Browser` and the
+    # Capybara driver so script boot lives in one place.
     #
     # The module is the stable entry point; the work lives on ScriptBooter, a
     # short-lived instance that holds the runtime / document / resources /
@@ -145,24 +147,66 @@ module Dommy
         ScriptBoot.wire_inline_handlers(@runtime, on_error: @on_error)
       end
 
-      # Fetch + run a dynamically-inserted external script, then fire `load` (or
-      # `error` if the fetch failed / it threw) so a loader awaiting the script
-      # element's onload resolves. The src was already taken from the element by
-      # the mutation coordinator, so this does not re-consume pending state.
+      # Fetch + run a dynamically-inserted external script, then fire the event a
+      # loader awaiting the element is listening for. The src was already taken
+      # from the element by the mutation coordinator, so this does not re-consume
+      # pending state.
+      #
+      # `error` means the FETCH failed — that is the only thing the element's
+      # event reports. A script that downloaded fine and then threw still fires
+      # `load`, because the load succeeded; its exception is reported at the
+      # global instead. Conflating the two tells a chunk loader (webpack, Vite)
+      # that the network failed, so it retries or gives up on a chunk that is
+      # sitting right there.
       def run_inserted_external(element, src)
-        ran = false
-        if @resources && (url = resolve_url(src)) && (response = @resources.get(url)) && response.success?
+        url = resolve_url(src) if @resources
+        response = (@resources.get(url) if url)
+        return dispatch_script_event(element, "error") unless response&.success?
+
+        begin
           with_current_script(element) { @runtime.load_script_cached(response.body, cache_key: url) }
-          ran = true
+        rescue StandardError => e
+          report_exception(e)
         end
-        dispatch_script_event(element, ran ? "load" : "error")
+        dispatch_script_event(element, "load")
       rescue StandardError => e
-        @on_error&.call(e)
+        # The fetch itself blew up (a resources adapter raising, not a page
+        # exception): nothing loaded, so the element reports a failure.
+        report_exception(e)
         dispatch_script_event(element, "error")
       end
 
       private
 
+      # WHATWG "report an exception" for a script whose EVALUATION threw: the
+      # exception belongs to the page, so it is reported at the global (firing
+      # `window.onerror`, which a page's error reporting listens on) rather than
+      # handed straight to the host. Only a report the page leaves unhandled
+      # reaches the host, through the window's unhandled-error seam.
+      #
+      # `on_error` is the fallback for a document with no window to report to
+      # (nothing else could hear it) and for the internal failures that are not
+      # page exceptions at all.
+      def report_exception(error)
+        window = (@document.default_view if @document.respond_to?(:default_view))
+        return @on_error&.call(error) unless window.respond_to?(:__internal_report_exception__)
+
+        Dommy::Internal::ExceptionReport.report_at(window, error, value: page_value_for(error))
+      end
+
+      # What the page should see as `event.error`. An engine that raises a host
+      # exception for a script\'s throw has already discarded the JS value, so
+      # there is nothing left to hand over: the page would get an opaque husk
+      # with no `message` or `stack`, and a handler reading either would itself
+      # throw — taking its `preventDefault()` down with it. A runtime that can
+      # rebuild an equivalent Error inside the realm gets to; nil falls back to
+      # whatever was caught.
+      def page_value_for(error)
+        return nil unless @runtime.respond_to?(:rebuild_error)
+
+        @runtime.rebuild_error(error)
+      end
+
       # Fire the script's load/error event ASYNCHRONOUSLY (a microtask), like a
       # real browser. Code commonly does `head.appendChild(s); s.onload = …`
       # (handlers set AFTER insertion), so a synchronous dispatch — during the
@@ -215,7 +259,7 @@ module Dommy
       def run_one(element)
         @on_script.call(element, nil) if run_pending(element) && @on_script
       rescue StandardError => e
-        @on_error&.call(e)
+        report_exception(e)
         @on_script&.call(element, e)
       end
 

data/lib/dommy/js/wire_tags.rb

@@ -33,6 +33,14 @@ module Dommy
       JS_REF = "__rb_js_ref"
       # A human-readable label captured alongside a JS ref (for #to_s/#inspect).
       JS_LABEL = "__rb_js_label"
+      # The thrown value's JS stack, carried alongside a callback's throw so the
+      # host can report WHERE the page failed (see ErrorEvent's filename /
+      # lineno / colno). A JS value crosses as an opaque ref, so Ruby cannot
+      # read `.stack` off it afterwards; it has to come over with the throw.
+      JS_STACK = "__rb_js_stack"
+      # The value's JS constructor name ("TypeError"), so a host log can say what
+      # kind of thing it holds rather than only naming the Ruby wrapper.
+      JS_NAME = "__rb_js_name"
       # Marks a JS ref that implements the EventListener interface (handleEvent).
       HANDLE_EVENT = "__rb_handle_event"
       # Marks a JS ref that implements the NodeFilter interface (acceptNode).

data/lib/dommy/location.rb

@@ -133,6 +133,13 @@ module Dommy
     # regardless, so this only affects the no-op default.
     def __internal_navigate_to__(raw, source:, replace: false, sync_cross_doc: true)
       target = resolve(raw)
+      if target.nil?
+        # A URL the parser rejects: the Location API throws, following a
+        # hyperlink to one does nothing.
+        raise DOMException::SyntaxError, "#{raw.inspect} is not a valid URL" if source == :location
+
+        return
+      end
       if same_document?(href, target)
         __internal_set_url__(raw)
       else
@@ -143,11 +150,14 @@ module Dommy
 
     private
 
-    # Resolve a possibly-relative URL against the current full URL.
+    # Resolve a possibly-relative URL against the current full URL with the
+    # URL parser; nil when it fails.
     def resolve(raw)
-      URI.join(href, raw).to_s
-    rescue URI::InvalidURIError, ArgumentError
-      raw
+      base = href
+      base = nil unless Internal::UrlParser.parse(base) rescue nil
+      Internal::UrlParser.serialize(Internal::UrlParser.parse(raw, base))
+    rescue Internal::UrlParser::Failure
+      nil
     end
 
     # Two URLs address the same document when everything but the fragment matches.

data/lib/dommy/navigator.rb

@@ -49,7 +49,9 @@ module Dommy
     # `navigator.sendBeacon(url, data)` — fire-and-forget POST used for analytics.
     # Dommy does not emit the request (no background egress); it just reports
     # success so callers that feature-detect `sendBeacon` take the beacon path.
-    def send_beacon(_url, _data = nil)
+    def send_beacon(url, _data = nil)
+      raise Bridge::TypeError, "Invalid URL #{url.to_s.inspect}" if @window.__internal_parse_url__(url).nil?
+
       true
     end
 

data/lib/dommy/promise.rb

@@ -100,6 +100,10 @@ module Dommy
       end
     end
 
+    def settled?
+      @state != :pending
+    end
+
     private
 
     # Drive the event loop over the work that is ready NOW until this promise
@@ -202,10 +206,6 @@ module Dommy
       self
     end
 
-    def settled?
-      @state != :pending
-    end
-
     def schedule_flush
       @window.scheduler.queue_microtask(proc { flush_handlers })
       nil

data/lib/dommy/scheduler.rb

@@ -86,6 +86,14 @@ module Dommy
     # all — vanilla CRuby use) re-raises, so genuine host bugs still surface.
     attr_accessor :timer_error_handler
 
+    # WHATWG "report an exception" for a task, supplied by the Window that owns
+    # this scheduler. A timer / rAF callback that throws is the page's bug, not
+    # the host's: the exception is reported at the global (firing
+    # `window.onerror`) and the event loop carries on with the remaining tasks,
+    # rather than tearing down whatever Ruby drove the clock. Absent in vanilla
+    # CRuby use, where a throwing callback keeps propagating.
+    attr_accessor :exception_reporter
+
     # 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
@@ -284,18 +292,28 @@ module Dommy
     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.
+    # Run a single timer's callback. The callback is invoked in its RAISING form
+    # so a JS throw surfaces here instead of being swallowed by the bridge —
+    # WHATWG reports a task's exception at the global and keeps the event loop
+    # running, which a silently dropped throw cannot do. The raised error is then
+    # 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 for a host
+    # bug, which is not a page exception and must not be reported as one.
     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)
+      CallableInvoker.invoke_raising(timer.callback, *args)
     rescue StandardError => e
+      # A page exception is reported and the timer keeps its schedule, like a
+      # browser: an interval whose callback throws goes on firing.
+      return nil if report_task_exception(e)
+      # Otherwise the runtime's handler decides. It swallows the errors it had to
+      # kill (an execution-timeout runaway, a poisoned VM), and those DO drop the
+      # timer so it cannot re-stall every tick. A declined error is a host bug.
       raise unless @timer_error_handler&.call(e, timer)
 
       timer.active = false
@@ -304,5 +322,16 @@ module Dommy
     ensure
       @nesting_level = prev_nesting
     end
+
+    # Report a task's exception at the global, per WHATWG. Only a `ThrowValue`
+    # qualifies: it is the one shape that unambiguously came out of page JS, so a
+    # host-side bug (a NoMethodError in Dommy itself) is never disguised as a
+    # page error — it falls through and propagates.
+    def report_task_exception(error)
+      return false unless error.is_a?(Bridge::ThrowValue) && @exception_reporter
+
+      @exception_reporter.call(error)
+      true
+    end
   end
 end