Исправление бесконечного рендер-цикла SearchView и поиск по публичному ключу

.gitignore

@@ -25,3 +25,4 @@ Package.resolved
 .DS_Store
 *.swp
 *~
+.claude.local.md

Rosetta.xcodeproj/project.pbxproj

@@ -264,7 +264,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = QN8Z263QGX;
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
@@ -280,7 +280,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.0.0;
+				MARKETING_VERSION = 1.0.3;
 				PRODUCT_BUNDLE_IDENTIFIER = com.rosetta.dev;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -301,7 +301,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = QN8Z263QGX;
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
@@ -317,7 +317,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.0.0;
+				MARKETING_VERSION = 1.0.3;
 				PRODUCT_BUNDLE_IDENTIFIER = com.rosetta.dev;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";

Rosetta.xcodeproj/xcshareddata/xcschemes/Rosetta.xcscheme

@@ -31,7 +31,7 @@
       shouldAutocreateTestPlan = "YES">
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Debug"
+      buildConfiguration = "Release"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       launchStyle = "0"

Rosetta/Assets.xcassets/ChatBackground.imageset/Contents.json

@@ -0,0 +1,13 @@
+{
+  "images" : [
+    {
+      "filename" : "back_5.png",
+      "idiom" : "universal",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

Rosetta/Core/Data/Repositories/DialogRepository.swift

@@ -72,12 +72,25 @@ final class DialogRepository {
     }
 
     /// Creates or updates a dialog from an incoming message packet.
-    func updateFromMessage(_ packet: PacketMessage, myPublicKey: String, decryptedText: String) {
+    ///
+    /// - Parameters:
+    ///   - isNewMessage: `true` when the message was NOT already known locally.
+    ///     Pass `false` for sync duplicates to avoid inflating `unreadCount`.
+    ///   - isDialogActive: `true` when the user currently has this chat open.
+    ///     Incoming messages in an active dialog do NOT increment `unreadCount`.
+    func updateFromMessage(
+        _ packet: PacketMessage,
+        myPublicKey: String,
+        decryptedText: String,
+        isNewMessage: Bool = true,
+        isDialogActive: Bool = false
+    ) {
         if currentAccount.isEmpty {
             currentAccount = myPublicKey
         }
         let fromMe = packet.fromPublicKey == myPublicKey
         let opponentKey = fromMe ? packet.toPublicKey : packet.fromPublicKey
+        let incomingTimestamp = normalizeTimestamp(packet.timestamp)
 
         var dialog = dialogs[opponentKey] ?? Dialog(
             id: opponentKey,
@@ -98,14 +111,21 @@ final class DialogRepository {
             lastMessageDelivered: .waiting
         )
 
+        // Android parity: only overwrite last-message fields when the incoming
+        // message is at least as new as the current latest. During sync, older
+        // messages must not overwrite a newer last-message preview.
+        if incomingTimestamp >= dialog.lastMessageTimestamp {
             dialog.lastMessage = decryptedText
-        dialog.lastMessageTimestamp = normalizeTimestamp(packet.timestamp)
+            dialog.lastMessageTimestamp = incomingTimestamp
             dialog.lastMessageFromMe = fromMe
             dialog.lastMessageDelivered = fromMe ? .waiting : .delivered
+        }
 
         if fromMe {
             dialog.iHaveSent = true
-        } else {
+        } else if isNewMessage && !isDialogActive {
+            // Only increment unread for genuinely new incoming messages
+            // when the user is NOT currently viewing this dialog.
             dialog.unreadCount += 1
         }
 
@@ -188,9 +208,9 @@ final class DialogRepository {
         if !title.isEmpty { dialog.opponentTitle = title }
         if !username.isEmpty { dialog.opponentUsername = username }
         if verified > 0 { dialog.verified = max(dialog.verified, verified) }
-        // online: 0 = offline, 1 = online, -1 = not provided (don't update)
+        // online: server sends inverted values (0 = online, 1 = offline), -1 = not provided
         if online >= 0 {
-            dialog.isOnline = online > 0
+            dialog.isOnline = online == 0
             if !dialog.isOnline { dialog.lastSeen = Int64(Date().timeIntervalSince1970 * 1000) }
         }
         dialogs[publicKey] = dialog

Rosetta/Core/Network/Protocol/Packets/PacketOnlineState.swift

@@ -21,8 +21,9 @@ struct PacketOnlineState: Packet {
         var list: [OnlineStateEntry] = []
         for _ in 0..<count {
             let publicKey = stream.readString()
-            let isOnline = stream.readBoolean()
+            let rawOnline = stream.readBoolean()
-            list.append(OnlineStateEntry(publicKey: publicKey, isOnline: isOnline))
+            // Server sends inverted: true = offline, false = online — negate it
+            list.append(OnlineStateEntry(publicKey: publicKey, isOnline: !rawOnline))
         }
         entries = list
     }

Rosetta/Core/Network/Protocol/ProtocolManager.swift

@@ -328,14 +328,13 @@ final class ProtocolManager: @unchecked Sendable {
 
     private func startHeartbeat(interval: Int) {
         heartbeatTask?.cancel()
-        let intervalMs = UInt64(interval) * 1_000_000_000 / 3
+        // Match Android: intervalMs = (intervalSeconds * 1000L) / 2
+        let intervalNs = UInt64(interval) * 1_000_000_000 / 2
 
         heartbeatTask = Task {
-            // Send first heartbeat immediately
+            // Match Android: delay first, then send (no immediate first beat)
-            client.sendText("heartbeat")
-
             while !Task.isCancelled {
-                try? await Task.sleep(nanoseconds: intervalMs)
+                try? await Task.sleep(nanoseconds: intervalNs)
                 guard !Task.isCancelled else { break }
                 client.sendText("heartbeat")
             }

Rosetta/Core/Network/Protocol/WebSocketClient.swift

@@ -6,6 +6,10 @@ final class WebSocketClient: NSObject, @unchecked Sendable, URLSessionWebSocketD
 
     private static let logger = Logger(subsystem: "com.rosetta.messenger", category: "WebSocket")
 
+    // Match Android: RECONNECT_INTERVAL = 10000L, MAX_RECONNECT_ATTEMPTS = 5
+    private static let reconnectInterval: UInt64 = 10_000_000_000 // 10 seconds (ns)
+    private static let maxReconnectAttempts = 5
+
     private let url = URL(string: "wss://wss.rosetta.im")!
     private var session: URLSession!
     private var webSocketTask: URLSessionWebSocketTask?
@@ -14,6 +18,7 @@ final class WebSocketClient: NSObject, @unchecked Sendable, URLSessionWebSocketD
     private var hasNotifiedConnected = false
     private(set) var isConnected = false
     private var disconnectHandledForCurrentSocket = false
+    private var reconnectAttempts = 0
 
     var onConnected: (() -> Void)?
     var onDisconnected: ((Error?) -> Void)?
@@ -23,6 +28,9 @@ final class WebSocketClient: NSObject, @unchecked Sendable, URLSessionWebSocketD
         super.init()
         let config = URLSessionConfiguration.default
         config.waitsForConnectivity = true
+        // Match Android OkHttp readTimeout(0) — disable client-side idle timeout
+        config.timeoutIntervalForRequest = 604800  // 1 week
+        config.timeoutIntervalForResource = 604800
         session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
     }
 
@@ -88,6 +96,7 @@ final class WebSocketClient: NSObject, @unchecked Sendable, URLSessionWebSocketD
         hasNotifiedConnected = true
         isConnected = true
         disconnectHandledForCurrentSocket = false
+        reconnectAttempts = 0  // Match Android: reset on successful connection
         reconnectTask?.cancel()
         reconnectTask = nil
         onConnected?()
@@ -139,10 +148,17 @@ final class WebSocketClient: NSObject, @unchecked Sendable, URLSessionWebSocketD
 
         guard !isManuallyClosed else { return }
 
+        // Match Android: MAX_RECONNECT_ATTEMPTS = 5
+        guard reconnectAttempts < Self.maxReconnectAttempts else {
+            Self.logger.error("Max reconnect attempts reached (\(Self.maxReconnectAttempts))")
+            return
+        }
+
         guard reconnectTask == nil else { return }
+        reconnectAttempts += 1
         reconnectTask = Task { [weak self] in
-            Self.logger.info("Reconnecting in 5 seconds...")
+            Self.logger.info("Reconnecting in 10 seconds (attempt \(self?.reconnectAttempts ?? 0)/\(Self.maxReconnectAttempts))...")
-            try? await Task.sleep(nanoseconds: 5_000_000_000)
+            try? await Task.sleep(nanoseconds: Self.reconnectInterval)
             guard let self, !isManuallyClosed, !Task.isCancelled else { return }
             self.reconnectTask = nil
             self.connect()

Rosetta/Core/Services/SessionManager.swift

@@ -410,6 +410,7 @@ final class SessionManager {
         let fromMe = packet.fromPublicKey == myKey
         let opponentKey = fromMe ? packet.toPublicKey : packet.fromPublicKey
         let wasKnownBefore = MessageRepository.shared.hasMessage(packet.messageId)
+        let dialogIsActive = MessageRepository.shared.isDialogActive(opponentKey)
 
         let decryptedText = Self.decryptIncomingMessage(
             packet: packet,
@@ -425,7 +426,11 @@ final class SessionManager {
         }
 
         DialogRepository.shared.updateFromMessage(
-            packet, myPublicKey: myKey, decryptedText: text
+            packet,
+            myPublicKey: myKey,
+            decryptedText: text,
+            isNewMessage: !wasKnownBefore,
+            isDialogActive: dialogIsActive
         )
         MessageRepository.shared.upsertFromMessagePacket(
             packet,

Rosetta/DesignSystem/Components/AvatarView.swift

@@ -38,16 +38,16 @@ struct AvatarView: View {
             }
         }
         .frame(width: size, height: size)
-        .overlay(alignment: .bottomLeading) {
+        .overlay(alignment: .bottomTrailing) {
             if isOnline {
                 Circle()
-                    .fill(Color(hex: 0x4CD964))
+                    .fill(RosettaColors.figmaBlue)
-                    .frame(width: badgeSize, height: badgeSize)
+                    .frame(width: size * 0.19, height: size * 0.19)
                     .overlay {
                         Circle()
-                            .stroke(RosettaColors.Adaptive.background, lineWidth: size * 0.05)
+                            .stroke(RosettaColors.Adaptive.background, lineWidth: size * 0.04)
                     }
-                    .offset(x: -1, y: 1)
+                    .offset(x: 0, y: -size * 0.06)
             }
         }
         .accessibilityLabel(isSavedMessages ? "Saved Messages" : initials)

Rosetta/DesignSystem/Components/ButtonStyles.swift

@@ -19,20 +19,9 @@ struct GlassBackButton: View {
         .clipShape(Circle())
     }
 
-    @ViewBuilder
     private var glassCircle: some View {
-        if #available(iOS 26, *) {
         Circle()
-                .fill(Color.white.opacity(0.08))
+            .fill(Color.white.opacity(0.15))
-                .glassEffect(.regular, in: .circle)
-        } else {
-            Circle()
-                .fill(Color.white.opacity(0.08))
-                .overlay {
-                    Circle()
-                        .stroke(Color.white.opacity(0.12), lineWidth: 0.5)
-                }
-        }
     }
 }
 
@@ -46,19 +35,9 @@ struct RosettaPrimaryButtonStyle: ButtonStyle {
     }
 
     func makeBody(configuration: Configuration) -> some View {
-        Group {
-            if #available(iOS 26, *) {
-                configuration.label
-                    .background {
-                        Capsule().fill(fillColor.opacity(configuration.isPressed ? 0.7 : 1.0))
-                    }
-                    .glassEffect(.regular, in: Capsule())
-            } else {
         configuration.label
             .background { glassBackground(isPressed: configuration.isPressed) }
             .clipShape(Capsule())
-            }
-        }
         .scaleEffect(configuration.isPressed && isEnabled ? 0.97 : 1.0)
         .animation(.easeOut(duration: 0.15), value: configuration.isPressed)
         .allowsHitTesting(isEnabled)
@@ -67,20 +46,6 @@ struct RosettaPrimaryButtonStyle: ButtonStyle {
     private func glassBackground(isPressed: Bool) -> some View {
         Capsule()
             .fill(fillColor.opacity(isPressed ? 0.7 : 1.0))
-            .overlay {
-                Capsule()
-                    .fill(
-                        LinearGradient(
-                            colors: [
-                                Color.white.opacity(isEnabled ? 0.18 : 0.05),
-                                Color.clear,
-                                Color.black.opacity(0.08),
-                            ],
-                            startPoint: .top,
-                            endPoint: .bottom
-                        )
-                    )
-            }
     }
 }
 

Rosetta/DesignSystem/Components/GlassCard.swift

@@ -16,10 +16,6 @@ struct GlassCard<Content: View>: View {
     }
 
     var body: some View {
-        if #available(iOS 26, *) {
-            content()
-                .glassEffect(.regular, in: RoundedRectangle(cornerRadius: cornerRadius))
-        } else {
         content()
             .background {
                 RoundedRectangle(cornerRadius: cornerRadius)
@@ -27,14 +23,6 @@ struct GlassCard<Content: View>: View {
                         light: Color.black.opacity(fillOpacity),
                         dark: Color.white.opacity(fillOpacity)
                     ))
-                        .overlay {
-                            RoundedRectangle(cornerRadius: cornerRadius)
-                                .stroke(RosettaColors.adaptive(
-                                    light: Color.black.opacity(0.06),
-                                    dark: Color.white.opacity(0.08)
-                                ), lineWidth: 0.5)
-                        }
-                }
             }
     }
 }

Rosetta/DesignSystem/Components/GlassModifier.swift

@@ -1,44 +1,24 @@
 import SwiftUI
 
-// MARK: - Glass Modifier (5-layer glass that works on black)
+// MARK: - Glass Modifier
 //
-// Layer stack:
+// Solid adaptive background — no glass or material effects
-// 1. .ultraThinMaterial        — system blur
-// 2. black.opacity(0.22)       — dark tint (depth on dark mode)
-// 3. white→clear gradient      — highlight / light refraction, blendMode(.screen)
-// 4. double stroke             — outer weak + inner stronger = glass edge
-// 5. shadow                    — depth
 
 struct GlassModifier: ViewModifier {
     let cornerRadius: CGFloat
 
-    func body(content: Content) -> some View {
+    private var fillColor: Color {
-        let shape = RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
+        RosettaColors.adaptive(
-
+            light: Color(hex: 0xF2F2F7),
-        if #available(iOS 26, *) {
+            dark: Color(hex: 0x1C1C1E)
-            content
-                .background {
-                    shape.fill(.clear)
-                        .glassEffect(.regular, in: .rect(cornerRadius: cornerRadius))
-                }
-        } else {
-            content
-                .background {
-                    ZStack {
-                        shape.fill(.ultraThinMaterial)
-                        shape.fill(Color.black.opacity(0.22))
-                        shape.fill(
-                            LinearGradient(
-                                colors: [Color.white.opacity(0.14), .clear],
-                                startPoint: .top,
-                                endPoint: .bottom
         )
-                        ).blendMode(.screen)
-                        shape.stroke(Color.white.opacity(0.10), lineWidth: 1)
-                        shape.stroke(Color.white.opacity(0.18), lineWidth: 1).padding(1.5)
-                    }
-                    .shadow(color: Color.black.opacity(0.45), radius: 22, y: 14)
     }
+
+    func body(content: Content) -> some View {
+        content
+            .background {
+                RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
+                    .fill(fillColor)
             }
     }
 }
@@ -46,36 +26,20 @@ struct GlassModifier: ViewModifier {
 // MARK: - View Extension
 
 extension View {
-    /// 5-layer frosted glass background.
+    /// Solid background with rounded corners.
     func glass(cornerRadius: CGFloat = 24) -> some View {
         modifier(GlassModifier(cornerRadius: cornerRadius))
     }
 
-    /// Glass capsule — convenience for pill-shaped elements.
+    /// Solid capsule background — convenience for pill-shaped elements.
-    @ViewBuilder
     func glassCapsule() -> some View {
-        if #available(iOS 26, *) {
         background {
-                Capsule().fill(.clear)
-                    .glassEffect(.regular, in: .capsule)
-            }
-        } else {
-            background {
-                ZStack {
-                    Capsule().fill(.ultraThinMaterial)
-                    Capsule().fill(Color.black.opacity(0.22))
             Capsule().fill(
-                        LinearGradient(
+                RosettaColors.adaptive(
-                            colors: [Color.white.opacity(0.14), .clear],
+                    light: Color(hex: 0xF2F2F7),
-                            startPoint: .top,
+                    dark: Color(hex: 0x1C1C1E)
-                            endPoint: .bottom
+                )
             )
-                    ).blendMode(.screen)
-                    Capsule().stroke(Color.white.opacity(0.10), lineWidth: 1)
-                    Capsule().stroke(Color.white.opacity(0.18), lineWidth: 1).padding(1.5)
-                }
-                .shadow(color: Color.black.opacity(0.45), radius: 22, y: 14)
-            }
         }
     }
 }

Rosetta/DesignSystem/Components/GlassModifiers.swift

@@ -5,12 +5,8 @@ import SwiftUI
 /// Applies glassmorphism effect to the navigation bar on iOS 26+, falling back to ultra-thin material.
 struct GlassNavBarModifier: ViewModifier {
     func body(content: Content) -> some View {
-        if #available(iOS 26, *) {
         content
-        } else {
+            .toolbarBackground(RosettaColors.Adaptive.background, for: .navigationBar)
-            content
-                .toolbarBackground(.ultraThinMaterial, for: .navigationBar)
-        }
     }
 }
 
@@ -25,12 +21,7 @@ extension View {
 /// Applies glassmorphism capsule effect on iOS 26+.
 struct GlassSearchBarModifier: ViewModifier {
     func body(content: Content) -> some View {
-        if #available(iOS 26, *) {
         content
-                .glassEffect(.regular, in: .capsule)
-        } else {
-            content
-        }
     }
 }
 

Rosetta/DesignSystem/Components/RosettaTabBar.swift

@@ -52,332 +52,232 @@ struct TabBarSwipeState {
     let fractionalIndex: CGFloat
 }
 
+// MARK: - Tab Bar Colors
+
+private enum TabBarColors {
+    static let pillBackground = Color(hex: 0x2C2C2E)
+    static let selectionBackground = Color(hex: 0x3A3A3C)
+    static let selectedTint = Color(hex: 0x008BFF)
+    static let unselectedTint = Color.white
+    static let pillBorder = Color.white.opacity(0.08)
+}
+
+// MARK: - Preference Keys
+
+private struct TabWidthPreferenceKey: PreferenceKey {
+    static var defaultValue: [Int: CGFloat] = [:]
+    static func reduce(value: inout [Int: CGFloat], nextValue: () -> [Int: CGFloat]) {
+        value.merge(nextValue()) { $1 }
+    }
+}
+
+private struct TabOriginPreferenceKey: PreferenceKey {
+    static var defaultValue: [Int: CGFloat] = [:]
+    static func reduce(value: inout [Int: CGFloat], nextValue: () -> [Int: CGFloat]) {
+        value.merge(nextValue()) { $1 }
+    }
+}
+
 // MARK: - RosettaTabBar
 
 struct RosettaTabBar: View {
     let selectedTab: RosettaTab
     var onTabSelected: ((RosettaTab) -> Void)?
     var onSwipeStateChanged: ((TabBarSwipeState?) -> Void)?
-    var badges: [TabBadge] = []
 
-    @State private var tabFrames: [RosettaTab: CGRect] = [:]
+    private let allTabs = RosettaTab.interactionOrder
-    @State private var interactionState: TabPressInteraction?
+    private let tabCount = RosettaTab.interactionOrder.count
 
-    private static let tabBarSpace = "RosettaTabBarSpace"
+    // Drag state
-    private let lensLiftOffset: CGFloat = 12
+    @State private var isDragging = false
+    @State private var dragFractional: CGFloat = 0
+    @State private var dragStartIndex: CGFloat = 0
+
+    // Measured tab geometry
+    @State private var tabWidths: [Int: CGFloat] = [:]
+    @State private var tabOrigins: [Int: CGFloat] = [:]
+
+    /// Cached badge text to avoid reading DialogRepository inside body
+    /// (which creates @Observable tracking and causes re-render storms during drag).
+    @State private var cachedBadgeText: String?
+
+    private var effectiveFractional: CGFloat {
+        isDragging ? dragFractional : CGFloat(selectedTab.interactionIndex)
+    }
 
     var body: some View {
-        interactiveTabBarContent
+        // Single pill with all tabs — same structure as iOS 26 system TabView
-            .padding(.horizontal, 25)
-            .padding(.top, 4)
-    }
-
-    private var interactiveTabBarContent: some View {
-        tabBarContent
-            .coordinateSpace(name: Self.tabBarSpace)
-            .onPreferenceChange(TabFramePreferenceKey.self) { frames in
-                tabFrames = frames
-            }
-            .contentShape(Rectangle())
-            .gesture(tabSelectionGesture)
-            .overlay(alignment: .topLeading) {
-                liftedLensOverlay
-            }
-            .onDisappear {
-                interactionState = nil
-                onSwipeStateChanged?(nil)
-            }
-    }
-
-    private var tabBarContent: some View {
-        HStack(spacing: 8) {
-            mainTabsPill
-            searchPill
-        }
-    }
-
-    private var visualSelectedTab: RosettaTab {
-        if let interactionState, interactionState.isLifted {
-            return interactionState.hoveredTab
-        }
-        return selectedTab
-    }
-
-    private var tabSelectionGesture: some Gesture {
-        DragGesture(minimumDistance: 0, coordinateSpace: .named(Self.tabBarSpace))
-            .onChanged(handleGestureChanged)
-            .onEnded(handleGestureEnded)
-    }
-
-    private func handleGestureChanged(_ value: DragGesture.Value) {
-        guard !tabFrames.isEmpty else {
-            return
-        }
-
-        if interactionState == nil {
-            guard let startTab = tabAtStart(location: value.startLocation),
-                  let startFrame = tabFrames[startTab]
-            else {
-                return
-            }
-
-            let state = TabPressInteraction(
-                id: UUID(),
-                startTab: startTab,
-                startCenterX: startFrame.midX,
-                currentCenterX: startFrame.midX,
-                hoveredTab: startTab,
-                isLifted: true
-            )
-            UIImpactFeedbackGenerator(style: .light).impactOccurred()
-            interactionState = state
-            publishSwipeState(for: state)
-            return
-        }
-
-        guard var state = interactionState else {
-            return
-        }
-
-        state.currentCenterX = clampedCenterX(state.startCenterX + value.translation.width)
-
-        if let nearest = nearestTab(toX: state.currentCenterX), nearest != state.hoveredTab {
-            state.hoveredTab = nearest
-            if state.isLifted {
-                UIImpactFeedbackGenerator(style: .soft).impactOccurred()
-            }
-        }
-
-        interactionState = state
-        publishSwipeState(for: state)
-    }
-
-    private func handleGestureEnded(_ value: DragGesture.Value) {
-        guard let state = interactionState else {
-            return
-        }
-
-        let targetTab = nearestTab(toX: value.location.x) ?? state.hoveredTab
-
-        withAnimation(.spring(response: 0.34, dampingFraction: 0.72)) {
-            interactionState = nil
-        }
-
-        onSwipeStateChanged?(nil)
-        onTabSelected?(targetTab)
-    }
-
-    private func publishSwipeState(for state: TabPressInteraction) {
-        guard state.isLifted,
-              let fractionalIndex = fractionalIndex(for: state.currentCenterX)
-        else {
-            onSwipeStateChanged?(nil)
-            return
-        }
-
-        onSwipeStateChanged?(
-            TabBarSwipeState(
-                fromTab: state.startTab,
-                hoveredTab: state.hoveredTab,
-                fractionalIndex: fractionalIndex
-            )
-        )
-    }
-
-    private func tabAtStart(location: CGPoint) -> RosettaTab? {
-        guard let nearest = nearestTab(toX: location.x),
-              let frame = tabFrames[nearest]
-        else {
-            return nil
-        }
-
-        return frame.insetBy(dx: -18, dy: -18).contains(location) ? nearest : nil
-    }
-
-    private func nearestTab(toX x: CGFloat) -> RosettaTab? {
-        tabFrames.min { lhs, rhs in
-            abs(lhs.value.midX - x) < abs(rhs.value.midX - x)
-        }?.key
-    }
-
-    private func clampedCenterX(_ value: CGFloat) -> CGFloat {
-        let centers = tabFrames.values.map(\.midX)
-        guard let minX = centers.min(), let maxX = centers.max() else {
-            return value
-        }
-        return min(max(value, minX), maxX)
-    }
-
-    private func fractionalIndex(for centerX: CGFloat) -> CGFloat? {
-        let centers = RosettaTab.interactionOrder.compactMap { tab -> CGFloat? in
-            tabFrames[tab]?.midX
-        }
-
-        guard centers.count == RosettaTab.interactionOrder.count else {
-            return nil
-        }
-
-        if centerX <= centers[0] {
-            return 0
-        }
-        if centerX >= centers[centers.count - 1] {
-            return CGFloat(centers.count - 1)
-        }
-
-        for index in 0 ..< centers.count - 1 {
-            let left = centers[index]
-            let right = centers[index + 1]
-            guard centerX >= left, centerX <= right else {
-                continue
-            }
-            let progress = (centerX - left) / max(1, right - left)
-            return CGFloat(index) + progress
-        }
-
-        return nil
-    }
-
-    private func badgeText(for tab: RosettaTab) -> String? {
-        badges.first(where: { $0.tab == tab })?.text
-    }
-
-    private func isCoveredByLens(_ tab: RosettaTab) -> Bool {
-        interactionState?.isLifted == true && interactionState?.hoveredTab == tab
-    }
-
-    private func lensDiameter(for tab: RosettaTab) -> CGFloat {
-        switch tab {
-        case .search:
-            return 88
-        default:
-            return 104
-        }
-    }
-}
-
-// MARK: - Main Tabs Pill
-
-private extension RosettaTabBar {
-    var mainTabsPill: some View {
         HStack(spacing: 0) {
-            ForEach(RosettaTab.allCases.filter { $0 != .search }, id: \.self) { tab in
+            ForEach(Array(allTabs.enumerated()), id: \.element) { index, tab in
-                TabItemView(
+                tabContent(tab: tab, index: index)
-                    tab: tab,
+                    .background(
-                    isSelected: tab == visualSelectedTab,
+                        GeometryReader { geo in
-                    isCoveredByLens: isCoveredByLens(tab),
+                            Color.clear
-                    badgeText: badgeText(for: tab)
+                                .preference(
+                                    key: TabWidthPreferenceKey.self,
+                                    value: [index: geo.size.width]
+                                )
+                                .preference(
+                                    key: TabOriginPreferenceKey.self,
+                                    value: [index: geo.frame(in: .named("tabBar")).minX]
+                                )
+                        }
                     )
-                .tabFramePreference(tab: tab, in: Self.tabBarSpace)
             }
         }
-        .padding(.horizontal, 4)
+        .padding(4)
-        .padding(.top, 3)
+        .coordinateSpace(name: "tabBar")
-        .padding(.bottom, 3)
+        .onPreferenceChange(TabWidthPreferenceKey.self) { tabWidths = $0 }
-        .frame(height: 62)
+        .onPreferenceChange(TabOriginPreferenceKey.self) { tabOrigins = $0 }
+        .background(alignment: .leading) {
+            selectionIndicator
+        }
         .background {
-            mainPillGlass
+            if #available(iOS 26.0, *) {
+                // iOS 26+ — liquid glass material for the capsule pill
+                Capsule()
+                    .fill(.ultraThinMaterial)
+            } else {
+                // iOS < 26 — solid dark capsule
+                Capsule()
+                    .fill(TabBarColors.pillBackground)
+                    .overlay(
+                        Capsule()
+                            .strokeBorder(TabBarColors.pillBorder, lineWidth: 0.5)
+                    )
             }
         }
+        .contentShape(Capsule())
+        .gesture(dragGesture)
+        .modifier(TabBarShadowModifier())
+        .padding(.horizontal, 25)
+        .padding(.top, 16)
+        .padding(.bottom, 12)
+        .onAppear { Task { @MainActor in refreshBadges() } }
+        .onChange(of: selectedTab) { _, _ in Task { @MainActor in refreshBadges() } }
+    }
+
+    /// Reads DialogRepository outside the body's observation scope.
+    private func refreshBadges() {
+        let repo = DialogRepository.shared
+        let unread = repo.sortedDialogs
+            .filter { !$0.isMuted }
+            .reduce(0) { $0 + $1.unreadCount }
+        if unread <= 0 {
+            cachedBadgeText = nil
+        } else {
+            cachedBadgeText = unread > 999 ? "\(unread / 1000)K" : "\(unread)"
+        }
+    }
+
+    // MARK: - Selection Indicator
 
     @ViewBuilder
-    var mainPillGlass: some View {
+    private var selectionIndicator: some View {
-        ZStack {
+        let frac = effectiveFractional
-            Capsule().fill(.ultraThinMaterial)
+        let nearestIdx = Int(frac.rounded()).clamped(to: 0...(tabCount - 1))
-            Capsule().fill(Color.black.opacity(0.34))
+        let width = tabWidths[nearestIdx] ?? 80
-            Capsule().fill(
+        let xOffset = interpolatedOrigin(for: frac)
-                LinearGradient(
+
-                    colors: [Color.white.opacity(0.08), .clear],
+        Group {
-                    startPoint: .top,
+            if #available(iOS 26.0, *) {
-                    endPoint: .bottom
+                Capsule().fill(.thinMaterial)
+                    .frame(width: width)
+                    .offset(x: xOffset)
+            } else {
+                Capsule().fill(TabBarColors.selectionBackground)
+                    .frame(width: width - 4)
+                    .padding(.vertical, 4)
+                    .offset(x: xOffset)
+            }
+        }
+        .animation(
+            isDragging ? nil : .spring(response: 0.34, dampingFraction: 0.82),
+            value: frac
         )
-            ).blendMode(.screen)
-            Capsule().stroke(Color.white.opacity(0.12), lineWidth: 1)
-            Capsule().stroke(Color.white.opacity(0.08), lineWidth: 1).padding(1.5)
-        }
-        .shadow(color: Color.black.opacity(0.45), radius: 22, y: 14)
     }
 
-    @ViewBuilder
+    private func interpolatedOrigin(for fractional: CGFloat) -> CGFloat {
-    var liftedLensOverlay: some View {
+        let lower = Int(fractional).clamped(to: 0...(tabCount - 1))
-        if let state = interactionState,
+        let upper = (lower + 1).clamped(to: 0...(tabCount - 1))
-           state.isLifted,
+        let t = fractional - CGFloat(lower)
-           let hoveredFrame = tabFrames[state.hoveredTab]
+        let lowerX = tabOrigins[lower] ?? 0
-        {
+        let upperX = tabOrigins[upper] ?? lowerX
-            let diameter = lensDiameter(for: state.hoveredTab)
+        return lowerX + (upperX - lowerX) * t
-
-            ZStack {
-                lensBubble
-                LensTabContentView(
-                    tab: state.hoveredTab,
-                    badgeText: badgeText(for: state.hoveredTab)
-                )
-                .padding(.top, state.hoveredTab == .search ? 0 : 8)
     }
-            .frame(width: diameter, height: diameter)
+
-            .position(x: state.currentCenterX, y: hoveredFrame.midY - lensLiftOffset)
+    // MARK: - Drag Gesture
-            .shadow(color: .black.opacity(0.42), radius: 24, y: 15)
+
-            .shadow(color: Color.cyan.opacity(0.10), radius: 20, y: 1)
+    private var dragGesture: some Gesture {
-            .allowsHitTesting(false)
+        DragGesture(minimumDistance: 8)
-            .transition(.scale(scale: 0.86).combined(with: .opacity))
+            .onChanged { value in
-            .animation(.spring(response: 0.34, dampingFraction: 0.74), value: state.isLifted)
+                if !isDragging {
-            .zIndex(20)
+                    isDragging = true
+                    dragStartIndex = CGFloat(selectedTab.interactionIndex)
+                }
+
+                let avgTabWidth = totalTabWidth / CGFloat(tabCount)
+                guard avgTabWidth > 0 else { return }
+                let delta = value.translation.width / avgTabWidth
+                let newFrac = (dragStartIndex - delta)
+                    .clamped(to: 0...CGFloat(tabCount - 1))
+
+                dragFractional = newFrac
+
+                let nearestIdx = Int(newFrac.rounded()).clamped(to: 0...(tabCount - 1))
+                onSwipeStateChanged?(TabBarSwipeState(
+                    fromTab: selectedTab,
+                    hoveredTab: allTabs[nearestIdx],
+                    fractionalIndex: newFrac
+                ))
+            }
+            .onEnded { value in
+                let avgTabWidth = totalTabWidth / CGFloat(tabCount)
+                let velocity = avgTabWidth > 0 ? value.predictedEndTranslation.width / avgTabWidth : 0
+                let projected = dragFractional - velocity * 0.15
+                let snappedIdx = Int(projected.rounded()).clamped(to: 0...(tabCount - 1))
+                let targetTab = allTabs[snappedIdx]
+
+                isDragging = false
+                dragFractional = CGFloat(snappedIdx)
+
+                UIImpactFeedbackGenerator(style: .light).impactOccurred()
+                onTabSelected?(targetTab)
+                onSwipeStateChanged?(nil)
             }
     }
 
-    @ViewBuilder
+    private var totalTabWidth: CGFloat {
-    var lensBubble: some View {
+        tabWidths.values.reduce(0, +)
-        ZStack {
-            Circle().fill(.ultraThinMaterial)
-            Circle().fill(Color.black.opacity(0.38))
-            Circle().fill(
-                LinearGradient(
-                    colors: [Color.white.opacity(0.08), Color.white.opacity(0.01), .clear],
-                    startPoint: .topLeading,
-                    endPoint: .bottomTrailing
-                )
-            )
-            Circle().stroke(Color.white.opacity(0.16), lineWidth: 1)
-            Circle().stroke(Color.white.opacity(0.06), lineWidth: 1).padding(1.6)
-            Circle().stroke(
-                AngularGradient(
-                    colors: [
-                        Color.cyan.opacity(0.34),
-                        Color.blue.opacity(0.28),
-                        Color.pink.opacity(0.28),
-                        Color.orange.opacity(0.30),
-                        Color.yellow.opacity(0.20),
-                        Color.cyan.opacity(0.34),
-                    ],
-                    center: .center
-                ),
-                lineWidth: 1.1
-            ).blendMode(.screen)
     }
-        .compositingGroup()
-    }
-}
 
-// MARK: - Tab Item
+    // MARK: - Tab Content
 
-private struct TabItemView: View {
+    private func tabContent(tab: RosettaTab, index: Int) -> some View {
-    let tab: RosettaTab
+        let frac = effectiveFractional
-    let isSelected: Bool
+        let distance = abs(frac - CGFloat(index))
-    let isCoveredByLens: Bool
+        let blend = (1 - distance).clamped(to: 0...1)
-    let badgeText: String?
+        let tint = tintColor(blend: blend)
+        let isEffectivelySelected = blend > 0.5
+        let badge: String? = (tab == .chats) ? cachedBadgeText : nil
 
-    var body: some View {
+        return Button {
-        VStack(spacing: 1) {
+            guard !isDragging else { return }
+            UIImpactFeedbackGenerator(style: .light).impactOccurred()
+            onTabSelected?(tab)
+        } label: {
+            VStack(spacing: 2) {
                 ZStack(alignment: .topTrailing) {
-                Image(systemName: isSelected ? tab.selectedIcon : tab.icon)
+                    Image(systemName: isEffectivelySelected ? tab.selectedIcon : tab.icon)
-                    .font(.system(size: 22))
+                        .font(.system(size: 22, weight: .regular))
-                    .foregroundStyle(tabColor)
+                        .foregroundStyle(tint)
-                    .frame(height: 30)
+                        .frame(height: 28)
 
-                if let badgeText {
+                    if let badge {
-                    Text(badgeText)
+                        Text(badge)
-                        .font(.system(size: 10, weight: .medium))
+                            .font(.system(size: 10, weight: .bold))
                             .foregroundStyle(.white)
-                        .padding(.horizontal, badgeText.count > 2 ? 4 : 0)
+                            .padding(.horizontal, badge.count > 2 ? 4 : 0)
                             .frame(minWidth: 18, minHeight: 18)
                             .background(Capsule().fill(RosettaColors.error))
                             .offset(x: 10, y: -4)
@@ -385,146 +285,64 @@ private struct TabItemView: View {
                 }
 
                 Text(tab.label)
-                .font(.system(size: 10, weight: isSelected ? .bold : .medium))
+                    .font(.system(size: 10, weight: isEffectivelySelected ? .bold : .medium))
-                .foregroundStyle(tabColor)
+                    .foregroundStyle(tint)
             }
-        .frame(maxWidth: .infinity)
+            .frame(minWidth: 66, maxWidth: .infinity)
-        .padding(14)
+            .padding(.vertical, 6)
-        .opacity(isCoveredByLens ? 0.07 : 1)
+        }
-        .animation(.easeInOut(duration: 0.14), value: isCoveredByLens)
+        .buttonStyle(.plain)
         .accessibilityLabel(tab.label)
-        .accessibilityAddTraits(isSelected ? .isSelected : [])
+        .accessibilityAddTraits(isEffectivelySelected ? .isSelected : [])
     }
 
-    private var tabColor: Color {
+    // MARK: - Color Interpolation
-        isSelected
+
-            ? RosettaColors.primaryBlue
+    /// Pre-computed RGBA to avoid creating UIColor on every drag frame.
-            : RosettaColors.adaptive(
+    private static let unselectedRGBA: (CGFloat, CGFloat, CGFloat, CGFloat) = {
-                light: Color(hex: 0x404040),
+        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
-                dark: Color(hex: 0x8E8E93)
+        UIColor(TabBarColors.unselectedTint).getRed(&r, green: &g, blue: &b, alpha: &a)
+        return (r, g, b, a)
+    }()
+
+    private static let selectedRGBA: (CGFloat, CGFloat, CGFloat, CGFloat) = {
+        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        UIColor(TabBarColors.selectedTint).getRed(&r, green: &g, blue: &b, alpha: &a)
+        return (r, g, b, a)
+    }()
+
+    private func tintColor(blend: CGFloat) -> Color {
+        let t = blend.clamped(to: 0...1)
+        let (fr, fg, fb, fa) = Self.unselectedRGBA
+        let (tr, tg, tb, ta) = Self.selectedRGBA
+        return Color(
+            red: fr + (tr - fr) * t,
+            green: fg + (tg - fg) * t,
+            blue: fb + (tb - fb) * t,
+            opacity: fa + (ta - fa) * t
         )
     }
 }
 
-// MARK: - Search Pill
+// MARK: - Shadow (iOS < 26 only)
 
-private extension RosettaTabBar {
+/// Glass has built-in depth on iOS 26+, so shadow is only needed on older versions.
-    var searchPill: some View {
+private struct TabBarShadowModifier: ViewModifier {
-        SearchPillView(
+    func body(content: Content) -> some View {
-            isSelected: visualSelectedTab == .search,
+        if #available(iOS 26.0, *) {
-            isCoveredByLens: isCoveredByLens(.search)
+            content
-        )
-        .tabFramePreference(tab: .search, in: Self.tabBarSpace)
-    }
-}
-
-private struct SearchPillView: View {
-    let isSelected: Bool
-    let isCoveredByLens: Bool
-
-    var body: some View {
-        Image(systemName: "magnifyingglass")
-            .font(.system(size: 17, weight: .semibold))
-            .foregroundStyle(
-                isSelected
-                    ? RosettaColors.primaryBlue
-                    : RosettaColors.adaptive(
-                        light: Color(hex: 0x404040),
-                        dark: Color(hex: 0x8E8E93)
-                    )
-            )
-            .frame(width: 62, height: 62)
-            .opacity(isCoveredByLens ? 0.08 : 1)
-            .animation(.easeInOut(duration: 0.14), value: isCoveredByLens)
-            .background { searchPillGlass }
-            .accessibilityLabel("Search")
-            .accessibilityAddTraits(isSelected ? .isSelected : [])
-    }
-
-    @ViewBuilder
-    private var searchPillGlass: some View {
-        ZStack {
-            Circle().fill(.ultraThinMaterial)
-            Circle().fill(Color.black.opacity(0.34))
-            Circle().fill(
-                LinearGradient(
-                    colors: [Color.white.opacity(0.08), .clear],
-                    startPoint: .top,
-                    endPoint: .bottom
-                )
-            ).blendMode(.screen)
-            Circle().stroke(Color.white.opacity(0.12), lineWidth: 1)
-            Circle().stroke(Color.white.opacity(0.08), lineWidth: 1).padding(1.5)
-        }
-        .shadow(color: Color.black.opacity(0.45), radius: 22, y: 14)
-    }
-}
-
-private struct LensTabContentView: View {
-    let tab: RosettaTab
-    let badgeText: String?
-
-    var body: some View {
-        if tab == .search {
-            Image(systemName: "magnifyingglass")
-                .font(.system(size: 29, weight: .semibold))
-                .foregroundStyle(RosettaColors.primaryBlue)
         } else {
-            VStack(spacing: 3) {
+            content
-                ZStack(alignment: .topTrailing) {
+                .shadow(color: Color.black.opacity(0.12), radius: 20, y: 8)
-                    Image(systemName: tab.selectedIcon)
-                        .font(.system(size: 30))
-                        .foregroundStyle(.white)
-                        .frame(height: 36)
-
-                    if let badgeText {
-                        Text(badgeText)
-                            .font(.system(size: 10, weight: .medium))
-                            .foregroundStyle(.white)
-                            .padding(.horizontal, badgeText.count > 2 ? 5 : 0)
-                            .frame(minWidth: 20, minHeight: 20)
-                            .background(Capsule().fill(RosettaColors.error))
-                            .offset(x: 16, y: -9)
-                    }
-                }
-
-                Text(tab.label)
-                    .font(.system(size: 17, weight: .semibold))
-                    .foregroundStyle(RosettaColors.primaryBlue)
-            }
         }
     }
 }
 
-// MARK: - Geometry Helpers
+// MARK: - Comparable Clamping
 
-private struct TabPressInteraction {
+private extension Comparable {
-    let id: UUID
+    func clamped(to range: ClosedRange<Self>) -> Self {
-    let startTab: RosettaTab
+        min(max(self, range.lowerBound), range.upperBound)
-    let startCenterX: CGFloat
-    var currentCenterX: CGFloat
-    var hoveredTab: RosettaTab
-    var isLifted: Bool
-}
-
-private struct TabFramePreferenceKey: PreferenceKey {
-    static var defaultValue: [RosettaTab: CGRect] = [:]
-
-    static func reduce(value: inout [RosettaTab: CGRect], nextValue: () -> [RosettaTab: CGRect]) {
-        value.merge(nextValue(), uniquingKeysWith: { _, new in new })
-    }
-}
-
-private extension View {
-    func tabFramePreference(tab: RosettaTab, in coordinateSpace: String) -> some View {
-        background {
-            GeometryReader { proxy in
-                Color.clear.preference(
-                    key: TabFramePreferenceKey.self,
-                    value: [tab: proxy.frame(in: .named(coordinateSpace))]
-                )
-            }
-        }
     }
 }
 
@@ -533,12 +351,6 @@ private extension View {
 #Preview {
     ZStack(alignment: .bottom) {
         Color.black.ignoresSafeArea()
-
+        RosettaTabBar(selectedTab: .chats)
-        RosettaTabBar(
-            selectedTab: .chats,
-            badges: [
-                TabBadge(tab: .chats, text: "7"),
-            ]
-        )
     }
 }

Rosetta/Features/Auth/AuthCoordinator.swift

@@ -2,7 +2,7 @@ import SwiftUI
 
 // MARK: - Auth Screen Enum
 
-enum AuthScreen: Equatable {
+enum AuthScreen: Hashable {
     case welcome
     case seedPhrase
     case confirmSeed
@@ -16,69 +16,12 @@ struct AuthCoordinator: View {
     let onAuthComplete: () -> Void
     var onBackToUnlock: (() -> Void)?
 
-    @State private var currentScreen: AuthScreen = .welcome
+    @State private var path = NavigationPath()
     @State private var seedPhrase: [String] = []
     @State private var isImportMode = false
-    @State private var navigationDirection: NavigationDirection = .forward
-    @State private var swipeOffset: CGFloat = 0
-
-    private var canSwipeBack: Bool {
-        currentScreen != .welcome
-    }
 
     var body: some View {
-        GeometryReader { geometry in
+        NavigationStack(path: $path) {
-            let screenWidth = geometry.size.width
-
-            ZStack {
-                RosettaColors.authBackground
-                    .ignoresSafeArea()
-
-                // Previous screen — peeks from behind during swipe
-                if canSwipeBack {
-                    previousScreenView
-                        .frame(maxWidth: .infinity, maxHeight: .infinity)
-                        .background { RosettaColors.authBackground.ignoresSafeArea() }
-                        .offset(x: -screenWidth * 0.3 + swipeOffset * 0.3)
-                        .overlay {
-                            Color.black
-                                .opacity(swipeOffset > 0
-                                    ? 0.5 * (1.0 - swipeOffset / screenWidth)
-                                    : 1.0)
-                                .ignoresSafeArea()
-                        }
-                        .allowsHitTesting(false)
-                }
-
-                // Current screen — slides right during swipe
-                currentScreenView
-                    .frame(maxWidth: .infinity, maxHeight: .infinity)
-                    .background { RosettaColors.authBackground.ignoresSafeArea() }
-                    .transition(.move(edge: navigationDirection == .forward ? .trailing : .leading))
-                    .id(currentScreen)
-                    .offset(x: swipeOffset)
-            }
-            .overlay(alignment: .leading) {
-                if canSwipeBack {
-                    Color.clear
-                        .frame(width: 20)
-                        .contentShape(Rectangle())
-                        .padding(.top, 60)
-                        .gesture(swipeBackGesture(screenWidth: screenWidth))
-                }
-            }
-            .preferredColorScheme(.dark)
-        }
-    }
-}
-
-// MARK: - Screen Views
-
-private extension AuthCoordinator {
-    @ViewBuilder
-    var currentScreenView: some View {
-        switch currentScreen {
-        case .welcome:
             WelcomeView(
                 onGenerateSeed: { navigateTo(.seedPhrase) },
                 onImportSeed: {
@@ -87,22 +30,40 @@ private extension AuthCoordinator {
                 },
                 onBack: onBackToUnlock
             )
+            .toolbar(.hidden, for: .navigationBar)
+            .navigationDestination(for: AuthScreen.self) { screen in
+                destinationView(for: screen)
+                    .toolbar(.hidden, for: .navigationBar)
+            }
+        }
+        .preferredColorScheme(.dark)
+    }
+}
+
+// MARK: - Screen Views
+
+private extension AuthCoordinator {
+    @ViewBuilder
+    func destinationView(for screen: AuthScreen) -> some View {
+        switch screen {
+        case .welcome:
+            EmptyView()
 
         case .seedPhrase:
             SeedPhraseView(
                 seedPhrase: $seedPhrase,
                 onContinue: { navigateTo(.confirmSeed) },
-                onBack: { navigateBack(to: .welcome) }
+                onBack: { navigateBack() }
             )
 
         case .confirmSeed:
             ConfirmSeedPhraseView(
-                seedPhrase: seedPhrase,
+                seedPhrase: $seedPhrase,
                 onConfirmed: {
                     isImportMode = false
                     navigateTo(.setPassword)
                 },
-                onBack: { navigateBack(to: .seedPhrase) }
+                onBack: { navigateBack() }
             )
 
         case .importSeed:
@@ -112,111 +73,31 @@ private extension AuthCoordinator {
                     isImportMode = true
                     navigateTo(.setPassword)
                 },
-                onBack: { navigateBack(to: .welcome) }
+                onBack: { navigateBack() }
             )
 
         case .setPassword:
             SetPasswordView(
-                seedPhrase: seedPhrase,
+                seedPhrase: $seedPhrase,
                 isImportMode: isImportMode,
                 onAccountCreated: onAuthComplete,
-                onBack: {
+                onBack: { navigateBack() }
-                    if isImportMode {
-                        navigateBack(to: .importSeed)
-                    } else {
-                        navigateBack(to: .confirmSeed)
-                    }
-                }
             )
         }
     }
-
-    @ViewBuilder
-    var previousScreenView: some View {
-        switch currentScreen {
-        case .welcome:
-            EmptyView()
-        case .seedPhrase:
-            WelcomeView(onGenerateSeed: {}, onImportSeed: {}, onBack: onBackToUnlock)
-        case .confirmSeed:
-            SeedPhraseView(seedPhrase: .constant(seedPhrase), onContinue: {}, onBack: {})
-        case .importSeed:
-            WelcomeView(onGenerateSeed: {}, onImportSeed: {}, onBack: onBackToUnlock)
-        case .setPassword:
-            if isImportMode {
-                ImportSeedPhraseView(seedPhrase: .constant(seedPhrase), onContinue: {}, onBack: {})
-            } else {
-                ConfirmSeedPhraseView(seedPhrase: seedPhrase, onConfirmed: {}, onBack: {})
-            }
-        }
-    }
 }
 
-// MARK: - Transitions (kept minimal — pure slide, no opacity, to avoid flash)
-
 // MARK: - Navigation
 
 private extension AuthCoordinator {
     func navigateTo(_ screen: AuthScreen) {
-        navigationDirection = .forward
+        path.append(screen)
-        withAnimation(.spring(response: 0.45, dampingFraction: 0.92)) {
-            currentScreen = screen
-        }
     }
 
-    func navigateBack(to screen: AuthScreen) {
+    func navigateBack() {
-        navigationDirection = .backward
+        guard !path.isEmpty else { return }
-        withAnimation(.spring(response: 0.4, dampingFraction: 0.95)) {
+        path.removeLast()
-            currentScreen = screen
     }
-    }
-}
-
-// MARK: - Swipe Back Gesture
-
-private extension AuthCoordinator {
-    func swipeBackGesture(screenWidth: CGFloat) -> some Gesture {
-        DragGesture(minimumDistance: 10)
-            .onChanged { value in
-                swipeOffset = max(value.translation.width, 0)
-            }
-            .onEnded { value in
-                let shouldGoBack = value.translation.width > 100
-                    || value.predictedEndTranslation.width > 200
-
-                if shouldGoBack {
-                    withAnimation(.easeOut(duration: 0.25)) {
-                        swipeOffset = screenWidth
-                    }
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) {
-                        swipeOffset = 0
-                        navigationDirection = .backward
-                        currentScreen = backDestination
-                    }
-                } else {
-                    withAnimation(.spring(response: 0.3, dampingFraction: 0.85)) {
-                        swipeOffset = 0
-                    }
-                }
-            }
-    }
-
-    var backDestination: AuthScreen {
-        switch currentScreen {
-        case .welcome: return .welcome
-        case .seedPhrase: return .welcome
-        case .confirmSeed: return .seedPhrase
-        case .importSeed: return .welcome
-        case .setPassword: return isImportMode ? .importSeed : .confirmSeed
-        }
-    }
-}
-
-// MARK: - Navigation Direction
-
-private enum NavigationDirection {
-    case forward
-    case backward
 }
 
 #Preview {

Rosetta/Features/Auth/ConfirmSeedPhraseView.swift

@@ -1,7 +1,7 @@
 import SwiftUI
 
 struct ConfirmSeedPhraseView: View {
-    let seedPhrase: [String]
+    @Binding var seedPhrase: [String]
     let onConfirmed: () -> Void
     let onBack: () -> Void
 
@@ -13,6 +13,7 @@ struct ConfirmSeedPhraseView: View {
     private let confirmPositions = [1, 4, 8, 11]
 
     private var allCorrect: Bool {
+        guard seedPhrase.count >= 12 else { return false }
         for (inputIndex, seedIndex) in confirmPositions.enumerated() {
             let input = confirmationInputs[inputIndex].lowercased().trimmingCharacters(in: .whitespaces)
             if input != seedPhrase[seedIndex].lowercased() { return false }
@@ -24,6 +25,7 @@ struct ConfirmSeedPhraseView: View {
         VStack(spacing: 0) {
             AuthNavigationBar(onBack: onBack)
 
+            if seedPhrase.count >= 12 {
                 ScrollView(showsIndicators: false) {
                     VStack(spacing: 24) {
                         headerSection
@@ -43,8 +45,12 @@ struct ConfirmSeedPhraseView: View {
                 confirmButton
                     .padding(.horizontal, 24)
                     .padding(.bottom, 16)
+            } else {
+                Spacer()
             }
         }
+        .background { RosettaColors.authBackground.ignoresSafeArea() }
+    }
 }
 
 // MARK: - Header
@@ -128,7 +134,7 @@ private extension ConfirmSeedPhraseView {
                 .foregroundStyle(RosettaColors.numberGray)
                 .frame(width: 28, alignment: .trailing)
 
-            TextField("enter word", text: $confirmationInputs[inputIndex])
+            TextField("enter", text: $confirmationInputs[inputIndex])
                 .font(.system(size: 17, weight: .semibold, design: .monospaced))
                 .foregroundStyle(.white)
                 .autocorrectionDisabled()
@@ -281,8 +287,8 @@ private extension ConfirmSeedPhraseView {
 
 #Preview {
     ConfirmSeedPhraseView(
-        seedPhrase: ["abandon", "ability", "able", "about", "above", "absent",
+        seedPhrase: .constant(["abandon", "ability", "able", "about", "above", "absent",
-                     "absorb", "abstract", "absurd", "abuse", "access", "accident"],
+                     "absorb", "abstract", "absurd", "abuse", "access", "accident"]),
         onConfirmed: {},
         onBack: {}
     )

Rosetta/Features/Auth/ImportSeedPhraseView.swift

@@ -37,6 +37,7 @@ struct ImportSeedPhraseView: View {
                 .padding(.horizontal, 24)
                 .padding(.bottom, 16)
         }
+        .background { RosettaColors.authBackground.ignoresSafeArea() }
     }
 }
 

Rosetta/Features/Auth/SeedPhraseView.swift

@@ -37,6 +37,7 @@ struct SeedPhraseView: View {
                 .padding(.horizontal, 24)
                 .padding(.bottom, 16)
         }
+        .background { RosettaColors.authBackground.ignoresSafeArea() }
         .onAppear(perform: generateSeedPhraseIfNeeded)
     }
 }
@@ -117,21 +118,12 @@ private struct SeedCardStyle: ViewModifier {
     let color: Color
 
     func body(content: Content) -> some View {
-        if #available(iOS 26, *) {
-            content
-                .glassEffect(.regular, in: RoundedRectangle(cornerRadius: 12))
-        } else {
         content
             .background {
-                    RoundedRectangle(cornerRadius: 12)
+                RoundedRectangle(cornerRadius: 14)
-                        .fill(color.opacity(0.12))
+                    .fill(color.opacity(0.15))
-                        .overlay {
-                            RoundedRectangle(cornerRadius: 12)
-                                .stroke(color.opacity(0.18), lineWidth: 0.5)
-                        }
-                }
-                .clipShape(RoundedRectangle(cornerRadius: 12))
             }
+            .clipShape(RoundedRectangle(cornerRadius: 14))
     }
 }
 
@@ -153,7 +145,7 @@ private extension SeedPhraseView {
                     .font(.system(size: 15, weight: .medium))
             }
             .foregroundStyle(showCopiedToast ? RosettaColors.success : RosettaColors.primaryBlue)
-            .contentTransition(.symbolEffect(.replace))
+            .animation(.easeInOut(duration: 0.2), value: showCopiedToast)
         }
         .accessibilityLabel(showCopiedToast ? "Copied to clipboard" : "Copy seed phrase to clipboard")
     }

Rosetta/Features/Auth/SetPasswordView.swift

@@ -1,7 +1,7 @@
 import SwiftUI
 
 struct SetPasswordView: View {
-    let seedPhrase: [String]
+    @Binding var seedPhrase: [String]
     let isImportMode: Bool
     let onAccountCreated: () -> Void
     let onBack: () -> Void
@@ -72,6 +72,7 @@ struct SetPasswordView: View {
             .padding(.horizontal, 24)
             .padding(.bottom, 16)
         }
+        .background { RosettaColors.authBackground.ignoresSafeArea() }
         .ignoresSafeArea(.keyboard)
     }
 }
@@ -278,8 +279,8 @@ private extension SetPasswordView {
 
 #Preview {
     SetPasswordView(
-        seedPhrase: ["abandon", "ability", "able", "about", "above", "absent",
+        seedPhrase: .constant(["abandon", "ability", "able", "about", "above", "absent",
-                     "absorb", "abstract", "absurd", "abuse", "access", "accident"],
+                     "absorb", "abstract", "absurd", "abuse", "access", "accident"]),
         isImportMode: false,
         onAccountCreated: {},
         onBack: {}

Rosetta/Features/Auth/WelcomeView.swift

@@ -49,6 +49,7 @@ struct WelcomeView: View {
                     .accessibilityLabel("Back")
             }
         }
+        .background { RosettaColors.authBackground.ignoresSafeArea() }
         .onAppear {
             guard !isVisible else { return }
             withAnimation(.easeOut(duration: 0.5)) { isVisible = true }

Rosetta/Features/Chats/ChatList/ChatListViewModel.swift

@@ -103,15 +103,8 @@ final class ChatListViewModel: ObservableObject {
                 self.serverSearchResults = packet.users
                 self.isServerSearching = false
                 Self.logger.debug("📥 isServerSearching=\(self.isServerSearching), count=\(self.serverSearchResults.count)")
-                for user in packet.users {
+                // Note: DialogRepository.updateUserInfo is handled by
-                    DialogRepository.shared.updateUserInfo(
+                // SessionManager.setupUserInfoSearchHandler — avoid duplicate mutations.
-                        publicKey: user.publicKey,
-                        title: user.title,
-                        username: user.username,
-                        verified: user.verified,
-                        online: user.online
-                    )
-                }
             }
         }
     }

Rosetta/Features/Onboarding/OnboardingPager.swift

@@ -9,7 +9,19 @@ struct OnboardingPager<Page: View>: UIViewControllerRepresentable {
     let count: Int
     let buildPage: (Int) -> Page
 
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
+    func makeCoordinator() -> OnboardingPagerCoordinator {
+        OnboardingPagerCoordinator(
+            currentIndex: currentIndex,
+            count: count,
+            currentIndexSetter: { [self] idx in self._currentIndex.wrappedValue = idx },
+            continuousProgressSetter: { [self] val in self._continuousProgress.wrappedValue = val },
+            buildControllers: { (0..<count).map { i in
+                let hc = UIHostingController(rootView: buildPage(i))
+                hc.view.backgroundColor = .clear
+                return hc
+            }}
+        )
+    }
 
     func makeUIViewController(context: Context) -> UIPageViewController {
         let vc = UIPageViewController(
@@ -36,29 +48,41 @@ struct OnboardingPager<Page: View>: UIViewControllerRepresentable {
     }
 
     func updateUIViewController(_ vc: UIPageViewController, context: Context) {
-        context.coordinator.parent = self
+        context.coordinator.count = count
+        context.coordinator.currentIndex = currentIndex
+        context.coordinator.currentIndexSetter = { [self] idx in self._currentIndex.wrappedValue = idx }
+        context.coordinator.continuousProgressSetter = { [self] val in self._continuousProgress.wrappedValue = val }
     }
+}
 
-    // MARK: - Coordinator
+// MARK: - Coordinator (non-generic to avoid Swift compiler crash in Release optimiser)
 
-    final class Coordinator: NSObject,
+final class OnboardingPagerCoordinator: NSObject,
     UIPageViewControllerDataSource,
     UIPageViewControllerDelegate,
     UIScrollViewDelegate
-    {
+{
-        var parent: OnboardingPager
+    let controllers: [UIViewController]
-        let controllers: [UIHostingController<Page>]
+    var count: Int
+    var currentIndex: Int
+    var currentIndexSetter: (Int) -> Void
+    var continuousProgressSetter: (CGFloat) -> Void
     var pageWidth: CGFloat = 0
     private var pendingIndex: Int = 0
 
-        init(_ parent: OnboardingPager) {
+    init(
-            self.parent = parent
+        currentIndex: Int,
-            self.pendingIndex = parent.currentIndex
+        count: Int,
-            self.controllers = (0..<parent.count).map { i in
+        currentIndexSetter: @escaping (Int) -> Void,
-                let hc = UIHostingController(rootView: parent.buildPage(i))
+        continuousProgressSetter: @escaping (CGFloat) -> Void,
-                hc.view.backgroundColor = .clear
+        buildControllers: () -> [UIViewController]
-                return hc
+    ) {
-            }
+        self.currentIndex = currentIndex
+        self.count = count
+        self.currentIndexSetter = currentIndexSetter
+        self.continuousProgressSetter = continuousProgressSetter
+        self.pendingIndex = currentIndex
+        self.controllers = buildControllers()
     }
 
     // MARK: DataSource
@@ -76,7 +100,7 @@ struct OnboardingPager<Page: View>: UIViewControllerRepresentable {
         viewControllerAfter vc: UIViewController
     ) -> UIViewController? {
         guard let idx = controllers.firstIndex(where: { $0 === vc }),
-                  idx < parent.count - 1 else { return nil }
+              idx < count - 1 else { return nil }
         return controllers[idx + 1]
     }
 
@@ -101,7 +125,8 @@ struct OnboardingPager<Page: View>: UIViewControllerRepresentable {
         guard completed,
               let current = pvc.viewControllers?.first,
               let idx = controllers.firstIndex(where: { $0 === current }) else { return }
-            parent.currentIndex = idx
+        currentIndex = idx
+        currentIndexSetter(idx)
     }
 
     // MARK: ScrollView — real-time progress
@@ -109,12 +134,9 @@ struct OnboardingPager<Page: View>: UIViewControllerRepresentable {
     func scrollViewDidScroll(_ scrollView: UIScrollView) {
         let w = scrollView.frame.width
         guard w > 0 else { return }
-            // UIPageViewController's scroll view rests at x = width.
-            // Dragging left (next page) increases x; dragging right decreases.
         let offsetFromCenter = scrollView.contentOffset.x - w
         let fraction = offsetFromCenter / w
-            let progress = CGFloat(parent.currentIndex) + fraction
+        let progress = CGFloat(currentIndex) + fraction
-            parent.continuousProgress = max(0, min(CGFloat(parent.count - 1), progress))
+        continuousProgressSetter(max(0, min(CGFloat(count - 1), progress)))
-        }
     }
 }