crossmate

PuzzleView.swift (40997B)

---

 import SwiftUI
 
 struct PuzzleView: View {
     @Bindable var session: PlayerSession
     var shareController: ShareController? = nil
     let roster: PlayerRoster
     var onComplete: (() -> Void)? = nil
     var onResign: (() throws -> Void)? = nil
     var onDelete: (() throws -> Void)? = nil
     @Environment(InputMonitor.self) private var inputMonitor
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(\.dismiss) private var dismiss
     @State private var isRenaming = false
     @State private var renameDraft = ""
     @State private var showErrorsAlert = false
     @State private var isConfirmingResign = false
     @State private var isConfirmingDelete = false
     @State private var isConfirmingLeave = false
     @State private var leaveError: String?
     @State private var destructiveActionError: String?
     @State private var isRevokedBannerDismissed = false
     @State private var isShowingShareSheet = false
     @State private var hasSolved = false
     @State private var padLayout: PadLayout?
 
     private enum PadLayout {
         case landscape
         case portrait
     }
 
     private func swatchImage(for color: PlayerColor) -> Image {
         let tint = UIColor(color.tint)
         let base = UIImage(systemName: "circle.fill") ?? UIImage()
         return Image(uiImage: base.withTintColor(tint, renderingMode: .alwaysOriginal))
     }
 
     private struct TitleParts {
         let title: String
         let subtitle: String?
     }
 
     private var titleParts: TitleParts {
         let title = session.puzzle.title
         let formattedDate = session.puzzle.date?.formatted(date: .long, time: .omitted)
         let subtitle: String?
         if let publisher = session.puzzle.publisher, let formattedDate {
             subtitle = "\(publisher) · \(formattedDate)"
         } else {
             subtitle = formattedDate
         }
         return TitleParts(title: title, subtitle: subtitle)
     }
 
     private var isSolved: Bool { hasSolved }
 
     var body: some View {
         Group {
             switch padLayout {
             case .landscape:
                 landscapePadLayout
             case .portrait:
                 portraitPadLayout
             case .none:
                 phoneLayout
             }
         }
         .overlay(alignment: .top) {
             if session.mutator.isAccessRevoked && !isRevokedBannerDismissed {
                 AccessRevokedBanner { isRevokedBannerDismissed = true }
                     .transition(.move(edge: .top).combined(with: .opacity))
             }
         }
         .background(Color(.systemBackground))
         .background {
             HardwareKeyboardInputView(onPress: handleHardwareKeyboardEvent)
                 .frame(width: 0, height: 0)
                 .allowsHitTesting(false)
         }
         .ignoresSafeArea(.keyboard)
         .modifier(PuzzleToolbarModifier(
             session: session,
             roster: roster,
             shareController: shareController,
             isSolved: isSolved,
             canResign: onResign != nil,
             canDelete: onDelete != nil,
             isRenaming: $isRenaming,
             renameDraft: $renameDraft,
             isConfirmingResign: $isConfirmingResign,
             isConfirmingDelete: $isConfirmingDelete,
             isConfirmingLeave: $isConfirmingLeave,
             isShowingShareSheet: $isShowingShareSheet
         ))
         .modifier(PuzzleLifecycleModifier(
             session: session,
             roster: roster,
             hasSolved: $hasSolved,
             onCompletionStateChanged: handleCompletionState
         ))
         .modifier(PuzzlePresentationModifier(
             session: session,
             shareController: shareController,
             isRenaming: $isRenaming,
             renameDraft: $renameDraft,
             showErrorsAlert: $showErrorsAlert,
             isConfirmingResign: $isConfirmingResign,
             isConfirmingDelete: $isConfirmingDelete,
             isConfirmingLeave: $isConfirmingLeave,
             leaveError: $leaveError,
             destructiveActionError: $destructiveActionError,
             isShowingShareSheet: $isShowingShareSheet,
             performResign: performResign,
             performDelete: performDelete,
             leaveSharedGame: leaveSharedGame
         ))
         .onGeometryChange(for: CGSize.self) { proxy in
             proxy.size
         } action: { newSize in
             updateLayoutTrait(for: newSize)
         }
     }
 
     private var phoneLayout: some View {
         VStack(spacing: 0) {
             puzzleArea
             controlsArea(showClueBar: true)
         }
     }
 
     private var landscapePadLayout: some View {
         VStack(spacing: 0) {
             HStack(spacing: 0) {
                 VStack(spacing: 0) {
                     if !isSolved {
                         PuzzleScoreboard(session: session, roster: roster)
 
                         Divider()
                     }
 
                     ClueList(session: session, presentation: .sidebar)
                 }
                     .frame(minWidth: 300, idealWidth: 360, maxWidth: 420)
                     .background(Color(.secondarySystemBackground))
 
                 Divider()
                     .ignoresSafeArea(edges: .top)
 
                 puzzleArea
                     .padding(.bottom, 12)
                     .frame(maxWidth: .infinity, maxHeight: .infinity)
             }
             .frame(maxWidth: .infinity, maxHeight: .infinity)
 
             controlsArea(showClueBar: false)
         }
     }
 
     private var portraitPadLayout: some View {
         VStack(spacing: 0) {
             WeightedVStack(weights: [3, 1]) {
                 puzzleArea
                     .frame(maxWidth: .infinity, maxHeight: .infinity)
                     .padding(.bottom, 12)
 
                 VStack(spacing: 0) {
                     Divider()
 
                     HStack(alignment: .top, spacing: 0) {
                         if !isSolved {
                             PuzzleScoreboard(session: session, roster: roster)
                                 .frame(minWidth: 240, idealWidth: 280, maxWidth: 320)
 
                             Divider()
                         }
 
                         ClueList(session: session, presentation: .sidebar)
                             .frame(maxWidth: .infinity, maxHeight: .infinity)
                     }
                     .background(Color(.secondarySystemBackground))
                 }
             }
             .frame(maxWidth: .infinity, maxHeight: .infinity)
 
             controlsArea(showClueBar: false)
         }
     }
 
     private func updateLayoutTrait(for size: CGSize) {
         guard UIDevice.current.userInterfaceIdiom == .pad, size != .zero else {
             padLayout = nil
             return
         }
         padLayout = size.width > size.height ? .landscape : .portrait
     }
 
     private func performResign() {
         do {
             try onResign?()
             dismiss()
         } catch {
             destructiveActionError = String(describing: error)
         }
     }
 
     private func performDelete() {
         do {
             try onDelete?()
             dismiss()
         } catch {
             destructiveActionError = String(describing: error)
         }
     }
 
     private func handleCompletionState(_ newValue: Game.CompletionState) {
             switch newValue {
             case .incomplete:
                 break
             case .filledWithErrors:
                 showErrorsAlert = true
             case .solved:
                 guard !hasSolved else { return }
                 hasSolved = true
                 if session.isPencilMode {
                     session.togglePencil()
                 }
                 Task { @MainActor in
                     onComplete?()
                 }
             }
         }
 
     private var puzzleArea: some View {
         ZStack {
             VStack(spacing: 4) {
                 PuzzleTitle(title: titleParts.title, subtitle: titleParts.subtitle)
                 GridView(
                     session: session,
                     roster: roster,
                     showsSharedAnnotations: session.mutator.isShared
                 )
             }
             .frame(maxWidth: .infinity, maxHeight: .infinity)
             .padding(.top, -8)
 
             if session.isRebusActive {
                 Color.black.opacity(0.35)
                     .ignoresSafeArea(edges: .top)
                     .contentShape(Rectangle())
                     .onTapGesture {
                         session.commitRebus()
                     }
                 RebusModal(text: session.rebusBuffer)
                     .padding(.horizontal)
                     .contentShape(Rectangle())
                     .onTapGesture { /* swallow */ }
             }
         }
     }
 
     private func controlsArea(showClueBar: Bool) -> some View {
         VStack(spacing: 0) {
             if showClueBar {
                 ClueBarSlot(session: session)
             }
             controlsPanel
                 .frame(height: controlsPanelHeight)
         }
     }
 
     private var controlsPanel: some View {
         ZStack(alignment: .top) {
             if isSolved {
                 ControlsView(height: controlsPanelHeight) {
                     SuccessPanel(session: session, roster: roster)
                 }
                 .transition(.move(edge: .bottom))
             } else if showsCustomKeyboard {
                 ControlsView(height: controlsPanelHeight) {
                     KeyboardView(session: session, showsNavigationKeys: padLayout != nil)
                 }
                 .transition(.move(edge: .bottom))
             }
         }
         .frame(height: controlsPanelHeight, alignment: .top)
         .background {
             Color(.systemGroupedBackground)
                 .ignoresSafeArea(edges: .bottom)
         }
         .overlay(alignment: .top) {
             if controlsPanelHeight > 0 {
                 Rectangle()
                     .fill(Color(.opaqueSeparator))
                     .frame(height: 0.5)
             }
         }
         .animation(.easeOut(duration: 0.25), value: isSolved)
         .ignoresSafeArea(edges: .bottom)
     }
 
     private var controlsPanelHeight: CGFloat {
         isSolved || showsCustomKeyboard ? KeyboardView.standardHeight : 0
     }
 
     private var showsCustomKeyboard: Bool {
         !inputMonitor.isConnected
     }
 
     private func handleHardwareKeyboardEvent(_ event: HardwareKeyboardEvent) -> Bool {
         guard !isSolved else { return false }
 
         switch event.keyCode {
         case .keyboardA, .keyboardB, .keyboardC, .keyboardD, .keyboardE,
              .keyboardF, .keyboardG, .keyboardH, .keyboardI, .keyboardJ,
              .keyboardK, .keyboardL, .keyboardM, .keyboardN, .keyboardO,
              .keyboardP, .keyboardQ, .keyboardR, .keyboardS, .keyboardT,
              .keyboardU, .keyboardV, .keyboardW, .keyboardX, .keyboardY,
              .keyboardZ:
             guard !event.modifierFlags.contains(.command),
                   !event.modifierFlags.contains(.control),
                   !event.modifierFlags.contains(.alternate),
                   let letter = hardwareKeyboardLetter(from: event) else {
                 return false
             }
             if session.isRebusActive {
                 session.appendRebusLetter(letter)
             } else {
                 session.enter(letter)
             }
             return true
 
         case .keyboardDeleteOrBackspace, .keyboardDeleteForward:
             if session.isRebusActive {
                 session.deleteRebusLetter()
             } else {
                 session.deleteBackward()
             }
             return true
 
         case .keyboardLeftArrow:
             guard !session.isRebusActive else { return false }
             if event.modifierFlags.contains(.command) {
                 session.goToPreviousWord()
                 return true
             }
             moveWithHardwareArrow(direction: .across) {
                 session.goToPreviousLetter()
             }
             return true
 
         case .keyboardRightArrow:
             guard !session.isRebusActive else { return false }
             if event.modifierFlags.contains(.command) {
                 session.goToNextWord()
                 return true
             }
             moveWithHardwareArrow(direction: .across) {
                 session.goToNextLetter()
             }
             return true
 
         case .keyboardUpArrow:
             guard !session.isRebusActive else { return false }
             moveWithHardwareArrow(direction: .down) {
                 session.goToPreviousLetter()
             }
             return true
 
         case .keyboardDownArrow:
             guard !session.isRebusActive else { return false }
             moveWithHardwareArrow(direction: .down) {
                 session.goToNextLetter()
             }
             return true
 
         case .keyboardTab:
             guard !session.isRebusActive else { return false }
             if event.modifierFlags.contains(.shift) {
                 session.goToPreviousClue()
             } else {
                 session.goToNextClue()
             }
             return true
 
         case .keyboardSpacebar:
             guard !session.isRebusActive else { return false }
             session.toggleDirection()
             return true
 
         case .keyboardReturnOrEnter:
             if session.isRebusActive {
                 session.commitRebus()
             } else {
                 session.toggleDirection()
             }
             return true
 
         case .keyboardEscape:
             if session.isRebusActive {
                 session.commitRebus()
                 return true
             }
             return false
 
         default:
             return false
         }
     }
 
     private func hardwareKeyboardLetter(from event: HardwareKeyboardEvent) -> String? {
         let scalars = event.charactersIgnoringModifiers.unicodeScalars
         guard scalars.count == 1, let scalar = scalars.first else { return nil }
 
         switch scalar.value {
         case 65...90, 97...122:
             return String(Character(scalar)).uppercased()
         default:
             return nil
         }
     }
 
     private func moveWithHardwareArrow(direction: Puzzle.Direction, move: () -> Void) {
         if session.direction != direction {
             let previousDirection = session.direction
             session.setDirection(direction)
             if session.direction != previousDirection {
                 return
             }
         }
 
         move()
     }
 
     private func leaveSharedGame() async {
         guard let shareController else { return }
         do {
             try await shareController.leaveShare(gameID: session.mutator.gameID)
             dismiss()
         } catch {
             leaveError = String(describing: error)
         }
     }
 }
 
 private struct PuzzleScoreboard: View {
     @Bindable var session: PlayerSession
     let roster: PlayerRoster
     @Environment(PlayerPreferences.self) private var preferences
 
     private struct Score: Identifiable {
         let authorID: String?
         let name: String
         let color: PlayerColor?
         let filledCount: Int
 
         var id: String { authorID ?? "unattributed" }
     }
 
     private var fillableCellCount: Int {
         session.puzzle.cells.reduce(0) { count, row in
             count + row.filter { !$0.isBlock }.count
         }
     }
 
     private var filledCellCount: Int {
         var count = 0
         for r in 0..<session.puzzle.height {
             for c in 0..<session.puzzle.width {
                 guard !session.puzzle.cells[r][c].isBlock else { continue }
                 if !session.game.squares[r][c].entry.isEmpty {
                     count += 1
                 }
             }
         }
         return count
     }
 
     private var revealedSquareCount: Int {
         var count = 0
         for r in 0..<session.puzzle.height {
             for c in 0..<session.puzzle.width {
                 guard !session.puzzle.cells[r][c].isBlock else { continue }
                 if session.game.squares[r][c].mark.isRevealed {
                     count += 1
                 }
             }
         }
         return count
     }
 
     private var remainingCount: Int {
         max(0, fillableCellCount - filledCellCount)
     }
 
     private var remainingPhrase: String {
         switch remainingCount {
         case 0:
             return "no squares to go"
         case 1:
             return "1 square to go"
         default:
             return "\(remainingCount) squares to go"
         }
     }
 
     private var revealedPhrase: String {
         switch revealedSquareCount {
         case 0:
             return "No squares revealed"
         case 1:
             return "1 square revealed"
         default:
             return "\(revealedSquareCount) squares revealed"
         }
     }
 
     private var progressText: String {
         if revealedSquareCount > 0 {
             return "\(revealedPhrase), \(remainingPhrase)"
         }
         switch remainingCount {
         case 0:
             return "No squares to go"
         case 1:
             return "1 square to go"
         default:
             return "\(remainingCount) squares to go"
         }
     }
 
     private var scores: [Score] {
         var counts: [String?: Int] = [:]
         for r in 0..<session.puzzle.height {
             for c in 0..<session.puzzle.width {
                 guard !session.puzzle.cells[r][c].isBlock else { continue }
                 let square = session.game.squares[r][c]
                 guard !square.entry.isEmpty, !square.mark.isRevealed else { continue }
                 counts[normalizedAuthorID(square.letterAuthorID), default: 0] += 1
             }
         }
 
         let entries = roster.entries
         let usesLocalFallback = entries.isEmpty
         let entryByAuthorID = Dictionary(uniqueKeysWithValues: entries.map { ($0.authorID, $0) })
         let rosterAuthorIDs = Set(entries.map(\.authorID))
 
         let rosterScores: [Score]
         if usesLocalFallback {
             rosterScores = [
                 Score(
                     authorID: nil,
                     name: preferences.name,
                     color: preferences.color,
                     filledCount: counts[nil] ?? 0
                 )
             ]
         } else {
             rosterScores = entries.map { entry in
                 Score(
                     authorID: entry.authorID,
                     name: entry.name,
                     color: entry.color,
                     filledCount: counts[entry.authorID] ?? 0
                 )
             }
         }
 
         let extraScores = counts.compactMap { authorID, count -> Score? in
             if let authorID, rosterAuthorIDs.contains(authorID) {
                 return nil
             }
             if authorID == nil && usesLocalFallback {
                 return nil
             }
             if let authorID, let entry = entryByAuthorID[authorID] {
                 return Score(authorID: authorID, name: entry.name, color: entry.color, filledCount: count)
             }
             if authorID == nil {
                 return Score(authorID: nil, name: "Unattributed", color: nil, filledCount: count)
             }
             return Score(authorID: authorID, name: "Player", color: nil, filledCount: count)
         }
 
         return (rosterScores + extraScores)
             .sorted {
                 if $0.filledCount != $1.filledCount { return $0.filledCount > $1.filledCount }
                 return $0.name < $1.name
             }
     }
 
     private func normalizedAuthorID(_ authorID: String?) -> String? {
         guard let authorID else {
             return roster.entries.contains(where: { !$0.isLocal }) ? nil : roster.localAuthorID
         }
         return authorID
     }
 
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
             Text("Players")
                 .font(.headline)
 
             VStack(alignment: .leading, spacing: 6) {
                 ForEach(scores) { score in
                     scoreRow(score)
                 }
 
                 Text(progressText)
                     .font(.footnote)
                     .foregroundStyle(.secondary)
                     .padding(.top, 10)
                     .frame(maxWidth: .infinity, alignment: .center)
             }
         }
         .padding(.horizontal, 18)
         .padding(.vertical, 14)
         .frame(maxWidth: .infinity, alignment: .leading)
     }
 
     private func scoreRow(_ score: Score) -> some View {
         HStack(spacing: 8) {
             Circle()
                 .fill(score.color?.tint ?? Color.secondary)
                 .frame(width: 8, height: 8)
             Text(score.name)
                 .font(.subheadline)
                 .lineLimit(1)
             Spacer(minLength: 8)
             Text("\(score.filledCount)")
                 .font(.subheadline.monospacedDigit().weight(.semibold))
         }
         .accessibilityElement(children: .combine)
     }
 }
 
 private struct PuzzleToolbarModifier: ViewModifier {
     let session: PlayerSession
     let roster: PlayerRoster
     let shareController: ShareController?
     let isSolved: Bool
     let canResign: Bool
     let canDelete: Bool
     @Binding var isRenaming: Bool
     @Binding var renameDraft: String
     @Binding var isConfirmingResign: Bool
     @Binding var isConfirmingDelete: Bool
     @Binding var isConfirmingLeave: Bool
     @Binding var isShowingShareSheet: Bool
     @Environment(PlayerPreferences.self) private var preferences
     @AppStorage("debugMode") private var debugMode = false
 
     func body(content: Content) -> some View {
         content.toolbar {
             ToolbarItemGroup(placement: .topBarTrailing) {
                 pencilButton
                 entryMenu
                 hintsMenu
                 playersMenu
             }
         }
     }
 
     private func swatchImage(for color: PlayerColor) -> Image {
         let tint = UIColor(color.tint)
         let base = UIImage(systemName: "circle.fill") ?? UIImage()
         return Image(uiImage: base.withTintColor(tint, renderingMode: .alwaysOriginal))
     }
 
     private var pencilButton: some View {
         Button {
             session.togglePencil()
         } label: {
             Image(systemName: "pencil")
                 .foregroundStyle(pencilButtonForeground)
                 .padding(6)
                 .glassEffect(
                     !isSolved && session.isPencilMode
                         ? .regular.tint(preferences.color.tint)
                         : .identity,
                     in: Circle()
                 )
         }
         .accessibilityLabel("Pencil")
         .disabled(isSolved)
     }
 
     private var pencilButtonForeground: Color {
         if isSolved {
             return .secondary
         }
         return session.isPencilMode ? .white : .primary
     }
 
     private var entryMenu: some View {
         Menu {
             Section {
                 Button("Enter Rebus") { session.startRebus() }
                 Button("Toggle Direction") { session.toggleDirection() }
             }
 
             if debugMode {
                 Section {
                     NavigationLink {
                         DiagnosticsView()
                     } label: {
                         Text("iCloud Diagnostics")
                     }
                 }
             }
 
             Section {
                 Button("Clear Word") { session.clearCurrentWord() }
                 Button("Clear Puzzle", role: .destructive) { session.clearPuzzle() }
             }
         } label: {
             Label("Entry", systemImage: "squareshape.split.2x2")
         }
         .disabled(isSolved)
     }
 
     private var hintsMenu: some View {
         Menu {
             Section {
                 Button("Check Square") { session.checkSquare() }
                 Button("Check Word") { session.checkCurrentWord() }
                 Button("Check Puzzle") { session.checkPuzzle() }
             }
             Section {
                 Button("Reveal Square") { session.revealSquare() }
                 Button("Reveal Word") { session.revealCurrentWord() }
                 Button("Reveal Puzzle") { session.revealPuzzle() }
             }
         } label: {
             Label("Hints", systemImage: "lightbulb")
         }
         .disabled(isSolved)
     }
 
     private var playersMenu: some View {
         Menu {
             playerRosterSection
             playerPreferencesSection
             shareSection
             puzzleDestructiveSection
         } label: {
             Label("Players", systemImage: "person.2")
         }
         .disabled(isSolved)
     }
 
     @ViewBuilder
     private var playerRosterSection: some View {
         Section {
             if !roster.entries.isEmpty {
                 ForEach(roster.entries) { entry in
                     Button {} label: {
                         Label {
                             Text(entry.isLocal ? "\(entry.name) (you)" : entry.name)
                         } icon: {
                             swatchImage(for: entry.color)
                         }
                     }
                     .disabled(true)
                 }
             } else {
                 Button {} label: {
                     Label {
                         Text(preferences.name)
                     } icon: {
                         swatchImage(for: preferences.color)
                     }
                 }
                 .disabled(true)
             }
         }
     }
 
     private var playerPreferencesSection: some View {
         Section {
             Menu("Change Colour") {
                 ForEach(PlayerColor.palette) { color in
                     Button {
                         preferences.color = color
                         Task { await roster.reassignOnLocalColorChange(newColor: color) }
                     } label: {
                         Label {
                             Text(color.id == preferences.colorID ? "\(color.name)  ✓" : color.name)
                         } icon: {
                             swatchImage(for: color)
                         }
                     }
                 }
             }
 
             Button("Change Name") {
                 renameDraft = preferences.name
                 isRenaming = true
             }
         }
     }
 
     @ViewBuilder
     private var shareSection: some View {
         if shareController != nil {
             Section {
                 Button {
                     isShowingShareSheet = true
                 } label: {
                     Text("Share Game")
                 }
                 .disabled(!session.mutator.isOwned)
             }
         }
     }
 
     private var puzzleDestructiveSection: some View {
         Section {
             Button("Resign Game", role: .destructive) {
                 isConfirmingResign = true
             }
             .disabled(isSolved || !canResign)
 
             if session.mutator.isShared && !session.mutator.isOwned {
                 Button("Leave Game", role: .destructive) {
                     isConfirmingLeave = true
                 }
                 .disabled(shareController == nil)
             } else {
                 Button("Delete Game", role: .destructive) {
                     isConfirmingDelete = true
                 }
                 .disabled(!canDelete)
             }
         }
     }
 }
 
 private struct PuzzleLifecycleModifier: ViewModifier {
     let session: PlayerSession
     let roster: PlayerRoster
     @Binding var hasSolved: Bool
     let onCompletionStateChanged: (Game.CompletionState) -> Void
 
     func body(content: Content) -> some View {
         content
             .task {
                 await roster.refresh()
             }
             .onAppear {
                 if session.game.completionState == .solved {
                     onCompletionStateChanged(.solved)
                 }
             }
             .onChange(of: session.game.completionState) { _, newValue in
                 onCompletionStateChanged(newValue)
             }
             .onAppear {
                 session.onCompletionStateChanged = { newValue in
                     onCompletionStateChanged(newValue)
                 }
             }
             .onDisappear {
                 session.onCompletionStateChanged = nil
             }
     }
 }
 
 private struct PuzzlePresentationModifier: ViewModifier {
     let session: PlayerSession
     let shareController: ShareController?
     @Binding var isRenaming: Bool
     @Binding var renameDraft: String
     @Binding var showErrorsAlert: Bool
     @Binding var isConfirmingResign: Bool
     @Binding var isConfirmingDelete: Bool
     @Binding var isConfirmingLeave: Bool
     @Binding var leaveError: String?
     @Binding var destructiveActionError: String?
     @Binding var isShowingShareSheet: Bool
     let performResign: () -> Void
     let performDelete: () -> Void
     let leaveSharedGame: () async -> Void
     @Environment(PlayerPreferences.self) private var preferences
 
     func body(content: Content) -> some View {
         content
             .alert("Not Quite Right", isPresented: $showErrorsAlert) {
                 Button("OK", role: .cancel) {}
             } message: {
                 Text("One or more squares are incorrect.")
             }
             .alert("Resign Puzzle?", isPresented: $isConfirmingResign) {
                 Button("Resign", role: .destructive) {
                     performResign()
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 Text("This will reveal the puzzle and mark it complete.")
             }
             .alert("Delete Puzzle?", isPresented: $isConfirmingDelete) {
                 Button("Delete", role: .destructive) {
                     performDelete()
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 deleteConfirmationMessage
             }
             .alert("Leave Puzzle?", isPresented: $isConfirmingLeave) {
                 Button("Leave", role: .destructive) {
                     Task { await leaveSharedGame() }
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 Text("You will lose access to \"\(session.puzzle.title)\".")
             }
             .alert(
                 "Couldn't Leave",
                 isPresented: .init(
                     get: { leaveError != nil },
                     set: { if !$0 { leaveError = nil } }
                 ),
                 presenting: leaveError
             ) { _ in
                 Button("OK", role: .cancel) {}
             } message: { message in
                 Text(message)
             }
             .alert(
                 "Couldn't Update Puzzle",
                 isPresented: .init(
                     get: { destructiveActionError != nil },
                     set: { if !$0 { destructiveActionError = nil } }
                 ),
                 presenting: destructiveActionError
             ) { _ in
                 Button("OK", role: .cancel) {}
             } message: { message in
                 Text(message)
             }
             .alert("Change Name", isPresented: $isRenaming) {
                 TextField("Name", text: $renameDraft)
                     .textInputAutocapitalization(.never)
                     .autocorrectionDisabled()
                 Button("Cancel", role: .cancel) {}
                 Button("Save") {
                     let trimmed = renameDraft.trimmingCharacters(in: .whitespacesAndNewlines)
                     if !trimmed.isEmpty {
                         preferences.name = trimmed
                     }
                 }
                 .keyboardShortcut(.defaultAction)
             } message: {
                 Text("Enter the name other players will see.")
             }
             .sheet(isPresented: $isShowingShareSheet) {
                 if let shareController {
                     GameShareSheet(
                         gameID: session.mutator.gameID,
                         title: session.puzzle.title,
                         shareController: shareController
                     )
                 }
             }
     }
 
     private var deleteConfirmationMessage: Text {
         if session.mutator.isOwned && session.mutator.isShared {
             Text("This will permanently delete \"\(session.puzzle.title)\" from iCloud for everyone.")
         } else {
             Text("This will permanently delete \"\(session.puzzle.title)\" and all progress.")
         }
     }
 }
 
 private struct PuzzleTitle: View {
     let title: String
     let subtitle: String?
 
     var body: some View {
         VStack(spacing: 2) {
             Text(title)
                 .font(.headline)
                 .lineLimit(2)
             if let subtitle {
                 Text(subtitle)
                     .font(.subheadline)
                     .foregroundStyle(.secondary)
                     .lineLimit(1)
             }
         }
         .multilineTextAlignment(.center)
         .frame(maxWidth: .infinity)
         .padding(.horizontal)
         .padding(.bottom, 12)
     }
 }
 
 private struct ClueKey: Hashable {
     let direction: Puzzle.Direction
     let number: Int
 }
 
 private struct ClueBarSlot: View {
     @Bindable var session: PlayerSession
 
     var body: some View {
         ZStack(alignment: .bottom) {
             ClueBarReservation()
 
             ClueBar(session: session)
         }
     }
 }
 
 private struct ClueBarReservation: View {
     var body: some View {
         ClueBarContent(
             label: "99 Across",
             clueText: "Clue reservation",
             reservesClueSpace: true
         )
             .opacity(0)
             .accessibilityHidden(true)
             .allowsHitTesting(false)
     }
 }
 
 private struct ClueBarContent: View {
     let label: String
     let clueText: String
     var reservesClueSpace = false
     var currentKey: ClueKey?
     var slideEdge: Edge = .trailing
     var onPrevious: (() -> Void)?
     var onNext: (() -> Void)?
     var onClueTap: (() -> Void)?
     var onLabelTap: (() -> Void)?
 
     var body: some View {
         HStack(alignment: .clueCenter, spacing: 8) {
             ClueBarIcon(systemName: "chevron.left", action: onPrevious)
 
             VStack(alignment: .leading, spacing: 4) {
                 Text(label)
                     .font(.caption)
                     .textCase(.uppercase)
                     .foregroundStyle(.secondary)
                     .contentShape(Rectangle())
                     .highPriorityGesture(
                         TapGesture()
                             .onEnded {
                                 onLabelTap?()
                             }
                     )
                 ZStack(alignment: .leading) {
                     clueTextView
                 }
                 .alignmentGuide(.clueCenter) { d in d[VerticalAlignment.center] }
                 .frame(maxWidth: .infinity, alignment: .leading)
                 .clipped()
             }
             .contentShape(Rectangle())
             .onTapGesture {
                 onClueTap?()
             }
 
             ClueBarIcon(systemName: "chevron.right", action: onNext)
         }
         .padding(.horizontal, 8)
         .padding(.top, 12)
         .padding(.bottom, 6)
     }
 
     @ViewBuilder
     private var clueTextView: some View {
         baseClueText
             .id(currentKey)
             .transition(.asymmetric(
                 insertion: .move(edge: slideEdge),
                 removal: .move(edge: slideEdge == .trailing ? .leading : .trailing)
             ))
     }
 
     private var baseClueText: some View {
         Text(clueText)
             .font(.headline)
             .lineLimit(2, reservesSpace: reservesClueSpace)
             .multilineTextAlignment(.leading)
             .frame(maxWidth: .infinity, alignment: .leading)
     }
 }
 
 private struct ClueBarIcon: View {
     let systemName: String
     var action: (() -> Void)?
 
     var body: some View {
         if let action {
             Button(action: action) {
                 icon
             }
             .buttonStyle(.plain)
         } else {
             icon
         }
     }
 
     private var icon: some View {
         Image(systemName: systemName)
             .font(.title3.weight(.semibold))
             .frame(width: 44, height: 44)
             .contentShape(Rectangle())
     }
 }
 
 private struct ClueBar: View {
     @Bindable var session: PlayerSession
     @Environment(PlayerPreferences.self) private var preferences
     @State private var slideEdge: Edge = .trailing
     @State private var isShowingClueList = false
 
     private var playerColor: PlayerColor { preferences.color }
 
     var body: some View {
         let clue = session.currentClue()
         let currentKey = clue.map { ClueKey(direction: session.direction, number: $0.number) }
 
         ClueBarContent(
             label: label(for: clue),
             clueText: clue?.text ?? "—",
             currentKey: currentKey,
             slideEdge: slideEdge,
             onPrevious: {
                 slideEdge = .leading
                 session.goToPreviousClue()
             },
             onNext: {
                 slideEdge = .trailing
                 session.goToNextClue()
             },
             onClueTap: {
                 isShowingClueList = true
             },
             onLabelTap: {
                 session.toggleDirection()
             }
         )
         .background(playerColor.highlightFill)
         .animation(.smooth(duration: 0.22), value: currentKey)
         .sheet(isPresented: $isShowingClueList) {
             ClueList(session: session)
                 .presentationDetents([.medium, .large])
                 .presentationDragIndicator(.visible)
         }
     }
 
     private func label(for clue: Puzzle.Clue?) -> String {
         let direction = session.direction == .across ? "Across" : "Down"
         if let clue {
             return "\(clue.number) \(direction)"
         }
         return direction
     }
 }
 
 private struct RebusModal: View {
     let text: String
 
     var body: some View {
         Text(text.isEmpty ? " " : text)
             .font(.system(size: 32, weight: .semibold, design: .rounded))
             .foregroundStyle(.primary)
             .frame(maxWidth: .infinity, minHeight: 56)
             .padding(.horizontal, 16)
             .background(Color(.systemBackground))
             .clipShape(RoundedRectangle(cornerRadius: 10, style: .continuous))
             .padding(20)
             .frame(maxWidth: .infinity)
             .background(Color(.secondarySystemBackground))
             .clipShape(RoundedRectangle(cornerRadius: 14, style: .continuous))
     }
 }
 
 private struct ControlsView<Content: View>: View {
     let height: CGFloat
     @ViewBuilder var content: () -> Content
 
     var body: some View {
         VStack(spacing: 0) {
             content()
                 .frame(height: height)
             Color(.systemGroupedBackground)
         }
         .background(Color(.systemGroupedBackground))
         .ignoresSafeArea(edges: .bottom)
     }
 }
 
 private extension VerticalAlignment {
     enum ClueCenterID: AlignmentID {
         static func defaultValue(in d: ViewDimensions) -> CGFloat { d[VerticalAlignment.center] }
     }
     static let clueCenter = VerticalAlignment(ClueCenterID.self)
 }
 
 private struct AccessRevokedBanner: View {
     let onDismiss: () -> Void
 
     var body: some View {
         HStack(spacing: 8) {
             Image(systemName: "person.slash")
             Text("This puzzle is no longer shared with you.")
                 .font(.footnote)
                 .frame(maxWidth: .infinity, alignment: .leading)
             Button {
                 onDismiss()
             } label: {
                 Image(systemName: "xmark")
                     .font(.footnote.weight(.semibold))
             }
             .buttonStyle(.plain)
         }
         .padding(.horizontal, 16)
         .padding(.vertical, 10)
         .background(Color(.secondarySystemBackground))
         .clipShape(RoundedRectangle(cornerRadius: 10, style: .continuous))
         .padding(.horizontal, 16)
         .padding(.top, 8)
     }
 }
 
 private struct WeightedVStack: Layout {
     let weights: [CGFloat]
 
     func sizeThatFits(
         proposal: ProposedViewSize,
         subviews: Subviews,
         cache: inout ()
     ) -> CGSize {
         CGSize(
             width: proposal.width ?? 0,
             height: proposal.height ?? 0
         )
     }
 
     func placeSubviews(
         in bounds: CGRect,
         proposal: ProposedViewSize,
         subviews: Subviews,
         cache: inout ()
     ) {
         let totalWeight = weights.reduce(0, +)
         guard totalWeight > 0 else { return }
 
         var y = bounds.minY
         for (index, subview) in subviews.enumerated() {
             let weight = index < weights.count ? weights[index] : 0
             let height = bounds.height * weight / totalWeight
             subview.place(
                 at: CGPoint(x: bounds.minX, y: y),
                 anchor: .topLeading,
                 proposal: ProposedViewSize(width: bounds.width, height: height)
             )
             y += height
         }
     }
 }