homura-runtime 0.2.23 → 0.2.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b404ba5cef20ed67d0b7f882c21a4f22b49bb0594e3175cec2137498764bafe9
-  data.tar.gz: 99dd3e6a2849a57d146c8d8f46b7cd01f805dc1712b858445c06bf5761dcb18a
+  metadata.gz: aa815fa7e02b0f798dd69003008576f264eb3a0e2532805a729fee6f4a5aca6b
+  data.tar.gz: e8af4871e543adc2ef6c6d8751272111c102987345ea6526ad1fa0e6e2192db8
 SHA512:
-  metadata.gz: 97e9d3a324ffe6545b080ce483c1b4446ed14937d3cc70dcf6852e793002d9a246fc9a9ef557b687a42f9cf5903bb85ee2faf6a80fef42f0ca22d7661d9a7074
-  data.tar.gz: 7b930885e9bad1526363d9b9f5c2940ba71a8f9f65f073352d17c4e679b8039a9f25e3d44653df723ef9204fd90ad17c9db7e15789ec0050d747f8892ca05b17
+  metadata.gz: c6f04b2b77f82131dd45148ff7d8467e0093ed005f49269ab2a2a37ab96ad957e6abd264c302331d37a4a95ac84885d9eef3882e51422fec7f6ed2f30aca25b1
+  data.tar.gz: ff80cbfcbc5b699eed8c7f79c1da2b40aab678163185b0471ec269c7fe55db06d14515aaa22ece20bbff019ff754bc38d398c3a812ea33a2df3716fbea395716

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.2.25 (2026-04-29)
+
+- `BuildSupport`: factor `opal_gem_paths` out of the path:-only
+  `path_gemfile_entries`. The new method also picks up
+  RubyGems-installed gems that opt in via
+  `spec.metadata['homura.auto_await'] = 'true'`. Without this, a
+  RubyGems-installed pure-Ruby gem (e.g. `sinatra-inertia >= 0.1.1`)
+  was missing from both the Opal load path and the auto-await pass,
+  so `require 'sinatra/inertia'` failed during `homura build`.
+- `homura-build` iterates `opal_gem_paths` instead of the old
+  path:-only list, so any opted-in gem (path: or RubyGems) gets the
+  same auto-await rewrite.
+
+## 0.2.24 (2026-04-29)
+
+- `BuildSupport.standalone_load_paths`: auto-discover `path:`-resolved
+  gems in the consumer Gemfile (skipping `require: false` and
+  `group :development/:test/:ci/...` blocks) and add their `lib/` and
+  `vendor/` to the Opal load path. Lets pure-Ruby gems like
+  `sinatra-inertia` drop into a project without runtime-side wiring.
+- `homura-build` now runs the `auto-await` analyzer over each `path:`
+  gem's `lib/` and writes the rewritten copy under
+  `build/auto_await/gem_<basename>/lib`. The transformed directory
+  is preferred over the gem's untransformed `lib/` on the load path,
+  so async chains inside gem code (e.g. `db[:foo].all` returning a
+  Promise) get `__await__` injected exactly like consumer app code.
+- `cloudflare_workers.rb#build_js_response`: emit `Set-Cookie`
+  Arrays via `Headers#append` (multiple lines) instead of stringifying
+  the Array via `to_s`. Previously, two cookies set by sequential Rack
+  middleware (e.g. session + auth) were serialised as
+  `'["a=…", "b=…"]'`, which broke cookie parsing on every Inertia /
+  CSRF / auth-cookie pattern.
+
 ## 0.2.17 (2026-04-27)
 
 - Rewrite class-variable references (`@@foo`) inside precompiled ERB
@@ -22,7 +55,7 @@
 
 ## 0.2.10 (2026-04-24)
 
-- Derive `worker.entrypoint.mjs` import paths relative to the actual
+- Derive `build/worker.entrypoint.mjs` import paths relative to the actual
   `--entrypoint-out` location, so standalone builds keep working when apps move
   the bundle and entrypoint under custom output directories.
 

data/README.md

