dommy-js-quickjs 0.1.0 → 0.9.0

data/lib/dommy/js/quickjs/runtime.rb

@@ -15,6 +15,16 @@ module Dommy
         def initialize(**vm_opts)
           @backend = Backend.new(**vm_opts)
           @bridge = Dommy::Js::HostBridge.new(@backend)
+          @callback_error_listener = nil
+          @js_halted = false
+          # Opt-in diagnostics: the engine stringifies a non-Error rejection reason
+          # to "[object Object]". Install a JS-side recorder so on_unhandled_rejection
+          # can surface the real cause (DOMMY_JS_DEBUG_REJECTIONS=1).
+          @track_rejections = !ENV["DOMMY_JS_DEBUG_REJECTIONS"].to_s.empty?
+          # Install the JS-side Promise rejection recorder (HostBridge registers
+          # the __rb_record_rejection_detail sink it pushes to). The detail then
+          # backfills the engine's detail-less report in #enrich_rejection.
+          @backend.call_js("__rbHost.installRejectionTracker") if @track_rejections
         end
 
         def define_host_object(name, obj)
@@ -30,12 +40,54 @@ module Dommy
           @window = win
           define_host_object("window", win)
           @bridge.window = win
+          # A runaway timer/rAF callback (busy loop) is force-killed by the gem's
+          # eval timeout, surfacing as a Quickjs::InterruptedError out of the host
+          # call. Route it through the scheduler's error hook so it is recorded as
+          # a js_error and dropped, not propagated as a fatal crash (browsing must
+          # never crash). Genuine host bugs (any other error) still propagate.
+          if win.respond_to?(:scheduler) && win.scheduler
+            win.scheduler.timer_error_handler = method(:handle_timer_error)
+            # The other half of a WHATWG microtask checkpoint: the engine's
+            # promise-job queue. Wiring this lets the scheduler drain microtasks
+            # after EACH task (not once per batch of due timers), as the event
+            # loop processing model requires.
+            win.scheduler.microtask_checkpoint = method(:drain_microtasks)
+          end
           @backend.eval(<<~JS)
-            globalThis.setTimeout = (fn, delay) => window.setTimeout(fn, delay);
+            // Remember where each timer was scheduled, so a throwing callback can
+            // be traced back to the code that set it up. This matters most for
+            // minified SPA bundles, where the thrown value is often a bare `null`
+            // with no stack of its own — the only locatable stack is the
+            // scheduling site. The origin Error is kept JS-side and only
+            // stringified if the callback actually throws (see
+            // __rbFetchTimerOrigin + handle_timer_error); a successful callback
+            // forgets its origin and the map is size-capped, so this stays cheap.
+            globalThis.__rbTimerOrigins = new Map();
+            const __rbDefer = (schedule, fn, delay) => {
+              if (typeof fn !== "function") return schedule(fn, delay);
+              const origin = new Error();
+              let id;
+              const wrapped = function () {
+                const result = fn.apply(this, arguments);
+                __rbTimerOrigins.delete(id); // ran cleanly — no need to keep it
+                return result;
+              };
+              id = schedule(wrapped, delay);
+              __rbTimerOrigins.set(id, origin);
+              if (__rbTimerOrigins.size > 4096) __rbTimerOrigins.delete(__rbTimerOrigins.keys().next().value);
+              return id;
+            };
+            globalThis.__rbFetchTimerOrigin = (id) => {
+              const origin = __rbTimerOrigins.get(id);
+              if (!origin) return "";
+              __rbTimerOrigins.delete(id);
+              return origin.stack || "";
+            };
+            globalThis.setTimeout = (fn, delay) => __rbDefer((f, d) => window.setTimeout(f, d), fn, delay);
             globalThis.clearTimeout = (id) => window.clearTimeout(id);
-            globalThis.setInterval = (fn, delay) => window.setInterval(fn, delay);
+            globalThis.setInterval = (fn, delay) => __rbDefer((f, d) => window.setInterval(f, d), fn, delay);
             globalThis.clearInterval = (id) => window.clearInterval(id);
