@rdlabo/ionic-theme-ios27 0.2.1 → 1.0.0

package/ios/Sources/IonicNativeUIShellPlugin/Components/ShellTabBar.swift

@@ -7,7 +7,18 @@ enum ShellTabBar {
         var isValid: Bool { [0, 0.5, 1].contains(x) && [0, 1].contains(y) }
     }
 
+    /// Optimistic tab selection until the Web selected state catches up (or times out).
+    struct PendingSelection: Equatable {
+        var id: String
+        var until: CFAbsoluteTime
+        static func start(_ id: String, ttl: CFTimeInterval = 1) -> PendingSelection {
+            PendingSelection(id: id, until: CFAbsoluteTimeGetCurrent() + ttl)
+        }
+    }
+
     static let kind = ShellComponent.tabBar
+    /// Tab bars waiting for an iOS 26 title-layout warmup after the next `fit`.
+    private static var pendingTitleWarmup = Set<ObjectIdentifier>()
 
     static func make(_ node: ShellControl, rendering: ShellRendering, delegate: UITabBarDelegate) -> UITabBar {
         let control = UITabBar()
@@ -31,8 +42,15 @@ enum ShellTabBar {
     }
 
     static func update(_ tabBar: UITabBar, node: ShellControl, rendering: ShellRendering) {
+        var pending: PendingSelection?
+        update(tabBar, node: node, rendering: rendering, pendingSelection: &pending)
+    }
+
+    static func update(_ tabBar: UITabBar, node: ShellControl, rendering: ShellRendering,
+                       pendingSelection: inout PendingSelection?) {
         let items = node.items
         let ids = items.map(\.id)
+        var needsTitleWarmup = false
         // Keep UIKit's item identities and interaction state across DOM selection updates.
         if tabBar.items?.map({ $0.accessibilityIdentifier ?? "" }) != ids {
             tabBar.items = items.map { item in
@@ -40,26 +58,54 @@ enum ShellTabBar {
                 tab.accessibilityIdentifier = item.id
                 return tab
             }
+            needsTitleWarmup = true
         }
         let nativeItems = tabBar.items ?? []
         for (tab, item) in zip(nativeItems, items) {
             let title = item.content.label
-            if tab.title != title { tab.title = title }
+            if tab.title != title {
+                tab.title = title
+                needsTitleWarmup = true
+            }
             let icon = rendering.image(item.content)
-            if tab.image !== icon { tab.image = icon }
+            if tab.image !== icon {
+                tab.image = icon
+                needsTitleWarmup = true
+            }
             if tab.selectedImage !== icon { tab.selectedImage = icon }
             tab.isEnabled = !item.content.disabled
             tab.accessibilityLabel = item.content.accessibilityLabel
-            applyTypography(item.content, to: tab)
+            if applyTypography(item.content, to: tab) { needsTitleWarmup = true }
             applyBadge(item.content.badge, to: tab, rendering: rendering)
         }
-        let selectedItem = zip(nativeItems, items).first { $0.1.content.selected }?.0
-        if tabBar.selectedItem !== selectedItem { tabBar.selectedItem = selectedItem }
+        let domSelected = zip(nativeItems, items).first { $0.1.content.selected }
+        let selectedItem = domSelected?.0
+        if let pending = pendingSelection {
+            let pendingItem = zip(nativeItems, items).first { $0.1.id == pending.id }
+            let expired = CFAbsoluteTimeGetCurrent() >= pending.until
+            let unavailable = pendingItem == nil || pendingItem!.1.content.disabled
+            if unavailable || expired {
+                // Ionic rejected the tap, the item vanished, or the echo timed out.
+                pendingSelection = nil
+                if tabBar.selectedItem !== selectedItem { tabBar.selectedItem = selectedItem }
+            } else if domSelected?.1.id == pending.id {
+                pendingSelection = nil
+                if tabBar.selectedItem !== selectedItem { tabBar.selectedItem = selectedItem }
+            } else if tabBar.selectedItem !== pendingItem!.0 {
+                // Keep the optimistic native selection until the Web selected state catches up.
+                tabBar.selectedItem = pendingItem!.0
+            }
+        } else if tabBar.selectedItem !== selectedItem {
+            tabBar.selectedItem = selectedItem
+        }
         tabBar.semanticContentAttribute = node.rtl ? .forceRightToLeft : .forceLeftToRight
         tabBar.accessibilityIdentifier = node.id
+        // Warm after `fit` settles geometry — not on every motion-driven frame sync.
+        if needsTitleWarmup { pendingTitleWarmup.insert(ObjectIdentifier(tabBar)) }
     }
 
-    static func applyTypography(_ content: ShellItemContent, to item: UITabBarItem) {
+    @discardableResult
+    static func applyTypography(_ content: ShellItemContent, to item: UITabBarItem) -> Bool {
         let weight: UIFont.Weight
         switch content.fontWeight {
         case ..<150: weight = .ultraLight
@@ -73,11 +119,14 @@ enum ShellTabBar {
         default: weight = .black
         }
         let font = UIFont.systemFont(ofSize: content.fontSize, weight: weight)
+        var changed = false
         for state in [UIControl.State.normal, .selected] {
             if item.titleTextAttributes(for: state)?[.font] as? UIFont != font {
                 item.setTitleTextAttributes([.font: font], for: state)
+                changed = true
             }
         }
+        return changed
     }
 
     static func applyBadge(_ badge: ShellBadge?, to item: UITabBarItem, rendering: ShellRendering) {
@@ -128,9 +177,31 @@ enum ShellTabBar {
         let center = CGPoint(x: bounds.minX + (bounds.width - content.width) * x - content.minX + size.width / 2,
                              y: bounds.minY + (bounds.height - content.height) * y - content.minY + size.height / 2)
         if tabBar.center != center { tabBar.center = center }
+        if pendingTitleWarmup.remove(ObjectIdentifier(tabBar)) != nil {
+            warmUnselectedTitleLayout(tabBar)
+        }
         return true
     }
 
+    /// iOS 26 only: programmatically visit each unselected item so UIKit measures
+    /// its title the same way a user tap would. Selection does not call the
+    /// tab-bar delegate. No-op on iOS 27+, where first paint already matches Web.
+    static func warmUnselectedTitleLayout(_ tabBar: UITabBar) {
+        let version = ProcessInfo.processInfo.operatingSystemVersion
+        guard version.majorVersion == 26, let items = tabBar.items, items.count > 1 else { return }
+        let selected = tabBar.selectedItem
+        UIView.performWithoutAnimation {
+            for item in items where item !== selected {
+                tabBar.selectedItem = item
+                tabBar.layoutIfNeeded()
+            }
+            if tabBar.selectedItem !== selected {
+                tabBar.selectedItem = selected
+                tabBar.layoutIfNeeded()
+            }
+        }
+    }
+
     private static func contentFrame(_ tabBar: UITabBar) -> CGRect? {
         func containsControl(_ view: UIView) -> Bool {
             view is UIControl || view.subviews.contains(where: containsControl)

package/ios/Sources/IonicNativeUIShellPlugin/IonicNativeUIShellPlugin.swift

@@ -20,6 +20,8 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
     private var revision = 0
     private var sequence = 0
     private var keyboardVisible = false
+    private var pendingTabSelections: [String: ShellTabBar.PendingSelection] = [:]
+    private var pendingTabExpiryWorks: [String: DispatchWorkItem] = [:]
     private var restoreTopEdge: (() -> Void)?
     private var observers: [NSObjectProtocol] = []
 
@@ -39,14 +41,21 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
                     }
                 }
                 if !keyboard { self.host?.isHidden = true }
+                var searchOwnsKeyboard = false
                 if #available(iOS 26.0, *) {
                     self.searchControllers.values.forEach {
                         guard let controller = $0 as? ShellSearchController else { return }
+                        if controller.ownsKeyboardChrome { searchOwnsKeyboard = true }
                         if !keyboard { controller.surface.isHidden = true }
                     }
                 }
-                if keyboard { self.bridge?.triggerWindowJSEvent(eventName: "nativeUIShellRefresh") }
-                else if name == UIDevice.orientationDidChangeNotification { self.notifyWebViewMetricsChange() }
+                if keyboard {
+                    if !searchOwnsKeyboard {
+                        self.bridge?.triggerWindowJSEvent(eventName: "nativeUIShellRefresh")
+                    }
+                } else if name == UIDevice.orientationDidChangeNotification {
+                    self.notifyWebViewMetricsChange()
+                }
             })
         }
         for name in [UIApplication.didBecomeActiveNotification, UIResponder.keyboardDidHideNotification,
@@ -129,6 +138,8 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
         }
         if let control = controls.removeValue(forKey: id) { ShellCrossfade.retire(control, duration: duration) }
         fingerprints.removeValue(forKey: id)
+        pendingTabSelections.removeValue(forKey: id)
+        pendingTabExpiryWorks.removeValue(forKey: id)?.cancel()
     }
 
     private func removeControls(duration: TimeInterval = 0) {
@@ -136,6 +147,36 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
         host?.removeFromSuperview()
         host = nil
         rendering.clear()
+        pendingTabSelections.removeAll()
+        pendingTabExpiryWorks.values.forEach { $0.cancel() }
+        pendingTabExpiryWorks.removeAll()
+    }
+
+    private func syncTabBar(_ tabBar: UITabBar, id: String, node: ShellControl) {
+        var pending = pendingTabSelections[id]
+        ShellTabBar.update(tabBar, node: node, rendering: rendering, pendingSelection: &pending)
+        if let pending {
+            pendingTabSelections[id] = pending
+        } else {
+            pendingTabSelections.removeValue(forKey: id)
+            pendingTabExpiryWorks.removeValue(forKey: id)?.cancel()
+        }
+    }
+
+    private func schedulePendingTabExpiry(_ id: String, until: CFAbsoluteTime) {
+        pendingTabExpiryWorks[id]?.cancel()
+        let delay = max(0, until - CFAbsoluteTimeGetCurrent()) + 0.02
+        let work = DispatchWorkItem { [weak self] in
+            guard let self else { return }
+            self.pendingTabExpiryWorks.removeValue(forKey: id)
+            guard let pending = self.pendingTabSelections[id],
+                  CFAbsoluteTimeGetCurrent() >= pending.until,
+                  let tabBar = self.controls[id] as? UITabBar,
+                  let node = self.fingerprints[id] else { return }
+            self.syncTabBar(tabBar, id: id, node: node)
+        }
+        pendingTabExpiryWorks[id] = work
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: work)
     }
 
     @objc func update(_ call: CAPPluginCall) {
@@ -173,7 +214,7 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
             }
             var rejectedControls: [String] = []
             var fabs: [(ShellFab, ShellControl)] = []
