dommy-js-quickjs 0.1.0 → 0.9.0

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

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Js
+    module Quickjs
+      # Source-level workaround for a QuickJS bytecode-generation bug: a `for...of`
+      # whose ITERABLE expression contains a `yield` fails to COMPILE with an
+      # internal "stack underflow" error (the for-of iterator-close finally region
+      # miscomputes the operand stack across the generator suspend). V8 / real
+      # browsers compile it fine, so SPA bundles ship it — e.g. note.com's modern
+      # build has `for (var f of (yield O(), _)) v(f)`, and the whole code-split
+      # chunk fails to load, so the app never mounts.
+      #
+      # The fix hoists the iterable into a temp `var` so the `yield` leaves the
+      # for-of operand position — `for (x of (yield a, b)) …` becomes
+      # `var t = (yield a, b); for (x of t) …` — semantically identical, and it
+      # compiles. Applied ONLY as a retry after a genuine "stack underflow" compile
+      # failure (see Backend), so working scripts are never rewritten and an
+      # imperfect transform cannot regress anything (the source already failed).
+      module SourceGuard
+        module_function
+
+        # The marker QuickJS raises for this codegen bug.
+        ERROR_MARKER = "stack underflow"
+
+        def relevant_error?(error)
+          error.respond_to?(:message) && error.message.to_s.include?(ERROR_MARKER)
+        end
+
+        # Rewrite every `for...of` whose iterable contains a `yield`, hoisting the
+        # iterable into a preceding `var`. Returns the source unchanged when there
+        # is nothing to do.
+        def fix_for_of_yield(source)
+          return source unless source.include?("yield")
+
+          # Scan at the BYTE level (binary encoding): on a multibyte (UTF-8) source
+          # — note's bundle has Japanese strings — Ruby's character indexing is
+          # O(index), making a char-by-char pass O(n^2). All tokens we look for are
+          # ASCII, and UTF-8 continuation bytes (>= 0x80) never collide with them,
+          # so byte scanning is both safe and O(1) per position.
+          Rewriter.new(source.b).run.force_encoding(source.encoding)
+        end
+
+        IDENT = /[A-Za-z0-9_$]/.freeze
+
+        def ident_char?(ch)
+          !ch.nil? && IDENT.match?(ch)
+        end
+
+        # A `/` begins a regex (not division) unless the previous significant code
+        # char can end an expression (ident / `)` / `]` / a literal).
+        def regex_allowed?(prev_sig)
+          return true if prev_sig.nil?
+          return false if ident_char?(prev_sig)
+
+          !")]'\"`".include?(prev_sig)
+        end
+
+        # If `src[i]` begins a string, template, regex literal, or comment, return
+        # the index just after it; otherwise nil. `prev_sig` (previous significant
+        # code char) disambiguates a regex `/` from division.
+        def atom_end(src, i, prev_sig)
+          case src[i]
+          when "/"
+            if src[i + 1] == "/"
+              src.index("\n", i) || src.length
+            elsif src[i + 1] == "*"
+              (idx = src.index("*/", i + 2)) ? idx + 2 : src.length
+            elsif regex_allowed?(prev_sig)
+              scan_regex(src, i)
+            end
+          when "'", '"'
+            scan_quote(src, i, src[i])
+          when "`"
+            scan_template(src, i)
+          end
+        end
+
+        def scan_quote(src, i, quote)
+          j = i + 1
+          n = src.length
+          while j < n
+            c = src[j]
+            return j + 1 if c == quote
+
+            j += c == "\\" ? 2 : 1
+          end
+          n
+        end
+
+        def scan_template(src, i)
+          j = i + 1
+          n = src.length
+          while j < n
+            c = src[j]
+            return j + 1 if c == "`"
+            if c == "\\"
+              j += 2
+              next
+            end
+            if c == "$" && src[j + 1] == "{"
+              close = match_bracket(src, j + 1)
+              return n unless close
+
+              j = close + 1
+              next
+            end
+            j += 1
+          end
+          n
+        end
+
+        # End of a regex literal at `i` (past its flags), or nil if it isn't one
+        # (an unescaped newline before the closing `/` → it was division).
+        def scan_regex(src, i)
+          j = i + 1
+          n = src.length
+          in_class = false
+          while j < n
+            c = src[j]
+            case c
+            when "\\" then j += 2; next
+            when "[" then in_class = true
+            when "]" then in_class = false
+            when "/"
+              unless in_class
+                j += 1
+                j += 1 while j < n && src[j] =~ /[a-z]/i
+                return j
+              end
+            when "\n"
+              return nil
+            end
+            j += 1
+          end
+          nil
+        end
+
+        # Index of the close bracket matching the (/[/{ at `open`, skipping nested
+        # brackets, strings, templates, regexes and comments. `limit` bounds the
+        # scan (a for-head is short; bounding keeps the whole pass linear and
+        # avoids a runaway scan when a mis-lexed token unbalances brackets).
+        def match_bracket(src, open, limit: nil)
+          pairs = {"(" => ")", "[" => "]", "{" => "}"}
+          want = [pairs[src[open]]]
+          i = open + 1
+          n = src.length
+          n = [n, open + limit].min if limit
+          prev = src[open]
+          while i < n
+            stop = atom_end(src, i, prev)
+            if stop
+              prev = src[stop - 1]
+              i = stop
+              next
+            end
+            c = src[i]
+            if pairs.key?(c)
+              want << pairs[c]
+            elsif ")]}".include?(c)
+              return i if want.size == 1 && want.last == c
+
+              want.pop if want.last == c
+            end
+            prev = c unless c =~ /\s/
+            i += 1
+          end
+          nil
+        end
+
+        # Position of the for-of `of` keyword at the top level of a for-head, or nil
+        # for a for-in / C-style for (a top-level `;` rules out for-of).
+        def top_level_of(head)
+          depth = 0
+          i = 0
+          n = head.length
+          prev = nil
+          while i < n
+            stop = atom_end(head, i, prev)
+            if stop
+              prev = head[stop - 1]
+              i = stop
+              next
+            end
+            c = head[i]
+            case c
+            when "(", "[", "{" then depth += 1
+            when ")", "]", "}" then depth -= 1
+            when ";" then return nil if depth.zero?
+            when "o"
+              if depth.zero? && head[i, 2] == "of" &&
+                 !ident_char?(i.zero? ? nil : head[i - 1]) && !ident_char?(head[i + 2])
+                return i
+              end
+            end
+            prev = c unless c =~ /\s/
+            i += 1
+          end
+          nil
+        end
+
+        def contains_yield?(expr)
+          i = 0
+          n = expr.length
+          prev = nil
+          while i < n
+            stop = atom_end(expr, i, prev)
+            if stop
+              prev = expr[stop - 1]
+              i = stop
+              next
+            end
+            if expr[i] == "y" && expr[i, 5] == "yield" &&
+               !ident_char?(i.zero? ? nil : expr[i - 1]) && !ident_char?(expr[i + 5])
+              return true
+            end
+            prev = expr[i] unless expr[i] =~ /\s/
+            i += 1
+          end
+          false
+        end
+
+        # Walks source once, copying literals/comments verbatim and rewriting a
+        # for-of-with-yield-in-iterable found at a statement boundary.
+        class Rewriter
+          # Upper bound on a `for (...)` head length we will consider (well above
+          # any real for-of header, including a large iterable expression).
+          HEAD_SCAN_LIMIT = 64 * 1024
+
+          def initialize(src)
+            @src = src
+            @n = src.length
+          end
+
+          def run
+            out = +""
+            i = 0
+            prev = nil  # previous significant code char
+            counter = 0
+            while i < @n
+              stop = SourceGuard.atom_end(@src, i, prev)
+              if stop
+                out << @src[i...stop]
+                prev = @src[stop - 1]
+                i = stop
+                next
+              end
+
+              ch = @src[i]
+              if ch == "f" && @src[i, 3] == "for" &&
+                 !SourceGuard.ident_char?(i.zero? ? nil : @src[i - 1]) &&
+                 !SourceGuard.ident_char?(@src[i + 3]) &&
+                 boundary?(prev)
+                rewrite = transform_for(i, counter)
+                if rewrite
+                  out << rewrite[:text]
+                  i = rewrite[:next]
+                  counter += 1
+                  prev = ")"
+                  next
+                end
+              end
+
+              out << ch
+              prev = ch unless ch =~ /\s/
+              i += 1
+            end
+            out
+          end
+
+          private
+
+          # A `var t = …;` may be inserted before `for` only at a statement
+          # boundary; otherwise (e.g. `if (c) for (…)`) it would change meaning.
+          def boundary?(prev_sig)
+            prev_sig.nil? || ";{}".include?(prev_sig)
+          end
+
+          def transform_for(for_idx, counter)
+            open = for_idx + 3
+            open += 1 while open < @n && @src[open] =~ /\s/
+            return nil unless @src[open] == "("
+
+            # A for-head is short; cap the scan so an unbalanced (mis-lexed) head
+            # can't turn the per-`for` work into an O(n) scan.
+            close = SourceGuard.match_bracket(@src, open, limit: HEAD_SCAN_LIMIT)
+            return nil unless close
+
+            head = @src[(open + 1)...close]
+            of_at = SourceGuard.top_level_of(head)
+            return nil unless of_at
+
+            decl = head[0...of_at]
+            iterable = head[(of_at + 2)..].to_s
+            return nil unless SourceGuard.contains_yield?(iterable)
+
+            tmp = "__dommyForOf#{counter}"
+            {text: "var #{tmp}=(#{iterable});for(#{decl}of #{tmp})", next: close + 1}
+          end
+        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.9.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
@@ -107,7 +107,7 @@ module Dommy
         # #on_invoke dispatcher can pack the values it hands back into JS.
         def pack(value)
           case value
