dommy-js-quickjs 0.1.0 → 0.10.0

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

@@ -0,0 +1,40 @@
+# 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
+
+          # Under the mutex like the others: one lock guards this cache, and a
+          # reader that steps outside it is the kind of inconsistency that only
+          # shows up under load.
+          def size = @mutex.synchronize { @cache.size }
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Dommy
   module Js
     module Quickjs
-      VERSION = "0.1.0"
+      VERSION = "0.10.0"
     end
   end
 end

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

@@ -15,13 +15,13 @@ module Dommy
       # cross as plain Ruby values. Callbacks the guest registers become JS
       # functions (also refs) that route back through `__rbWasmInvoke`.
       class WasmBridge
-        # An opaque handle to a JS value living in the VM. `ref` is the integer
-        # id into the JS-side jsRefs table.
-        JSValue = Struct.new(:ref) do
-          def to_s
-            "#<JSValue ref=#{ref}>"
-          end
-        end
+        # An opaque handle to a JS value living in the VM, identified by its id
+        # into the JS-side `jsRefs` table. This is the SAME table and the SAME
+        # `__rb_js_ref` tag the Proxy bridge's dehydrate/rehydrate use (see
+        # host_runtime.js), so a ref is one concept across both bridges — hence a
+        # single shared type. Aliased here so existing `WasmBridge::JSValue`
+        # callers keep resolving.
+        JSValue = ::Dommy::Bridge::JSValue
 
         def initialize(backend)
           @backend = backend
@@ -105,9 +105,15 @@ module Dommy
 
         # Ruby value -> wasm-tagged JS value. Public so the embedder's
         # #on_invoke dispatcher can pack the values it hands back into JS.
+        #
+        # Deliberately not core's Marshaller, which shares the same WireTags but
+        # answers a bigger question: it wraps host objects as DOM proxies, binds
+        # callbacks and resolves interfaces against a handle table. A wasm guest
+        # has none of that — every non-primitive is an opaque ref it asks about
+        # through #get / #call — so what it needs is the tags and nothing else.
         def pack(value)
           case value
-          when JSValue then {"__rb_js_ref" => value.ref}
+          when JSValue then {Dommy::Bridge::WireTags::JS_REF => value.ref}
           when nil, true, false, Integer, Float, String then value
           when Symbol then value.to_s
           when Array then value.map { |e| pack(e) }
@@ -122,14 +128,14 @@ module Dommy
         def unpack(value)
           case value
           when Hash
-            if value.key?("__rb_js_ref")
-              JSValue.new(value["__rb_js_ref"])
-            elsif value.key?("__rb_undefined")
+            if value.key?(Dommy::Bridge::WireTags::JS_REF)
+              JSValue.new(value[Dommy::Bridge::WireTags::JS_REF])
+            elsif value.key?(Dommy::Bridge::WireTags::UNDEFINED)
               nil
-            elsif value.key?("__rb_bytes")
-              value["__rb_bytes"]
-            elsif value.key?("__rb_arraybuffer")
-              value["__rb_arraybuffer"]
+            elsif value.key?(Dommy::Bridge::WireTags::BYTES)
+              value[Dommy::Bridge::WireTags::BYTES]
+            elsif value.key?(Dommy::Bridge::WireTags::ARRAY_BUFFER)
+              value[Dommy::Bridge::WireTags::ARRAY_BUFFER]
             else
               value.each_with_object({}) { |(k, v), h| h[k] = unpack(v) }
             end

data/lib/dommy/js/quickjs.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "dommy"
 require_relative "quickjs/version"
 
 module Dommy
@@ -10,11 +11,22 @@ module Dommy
   end
 end
 
-require_relative "handle_table"
-require_relative "dom_interfaces"
-require_relative "constructor_registry"
-require_relative "custom_elements"
-require_relative "host_bridge"
+# The engine-agnostic host layer lives in the `dommy` gem (loaded above via
+# `require "dommy"`): the Runtime port + registry, ScriptBoot/ImportMap/
+# ModuleLoader, Dommy::Browser, AND the JS<->Ruby DOM bridge (HostBridge +
+# Bridge::WireTags / Js::HandleTable / DomInterfaces / ConstructorResolver /
+# CustomElementBridge, with host_runtime.js / observable_runtime.js). This gem
+# provides only the QuickJS backend that plugs in underneath.
+require_relative "quickjs/config"
 require_relative "quickjs/backend"
+require_relative "quickjs/browser_environment"
+require_relative "quickjs/event_loop"
+require_relative "quickjs/error_translator"
 require_relative "quickjs/wasm_bridge"
 require_relative "quickjs/runtime"
