ruflet_rails 0.0.13 → 0.0.14

data/lib/ruflet/rails/native_app.rb

@@ -1,249 +1,52 @@
 # frozen_string_literal: true
 
+require "json"
 require "uri"
 
 module Ruflet
   module Rails
-    # Managed webview navigation driver for ruflet_rails.
-    #
-    # Your existing web app is the body, rendered in a WebView. Navigation works
-    # out of the box: a tiny JS bridge injected into each page intercepts link
-    # clicks and proposes them to native, so every visit becomes a NATIVE screen
-    # pushed onto the stack (with an automatic back button) — no per-link code.
-    # The native AppBar title tracks each page's <title>, and you declare special
-    # paths as data.
-    #
-    #   Ruflet.run do |page|
-    #     Ruflet::Rails.native_app(
-    #       page,
-    #       start_url: "https://myapp.com",
-    #       title: "My App",                              # auto-updates from <title>
-    #       actions: -> { [icon_button("search", on_click: ->(_e) { ... })] },
-    #       navigation_bar: navigation_bar(destinations: [...]),
-    #
-    #       # web content shown in a bottom sheet (auth, quick forms):
-    #       modal: ["/sign_in", "/sign_up", %r{/new\z}],
-    #
-    #       # optional: override a path with a fully native screen:
-    #       native: { %r{\A/products/(\d+)\z} => ->(ctx) { product_screen(ctx.match[1]) } }
-    #     )
-    #   end
-    #
-    # Normal links just push a native webview screen (back returns). Paths listed
-    # in `modal:` open as a bottom sheet. Paths in `native:` render your own UI.
-    #
-    # The bridge talks to native over the webview's console channel
-    # (on_console_message), which works on iOS/Android/macOS. On platforms
-    # without a native webview the body degrades to a plain frame.
+    # Managed native shell for a Rails WebView body.
     class NativeApp
-      # Injected into every page: report the title, and turn same-origin link
-      # clicks into native visit proposals (so they don't load in place).
-      BRIDGE_JS = <<~JS
-        (function () {
-          function report(kind, value) { console.log("ruflet:" + kind + ":" + value); }
-          report("title", document.title || "");
-          if (window.__rufletBridgeBound) return;
-          window.__rufletBridgeBound = true;
-          document.addEventListener("click", function (e) {
-            var a = e.target && e.target.closest ? e.target.closest("a[href]") : null;
-            if (!a || a.target === "_blank") return;
-            if (a.origin && a.origin !== location.origin) return; // external: leave it
-            e.preventDefault();
-            report("visit", a.href);
-          }, true);
-        })();
-      JS
+      Screen = Struct.new(:url, :view, :webview, :loading, :body, :title_text, :appbar_spec, :appbar_signature,
+                          :drawer, :end_drawer, :drawer_signature, :rail, :rail_signature, keyword_init: true)
 
-      VISIT_PREFIX = "ruflet:visit:"
-      TITLE_PREFIX = "ruflet:title:"
-
-      Screen  = Struct.new(:kind, :url, :view, :webview, :title_text, keyword_init: true)
-      Context = Struct.new(:url, :path, :match, keyword_init: true)
-
-      def initialize(page, start_url:, title: nil, actions: nil, navigation_bar: nil,
-                     bottom_appbar: nil, modal: [], native: {})
+      def initialize(page, start_url:, title: nil, actions: nil, navigation_bar: nil, bottom_appbar: nil,
+                     loading: :shimmer)
         @page = page
         @start_url = start_url.to_s
         @title = title.to_s
         @actions = actions
         @navigation_bar = navigation_bar
         @bottom_appbar = bottom_appbar
-        @modal_patterns = Array(modal).map { |p| compile_pattern(p) }
-        @native_rules = native.map { |pattern, builder| [compile_pattern(pattern), builder] }
+        @loading = loading
         @screens = []