-            globalThis.requestAnimationFrame = (fn) => window.requestAnimationFrame(fn);
+            globalThis.requestAnimationFrame = (fn) => __rbDefer((f) => window.requestAnimationFrame(f), fn);
             globalThis.cancelAnimationFrame = (id) => window.cancelAnimationFrame(id);
             // queueMicrotask must share the engine's promise-job (microtask)
             // queue so its callbacks are FIFO-ordered with Promise reactions
@@ -67,6 +119,49 @@ module Dommy
           nil
         end
 
+        # Load a script the way a browser <script> does: in GLOBAL scope, so its
+        # top-level `var` / `function` / `let` declarations become globals. UMD /
+        # "global" bundles rely on this — e.g. Vue's global build is literally
+        # `var Vue = (function(){…})({})`, which an IIFE wrapper (execute) would
+        # trap in function scope. Drains microtasks afterward.
+        def load_script(js)
+          @backend.eval(js)
+          drain_microtasks
+          nil
+        end
+
+        # Like #load_script, but compiles the source to bytecode once per
+        # `cache_key` (an external script's URL) and reuses it across VMs —
+        # avoiding a re-parse of large vendored bundles on every page load.
+        def load_script_cached(js, cache_key:)
+          @backend.run_compiled(ScriptCache.compiled(cache_key, js))
+          drain_microtasks
+          nil
+        end
+
+        # Install the ESM module resolver (see Backend#module_loader=). A
+        # callable `(specifier, importer) -> source | {code:, as:} | nil`.
+        def module_loader=(callable)
+          @backend.module_loader = callable
+        end
+
+        # Evaluate an inline `<script type="module">` body as an ES module (run
+        # for side effects). Bare specifiers / absolute paths in its imports
+        # resolve through the module loader. Drains microtasks afterward.
+        def load_module(source)
+          @backend.import_module(source)
+          drain_microtasks
+          nil
+        end
+
+        # Evaluate an external module by URL (the loader fetches it); its
+        # relative imports resolve against that URL. Drains microtasks.
+        def load_module_url(url)
+          @backend.import_module_url(url)
+          drain_microtasks
+          nil
+        end
+
         # Evaluate JS and return its value, with DOM nodes decoded to Dommy
         # objects (rather than the empty Hash a raw proxy becomes crossing to
         # Ruby). Accepts either an expression (`document.title`) or a statement
@@ -76,13 +171,67 @@ module Dommy
         # attempt runs nothing. The result is awaited, so a Promise resolves
         # before returning.
         def evaluate(js)
-          @bridge.decode(eval_tagged("await (#{js.strip.sub(/;\s*\z/, "")})"))
+          evaluate_settled("(#{js.strip.sub(/;\s*\z/, "")})")
         rescue ::Quickjs::SyntaxError
-          @bridge.decode(eval_tagged("await (async () => {\n#{js}\n})()"))
+          evaluate_settled("(async () => {\n#{js}\n})()")
+        end
+
+        # Evaluate `expr` to its awaited value, driving the event loop so a result
+        # that depends on a TASK (a fetch's setTimeout(0) delivery, a setTimeout)
+        # settles first. The gem's top-level await (js_std_await) only drains the
+        # engine's job queue, never Dommy's scheduler — so awaiting a task-resolved
+        # promise directly deadlocks in C. Instead: store the result, run the
+        # event loop over everything due NOW (microtask checkpoint + due tasks and
+        # the tasks they chain), then await the now-settled promise (which returns
+        # immediately and still surfaces a rejection as a Ruby raise, as before).
+        def evaluate_settled(expr)
+          # `void 0` keeps the completion value off the promise, so the eval
+          # doesn't trip the gem's "unawaited Promise at top-level" guard.
+          @backend.eval("globalThis.__rbEvalP = Promise.resolve(#{expr}); void 0;")
+          drive_due_now
+          @bridge.decode(eval_tagged("await globalThis.__rbEvalP"))
+        end
+
+        # Run the event loop over the work ready at the current virtual time —
+        # the microtask checkpoint plus every due task and anything it queues at
+        # the same instant — WITHOUT advancing the clock to a future timer (a
+        # result waiting on a real delay is left for the await to surface). The
+        # nested-timer 4ms clamp guarantees due-now work drains in finite turns.
+        def drive_due_now
+          sched = @window&.scheduler
+          return drain_microtasks unless sched
+
+          64.times do
+            sched.advance_time(0)
+            break unless sched.next_due_timer_at == sched.now_ms
+          end
+          nil
         end
 
         def drain_microtasks
           @backend.drain_microtasks
