ruby_everywhere 0.2.0 → 0.4.0

data/lib/everywhere/log_filter.rb

@@ -30,6 +30,7 @@ module Everywhere
       when :notarize   then notarize(line)
       when :tebako     then tebako(line)
       when :xcodebuild then xcodebuild(line)
+      when :gradle     then gradle(line)
       end
     end
 
@@ -153,6 +154,79 @@ module Everywhere
       end
     end
 
+    # --- gradle (Android shell) -----------------------------------------------
+    #
+    # Gradle is the quiet one: a cold build is ~120 lines, ~83 of them
+    # "> Task :app:…". So this filter isn't fighting volume like the two above —
+    # it exists because of two specific noises that make a healthy build look
+    # broken. Gradle 9 ends every build with a four-line "incompatible with
+    # Gradle 10" deprecation banner earned by the Android Gradle Plugin, not by
+    # anything the user wrote; and hotwire-native-android 1.3.0 compiled with
+    # Kotlin 2.3.0 emits exactly 7 `w:` warnings from navigation-fragments
+    # (deprecated overrides, getParcelableArrayList, KT-73255) that no app can
+    # act on. Both are suppressed here and both stay in the on-disk log.
+    #
+    # The line that decides a warning's fate is its path: app-authored Kotlin is
+    # stamped into extensions/, and that's the only code the user can fix.
+    MILESTONES = {
+      /:process\w*Manifest\b/ => "merging manifests",
+      /:merge\w*Resources\b/ => "merging resources",
+      /:merge\w*Assets\b/ => "bundling assets",
+      /:compile\w*Kotlin\b/ => "compiling Kotlin",
+      /:compile\w*JavaWithJavac\b/ => "compiling Java",
+      /:package\w+\b/ => "packaging APK"
+    }.freeze
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def gradle(line)
+      short = UI.short_path(line)
+      case line
+      # Kotlin/javac/AAPT failures, and Gradle's own failure block.
+      when /\Ae: /, /\berror:/i, /\AFAILURE: /, /\A\* What went wrong:/, /\ABUILD FAILED/
+        "    #{UI.red(short)}"
+      when /\Aw: /
+        return "    #{UI.yellow(short)}" if line.include?("/extensions/")
+
+        once(:shell_warning) { UI.note_line("Kotlin warnings from the shell template — see the full log") }
+      when /\ABUILD SUCCESSFUL(?: in (.+))?/
+        UI.note_line("build succeeded#{Regexp.last_match(1) && " (#{Regexp.last_match(1)})"}",
+                     marker: "✓", color: :green)
+      when /\A\d+ actionable tasks?:/
+        UI.note_line(line)
+
+      # First-run downloads are the whole reason a cold build takes minutes.
+      when /\ADownloading https:\/\/services\.gradle\.org/
+        once(:gradle_dist) { UI.note_line("downloading Gradle (first run only)") }
+      when /\AStarting a Gradle Daemon/
+        once(:daemon) { UI.note_line("starting the Gradle daemon") }
+
+      # ~83 task lines. Milestones once each; the rest, including everything
+      # already up to date, is background.
+      when /\A> Task (\S+)/
+        task = Regexp.last_match(1)
+        return :drop if line.match?(/(UP-TO-DATE|FROM-CACHE|NO-SOURCE|SKIPPED)\s*\z/)
+
+        label = MILESTONES.find { |pattern, _| task.match?(pattern) }&.last or return :drop
+
+        once("task-#{label}") { UI.note_line(label) }
+
+      # Gradle 9's deprecation banner and its follow-on lines, the incubating
+      # problems report, the daemon's welcome, and any progress redraw that
+      # survives --console=plain.
+      when /Deprecated Gradle features were used in this build/,
+           /--warning-mode all/,
+           /\AFor more information[, ].*docs\.gradle\.org/,
+           /\A\[Incubating\] Problems report/,
+           /\AWelcome to Gradle /,
+           /\A<[=\-]+>/,
+           /\A> (Configure|Starting|Loading|Calculating|IDLE)/
+        :drop
+      else
+        nil # unrecognized -> caller shows it dimmed
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
     # Show a line only the first time its key is seen; :drop the repeats. Keeps a
     # long notarization from scrolling a wall of identical "waiting" lines (and
     # notarytool's thrice-echoed submission id from showing three times).

data/lib/everywhere/mobile_config_endpoint.rb

@@ -23,6 +23,8 @@ module Everywhere
   class MobileConfigEndpoint
     PATH = %r{\A/everywhere/(ios|android)_v1\.json\z}
     RESET = "/everywhere/reset"
+    AASA = "/.well-known/apple-app-site-association"
+    ASSETLINKS = "/.well-known/assetlinks.json"
 
     def initialize(app, root: Dir.pwd)
       @app = app
@@ -38,6 +40,17 @@ module Everywhere
         return html(Everywhere.mobile_reset_html(to))
       end
 
+      # Deep-linking association files (generated from everywhere.yml). Pass
+      # through when not configured so the host app can serve its own.
+      if env["PATH_INFO"] == AASA
+        body = Config.load(@root).apple_app_site_association_json
+        return body ? json(body) : @app.call(env)
+      end
+      if env["PATH_INFO"] == ASSETLINKS
+        body = Config.load(@root).asset_links_json
+        return body ? json(body) : @app.call(env)
+      end
+
       match = PATH.match(env["PATH_INFO"]) or return @app.call(env)
 
       os = match[1]

data/lib/everywhere/mobile_configs_controller.rb

@@ -34,6 +34,24 @@ module Everywhere
       render json: config.path_configuration_hash(os, tabs: tabs)
     end
 
+    # GET /.well-known/apple-app-site-association — the iOS universal-links
+    # association file, generated from everywhere.yml. Extension-less and
+    # application/json, per Apple. 404 when deep linking isn't configured.
+    def apple_app_site_association
+      json = Config.load(::Rails.root.to_s).apple_app_site_association_json
+      return head(:not_found) unless json
+
+      render json: json
+    end
+
+    # GET /.well-known/assetlinks.json — the Android Digital Asset Links file.
+    def asset_links
+      json = Config.load(::Rails.root.to_s).asset_links_json
+      return head(:not_found) unless json
+
+      render json: json
+    end
+
     # GET /everywhere/reset?to=/path — the native "reset the app" page. Auth
     # flows redirect the shell here so it rebuilds cleanly before landing on
     # `to`. Never cached (it must run every time).

data/lib/everywhere/native_helper.rb

@@ -2,6 +2,7 @@
 
 require "erb"
 require "json"
+require_relative "config"
 
 module Everywhere
   # Server-side view helpers mirroring the JS bridge's platform detection, so
@@ -25,11 +26,7 @@ module Everywhere
     # :ios, :android, or nil in a plain browser. Reads Hotwire Native's UA
     # marker, so it's correct even before the JS bridge has booted.
     def native_platform
-      ua = _everywhere_user_agent or return nil
-      return :ios if ua.include?("Hotwire Native iOS")
-      return :android if ua.include?("Hotwire Native Android")
-
-      nil
+      Everywhere.native_platform_of(_everywhere_user_agent)
     end
 
     # The shell's version as a Gem::Version (from the "RubyEverywhere/<ver>"
@@ -140,8 +137,204 @@ module Everywhere
       html.respond_to?(:html_safe) ? html.html_safe : html
     end
 
+    # A navigation-bar button. Renders a normal link (or a submit button with
+    # type: :submit) that the mobile shell lifts into the top navigation bar —
+    # tapping the native button just clicks this element, so a link navigates
+    # and a submit submits, defined once. In a browser it's the plain link it
+    # already is (the shell hides the in-page copy). Icons are per-platform like
+    # tabs: icon: is the shared fallback, icons: {ios:, android:} the specifics
+    # (SF Symbol / Material name).
+    #
+    #   <%= everywhere_nav_button "New", new_note_path, icons: { ios: "plus", android: "add" } %>
+    #   <%= everywhere_nav_button "Save", type: :submit, style: "done" %>
+    def everywhere_nav_button(title, href = nil, icon: nil, icons: nil, side: "right",
+                              style: "plain", type: nil, form: nil, disabled: false,
+                              method: nil, css_class: nil, id: nil)
+      nav = _everywhere_nav_attrs("data-everywhere-nav-button", title: title, icon: icon,
+                                  icons: icons, side: side, style: style, disabled: disabled)
+      _everywhere_clickable(title, href, type: type, form: form, method: method,
+                            disabled: disabled, css_class: css_class, id: id, extra: nav)
+    end
+
+    # A form's submit control mirrored into the navigation bar (right side,
+    # "done" style by default). Place it inside the <form>, or aim it at one
+    # with form: "<form-id>".
+    #
+    #   <%= form_with model: @note do |f| %>
+    #     <%= everywhere_submit_button "Save" %>
+    #     ...
+    #   <% end %>
+    def everywhere_submit_button(title = "Save", side: "right", style: "done", form: nil,
+                                 icon: nil, icons: nil, css_class: nil, id: nil)
+      everywhere_nav_button(title, type: :submit, side: side, style: style, form: form,
+                            icon: icon, icons: icons, css_class: css_class, id: id)
+    end
+
+    # A navigation-bar pull-down / overflow menu (defaults to the ⋯ ellipsis
+    # icon). Yields the items — build them with everywhere_menu_item; in the
+    # shell they become a native UIMenu, in a browser a plain list of links.
+    #
+    #   <%= everywhere_nav_menu do %>
+    #     <%= everywhere_menu_item "Share", share_path, icons: { ios: "square.and.arrow.up" } %>
+    #     <%= everywhere_menu_item "Delete", note_path(@note), method: :delete, style: "destructive" %>
+    #   <% end %>
+    def everywhere_nav_menu(title = nil, icon: nil, icons: nil, side: "right",
+                            css_class: nil, id: nil, &block)
+      content = _everywhere_capture(&block)
+      attrs = _everywhere_nav_attrs("data-everywhere-nav-menu", title: title, icon: icon,
+                                    icons: icons, side: side)
+      common = +""
+      common << %( id="#{_everywhere_attr(id)}") if id
+      common << %( class="#{_everywhere_attr(css_class)}") if css_class
+      _everywhere_safe(%(<div#{common} #{attrs}>#{content}</div>))
+    end
+
+    # One item inside an everywhere_nav_menu or everywhere_menu. A link by
+    # default; type: :submit (with form:) submits a form, and method: (:delete,
+    # …) makes a Turbo method link. style: "destructive" tints it in the native
+    # menu / action sheet.
+    def everywhere_menu_item(title, href = nil, icon: nil, icons: nil, style: nil,
+                             type: nil, form: nil, method: nil, css_class: nil, id: nil)
+      extra = +"data-everywhere-menu-item"
+      extra << %( data-everywhere-menu-title="#{_everywhere_attr(title)}")
+      extra << _everywhere_icon_attrs("data-everywhere-menu-icon", icon, icons)
+      extra << %( data-everywhere-menu-style="#{_everywhere_attr(style)}") if style
+      _everywhere_clickable(title, href, type: type, form: form, method: method,
+                            css_class: css_class, id: id, extra: extra)
+    end
+
+    # An in-content action sheet: a trigger and the items it opens. In the
+    # mobile shell the trigger presents a native action sheet; in a browser it
+    # toggles the items as an inline menu (styled by everywhere/native.css).
+    # Choosing an item clicks it, so behavior lives in the items themselves.
+    #
+    #   <%= everywhere_menu "Options" do %>
+    #     <%= everywhere_menu_item "Edit", edit_post_path(@post) %>
+    #     <%= everywhere_menu_item "Delete", post_path(@post), method: :delete, style: "destructive" %>
+    #   <% end %>
+    def everywhere_menu(trigger = "Options", title: nil, trigger_class: nil,
+                        items_class: nil, css_class: nil, id: nil, &block)
+      content = _everywhere_capture(&block)
+      wrap = +""
+      wrap << %( id="#{_everywhere_attr(id)}") if id
+      wrap << %( class="#{_everywhere_attr(css_class)}") if css_class
+      wrap << %( data-everywhere-menu-title="#{_everywhere_attr(title)}") if title
+
+      trig = %(<button type="button" data-everywhere-menu-trigger#{%( class="#{_everywhere_attr(trigger_class)}") if trigger_class}>#{_everywhere_attr(trigger)}</button>)
+      items = %(<div data-everywhere-menu-items#{%( class="#{_everywhere_attr(items_class)}") if items_class}>#{content}</div>)
+      _everywhere_safe(%(<div data-everywhere-menu#{wrap}>#{trig}#{items}</div>))
+    end
+
+    # A floating action button: a fixed, safe-area-aware circular control (see
+    # everywhere/native.css). A real link (or button) that shows in a browser
+    # too and gains a tap haptic in the shell. Pass a block for custom content,
+    # or icon: for a built-in line glyph; label: sets the accessible name and,
+    # with extended: true, a visible label pill.
+    #
+    #   <%= everywhere_fab new_note_path, icon: :plus, label: "New note" %>
+    #   <%= everywhere_fab compose_path, icon: :pencil, label: "Compose", extended: true %>
+    def everywhere_fab(href = nil, icon: :plus, label: nil, haptic: "light", side: "right",
+                       extended: false, type: nil, form: nil, method: nil,
+                       css_class: nil, id: nil, &block)
+      classes = ["everywhere-fab"]
+      classes << "everywhere-fab-left" if side.to_s == "left"
+      classes << "everywhere-fab-extended" if extended
+      classes << css_class if css_class
+
+      inner = block ? _everywhere_capture(&block) : _everywhere_fab_icon(icon)
+      inner = "#{inner}<span class=\"everywhere-fab-label\">#{_everywhere_attr(label)}</span>" if extended && label
+
+      extra = %(class="#{classes.join(" ")}")
+      extra << %( aria-label="#{_everywhere_attr(label)}") if label
+      extra << %( data-everywhere-haptic="#{_everywhere_attr(haptic)}") if haptic
+
+      _everywhere_clickable(inner, href, type: type, form: form, method: method,
+                            id: id, extra: extra, raw_content: true)
+    end
+
     private
 
+    # Build a link or button carrying `extra` attributes. `raw_content: true`
+    # trusts pre-built inner HTML (icon SVG); otherwise the text is escaped.
+    def _everywhere_clickable(content, href, type: nil, form: nil, method: nil,
+                              disabled: false, css_class: nil, id: nil, extra: "",
+                              raw_content: false)
+      common = +""
+      common << %( id="#{_everywhere_attr(id)}") if id
+      common << %( class="#{_everywhere_attr(css_class)}") if css_class
+      inner = raw_content ? content.to_s : _everywhere_attr(content)
+
+      html =
+        if type.to_s == "submit"
+          %(<button type="submit"#{%( form="#{_everywhere_attr(form)}") if form}#{" disabled" if disabled}#{common} #{extra}>#{inner}</button>)
+        elsif href.nil? && type
+          %(<button type="#{_everywhere_attr(type)}"#{" disabled" if disabled}#{common} #{extra}>#{inner}</button>)
+        else
+          meth = method ? %( data-turbo-method="#{_everywhere_attr(method)}") : ""
+          %(<a href="#{_everywhere_attr(href || "#")}"#{meth}#{common} #{extra}>#{inner}</a>)
+        end
+      _everywhere_safe(html)
+    end
+
+    # The data-* attribute run shared by nav buttons and nav menus.
+    def _everywhere_nav_attrs(marker, title:, icon: nil, icons: nil, side: "right",
+                              style: nil, disabled: false)
+      out = +marker.to_s
+      out << %( data-everywhere-nav-title="#{_everywhere_attr(title)}") if title
+      out << _everywhere_icon_attrs("data-everywhere-nav-icon", icon, icons)
+      out << %( data-everywhere-nav-side="left") if side.to_s == "left"
+      out << %( data-everywhere-nav-style="#{_everywhere_attr(style)}") if style && style.to_s != "plain"
+      out << " data-everywhere-nav-disabled" if disabled
+      out
+    end
+
+    # Per-platform icon attributes: the shared `<base>` plus `<base>-ios` /
+    # `<base>-android` from an icons: {ios:, android:} hash (string or symbol keys).
+    def _everywhere_icon_attrs(base, icon, icons)
+      out = +""
+      out << %( #{base}="#{_everywhere_attr(icon)}") if icon
+      if icons.is_a?(Hash)
+        %i[ios android].each do |os|
+          value = icons[os] || icons[os.to_s]
+          out << %( #{base}-#{os}="#{_everywhere_attr(value)}") if value
+        end
+      end
+      out
+    end
+
+    def _everywhere_capture(&block)
+      return "" unless block
+
+      respond_to?(:capture) ? capture(&block) : block.call
+    end
+
+    def _everywhere_safe(html)
+      html.respond_to?(:html_safe) ? html.html_safe : html
+    end
+
+    # Built-in line glyphs for everywhere_fab (24×24, currentColor stroke). SF
+    # Symbol / Material names don't render on the web, so the FAB carries its own.
+    FAB_ICONS = {
+      plus: "M12 5v14M5 12h14",
+      pencil: "M12 20h9M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4z",
+      camera: "M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2zM12 17a4 4 0 1 0 0-8 4 4 0 0 0 0 8z",
+      search: "M21 21l-4.35-4.35M11 19a8 8 0 1 0 0-16 8 8 0 0 0 0 16z",
+      share: "M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8M16 6l-4-4-4 4M12 2v14",
+      check: "M20 6L9 17l-5-5",
+      close: "M18 6L6 18M6 6l12 12",
+      trash: "M3 6h18M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6",
+      arrow_up: "M12 19V5M5 12l7-7 7 7",
+      chevron_up: "M18 15l-6-6-6 6"
+    }.freeze
+
+    def _everywhere_fab_icon(icon)
+      return "" if icon.nil?
+
+      path = FAB_ICONS[icon.to_sym] || FAB_ICONS[:plus]
+      %(<svg class="everywhere-fab-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" ) +
+        %(stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="#{path}"/></svg>)
+    end
+
     def _everywhere_attr(value)
       ERB::Util.html_escape(value.to_s)
     end

data/lib/everywhere/omniauth.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "auth_handoff"
+
+module Everywhere
+  # OmniAuth 2 and the native sign-in flow, introduced to each other.
+  #
+  # Since CVE-2015-9284, OmniAuth only starts a provider flow from a POST
+  # carrying a CSRF token (omniauth-rails_csrf_protection). Right for browsers —
+  # and impossible for the native flow, which enters the provider path through
+  # /everywhere/auth/start's redirect: a GET, in a browser session that has no
+  # CSRF token to give. Without help, tapping "Sign in with GitHub" in the app
+  # ends on OmniAuth's failure page.
+  #
+  #   # config/initializers/omniauth.rb, after your provider setup
+  #   require "everywhere/omniauth"
+  #   Everywhere::OmniAuth.protect!
+  #
+  # Browsers keep exactly the validation they had — whatever
+  # request_validation_phase was set to keeps running. The one extra shape
+  # allowed through is the native flow's entry: a top-level, not-cross-site GET
+  # carrying a marker cookie that /everywhere/auth/start sealed seconds ago.
+  # Nobody else can mint that marker (AES-GCM under the app's secret), start
+  # refuses cross-site initiators outright, and the freshness window means a
+  # marker lingering in Safari's jar after a real sign-in stops vouching for
+  # anything almost immediately.
+  module OmniAuth
+    # How long after start seals the marker its GET still reads as the native
+    # flow arriving. The real gap is one redirect — milliseconds — but the
+    # sheet can sit on our page briefly on a slow network; anything past this
+    # is a browser wandering in.
+    ENTRY_WINDOW = 90
+
+    class << self
+      # Wire OmniAuth's global config: allow GET request phases (they're
+      # refused per-request by the validator unless they prove themselves),
+      # and wrap the configured validation phase so everything that isn't the
+      # native entry is judged exactly as before. Safe to call more than once —
+      # re-running replaces the wrapper, never stacks it.
+      def protect!(entry_window: ENTRY_WINDOW)
+        unless defined?(::OmniAuth) && ::OmniAuth.respond_to?(:config)
+          raise "Everywhere::OmniAuth.protect! needs OmniAuth loaded first — " \
+                "call it below your OmniAuth/Devise setup (config/initializers/omniauth.rb)"
+        end
+
+        config = ::OmniAuth.config
+        config.allowed_request_methods = Array(config.allowed_request_methods) | [:get]
+        config.silence_get_warning = true if config.respond_to?(:silence_get_warning=)
+
+        fallback = config.request_validation_phase
+        fallback = fallback.fallback if fallback.is_a?(RequestValidator)
+        config.request_validation_phase = RequestValidator.new(fallback: fallback, entry_window: entry_window)
+      end
+    end
+
+    # OmniAuth request_validation_phase: passes the native flow's entry,
+    # delegates everything else. A nil fallback means the app had no request
+    # validation configured, and it still has none — this never tightens.
+    class RequestValidator
+      attr_reader :fallback
+
+      def initialize(fallback: nil, entry_window: ENTRY_WINDOW)
+        @fallback = fallback
+        @entry_window = entry_window
+      end
+
+      def call(env)
+        return if native_entry?(env)
+
+        @fallback&.call(env)
+      end
+
+      private
+
+      # The one shape the native flow produces: a GET, not from a cross-site
+      # initiator, carrying a marker minted moments ago. POSTs never qualify —
+      # they come from rendered pages that have a CSRF token to present.
+      def native_entry?(env)
+        return false unless env["REQUEST_METHOD"] == "GET"
+        return false if env["HTTP_SEC_FETCH_SITE"] == "cross-site"
+
+        marker = AuthHandoff.marker(env)
+        issued = marker && marker["iat"]
+        !!issued && Time.now.to_i - issued.to_i <= @entry_window
+      end
+    end
+  end
+end

data/lib/everywhere/paths.rb

@@ -54,6 +54,30 @@ module Everywhere
                          "reinstall ruby_everywhere or pass --template-dir")
     end
 
+    # The Hotwire Native Android shell template bundled inside the gem:
+    # support/mobile/android/ holds a frozen Gradle project (wrapper committed)
+    # the CLI stamps per-app — everywhere.properties + assets + res, never a
+    # build script. Same freeze contract the iOS template has.
+    def bundled_android_dir
+      File.join(gem_root, "support", "mobile", "android")
+    end
+
+    # Absolute path to the Android template, or nil when it isn't there. Unlike
+    # #ios_dir, nil is the NORMAL state until the template lands — callers must
+    # read it as "Android isn't buildable in this release yet", not as a corrupt
+    # install. settings.gradle.kts is the marker because it's the one file every
+    # Gradle project must have at its root.
+    def android_dir
+      bundled_android_dir if File.exist?(File.join(bundled_android_dir, "settings.gradle.kts"))
+    end
+
+    # Like #android_dir but aborts with a helpful message when the template is
+    # missing. The --template-dir hint covers dev on a modified template.
+    def android_dir!
+      android_dir or UI.die!("couldn't find the bundled Android template at #{bundled_android_dir}; " \
+                             "reinstall ruby_everywhere or pass --template-dir")
+    end
+
     # Per-user cache dir. Keeps heavy build state out of the gem and the app.
     def cache_dir
       File.expand_path(ENV["RUBYEVERYWHERE_HOME"] || "~/.rubyeverywhere")
@@ -79,6 +103,29 @@ module Everywhere
       File.join(cache_dir, "ios-packages")
     end
 
+    # The stamped copy of the Android template for one app, keyed by
+    # applicationId. Persistent for the same reasons ios_work_dir is: Gradle's
+    # incremental state is path-sensitive, and the stamped project opens in
+    # Android Studio unmodified.
+    def android_work_dir(application_id)
+      File.join(cache_dir, "android", application_id)
+    end
+
+    # GRADLE_USER_HOME for shell builds. Redirected here so the multi-GB Gradle
+    # distribution, the Android Gradle Plugin and the Hotwire artifacts are
+    # downloaded once and stay warm across every app — and never land inside the
+    # installed gem. Same trick as cargo_target_dir.
+    def android_gradle_home
+      File.join(cache_dir, "android-gradle")
+    end
+
+    # Where the Material Symbols icon font is cached after its one-time fetch.
+    # The font is ~10 MB, so it's fetched on first Android build instead of
+    # riding along in a 229 KB gem that most users never build Android with.
+    def android_fonts_dir
+      File.join(cache_dir, "android-fonts")
+    end
+
     # Where cargo writes the shell's build output (CARGO_TARGET_DIR). Redirected
     # here so cargo never dumps a multi-GB target/ into the installed gem, and so
     # the shell compiles warm across projects — the shell source is identical for

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 
   # Version of the @rubyeverywhere/bridge JS this gem ships. bridge/ in the
   # gem IS the npm package (served to Rails apps by Everywhere::Engine,