-        @modal_sheet = nil
+        @sheet = nil
+        @dialog = nil
+        @bottomnav_signature = nil
+        @bottomnav_spec = nil
+        @appbar_specs_by_url = {}
+        @drawer_spec = nil
+        @drawer_open_requested = false
       end
 
-      def self.bridge_js = BRIDGE_JS
-
       def start
         @page.on_view_pop = ->(_event) { pop }
         push_webview(@start_url, root: true)
         self
       end
-
-      private
-
-      # --- Stack operations ---------------------------------------------------
-
-      def push_webview(url, root: false)
-        screen = Screen.new(kind: :webview, url: url.to_s)
-        screen.title_text = Ruflet::UI::ControlFactory.build(:text, value: @title)
-        screen.webview = build_webview(screen)
-        screen.view = build_view(screen, root: root)
-        @screens.push(screen)
-        flush
-        screen
-      end
-
-      def push_native(builder, ctx)
-        view = builder.call(ctx)
-        return unless view.is_a?(Ruflet::Control)
-
-        @screens.push(Screen.new(kind: :native, url: ctx.url, view: view))
-        flush
-      end
-
-      def pop
-        return if @screens.size <= 1
-
-        @screens.pop
-        flush
-      end
-
-      def flush
-        @page.views = @screens.map(&:view)
-        @page.update
-      end
-
-      # --- Webview screen + native chrome ------------------------------------
-
-      def build_webview(screen)
-        Ruflet::UI::ControlFactory.build(
-          :webview,
-          url: screen.url,
-          method: "get",
-          expand: true,
-          on_page_ended: ->(_event) { inject_bridge(screen) },
-          on_console_message: ->(event) { handle_message(screen, message_of(event)) }
-        )
-      end
-
-      def build_view(screen, root:)
-        args = { route: root ? "/" : "/screen", controls: [screen.webview], appbar: build_appbar(screen) }
-        if root
-          args[:navigation_bar] = @navigation_bar unless @navigation_bar.nil?
-          args[:bottom_appbar] = @bottom_appbar unless @bottom_appbar.nil?
-        end
-        Ruflet::UI::ControlFactory.build(:view, **args)
-      end
-
-      def build_appbar(screen)
-        args = { title: screen.title_text }
-        actions = resolve_actions
-        args[:actions] = actions if actions
-        Ruflet::UI::ControlFactory.build(:appbar, **args)
-      end
-
-      def resolve_actions
-        @actions.respond_to?(:call) ? @actions.call : @actions
-      end
-
-      # --- Bridge ------------------------------------------------------------
-
-      def inject_bridge(screen)
-        screen.webview.run_javascript(BRIDGE_JS) if screen.webview.respond_to?(:run_javascript)
-      rescue StandardError
-        nil
-      end
-
-      def handle_message(screen, message)
-        return if message.nil?
-
-        if message.start_with?(TITLE_PREFIX)
-          update_title(screen, message[TITLE_PREFIX.length..])
-        elsif message.start_with?(VISIT_PREFIX)
-          visit(message[VISIT_PREFIX.length..])
-        end
-      end
-
-      def update_title(screen, value)
-        return unless screen.title_text&.wire_id
-
-        @page.update(screen.title_text, value: value.to_s)
-      end
-
-      # A proposed visit: native screen > modal sheet > push a webview screen.
-      def visit(url)
-        path = path_of(url)
-        return if path.nil?
-
-        builder, match = match_native(path)
-        if builder
-          push_native(builder, Context.new(url: url, path: path, match: match))
-        elsif modal?(path)
-          present_modal(url)
-        else
-          push_webview(url)
-        end
-      end
-
-      # --- Modal (bottom sheet of web content) -------------------------------
-
-      def present_modal(url)
-        sheet_webview = Ruflet::UI::ControlFactory.build(:webview, url: url.to_s, method: "get", expand: true)
-        @modal_sheet = Ruflet::UI::ControlFactory.build(
-          :bottomsheet,
-          open: true,
-          dismissible: true,
-          content: Ruflet::UI::ControlFactory.build(:container, height: 520, content: sheet_webview),
-          on_dismiss: ->(_event) { @modal_sheet = nil }
-        )
-        @page.bottom_sheet = @modal_sheet
-        @page.update
-      end
-
-      # --- Matching ----------------------------------------------------------
-
-      def match_native(path)
-        @native_rules.each do |pattern, builder|
-          if pattern.is_a?(Regexp)
-            m = pattern.match(path)
-            return [builder, m] if m
-          elsif pattern == path
-            return [builder, nil]
-          end
-        end
-        nil
-      end
-
-      def modal?(path)
-        @modal_patterns.any? do |pattern|
-          pattern.is_a?(Regexp) ? pattern.match?(path) : pattern == path
-        end
-      end
-
-      def compile_pattern(pattern)
-        return pattern if pattern.is_a?(Regexp)
-
-        value = pattern.to_s
-        value.start_with?("/") ? value : "/#{value}"
-      end
-
-      def path_of(url)
-        URI.parse(url.to_s).path
-      rescue URI::InvalidURIError
-        nil
-      end
-
-      def message_of(event)
-        data = event.respond_to?(:data) ? event.data : event
-        return data["message"] || data[:message] if data.is_a?(Hash)
-
-        data
-      end
     end
