homura-runtime 0.2.22 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cff255ad823986df011ec56a290aafb83c08a148aee51a0e5f614f9ca80f2d41
-  data.tar.gz: 9e3cb0a22c2a6c497fea120d38111d9cc299cd43213bfeb7d9f52ff2cd6cda3c
+  metadata.gz: 0e4fc42870cef61572354025f9091524f2b65d91f93910cb3470acd4038472e7
+  data.tar.gz: b8fafbfe977f2bfa1cbaf42f16f0b2849a3f9f3b0f12525eb2f9809497fa38e2
 SHA512:
-  metadata.gz: 1ff4f7099815079d7e3c284b32935c99afb1cabc64a31e0115f69dcda7a72bdb56f9ffb11dee82a2ae37b809112319651fba79d03c7ec7dc7d00210634672641
-  data.tar.gz: 5f2cc557b7c0484d35fbe4bb08dedcc26044b0c537f57b93f68ddd648b5e665ae32613704052f590bc73005d7730954062e091c429c6afb9ded204d6ae268fc8
+  metadata.gz: 3aabb8d2b5678419c57247f834bba6ae02d4de928b154529acf026011cb23c8b08cab01fd95a59b98c74e749b64e86a3f6f4749b6305ab143af54bf5cbc16852
+  data.tar.gz: 8b71e4b7a2a297aa463b5d68734ca8dc6d88adab156d4bbc9b33e20f7caa58b1fd188c9a4a208fcce83c3df9a57aa2eaf5d18673f4d36cd4d962932dd59a0b97

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 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 +42,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

@@ -77,10 +77,13 @@ options[:assets_namespace] ||= CloudflareWorkers::BuildSupport.standalone_namesp
 
 if options[:standalone]
   Dir.chdir(root) { require 'bundler/setup' }
-  options[:setup_import] ||= 'cf-runtime/setup-node-crypto.mjs'
+  # Both .mjs glue files and the entrypoint live under `build/` from
+  # 0.2.23 on. write_entrypoint! resolves these as project-root
+  # relative paths and computes the entrypoint-relative import spec.
+  options[:setup_import] ||= 'build/cf-runtime/setup-node-crypto.mjs'
   options[:bundle_import] ||= options[:opal_output]
-  options[:worker_module_import] ||= 'cf-runtime/worker_module.mjs'
-  options[:entrypoint_out] ||= 'worker.entrypoint.mjs'
+  options[:worker_module_import] ||= 'build/cf-runtime/worker_module.mjs'
+  options[:entrypoint_out] ||= 'build/worker.entrypoint.mjs'
 else
   options[:setup_import] ||= 'gems/homura-runtime/runtime/setup-node-crypto.mjs'
   options[:bundle_import] ||= options[:opal_output]
@@ -272,6 +275,29 @@ else
     warn 'homura build: no app/ directory or top-level app.rb — skipping auto-await'
   end
 
+  # Also run auto-await over any `path:`-resolved gems declared in the
+  # consumer's Gemfile (e.g. `sinatra-inertia`). The transformed copies
+  # are written to `build/auto_await/gem_<basename>/<original-relative>`,
+  # and `standalone_load_paths` puts those directories ahead of the
+  # untransformed gem `lib/` so `require 'sinatra/inertia'` resolves to
+  # the rewritten file.
+  CloudflareWorkers::BuildSupport.path_gemfile_entries(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

@@ -44,7 +44,13 @@ module CloudflareWorkers
       end
 
       def ensure_standalone_runtime(project_root, current_file: __FILE__, loaded_specs: Gem.loaded_specs)
-        target_dir = Pathname(project_root).join('cf-runtime')
+        # The homura runtime needs two .mjs glue files alongside the
+        # generated `worker.entrypoint.mjs`. Until 0.2.22 we wrote them
+        # to `cf-runtime/` at the project root, which made every Ruby
+        # repo carry two opaque JS files in source control. Hide them
+        # under `build/cf-runtime/` so the build artifact tree owns
+        # them — `build/` is already in the example .gitignore template.
+        target_dir = Pathname(project_root).join('build', 'cf-runtime')
         FileUtils.mkdir_p(target_dir)
 
         %w[setup-node-crypto.mjs worker_module.mjs].each do |name|
@@ -80,6 +86,27 @@ module CloudflareWorkers
           end
         end
 
+        # Pick up any other `path:`-resolved gems declared in the consumer's
+        # Gemfile (e.g. `sinatra-inertia`). This keeps the build pipeline
+        # extensible: users can drop a pure-Ruby gem under `gems/foo`, list
+        # it as `gem 'foo', path: '../../gems/foo'`, and Opal will find its
+        # `lib/` automatically — no homura-runtime change required.
+        #
+        # We prefer the auto-await-transformed copy under
+        # `build/auto_await/gem_<basename>/lib` if present (homura-build
+        # writes one for every path: gem before invoking Opal), so that
+        # async chains inside the gem get `__await__` inserted just like
+        # consumer app code.
+        path_gemfile_entries(root).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
@@ -105,6 +132,53 @@ module CloudflareWorkers
         vend = runtime_path.join('..', '..', 'vendor').expand_path
         vend if vend.directory?
       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.22'
+  VERSION = '0.2.24'
 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.22
+  version: 0.2.24
 platform: ruby
 authors:
 - Kazuhiro Homma