craft-native 0.0.241 → 0.0.243

package/dist/android/src/index.d.ts

@@ -5,6 +5,12 @@
  */
 import { type AndroidMapProvider } from './native-map.js';
 export type { AndroidMapProvider } from './native-map.js';
+/**
+ * The builder installs a directory of route bundles (stx's `routesDir`) as
+ * well as the one-file bundle, and the app runs each screen from its own
+ * route's file. Stacks asks for route bundles only when this is true.
+ */
+export declare const nativeRouteBundles = true;
 /** Providers this published builder can generate as real Android map views. */
 export declare const nativeMapProviders: readonly ['google', 'maplibre'];
 export { runKotlinFixture } from './testing.js';

package/dist/android/src/index.js

@@ -357,6 +357,7 @@ async function createAndroidEmulator(options) {
 }
 
 // ../android/src/index.ts
+var nativeRouteBundles = true;
 var nativeMapProviders = ["google", "maplibre"];
 function syncNativeFonts(fonts, output) {
   const destination = join3(output, "app/src/main/assets/NativeFonts");
@@ -1243,15 +1244,29 @@ async function build(options) {
     if (htmlPath || devServer)
       throw new Error("A native Android screen cannot use --html-path or --dev-server.");
     const destination = join3(output, "app/src/main/assets/native-screen.js");
-    if (nativeBundlePath && resolve2(nativeBundlePath) !== resolve2(destination))
-      cpSync(nativeBundlePath, destination);
+    const routeDestination = join3(output, "app/src/main/assets/native-screens");
+    if (nativeBundlePath) {
+      if (!existsSync(nativeBundlePath))
+        throw new Error(`Native bundle not found: ${nativeBundlePath}`);
+      if (statSync(nativeBundlePath).isDirectory()) {
+        if (resolve2(nativeBundlePath) !== resolve2(routeDestination)) {
+          rmSync2(routeDestination, { recursive: true, force: true });
+          cpSync(nativeBundlePath, routeDestination, { recursive: true });
+        }
+        rmSync2(destination, { force: true });
+      } else {
+        if (resolve2(nativeBundlePath) !== resolve2(destination))
+          cpSync(nativeBundlePath, destination);
+        rmSync2(routeDestination, { recursive: true, force: true });
+      }
+    }
     const icons = join3(output, "app/src/main/assets/craft-icons.json");
     if (options.iconsPath) {
       requireRegularFile(options.iconsPath, "Icon table");
       if (resolve2(options.iconsPath) !== resolve2(icons))
         cpSync(options.iconsPath, icons);
     }
-    if (!existsSync(destination)) {
+    if (!existsSync(destination) && !existsSync(routeDestination)) {
       throw new Error("Native Android mode needs app/src/main/assets/native-screen.js. Compile a .stx screen with `stx native compile` first.");
     }
   } else if (nativeBundlePath) {
@@ -1362,6 +1377,7 @@ export {
   renderAndroidPermissions,
   renderAndroidDeepLinks,
   open,
+  nativeRouteBundles,
   nativeMapProviders,
   installRuntime,
   init,

package/dist/android/templates/CraftNativeBackground.kt.template

@@ -56,6 +56,33 @@ internal object CraftNativeSandbox {
     }
 }
 
+/**
+ * The native screens' JavaScript: a route's own file when stx wrote one
+ * (`native-screens/<route>.js`, its `routesDir`), else the one-file
+ * `native-screen.js`. An isolate evaluates all it is given, so a route file
+ * spares each screen parsing (and sending the sandbox) every other screen.
+ * Read once and kept while memory allows.
+ */
+internal object CraftNativeBundle {
+    private val sources = object : android.util.LruCache<String, String>(24 shl 20) {
+        override fun sizeOf(key: String, value: String) = value.length
+    }
+
+    private fun read(context: Context, asset: String): String? = sources.get(asset)
+        ?: runCatching { context.assets.open(asset).bufferedReader().use { it.readText() } }.getOrNull()?.also { sources.put(asset, it) }
+
+    fun source(context: Context, route: String?): String? {
+        if (!route.isNullOrBlank() && !route.contains('/') && !route.startsWith('.')) {
+            read(context, "native-screens/$route.js")?.let { return it }
+        }
+        return read(context, "native-screen.js")
+    }
+
+    fun isAvailable(context: Context): Boolean =
+        runCatching { context.assets.open("native-screen.js").close(); true }.getOrDefault(false)
+            || (context.assets.list("native-screens")?.isNotEmpty() == true)
+}
+
 /**
  * Background refresh, as iOS's BGAppRefreshTask gives it: WorkManager wakes
  * the app every `backgroundRefresh.minimumIntervalMinutes` (15 at the
@@ -153,8 +180,7 @@ internal class CraftNativeHeadlessApp(
     fun start() {
         val route = config.optString("nativeApp")
         if (route.isBlank() || !JavaScriptSandbox.isSupported()) return finish(true)
-        val bundle = runCatching { context.assets.open("native-screen.js").bufferedReader().use { it.readText() } }.getOrNull()
-            ?: return finish(true)
+        val bundle = CraftNativeBundle.source(context, route) ?: return finish(true)
         CraftNativeSandbox.connect(context) { engine, error ->
             if (closed) return@connect
             if (engine == null || !engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_CONSOLE_MESSAGING)) {

package/dist/android/templates/MainActivityNative.kt.template

@@ -3683,7 +3683,6 @@ class MainActivity : AppCompatActivity() {
     private val backgroundWaiters = mutableMapOf<String, (Boolean) -> Unit>()
     /** A tapped notification that opened the app, for the app script once it runs. */
     private var pendingNotificationTap: JSONObject? = null
-    private var bundle = ""
     private lateinit var config: JSONObject
     private lateinit var capabilities: CraftNativeCapabilities
     private val capabilityHandler = Handler(Looper.getMainLooper())
@@ -3794,9 +3793,7 @@ class MainActivity : AppCompatActivity() {
         for (index in 0 until schemes.length()) urlSchemes.add(schemes.optString(index).lowercase())
         if (!routes.isEmpty) installChrome()
         refreshThemeDefaults()
-        bundle = runCatching {
-            assets.open("native-screen.js").bufferedReader().use { it.readText() }
-        }.getOrElse {
+        if (!CraftNativeBundle.isAvailable(this)) {
             showError("Missing native-screen.js. Build with --native-bundle after compiling STX.")
             return
         }
@@ -4362,7 +4359,12 @@ class MainActivity : AppCompatActivity() {
             if (!activeScreen.active) return@addListener
             try {
                 setup.get()
-                val load = isolate.evaluateJavaScriptAsync(bundle)
+                val source = CraftNativeBundle.source(this, route)
+                if (source == null) {
+                    if (activeScreen.active) showError("Missing native-screen.js. Build with --native-bundle after compiling STX.")
+                    return@addListener
+                }
+                val load = isolate.evaluateJavaScriptAsync(source)
                 load.addListener({
                     try {
                         load.get()

package/dist/cli.js

@@ -3424,7 +3424,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.241";
+var version = "0.0.243";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -310,7 +310,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.241";
+var version = "0.0.243";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -57,7 +57,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.241";
+var version = "0.0.243";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/src/index.d.ts

@@ -223,7 +223,12 @@ export interface CraftConfig {
      * opens in the in-app browser on the app's site.
      */
     nativeScreens?: Record<string, string>;
-    /** The bundle `stx native compile --format bundle` wrote, copied to `dist/native-screen.js`. */
+    /**
+     * The bundle `stx native compile --format bundle` wrote, copied to
+     * `dist/native-screen.js`; or a directory of route bundles (stx's
+     * `routesDir`: `<Screen>.js` and `__app.js`), copied to
+     * `dist/native-screens/`, so each screen evaluates only its own file.
+     */
     nativeBundle?: string;
     /**
      * The bundle route of a screen-less script that runs once for the app's
@@ -307,6 +312,12 @@ export declare function usesNativeBundle(config: Pick<CraftConfig, 'renderer' |
 export declare function nativeStartPath(config: Pick<CraftConfig, 'devServerURL'>): string;
 /** What is wrong with a config's hybrid and tab settings, one sentence each. */
 export declare function hybridConfigProblems(config: Pick<CraftConfig, 'renderer' | 'nativeScreens' | 'tabs' | 'shareStorage' | 'devServerURL' | 'nativeApp'>): string[];
+/**
+ * The builder installs a directory of route bundles (stx's `routesDir`) as
+ * well as the one-file bundle, and the app runs each screen from its own
+ * route's file. Stacks asks for route bundles only when this is true.
+ */
+export declare const nativeRouteBundles = true;
 export interface CraftBackgroundRefresh {
     enabled: boolean;
     /** The BGTaskScheduler identifier. Default `<bundleId>.refresh`. */

package/dist/ios/src/index.js

@@ -484,13 +484,29 @@ function hybridConfigProblems(config) {
   }
   return problems;
 }
+var nativeRouteBundles = true;
 function installNativeBundle(source, output) {
   if (!existsSync(source))
     throw new Error(`Native bundle not found: ${source}`);
-  const destination = join3(output, "dist", "native-screen.js");
-  mkdirSync2(dirname2(destination), { recursive: true });
-  if (resolve(source) !== resolve(destination))
-    cpSync(source, destination);
+  const single = join3(output, "dist", "native-screen.js");
+  const routes = join3(output, "dist", "native-screens");
+  mkdirSync2(dirname2(single), { recursive: true });
+  if (statSync(source).isDirectory()) {
+    if (!readdirSync2(source).some((name) => name.endsWith(".js")))
+      throw new Error(`Native route bundles not found in ${source}`);
+    if (resolve(source) !== resolve(routes)) {
+      rmSync2(routes, { recursive: true, force: true });
+      cpSync(source, routes, { recursive: true });
+    }
+    rmSync2(single, { force: true });
+    return;
+  }
+  if (resolve(source) !== resolve(single))
+    cpSync(source, single);
+  rmSync2(routes, { recursive: true, force: true });
+}
+function hasInstalledNativeBundle(output) {
+  return existsSync(join3(output, "dist", "native-screen.js")) || existsSync(join3(output, "dist", "native-screens"));
 }
 var DEFAULT_CONFIG = {
   renderer: "web",
@@ -1353,7 +1369,7 @@ async function build(options) {
     const bundle = nativeBundlePath ?? config.nativeBundle;
     if (bundle)
       installNativeBundle(bundle, output);
-    if (!existsSync(join3(output, "dist", "native-screen.js"))) {
+    if (!hasInstalledNativeBundle(output)) {
       throw new Error("Native iOS mode needs dist/native-screen.js. Compile a .stx screen with `stx native compile` first.");
     }
   } else if (nativeBundlePath && !isHybrid(config)) {
@@ -1378,8 +1394,8 @@ async function build(options) {
     const bundle = nativeBundlePath ?? config.nativeBundle;
     if (bundle) {
       installNativeBundle(bundle, output);
-      console.log(`   Native screens: ${bundle} \u2192 dist/native-screen.js`);
-    } else if (!existsSync(join3(output, "dist", "native-screen.js"))) {
+      console.log(`   Native screens: ${bundle} \u2192 ${statSync(bundle).isDirectory() ? "dist/native-screens/" : "dist/native-screen.js"}`);
+    } else if (!hasInstalledNativeBundle(output)) {
       console.warn("   \u26A0 nativeScreens is set but there is no native bundle: every path opens in the web view.");
     }
   }
@@ -1552,6 +1568,7 @@ export {
   open,
   normalizeNativePath,
   nativeStartPath,
+  nativeRouteBundles,
   matchNativePath,
   isHybrid,
   installRuntime,

package/dist/ios/templates/CraftApp.swift

@@ -251,6 +251,17 @@ final class CraftAppDelegate: NSObject, UIApplicationDelegate, UNUserNotificatio
         CraftEventManager.shared.sendToWeb("craftSilentPush", data: ["id": id, "payload": CraftEventManager.pageData(userInfo)])
     }
 
+    /// iOS relaunched the app because `craft.media.keep`'s background
+    /// transfers finished (CraftNativeMediaTransfers): their session takes
+    /// the events, stores the files, then says it is done.
+    func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
+        guard identifier == CraftNativeMediaTransfers.identifier else {
+            completionHandler()
+            return
+        }
+        CraftNativeMediaTransfers.shared.backgroundCompletion = completionHandler
+    }
+
     func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
         let token = deviceToken.map { String(format: "%02x", $0) }.joined()
         NotificationCenter.default.post(name: .craftPushToken, object: token)
@@ -679,6 +690,9 @@ final class CraftChrome: ObservableObject {
     private var splashDeadline: DispatchWorkItem?
     private var tabSwipePrevious: String?
     private var tabSwipeTarget: String?
+    /// One generator for every tab change. A new one per tick started the
+    /// Taptic Engine cold each time, on the main thread, late.
+    private let selectionFeedback = UISelectionFeedbackGenerator()
     /// The keyboard is up and covers the tab bar, so the page need not leave
     /// room for it: the web view ends at the keyboard (CraftHybrid's webHost).
     private var keyboardUp = false
@@ -866,7 +880,7 @@ final class CraftChrome: ObservableObject {
     func swipe(to id: String) {
         guard id != selected, tabs.contains(where: { $0.id == id }) else { return }
         withAnimation(Self.motion(.spring(response: 0.32, dampingFraction: 0.86))) { selected = id }
-        UISelectionFeedbackGenerator().selectionChanged()
+        selectionFeedback.selectionChanged()
         guard CraftHybrid.shared.tabTapped(id, reselect: false) else { return }
         emit("craftTabSelect", ["id": id])
     }
@@ -875,6 +889,9 @@ final class CraftChrome: ObservableObject {
     /// controller commits or restores this preview when the finger lifts.
     func beginTabSwipe(to id: String, from previous: String) {
         guard id != previous, tabs.contains(where: { $0.id == id }) else { return }
+        // The tick comes as the swipe commits; wake the Taptic Engine now, as
+        // UIFeedbackGenerator asks, so it is on time rather than late.
+        selectionFeedback.prepare()
         // A page's pending selection report may disagree with the native
         // stack. Cancellation belongs to the stack the finger left.
         tabSwipePrevious = previous
@@ -917,7 +934,7 @@ final class CraftChrome: ObservableObject {
         withAnimation(nil) { tabSwipePosition = nil }
         guard tabs.contains(where: { $0.id == id }) else { return }
         withAnimation(nil) { selected = id }
-        UISelectionFeedbackGenerator().selectionChanged()
+        selectionFeedback.selectionChanged()
         guard CraftHybrid.shared.tabTapped(id, reselect: false) else { return }
         emit("craftTabSelect", ["id": id])
     }
@@ -1183,9 +1200,20 @@ struct CraftTabBarView: View {
 
     /// The filled variant for the current tab, when the symbol has one.
     private func symbol(_ name: String, selected: Bool) -> String {
-        guard selected, !name.hasSuffix(".fill"), UIImage(systemName: "\(name).fill") != nil else { return name }
+        guard selected, !name.hasSuffix(".fill"), Self.hasFilledSymbol(name) else { return name }
         return "\(name).fill"
     }
+
+    /// Whether `<name>.fill` exists, asked of the symbol catalog once per
+    /// name: the bar's body runs again for every selection change and asked
+    /// it for every tab each time.
+    private static var filledSymbols: [String: Bool] = [:]
+    private static func hasFilledSymbol(_ name: String) -> Bool {
+        if let known = filledSymbols[name] { return known }
+        let exists = UIImage(systemName: "\(name).fill") != nil
+        filledSymbols[name] = exists
+        return exists
+    }
 }
 
 private struct CraftTabSelectionIndicator: View {
@@ -1267,13 +1295,14 @@ class DeepLinkManager {
     // Every link that arrived while no page could receive it, in order. This
     // was a single slot, so a second link before the bridge was ready replaced
     // the first; on a cold start, that could be the link that launched the app.
-    private var pendingURLs: [URL] = []
+    private var pendingURLs: [(url: URL, initial: Bool)] = []
+    private var replayingNativeLinks = false
     private weak var webView: WKWebView?
     private var isReady = false
     // Replay bookkeeping only. A native screen can become ready before UIKit
     // delivers the launch URL; listener readiness cannot classify that URL.
     private var hasBeenReady = false
-    private var nativeListeners: [UUID: (URL, Bool) -> Void] = [:]
+    private var nativeListeners: [UUID: (canReceive: () -> Bool, receive: (URL, Bool) -> Void)] = [:]
 
     private init() {
         for name in [UIApplication.didBecomeActiveNotification, UIApplication.didEnterBackgroundNotification] {
@@ -1297,12 +1326,11 @@ class DeepLinkManager {
 
     func setReady() {
         isReady = true
-        let firstPage = !hasBeenReady
         hasBeenReady = true
         let urls = pendingURLs
         pendingURLs.removeAll()
-        for url in urls {
-            dispatchDeepLink(url, initial: firstPage && url == initialURL)
+        for link in urls {
+            dispatchDeepLink(link.url, initial: link.initial)
         }
     }
 
@@ -1316,21 +1344,21 @@ class DeepLinkManager {
             if CraftHybrid.shared.handleDeepLink(url) {
                 dispatchNative(url, initial: false)
             } else if !CraftHybrid.shared.hasWeb {
-                if nativeListeners.isEmpty { pendingURLs.append(url) } else { dispatchNative(url, initial: false) }
+                enqueueNative(url)
             } else if isReady && webView != nil {
                 dispatchDeepLink(url, initial: false)
             } else {
-                pendingURLs.append(url)
+                pendingURLs.append((url, !hasBeenReady && url == initialURL))
             }
             return
         }
 
         if !nativeListeners.isEmpty {
-            dispatchNative(url, initial: false)
+            enqueueNative(url)
         } else if isReady && webView != nil {
             dispatchDeepLink(url, initial: false)
         } else {
-            pendingURLs.append(url)
+            pendingURLs.append((url, !hasBeenReady && url == initialURL))
         }
     }
 
@@ -1350,20 +1378,14 @@ class DeepLinkManager {
     }
 
     @discardableResult
-    func addNativeListener(_ listener: @escaping (URL, Bool) -> Void) -> UUID {
+    func addNativeListener(canReceive: @escaping () -> Bool = { true }, _ listener: @escaping (URL, Bool) -> Void) -> UUID {
         let token = UUID()
-        nativeListeners[token] = listener
+        nativeListeners[token] = (canReceive, listener)
         // In a hybrid app the page is the one waiting for the links that
         // arrived early; a native screen hears only native ones, as they come.
         // An all-native app has no page, so its first screen hears them.
         if CraftHybrid.shared.isEnabled && CraftHybrid.shared.hasWeb { return token }
-        let firstNativeScreen = !hasBeenReady
-        hasBeenReady = true
-        let urls = pendingURLs
-        pendingURLs.removeAll()
-        for url in urls {
-            listener(url, firstNativeScreen && url == initialURL)
-        }
+        replayNativeLinks()
         return token
     }
 
@@ -1371,8 +1393,31 @@ class DeepLinkManager {
         nativeListeners.removeValue(forKey: token)
     }
 
+    private func enqueueNative(_ url: URL) {
+        pendingURLs.append((url, !hasBeenReady && url == initialURL))
+        replayNativeLinks()
+    }
+
+    /// Registration can happen while a controller is being prewarmed. Keep
+    /// links until a screen is visible, including across a tab switch.
+    func replayNativeLinks() {
+        guard !(CraftHybrid.shared.isEnabled && CraftHybrid.shared.hasWeb), !replayingNativeLinks else { return }
+        replayingNativeLinks = true
+        defer { replayingNativeLinks = false }
+        while let link = pendingURLs.first {
+            let receivers = nativeListeners.values.filter { $0.canReceive() }
+            guard !receivers.isEmpty else { return }
+            pendingURLs.removeFirst()
+            hasBeenReady = true
+            for receiver in receivers { receiver.receive(link.url, link.initial) }
+        }
+    }
+
     private func dispatchNative(_ url: URL, initial: Bool) {
-        for listener in nativeListeners.values { listener(url, initial) }
+        // The hybrid shell already opened this route; notify visible screens
+        // without queuing a second navigation for its future destination.
+        let receivers = nativeListeners.values.filter { $0.canReceive() }
+        for receiver in receivers { receiver.receive(url, initial) }
     }
 
     private func dispatchDeepLink(_ url: URL, initial: Bool) {