dommy-js-quickjs 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df093cff1000de6ad73f27367c17845c2b6846b87785913d70695b0d38938daf
-  data.tar.gz: aab8821f4e6974306d7e47b35730f32d7340cec51437d0926e94986e692bbb4d
+  metadata.gz: e78c3781c9d334b0ec8bd70fb68b0fa285685e5de516ff5b72d073aa74800ca1
+  data.tar.gz: 9278f706bd5d0929b3c74130e188c90f5bb07e2c8213f84130a21a0b3acce671
 SHA512:
-  metadata.gz: efe4b423fc15fc33f2e3a77108f145cadf0d4d072b69c9447f958cbdcb872b367cd7857ce07a975bacb2d7a64a36c3bee760a4070ebfcc893bff8e6df8ea8441
-  data.tar.gz: c5fa56f132d9df6e4c067f96f0fa5c1e915c63d9ff641832c72aac75307e6fad57d7e671e4585e0cdffe73419cba0e965a08d750e2c50e5dfbad223b5987c6f1
+  metadata.gz: e09091050fc6e2d6512708a5cf105da37ae9e30b3edc33da6258d3ac83981837ba52b6d4c4d152e099f7c19cdb146d2e8046b005227227cb54fc98e12447b45b
+  data.tar.gz: cd6dd057505db8978757a52d7a52a99d2060b957ea3538db112013d4129178b81a9535bb9ec69ef2c88bc4dccc29ab8aeaa99a847e801c127d0898587dbcbbba

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.12.0 — 2026-10-10
+
+Requires `dommy >= 0.16.0, < 0.17` and `quickjs ~> 0.22.0`.
+
+### Added
+
+- A bare `frameElement` global, read from the window on each access (a frame's container can change). It is a plain readonly attribute, so unlike the [Replaceable] ones below an assignment does not replace it.
+
+### Changed
+
+- Requires `dommy >= 0.16.0, < 0.17` (was `>= 0.15.0, < 0.16`). dommy 0.16.0 needs makiri 0.16.0 and changes what `Session#click_link` and `#click_button` return; the suite passes against it, and the boot-cost bound below needs its lazy interface seeding.
+- The realm's bootstrap bundles no longer hand their completion value to Ruby. `window_builtins.js` ends by assigning `window.globalThis`, so every page load converted the whole global object to a Ruby value: 184 host reads and about 6 ms. `Backend#run_bundle` now discards it (the compiled bundle ends with `void 0`). `test/dommy/js/test_window_boot.rb` checks that lazily seeded interfaces resolve like eager ones and bounds the bridge crossings of opening a window (`install_window` under 60; it was 424).
+- The bare timer globals follow the IDL: `setTimeout(handler, timeout = 0, ...arguments)` and `setInterval` hand the extra arguments to the handler, and every timer global has the IDL's `length` (`setTimeout.length` is 1, `clearTimeout.length` 0).
+- The bare forwards to window methods (`structuredClone`, `fetch`, `postMessage`, `addEventListener`, …) carry the operation's name and `length` from dommy's generated WebIDL signatures, instead of being 0-length `(...args)` wrappers.
+- `innerWidth`, `innerHeight`, `scrollX`/`scrollY`, `pageXOffset`/`pageYOffset` and `devicePixelRatio` are read from the window on each access rather than copied once at boot, and an assignment replaces them ([Replaceable]).
+- The WPT file runner boots its browser with `navigable: true`, so an `<iframe src>` loads through dommy's child navigables and the browser's resources (dommy now gives every iframe an initial `about:blank` document and navigates it from a task). `dom/nodes/Element-matches.html` and `Element-webkitMatchesSelector.html` are back to 669/669 and `ParentNode-querySelector-All.html` to 1975/1975.
+- Tests follow dommy's spec changes: a srcless or `about:blank` iframe fires `load` during `appendChild`; boot runs HTML's "the end" to the load task, so a `setTimeout(0)` queued while parsing has fired before `Dommy::Browser.new` / `Session#visit` return, even with `settle: false` (which still leaves what the load handler queued pending); an unhandled rejection fails from the queued "notify about rejected promises" task, at the next `settle`, not from `execute`; and the custom element construction-stack test defines through a `CustomElementRegistry` host object and runs `__rbHost.ceUpgrade`.
+
+### Fixed
+
+- The bare `localStorage` and `sessionStorage` globals are read from the window on each access instead of being copied at boot, so a window on an opaque origin (`about:blank`, which `Dommy::Browser.visit` starts from, `data:`, a sandboxed frame) no longer fails to install its globals with `SecurityError: Storage is disabled for an opaque origin`; the page gets that `SecurityError` when it reads them, as the HTML spec says. They are no longer enumerable own properties of the global.
+
 ## 0.11.0 — 2026-10-04
 
 Requires `dommy >= 0.15.0, < 0.16` and `quickjs ~> 0.22.0`.

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

@@ -96,8 +96,14 @@ module Dommy
         @bundle_cache = {}
         @bundle_mutex = Mutex.new
 
+        # A bundle runs for its side effects, so its completion value is
+        # discarded (the trailing `void 0`, on a line of its own so a final
+        # line comment cannot swallow it). Whatever its last statement
+        # evaluated to would otherwise be converted to a Ruby value on every
+        # VM — for window_builtins.js, whose last statement assigns
+        # `window.globalThis`, the entire global object.
         def self.compiled_bundle(cache_key, source)
-          @bundle_mutex.synchronize { @bundle_cache[cache_key] ||= compile(source, filename: cache_key.to_s) }
+          @bundle_mutex.synchronize { @bundle_cache[cache_key] ||= compile("#{source}\n;void 0;", filename: cache_key.to_s) }
         end
 
         # Execute precompiled bytecode (a Quickjs::Runnable) on this VM in global

data/lib/dommy/js/quickjs/js/browser_globals.js

@@ -11,26 +11,83 @@ globalThis.frames = window;
 globalThis.location = window.location;
 globalThis.history = window.history;
 globalThis.navigator = window.navigator;
-globalThis.sessionStorage = window.sessionStorage;
-globalThis.localStorage = window.localStorage;
+// Web Storage is read from the window on each access, not copied at boot: the
+// sessionStorage / localStorage getters throw a SecurityError when "obtain a
+// session/local storage bottle map" fails (HTML, Web storage), which it does
+// for an opaque origin (Storage Standard, "obtain a storage key": an opaque
+// origin is failure). A page on about:blank, data: or a sandboxed frame must
+// see that when it reads `localStorage`, and it must not abort installing the
+// rest of the globals. Not enumerable: on a real window they are accessors of
+// Window.prototype, not own keys of the global — and an enumerable throwing
+// getter would break whatever walks the global's own properties (handing
+// `globalThis` to the host, as window_builtins.js does, reads each of them).
+for (const __n of ["sessionStorage", "localStorage"]) {
+  Object.defineProperty(globalThis, __n, {
+    get() { return window[__n]; },
+    enumerable: false,
+    configurable: true,
+  });
+}
 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);