+        rescue ::Quickjs::RuntimeError => e
+          # The microtask checkpoint hit out-of-memory and poisoned the VM. Per
+          # the "browsing never crashes" contract, don't let it escape the event
+          # loop: record it once (so it shows in js_errors / the activity log) and
+          # then no-op — the page's JS is dead, but the browser stays alive.
+          raise unless @backend.poisoned?
+
+          note_js_halted(e)
+        end
+
+        # Drive the document lifecycle: set `document.readyState` and fire the
+        # milestone events (`readystatechange`, then `DOMContentLoaded` on
+        # "interactive" / `load` on "complete"), then drain microtasks so the
+        # listeners settle. Lets a host replay the real load sequence so code
+        # that waits on document readiness (framework startup, `ready` handlers)
+        # runs the deferred path. The document defaults to "complete", so call
+        # `set_document_ready_state("loading")` BEFORE loading such code to
+        # exercise the waiting path.
+        def set_document_ready_state(state)
+          @window&.document&.__internal_set_ready_state__(state)
+          drain_microtasks
+          self
         end
 
         # Handle-oriented JS access for a wasm guest (see WasmBridge). Memoized
@@ -115,9 +264,68 @@ module Dommy
           self
         end
 
+        # Settle the work that is READY at the current virtual time: drain
+        # microtasks, run timers already due now (`setTimeout(0)` chains), and
+        # flush pending `requestAnimationFrame` callbacks by advancing to their
+        # frame boundary — but do NOT jump the clock to a not-yet-due
+        # `setTimeout(300)` (that needs an explicit `advance_time(300)`). This is
+        # the "let promises and animation frames resolve" entry point; `bound`
+        # caps a self-rescheduling rAF loop.
+        def settle(max_iterations: 1000)
+          sched = @window&.scheduler
+          max_iterations.times do
+            drain_microtasks
+            break unless sched
+
+            before = sched.now_ms
+            sched.advance_time(0) # run due-now timers + microtasks, no clock jump
+            drain_microtasks
+
+            raf_at = sched.next_animation_frame_at
+            if raf_at && raf_at > sched.now_ms
+              sched.advance_time(raf_at - sched.now_ms) # advance to the frame, run rAF
+              drain_microtasks
+              next
+            end
+
+            break if sched.now_ms == before
+          end
+          self
+        end
+
         # Surface otherwise-swallowed JS promise rejections (see Backend).
         def on_unhandled_rejection(&block)
-          @backend.on_unhandled_rejection(&block)
+          if @track_rejections
+            @backend.on_unhandled_rejection { |err| block.call(enrich_rejection(err)) }
+          else
+            @backend.on_unhandled_rejection(&block)
+          end
+          self
+        end
+
+        # In rejection-debug mode, replace the engine's detail-less "[object
+        # Object]" message (a non-Error reason the engine could only toString)
+        # with the rich detail recorded JS-side at rejection time, paired by
+        # recency. A no-op for errors that already carry a real message.
+        def enrich_rejection(err)
+          return err unless err.respond_to?(:message) && err.message.to_s.strip == "[object Object]"
+
+          detail = @bridge.take_rejection_detail
+          return err if detail.nil? || detail.to_s.empty?
+
+          enriched = ::Quickjs::RuntimeError.new(detail.to_s, "UnhandledRejection")
+          enriched.set_backtrace(err.backtrace) if err.backtrace
+          enriched
+        rescue StandardError
+          err
+        end
+
+        # Observe a timer/rAF callback that was force-killed by the execution
+        # timeout (a runaway busy loop). The host records it as a js_error; the
+        # offending timer is already dropped by the scheduler so it cannot
+        # re-stall. Optional in the Runtime contract (guard with respond_to?).
+        def on_callback_error(&block)
+          @callback_error_listener = block
           self
         end
 
@@ -132,43 +340,116 @@ module Dommy
         # CSS / fetch / addEventListener / .... Call after install_window. This
         # is what lets real frontend bundles (Turbo, …) run unmodified.
         def install_browser_globals