-          when JSValue then {"__rb_js_ref" => value.ref}
+          when JSValue then {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 +122,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?(WireTags::JS_REF)
+              JSValue.new(value[WireTags::JS_REF])
+            elsif value.key?(WireTags::UNDEFINED)
               nil
-            elsif value.key?("__rb_bytes")
-              value["__rb_bytes"]
-            elsif value.key?("__rb_arraybuffer")
-              value["__rb_arraybuffer"]
+            elsif value.key?(WireTags::BYTES)
+              value[WireTags::BYTES]
+            elsif value.key?(WireTags::ARRAY_BUFFER)
+              value[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,18 @@ 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 +
+# WireTags / 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/backend"
 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) }

data/script/build_jsx_transform.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Regenerate test/fixtures/jsx-transform.umd.js — a minimal JSX→JS transpiler
+# (sucrase) bundled into a single IIFE that exposes `globalThis.transformJSX`.
+#
+# Sucrase is a tiny, JSX/TS-focused alternative to Babel: the bundle is ~200 KB
+# vs @babel/standalone's ~3 MB, since it carries only the JSX transform. At run
+# time the bundle is loaded into the QuickJS VM (pure Ruby + RubyGems — no Node,
+# no native binary); Node/esbuild are only needed here to (re)build it.
+#
+#   script/build_jsx_transform.sh
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+OUT="$ROOT/test/fixtures/jsx-transform.umd.js"
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+
+cd "$TMP"
+npm init -y >/dev/null 2>&1
+npm install sucrase >/dev/null 2>&1
+# `production: true` emits classic React.createElement calls (no dev __source/
+# __self props), which the vendored React UMD build consumes.
+echo "import { transform } from 'sucrase';
+globalThis.transformJSX = (code) => transform(code, { transforms: ['jsx'], production: true }).code;" > entry.js
+
+npx --yes esbuild@0.24.0 entry.js --bundle --format=iife --minify --outfile="$OUT"
+echo "Wrote $OUT ($(wc -c < "$OUT") bytes)"