+require_relative "quickjs/script_cache"
+
+# Register QuickJS as a pluggable JS runtime backend (the default). The host
+# layer builds runtimes through `Dommy::Js.build_runtime` rather than naming
+# this class directly.
+Dommy::Js.register_runtime(:quickjs) { |**opts| Dommy::Js::Quickjs::Runtime.new(**opts) }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dommy-js-quickjs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.10.0
 platform: ruby
 authors:
 - takahashim
 bindir: exe
 cert_chain: []
-date: 2026-05-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: quickjs
@@ -15,28 +15,34 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.21.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.21.0
 - !ruby/object:Gem::Dependency
   name: dommy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: '0.15'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: '0.15'
 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
@@ -50,20 +56,22 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- docs/bridge-redesign.md
-- docs/wpt-conformance.md
-- lib/dommy/js/constructor_registry.rb
-- lib/dommy/js/custom_elements.rb
-- lib/dommy/js/dom_interfaces.rb
-- lib/dommy/js/handle_table.rb
-- lib/dommy/js/host_bridge.rb
-- lib/dommy/js/host_runtime.js
-- lib/dommy/js/observable_runtime.js
 - lib/dommy/js/quickjs.rb
 - lib/dommy/js/quickjs/backend.rb
+- lib/dommy/js/quickjs/browser_environment.rb
 - lib/dommy/js/quickjs/capybara.rb
+- lib/dommy/js/quickjs/config.rb
+- lib/dommy/js/quickjs/error_translator.rb
+- lib/dommy/js/quickjs/event_loop.rb
+- lib/dommy/js/quickjs/js/browser_globals.js
+- lib/dommy/js/quickjs/js/error_rebuild.js
+- lib/dommy/js/quickjs/js/intl_polyfill.js
+- lib/dommy/js/quickjs/js/timer_globals.js
+- lib/dommy/js/quickjs/js/wasm_stub.js
+- lib/dommy/js/quickjs/js/window_builtins.js
+- lib/dommy/js/quickjs/rack.rb
 - lib/dommy/js/quickjs/runtime.rb
+- lib/dommy/js/quickjs/script_cache.rb
 - lib/dommy/js/quickjs/version.rb
 - lib/dommy/js/quickjs/wasm_bridge.rb
 - sig/dommy/js/quickjs.rbs
@@ -89,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.20
 specification_version: 4
 summary: QuickJS backend for running JavaScript against a Dommy DOM.
 test_files: []

data/Rakefile

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "minitest/test_task"
-
-Minitest::TestTask.create
-
-task default: :test
-
-namespace :wpt do
-  desc "Run the vendored WPT corpus against the bridge and report a conformance rate"
-  task :conformance, [:filter] do |_t, args|
-    $LOAD_PATH.unshift File.expand_path("test", __dir__)
-    require "test_helper"
-    require "support/wpt_runner"
-
-    runner = Dommy::Js::WptRunner
-    files = runner.manifest
-    files = files.grep(/#{args[:filter]}/) if args[:filter]
-
-    total_pass = total = file_ok = 0
-    blocked = []
-    by_dir = Hash.new { |h, k| h[k] = [0, 0] } # dir => [pass, total]
-    files.each do |rel|
-      results = runner.run(rel)
-      pass = results.count(&:pass?)
-      n = results.size
-      total_pass += pass
-      total += n
-      dir = rel.split("/").first
-      by_dir[dir][0] += pass
-      by_dir[dir][1] += n
-      file_ok += 1 if n.positive? && pass == n
-      flag = n.zero? ? "—" : (pass == n ? "✓" : " ")
-      printf("  %s %-46s %3d/%-3d\n", flag, rel, pass, n)
-      results.reject(&:pass?).first(3).each { |r| puts "        #{r.to_s[0, 110]}" }
-    rescue => e
-      blocked << rel
-      puts "  ✗ #{rel}  (errored: #{e.class}: #{e.message[0, 80]})"
-    end
-
-    pct = ->(p, t) { t.zero? ? 0 : (100.0 * p / t).round(1) }
-    puts
-    by_dir.sort.each { |dir, (p, t)| printf("  %-8s %4d/%-5d (%.1f%%)\n", dir, p, t, pct.call(p, t)) }
-    puts
-    puts "WPT conformance: #{total_pass}/#{total} subtests (#{pct.call(total_pass, total)}%) across #{files.size} files; " \
-         "#{file_ok} files fully green#{blocked.empty? ? "" : ", #{blocked.size} errored"}"
-  end
-end