-            var searches: [(ShellSearchController, ShellControl, CGRect, CGRect)] = []
+            var searches: [(ShellSearchController, ShellControl, CGRect, CGRect, UIView?, Bool)] = []
             var rejectedSearches: [String] = []
             UIView.performWithoutAnimation {
                 if host.superview !== parent { parent.addSubview(host) }
@@ -201,9 +242,11 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
                     if let search = node.search {
                         guard let owner = self.bridge?.viewController else { rejectedSearches.append(id); continue }
                         let controller: ShellSearchController
-                        if let existing = self.searchControllers[id] as? ShellSearchController { controller = existing }
+                        let previousCover = self.controls[id]
+                        let replacing = self.searchControllers[id] as? ShellSearchController
+                        if let existing = replacing { controller = existing }
                         else {
-                            self.removeControl(id)
+                            // Keep the ordinary UITabBar cover until the search controller applies.
                             controller = ShellSearchController()
                             controller.activate = { [weak self] id in self?.activate(id) }
                             controller.changed = { [weak self] id, phase, value, composing, valueVersion in
@@ -222,7 +265,7 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
                             y: webView.bounds.minY + local.minY * scale, width: local.width * scale, height: local.height * scale), to: owner.view)
                         let triggerFrame = webView.convert(CGRect(x: webView.bounds.minX + trigger.minX * scale,
                             y: webView.bounds.minY + trigger.minY * scale, width: trigger.width * scale, height: trigger.height * scale), to: owner.view)
-                        searches.append((controller, node, searchBarFrame, triggerFrame))
+                        searches.append((controller, node, searchBarFrame, triggerFrame, previousCover, replacing == nil))
                         continue
                     } else if self.searchControllers[id] != nil {
                         self.removeControl(id)
@@ -236,7 +279,7 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
                         } else if let segment = self.controls[id] as? ShellSegment, node.kind == ShellSegment.kind {
                             segment.update(node, scale: scale, rendering: self.rendering)
                         } else if let tabBar = self.controls[id] as? UITabBar, node.kind == ShellTabBar.kind {
-                            ShellTabBar.update(tabBar, node: node, rendering: self.rendering)
+                            self.syncTabBar(tabBar, id: id, node: node)
                         } else {
                             guard let control = ShellComponents.make(node, scale: scale, rendering: self.rendering, tabDelegate: self,
                                 activate: { [weak self] id in self?.activate(id) }) else { reject(); continue }
@@ -245,6 +288,9 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
                             host.addSubview(control)
                         }
                         self.fingerprints[id] = node
+                    } else if let tabBar = self.controls[id] as? UITabBar, self.pendingTabSelections[id] != nil {
+                        // Resolve an in-flight native tap even when other fingerprint fields are unchanged.
+                        self.syncTabBar(tabBar, id: id, node: node)
                     }
                     guard let control = self.controls[id] else { reject(); continue }
                     if let tabBar = control as? UITabBar {
@@ -262,13 +308,29 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
             for (fab, node) in fabs {
                 fab.apply(node, scale: scale, rendering: self.rendering, activate: { [weak self] id in self?.activate(id) })
             }
-            for (controller, node, frame, triggerFrame) in searches {
+            for (controller, node, frame, triggerFrame, previousCover, created) in searches {
+                let id = node.id
                 let webFrame = webView.convert(webView.bounds, to: controller.surface.superview)
                 if !controller.apply(node, webFrame: webFrame, barFrame: frame, triggerFrame: triggerFrame, rendering: self.rendering) {
-                    let id = node.id
-                    self.removeControl(id)
+                    if created {
+                        self.searchControllers.removeValue(forKey: id)
+                        controller.detach()
+                        if let previousCover, previousCover.superview != nil {
+                            self.controls[id] = previousCover
+                        } else {
+                            self.controls.removeValue(forKey: id)?.removeFromSuperview()
+                            self.fingerprints.removeValue(forKey: id)
+                            self.pendingTabSelections[id] = nil
+                            self.pendingTabExpiryWorks.removeValue(forKey: id)?.cancel()
+                        }
+                    } else {
+                        self.removeControl(id)
+                    }
                     rejectedSearches.append(id)
                 } else {
+                    if created, let previousCover, previousCover !== controller.surface {
+                        previousCover.removeFromSuperview()
+                    }
                     controller.surface.isHidden = self.keyboardVisible && !controller.ownsKeyboard
                 }
             }
@@ -284,8 +346,13 @@ public class IonicNativeUIShellPlugin: CAPPlugin, CAPBridgedPlugin, UITabBarDele
     }
 
     public func tabBar(_ tabBar: UITabBar, didSelect item: UITabBarItem) {
-        guard item.isEnabled, let id = item.accessibilityIdentifier else { return }
-        activate(id)
+        guard item.isEnabled, let itemId = item.accessibilityIdentifier else { return }
+        if let controlId = controls.first(where: { $0.value === tabBar })?.key {
+            let pending = ShellTabBar.PendingSelection.start(itemId)
+            pendingTabSelections[controlId] = pending
+            schedulePendingTabExpiry(controlId, until: pending.until)
+        }
+        activate(itemId)
     }
 
     private func activate(_ id: String) {

package/ios/Tests/IonicNativeUIShellPluginTests/ShellSnapshotTests.swift

@@ -237,8 +237,8 @@ final class ShellSnapshotTests: XCTestCase {
             let node = try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "search": search,
                 "items": [item(["id": "first", "selected": true]), item(["id": "second"]) ]])]).controls.first)
             XCTAssertTrue(controller.apply(node, webFrame: CGRect(x: 0, y: 0, width: 390, height: 844),
-                barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
-                triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering))
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering))
         }
         try apply("old-search", value: "initial")
         let navigation = try XCTUnwrap(controller.tabs.last?.viewController as? UINavigationController)