data/script/build_stimulus_tests.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# Regenerate test/fixtures/stimulus-tests.umd.js — the @hotwired/stimulus QUnit
+# suite bundled into a single IIFE script runnable in the QuickJS VM.
+#
+# Requirements: git, node + npx (esbuild is fetched on demand).
+#
+#   script/build_stimulus_tests.sh [stimulus-git-ref]
+#
+# Stimulus runs its tests under Karma+webpack; we replicate the inputs:
+#   1. Clone the source (its tests live in src/tests, not the npm package).
+#   2. Replace the webpack-only `require.context` entry with an explicit entry
+#      that imports every *_tests.ts module and calls defineModule().
+#   3. Patch TestCase.testPropertyNames to use getOwnPropertyNames instead of
+#      Object.keys — native ES2017 class methods are non-enumerable, whereas
+#      Stimulus's own es5 (tsc) build emits enumerable prototype assignments.
+#      The two are equivalent (own, string-keyed); this just lets the esbuild
+#      ES2017 bundle discover the `test ...` methods.
+#   4. esbuild-bundle to an IIFE that references a global QUnit (the shim in
+#      test/support/qunit_shim.js provides it at run time).
+set -euo pipefail
+
+REF="${1:-v3.2.2}"
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+OUT="$ROOT/test/fixtures/stimulus-tests.umd.js"
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+
+echo "Cloning hotwired/stimulus @ $REF ..."
+git clone --depth 1 --branch "$REF" -q https://github.com/hotwired/stimulus.git "$TMP/stimulus"
+cd "$TMP/stimulus"
+
+# (3) enumerability patch
+ruby -i -pe 'sub(/Object\.keys\(this\.prototype\)/, "Object.getOwnPropertyNames(this.prototype)")' \
+  src/tests/cases/test_case.ts
+
+# (2) explicit entry replacing require.context
+ruby -e '
+mods = Dir.chdir("src/tests") { Dir["modules/**/*_tests.ts"].sort }
+imports = mods.each_with_index.map { |m, i| %(import M#{i} from "./#{m.sub(/\.ts$/, "")}") }
+File.write("src/tests/conformance.entry.ts",
+  imports.join("\n") + "\n" +
+  "const MODULES = [#{mods.size.times.map { |i| "M#{i}" }.join(", ")}]\n" +
+  "MODULES.forEach((c) => c.defineModule())\n")
+puts "entry: #{mods.size} modules"
+'
+
+# (4) bundle
+npx --yes esbuild@0.24.0 src/tests/conformance.entry.ts \
+  --bundle --format=iife --target=es2017 --tsconfig=tsconfig.json \
+  --outfile="$OUT"
+
+echo "Wrote $OUT"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dommy-js-quickjs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.9.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
@@ -27,16 +27,16 @@ dependencies:
   name: dommy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.9.0
 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
@@ -47,25 +47,24 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/test.yml"
 - 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/capybara.rb
+- lib/dommy/js/quickjs/rack.rb
 - lib/dommy/js/quickjs/runtime.rb
+- lib/dommy/js/quickjs/script_cache.rb
+- lib/dommy/js/quickjs/source_guard.rb
 - lib/dommy/js/quickjs/version.rb
 - lib/dommy/js/quickjs/wasm_bridge.rb
+- script/build_jsx_transform.sh
+- script/build_stimulus_tests.sh
 - sig/dommy/js/quickjs.rbs
 homepage: https://github.com/takahashim/dommy-js-quickjs
 licenses:
@@ -89,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: QuickJS backend for running JavaScript against a Dommy DOM.
 test_files: []

data/lib/dommy/js/constructor_registry.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Dommy
-  module Js
-    # Resolves a JS constructor by interface name for reverse construction
-    # (`new Event(...)`, `new DOMException(...)`). The window object is the
-    # source for most constructors — it exposes them via __js_get__ — while a
-    # few not on the window are provided directly. Engine-agnostic.
-    class ConstructorRegistry
-      # The window whose __js_get__ exposes Event/CustomEvent/MouseEvent/… .
-      attr_writer :source
-
-      def initialize
-        @source = nil
-      end
-
-      # An object responding to __js_new__ for `name`, or nil if `name` isn't
-      # constructable (the bridge then makes the JS side throw).
-      def resolve(name)
-        if @source.respond_to?(:__js_get__)
-          ctor = @source.__js_get__(name)
-          return ctor if ctor.respond_to?(:__js_new__)
-        end
-        extra(name)
-      end
-
-      private
-
-      # Constructors the window doesn't expose.
-      def extra(name)
-        case name
-        when "DOMException"
-          return unless defined?(Dommy::DOMException)
-
-          Dommy::Bridge::Constructor.new { |args| Dommy::DOMException.new(args[0], args[1] || "Error") }
-        end
-      end
-    end
-  end
-end

data/lib/dommy/js/custom_elements.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Dommy
-  module Js
-    # Bridges JS-defined custom elements to Dommy's custom element pipeline.
-    # `customElements.define(name, JSClass)` on the JS side calls in here, which
-    # registers a Dommy::HTMLElement subclass for `name` whose lifecycle
-    # reactions (connected/disconnected/adopted/attributeChanged) route back to
-    # the JS instance through the bridge. The JS class's constructor itself runs
-    # on the JS side via the construction-stack upgrade in host_runtime.js.
-    class CustomElements
-      attr_writer :window
-
-      def initialize(bridge)
-        @bridge = bridge
-        @window = nil
-      end
-
-      def define(name, observed)
-        return unless @window.respond_to?(:custom_elements)
-
-        @window.custom_elements.define(name, build_class(name, observed))
-        nil
-      end
-
-      # customElements.upgrade(root): delegate to Dommy's registry so a subtree
-      # attached without firing reactions gets its registered elements upgraded.
-      def upgrade(root)
-        return unless @window.respond_to?(:custom_elements)
-
-        @window.custom_elements.upgrade(root)
-        nil
-      end
-
-      private
-
-      # A Dommy custom element class that forwards each reaction to the JS
-      # instance. `__js_custom_element_name__` marks the node so the bridge tells
-      # the JS side to upgrade it on first crossing (see HostBridge interface info).
-      def build_class(name, observed)
-        bridge = @bridge
-        Class.new(Dommy::HTMLElement) do
-          define_singleton_method(:observed_attributes) { observed }
-          define_method(:__js_custom_element_name__) { name }
-          define_method(:connected_callback) { bridge.invoke_lifecycle(self, "connectedCallback", []) }
-          define_method(:disconnected_callback) { bridge.invoke_lifecycle(self, "disconnectedCallback", []) }
-          define_method(:adopted_callback) { bridge.invoke_lifecycle(self, "adoptedCallback", []) }
-          define_method(:attribute_changed_callback) do |attr, old_value, new_value|
-            bridge.invoke_lifecycle(self, "attributeChangedCallback", [attr, old_value, new_value])
-          end
-        end
-      end
-    end
-  end
-end