+// A bare window method forwards to the window, named and sized as the IDL
+// declares it (`structuredClone.length` is 1, not a rest wrapper's 0): the
+// generated signatures dommy loads give each operation's required-argument
+// count, looked up along the interface's inheritance (EventTarget's
+// addEventListener).
+const __rbWindowOperation = (name) => {
+  const signatures = globalThis.__rbIdlSignatures || {};
+  for (let iface = "Window"; iface && signatures[iface]; iface = signatures[iface].inherits) {
+    const operation = (signatures[iface].operations || {})[name];
+    if (operation) return operation;
+  }
+  return null;
+};
+const __rbForwardWindowMethod = (name) => {
+  const forward = function (...args) { return window[name](...args); };
+  const operation = __rbWindowOperation(name);
+  Object.defineProperty(forward, "name", { value: name });
+  Object.defineProperty(forward, "length", { value: operation ? operation.required : 0 });
+  globalThis[name] = forward;
+};
+for (const __m of ["getComputedStyle", "matchMedia", "fetch",
+                   "addEventListener", "removeEventListener", "dispatchEvent"]) {
+  __rbForwardWindowMethod(__m);
+}
 
 // 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.
+// screen). Objects the window always returns the same of are aliased by
+// reference; methods forward (above) so `this` binds to the window.
 for (const __n of ["performance", "crypto", "screen", "visualViewport",
-                   "indexedDB", "caches", "devicePixelRatio",
-                   "innerWidth", "innerHeight", "scrollX", "scrollY", "pageXOffset"]) {
+                   "indexedDB", "caches"]) {
   try { globalThis[__n] = window[__n]; } catch (__e) {}
 }
