crossmate

GameListView.swift (37602B)

---

 import CoreData
 import SwiftUI
 
 struct GameListView: View {
     let store: GameStore
     let shareController: ShareController
     let authorIdentity: AuthorIdentity
     let onRefresh: () async -> Void
     let onAppear: () async -> Void
     let onLoadRecentCompleted: (Date) async -> GameArchiver.CompletedPage
     let onLoadMoreCompleted: () async -> GameArchiver.CompletedPage
     let onDisappear: () -> Void
     let onAcceptInvite: ((String, String, GridSilhouette.Grid?) async throws -> Void)?
     @Binding var pendingInviteNotificationGameID: UUID?
     @Binding var navigationPath: NavigationPath
 
     @Environment(\.accessibilityVoiceOverEnabled) private var isVoiceOverEnabled
     @Environment(\.dynamicTypeSize) private var dynamicTypeSize
     @Environment(\.horizontalSizeClass) private var horizontalSizeClass
     @FetchRequest(
         sortDescriptors: [],
         predicate: GameEntity.visibleInGameListPredicate,
         animation: .default
     )
     private var games: FetchedResults<GameEntity>
 
     @FetchRequest(
         sortDescriptors: [NSSortDescriptor(keyPath: \InviteEntity.createdAt, ascending: true)],
         predicate: NSPredicate(format: "status == %@", "pending"),
         animation: .default
     )
     private var pendingInvites: FetchedResults<InviteEntity>
 
     @FetchRequest(
         sortDescriptors: [],
         predicate: NSPredicate(format: "isBlocked == YES")
     )
     // Drives the Invited section filter below. Pending invites from blocked
     // friends can exist briefly until the ping cleanup path consumes them,
     // but the library and badge state should never surface them.
     private var blockedFriends: FetchedResults<FriendEntity>
 
     @Environment(\.appActions) private var appActions
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(AnnouncementCenter.self) private var announcements
     @Environment(EventLog.self) private var eventLog
     @Environment(TipStore.self) private var tips
     #if DEBUG
     @Environment(DriveMonitor.self) private var driveMonitor
     #endif
     @State private var acceptingInviteID: NSManagedObjectID?
     @State private var blockTarget: InviteEntity?
 
     @State private var newGamePresentation: NewGamePresentation?
     @State private var showingSettings = false
     @AppStorage(AppServices.showV4NoticeDefaultsKey) private var showV4Notice = false
     @State private var showingFriends = false
     @State private var queuedNewGameInviteTarget: FriendNewGameTarget?
     @State private var deleteTarget: GameSummary?
     @State private var resignTarget: GameSummary?
     @State private var leaveTarget: GameSummary?
     @State private var showingNamePrompt = false
     @State private var nameDraft = ""
     @State private var summaryCache = GameSummaryCache()
     @State private var completedCutoff = Calendar.current.date(
         byAdding: .day,
         value: -7,
         to: Date()
     ) ?? Date().addingTimeInterval(-7 * 24 * 60 * 60)
     @State private var cloudHasMoreCompleted = false
     @State private var isLoadingMoreCompleted = false
     /// Shows the "Never show me tips" opt-out in the banner slot for a few
     /// seconds after a tip is dismissed; cleared by the timer or by tapping it.
     @State private var showTipOptOut = false
     @State private var tipOptOutHideTask: Task<Void, Never>?
     @State private var containerHeight: CGFloat = 0
     @AccessibilityFocusState private var isPuzzleListHeadingFocused: Bool
 
     private struct NewGamePresentation: Identifiable {
         let id = UUID()
         let inviteTarget: FriendNewGameTarget?
     }
 
     var body: some View {
         VStack(spacing: 0) {
             accessibilityHeading
             if let announcement = announcements.currentGlobal() {
                 AnnouncementBanner(announcement: announcement, contentSize: .prominent) {
                     dismissAnnouncement(announcement)
                 }
                 .padding(.horizontal)
                 .padding(.top, 8)
                 .transition(.move(edge: .top).combined(with: .opacity))
             } else if showTipOptOut {
                 Button("Never Show Tips") {
                     tipOptOutHideTask?.cancel()
                     tips.disable()
                     showTipOptOut = false
                 }
                 .buttonStyle(.borderedProminent)
                 .buttonBorderShape(.capsule)
                 .controlSize(.small)
                 .padding(.top, 8)
                 .transition(.opacity)
             }
             content(usesRoomierType: usesRoomierType)
         }
         .background(Color(.systemGroupedBackground))
         .animation(.easeInOut(duration: 0.3), value: announcements.currentGlobal())
         .animation(.easeInOut(duration: 0.3), value: showTipOptOut)
         .onGeometryChange(for: CGFloat.self) { proxy in
             proxy.size.height
         } action: { height in
             containerHeight = height
         }
         .navigationTitle("")
         .navigationBarTitleDisplayMode(.inline)
         .toolbar {
             ToolbarItem(placement: .topBarLeading) {
                 Button {
                     showingSettings = true
                 } label: {
                     Image(systemName: "gearshape")
                 }
                 .accessibilityLabel("Settings")
             }
             ToolbarItem(placement: .topBarTrailing) {
                 Button {
                     showingFriends = true
                 } label: {
                     Image(systemName: "person.2")
                 }
                 .accessibilityLabel("Crossmates")
             }
             if #available(iOS 26.0, *) {
                 ToolbarSpacer(.fixed, placement: .topBarTrailing)
             }
             ToolbarItem(placement: .topBarTrailing) {
                 Button {
                     newGamePresentation = NewGamePresentation(inviteTarget: nil)
                 } label: {
                     Image(systemName: "plus")
                 }
                 .accessibilityLabel("New Puzzle")
             }
         }
         .sheet(isPresented: $showingSettings) {
             SettingsView()
         }
         .sheet(isPresented: $showV4Notice) {
             NoticeView { showV4Notice = false }
         }
         .sheet(isPresented: $showingFriends, onDismiss: presentQueuedFriendNewGame) {
             FriendsView { target in
                 queuedNewGameInviteTarget = target
             }
         }
         .sheet(item: $newGamePresentation) { presentation in
             NewGameSheet(
                 store: store,
                 inviteTargetName: presentation.inviteTarget?.displayName
             ) { gameID in
                 navigationPath.append(gameID)
                 if let target = presentation.inviteTarget {
                     Task { await inviteNewGame(gameID, to: target) }
                 }
             }
         }
         .task {
             await onAppear()
             let page = await onLoadRecentCompleted(completedCutoff)
             cloudHasMoreCompleted = page.hasMore
             reconcilePendingInviteNotification()
             focusPuzzleListHeading()
         }
         .onReceive(NotificationCenter.default.publisher(for: .chronicleZoneDidChange)) { _ in
             Task {
                 let page = await onLoadRecentCompleted(completedCutoff)
                 cloudHasMoreCompleted = page.hasMore
             }
         }
         #if DEBUG
         .task {
             // Marketing "import" scene: render the real New Puzzle sheet over the
             // seeded library instead of a mock. Seed the Imported tab with fake
             // files, preselect it, then present the real sheet.
             guard MarketingLaunch.isImportScene else { return }
             driveMonitor.seedMarketingImports()
             UserDefaults.standard.set(PuzzleSource.imported.rawValue, forKey: "lastPuzzleSource")
             newGamePresentation = NewGamePresentation(inviteTarget: nil)
         }
         #endif
         .onChange(of: pendingInviteNotificationGameID) { _, _ in
             reconcilePendingInviteNotification()
         }
         .onChange(of: pendingInvites.count) { _, _ in
             reconcilePendingInviteNotification()
         }
         .onChange(of: isVoiceOverEnabled) { _, enabled in
             if enabled {
                 focusPuzzleListHeading()
             }
         }
         .onDisappear {
             onDisappear()
         }
         .alert("Resign Puzzle?", isPresented: .init(
             get: { resignTarget != nil },
             set: { if !$0 { resignTarget = nil } }
         )) {
             Button("Resign", role: .destructive) {
                 if let target = resignTarget {
                     do {
                         try store.resignGame(id: target.id)
                     } catch {
                         announcements.post(Announcement(
                             id: Self.destructiveActionErrorID,
                             scope: .global,
                             severity: .error,
                             title: "Resigning Failed",
                             body: error.localizedDescription,
                             dismissal: .manual
                         ))
                     }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             if let target = resignTarget {
                 Text("This will reveal all answers for \"\(target.title)\".")
             }
         }
         .alert("Leave Puzzle?", isPresented: .init(
             get: { leaveTarget != nil },
             set: { if !$0 { leaveTarget = nil } }
         )) {
             Button("Leave", role: .destructive) {
                 if let target = leaveTarget {
                     Task { await leaveShare(game: target) }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             if let target = leaveTarget {
                 Text("You will lose access to \"\(target.title)\".")
             }
         }
         .alert("Delete Puzzle?", isPresented: .init(
             get: { deleteTarget != nil },
             set: { if !$0 { deleteTarget = nil } }
         )) {
             Button("Delete", role: .destructive) {
                 if let target = deleteTarget {
                     do {
                         try store.deleteGame(id: target.id)
                     } catch {
                         announcements.post(Announcement(
                             id: Self.destructiveActionErrorID,
                             scope: .global,
                             severity: .error,
                             title: "Deleting Failed",
                             body: error.localizedDescription,
                             dismissal: .manual
                         ))
                     }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             if let target = deleteTarget {
                 if target.isOwned && target.isShared {
                     Text("This will permanently delete \"\(target.title)\" from iCloud for everyone.")
                 } else {
                     Text("This will permanently delete \"\(target.title)\" and all progress.")
                 }
             }
         }
         .alert("Block This Player?", isPresented: .init(
             get: { blockTarget != nil },
             set: { if !$0 { blockTarget = nil } }
         )) {
             Button("Block", role: .destructive) {
                 if let target = blockTarget, let authorID = target.inviterAuthorID {
                     Task { await appActions?.blockFriend(authorID: authorID) }
                 }
             }
             Button("Cancel", role: .cancel) {}
         } message: {
             let name = blockTarget?.resolvedInviterName ?? "this player"
             Text("You won't receive further invites from \(name), and any puzzles they currently share with you will be hidden from your list. You can unblock them later to bring everything back.")
         }
         .alert("Set Profile Name", isPresented: $showingNamePrompt) {
             TextField("Name", text: $nameDraft)
                 .textInputAutocapitalization(.never)
                 .autocorrectionDisabled()
             Button("Cancel", role: .cancel) {}
             Button("Save") {
                 let trimmed = nameDraft.trimmingCharacters(in: .whitespacesAndNewlines)
                 if !trimmed.isEmpty {
                     preferences.name = trimmed
                     nameDraft = trimmed
                 }
             }
             .keyboardShortcut(.defaultAction)
         } message: {
             Text("Enter the name other players will see.")
         }
     }
 
     private var accessibilityHeading: some View {
         Text("List of Puzzles")
             .accessibilityAddTraits(.isHeader)
             .accessibilityFocused($isPuzzleListHeadingFocused)
             .frame(width: 1, height: 1)
             .opacity(0.01)
             .allowsHitTesting(false)
     }
 
     private func focusPuzzleListHeading() {
         guard isVoiceOverEnabled else { return }
         isPuzzleListHeadingFocused = true
     }
 
     /// Dismisses the banner's announcement. For a tip, also records it as
     /// dismissed so it never returns, and surfaces the "Never show me tips"
     /// opt-out in its place for a few seconds.
     private func dismissAnnouncement(_ announcement: Announcement) {
         announcements.dismiss(id: announcement.id)
         guard let tipID = Tip.tipID(fromAnnouncementID: announcement.id) else { return }
         tips.markDismissed(tipID)
         showTipOptOut = true
         tipOptOutHideTask?.cancel()
         tipOptOutHideTask = Task { @MainActor in
             try? await Task.sleep(for: .seconds(6))
             guard !Task.isCancelled else { return }
             showTipOptOut = false
         }
     }
 
     private func reconcilePendingInviteNotification() {
         guard let gameID = pendingInviteNotificationGameID else { return }
         if pendingInvites.contains(where: { $0.gameID == gameID }) {
             announcements.dismiss(id: Self.inviteSyncID)
             pendingInviteNotificationGameID = nil
             return
         }
         announcements.post(Announcement(
             id: Self.inviteSyncID,
             scope: .global,
             severity: .info,
             title: "Syncing Invitation",
             body: "An invitation is still syncing. It should appear shortly.",
             dismissal: .transient(after: 8)
         ))
     }
 
     private func presentQueuedFriendNewGame() {
         guard let target = queuedNewGameInviteTarget else { return }
         queuedNewGameInviteTarget = nil
         newGamePresentation = NewGamePresentation(inviteTarget: target)
     }
 
     private func inviteNewGame(_ gameID: UUID, to target: FriendNewGameTarget) async {
         guard let appActions else { return }
         announcements.dismiss(id: Self.newGameInviteErrorID)
         do {
             try await appActions.inviteFriend(gameID: gameID, friendAuthorID: target.authorID)
         } catch SyncEngine.PingOutboxError.deliveryPending {
             // The invite is durably queued; CloudKit just hasn't confirmed yet.
             // Don't raise a failure banner — the async delivery update surfaces
             // one only if the send is ultimately rejected.
             eventLog.note(
                 "new game friend invite queued game=\(gameID.uuidString) friend=\(target.authorID)",
                 level: "info"
             )
         } catch {
             announcements.dismiss(
                 id: InviteDeliveryStore.failureAnnouncementID(
                     gameID: gameID,
                     friendAuthorID: target.authorID
                 )
             )
             let quotaExceeded = (error as? SyncEngine.PingOutboxError)?
                 .isQuotaExceeded == true
             eventLog.note(
                 "new game friend invite failed game=\(gameID.uuidString) friend=\(target.authorID): \(error)",
                 level: "error"
             )
             announcements.post(Announcement(
                 id: Self.newGameInviteErrorID,
                 scope: .game(gameID),
                 severity: .error,
                 title: quotaExceeded
                     ? String(localized: InviteDeliveryFailure.quotaExceeded.title)
                     : "Inviting Failed",
                 body: quotaExceeded
                     ? String(localized: InviteDeliveryFailure.quotaExceeded.body)
                     : "\(target.displayName) could not be invited. Try again from the Share menu.",
                 dismissal: .manual
             ))
         }
     }
 
     @ViewBuilder
     private func content(usesRoomierType: Bool) -> some View {
         let summaries = games.compactMap {
             summaryCache.summary(
                 for: $0,
                 localAuthorID: authorIdentity.currentID,
                 localName: preferences.name,
                 localColor: preferences.color
             )
         }
         let inProgress = summaries
             .filter { $0.completedAt == nil && !$0.isAccessRevoked }
             .sorted { ($0.updatedAt ?? .distantPast) > ($1.updatedAt ?? .distantPast) }
         let revoked = summaries
             .filter { $0.isAccessRevoked }
             .sorted { ($0.updatedAt ?? .distantPast) > ($1.updatedAt ?? .distantPast) }
         let completed = summaries
             .filter { $0.completedAt != nil && !$0.isAccessRevoked }
             .sorted { ($0.completedAt ?? .distantPast) > ($1.completedAt ?? .distantPast) }
         let visibleCompleted = completed.filter {
             ($0.completedAt ?? .distantPast) >= completedCutoff
         }
         let olderLocal = completed.filter {
             ($0.completedAt ?? .distantPast) < completedCutoff
         }
         let nextLocalCutoff = olderLocal
             .prefix(GameArchiver.completedPageSize)
             .last?
             .completedAt
         let hasMore = cloudHasMoreCompleted || !olderLocal.isEmpty
 
         let blockedIDs = Set(blockedFriends.compactMap { $0.authorID })
         let visibleInvites = pendingInvites.filter {
             guard let inviter = $0.inviterAuthorID else { return true }
             return !blockedIDs.contains(inviter)
         }
 
         Group {
             if horizontalSizeClass == .regular {
                 gridLayout(
                     invites: visibleInvites,
                     inProgress: inProgress,
                     revoked: revoked,
                     completed: visibleCompleted,
                     hasMore: hasMore,
                     nextLocalCutoff: nextLocalCutoff,
                     usesRoomierType: usesRoomierType
                 )
             } else {
                 listLayout(
                     invites: visibleInvites,
                     inProgress: inProgress,
                     revoked: revoked,
                     completed: visibleCompleted,
                     hasMore: hasMore,
                     nextLocalCutoff: nextLocalCutoff,
                     usesRoomierType: usesRoomierType
                 )
             }
         }
         .overlay {
             if games.isEmpty {
                 Group {
                     if preferences.hasName {
                         ContentUnavailableView {
                             Label("No Puzzles", systemImage: "square.grid.3x3")
                         } description: {
                             Text("Tap the + button to start a new puzzle, or pull down to refresh.")
                         }
                     } else {
                         ContentUnavailableView {
                             Label("Set Your Profile Name", systemImage: "person.text.rectangle")
                         } description: {
                             Text("Choose the name other players will see.")
                         } actions: {
                             Button {
                                 nameDraft = ""
                                 showingNamePrompt = true
                             } label: { Text("Set Profile Name") }
                             .buttonStyle(.borderedProminent)
                         }
                     }
                 }
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
                 .background(Color(.systemGroupedBackground))
             }
         }
     }
 
     // MARK: - List layout (compact width / iPhone)
 
     @ViewBuilder
     private func listLayout(
         invites: [InviteEntity],
         inProgress: [GameSummary],
         revoked: [GameSummary],
         completed: [GameSummary],
         hasMore: Bool,
         nextLocalCutoff: Date?,
         usesRoomierType: Bool
     ) -> some View {
         List {
             if !invites.isEmpty {
                 Section {
                     ForEach(invites, id: \.objectID) { invite in
                         inviteRow(for: invite)
                     }
                 } header: {
                     listSectionHeader("Invited")
                 }
             }
 
             if !inProgress.isEmpty {
                 Section {
                     ForEach(inProgress) { game in
                         rowView(for: game, usesRoomierType: usesRoomierType)
                     }
                 } header: {
                     listSectionHeader("In Progress")
                 }
             }
 
             if !revoked.isEmpty {
                 Section {
                     ForEach(revoked) { game in
                         rowView(for: game, usesRoomierType: usesRoomierType)
                     }
                 } header: {
                     listSectionHeader("Revoked")
                 }
             }
 
             if !completed.isEmpty || hasMore {
                 Section {
                     ForEach(completed, id: \.listID) { game in
                         rowView(for: game, usesRoomierType: usesRoomierType)
                     }
                 } header: {
                     listSectionHeader("Completed")
                 } footer: {
                     if hasMore {
                         loadMoreButton(nextLocalCutoff: nextLocalCutoff)
                     }
                 }
             }
         }
         .refreshable {
             await refreshList()
         }
     }
 
     private func listSectionHeader(_ title: String) -> some View {
         Text(title)
             .accessibilityAddTraits(.isHeader)
     }
 
     // MARK: - Grid layout (regular width / iPad)
 
     private var gridColumns: [GridItem] {
         // 380 keeps the 13" iPad to two portrait columns (three at 320 left
         // each card's text column so narrow that every headline title was
         // scale-crushed back down to metadata size).
         [GridItem(.adaptive(minimum: 380), spacing: 12)]
     }
 
     @ViewBuilder
     private func gridLayout(
         invites: [InviteEntity],
         inProgress: [GameSummary],
         revoked: [GameSummary],
         completed: [GameSummary],
         hasMore: Bool,
         nextLocalCutoff: Date?,
         usesRoomierType: Bool
     ) -> some View {
         ScrollView {
             LazyVStack(spacing: 8) {
                 if !invites.isEmpty {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(invites, id: \.objectID) { invite in
                                 inviteCard(for: invite)
                             }
                         }
                         .padding(.horizontal)
                     } header: {
                         gridSectionHeader("Invited")
                     }
                 }
 
                 if !inProgress.isEmpty {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(inProgress) { game in
                                 gameCard(for: game, usesRoomierType: usesRoomierType)
                             }
                         }
                         .padding(.horizontal)
                     } header: {
                         gridSectionHeader("In Progress")
                     }
                 }
 
                 if !revoked.isEmpty {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(revoked) { game in
                                 gameCard(for: game, usesRoomierType: usesRoomierType)
                             }
                         }
                         .padding(.horizontal)
                     } header: {
                         gridSectionHeader("Revoked")
                     }
                 }
 
                 if !completed.isEmpty || hasMore {
                     Section {
                         LazyVGrid(columns: gridColumns, spacing: 12) {
                             ForEach(completed, id: \.listID) { game in
                                 gameCard(for: game, usesRoomierType: usesRoomierType)
                             }
                         }
                         .padding(.horizontal)
 
                         if hasMore {
                             loadMoreButton(nextLocalCutoff: nextLocalCutoff)
                                 .padding(.horizontal)
                         }
                     } header: {
                         gridSectionHeader("Completed")
                     }
                 }
             }
             .padding(.vertical, 8)
         }
         .background(Color(.systemGroupedBackground))
         .refreshable {
             await refreshList()
         }
     }
 
     private func refreshList() async {
         await onRefresh()
         let page = await onLoadRecentCompleted(completedCutoff)
         cloudHasMoreCompleted = page.hasMore
     }
 
     private func gridSectionHeader(_ title: String) -> some View {
         Text(title)
             .font(.footnote.weight(.semibold))
             .foregroundStyle(.secondary)
             .frame(maxWidth: .infinity, alignment: .leading)
             .padding(.horizontal, 16)
             .padding(.vertical, 8)
             .background(Color(.systemGroupedBackground))
             .accessibilityAddTraits(.isHeader)
     }
 
     private func loadMoreButton(nextLocalCutoff: Date?) -> some View {
         HStack {
             Spacer()
             Button {
                 Task {
                     isLoadingMoreCompleted = true
                     let page = await onLoadMoreCompleted()
                     let cutoffs = [nextLocalCutoff, page.oldestCompletedAt].compactMap { $0 }
                     if let oldest = cutoffs.min() {
                         withAnimation(.easeInOut(duration: 0.25)) {
                             completedCutoff = oldest
                         }
                     }
                     cloudHasMoreCompleted = page.hasMore
                     isLoadingMoreCompleted = false
                 }
             } label: {
                 if isLoadingMoreCompleted {
                     ProgressView()
                         .controlSize(.small)
                         .padding(.horizontal, 18)
                         .padding(.vertical, 8)
                 } else {
                     Text("Load More")
                     .font(.subheadline.weight(.semibold))
                     .foregroundColor(.secondary)
                     .padding(.horizontal, 18)
                     .padding(.vertical, 8)
                     .background(Color(.tertiarySystemFill), in: Capsule())
                 }
             }
             .disabled(isLoadingMoreCompleted)
             .buttonStyle(.plain)
             .textCase(nil)
             Spacer()
         }
         .padding(.top, 8)
     }
 
     private func gameCard(for game: GameSummary, usesRoomierType: Bool) -> some View {
         GameCardView(
             game: game,
             shareController: shareController,
             usesRoomierType: usesRoomierType,
             onResume: { navigationPath.append(game.id) },
             onLeave: { leaveTarget = game },
             onResign: { resignTarget = game },
             onDelete: { deleteTarget = game }
         )
     }
 
     /// The puzzle-shape preview for an invite, decoded from the silhouette
     /// segment the inviter sent. Open cells render grey (`.filled`) to read as
     /// "not yet playable", matching the link-tap placeholder in
     /// `JoiningPuzzleView`. An absent or undecodable grid gets no thumbnail.
     @ViewBuilder
     private func inviteThumbnail(for invite: InviteEntity) -> some View {
         if let segment = invite.gridSilhouette,
            let shape = GridSilhouette.decode(segment) {
             GridThumbnailView(
                 width: shape.width,
                 height: shape.height,
                 cells: shape.blocks.map { $0 ? .block : .filled }
             )
         }
     }
 
     @ViewBuilder
     private func inviteCard(for invite: InviteEntity) -> some View {
         let inviter = invite.resolvedInviterName ?? "A player"
         let title = (invite.gameTitle?.isEmpty == false) ? invite.gameTitle! : "a puzzle"
         HStack(spacing: 12) {
             inviteThumbnail(for: invite)
             VStack(alignment: .leading, spacing: 2) {
                 Text(title)
                     .font(.headline)
                     .lineLimit(1)
                     .truncationMode(.tail)
                 Text("Invited by \(inviter)")
                     .font(.footnote)
                     .foregroundStyle(.secondary)
                     .lineLimit(1)
             }
             Spacer(minLength: 0)
             if acceptingInviteID == invite.objectID {
                 ProgressView()
             } else {
                 Button("Accept") { Task { await accept(invite) } }
                     .buttonStyle(.borderedProminent)
                     .controlSize(.small)
             }
             inviteMenu(for: invite)
         }
         .padding(12)
         .frame(maxWidth: .infinity)
         .frame(height: CardMetrics.height)
         .background(
             Color(.secondarySystemGroupedBackground),
             in: RoundedRectangle(cornerRadius: CardMetrics.cornerRadius)
         )
         .modifier(InviteAccessibility(
             invite: invite,
             isAccepting: acceptingInviteID == invite.objectID,
             onAccept: { Task { await accept(invite) } },
             onDecline: { Task { await decline(invite) } },
             onBlock: { blockTarget = invite }
         ))
     }
 
     private func inviteMenu(for invite: InviteEntity) -> some View {
         Menu {
             Button { Task { await decline(invite) } } label: {
                 Label("Decline", systemImage: "xmark")
             }
             Button(role: .destructive) { blockTarget = invite } label: {
                 Label("Block", systemImage: "hand.raised")
             }
         } label: {
             Text("More")
                 .foregroundStyle(.primary)
         }
         .buttonStyle(.bordered)
         .controlSize(.small)
         .tint(.secondary)
         .compositingGroup()
     }
 
     @ViewBuilder
     private func inviteRow(for invite: InviteEntity) -> some View {
         let inviter = invite.resolvedInviterName ?? "A player"
         let title = (invite.gameTitle?.isEmpty == false) ? invite.gameTitle! : "a puzzle"
         HStack {
             inviteThumbnail(for: invite)
             VStack(alignment: .leading, spacing: 2) {
                 Text(title).font(.body.weight(.medium))
                 Text("Invited by \(inviter)")
                     .font(.caption)
                     .foregroundStyle(.secondary)
             }
             Spacer()
             if acceptingInviteID == invite.objectID {
                 ProgressView()
             } else {
                 Button("Accept") { Task { await accept(invite) } }
                     .buttonStyle(.borderedProminent)
                     .controlSize(.small)
             }
             inviteMenu(for: invite)
         }
         .swipeActions(edge: .trailing) {
             Button("Decline") { Task { await decline(invite) } }
                 .tint(.gray)
             Button("Block", role: .destructive) { blockTarget = invite }
         }
         .modifier(InviteAccessibility(
             invite: invite,
             isAccepting: acceptingInviteID == invite.objectID,
             onAccept: { Task { await accept(invite) } },
             onDecline: { Task { await decline(invite) } },
             onBlock: { blockTarget = invite }
         ))
     }
 
     private struct InviteAccessibility: ViewModifier {
         let invite: InviteEntity
         let isAccepting: Bool
         let onAccept: () -> Void
         let onDecline: () -> Void
         let onBlock: () -> Void
 
         func body(content: Content) -> some View {
             content
                 .accessibilityElement(children: .ignore)
                 .accessibilityLabel(accessibilityLabel)
                 .accessibilityHint(isAccepting ? "Invitation is being accepted" : "Accepts invitation")
                 .accessibilityAddTraits(.isButton)
                 .accessibilityAction {
                     guard !isAccepting else { return }
                     onAccept()
                 }
                 .accessibilityActions {
                     if !isAccepting {
                         Button("Accept", action: onAccept)
                         Button("Decline", action: onDecline)
                         Button("Block", role: .destructive, action: onBlock)
                     }
                 }
         }
 
         private var accessibilityLabel: String {
             let inviter = invite.resolvedInviterName ?? "A player"
             let title = (invite.gameTitle?.isEmpty == false) ? invite.gameTitle! : "a puzzle"
             if isAccepting {
                 return "\(title), invited by \(inviter), accepting"
             }
             return "\(title), invited by \(inviter)"
         }
     }
 
     private func accept(_ invite: InviteEntity) async {
         guard let url = invite.shareURL,
               let ping = invite.pingRecordName
         else { return }
         let shape = invite.gridSilhouette.flatMap(GridSilhouette.decode)
         acceptingInviteID = invite.objectID
         announcements.dismiss(id: Self.inviteErrorID)
         defer { acceptingInviteID = nil }
         do {
             if let onAcceptInvite {
                 try await onAcceptInvite(url, ping, shape)
             } else if let appActions {
                 try await appActions.acceptInvite(shareURL: url, pingRecordName: ping)
             }
         } catch {
             let copy = CloudFailureCopy.joinFailure(for: error)
             announcements.post(Announcement(
                 id: Self.inviteErrorID,
                 scope: .global,
                 severity: .error,
                 title: copy.title,
                 body: copy.body,
                 dismissal: .manual
             ))
         }
     }
 
     /// Single-slot id for the invite-accept failure banner — a fresh
     /// failure replaces the prior one rather than stacking.
     private static let inviteErrorID = "invite-accept-error"
     private static let inviteSyncID = "invite-sync-in-progress"
 
     /// Single-slot id for failures after starting a puzzle from the friends
     /// sheet — scoped to the new puzzle, where the user can retry from its
     /// Share menu.
     private static let newGameInviteErrorID = "new-game-friend-invite-error"
 
     /// Single-slot id for game-list destructive-action failures (decline,
     /// resign, delete, leave) — a fresh failure replaces the prior one.
     private static let destructiveActionErrorID = "game-list-destructive-action-error"
 
     private func decline(_ invite: InviteEntity) async {
         guard let appActions, let gameID = invite.gameID else { return }
         do {
             try await appActions.declineInvite(gameID: gameID)
         } catch {
             announcements.post(Announcement(
                 id: Self.destructiveActionErrorID,
                 scope: .global,
                 severity: .error,
                 title: "Declining Failed",
                 body: error.localizedDescription,
                 dismissal: .manual
             ))
         }
     }
 
     @ViewBuilder
     private func rowView(for game: GameSummary, usesRoomierType: Bool) -> some View {
         GameRowView(
             game: game,
             shareController: shareController,
             usesRoomierType: usesRoomierType,
             onResume: { navigationPath.append(game.id) },
             onLeave: { leaveTarget = game },
             onResign: { resignTarget = game },
             onDelete: { deleteTarget = game }
         )
         .background(
             NavigationLink(value: game.id) { EmptyView() }
                 .opacity(0)
         )
         .swipeActions(edge: .trailing, allowsFullSwipe: false) {
             if game.completedAt == nil && !game.isOwned && game.isShared {
                 Button("Leave", role: .destructive) {
                     leaveTarget = game
                 }
             } else {
                 Button("Delete", role: .destructive) {
                     deleteTarget = game
                 }
             }
         }
     }
 
     private func leaveShare(game: GameSummary) async {
         defer { leaveTarget = nil }
         do {
             try await shareController.leaveShare(gameID: game.id)
         } catch {
             announcements.post(Announcement(
                 id: Self.destructiveActionErrorID,
                 scope: .global,
                 severity: .error,
                 title: "Leaving Failed",
                 body: error.localizedDescription,
                 dismissal: .manual
             ))
         }
     }
 
     private var usesRoomierType: Bool {
         containerHeight >= 760 && dynamicTypeSize <= .medium
     }
 }