RubyGems - ruby_everywhere - Versions diffs - 0.7.0 → 0.9.0 - Mend

ruby_everywhere 0.7.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (73) hide show

checksums.yaml +4 -4
data/exe/every +2 -13
data/exe/rbe +2 -13
data/lib/everywhere/boot.rb +9 -2
data/lib/everywhere/builders/android.rb +55 -42
data/lib/everywhere/builders/base.rb +53 -0
data/lib/everywhere/builders/desktop.rb +7 -23
data/lib/everywhere/builders/ios.rb +49 -52
data/lib/everywhere/builders/native_sources.rb +38 -0
data/lib/everywhere/child_processes.rb +4 -4
data/lib/everywhere/child_supervision.rb +172 -0
data/lib/everywhere/clock.rb +12 -0
data/lib/everywhere/commands/build.rb +20 -9
data/lib/everywhere/commands/dev.rb +59 -284
data/lib/everywhere/commands/doctor.rb +6 -6
data/lib/everywhere/commands/install.rb +1 -0
data/lib/everywhere/commands/platform/auth_status.rb +1 -0
data/lib/everywhere/commands/platform/build.rb +5 -6
data/lib/everywhere/commands/platform/login.rb +4 -4
data/lib/everywhere/commands/platform/logout.rb +1 -0
data/lib/everywhere/commands/platform/runner.rb +62 -7
data/lib/everywhere/commands/preview.rb +24 -97
data/lib/everywhere/commands/publish.rb +2 -0
data/lib/everywhere/commands/release.rb +14 -11
data/lib/everywhere/commands/shell_dir.rb +2 -0
data/lib/everywhere/commands/updates_keygen.rb +25 -1
data/lib/everywhere/config/app.rb +126 -0
data/lib/everywhere/config/auth.rb +108 -0
data/lib/everywhere/config/data.rb +50 -0
data/lib/everywhere/config/deep_linking.rb +107 -0
data/lib/everywhere/config/desktop_ui.rb +153 -0
data/lib/everywhere/config/mobile.rb +223 -0
data/lib/everywhere/config/native_desktop.rb +168 -0
data/lib/everywhere/config/native_mobile.rb +337 -0
data/lib/everywhere/config/shell.rb +57 -0
data/lib/everywhere/config/updates.rb +63 -0
data/lib/everywhere/config.rb +30 -1423
data/lib/everywhere/desktop_dev_app.rb +138 -0
data/lib/everywhere/dock/state.rb +3 -1
data/lib/everywhere/entrypoint.rb +24 -0
data/lib/everywhere/error.rb +8 -0
data/lib/everywhere/framework.rb +2 -2
data/lib/everywhere/host.rb +11 -0
data/lib/everywhere/ignore.rb +11 -5
data/lib/everywhere/line_pump.rb +3 -1
data/lib/everywhere/minisign.rb +1 -0
data/lib/everywhere/native_platform.rb +44 -0
data/lib/everywhere/paths.rb +23 -7
data/lib/everywhere/platform/client.rb +19 -1
data/lib/everywhere/platform/snapshot.rb +6 -4
data/lib/everywhere/plist.rb +17 -0
data/lib/everywhere/png.rb +1 -0
data/lib/everywhere/raw_tty.rb +51 -0
data/lib/everywhere/s3.rb +1 -0
data/lib/everywhere/shell_pages.rb +109 -0
data/lib/everywhere/tab_filter.rb +36 -0
data/lib/everywhere/task_pool.rb +3 -4
data/lib/everywhere/ui.rb +6 -1
data/lib/everywhere/version.rb +6 -4
data/lib/everywhere.rb +1 -2
data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/EverywhereApplication.kt +65 -4
data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/EverywhereConfig.kt +21 -0
data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/MainActivity.kt +75 -17
data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/MissingExtensionFragment.kt +105 -0
data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/WebFragment.kt +31 -4
data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/bridge/WebControlChannel.kt +6 -10
data/support/mobile/android/app/src/main/res/layout/everywhere_error.xml +60 -0
data/support/mobile/android/app/src/main/res/values/strings.xml +19 -0
data/support/mobile/ios/App/ErrorViewController.swift +21 -3
data/support/mobile/ios/App/SceneDelegate.swift +12 -1
data/support/mobile/ios/App.xcodeproj/project.pbxproj +0 -2
data/support/release/macos/notarize.sh +3 -0
metadata +26 -1