+// Values that change (a resize, a scroll) are read from the window each time
+// rather than copied once at boot. They are [Replaceable]: an assignment
+// replaces the accessor with the assigned value, as on a real window.
+for (const __n of ["devicePixelRatio", "innerWidth", "innerHeight",
+                   "scrollX", "scrollY", "pageXOffset", "pageYOffset"]) {
+  try {
+    Object.defineProperty(globalThis, __n, {
+      get() { return window[__n]; },
+      set(value) {
+        Object.defineProperty(globalThis, __n, { value, writable: true, enumerable: true, configurable: true });
+      },
+      enumerable: true,
+      configurable: true,
+    });
+  } catch (__e) {}
+}
+// `frameElement` is a plain readonly attribute: read from the window each
+// time (a frame's container can change), never replaced by an assignment.
+try {
+  Object.defineProperty(globalThis, "frameElement", {
+    get() { return window.frameElement; },
+    enumerable: false,
+    configurable: true,
+  });
+} 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) {}
+  try { __rbForwardWindowMethod(__m); } catch (__e) {}
 }

data/lib/dommy/js/quickjs/js/timer_globals.js

@@ -30,17 +30,28 @@ globalThis.__rbFetchTimerOrigin = (id) => {
   __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) => __rbDefer((f, d) => window.setInterval(f, d), fn, delay);
-globalThis.clearInterval = (id) => window.clearInterval(id);
-globalThis.requestAnimationFrame = (fn) => __rbDefer((f) => window.requestAnimationFrame(f), fn);
-globalThis.cancelAnimationFrame = (id) => window.cancelAnimationFrame(id);
+// The signatures are the IDL's (HTML "timers"): `setTimeout(handler, timeout
+// = 0, ...arguments)` hands the extra arguments to the handler, and the
+// defaults keep each function's `length` the IDL's (1, 0, 1, 0, 1, 1).
+globalThis.setTimeout = function setTimeout(handler, timeout = 0, ...args) {
+  return __rbDefer((f, d) => window.setTimeout(f, d, ...args), handler, timeout);
+};
+globalThis.clearTimeout = function clearTimeout(id = 0) { return window.clearTimeout(id); };
+globalThis.setInterval = function setInterval(handler, timeout = 0, ...args) {
+  return __rbDefer((f, d) => window.setInterval(f, d, ...args), handler, timeout);
+};
+globalThis.clearInterval = function clearInterval(id = 0) { return window.clearInterval(id); };
+globalThis.requestAnimationFrame = function requestAnimationFrame(callback) {
+  return __rbDefer((f) => window.requestAnimationFrame(f), callback);
+};
+globalThis.cancelAnimationFrame = function cancelAnimationFrame(handle) {
+  return window.cancelAnimationFrame(handle);
+};
 // queueMicrotask must share the engine's promise-job (microtask) queue so its
 // callbacks are FIFO-ordered with Promise reactions (the WHATWG
 // single-microtask-queue model). Routing through the Ruby scheduler instead
 // would drain on a separate pass, reordering it after all native promise jobs.
-globalThis.queueMicrotask = (fn) => {
-  if (typeof fn !== "function") throw new TypeError("queueMicrotask requires a function");
-  Promise.resolve().then(() => { fn(); });
+globalThis.queueMicrotask = function queueMicrotask(callback) {
+  if (typeof callback !== "function") throw new TypeError("queueMicrotask requires a function");
+  Promise.resolve().then(() => { callback(); });
 };

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

@@ -3,7 +3,7 @@
 module Dommy
   module Js
     module Quickjs
-      VERSION = "0.11.0"
+      VERSION = "0.12.0"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dommy-js-quickjs
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - takahashim
@@ -29,20 +29,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.17'
 description: |
   dommy-js-quickjs lets JavaScript drive a Dommy DOM by embedding QuickJS (via
   the quickjs gem) and bridging DOM nodes to JS through an ES Proxy that routes