@@ -292,4 +292,260 @@ final class ShellSnapshotTests: XCTestCase {
         }
     }
 
+    @MainActor
+    func testTabTitleLayoutWarmupRestoresSelection() throws {
+        let image = UIGraphicsImageRenderer(size: CGSize(width: 24, height: 24)).image { context in
+            UIColor.black.setFill()
+            context.fill(CGRect(x: 0, y: 0, width: 24, height: 24))
+        }.pngData()!.base64EncodedString()
+        let items = [
+            item(["id": "first", "label": "Index", "selected": true, "icon": image, "iconWidth": 24.0, "iconHeight": 24.0]),
+            item(["id": "second", "label": "Docs", "icon": image, "iconWidth": 24.0, "iconHeight": 24.0]),
+            item(["id": "third", "label": "Library", "icon": image, "iconWidth": 24.0, "iconHeight": 24.0]),
+        ]
+        let node = try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "width": 280.0, "height": 62.0, "items": items])]).controls.first)
+        let bar = UITabBar()
+        ShellTabBar.update(bar, node: node, rendering: ShellRendering())
+        XCTAssertTrue(ShellTabBar.fit(bar, node: node, bounds: CGRect(x: 20, y: 700, width: 280, height: 62)))
+        XCTAssertEqual(bar.selectedItem?.accessibilityIdentifier, "first")
+        // A second fit without content changes must not leave a pending warmup.
+        XCTAssertTrue(ShellTabBar.fit(bar, node: node, bounds: CGRect(x: 20, y: 700, width: 280, height: 62)))
+        XCTAssertEqual(bar.selectedItem?.accessibilityIdentifier, "first")
+    }
+
+    @MainActor
+    func testTabPendingSelectionIgnoresStaleDomEcho() throws {
+        let first = item(["id": "first", "selected": true])
+        let second = item(["id": "second"])
+        let bar = UITabBar()
+        let initial = try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "items": [first, second]])]).controls.first)
+        ShellTabBar.update(bar, node: initial, rendering: ShellRendering())
+        XCTAssertEqual(bar.selectedItem?.accessibilityIdentifier, "first")
+
+        var pending: ShellTabBar.PendingSelection? = .start("second")
+        // Stale Web echo still reports the previous tab.
+        ShellTabBar.update(bar, node: initial, rendering: ShellRendering(), pendingSelection: &pending)
+        XCTAssertEqual(pending?.id, "second")
+        XCTAssertEqual(bar.selectedItem?.accessibilityIdentifier, "second")
+
+        let echoed = try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "items": [
+            item(["id": "first"]), item(["id": "second", "selected": true]),
+        ]])]).controls.first)
+        ShellTabBar.update(bar, node: echoed, rendering: ShellRendering(), pendingSelection: &pending)
+        XCTAssertNil(pending)
+        XCTAssertEqual(bar.selectedItem?.accessibilityIdentifier, "second")
+    }
+
+    @MainActor
+    func testTabPendingSelectionFallsBackWhenDomRejects() throws {
+        let first = item(["id": "first", "selected": true])
+        let second = item(["id": "second"])
+        let bar = UITabBar()
+        let node = try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "items": [first, second]])]).controls.first)
+        ShellTabBar.update(bar, node: node, rendering: ShellRendering())
+        bar.selectedItem = bar.items?.first { $0.accessibilityIdentifier == "second" }
+
+        var pending: ShellTabBar.PendingSelection? = ShellTabBar.PendingSelection(id: "second", until: CFAbsoluteTimeGetCurrent() - 1)
+        ShellTabBar.update(bar, node: node, rendering: ShellRendering(), pendingSelection: &pending)
+        XCTAssertNil(pending)
+        XCTAssertEqual(bar.selectedItem?.accessibilityIdentifier, "first")
+
+        pending = .start("second")
+        let disabled = try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "items": [
+            item(["id": "first", "selected": true]), item(["id": "second", "disabled": true]),
+        ]])]).controls.first)
+        bar.selectedItem = bar.items?.first { $0.accessibilityIdentifier == "second" }
+        ShellTabBar.update(bar, node: disabled, rendering: ShellRendering(), pendingSelection: &pending)
+        XCTAssertNil(pending)
+        XCTAssertEqual(bar.selectedItem?.accessibilityIdentifier, "first")
+    }
+
+    @MainActor
+    func testSearchOptimisticTabSelectionIgnoresStaleDomEcho() throws {
+        guard #available(iOS 26.0, *) else { throw XCTSkip("Requires UISearchTab") }
+        let controller = ShellSearchController()
+        let rendering = ShellRendering()
+        let resting = CGRect(x: 0, y: 0, width: 390, height: 844)
+        let bar = CGRect(x: 18, y: 730, width: 280, height: 62)
+        let trigger = CGRect(x: 320, y: 730, width: 56, height: 56)
+        func node(selected: String) throws -> ShellControl {
+            let search: JSObject = ["id": "search", "field": item(), "trigger": item(["id": "trigger"]),
+                "closeId": "close", "active": false, "available": true, "focused": false,
+                "value": "", "placeholder": "Search", "disabled": false, "editSequence": 0, "valueVersion": 0]
+            return try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "search": search,
+                "items": [item(["id": "first", "selected": selected == "first"]),
+                          item(["id": "second", "selected": selected == "second"])]])]).controls.first)
+        }
+        _ = controller.apply(try node(selected: "first"), webFrame: resting, barFrame: bar, triggerFrame: trigger, rendering: rendering)
+        let second = try XCTUnwrap(controller.tabs.first { $0.identifier == "second" })
+        var activated: [String] = []
+        controller.activate = { activated.append($0) }
+        XCTAssertTrue(controller.tabBarController(controller, shouldSelectTab: second))
+        XCTAssertEqual(activated, ["second"])
+        XCTAssertEqual(controller.selectedTab?.identifier, "second")
+        // Stale Web echo still reports the previous tab.
+        _ = controller.apply(try node(selected: "first"), webFrame: resting, barFrame: bar, triggerFrame: trigger, rendering: rendering)
+        XCTAssertEqual(controller.selectedTab?.identifier, "second")
+        // Web catches up — clear pending without bouncing selection.
+        _ = controller.apply(try node(selected: "second"), webFrame: resting, barFrame: bar, triggerFrame: trigger, rendering: rendering)
+        XCTAssertEqual(controller.selectedTab?.identifier, "second")
+    }
+
+    @MainActor
+    func testSearchLocksProjectionWhileActiveAndKeepsApplicationValue() throws {
+        guard #available(iOS 26.0, *) else { throw XCTSkip("Requires UISearchTab") }
+        let controller = ShellSearchController()
+        let rendering = ShellRendering()
+        let resting = CGRect(x: 0, y: 0, width: 390, height: 844)
+        let shrunk = CGRect(x: 0, y: 0, width: 390, height: 500)
+        func node(active: Bool, focused: Bool, value: String = "", valueVersion: Int = 0) throws -> ShellControl {
+            let search: JSObject = ["id": "search", "field": item(), "trigger": item(["id": "trigger"]),
+                "closeId": "close", "active": active, "available": true, "focused": focused,
+                "value": value, "placeholder": "Search", "disabled": false, "editSequence": 0, "valueVersion": valueVersion]
+            return try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "search": search,
+                "items": [item(["id": "first", "selected": true]), item(["id": "second"])]])]).controls.first)
+        }
+        // Resting layout may reject without a full window hierarchy; surface is still assigned.
+        _ = controller.apply(try node(active: false, focused: false), webFrame: resting,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering)
+        controller.surface.frame = resting
+        // Active (even before focus) freezes Web layout for the whole search session.
+        XCTAssertTrue(controller.apply(try node(active: true, focused: false), webFrame: resting,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering))
+        XCTAssertEqual(controller.surface.frame, resting)
+        XCTAssertTrue(controller.apply(try node(active: true, focused: false), webFrame: shrunk,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering))
+        XCTAssertEqual(controller.surface.frame, resting)
+        // Application realtime value updates still cross the lock.
+        XCTAssertTrue(controller.apply(try node(active: true, focused: true, value: "external", valueVersion: 2), webFrame: shrunk,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering))
+        XCTAssertEqual(controller.surface.frame, resting)
+        let navigation = try XCTUnwrap(controller.tabs.last?.viewController as? UINavigationController)
+        let searchBar = try XCTUnwrap(navigation.topViewController?.navigationItem.searchController?.searchBar)
+        XCTAssertEqual(searchBar.text, "external")
+        // Blur request returns to presented (active, not focused) without unlocking projection.
+        XCTAssertTrue(controller.apply(try node(active: true, focused: false, value: "external", valueVersion: 2), webFrame: shrunk,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering))
+        XCTAssertEqual(controller.surface.frame, resting)
+        XCTAssertFalse(searchBar.searchTextField.isFirstResponder)
+        let tabsBeforeLeave = controller.tabs.map(\.identifier)
+        // Leave re-fits; without a window hierarchy fit may reject while still restoring selection.
+        _ = controller.apply(try node(active: false, focused: false, value: "external", valueVersion: 2), webFrame: resting,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering)
+        XCTAssertEqual(controller.surface.frame, resting)
+        // Leave must reassign tabs even when identifiers match (UISearchTab morph cleanup).
+        XCTAssertEqual(controller.tabs.map(\.identifier), tabsBeforeLeave)
+        XCTAssertEqual(controller.tabs.count, 3) // first, second, search
+        XCTAssertEqual(controller.selectedTab?.identifier, "first")
+        // Switching ordinary tabs after leave must keep resting chrome (no deferred morph expand).
+        func nodeSelecting(_ id: String) throws -> ShellControl {
+            let search: JSObject = ["id": "search", "field": item(), "trigger": item(["id": "trigger"]),
+                "closeId": "close", "active": false, "available": true, "focused": false,
+                "value": "external", "placeholder": "Search", "disabled": false, "editSequence": 0, "valueVersion": 2]
+            return try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "search": search,
+                "items": [item(["id": "first", "selected": id == "first"]),
+                          item(["id": "second", "selected": id == "second"])]])]).controls.first)
+        }
+        let tabsAfterLeave = controller.tabs.map(\.identifier)
+        _ = controller.apply(try nodeSelecting("second"), webFrame: resting,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering)
+        XCTAssertEqual(controller.selectedTab?.identifier, "second")
+        XCTAssertEqual(controller.tabs.map(\.identifier), tabsAfterLeave)
+        _ = controller.apply(try nodeSelecting("first"), webFrame: resting,
+            barFrame: CGRect(x: 18, y: 730, width: 280, height: 62),
+            triggerFrame: CGRect(x: 320, y: 730, width: 56, height: 56), rendering: rendering)
+        XCTAssertEqual(controller.selectedTab?.identifier, "first")
+        XCTAssertEqual(controller.tabs.map(\.identifier), tabsAfterLeave)
+    }
+
+    @MainActor
+    func testSearchRelocksProjectionWidthAfterRotation() throws {
+        guard #available(iOS 26.0, *) else { throw XCTSkip("Requires UISearchTab") }
+        let controller = ShellSearchController()
+        let rendering = ShellRendering()
+        let portrait = CGRect(x: 0, y: 0, width: 390, height: 844)
+        let landscape = CGRect(x: 0, y: 0, width: 844, height: 390)
+        let keyboardShrunk = CGRect(x: 0, y: 0, width: 844, height: 200)
+        func node(active: Bool) throws -> ShellControl {
+            let search: JSObject = ["id": "search", "field": item(), "trigger": item(["id": "trigger"]),
+                "closeId": "close", "active": active, "available": true, "focused": false,
+                "value": "", "placeholder": "Search", "disabled": false, "editSequence": 0, "valueVersion": 0]
+            return try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "search": search,
+                "items": [item(["id": "first", "selected": true]), item(["id": "second"])]])]).controls.first)
+        }
+        let bar = CGRect(x: 18, y: 730, width: 280, height: 62)
+        let trigger = CGRect(x: 320, y: 730, width: 56, height: 56)
+        _ = controller.apply(try node(active: false), webFrame: portrait, barFrame: bar, triggerFrame: trigger, rendering: rendering)
+        controller.surface.frame = portrait
+        XCTAssertTrue(controller.apply(try node(active: true), webFrame: portrait, barFrame: bar, triggerFrame: trigger, rendering: rendering))
+        XCTAssertEqual(controller.surface.frame, portrait)
+        // Rotation must adopt the new width instead of keeping the portrait lock.
+        XCTAssertTrue(controller.apply(try node(active: true), webFrame: landscape, barFrame: bar, triggerFrame: trigger, rendering: rendering))
+        XCTAssertEqual(controller.surface.frame, landscape)
+        // Keyboard shrink at the same width must still be ignored.
+        XCTAssertTrue(controller.apply(try node(active: true), webFrame: keyboardShrunk, barFrame: bar, triggerFrame: trigger, rendering: rendering))
+        XCTAssertEqual(controller.surface.frame, landscape)
+    }
+
+    @MainActor
+    func testSearchPendingSelectionExpiresWithoutLaterApply() throws {
+        guard #available(iOS 26.0, *) else { throw XCTSkip("Requires UISearchTab") }
+        let controller = ShellSearchController()
+        let rendering = ShellRendering()
+        let resting = CGRect(x: 0, y: 0, width: 390, height: 844)
+        let bar = CGRect(x: 18, y: 730, width: 280, height: 62)
+        let trigger = CGRect(x: 320, y: 730, width: 56, height: 56)
+        let search: JSObject = ["id": "search", "field": item(), "trigger": item(["id": "trigger"]),
+            "closeId": "close", "active": false, "available": true, "focused": false,
+            "value": "", "placeholder": "Search", "disabled": false, "editSequence": 0, "valueVersion": 0]
+        let node = try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "search": search,
+            "items": [item(["id": "first", "selected": true]), item(["id": "second"])]])]).controls.first)
+        _ = controller.apply(node, webFrame: resting, barFrame: bar, triggerFrame: trigger, rendering: rendering)
+        let second = try XCTUnwrap(controller.tabs.first { $0.identifier == "second" })
+        XCTAssertTrue(controller.tabBarController(controller, shouldSelectTab: second))
+        XCTAssertEqual(controller.selectedTab?.identifier, "second")
+        let expectation = expectation(description: "pending selection expires back to DOM")
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.15) {
+            XCTAssertEqual(controller.selectedTab?.identifier, "first")
+            expectation.fulfill()
+        }
+        wait(for: [expectation], timeout: 2)
+    }
+
+    @MainActor
+    func testSearchEmitsInputAfterRestingToActive() throws {
+        guard #available(iOS 26.0, *) else { throw XCTSkip("Requires UISearchTab") }
+        let controller = ShellSearchController()
+        let rendering = ShellRendering()
+        let resting = CGRect(x: 0, y: 0, width: 390, height: 844)
+        let bar = CGRect(x: 18, y: 730, width: 280, height: 62)
+        let trigger = CGRect(x: 320, y: 730, width: 56, height: 56)
+        func node(active: Bool) throws -> ShellControl {
+            let search: JSObject = ["id": "search", "field": item(), "trigger": item(["id": "trigger"]),
+                "closeId": "close", "active": active, "available": true, "focused": active,
+                "value": "", "placeholder": "Search", "disabled": false, "editSequence": 0, "valueVersion": 0]
+            return try XCTUnwrap(decode([control(["kind": "ion-tab-bar", "search": search,
+                "items": [item(["id": "first", "selected": true]), item(["id": "second"])]])]).controls.first)
+        }
+        // Resting must not permanently close the editing bridge.
+        _ = controller.apply(try node(active: false), webFrame: resting, barFrame: bar, triggerFrame: trigger, rendering: rendering)
+        var phases: [String] = []
+        controller.changed = { _, phase, _, _, _ in
+            phases.append(phase.rawValue)
+            return phases.count
+        }
+        XCTAssertTrue(controller.apply(try node(active: true), webFrame: resting, barFrame: bar, triggerFrame: trigger, rendering: rendering))
+        let navigation = try XCTUnwrap(controller.tabs.last?.viewController as? UINavigationController)
+        let searchBar = try XCTUnwrap(navigation.topViewController?.navigationItem.searchController?.searchBar)
+        controller.searchBar(searchBar, textDidChange: "query")
+        XCTAssertEqual(phases, ["input"])
+    }
+
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rdlabo/ionic-theme-ios27",
   "private": false,
-  "version": "0.2.1",
+  "version": "1.0.0",
   "description": "iOS27 Theme for Ionic Framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",