data/lib/everywhere/shell_pages.rb ADDED Viewed

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+module Everywhere
+  class << self
+    # The tiny page served at /everywhere/reset. Auth flows redirect the native
+    # app here so it resets cleanly (fresh web views, re-fetched tabs) before
+    # continuing — the standard Hotwire Native "reset the app" pattern. It talks
+    # to the shell's control channel directly (no bridge/importmap dependency);
+    # in a plain browser it just forwards to the target. `to` is constrained to
+    # a same-origin path.
+    #
+    # Both shells are addressed inline, and differently, for the same reason
+    # the bridge normalizes them: WKWebView's message handler takes an object,
+    # while Android's WebMessageListener channel takes a string. Reaching for
+    # the bridge here instead would trade that one line for an importmap
+    # dependency on a page whose whole job is to work before anything loads.
+    def mobile_reset_html(to)
+      require "json"
+      target = to.to_s
+      target = "/" unless target.start_with?("/") && !target.start_with?("//")
+      # script_safe, not to_json: this lands inside <script>, and outside Rails
+      # nothing escapes "</script>" in a plain JSON string.
+      encoded = JSON.generate(target, script_safe: true)
+      <<~HTML
+        <!DOCTYPE html><html><head><meta charset="utf-8"><title>One moment…</title>
+        <meta name="viewport" content="width=device-width,initial-scale=1"></head>
+        <body><script>
+        (function(){var to=#{encoded};var msg={action:"reset",to:to};
+        var ios=window.webkit&&window.webkit.messageHandlers&&window.webkit.messageHandlers.everywhereControl;
+        var android=window.everywhereControl;
+        if(ios){ios.postMessage(msg);}
+        else if(android&&android.postMessage){android.postMessage(JSON.stringify(msg));}
+        else{window.location.replace(to);}})();
+        </script></body></html>
+      HTML
+    end
+    # The page served at /everywhere/jump/leave — the way OUT of a Jump
+    # preview. Once Jump re-roots onto a previewed app (instance.set), every
+    # Jump surface — launcher, scanner, tabs — resolves against the previewed
+    # app, so the escape hatch has to be served by the previewed app itself:
+    # this gem is the one thing guaranteed to be there. Posts clearInstance on
+    # the shell's control channel; shells that aren't multi-instance ignore
+    # it, and a plain browser just goes home.
+    # Fires clearInstance only once VISIBLE. This page rides in the previewed
+    # app's tab bar; shells preload tabs eagerly, but a preloaded webview is
+    # offscreen and reports visibilityState "hidden" — firing on load would
+    # bounce every preview the instant it connects, and a tap on the tab
+    # never re-proposes a visit, so visibility flipping is the ONLY signal a
+    # tab tap gives the page. The button is a belt for browsers and any
+    # webview that lies about visibility.
+    def mobile_jump_leave_html
+      <<~HTML
+        <!DOCTYPE html><html><head><meta charset="utf-8"><title>Jump</title>
+        <meta name="viewport" content="width=device-width,initial-scale=1">
+        <style>
+          body{font-family:-apple-system,system-ui,sans-serif;margin:0;min-height:100vh;
+               display:flex;flex-direction:column;align-items:center;justify-content:center;
+               gap:12px;padding:24px;text-align:center;background:#fff;color:#171717}
+          @media(prefers-color-scheme:dark){body{background:#171717;color:#fafafa}}
+          p{margin:0;opacity:.6}
+          button{font:inherit;font-weight:600;font-size:18px;color:#fff;background:#dc2626;
+                 border:0;border-radius:12px;padding:16px 32px}
+        </style></head>
+        <body>
+        <p>Returning to Jump…</p>
+        <button onclick="everywhereJumpLeave()">Return to Jump</button>
+        <script>
+        function everywhereJumpLeave(){var msg={action:"clearInstance"};
+        var ios=window.webkit&&window.webkit.messageHandlers&&window.webkit.messageHandlers.everywhereControl;
+        var android=window.everywhereControl;
+        if(ios){ios.postMessage(msg);}
+        else if(android&&android.postMessage){android.postMessage(JSON.stringify(msg));}
+        else{window.location.replace("/");}}
+        if(document.visibilityState==="visible"){everywhereJumpLeave();}
+        else{document.addEventListener("visibilitychange",function(){
+          if(document.visibilityState==="visible"){everywhereJumpLeave();}});}
+        </script></body></html>
+      HTML
+    end
+    # The page served at /everywhere/auth/native. The shell normally diverts a
+    # provider path natively, before the request is ever made; this covers the
+    # visits it can't see — a `data-turbo="false"` link, or the POST OmniAuth 2
+    # requires — by asking the shell, from the page, to open the auth session.
+    # In a browser it just continues to the provider.
+    def mobile_auth_html(to)
+      require "json"
+      target = to.to_s
+      target = "/" unless target.start_with?("/") && !target.start_with?("//")
+      # script_safe, as in mobile_reset_html: `to` is request input.
+      encoded = JSON.generate(target, script_safe: true)
+      <<~HTML
+        <!DOCTYPE html><html><head><meta charset="utf-8"><title>Signing in…</title>
+        <meta name="viewport" content="width=device-width,initial-scale=1"></head>
+        <body><p>Opening secure sign-in…</p><script>
+        (function(){var to=#{encoded};var msg={action:"authFlow",to:to};
+        var ios=window.webkit&&window.webkit.messageHandlers&&window.webkit.messageHandlers.everywhereControl;
+        var android=window.everywhereControl;
+        if(ios){ios.postMessage(msg);}
+        else if(android&&android.postMessage){android.postMessage(JSON.stringify(msg));}
+        else{window.location.replace(to);}})();
+        </script></body></html>
+      HTML
+    end
+  end
+end

data/lib/everywhere/tab_filter.rb ADDED Viewed

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module Everywhere
+  class << self
+    # Register a per-request filter for the mobile tab bar. The block receives
+    # the resolved tab list (`[{ "title" =>, "path" =>, "icon" => }, …]`) and
+    # the current request, and returns the subset to show — return `[]` to hide
+    # the tab bar entirely (the shell falls back to single-screen navigation).
+    #
+    # It runs inside the mobile config endpoint, which shares the app's session
+    # and cookies, so it can branch on auth or any request state:
+    #
+    #   # config/initializers/everywhere.rb
+    #   Everywhere.filter_tabs do |tabs, request|
+    #     request.session[:user_id] ? tabs : []
+    #   end
+    #
+    # Live like the rest of the config: the shell re-reads it on launch and on
+    # every foreground, so a sign-in shows the tabs on next foreground — no
+    # rebuild, no app-store release.
+    def filter_tabs(&block)
+      @tabs_filter = block
+    end
+    # Apply the registered filter (identity when none is set). Always returns
+    # an Array so a stray nil/scalar from a block can't break serialization.
+    def resolve_tabs(tabs, request)
+      return tabs unless @tabs_filter
+      Array(@tabs_filter.call(tabs, request))
+    end
+    # Test/reset hook.
+    attr_writer :tabs_filter
+  end
+end

data/lib/everywhere/task_pool.rb CHANGED Viewed

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
+require_relative "clock"
 require_relative "console"
 require_relative "child_processes"
@@ -78,8 +79,8 @@ module Everywhere
       return if live.empty?
       live.each { |thread| ChildProcesses.terminate(thread, grace: grace) }
-      deadline = now + grace
-      live.each { |thread| thread.join([deadline - now, 0].max) }
+      deadline = Clock.monotonic + grace
+      live.each { |thread| thread.join([deadline - Clock.monotonic, 0].max) }
       live.select(&:alive?).each(&:kill)
       Console.multiplexed = false
     end
@@ -117,7 +118,5 @@ module Everywhere
       live = @threads.each_value.count { |t| t.alive? && t != Thread.current }
       Console.multiplexed = live > 1
     end
-    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 end

data/lib/everywhere/ui.rb CHANGED Viewed

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
+require_relative "clock"
 require_relative "fatal"
 require_relative "console"
@@ -164,7 +165,7 @@ module Everywhere
       private
       def headless(text)
-        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        now = Clock.monotonic
         return if @last_headless && (now - @last_headless) < HEADLESS_INTERVAL
         @last_headless = now
@@ -217,5 +218,9 @@ module Everywhere
       s = s.gsub("#{home}/", "~/") if home && !home.empty?
       s
     end
+    # short_path for a path we know the root of: drop the project root (or the
+    # cwd, when the command runs from somewhere else) before shortening.
+    def rel_path(path, root) = short_path(path.to_s.sub("#{root}/", "").sub("#{Dir.pwd}/", ""))
   end
 end

data/lib/everywhere/version.rb CHANGED Viewed

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
+require "json"
 module Everywhere
-  VERSION = "0.7.0"
+  VERSION = "0.9.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,
   # vendored to public/ for Sinatra/Hanami), so its package.json is the single
   # source of truth. The build receipt records it; it versions independently
   # of the CLI.
-  BRIDGE_VERSION = File.read(
-    File.expand_path("../../bridge/package.json", __dir__)
-  )[/"version":\s*"([^"]+)"/, 1]
+  BRIDGE_VERSION = JSON.parse(
+    File.read(File.expand_path("../../bridge/package.json", __dir__))
+  )["version"]
 end

data/lib/everywhere.rb CHANGED Viewed

@@ -3,6 +3,7 @@
 # Runtime entry point: what an app gets from `require "ruby_everywhere"`.
 # The CLI lives in everywhere/cli and is only loaded by the every/rbe executables.
 require_relative "everywhere/version"
+require_relative "everywhere/error"
 require_relative "everywhere/config"
 require_relative "everywhere/framework"
 require_relative "everywhere/database"
@@ -12,8 +13,6 @@ require_relative "everywhere/boot"
 require_relative "everywhere/engine" if defined?(::Rails::Engine)
 module Everywhere
-  class Error < StandardError; end
   # App-facing runtime configuration. Apps register overrides at load time:
   #
   #   # config/initializers/everywhere.rb (Rails) or anywhere loaded by config.ru

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/EverywhereApplication.kt CHANGED Viewed

@@ -2,6 +2,8 @@ package com.rubyeverywhere.shell
 import android.app.Application
 import android.webkit.CookieManager
+import android.webkit.WebSettings
+import android.widget.Toast
 import androidx.core.net.toUri
 import com.rubyeverywhere.shell.bridge.BiometricsComponent
 import com.rubyeverywhere.shell.bridge.HapticsComponent
@@ -20,6 +22,7 @@ import dev.hotwire.core.turbo.visit.VisitProposal
 import dev.hotwire.core.turbo.webview.HotwireWebView
 import dev.hotwire.navigation.activities.HotwireActivity
 import dev.hotwire.navigation.config.defaultFragmentDestination
+import dev.hotwire.navigation.destinations.HotwireDestinationDeepLink
 import dev.hotwire.navigation.config.registerBridgeComponents
 import dev.hotwire.navigation.config.registerFragmentDestinations
 import dev.hotwire.navigation.config.registerRouteDecisionHandlers
@@ -55,12 +58,22 @@ class EverywhereApplication : Application() {
         Hotwire.defaultFragmentDestination = WebFragment::class
-        Hotwire.registerFragmentDestinations(
+        val fragmentDestinations = listOf(
             WebFragment::class,
             WebBottomSheetFragment::class,
-            // App-provided native screens (everywhere.yml native.android.screens).
-            *EverywhereExtensions.fragmentDestinations.toTypedArray()
-        )
+            // Where a rule's fallback_uri lands when its primary uri names a
+            // Fragment this build doesn't contain (previewing another app).
+            MissingExtensionFragment::class
+        ) + EverywhereExtensions.fragmentDestinations // everywhere.yml native.android.screens
+        Hotwire.registerFragmentDestinations(*fragmentDestinations.toTypedArray())
+        // Every uri those destinations answer to, read from the same
+        // annotation Hotwire itself matches against — handed to the
+        // missing-screen guard below so it can tell a resolvable rule from
+        // one that would go nowhere.
+        val registeredUris = fragmentDestinations
+            .mapNotNull { it.java.getAnnotation(HotwireDestinationDeepLink::class.java)?.uri }
+            .toSet()
         Hotwire.registerBridgeComponents(
             BridgeComponentFactory("everywhere--notification", ::NotificationComponent),
@@ -78,6 +91,7 @@ class EverywhereApplication : Application() {
         Hotwire.registerRouteDecisionHandlers(
             ResetRouteDecisionHandler(),
             AuthFlowRouteDecisionHandler(),
+            MissingScreenRouteDecisionHandler(registeredUris),
             AppNavigationRouteDecisionHandler(),
             BrowserTabRouteDecisionHandler(),
             SystemNavigationRouteDecisionHandler()
@@ -99,6 +113,16 @@ class EverywhereApplication : Application() {
         Hotwire.config.makeCustomWebView = { context ->
             HotwireWebView(context, null).also { webView ->
                 WebControlChannel.install(webView, config.webConfigJson)
+                // Instance apps pair with LAN-hosted previews: the picker page
+                // is https but the app it probes is plain http, which WebView
+                // blocks as mixed content — and then the picker reports a live
+                // preview as "not answering". Scoped to remote.instances so
+                // ordinary apps keep the strict default. The main-frame http
+                // load itself is governed by network_security_config.xml,
+                // which `every build` opens up under the same flag.
+                if (config.remoteInstances) {
+                    webView.settings.mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
+                }
             }
         }
     }
@@ -154,6 +178,43 @@ private class ResetRouteDecisionHandler : Router.RouteDecisionHandler {
     }
 }
+/**
+ * The last line of defence for a native-screen rule this build can't serve.
+ *
+ * A previewed app on a current gem serves `fallback_uri` pointing at
+ * [MissingExtensionFragment], and the visit lands there — this handler never
+ * matches. An app on an older gem serves only `uri: hotwire://fragment/<id>`,
+ * and Hotwire's answer to a uri no registered destination claims is to do
+ * nothing at all — which reads as a spinner that never ends. Refuse the visit
+ * loudly instead: a toast naming the screen, and the user stays on the page
+ * they tapped from.
+ */
+private class MissingScreenRouteDecisionHandler(
+    private val registeredUris: Set<String>
+) : Router.RouteDecisionHandler {
+    override val name = "everywhere-missing-screen"
+    override fun matches(proposal: VisitProposal, configuration: NavigatorConfiguration): Boolean {
+        val uri = proposal.properties["uri"]?.toString() ?: return false
+        val fallback = proposal.properties["fallback_uri"]?.toString()
+        return uri !in registeredUris && (fallback == null || fallback !in registeredUris)
+    }
+    override fun handle(
+        proposal: VisitProposal,
+        configuration: NavigatorConfiguration,
+        activity: HotwireActivity
+    ): Router.Decision {
+        val identifier = proposal.properties["view_controller"]?.toString() ?: "native"
+        Toast.makeText(
+            activity,
+            activity.getString(R.string.everywhere_missing_screen_toast, identifier),
+            Toast.LENGTH_LONG
+        ).show()
+        return Router.Decision.CANCEL
+    }
+}
 /**
  * A provider sign-in: hand it to a Custom Tab instead of loading it in the web
  * view. Cancelling leaves the user on the page they tapped from, which is where

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/EverywhereConfig.kt CHANGED Viewed

@@ -189,6 +189,27 @@ class EverywhereConfig private constructor(
             return if (path.isNullOrEmpty() || path == "/") rootUrl else url(forPath = path)
         }
+    /**
+     * Every origin the shell's own pages can be served from: the stamped
+     * root, the dev override, and a picked instance. The control channel is
+     * offered to all of them, not just the current [rootUrl] — while rooted
+     * on an instance, the picker's pages still come from the stamped origin,
+     * and without the channel there they could switch in but never switch
+     * again (`Everywhere.instance.*` would fall back to a plain navigation).
+     */
+    val trustedRootOrigins: Set<String>
+        get() = listOfNotNull(stampedRemoteUrl, devUrl, instanceUrl)
+            .mapNotNull(::originOf)
+            .toSet()
+    private fun originOf(url: String): String? {
+        val uri = url.toUri()
+        val scheme = uri.scheme ?: return null
+        val host = uri.host ?: return null
+        val port = if (uri.port > 0) ":${uri.port}" else ""
+        return "$scheme://$host$port"
+    }
     /**
      * The server half of the path configuration (rules + settings.tabs),
      * generated from everywhere.yml by the gem's MobileConfigEndpoint — so tab

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/MainActivity.kt CHANGED Viewed

@@ -140,7 +140,16 @@ class MainActivity : HotwireActivity() {
         // Swap to the real theme before the content view inflates.
         setTheme(R.style.Theme_Everywhere)
         enableEdgeToEdge()
-        super.onCreate(savedInstanceState)
+        // A rebuild ([rebuildAndRoute]: reset, sign-in/out, instance switch)
+        // arrives with EXTRA_ROUTE on the Intent and must start from scratch:
+        // handing the saved state to super restores every navigator's back
+        // stack, climbing the page the user just left back on top of the new
+        // root. Dropped here, the recreate behaves like a fresh launch — while
+        // a real config change or process death (no EXTRA_ROUTE) restores
+        // normally.
+        val state = if (intent.hasExtra(EXTRA_ROUTE)) null else savedInstanceState
+        super.onCreate(state)
         setContentView(R.layout.activity_main)
         findViewById<View>(R.id.root).applyDefaultImeWindowInsets()
@@ -148,7 +157,7 @@ class MainActivity : HotwireActivity() {
         splash = findViewById(R.id.splash)
         showSplash()
-        initializeTabs(savedInstanceState?.getInt(STATE_SELECTED_TAB) ?: 0)
+        initializeTabs(state?.getInt(STATE_SELECTED_TAB) ?: 0)
         observeEvents()
         observePathConfiguration()
@@ -220,7 +229,14 @@ class MainActivity : HotwireActivity() {
         pendingRoute = null
         pendingRouteHostId = null
-        navigator.route(route)
+        // Post, don't call: this callback fires from onAttachFragment while
+        // the host's start fragment is still mid-transaction — no view, no
+        // web delegate — and routing into it synchronously crashes Hotwire
+        // ("lateinit property webDelegate has not been initialized"). One
+        // trip through the main queue lets the transaction finish first.
+        window.decorView.post {
+            if (!isFinishing && !isDestroyed) navigator.route(route)
+        }
     }
     // ------------------------------------------------------------------------
@@ -380,19 +396,32 @@ class MainActivity : HotwireActivity() {
      * handling selection would make More a one-shot.
      */
     private fun installTabListeners(arrangement: MainTabs.Arrangement) {
-        if (!arrangement.hasMore) return
+        val hasLeaveSlot = arrangement.slots.any { isLeaveTab(it.entry?.path) }
+        if (!arrangement.hasMore && !hasLeaveSlot) return
         bottomNav.setOnItemSelectedListener { item ->
             val index = item.itemId
-            // selectingMoreForRoute is the one case where selecting More IS the
-            // intent: something routed to an overflow path and the host has to
-            // come forward to receive it.
-            if (arrangement.isMoreIndex(index) && !selectingMoreForRoute) {
-                showMoreSheet(arrangement)
-                false
-            } else {
-                switchToSlot(index)
-                true
+            when {
+                // The Jump leave tab is a native action, exactly as on iOS
+                // (EverywhereTabBarController): the page behind it is a
+                // gem-served Turbo-less fallback, so selecting its host could
+                // only end at the error view. The tap clears the picked
+                // instance directly and never becomes a selection.
+                isLeaveTab(arrangement.entryAt(index)?.path) -> {
+                    leaveInstance()
+                    false
+                }
+                // selectingMoreForRoute is the one case where selecting More IS
+                // the intent: something routed to an overflow path and the host
+                // has to come forward to receive it.
+                arrangement.isMoreIndex(index) && !selectingMoreForRoute -> {
+                    showMoreSheet(arrangement)
+                    false
+                }
+                else -> {
+                    switchToSlot(index)
+                    true
+                }
             }
         }
@@ -408,6 +437,19 @@ class MainActivity : HotwireActivity() {
         }
     }
+    /**
+     * The injected "leave preview" tab (a Jump instance's way home), matched
+     * by its gem-reserved path. Only meaningful for instance apps — for
+     * everyone else no such tab is ever injected, and the guard keeps an
+     * unlucky app path from being swallowed.
+     */
+    private fun isLeaveTab(path: String?): Boolean =
+        config.remoteInstances && path == JUMP_LEAVE_PATH
+    private fun leaveInstance() {
+        EverywhereEvents.emit(EverywhereEvents.Event.ClearInstance(null))
+    }
     /**
      * Bring a slot's host forward — upstream `HotwireBottomNavigationController`'s
      * private `switchTab`, which taking over the item-selected listener costs us.
@@ -466,7 +508,11 @@ class MainActivity : HotwireActivity() {
             row.setOnClickListener {
                 dialog.dismiss()
-                route(config.url(forPath = entry.path))
+                // The leave row is the same native action as a leave SLOT —
+                // see installTabListeners; routing it would load the
+                // Turbo-less fallback page and end at the error view.
+                if (isLeaveTab(entry.path)) leaveInstance()
+                else route(config.url(forPath = entry.path))
             }
             list.addView(row)
         }
@@ -777,9 +823,17 @@ class MainActivity : HotwireActivity() {
     }
     /**
-     * `recreate()` loses every field, so the landing page rides along on the
-     * Intent — which `recreate()` does preserve — and is picked up by the next
-     * `onCreate`.
+     * `recreate()` for an in-place rebuild — a CLEAR_TASK relaunch tears the
+     * task down first, which plays as the app closing and cold-starting on
+     * every reset (sign-in, sign-out, instance switch). recreate() keeps the
+     * window; the landing page rides along on the Intent, which recreate()
+     * preserves while fields are lost.
+     *
+     * The saved instance state, however, must NOT come back: it carries every
+     * navigator's back stack, and restoring it climbs the page the user just
+     * left (Jump's connect screen, a pre-sign-in page) right back on top of
+     * the new root. `onCreate` treats the presence of [EXTRA_ROUTE] as the
+     * fresh-start flag and drops the state — see the top of [onCreate].
      */
     private fun rebuildAndRoute(target: String) {
         AuthFlow.cancel()
@@ -956,6 +1010,10 @@ class MainActivity : HotwireActivity() {
         const val EXTRA_ROUTE = "everywhere.route"
         const val EXTRA_LAST_REBUILD = "everywhere.lastRebuild"
+        /** The injected leave tab's path — same constant iOS keeps on
+         *  EverywhereTabBarController.jumpLeavePath. */
+        const val JUMP_LEAVE_PATH = "/everywhere/jump/leave"
         /**
          * How close two path-change rebuilds have to be before the second is
          * treated as a loop rather than a legitimate config change. Generous

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/MissingExtensionFragment.kt ADDED Viewed

@@ -0,0 +1,105 @@
+package com.rubyeverywhere.shell
+import android.graphics.drawable.Drawable
+import android.os.Bundle
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.appcompat.widget.Toolbar
+import androidx.core.graphics.drawable.DrawableCompat
+import com.google.android.material.appbar.AppBarLayout
+import dev.hotwire.navigation.destinations.HotwireDestinationDeepLink
+import dev.hotwire.navigation.fragments.HotwireFragment
+/**
+ * The per-rule fallback destination for native screens this build doesn't
+ * contain — the Android half of iOS's `MissingExtensionScreen`.
+ *
+ * The gem writes `fallback_uri: hotwire://fragment/everywhere-missing` next to
+ * every derived screen `uri` (see the gem's Config::Mobile), so when a
+ * Jump-style shell previews an app whose rules name Fragments compiled into
+ * THAT app's build, the visit lands here and says so — instead of Hotwire
+ * finding no destination and leaving the user on a spinner forever. An app's
+ * own build resolves the primary uri and never consults the fallback.
+ */
+@HotwireDestinationDeepLink(uri = "hotwire://fragment/everywhere-missing")
+class MissingExtensionFragment : HotwireFragment() {
+    private lateinit var toolbar: Toolbar
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        val context = requireContext()
+        // The rule that routed here still carries the screen's identifier.
+        val identifier = pathProperties["view_controller"]?.toString() ?: "native"
+        toolbar = Toolbar(context).apply {
+            title = getString(R.string.everywhere_missing_screen_nav_title)
+        }
+        val appBar = AppBarLayout(context).apply {
+            fitsSystemWindows = true
+            addView(toolbar, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+        }
+        val secondary = TypedValue().let {
+            context.theme.resolveAttribute(android.R.attr.textColorSecondary, it, true)
+            requireNotNull(context.getColorStateList(it.resourceId)).defaultColor
+        }
+        val icon = ImageView(context).apply {
+            setImageDrawable(tinted(IconFont.drawable(context, "extension", dp(44)), secondary))
+        }
+        val title = TextView(context).apply {
+            text = getString(R.string.everywhere_missing_screen_title)
+            textSize = 20f
+            setTypeface(typeface, android.graphics.Typeface.BOLD)
+            gravity = Gravity.CENTER
+        }
+        val body = TextView(context).apply {
+            text = getString(R.string.everywhere_missing_screen_body, identifier)
+            textSize = 15f
+            setTextColor(secondary)
+            gravity = Gravity.CENTER
+        }
+        val column = LinearLayout(context).apply {
+            orientation = LinearLayout.VERTICAL
+            gravity = Gravity.CENTER_HORIZONTAL
+            setPadding(dp(32), 0, dp(32), 0)
+            addView(icon)
+            addView(title, spaced(dp(14)))
+            addView(body, spaced(dp(14)))
+        }
+        val content = FrameLayout(context).apply {
+            addView(column, FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT,
+                Gravity.CENTER
+            ))
+        }
+        return LinearLayout(context).apply {
+            orientation = LinearLayout.VERTICAL
+            addView(appBar, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+            addView(content, LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 0, 1f))
+        }
+    }
+    override fun toolbarForNavigation(): Toolbar = toolbar
+    private fun tinted(drawable: Drawable, color: Int): Drawable =
+        DrawableCompat.wrap(drawable).mutate().also { DrawableCompat.setTint(it, color) }
+    private fun spaced(marginTop: Int) = LinearLayout.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT
+    ).apply { topMargin = marginTop }
+    private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt()
+}