dommy-js-quickjs 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56e600a474810ea778587cf249cbb7c200d9947c28270449837550971e5674de
-  data.tar.gz: ff9e6cf37ed37fb89f148163e38ee6fdd63e8bd5fc1e81669f8538eebc84d3ea
+  metadata.gz: e78c3781c9d334b0ec8bd70fb68b0fa285685e5de516ff5b72d073aa74800ca1
+  data.tar.gz: 9278f706bd5d0929b3c74130e188c90f5bb07e2c8213f84130a21a0b3acce671
 SHA512:
-  metadata.gz: ffa632c98fe6c8bedba9bc8e189cda13a1c9baef1c4bd0224fa1f7f9ffd31bdcaad8bcb84ffdbdf2b2436ec3a29bb68d0d8ceaa7879602f5cc45d8edbc1633ba
-  data.tar.gz: 22272e499d364204ecba6edb91cb6c01953d72d46990652b3f14907e2141686e8bbc8d94de3d5125e2f96b21e9e1a34b8d5c887c41af3dbe8cd693e33a2370bd
+  metadata.gz: e09091050fc6e2d6512708a5cf105da37ae9e30b3edc33da6258d3ac83981837ba52b6d4c4d152e099f7c19cdb146d2e8046b005227227cb54fc98e12447b45b
+  data.tar.gz: cd6dd057505db8978757a52d7a52a99d2060b957ea3538db112013d4129178b81a9535bb9ec69ef2c88bc4dccc29ab8aeaa99a847e801c127d0898587dbcbbba

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 # 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`.
+
+### Added
+
+- ES modules can be preloaded as bytecode. `Runtime.register_module(name, source:)` registers a module once per process (wrapping `Quickjs.register_module`), and `Runtime.new(preload_modules: [name, …])` reads registered modules into the new VM, so a later page loads them without parsing their source again. A preloaded module is found before the module loader is asked for its name, and a loader that returns `{as: name}` for another specifier lands on it too. dommy's `Dommy::Js::ModulePreload` drives both: with it enabled, a page that imports Turbo as an ES module boots in about 11 ms instead of 24 ms from the third page on.
+
+### Changed
+
+- Requires `dommy >= 0.15.0, < 0.16` (was `>= 0.14.0, < 0.15`), the release whose `ModulePreload` uses the API above and whose behavior the suite checks.
+- Requires `quickjs ~> 0.22.0` (was `~> 0.21.0`). 0.22.0 releases [hmsk/quickjs.rb#141](https://github.com/hmsk/quickjs.rb/pull/141): an unhandled rejection is reported at the end of the microtask checkpoint, as HTML requires, so `Promise.reject(x).catch(...)` and `try { await rejecting() } catch {}` are no longer misreported. On a RubyGems install, `on_unhandled_rejection` reports again, a strict `Dommy::Browser` fails on a rejection the page leaves unhandled, and the page's `unhandledrejection` event fires. `event.reason` and `event.promise` are still not the page's own values there, and `rejectionhandled` does not fire: those need the JS rejection hook, which no quickjs release has yet.
+- The development Gemfile pins the quickjs fork that carries the hook by tag ([`v0.22.0-rejection-hook.1`](https://github.com/takahashim/quickjs.rb/tree/v0.22.0-rejection-hook.1)) rather than by commit, so the fork's branch can be rebased onto each upstream release without stranding the ref an older commit pins.
+- The suite no longer takes `DOMMY_BACKEND`: dommy 0.15 has Makiri as its only backend.
+
+### Removed
+
+- The 0.21.0 workaround is gone: `Backend.premature_rejection_reports?`, its once-per-process probe, and the warning `on_unhandled_rejection` gave in place of reporting. No quickjs the gemspec allows behaves that way.
+
 ## 0.10.0 — 2026-10-01
 
 Requires `dommy >= 0.14.0, < 0.15` and `quickjs ~> 0.21.0`.

data/README.md

@@ -110,15 +110,37 @@ The pieces it relies on are public Runtime API:
 - `Runtime#on_unhandled_rejection { |err| }` — surface promise rejections that
   reach the microtask queue with no handler. Frameworks swallow these; `err.backtrace`
   carries the JS stack, which is the difference between blind and one-shot debugging.
-  The released quickjs (0.21.0) reports a rejection before a handler attached in
-  the same microtask checkpoint can catch it, so `.catch` and `try { await … }
-  catch` would look unhandled; on such an engine nothing is reported here (a
-  warning says so once), so a strict `Dommy::Browser` does not fail on
-  rejections and the page's `unhandledrejection` event (and
-  `window.onunhandledrejection`) never fires. A quickjs with
-  [hmsk/quickjs.rb#141](https://github.com/hmsk/quickjs.rb/pull/141) reports them.
 - `Runtime#on_log { |log| }` — observe `console.*` (`log.severity` / `log.to_s`).
 
+### Preloading ES modules
+
+A module the loader hands over as source is parsed again by every Runtime that
+imports it. Register it once per process and later Runtimes read it in as
+bytecode instead:
+
+```ruby
+Dommy::Js::Quickjs::Runtime.register_module("https://example.test/vendor/turbo.js", source: turbo_js)
+
+rt = Dommy::Js::Quickjs::Runtime.new(preload_modules: ["https://example.test/vendor/turbo.js"])
+rt.module_loader = ->(specifier, _importer) {
+  {as: "https://example.test/vendor/turbo.js"} if specifier == "@hotwired/turbo"
+}
+```
+
+- The name is the module's canonical name: the VM keys its module map by it,
+  and the module's relative imports resolve against it. Register a page's
+  module under its resolved URL.
+- `source:` may be a Proc returning the source; it is read when a Runtime first
+  preloads the module, and the bytecode is shared from then on. Each Runtime
+  still gets its own instance, with its own module-level state.
+- A preloaded module is found before the loader is asked for its name. A loader
+  that returns `{as: name}` for another specifier (an importmap entry, say)
+  lands on it too.
+- A preloaded module's own imports are not preloaded; register each one you
+  want cached. Naming a module that is not registered raises `ArgumentError`.
+- Preloading bypasses the loader for that name, so do not preload a module the
+  loader would refuse to some importers.
+
 ### Capybara
 
 Requiring the adapter enables `execute_script` / `evaluate_script` on

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

@@ -45,42 +45,9 @@ module Dommy
       # the top-level tag); either way it maps to Dommy::Bridge::UNDEFINED. No
       # normalization is needed here.
       class Backend
-        # Whether this quickjs reports a promise rejection the moment it
-        # happens, before a handler attached later in the same microtask
-        # checkpoint gets the chance — the released quickjs (0.21.0) does, so
-        # `Promise.reject(x).catch(f)` and `try { await p } catch {}` both
-        # come out as unhandled. HTML reports at the end of the checkpoint
-        # (hmsk/quickjs.rb#141, merged upstream but unreleased).
-        #
-        # Decided by behavior, not by version — a git checkout of the fixed
-        # engine still says 0.21.0 — on a throwaway VM, once per process.
-        def self.premature_rejection_reports?
-          return @premature_rejection_reports if defined?(@premature_rejection_reports)
-
-          @premature_rejection_reports = probe_premature_rejection_reports
-        end
-
-        def self.probe_premature_rejection_reports
-          vm = ::Quickjs::VM.new
-          reported = false
-          vm.on_unhandled_rejection { |_error| reported = true }
-          vm.eval_code(<<~JS, async: false)
-            Promise.reject(1).catch(function () {});
-            (async function () { try { await Promise.reject(2); } catch (e) {} })();
-            0
-          JS
-          vm.drain_jobs!
-          reported
-        rescue ::StandardError
-          # A probe that cannot run says nothing either way; keep reporting.
-          false
-        ensure
-          vm&.dispose!
-        end
-        private_class_method :probe_premature_rejection_reports
-
         # Timeout and memory ceiling both differ from the gem's defaults, for
-        # reasons Config documents.
+        # reasons Config documents. Every other option goes to the VM as is,
+        # `preload_modules:` among them (see Runtime#initialize).
         def initialize(**vm_opts)
           vm_opts = {timeout_msec: Config.timeout_msec, memory_limit: Config.memory_limit}.merge(vm_opts)
           @vm = ::Quickjs::VM.new(**vm_opts)
@@ -114,6 +81,14 @@ module Dommy
           ::Quickjs.compile(source, filename: filename)
         end
 
+        # Register an ES module process-wide under its canonical name: compiled
+        # to bytecode once, on the first VM that preloads it, and read into each
+        # VM that names it in `preload_modules:`. `source:` is a String or a Proc
+        # returning one.
+        def self.register_module(name, source:)
+          ::Quickjs.register_module(name, source: source)
+        end
+
         # Process-global cache for the engine-internal runtime bundles run via
         # #run_bundle (host_runtime.js, observable_runtime.js). Kept separate
         # from ScriptCache (user-facing external scripts) so the two concerns
@@ -121,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
@@ -143,8 +124,8 @@ module Dommy
         def eval_awaited(js) = guarded { @vm.eval_code(js, async: true) }
 
         # Install the ESM module resolver: a callable `(specifier, importer) ->
-        # source String | { code:, as: } | nil` the engine consults for every
-        # static/dynamic `import`. nil clears it (engine default loader).
+        # source String | { code:, as: } | { as: } | nil` the engine consults for
+        # every static/dynamic `import`. nil clears it (engine default loader).
         def module_loader=(callable)
           @vm.module_loader = callable
         end

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/runtime.rb

@@ -21,8 +21,23 @@ module Dommy
       # What stays here is the port itself: script evaluation, and the wiring
       # that decides which collaborator answers a host's call.
       class Runtime
-        def initialize(**vm_opts)
-          @backend = Backend.new(**vm_opts)
+        # Register an ES module process-wide, so a later Runtime can preload it
+        # as bytecode instead of parsing its source again. `name` is the
+        # module's canonical name — the one the VM's module map keys it by and
+        # its relative imports resolve against — so a page module is best
+        # registered under its resolved URL. `source:` is a String or a Proc
+        # returning one (read only when a Runtime first preloads it).
+        def self.register_module(name, source:)
+          Backend.register_module(name, source: source)
+        end
+
+        # `preload_modules:` names registered modules (see .register_module) to
+        # read into this Runtime's VM as it is made. A preloaded module is found
+        # before the module loader is asked for its name, and a loader that
+        # returns `{as: name}` for another specifier lands on it too. A name not
+        # registered raises ArgumentError. Other options go to the VM.
+        def initialize(preload_modules: [], **vm_opts)
+          @backend = Backend.new(preload_modules: preload_modules, **vm_opts)
           @bridge = Dommy::Js::HostBridge.new(@backend)
           @environment = BrowserEnvironment.new(@backend)
           @errors = ErrorTranslator.new(@backend, @bridge)
@@ -113,7 +128,9 @@ module Dommy
         end
 
         # Install the ESM module resolver (see Backend#module_loader=). A
-        # callable `(specifier, importer) -> source | {code:, as:} | nil`.
+        # callable `(specifier, importer) -> source | {code:, as:} | {as:} | nil`;
+        # `{as: name}` with no code redirects to a module the VM already has,
+        # such as one in `preload_modules:`.
         def module_loader=(callable)
           @backend.module_loader = callable
         end
@@ -195,19 +212,11 @@ module Dommy
         # Surface otherwise-swallowed JS promise rejections (see Backend).
         # Goes quiet once the JS hook is installed: both would fire for the same
         # rejection, and the hook carries strictly more.
-        #
-        # Goes quiet, too, on an engine that reports a rejection before a
-        # handler could attach (Backend.premature_rejection_reports?): there
-        # every `.catch` and `try { await … } catch` would surface as an
-        # unhandled rejection and fail a strict host on correct code. Reporting
-        # none is the lesser loss — a rejection the page truly leaves unhandled
-        # goes unreported until the engine is fixed.
         def on_unhandled_rejection(&block)
           # Decided when a rejection actually arrives, not now: a host registers
           # this before #install_window, which is where the hook goes in.
           relay = lambda do |error|
             next if js_rejection_hook?
-            next self.class.warn_premature_rejection_reports if Backend.premature_rejection_reports?
 
             block.call(@track_rejections ? @errors.enrich_rejection(error) : error)
           end
@@ -215,17 +224,6 @@ module Dommy
           self
         end
 
-        # Said once per process, on the first rejection left unreported.
-        def self.warn_premature_rejection_reports
-          return if @warned_premature_rejection_reports
-
-          @warned_premature_rejection_reports = true
-          warn "dommy-js-quickjs: this quickjs (#{::Quickjs::VERSION}) reports a promise rejection before " \
-               "a handler can attach, so unhandled rejections are not reported. A quickjs with " \
-               "hmsk/quickjs.rb#141 (unhandled-rejection timing) reports them."
-          nil
-        end
-
         # Whether rejections arrive through the JS hook. A host that also relays
         # #on_unhandled_rejection would otherwise report each rejection twice.
         def js_rejection_hook? = !!@js_rejection_hook

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

@@ -3,7 +3,7 @@
 module Dommy
   module Js
     module Quickjs
-      VERSION = "0.10.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.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - takahashim
@@ -15,34 +15,34 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.0
 - !ruby/object:Gem::Dependency
   name: dommy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: '0.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        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