homura-runtime 0.2.24 → 0.2.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e4fc42870cef61572354025f9091524f2b65d91f93910cb3470acd4038472e7
-  data.tar.gz: b8fafbfe977f2bfa1cbaf42f16f0b2849a3f9f3b0f12525eb2f9809497fa38e2
+  metadata.gz: 961609130fd819224d263b877755bd615b98c27ec2677bb3842aaeeed13a131b
+  data.tar.gz: 4412446fe4defcfb5e65cbafc19f53c2bbdb7461a5e835a2a7fa7a09bf6da38e
 SHA512:
-  metadata.gz: 3aabb8d2b5678419c57247f834bba6ae02d4de928b154529acf026011cb23c8b08cab01fd95a59b98c74e749b64e86a3f6f4749b6305ab143af54bf5cbc16852
-  data.tar.gz: 8b71e4b7a2a297aa463b5d68734ca8dc6d88adab156d4bbc9b33e20f7caa58b1fd188c9a4a208fcce83c3df9a57aa2eaf5d18673f4d36cd4d962932dd59a0b97
+  metadata.gz: 36b7a90afec547e760a751bf2dcfe1a3ef5a9718d64f31d00d740f9715291a5ce869c9845d3fe7d8b5aa6f99f9787254d77d4197a20fc0095106dcc6bc6959a1
+  data.tar.gz: fa08804d6bfcc39032f75889de9066105c46ceccecb7c91a9b2126bffe8db05af8ccf3dfaf02d6da9795cae82dbc987a55a61e86cf676a1aff8a06a3de342ef8

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.2.26 (2026-04-29)
+
+- `Rack::Handler::CloudflareWorkers#call`: when `@app` is nil, fall
+  back to `Sinatra::CloudflareWorkers.ensure_rack_app!` to discover
+  the Sinatra app lazily on the first fetch. This is what lets
+  classic-style apps omit the trailing `run Sinatra::Application`
+  line (paired with `sinatra-homura >= 0.2.23`).
+- New `Rack::Handler::CloudflareWorkers.ensure_dispatcher_installed!`:
+  eagerly registers the JS-side dispatcher (`globalThis.__HOMURA_RACK_DISPATCH__`)
+  at script-load time, so a fetch arriving before `run` was called
+  still routes into our `call` method (where the lazy app discovery
+  above kicks in). On Workers `at_exit` is unreliable because the
+  isolate doesn't exit between requests; this eager install is the
+  reliable hook.
+
+## 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

data/exe/homura-build

@@ -275,13 +275,14 @@ 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|
+  # 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?

data/lib/cloudflare_workers/build_support.rb

@@ -86,18 +86,19 @@ 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.
+        # Pick up any other gems that should ship in the Workers bundle:
         #
-        # 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|
+        #   * `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?
@@ -133,6 +134,31 @@ module CloudflareWorkers
         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.
       #

data/lib/cloudflare_workers/version.rb

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

data/lib/cloudflare_workers.rb

@@ -134,6 +134,34 @@ module Rack
         @app
       end
 
+      def self.app=(app)
+        @app = app
+      end
+
+      # Eagerly install the JS-side dispatcher so a fetch arriving
+      # before `run` was called (e.g. classic-style apps that omit the
+      # trailing `run Sinatra::Application`) still gets routed into our
+      # `call` method, which can then discover the user's Sinatra app
+      # lazily via `Sinatra::CloudflareWorkers.ensure_rack_app!`. This
+      # is what makes the canonical sinatrarb.com snippet work
+      # verbatim on Workers — `at_exit` is unreliable here because the
+      # isolate never actually exits between fetches.
+      def self.ensure_dispatcher_installed!
+        return true if @dispatcher_installed
+        handler = self
+        `
+          globalThis.__HOMURA_RACK_DISPATCH__ = async function(req, env, ctx, body_text) {
+            return await #{handler}.$call(req, env, ctx, body_text == null ? "" : body_text);
+          };
+          (function () {
+            var g = globalThis;
+            g.__OPAL_WORKERS__ = g.__OPAL_WORKERS__ || {};
+            g.__OPAL_WORKERS__.rack = g.__HOMURA_RACK_DISPATCH__;
+          })();
+        `
+        @dispatcher_installed = true
+      end
+
       # Entry point invoked from the Module Worker (src/worker.mjs) for
       # every fetch event. `js_req` is a Cloudflare Workers Request,
       # `js_env` is the bindings object (D1, KV, R2, secrets...),
@@ -141,7 +169,13 @@ module Rack
       # request body (the worker.mjs front awaits req.text() before
       # handing control to Ruby because Opal runs synchronously).
       def self.call(js_req, js_env, js_ctx, body_text = '')
-        raise '`run app` was never called from user code' if @app.nil?
+        if @app.nil?
+          if defined?(::Sinatra::CloudflareWorkers) &&
+             ::Sinatra::CloudflareWorkers.respond_to?(:ensure_rack_app!)
+            ::Sinatra::CloudflareWorkers.ensure_rack_app!
+          end
+          raise '`run app` was never called from user code, and no Sinatra app was discoverable (define `class App < Sinatra::Base` or use top-level classic Sinatra routes)' if @app.nil?
+        end
 
         env = build_rack_env(js_req, js_env, js_ctx, body_text)
         result = @app.call(env)

metadata

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