+          alias_browser_globals
+          install_intl_polyfill
+          install_wasm_stub
+          mirror_builtins_on_window
+          self
+        end
+
+        # This QuickJS build has no WebAssembly, so a bare `WebAssembly.foo`
+        # reference throws `'WebAssembly' is not defined` (nuxt.com via Shiki,
+        # many bundlers' feature probes). Define a stub: compile/instantiate
+        # reject and validate() returns false, so WASM-loading code takes its
+        # JS fallback instead of crashing. `Memory` honors `{shared:true}` (a
+        # SharedArrayBuffer) so WPT's common/sab.js keeps working.
+        def install_wasm_stub
+          @backend.eval(WASM_STUB_JS)
+          self
+        end
+
+        WASM_STUB_JS = <<~'JS'
+          if (typeof globalThis.WebAssembly === "undefined") {
+            var unsupported = function () { return Promise.reject(new Error("WebAssembly is not supported")); };
+            var throwUnsupported = function () { throw new Error("WebAssembly is not supported"); };
+            globalThis.WebAssembly = {
+              instantiate: unsupported, instantiateStreaming: unsupported,
+              compile: unsupported, compileStreaming: unsupported,
+              validate: function () { return false; },
+              Module: throwUnsupported, Instance: throwUnsupported,
+              Memory: function (opts) {
+                var bytes = ((opts && opts.initial) || 0) * 65536;
+                this.buffer = (opts && opts.shared && typeof SharedArrayBuffer === "function")
+                  ? new SharedArrayBuffer(bytes) : new ArrayBuffer(bytes);
+              },
+              Table: function () {}, Global: function () {},
+              CompileError: Error, LinkError: Error, RuntimeError: Error,
+            };
+          }
+        JS
+
+        # This QuickJS build ships without ICU, so `Intl` is undefined and any
+        # page touching `Intl.NumberFormat` / `DateTimeFormat` / … throws
+        # `'Intl' is not defined` (nuxt.com, i18n libraries, …). Install a small
+        # locale-naive polyfill: it formats reasonably (grouped numbers, ISO-ish
+        # dates) so pages run instead of crashing, without pulling in full ICU.
+        def install_intl_polyfill
+          @backend.eval(INTL_POLYFILL_JS)
+          self
+        end
+
+        INTL_POLYFILL_JS = <<~'JS'
+          if (typeof globalThis.Intl === "undefined") {
+            var I = {};
+            var group = function (s) {
+              var p = String(s).split(".");
+              p[0] = p[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+              return p.join(".");
+            };
+            function NumberFormat(l, o) { this.o = o || {}; }
+            NumberFormat.prototype.format = function (n) {
+              n = Number(n); var o = this.o;
+              if (o.style === "percent") n *= 100;
+              var max = o.maximumFractionDigits;
+              if (max == null && o.style === "currency") max = 2;
+              var s = group(max == null ? String(n) : n.toFixed(max));
+              if (o.style === "percent") s += "%";
+              if (o.style === "currency" && o.currency) s = o.currency + " " + s;
+              return s;
+            };
+            NumberFormat.prototype.formatToParts = function (n) { return [{ type: "literal", value: this.format(n) }]; };
+            NumberFormat.prototype.resolvedOptions = function () { return Object.assign({ locale: "en", numberingSystem: "latn", style: "decimal" }, this.o); };
+            function DateTimeFormat(l, o) { this.o = o || {}; }
+            DateTimeFormat.prototype.format = function (d) {
+              d = d == null ? new Date() : new Date(d);
+              if (isNaN(d.getTime())) return "";
+              try { return d.toLocaleString(); } catch (e) { return d.toString(); }
+            };
+            DateTimeFormat.prototype.formatToParts = function (d) { return [{ type: "literal", value: this.format(d) }]; };
+            DateTimeFormat.prototype.formatRange = function (a, b) { return this.format(a) + " – " + this.format(b); };
+            DateTimeFormat.prototype.resolvedOptions = function () { return Object.assign({ locale: "en", calendar: "gregory", numberingSystem: "latn", timeZone: "UTC" }, this.o); };
+            function Collator(l, o) { this.o = o || {}; }
+            Collator.prototype.compare = function (a, b) { a = String(a); b = String(b); return a < b ? -1 : a > b ? 1 : 0; };
+            Collator.prototype.resolvedOptions = function () { return Object.assign({ locale: "en" }, this.o); };
+            function PluralRules(l, o) { this.o = o || {}; }
+            PluralRules.prototype.select = function (n) { return Number(n) === 1 ? "one" : "other"; };
+            PluralRules.prototype.resolvedOptions = function () { return Object.assign({ locale: "en", type: "cardinal" }, this.o); };
+            function RelativeTimeFormat(l, o) { this.o = o || {}; }
+            RelativeTimeFormat.prototype.format = function (v, u) { return v + " " + u + (Math.abs(v) === 1 ? "" : "s"); };
+            RelativeTimeFormat.prototype.formatToParts = function (v, u) { return [{ type: "literal", value: this.format(v, u) }]; };
+            RelativeTimeFormat.prototype.resolvedOptions = function () { return Object.assign({ locale: "en", numeric: "always", style: "long" }, this.o); };
+            function ListFormat(l, o) { this.o = o || {}; }
+            ListFormat.prototype.format = function (a) { return Array.from(a || []).join(", "); };
+            ListFormat.prototype.formatToParts = function (a) { return [{ type: "element", value: this.format(a) }]; };
+            ListFormat.prototype.resolvedOptions = function () { return Object.assign({ locale: "en", type: "conjunction", style: "long" }, this.o); };
+            I.NumberFormat = NumberFormat; I.DateTimeFormat = DateTimeFormat; I.Collator = Collator;
+            I.PluralRules = PluralRules; I.RelativeTimeFormat = RelativeTimeFormat; I.ListFormat = ListFormat;
+            ["NumberFormat", "DateTimeFormat", "Collator", "PluralRules", "RelativeTimeFormat", "ListFormat"].forEach(function (k) {
+              I[k].supportedLocalesOf = function (locs) { return Array.isArray(locs) ? locs.slice() : locs ? [locs] : []; };
+            });
+            I.getCanonicalLocales = function (locs) { return Array.isArray(locs) ? locs.slice() : locs ? [String(locs)] : []; };
+            globalThis.Intl = I;
+          }
+        JS
+
+        # WPT-only scaffolding: a minimal `WebAssembly.Memory` whose `.buffer`
+        # is a SharedArrayBuffer. The engine ships a real SharedArrayBuffer but
+        # no WebAssembly, and WPT's `common/sab.js` derives the SAB constructor
+        # from `new WebAssembly.Memory({shared:true}).buffer.constructor`. This
+        # is test-harness-only (real pages never need it), so it is opt-in and
+        # NOT part of #install_browser_globals.
+        def install_wasm_memory_shim
           @backend.eval(<<~JS)
-            globalThis.self = globalThis;
-            // Top-level window: parent/top are the window itself (spec), so
-            // frame-walking loops terminate instead of dereferencing undefined.
-            globalThis.parent = globalThis;
-            globalThis.top = globalThis;
-            globalThis.location = window.location;
-            globalThis.history = window.history;
-            globalThis.navigator = window.navigator;
-            globalThis.sessionStorage = window.sessionStorage;
-            globalThis.localStorage = window.localStorage;
-            globalThis.CSS = window.CSS;
-            globalThis.fetch = (...args) => window.fetch(...args);
-            globalThis.addEventListener = (...args) => window.addEventListener(...args);
-            globalThis.removeEventListener = (...args) => window.removeEventListener(...args);
-            globalThis.dispatchEvent = (event) => window.dispatchEvent(event);
-            // The window IS the global object, so JS built-in constructors and
-            // namespaces are also `window` properties (`window.String`,
-            // `window.Number`, …). Mirror them as own props on the window proxy
-            // so code that reads constructors off `window` (e.g. the WPT
-            // reflection harness's `window[type]` casts) resolves them.
-            for (const __n of [
-              "String", "Boolean", "Number", "BigInt", "Symbol", "Object", "Array",
-              "Function", "Date", "RegExp", "Promise", "Map", "Set", "WeakMap",
-              "WeakSet", "Math", "JSON", "Reflect", "Proxy", "Error", "TypeError",
-              "RangeError", "SyntaxError", "Infinity", "NaN", "undefined",
-              "parseInt", "parseFloat", "isNaN", "isFinite", "globalThis",
-            ]) {
-              try { window[__n] = globalThis[__n]; } catch (__e) {}
-            }
-            // Minimal WebAssembly.Memory: the engine provides a real
-            // SharedArrayBuffer but no WebAssembly, and WPT's `common/sab.js`
-            // derives the SAB constructor from
-            // `new WebAssembly.Memory({shared:true}).buffer.constructor`. A
-            // Memory whose `.buffer` is a SharedArrayBuffer is enough to let
-            // those tests (encodeInto, TextDecoder copy, …) exercise shared
-            // buffers with the real codec logic.
             if (typeof globalThis.WebAssembly === "undefined" && typeof globalThis.SharedArrayBuffer === "function") {
               globalThis.WebAssembly = {
                 Memory: function (opts) {
@@ -195,12 +476,139 @@ module Dommy
           @bridge.registered_count
         end
 
+        # Snapshot bridge crossing counts when DOMMY_JS_BRIDGE_PROFILE=1.
+        def bridge_crossing_counts(limit: nil)
+          @bridge.crossing_counts(limit: limit)
+        end
+
+        def reset_bridge_crossing_counts
+          @bridge.reset_crossing_counts
+          self
+        end
+
         def dispose
           @backend.dispose
         end
 
         private
 
+        # Scheduler hook: a timer/rAF callback raised. A JS-execution error —
+        # the callback threw (Quickjs::RuntimeError) or was force-killed for
+        # running too long (Quickjs::InterruptedError < RuntimeError) — must not
+        # escape its dispatch (WHATWG: a timer callback's exception is reported,
+        # the event loop keeps running). Record it and return truthy so the
+        # scheduler drops the timer and browsing continues. A non-JS error is a
+        # genuine host bug: return falsy so it propagates.
+        def handle_timer_error(error, timer)
+          return false unless error.is_a?(::Quickjs::RuntimeError)
+
+          # An out-of-memory in a timer callback poisons the whole VM: the page's
+          # JS is dead from here on, so flag it (and report once) — not just this
+          # one callback.
+          note_js_halted(error) if @backend.poisoned?
+          @callback_error_listener&.call(enrich_callback_error(error, timer))
+          true
+        end
+
+        # The VM hit out-of-memory and is poisoned. Surface the failure ONCE (a
+        # repeated drain would otherwise report it every tick) so the user sees
+        # that the page's JavaScript stopped, then leave it to the no-op guards.
+        def note_js_halted(error)
+          return if @js_halted
+
+          @js_halted = true
+          @callback_error_listener&.call(error)
+          nil
+        end
+
+        # Attach the timer's scheduling stack (where the page set the timer up) to
+        # the recorded error, so a callback that throws a stackless value — a bare
+        # `null`, common in minified bundles — is still traceable to the code that
+        # scheduled it. The error's class (and message, the dedup key) is kept;
+        # only its backtrace is replaced with the JS frames, which the diagnostics
+        # UI reads in place of the host scheduler internals. A no-op when no origin
+        # was captured (a timer not created through the instrumented globals, or a
+        # unit test driving the scheduler directly).
+        def enrich_callback_error(error, timer)
+          frames = fetch_timer_origin(timer)
+          error.set_backtrace(frames) unless frames.empty?
+          error
+        rescue StandardError
+          error
+        end
+
+        # The scheduling stack for `timer`, as cleaned frame strings (or []). The
+        # origin Error lives JS-side until now; fetching it also clears it.
+        def fetch_timer_origin(timer)
+          return [] unless timer.respond_to?(:id)
+
+          stack = @backend.call_js("__rbFetchTimerOrigin", timer.id).to_s
+          # Drop the shim's own frame (the `new Error()` in __rbDefer) so the top
+          # frame is the page code that called setTimeout/setInterval.
+          stack.split("\n").map(&:strip).reject(&:empty?)
+               .reject { |line| line.include?("__rbDefer") }
+        rescue StandardError
+          []
+        end
+
+        # Alias the bare browser globals frameworks reach for onto the installed
+        # window (self/parent/top/location/history/navigator/storages/CSS/fetch/
+        # event methods). This is what lets real frontend bundles run unmodified.
+        def alias_browser_globals
+          @backend.eval(<<~JS)
+            globalThis.self = globalThis;
+            // Top-level window: parent/top are the window itself (spec), so
+            // frame-walking loops terminate instead of dereferencing undefined.
+            globalThis.parent = globalThis;
+            globalThis.top = globalThis;
+            globalThis.location = window.location;
+            globalThis.history = window.history;
+            globalThis.navigator = window.navigator;
+            globalThis.sessionStorage = window.sessionStorage;
+            globalThis.localStorage = window.localStorage;
+            globalThis.CSS = window.CSS;
+            globalThis.getComputedStyle = (...args) => window.getComputedStyle(...args);
+            globalThis.matchMedia = (...args) => window.matchMedia(...args);
+            globalThis.fetch = (...args) => window.fetch(...args);
+            globalThis.addEventListener = (...args) => window.addEventListener(...args);
+            globalThis.removeEventListener = (...args) => window.removeEventListener(...args);
+            globalThis.dispatchEvent = (event) => window.dispatchEvent(event);
+
+            // More bare globals frameworks read directly (e.g. performance.now(),
+            // crypto, screen). Objects/values are aliased by reference; methods are
+            // wrapped so `this` binds to the window. All already exist on window.
+            for (const __n of ["performance", "crypto", "screen", "visualViewport",
+                               "indexedDB", "caches", "devicePixelRatio",
+                               "innerWidth", "innerHeight", "scrollX", "scrollY", "pageXOffset"]) {
+              try { globalThis[__n] = window[__n]; } catch (__e) {}
+            }
+            for (const __m of ["scrollTo", "scrollBy", "requestIdleCallback", "cancelIdleCallback",
+                               "getSelection", "structuredClone", "reportError", "btoa", "atob",
+                               "alert", "confirm", "prompt", "open", "postMessage"]) {
+              try { globalThis[__m] = (...args) => window[__m](...args); } catch (__e) {}
+            }
+          JS
+        end
+
+        # The window IS the global object, so JS built-in constructors and
+        # namespaces are also `window` properties (`window.String`,
+        # `window.Number`, …). Mirror them as own props on the window proxy so
+        # code that reads constructors off `window` (e.g. the WPT reflection
+        # harness's `window[type]` casts) resolves them.
+        def mirror_builtins_on_window
+          @backend.eval(<<~JS)
+            for (const __n of [
+              "String", "Boolean", "Number", "BigInt", "Symbol", "Object", "Array",
+              "Function", "Date", "RegExp", "Promise", "Map", "Set", "WeakMap",
+              "WeakSet", "Math", "JSON", "Reflect", "Proxy", "Error", "TypeError",
+              "RangeError", "SyntaxError", "Infinity", "NaN", "undefined",
+              "parseInt", "parseFloat", "isNaN", "isFinite", "globalThis",
+            ]) {
+              try { window[__n] = globalThis[__n]; } catch (__e) {}
+            }
+          JS
+        end
+
         def eval_tagged(inner_expr)
           @backend.eval_awaited("__rbHost.tag(#{inner_expr});")
         end

data/lib/dommy/js/quickjs/script_cache.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Js
+    module Quickjs
+      # A process-global cache of compiled external-script bytecode, keyed by
+      # URL. Vendored bundles (turbo.umd.js, stimulus.umd.js, application.js, …)
+      # are identical across page loads but otherwise re-parsed on every fresh
+      # VM; compiling each once and running the bytecode per VM removes that
+      # repeated parse cost (the bundles are hundreds of KB).
+      #
+      # Keyed by URL: an asset URL maps 1:1 to its content (Propshaft / Sprockets
+      # digest-stamp it; test fixtures are stable within a process).
+      #
+      # The bridge's built-in runtime bundles (host_runtime.js,
+      # observable_runtime.js) use a separate cache in Backend#run_bundle, so an
+      # external-script count here stays uncontaminated by engine internals.
+      module ScriptCache
+        @cache = {}
+        @mutex = Mutex.new
+
+        class << self
+          # The compiled bytecode for `url`, compiling `source` on first use.
+          def compiled(url, source)
+            @mutex.synchronize { @cache[url] ||= Backend.compile(source, filename: url.to_s) }
+          end
+
+          def clear
+            @mutex.synchronize { @cache.clear }
+          end
+
+          def size = @cache.size
+        end
+      end
+    end
+  end
+end