+  end
+end
 
+require_relative "native_app/html_adapter"
+require_relative "native_app/customization"
+require_relative "native_app/shell"
+require_relative "native_app/navigation"
+require_relative "native_app/actions"
+require_relative "native_app/overlays"
+
+module Ruflet
+  module Rails
     module_function
 
     # Start a managed webview app. See NativeApp.

data/lib/ruflet/rails/protocol/web_app.rb

@@ -74,7 +74,7 @@ module Ruflet
 
         def entrypoint
           @entrypoint_option || @app_block ||
-            raise(ArgumentError, "web_app requires one of view:, app_file:, or a block")
+            raise(ArgumentError, "web_app requires one of app_file: or a block")
         end
 
         # The web build must NOT live under public/, or Rails' static

data/lib/ruflet/rails/railtie.rb

@@ -3,11 +3,6 @@
 module Ruflet
   module Rails
     class Railtie < ::Rails::Railtie
-      generators do
-        require "ruflet/rails/generator_hooks"
-        Ruflet::Rails::GeneratorHooks.install!
-      end
-
       # Make ruflet_frame and friends available in every .erb template.
       initializer "ruflet_rails.view_helpers" do
         ActiveSupport.on_load(:action_view) do
@@ -15,18 +10,6 @@ module Ruflet
         end
       end
 
-      # Ruflet components live under app/views so Rails will not discover them
-      # by default. Add that directory as a Zeitwerk root and collapse its
-      # organizational subdirectories, matching generated top-level constants
-      # such as components/products/product_component.rb -> ProductComponent.
-      initializer "ruflet_rails.components", before: :bootstrap_hook do |app|
-        components = app.root.join("app/views/ruflet/components")
-        next unless components.directory?
-
-        app.autoloaders.main.push_dir(components)
-        app.autoloaders.main.collapse(components.join("**"))
-      end
-
       initializer "ruflet_rails.desktop_launcher", after: :load_config_initializers do |_app|
         next unless defined?(::Rails.root)
 
@@ -61,10 +44,10 @@ module Ruflet
             require "tempfile"
 
             exit_code = Dir.chdir(::Rails.root) do
-              # If no ruflet.yaml on disk, generate one from Rails config so the
-              # CLI has access to assets, services, and build options.
+              # Rails build metadata lives in config/initializers/ruflet.rb.
+              # Serialize it to the CLI's yaml shape for this build invocation.
               yaml_hash = cfg.to_ruflet_yaml_hash