@@ -9,14 +9,14 @@ Core Ruby + Module Worker glue for [Opal](https://opalrb.com/) on [Cloudflare Wo
 - `runtime/worker_module.mjs` — fetch / scheduled / queue / DO adapters (**no Opal bundle import**).
 - `runtime/worker.mjs` — thin bootstrap (crypto shim → bundle → `worker_module`) for legacy layouts.
 - `runtime/setup-node-crypto.mjs` — `node:crypto` on `globalThis` before the Opal bundle loads.
-- `homura build` — single build pipeline (ERB → assets → Opal → patch → `worker.entrypoint.mjs`). Use `--standalone` in generated apps; it restores `cf-runtime/` automatically, derives standalone template/asset namespaces from the project name, and computes entrypoint import paths relative to the actual `--entrypoint-out` location.
+- `homura build` — single build pipeline (ERB → assets → Opal → patch → `build/worker.entrypoint.mjs`). Use `--standalone` in generated apps; it restores `cf-runtime/` automatically, derives standalone template/asset namespaces from the project name, and computes entrypoint import paths relative to the actual `--entrypoint-out` location.
 - `docs/ARCHITECTURE.md` — wrangler `main`, codegen entrypoint, and fixed-import policy.
 
 ## Quick start (homura monorepo)
 
 1. `Gemfile`: `gem 'homura-runtime', path: 'gems/homura-runtime'` and `gem 'opal-homura', '= 1.8.3.rc1.3', require: 'opal'` (path or exact pin).
-2. `bundle exec homura build` — in generated standalone apps, writes `build/hello.no-exit.mjs` plus root-level `worker.entrypoint.mjs`; in the monorepo it writes `build/worker.entrypoint.mjs`.
-3. `wrangler.toml`: generated apps use `main = "worker.entrypoint.mjs"` and `compatibility_flags = ["nodejs_compat"]`.
+2. `bundle exec homura build` — in generated standalone apps, writes `build/hello.no-exit.mjs` plus root-level `build/worker.entrypoint.mjs`; in the monorepo it writes `build/worker.entrypoint.mjs`.
+3. `wrangler.toml`: generated apps use `main = "build/worker.entrypoint.mjs"` and `compatibility_flags = ["nodejs_compat"]`.
 
 ## Support matrix (indicative)
 

data/docs/ARCHITECTURE.md

@@ -5,7 +5,7 @@
 | レイヤ | 役割 |
 |--------|------|
 | `wrangler.toml` の `main` | **Workers Module のエントリ**（`fetch` / `scheduled` / `queue` / DO クラスを export） |
-| `worker.entrypoint.mjs`（生成物） | `setup-node-crypto` → **Opal bundle（副作用）** → `worker_module.mjs` の順で import。import path は entrypoint 出力位置からの **相対パス** に自動調整される |
+| `build/worker.entrypoint.mjs`（生成物） | `setup-node-crypto` → **Opal bundle（副作用）** → `worker_module.mjs` の順で import。import path は entrypoint 出力位置からの **相対パス** に自動調整される |
 | Opal bundle（例: `build/hello.no-exit.mjs`） | **ビルド成果物**。Rack ディスパッチャ等を `globalThis` に登録 |
 | `worker_module.mjs`（gem 同梱） | Rack / Cron / Queue / DO への **純粋な JS アダプタ**（Opal bundle を import しない） |
 
@@ -21,7 +21,7 @@ flowchart LR
     W1[worker.mjs] -->|hard-coded| B1[../../../build/hello.mjs]
   end
   subgraph after["After (Phase 15-E)"]
-    E[worker.entrypoint.mjs] --> S[setup-node-crypto.mjs]
+    E[build/worker.entrypoint.mjs] --> S[setup-node-crypto.mjs]
     E --> O[build/*.mjs Opal bundle]
     E --> M[worker_module.mjs]
   end
@@ -34,7 +34,7 @@ flowchart LR
 
 ## スキャフォールド済みアプリ
 
-- プロジェクト直下に `worker.entrypoint.mjs`（`main` と一致）。
+- プロジェクト直下に `build/worker.entrypoint.mjs`（`main` と一致）。
 - `cf-runtime/` に `setup-node-crypto.mjs` と `worker_module.mjs` をコピー（gem から）。
 - `bundle exec homura build --standalone` が consumer 向けパイプラインを実行し、`Gemfile` の `path:` から homura の `vendor/` を追加ロードパスへ取り込み（digest / zlib 等の Workers 向け補助ファイル）。
 - low-level `--output` / `--entrypoint-out` を変えても、entrypoint 内 import は出力先からの相対パスに自動調整される。

data/exe/homura-build

@@ -275,6 +275,30 @@ else
     warn 'homura build: no app/ directory or top-level app.rb — skipping auto-await'
   end
 
+  # Also run auto-await over every gem we ship to Opal:
+  # `path:`-resolved gems in the consumer Gemfile *and* RubyGems-
+  # installed gems that opt in via
+  # `spec.metadata['homura.auto_await'] = 'true'`. Both go to
+  # `build/auto_await/gem_<basename>/<sub>` and
+  # `standalone_load_paths` puts those rewritten copies ahead of the
+  # gem's untransformed `lib/`.
+  CloudflareWorkers::BuildSupport.opal_gem_paths(root).each do |gem_path|
+    %w[lib].each do |sub|
+      src = gem_path.join(sub)
+      next unless src.directory?
+      out = root.join('build', 'auto_await', "gem_#{gem_path.basename}", sub)
+      FileUtils.mkdir_p(out)
+      run!(
+        [
+          'ruby', CloudflareWorkersBuild.exe_path('auto-await').to_s,
+          '--input', src.to_s,
+          '--output', out.to_s
+        ],
+        chdir: root
+      )
+    end
+  end
+
   opal_in = Pathname(resolve_opal_input(root, options[:opal_input]))
   opal_out = Pathname(options[:opal_output])
   opal_in = root.join(opal_in) unless opal_in.absolute?

data/lib/cloudflare_workers/build_support.rb

@@ -86,6 +86,28 @@ module CloudflareWorkers
           end
         end
 
+        # Pick up any other gems that should ship in the Workers bundle:
+        #
+        #   * `path:`-resolved gems in the consumer's Gemfile (monorepo
+        #     dev mode), and
+        #   * RubyGems-installed gems that opt in via
+        #     `spec.metadata['homura.auto_await'] = 'true'`.
+        #
+        # Both go through the same auto-await pass during `homura-build`,
+        # and we prefer the rewritten copy under
+        # `build/auto_await/gem_<basename>/lib` if present so async chains
+        # inside gem code get `__await__` inserted just like consumer
+        # app code.
+        opal_gem_paths(root, loaded_specs: loaded_specs).each do |gem_path|
+          basename = gem_path.basename.to_s
+          rewritten_lib = root.join('build', 'auto_await', "gem_#{basename}", 'lib')
+          load_paths << rewritten_lib.to_s if rewritten_lib.directory?
+          %w[lib vendor].each do |sub|
+            dir = gem_path.join(sub)
+            load_paths << dir.to_s if dir.directory?
+          end
+        end
+
         load_paths << 'vendor' if root.join('vendor').directory?
         load_paths << 'build'
         load_paths.uniq
@@ -111,6 +133,78 @@ module CloudflareWorkers
         vend = runtime_path.join('..', '..', 'vendor').expand_path
         vend if vend.directory?
       end
+
+      # Returns the union of `path_gemfile_entries(project_root)` and any
+      # bundled gems that opt in to the Opal pipeline via
+      # `spec.metadata['homura.auto_await']`. This is the single source
+      # of truth for both `standalone_load_paths` and the auto-await pass
+      # that `homura-build` runs. Returns `Pathname` objects pointing at
+      # each gem's root directory.
+      def opal_gem_paths(project_root, loaded_specs: Gem.loaded_specs)
+        wired = [RUNTIME_GEM_NAME, SINATRA_GEM_NAME, SEQUEL_D1_GEM_NAME]
+        out = []
+        out.concat(path_gemfile_entries(project_root))
+
+        loaded_specs.each_value do |spec|
+          next if wired.include?(spec.name)
+          meta = spec.metadata
+          next unless meta.is_a?(Hash)
+          flag = meta['homura.auto_await']
+          next unless flag == 'true' || flag == true
+          next if spec.full_gem_path.nil?
+          gem_path = Pathname(spec.full_gem_path)
+          out << gem_path if gem_path.directory?
+        end
+
+        out.uniq
+      end
+
+      # Returns absolute Pathnames for every `path:`-declared gem in the
+      # project's Gemfile that should ship in the Workers bundle.
+      #
+      # Excludes:
+      # * gems we already wire in explicitly
+      #   (homura-runtime / sinatra-homura / sequel-d1)
+      # * `require: false` gems (dev tooling like `gem 'rspec', path: ..., require: false`)
+      # * gems declared inside `group :development do … end` /
+      #   `group :test do … end` blocks (they don't ship to production)
+      EXCLUDED_GROUPS = %i[development test dev_test development_test ci tools].freeze
+
+      def path_gemfile_entries(project_root)
+        gf = Pathname(project_root).join('Gemfile')
+        return [] unless gf.file?
+
+        wired = [RUNTIME_GEM_NAME, SINATRA_GEM_NAME, SEQUEL_D1_GEM_NAME]
+        out = []
+        group_stack = []
+
+        gf.read.each_line do |line|
+          stripped = line.strip
+          next if stripped.empty? || stripped.start_with?('#')
+
+          if (m = stripped.match(/\Agroup\s+(.+?)\s+do\b/))
+            groups = m[1].scan(/[:'"]([A-Za-z0-9_]+)['"]?/).flatten.map(&:to_sym)
+            group_stack.push(groups)
+            next
+          end
+          if stripped == 'end'
+            group_stack.pop unless group_stack.empty?
+            next
+          end
+
+          next if group_stack.flatten.any? { |g| EXCLUDED_GROUPS.include?(g) }
+
+          m = line.match(/gem\s+['"]([^'"]+)['"][^#]*?path:\s*['"]([^'"]+)['"]/)
+          next unless m
+          name, rel = m[1], m[2]
+          next if wired.include?(name)
+          next if line.match?(/require:\s*false/)
+
+          gem_path = Pathname.new(rel).expand_path(project_root)
+          out << gem_path if gem_path.directory?
+        end
+        out.uniq
+      end
     end
   end
 end

data/lib/cloudflare_workers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloudflareWorkers
-  VERSION = '0.2.23'
+  VERSION = '0.2.25'
 end

data/lib/cloudflare_workers.rb

@@ -376,13 +376,54 @@ module Rack
             chunks << body
           end
 
+          # Build JS-side headers. Set-Cookie is the one HTTP response
+          # header that legitimately repeats — Rack 3 surfaces it as an
+          # Array of cookie strings (e.g. session middleware + auth
+          # middleware both setting cookies). Plain `vs = v.to_s` would
+          # collapse that Array into its `inspect` form and break cookie
+          # parsing on the client. We use a `__multi__` sentinel here
+          # and let `Cloudflare.headers_to_js` (the SSE/streaming code
+          # path also uses it) emit each entry as a separate header line
+          # via Headers#append.
           js_headers = `({})`
           headers.each do |k, v|
             ks = k.to_s
-            vs = v.to_s
-            `#{js_headers}[#{ks}] = #{vs}`
+            if v.is_a?(Array)
+              arr = `[]`
+              v.each { |vi| `#{arr}.push(#{vi.to_s})` }
+              `#{js_headers}[#{ks}] = { __multi__: true, values: #{arr} }`
+            else
+              vs = v.to_s
+              `#{js_headers}[#{ks}] = #{vs}`
+            end
           end
 
+          # Convert any `{ __multi__: true, values: [...] }` markers into
+          # a real `Headers` object that Workers' `new Response(headers:)`
+          # accepts. Single-valued headers stay as plain string values.
+          js_headers = `(function(h) {
+            var hasMulti = false;
+            for (var key in h) {
+              if (h[key] && typeof h[key] === 'object' && h[key].__multi__ === true) {
+                hasMulti = true;
+                break;
+              }
+            }
+            if (!hasMulti) return h;
+            var realHeaders = new Headers();
+            for (var key in h) {
+              var val = h[key];
+              if (val && typeof val === 'object' && val.__multi__ === true) {
+                for (var j = 0; j < val.values.length; j++) {
+                  realHeaders.append(key, val.values[j]);
+                }
+              } else {
+                realHeaders.set(key, val);
+              }
+            }
+            return realHeaders;
+          })(#{js_headers})`
+
           status_int = status.to_i
 
           js_chunks = `[]`

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: homura-runtime
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.2.25
 platform: ruby
 authors:
 - Kazuhiro Homma