-              use_temp  = yaml_hash.any? && !File.file?("ruflet.yaml") && !File.file?("ruflet.yml")
+              use_temp  = yaml_hash.any?
 
               if use_temp
                 Tempfile.create(["ruflet", ".yaml"], ::Rails.root) do |f|

data/lib/ruflet/rails/view_helpers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "erb"
+require "json"
 
 module Ruflet
   module Rails
@@ -44,8 +45,212 @@ module Ruflet
         ruflet_html_safe(markup)
       end
 
+      # --- Native annotations ------------------------------------------------
+      #
+      # These emit plain HTML decorated with `ruflet-*` attributes. In a normal
+      # browser they render and behave as ordinary HTML; inside the Ruflet
+      # native shell (Ruflet::Rails.native_app) the HTML adapter reads the
+      # attributes and drives native navigation/chrome instead. They degrade
+      # gracefully — no JavaScript required for the web rendering.
+
+      # A header the native shell hides and re-renders as a native AppBar. Place
+      # action items inside with `ruflet-icon` (use ruflet_appbar_action).
+      #
+      #   <%= ruflet_appbar "Inbox" do %>
+      #     <%= ruflet_appbar_action "search", search_path %>
+      #   <% end %>
+      def ruflet_appbar(title = nil, payload: {}, leading: nil, actions: nil, **attrs, &block)
+        appbar_payload = ruflet_stringify_keys(payload)
+        appbar_payload["leading"] = ruflet_stringify_keys(leading) unless leading.nil?
+        appbar_payload["actions"] = ruflet_stringify_keys(actions) unless actions.nil?
+        data = { "data-ruflet-appbar" => appbar_payload.empty? ? "" : ruflet_json(appbar_payload),
+                 "data-ruflet-title" => title,
+                 "hidden" => true }
+        ruflet_build_tag("header", ruflet_capture(&block), data.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      # An AppBar action button (icon taps navigate).
+      def ruflet_appbar_action(icon, href = nil, nav: :push, payload: {}, **attrs)
+        payload = ruflet_compact_hash({ "icon" => icon, "action" => nav.to_s }.merge(ruflet_stringify_keys(payload)))
+        data = { "data-ruflet-icon" => ruflet_json(payload), "href" => href }
+        ruflet_build_tag("a", "", data.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      # A nav the native shell hides and re-renders as a native bottom
+      # NavigationBar. Items are `ruflet_nav_item` links.
+      #
+      #   <%= ruflet_bottom_nav do %>
+      #     <%= ruflet_nav_item "Home", root_path, icon: "house", selected: true %>
+      #     <%= ruflet_nav_item "Profile", profile_path, icon: "person" %>
+      #   <% end %>
+      def ruflet_bottom_nav(name: "bottom-navigation", payload: {}, **attrs, &block)
+        nav_payload = ruflet_stringify_keys(payload)
+        ruflet_build_tag("nav", ruflet_capture(&block), {
+          "data-ruflet-tabs" => nav_payload.empty? ? name : ruflet_json(nav_payload),
+          "hidden" => true
+        }.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      # A destination inside ruflet_bottom_nav.
+      def ruflet_nav_item(label, href, icon:, selected: false, color: nil, size: 24, payload: {}, **attrs)
+        item_payload = ruflet_stringify_keys(payload)
+        data = {
+          "href" => href,
+          "data-ruflet-icon" => ruflet_json(ruflet_compact_hash(item_payload.merge(icon: icon, label: label,
+                                                                                   color: color, size: size)))
+        }
+        data["data-ruflet-selected"] = "true" if selected
+        ruflet_build_tag("a", label, data.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      # A drawer the native shell hides and re-renders as a native
+      # NavigationDrawer. Items are `ruflet_drawer_item` links.
+      #
+      #   <%= ruflet_drawer do %>
+      #     <%= ruflet_drawer_item "Home", root_path, icon: "home" %>
+      #     <%= ruflet_drawer_item "Settings", settings_path, icon: "settings", nav: :push %>
+      #   <% end %>
+      def ruflet_drawer(action: :root, payload: {}, **attrs, &block)
+        ruflet_build_tag("nav", ruflet_capture(&block), {
+          "data-ruflet-drawer" => ruflet_json(ruflet_compact_hash(ruflet_stringify_keys(payload).merge(action: action.to_s))),
+          "hidden" => true
+        }.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      # A destination inside ruflet_drawer.
+      def ruflet_drawer_item(label, href, icon:, selected: false, nav: nil, payload: {}, **attrs)
+        item_payload = ruflet_stringify_keys(payload)
+        data = {
+          "href" => href,
+          "data-ruflet-icon" => ruflet_json(ruflet_compact_hash(item_payload.merge(icon: icon, label: label,
+                                                                                   action: nav&.to_s)))
+        }
+        data["data-ruflet-selected"] = "true" if selected
+        ruflet_build_tag("a", label, data.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      # Desktop/tablet navigation the native shell hides and re-renders as a
+      # native NavigationRail beside the WebView body.
+      #
+      #   <%= ruflet_navigation_rail extended: true do %>
+      #     <%= ruflet_rail_item "Home", root_path, icon: "home" %>
+      #     <%= ruflet_rail_item "Inbox", inbox_path, icon: "mail" %>
+      #   <% end %>
+      def ruflet_navigation_rail(action: :root, extended: nil, label_type: nil, breakpoint: nil, payload: {}, **attrs, &block)
+        payload = ruflet_compact_hash(ruflet_stringify_keys(payload).merge(action: action.to_s, extended: extended,
+                                                                           label_type: label_type, breakpoint: breakpoint))
+        ruflet_build_tag("nav", ruflet_capture(&block), {
+          "data-ruflet-rail" => ruflet_json(payload),
+          "hidden" => true
+        }.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      alias ruflet_rail ruflet_navigation_rail
+
+      # A destination inside ruflet_navigation_rail.
+      def ruflet_rail_item(label, href, icon:, selected: false, nav: nil, payload: {}, **attrs)
+        item_payload = ruflet_stringify_keys(payload)
+        data = {
+          "href" => href,
+          "data-ruflet-icon" => ruflet_json(ruflet_compact_hash(item_payload.merge(icon: icon, label: label,
+                                                                                   action: nav&.to_s)))
+        }
+        data["data-ruflet-selected"] = "true" if selected
+        ruflet_build_tag("a", label, data.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      # Native platform services from ERB. These are normal HTML elements in a
+      # browser and native service calls inside Ruflet::Rails.native_app.
+      def ruflet_share_link(label, href = "#", text: nil, title: nil, subject: nil, url: nil, files: nil, **attrs)
+        payload = ruflet_compact_hash(component: "share", text: text, title: title, subject: subject,
+                                      url: url || href, files: files)
+        ruflet_action_tag("a", label, payload, { "href" => href }.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      def ruflet_copy_button(label, text:, toast: "Copied", haptic: true, **attrs)
+        payload = ruflet_compact_hash(component: "clipboard", text: text, toast: toast, haptic: haptic)
+        ruflet_action_tag("button", label, payload, { "type" => "button" }.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      def ruflet_launch_link(label, href, mode: nil, **attrs)
+        payload = ruflet_compact_hash(component: "url_launcher", url: href, mode: mode)
+        ruflet_action_tag("a", label, payload, { "href" => href }.merge(ruflet_dash_attrs(attrs)))
+      end
+
+      def ruflet_haptic_button(label, style: "selection", **attrs)
+        payload = ruflet_compact_hash(component: "haptic", style: style)
+        ruflet_action_tag("button", label, payload, { "type" => "button" }.merge(ruflet_dash_attrs(attrs)))
+      end
+
       private
 
+      def ruflet_action_tag(name, content, payload, attrs)
+        attrs["data-ruflet-action"] = ruflet_json(ruflet_stringify_keys(payload))
+        ruflet_build_tag(name, content, attrs)
+      end
+
+      # Capture block content via ActionView when available (real ERB), else
+      # fall back to the block's return value (standalone use / tests).
+      def ruflet_capture(&block)
+        return nil unless block
+
+        respond_to?(:capture) ? capture(&block) : block.call
+      end
+
+      # Build a tag from a name, inner content, and an attribute hash. nil/false
+      # attribute values are dropped; "" is kept (a bare boolean attribute).
+      def ruflet_build_tag(name, content, attributes)
+        markup = +"<#{name}"
+        attributes.each do |key, value|
+          next if value.nil? || value == false
+
+          markup << %( #{key}="#{ERB::Util.html_escape(value)}")
+        end
+        markup << ">"
+        markup << content.to_s if content
+        markup << "</#{name}>"
+        ruflet_html_safe(markup)
+      end
+
+      # Turn extra helper kwargs (data_role:) into dashed attribute keys
+      # (data-role), mirroring ruflet_frame.
+      def ruflet_dash_attrs(attrs)
+        attrs.each_with_object({}) do |(key, value), out|
+          if value.is_a?(Hash)
+            value.each do |nested_key, nested_value|
+              out["#{key}-#{nested_key}".to_s.tr("_", "-")] = nested_value.nil? ? nil : nested_value.to_s
+            end
+          else
+            out[key.to_s.tr("_", "-")] = value
+          end
+        end
+      end
+
+      def ruflet_compact_hash(hash)
+        hash.each_with_object({}) do |(key, value), out|
+          next if value.nil?
+
+          out[key] = value
+        end
+      end
+
+      def ruflet_stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, nested), out|
+            out[key.to_s] = ruflet_stringify_keys(nested)
+          end
+        when Array
+          value.map { |nested| ruflet_stringify_keys(nested) }
+        else
+          value
+        end
+      end
+
+      def ruflet_json(value)
+        JSON.generate(value)
+      end
+
       def ruflet_css_dimension(value)
         value.is_a?(Numeric) ? "#{value}px" : value.to_s
       end

data/lib/ruflet/rails.rb

@@ -20,18 +20,6 @@ module Ruflet
       yield config
     end
 
-    # Flet-style routed navigation stack for complex multi-screen apps. Wires
-    # up on_route_change / on_view_pop and starts at the current route. See
-    # Ruflet::Rails::RouteStack.
-    #
-    #   Ruflet::Rails.routed(page) do |route, nav|
-    #     nav.push(home_view)
-    #     nav.push(store_view) if route == "/store"
-    #   end
-    def routed(page, &builder)
-      RouteStack.new(page, &builder).start
-    end
-
     def sessions
       @sessions ||= SessionRegistry.new
     end
@@ -40,30 +28,24 @@ module Ruflet
       sessions.broadcast(&block)
     end
 
-    # WebSocket endpoint for native mobile/desktop clients. The developer
-    # declares the entry the same way they declare a web mount — the screens
-    # the app shows live in dev code, never in framework auto-discovery:
+    # WebSocket endpoint for native mobile/desktop clients. The developer owns
+    # the Ruflet entrypoint explicitly; there is no Rails component discovery:
     #
     #   # a standalone Ruflet app file (Ruflet.run/MyApp.new.run), per session:
     #   match "/ws", to: Ruflet::Rails.endpoint(app_file: Rails.root.join("app/ruflet/main.rb")), via: :all
     #
-    #   # a single component/view class (resolved lazily, so reloading works):
-    #   match "/ws", to: Ruflet::Rails.endpoint(view: "ProductComponent"), via: :all
-    #
     #   # a custom block:
     #   match "/ws", to: Ruflet::Rails.endpoint { |page| MyHome.render(page) }, via: :all
     #
-    # One of view:, app_file:, or a block is required — there is no
-    # auto-discovery fallback.
-    def endpoint(view: nil, app_file: nil, &block)
-      sources = [view, app_file, block].compact
-      raise ArgumentError, "endpoint accepts only one of view:, app_file:, or a block" if sources.length > 1
-      raise ArgumentError, "endpoint requires one of view:, app_file:, or a block" if sources.empty?
+    # One of app_file: or a block is required.
+    def endpoint(app_file: nil, &block)
+      sources = [app_file, block].compact
+      raise ArgumentError, "endpoint accepts only one of app_file: or a block" if sources.length > 1
+      raise ArgumentError, "endpoint requires one of app_file: or a block" if sources.empty?
 
       return Protocol::Runner.new.build_app_endpoint(file_path: app_file) if app_file
 
-      entry = block || web_app_entrypoint(view: view)
-      Protocol::Runner.new(&entry).build_endpoint
+      Protocol::Runner.new(&block).build_endpoint
     end
 
     # Shorthand for a standalone app-file endpoint.
@@ -78,49 +60,34 @@ module Ruflet
     # answers the Ruflet WebSocket on the same path. Routes stay routing-only;
     # UI code lives in dev files:
     #
-    #   # a single view class (resolved lazily, so reloading works):
-    #   mount Ruflet::Rails.web_app(view: "CounterView"), at: "/myfrontend"
-    #
     #   # a standalone Ruflet app file (MyApp.new.run), loaded per session:
     #   mount Ruflet::Rails.web_app(app_file: "app/ruflet/showcase/main.rb"), at: "/showcase"
     #
     #   # a custom block:
     #   mount Ruflet::Rails.web_app { |page| MyHome.render(page) }, at: "/app"
     #
-    # One of view:, app_file:, or a block is required — there is no
-    # auto-discovery fallback.
-    def web_app(view: nil, app_file: nil, build_dir: nil, &app_block)
-      sources = [view, app_file, app_block].compact
-      raise ArgumentError, "web_app accepts only one of view:, app_file:, or a block" if sources.length > 1
-      raise ArgumentError, "web_app requires one of view:, app_file:, or a block" if sources.empty?
+    # One of app_file: or a block is required.
+    def web_app(app_file: nil, build_dir: nil, &app_block)
+      sources = [app_file, app_block].compact
+      raise ArgumentError, "web_app accepts only one of app_file: or a block" if sources.length > 1
+      raise ArgumentError, "web_app requires one of app_file: or a block" if sources.empty?
 
       Protocol::WebApp.new(
         build_dir: build_dir,
-        entrypoint: web_app_entrypoint(view: view, app_file: app_file),
+        entrypoint: web_app_entrypoint(app_file: app_file),
         &app_block
       )
     end
 
-    def web_app_entrypoint(view: nil, app_file: nil)
-      if view
-        lambda do |page|
-          view_class_for(view).render(page)
-        end
-      elsif app_file
-        absolute = app_file.to_s
-        lambda do |page, env|
-          loaded = Protocol::MobileLoader.new(File.expand_path(absolute)).load!
-          entry = loaded[:entrypoint]
-          entry.arity == 1 ? entry.call(page) : entry.call(page, env)
-        end
-      end
-    end
+    def web_app_entrypoint(app_file: nil)
+      return unless app_file
 
-    # Resolved lazily on each session so Rails code reloading picks up edits.
-    def view_class_for(view)
-      return view if view.is_a?(Class)
-
-      view.to_s.constantize
+      absolute = app_file.to_s
+      lambda do |page, env|
+        loaded = Protocol::MobileLoader.new(File.expand_path(absolute)).load!
+        entry = loaded[:entrypoint]
+        entry.arity == 1 ? entry.call(page) : entry.call(page, env)
+      end
     end
 
   end

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.13" unless const_defined?(:VERSION)
+  VERSION = "0.0.14" unless const_defined?(:VERSION)
 end